Ruby - Краткое руководство

Ruby - чистый объектно-ориентированный язык программирования. Он был создан в 1993 году Юкихиро Мацумото из Японии.

Вы можете найти имя Юкихиро Мацумото в списке рассылки Ruby на www.ruby-lang.org . Мацумото также известен как Мац в сообществе рубинов.

Ruby is "A Programmer's Best Friend".

Ruby имеет функции, аналогичные функциям Smalltalk, Perl и Python. Perl, Python и Smalltalk - это языки сценариев. Smalltalk - настоящий объектно-ориентированный язык. Ruby, как и Smalltalk, является идеальным объектно-ориентированным языком. Использовать синтаксис Ruby намного проще, чем синтаксис Smalltalk.

Особенности Ruby

  • Ruby имеет открытый исходный код и свободно доступен в Интернете, но требует лицензии.

  • Ruby - это интерпретируемый язык программирования общего назначения.

  • Ruby - настоящий объектно-ориентированный язык программирования.

  • Ruby - это язык сценариев на стороне сервера, похожий на Python и PERL.

  • Ruby можно использовать для написания сценариев Common Gateway Interface (CGI).

  • Ruby можно встроить в язык гипертекстовой разметки (HTML).

  • Ruby имеет чистый и простой синтаксис, который позволяет новому разработчику быстро и легко учиться.

  • Ruby имеет синтаксис, аналогичный синтаксису многих языков программирования, таких как C ++ и Perl.

  • Ruby очень масштабируем, и большие программы, написанные на Ruby, легко обслуживаются.

  • Ruby можно использовать для разработки приложений для Интернета и интрасети.

  • Ruby можно установить в средах Windows и POSIX.

  • Ruby поддерживает множество инструментов с графическим интерфейсом, таких как Tcl / Tk, GTK и OpenGL.

  • Ruby можно легко подключить к DB2, MySQL, Oracle и Sybase.

  • Ruby имеет богатый набор встроенных функций, которые можно использовать непосредственно в сценариях Ruby.

Инструменты, которые вам понадобятся

Для выполнения примеров, обсуждаемых в этом руководстве, вам понадобится компьютер последней версии, например Intel Core i3 или i5, с минимум 2 ГБ ОЗУ (рекомендуется 4 ГБ ОЗУ). Вам также понадобится следующее программное обеспечение -

  • Операционная система Linux или Windows 95/98/2000 / NT или Windows 7.

  • Веб-сервер Apache 1.3.19-5.

  • Internet Explorer 5.0 или выше. Веб-браузер.

  • Рубин 1.8.5

Это руководство предоставит необходимые навыки для создания графических интерфейсов, сетевых и веб-приложений с использованием Ruby. Также будет рассказано о расширении и встраивании приложений Ruby.

Что следующее?

В следующей главе вы узнаете, где можно получить Ruby и документацию к нему. Наконец, в нем рассказывается, как установить Ruby и подготовить среду для разработки приложений Ruby.

Настройка локальной среды

Если вы все еще хотите настроить свою среду для языка программирования Ruby, то приступим. Это руководство научит вас всем важным темам, связанным с настройкой среды. Мы рекомендуем вам сначала изучить следующие темы, а затем продолжить -

  • Установка Ruby в Linux / Unix. Если вы планируете использовать среду разработки на Linux / Unix Machine, прочтите эту главу.

  • Установка Ruby в Windows. Если вы планируете использовать среду разработки на Windows Machine, прочтите эту главу.

  • Параметры командной строки Ruby - в этой главе перечислены все параметры командной строки, которые вы можете использовать вместе с интерпретатором Ruby.

  • Переменные среды Ruby - в этой главе содержится список всех важных переменных среды, которые необходимо установить, чтобы Ruby Interpreter работал.

Популярные редакторы Ruby

Чтобы писать свои программы Ruby, вам понадобится редактор -

  • Если вы работаете на компьютере с Windows, вы можете использовать любой простой текстовый редактор, например Блокнот или Edit plus.

  • VIM (Vi IMproved) - очень простой текстовый редактор. Это доступно почти на всех машинах Unix, а теперь и на Windows. В противном случае вы можете использовать свой любимый редактор vi для написания программ Ruby.

  • RubyWin - это интегрированная среда разработки (IDE) Ruby для Windows.

  • Ruby Development Environment (RDE) также является очень хорошей IDE для пользователей Windows.

Интерактивный Ruby (IRb)

Интерактивный Ruby (IRb) предоставляет оболочку для экспериментов. В оболочке IRb вы можете сразу просмотреть результаты выражения построчно.

Этот инструмент поставляется вместе с установкой Ruby, поэтому вам не нужно ничего делать, чтобы IRb работал.

Просто введите irb в командной строке, и интерактивный сеанс Ruby начнется, как показано ниже -

$irb
irb 0.6.1(99/09/16)
irb(main):001:0> def hello
irb(main):002:1> out = "Hello World"
irb(main):003:1> puts out
irb(main):004:1> end
nil
irb(main):005:0> hello
Hello World
nil
irb(main):006:0>

Не беспокойтесь о том, что мы здесь сделали. Вы изучите все эти шаги в следующих главах.

Что следующее?

Мы предполагаем, что теперь у вас есть рабочая среда Ruby и вы готовы написать первую программу Ruby. В следующей главе вы узнаете, как писать программы на Ruby.

Напишем простую программу на ruby. Все файлы ruby ​​будут иметь расширение.rb. Итак, поместите следующий исходный код в файл test.rb.

#!/usr/bin/ruby -w

puts "Hello, Ruby!";

Здесь мы предположили, что у вас есть интерпретатор Ruby, доступный в каталоге / usr / bin. Теперь попробуйте запустить эту программу следующим образом -

$ ruby test.rb

Это даст следующий результат -

Hello, Ruby!

Вы видели простую программу Ruby, теперь давайте рассмотрим несколько основных концепций, связанных с синтаксисом Ruby.

Пробелы в программе Ruby

Пробелы, такие как пробелы и табуляции, обычно игнорируются в коде Ruby, за исключением случаев, когда они появляются в строках. Однако иногда они используются для толкования неоднозначных утверждений. Интерпретации такого рода вызывают предупреждения, если включена опция -w.

пример

a + b is interpreted as a+b ( Here a is a local variable)
a  +b is interpreted as a(+b) ( Here a is a method call)

Окончание строк в программе Ruby

Ruby интерпретирует точки с запятой и символы новой строки как окончание оператора. Однако, если Ruby встречает такие операторы, как +, - или обратная косая черта в конце строки, они указывают на продолжение оператора.

Идентификаторы Ruby

Идентификаторы - это имена переменных, констант и методов. Идентификаторы Ruby чувствительны к регистру. Это означает, что Ram и RAM - это два разных идентификатора в Ruby.

Имена идентификаторов Ruby могут состоять из буквенно-цифровых символов и символа подчеркивания (_).

Зарезервированные слова

В следующем списке показаны зарезервированные слова в Ruby. Эти зарезервированные слова нельзя использовать в качестве имен констант или переменных. Однако их можно использовать как имена методов.

НАЧАТЬ делать следующий тогда
КОНЕЦ еще ноль правда
псевдоним Эльсиф не undef
и конец или же если только
начать обеспечить повторить до того как
сломать ложный спасение когда
дело за повторить попытку в то время как
класс если возвращение в то время как
def в я __ФАЙЛ__
определены? модуль супер __ЛИНИЯ__

Здесь документ на Ruby

«Здесь документ» относится к построению строк из нескольких строк. После << вы можете указать строку или идентификатор для завершения строкового литерала, и все строки, следующие за текущей строкой до терминатора, являются значением строки.

Если терминатор заключен в кавычки, тип кавычек определяет тип строкового литерала с ориентацией на строку. Обратите внимание, что между << и терминатором не должно быть пробелов.

Вот разные примеры -

#!/usr/bin/ruby -w

print <<EOF
   This is the first way of creating
   here document ie. multiple line string.
EOF

print <<"EOF";                # same as above
   This is the second way of creating
   here document ie. multiple line string.
EOF

print <<`EOC`                 # execute commands
	echo hi there
	echo lo there
EOC

print <<"foo", <<"bar"  # you can stack them
	I said foo.
foo
	I said bar.
bar

Это даст следующий результат -

This is the first way of creating
   her document ie. multiple line string.
   This is the second way of creating
   her document ie. multiple line string.
hi there
lo there
      I said foo.
      I said bar.

Заявление Ruby BEGIN

Синтаксис

BEGIN {
   code
}

Объявляет код, который будет вызываться перед запуском программы.

пример

#!/usr/bin/ruby

puts "This is main Ruby Program"

BEGIN {
   puts "Initializing Ruby Program"
}

Это даст следующий результат -

Initializing Ruby Program
This is main Ruby Program

Заявление Ruby END

Синтаксис

END {
   code
}

Объявляет код, который будет вызываться в конце программы.

пример

#!/usr/bin/ruby

puts "This is main Ruby Program"

END {
   puts "Terminating Ruby Program"
}
BEGIN {
   puts "Initializing Ruby Program"
}

Это даст следующий результат -

Initializing Ruby Program
This is main Ruby Program
Terminating Ruby Program

Комментарии Ruby

Комментарий скрывает строку, часть строки или несколько строк от интерпретатора Ruby. Вы можете использовать символ решетки (#) в начале строки -

# I am a comment. Just ignore me.

Или комментарий может быть в той же строке после утверждения или выражения -

name = "Madisetti" # This is again comment

Вы можете прокомментировать несколько строк следующим образом -

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

Вот еще одна форма. Этот комментарий блока скрывает от интерпретатора несколько строк с = begin / = end -

=begin
This is a comment.
This is a comment, too.
This is a comment, too.
I said that already.
=end

Ruby - идеальный язык объектно-ориентированного программирования. Особенности объектно-ориентированного языка программирования включают в себя:

  • Инкапсуляция данных
  • Абстракция данных
  • Polymorphism
  • Inheritance

Эти возможности обсуждались в главе « Объектно-ориентированный Ruby» .

Объектно-ориентированная программа включает классы и объекты. Класс - это план, из которого создаются отдельные объекты. В объектно-ориентированных терминах мы говорим, что ваш велосипед является экземпляром класса объектов, известных как велосипеды.

Возьмем для примера любое транспортное средство. Он включает колеса, мощность и емкость топливного или бензобака. Эти характеристики образуют элементы данных класса Vehicle. Вы можете отличить одно транспортное средство от другого с помощью этих характеристик.

Транспортное средство также может иметь определенные функции, такие как остановка, вождение и превышение скорости. Даже эти функции образуют элементы данных класса Vehicle. Таким образом, вы можете определить класс как комбинацию характеристик и функций.

Класс Vehicle можно определить как -

Class Vehicle {

   Number no_of_wheels
   Number horsepower
   Characters type_of_tank
   Number Capacity
   Function speeding {
   }
   
   Function driving {
   }
   
   Function halting {
   }
}

Присваивая разные значения этим элементам данных, вы можете сформировать несколько экземпляров класса Vehicle. Например, самолет имеет три колеса, мощность в 1000 лошадиных сил, топливо как тип бака и емкость 100 литров. Таким же образом автомобиль имеет четыре колеса, мощность 200 лошадиных сил, бензобак как тип бака и емкость 25 литров.

Определение класса в Ruby

Чтобы реализовать объектно-ориентированное программирование с помощью Ruby, вам нужно сначала научиться создавать объекты и классы в Ruby.

Класс в Ruby всегда начинается с ключевого слова class, за которым следует имя класса. Имя всегда должно быть написано заглавными буквами. Класс Customer может отображаться как -

class Customer
end

Вы завершаете класс, используя ключевое слово end . Все элементы данных в классе находятся между определением класса и ключевым словом end .

Переменные в классе Ruby

Ruby предоставляет четыре типа переменных -

  • Local Variables- Локальные переменные - это переменные, определенные в методе. Локальные переменные недоступны вне метода. Вы увидите более подробную информацию о методе в следующей главе. Локальные переменные начинаются со строчной буквы или _.

  • Instance Variables- Переменные экземпляра доступны через методы для любого конкретного экземпляра или объекта. Это означает, что переменные экземпляра меняются от объекта к объекту. Переменным экземпляра предшествует знак (@), за которым следует имя переменной.

  • Class Variables- Переменные класса доступны для разных объектов. Переменная класса принадлежит классу и является характеристикой класса. Им предшествует знак @@, а за ними следует имя переменной.

  • Global Variables- Переменные класса недоступны для разных классов. Если вы хотите иметь одну переменную, доступную для всех классов, вам необходимо определить глобальную переменную. Глобальным переменным всегда предшествует знак доллара ($).

пример

Используя переменную класса @@ no_of_customers, вы можете определить количество создаваемых объектов. Это позволяет определить количество клиентов.

class Customer
   @@no_of_customers = 0
end

Создание объектов в Ruby с использованием нового метода

Объекты - это экземпляры класса. Теперь вы узнаете, как создавать объекты класса в Ruby. Вы можете создавать объекты в Ruby, используя метод new класса.

Метод новый уникальный тип метода, который предопределен в библиотеке Ruby. Новый метод принадлежит к классу методов.

Вот пример создания двух объектов cust1 и cust2 класса Customer:

cust1 = Customer. new
cust2 = Customer. new

Здесь cust1 и cust2 - это имена двух объектов. Вы пишете имя объекта, за которым следует знак равенства (=), после которого следует имя класса. Затем последуют оператор точка и ключевое слово new .

Пользовательский метод создания объектов Ruby

Вы можете передавать параметры методу new, и эти параметры можно использовать для инициализации переменных класса.

Когда вы планируете объявить новый метод с параметрами, вам необходимо объявить инициализацию метода во время создания класса.

Метод инициализации - это особый тип метода, который будет выполняться при вызове нового метода класса с параметрами.

Вот пример создания метода инициализации -

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
end

В этом примере вы объявляете метод инициализации с помощьюid, name, и addrкак локальные переменные. Здесь def и end используются для определения инициализации метода Ruby . Вы узнаете больше о методах в следующих главах.

В методе инициализации вы передаете значения этих локальных переменных в переменные экземпляра @cust_id, @cust_name и @cust_addr. Здесь локальные переменные содержат значения, которые передаются вместе с новым методом.

Теперь вы можете создавать объекты следующим образом -

cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

Функции-члены в классе Ruby

В Ruby функции называются методами. Каждый метод в классе начинается с ключевого слова def, за которым следует имя метода.

Имя метода всегда предпочтительнее в lowercase letters. Вы завершаете метод в Ruby, используя ключевое слово end .

Вот пример определения метода Ruby -

class Sample
   def function
      statement 1
      statement 2
   end
end

Здесь оператор 1 и оператор 2 являются частью тела функции метода внутри класса Sample. Эти состояния могут быть любым допустимым оператором Ruby. Например , мы можем поставить метод путы для печати Hello рубина следующим образом -

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

Теперь в следующем примере создайте один объект класса Sample, вызовите метод hello и посмотрите результат -

#!/usr/bin/ruby

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

# Now using above class to create objects
object = Sample. new
object.hello

Это даст следующий результат -

Hello Ruby!

Простой пример использования

Вот пример из практики, если вы хотите попрактиковаться с классом и объектами.

Пример использования класса Ruby

Переменные - это ячейки памяти, в которых хранятся любые данные, которые могут использоваться любой программой.

Ruby поддерживает пять типов переменных. Вы уже прошли небольшое описание этих переменных в предыдущей главе. Эти пять типов переменных объясняются в этой главе.

Глобальные переменные Ruby

Глобальные переменные начинаются с $. Неинициализированные глобальные переменные имеют значение nil и выдают предупреждения с параметром -w.

Присвоение глобальным переменным изменяет глобальный статус. Не рекомендуется использовать глобальные переменные. Они делают программы загадочными.

Вот пример, показывающий использование глобальной переменной.

#!/usr/bin/ruby

$global_variable = 10 class Class1 def print_global puts "Global variable in Class1 is #$global_variable"
   end
end
class Class2
   def print_global
      puts "Global variable in Class2 is #$global_variable"
   end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

Здесь $ global_variable - глобальная переменная. Это даст следующий результат -

NOTE - В Ruby вы МОЖЕТЕ получить доступ к значению любой переменной или константы, поместив символ решетки (#) непосредственно перед этой переменной или константой.

Global variable in Class1 is 10
Global variable in Class2 is 10

Переменные экземпляра Ruby

Переменные экземпляра начинаются с @. Неинициализированные переменные экземпляра имеют значение nil и выдают предупреждения с параметром -w.

Вот пример, показывающий использование переменных экземпляра.

#!/usr/bin/ruby

class Customer
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.display_details()
cust2.display_details()

Здесь @cust_id, @cust_name и @cust_addr - переменные экземпляра. Это даст следующий результат -

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

Переменные класса Ruby

Переменные класса начинаются с @@ и должны быть инициализированы, прежде чем их можно будет использовать в определениях методов.

Ссылка на неинициализированную переменную класса приводит к ошибке. Переменные класса совместно используются потомками класса или модуля, в котором определены переменные класса.

Переопределение переменных класса вызывает предупреждения с параметром -w.

Вот пример, показывающий использование переменной класса -

#!/usr/bin/ruby

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
   def total_no_of_customers()
      @@no_of_customers += 1
      puts "Total number of customers: #@@no_of_customers"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()

Здесь @@ no_of_customers - это переменная класса. Это даст следующий результат -

Total number of customers: 1
Total number of customers: 2

Локальные переменные Ruby

Локальные переменные начинаются со строчной буквы или _. Область действия локальной переменной варьируется от class, module, def или do до соответствующего конца или от открывающей скобки блока до его закрывающей скобки {}.

Когда ссылаются на неинициализированную локальную переменную, это интерпретируется как вызов метода, не имеющего аргументов.

Присвоение неинициализированным локальным переменным также служит объявлением переменной. Переменные начинают существовать до тех пор, пока не будет достигнут конец текущей области. Время жизни локальных переменных определяется, когда Ruby анализирует программу.

В приведенном выше примере локальными переменными являются id, name и addr.

Константы Ruby

Константы начинаются с заглавной буквы. Константы, определенные в классе или модуле, могут быть доступны из этого класса или модуля, а те, которые определены вне класса или модуля, могут быть доступны глобально.

Константы не могут быть определены в методах. Ссылка на неинициализированную константу вызывает ошибку. Присваивание уже инициализированной константе вызывает предупреждение.

#!/usr/bin/ruby

class Example
   VAR1 = 100
   VAR2 = 200
   def show
      puts "Value of first Constant is #{VAR1}"
      puts "Value of second Constant is #{VAR2}"
   end
end

# Create Objects
object = Example.new()
object.show

Здесь VAR1 и VAR2 - константы. Это даст следующий результат -

Value of first Constant is 100
Value of second Constant is 200

Псевдо-переменные Ruby

Это специальные переменные, которые имеют вид локальных переменных, но ведут себя как константы. Этим переменным нельзя присвоить какое-либо значение.

  • self - объект-получатель текущего метода.

  • true - Значение, представляющее истину.

  • false - Значение, представляющее ложь.

  • nil - Значение, представляющее неопределенное.

  • __FILE__ - Имя текущего исходного файла.

  • __LINE__ - Текущий номер строки в исходном файле.

Базовые литералы Ruby

Правила, которые Ruby использует для литералов, просты и интуитивно понятны. В этом разделе объясняются все основные литералы Ruby.

Целые числа

Ruby поддерживает целые числа. Целое число может находиться в диапазоне от -2 30 до 2 30-1 или от -2 62 до 2 62-1 . Целые числа в этом диапазоне являются объектами класса Fixnum, а целые числа вне этого диапазона хранятся в объектах класса Bignum .

Вы пишете целые числа, используя необязательный начальный знак, необязательный базовый индикатор (0 для восьмеричного, 0x для шестнадцатеричного или 0b для двоичного), за которым следует строка цифр в соответствующей базе. Знаки подчеркивания игнорируются в строке цифр.

Вы также можете получить целочисленное значение, соответствующее символу ASCII, или экранировать последовательность, поставив перед ней вопросительный знак.

пример

123                  # Fixnum decimal
1_234                # Fixnum decimal with underline
-500                 # Negative Fixnum
0377                 # octal
0xff                 # hexadecimal
0b1011               # binary
?a                   # character code for 'a'
?\n                  # code for a newline (0x0a)
12345678901234567890 # Bignum

NOTE - Класс и объекты описаны в отдельной главе этого руководства.

Плавающие числа

Ruby поддерживает плавающие числа. Это тоже числа, но с десятичными знаками. Числа с плавающей запятой являются объектами класса Float и могут быть любым из следующих:

пример

123.4                # floating point value
1.0e6                # scientific notation
4E20                 # dot not required
4e+20                # sign before exponential

Строковые литералы

Строки Ruby - это просто последовательности 8-битных байтов, которые являются объектами класса String. Строки в двойных кавычках допускают замену и обратную косую черту, но строки в одинарных кавычках не допускают замену и допускают обратную косую черту только для \\ и \ '

пример

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

Это даст следующий результат -

escape using "\"
That's right

Вы можете подставить значение любого выражения Ruby в строку, используя последовательность #{ expr }. Здесь expr может быть любым выражением ruby.

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

Это даст следующий результат -

Multiplication Value : 86400

Обозначения с обратной косой чертой

Ниже приведен список нотаций с обратной косой чертой, поддерживаемых Ruby.

Обозначение Представленный персонаж
\ п Новая строка (0x0a)
Возврат каретки (0x0d)
\ f Подача формы (0x0c)
\ b Backspace (0x08)
\ а Колокол (0x07)
\ е Побег (0x1b)
\ s Пробел (0x20)
\ nnn Восьмеричная запись (n = 0-7)
\ xnn Шестнадцатеричное представление (n - 0-9, af или AF)
\ cx, \ Cx Ctrl-x
\ Mx Мета-х (c | 0x80)
\ M- \ Cx Мета-Control-x
\Икс Символ x

Дополнительные сведения о Ruby Strings см. В Ruby Strings .

Рубиновые массивы

Литералы Ruby Array создаются путем помещения в квадратные скобки ряда ссылок на объекты, разделенных запятыми. Завершающая запятая игнорируется.

пример

#!/usr/bin/ruby

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
   puts i
end

Это даст следующий результат -

fred
10
3.14
This is a string
last element

Для получения более подробной информации о Ruby Arrays, просмотрите Ruby Arrays .

Рубиновые хэши

Литеральный Ruby Hash создается путем помещения списка пар ключ / значение в фигурные скобки, с запятой или последовательностью => между ключом и значением. Завершающая запятая игнорируется.

пример

#!/usr/bin/ruby

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

Это даст следующий результат -

red is 3840
green is 240
blue is 15

Для получения более подробной информации о Ruby Hashes, просмотрите Ruby Hashes .

Рубиновые диапазоны

Диапазон представляет собой интервал, который представляет собой набор значений с началом и концом. Диапазоны могут быть созданы с использованием литералов s..e и s ... e или с помощью Range.new.

Диапазоны, построенные с помощью .., выполняются от начала до конца включительно. Те, которые созданы с использованием ... исключают конечное значение. При использовании в качестве итератора диапазоны возвращают каждое значение в последовательности.

Диапазон (1..5) означает, что он включает 1, 2, 3, 4, 5 значений, а диапазон (1 ... 5) означает, что он включает 1, 2, 3, 4 значения.

пример

#!/usr/bin/ruby

(10..15).each do |n| 
   print n, ' ' 
end

Это даст следующий результат -

10 11 12 13 14 15

Чтобы узнать больше о Ruby Ranges, пройдите по Ruby Ranges .

Ruby поддерживает богатый набор операторов, как и следовало ожидать от современного языка. Большинство операторов на самом деле являются вызовами методов. Например, a + b интерпретируется как a. + (B), где метод + в объекте, на который указывает переменная a, вызывается с b в качестве аргумента.

Для каждого оператора (+ - * /% ** & | ^ << >> && ||) существует соответствующая форма сокращенного оператора присваивания (+ = - = и т. Д.).

Арифметические операторы Ruby

Предположим, что переменная a содержит 10, а переменная b содержит 20, тогда -

Оператор Описание пример
+ Сложение - добавляет значения по обе стороны от оператора. a + b даст 30
- Вычитание - вычитает правый операнд из левого операнда. а - б даст -10
* Умножение - умножает значения по обе стороны от оператора. a * b даст 200
/ Деление - делит левый операнд на правый. б / у даст 2
% Модуль - делит левый операнд на правый и возвращает остаток. b% a даст 0
** Exponent - Выполняет экспоненциальный (степенной) расчет для операторов. a ** b даст 10 в степени 20

Операторы сравнения Ruby

Предположим, что переменная a содержит 10, а переменная b содержит 20, тогда -

Оператор Описание пример
== Проверяет, равны ли значения двух операндов или нет, если да, то условие становится истинным. (a == b) неверно.
знак равно Проверяет, равны ли значения двух операндов или нет, если значения не равны, условие становится истинным. (a! = b) верно.
> Проверяет, больше ли значение левого операнда, чем значение правого операнда, если да, то условие становится истинным. (a> b) неверно.
< Проверяет, меньше ли значение левого операнда, чем значение правого операнда, если да, то условие становится истинным. (a <b) верно.
> = Проверяет, больше ли значение левого операнда или равно значению правого операнда, если да, то условие становится истинным. (a> = b) неверно.
<= Проверяет, меньше ли значение левого операнда или равно значению правого операнда, если да, то условие становится истинным. (a <= b) верно.
<=> Комбинированный оператор сравнения. Возвращает 0, если первый операнд равен второму, 1, если первый операнд больше второго, и -1, если первый операнд меньше второго. (a <=> b) возвращает -1.
=== Используется для проверки равенства в предложении when оператора case . (1 ... 10) === 5 возвращает истину.
.eql? Истинно, если получатель и аргумент имеют один и тот же тип и равные значения. 1 == 1.0 возвращает true, но 1.eql? (1.0) ложно.
равный? Истинно, если получатель и аргумент имеют одинаковый идентификатор объекта. если aObj дублирует bObj, тогда aObj == bObj истинно, a.equal? ​​bObj ложно, но a.equal? ​​aObj истинно.

Операторы присваивания Ruby

Предположим, что переменная a содержит 10, а переменная b содержит 20, тогда -

Оператор Описание пример
знак равно Простой оператор присваивания, присваивает значения из правых операндов левому операнду. c = a + b присвоит значение a + b в c
+ = Добавить оператор присваивания И, добавляет правый операнд к левому операнду и присваивает результат левому операнду. c + = a эквивалентно c = c + a
знак равно Оператор вычитания И присваивания, вычитает правый операнд из левого операнда и присваивает результат левому операнду. c - = a эквивалентно c = c - a
знак равно Оператор умножения И присваивания, умножает правый операнд на левый операнд и присваивает результат левому операнду. c * = a эквивалентно c = c * a
знак равно Оператор деления И присваивания, делит левый операнд на правый и присваивает результат левому операнду. c / = a эквивалентно c = c / a
знак равно Оператор модуля И присваивания принимает модуль с использованием двух операндов и присваивает результат левому операнду. c% = a эквивалентно c = c% a
знак равно Оператор экспоненты И присваивания, выполняет экспоненциальное (степенное) вычисление операторов и присваивает значение левому операнду. c ** = a эквивалентно c = c ** a

Параллельное присвоение Ruby

Ruby также поддерживает параллельное присвоение переменных. Это позволяет инициализировать несколько переменных с помощью одной строки кода Ruby. Например -

a = 10
b = 20
c = 30

Это можно быстрее объявить с помощью параллельного присваивания -

a, b, c = 10, 20, 30

Параллельное присвоение также полезно для обмена значениями, содержащимися в двух переменных:

a, b = b, c

Побитовые операторы Ruby

Побитовый оператор работает с битами и выполняет побитовую операцию.

Допустим, если a = 60; и b = 13; теперь в двоичном формате они будут такими -

a    =  0011 1100
 b    =  0000 1101
 ------------------
 a&b  =  0000 1100
 a|b  =  0011 1101
 a^b  =  0011 0001
 ~a   =  1100 0011

Следующие побитовые операторы поддерживаются языком Ruby.

Оператор Описание пример
& Двоичный оператор И копирует бит в результат, если он существует в обоих операндах. (a и b) даст 12, что составляет 0000 1100
| Оператор двоичного ИЛИ копирует бит, если он существует в любом из операндов. (a | b) даст 61, что составляет 0011 1101
^ Двоичный оператор XOR копирует бит, если он установлен в одном операнде, но не в обоих. (a ^ b) даст 49, что составляет 0011 0001
~ Оператор дополнения двоичных единиц является унарным и имеет эффект «переворачивания» битов. (~ a) даст -61, что составляет 1100 0011 в форме дополнения до 2 из-за двоичного числа со знаком.
<< Оператор двоичного сдвига влево. Значение левого операнда сдвигается влево на количество битов, указанное правым операндом. << 2 даст 240, что составляет 1111 0000
>> Оператор двоичного сдвига вправо. Значение левого операнда перемещается вправо на количество битов, указанное правым операндом. a >> 2 даст 15, что равно 0000 1111

Логические операторы Ruby

Следующие логические операторы поддерживаются языком Ruby.

Предположим, что переменная a содержит 10, а переменная b содержит 20, тогда -

Оператор Описание пример
и Вызывается логическим оператором И. Если оба операнда верны, то условие становится истинным. (а и б) верно.
или же Вызывается логическим оператором ИЛИ. Если какой-либо из двух операндов не равен нулю, условие становится истинным. (а или б) верно.
&& Вызывается логическим оператором И. Если оба операнда не равны нулю, условие становится истинным. (a && b) верно.
|| Вызывается логическим оператором ИЛИ. Если какой-либо из двух операндов не равен нулю, условие становится истинным. (a || b) верно.
! Вызывается оператором логического НЕ. Используется для изменения логического состояния операнда на обратное. Если условие истинно, то оператор логического НЕ сделает ложным. ! (a && b) ложно.
не Вызывается оператором логического НЕ. Используется для изменения логического состояния операнда на обратное. Если условие истинно, то оператор логического НЕ сделает ложным. not (a && b) ложно.

Тернарный оператор Ruby

Есть еще один оператор - Ternary Operator. Сначала он оценивает выражение для истинного или ложного значения, а затем выполняет один из двух заданных операторов в зависимости от результата оценки. Условный оператор имеет этот синтаксис -

Оператор Описание пример
? : Условное выражение Если условие верно? Затем значение X: в противном случае значение Y

Операторы диапазона Ruby

Диапазоны последовательностей в Ruby используются для создания диапазона последовательных значений, состоящего из начального значения, конечного значения и диапазона значений между ними.

В Ruby эти последовательности создаются с помощью операторов диапазона «..» и «...». Форма с двумя точками создает включающий диапазон, а форма с тремя точками создает диапазон, исключающий указанное максимальное значение.

Оператор Описание пример
.. Создает диапазон от начальной до конечной точки включительно. 1..10 Создает диапазон от 1 до 10 включительно.
... Создает исключительный диапазон от начальной до конечной точки. 1 ... 10 Создает диапазон от 1 до 9.

Определение Ruby? Операторы

определены? - это специальный оператор, который принимает форму вызова метода, чтобы определить, определено ли переданное выражение. Он возвращает строку описания выражения или ноль, если выражение не определено.

Есть различные варианты использования определенных? Оператор

Использование 1

defined? variable # True if variable is initialized

For Example

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

Использование 2

defined? method_call # True if a method is defined

For Example

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

Использование 3

# True if a method exists that can be called with super user
defined? super

For Example

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

Использование 4

defined? yield   # True if a code block has been passed

For Example

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

Рубиновая точка "." and Double Colon "::" Операторы

Вы вызываете метод модуля, предваряя его имя именем модуля и точкой, и вы ссылаетесь на константу, используя имя модуля и два двоеточия.

В :: - это унарный оператор, который позволяет: к константам, методам экземпляра и методам класса, определенным в классе или модуле, получить доступ из любого места за пределами класса или модуля.

Remember в Ruby классы и методы также можно считать константами.

Вам нужно просто добавить префикс :: Const_name с выражением, которое возвращает соответствующий объект класса или модуля.

Если префиксное выражение не используется, по умолчанию используется основной класс Object.

Вот два примера -

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

Second Example

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

Приоритет операторов Ruby

В следующей таблице перечислены все операторы от самого высокого до самого низкого приоритета.

Метод Оператор Описание
да :: Оператор постоянного разрешения
да знак равно Ссылка на элемент, набор элементов
да ** Возведение в степень (возведение в степень)
да ! ~ + - Не, дополнение, унарный плюс и минус (имена методов для последних двух: + @ и - @)
да * /% Умножение, деление и по модулю
да + - Сложение и вычитание
да >> << Поразрядный сдвиг вправо и влево
да & Побитовое "И"
да ^ | Побитовое исключающее `ИЛИ 'и обычное` ИЛИ'
да <= <>> = Операторы сравнения
да <=> == ===! = = ~! ~ Операторы равенства и сопоставления с образцом (! = И! ~ Не могут быть определены как методы)
  && Логическое "И"
  || Логическое ИЛИ
  .. ... Ассортимент (включительно и эксклюзивно)
  ? : Тернарный if-then-else
  =% = {/ = - = + = | = & = >> = << = * = && = || = ** = Назначение
  определены? Проверить, определен ли указанный символ
  не Логическое отрицание
  или и Логическая композиция

NOTE- Операторы, для которых в столбце метода указано « Да», на самом деле являются методами и поэтому могут быть переопределены.

Комментарии - это строки аннотации в коде Ruby, которые игнорируются во время выполнения. Однострочный комментарий начинается с символа # и простирается от # до конца строки следующим образом:

#!/usr/bin/ruby -w
# This is a single line comment.

puts "Hello, Ruby!"

При выполнении вышеуказанная программа дает следующий результат -

Hello, Ruby!

Многострочные комментарии Ruby

Вы можете прокомментировать несколько строк, используя =begin и =end синтаксис следующим образом -

#!/usr/bin/ruby -w

puts "Hello, Ruby!"

=begin
This is a multiline comment and con spwan as many lines as you
like. But =begin and =end should come in the first line only. 
=end

При выполнении вышеуказанная программа дает следующий результат -

Hello, Ruby!

Убедитесь, что завершающие комментарии находятся достаточно далеко от кода и легко различимы. Если в блоке существует более одного завершающего комментария, выровняйте их. Например -

@counter      # keeps track times page has been hit
@siteCounter  # keeps track of times all pages have been hit

Ruby предлагает условные структуры, довольно общие для современных языков. Здесь мы объясним все условные операторы и модификаторы, доступные в Ruby.

Ruby if ... else Заявление

Синтаксис

if conditional [then]
   code...
[elsif conditional [then]
   code...]...
[else
   code...]
end

если выражения используются для условного выполнения. Значения false и nil ложны, а все остальное верно. Обратите внимание, что Ruby использует elsif, а не else if или elif.

Выполняет код, если условие истинно. Если условие не истинно, выполняется код, указанный в предложении else.

Условное выражение if отделяется от кода зарезервированным словом then , новой строкой или точкой с запятой.

пример

#!/usr/bin/ruby

x = 1
if x > 2
   puts "x is greater than 2"
elsif x <= 2 and x!=0
   puts "x is 1"
else
   puts "I can't guess the number"
end
x is 1

Рубиновый модификатор if

Синтаксис

code if condition

Выполняет код, если условие истинно.

пример

#!/usr/bin/ruby

$debug = 1
print "debug\n" if $debug

Это даст следующий результат -

debug

Ruby if Statement

Синтаксис

unless conditional [then]
   code
[else
   code ]
end

Выполняет код, если условие ложно. Если условие истинно, выполняется код, указанный в предложении else.

пример

#!/usr/bin/ruby

x = 1 
unless x>=2
   puts "x is less than 2"
 else
   puts "x is greater than 2"
end

Это даст следующий результат -

x is less than 2

Руби, если модификатор

Синтаксис

code unless conditional

Выполняет код, если условие ложно.

пример

#!/usr/bin/ruby

$var =  1
print "1 -- Value is set\n" if $var print "2 -- Value is set\n" unless $var

$var = false print "3 -- Value is set\n" unless $var

Это даст следующий результат -

1 -- Value is set
3 -- Value is set

Заявление о регистре Ruby

Синтаксис

case expression
[when expression [, expression ...] [then]
   code ]...
[else
   code ]
end

Сравнивает выражение, указанное с помощью case, и выражение , указанное с помощью оператора ===, и выполняет код соответствующего предложения when.

Выражение задается когда это п оценивается как левый операнд. Если предложения when не совпадают, case выполняет код предложения else .

Когда - выражение отделено от кода зарезервированного слова, то символом новой строки или точкой с запятой. Таким образом -

case expr0
when expr1, expr2
   stmt1
when expr3, expr4
   stmt2
else
   stmt3
end

в основном похож на следующее -

_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
   stmt1
elsif expr3 === _tmp || expr4 === _tmp
   stmt2
else
   stmt3
end

пример

#!/usr/bin/ruby

$age = 5 case $age
when 0 .. 2
   puts "baby"
when 3 .. 6
   puts "little child"
when 7 .. 12
   puts "child"
when 13 .. 18
   puts "youth"
else
   puts "adult"
end

Это даст следующий результат -

little child

Циклы в Ruby используются для выполнения одного и того же блока кода определенное количество раз. В этой главе подробно описаны все операторы цикла, поддерживаемые Ruby.

Ruby while Statement

Синтаксис

while conditional [do]
   code
end

Выполняет код, пока условие истинно. А в то время как Loop в условно отделена от кода зарезервированным словом сделать, символ новой строки, обратная косая черта \ или точкой с запятой;.

пример

#!/usr/bin/ruby

$i = 0
$num = 5

while $i < $num  do
   puts("Inside the loop i = #$i" )
   $i +=1
end

Это даст следующий результат -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

Рубиновый модификатор while

Синтаксис

code while condition

OR

begin 
  code 
end while conditional

Выполняет код, пока условие истинно.

Если модификатор while следует за оператором begin без предложений rescue или protect, код выполняется один раз перед вычислением условного выражения .

пример

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1
end while $i < $num

Это даст следующий результат -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

Рубин до заявления

until conditional [do]
   code
end

Выполняет код, пока условное значение ложно. An , пока условный оператор отделено от кода зарезервированным словом делать , переводом строки или точкой с запятой.

пример

#!/usr/bin/ruby

$i = 0
$num = 5

until $i > $num  do
   puts("Inside the loop i = #$i" )
   $i +=1;
end

Это даст следующий результат -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

Рубин до модификатора

Синтаксис

code until conditional

OR

begin
   code
end until conditional

Выполняет код, пока условное значение ложно.

Если модификатор until следует за оператором begin без предложений rescue или protect, код выполняется один раз перед вычислением условного выражения .

пример

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1;
end until $i > $num

Это даст следующий результат -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

Рубин для утверждения

Синтаксис

for variable [, variable ...] in expression [do]
   code
end

Выполняет код один раз для каждого элемента в выражении .

пример

#!/usr/bin/ruby

for i in 0..5
   puts "Value of local variable is #{i}"
end

Здесь мы определили диапазон 0..5. Оператор для i в 0..5 позволит i принимать значения в диапазоне от 0 до 5 (включая 5). Это даст следующий результат -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Цикл for ... in почти точно эквивалентен следующему:

(expression).each do |variable[, variable...]| code end

за исключением того, что цикл for не создает новую область для локальных переменных. А для Loop в выражение отделяется от кода зарезервированным словом делать, переводом строки или точкой с запятой.

пример

#!/usr/bin/ruby

(0..5).each do |i|
   puts "Value of local variable is #{i}"
end

Это даст следующий результат -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Заявление о прерывании Ruby

Синтаксис

break

Завершает самый внутренний цикл. Завершает метод со связанным блоком, если он вызывается внутри блока (при этом метод возвращает nil).

пример

#!/usr/bin/ruby

for i in 0..5
   if i > 2 then
      break
   end
   puts "Value of local variable is #{i}"
end

Это даст следующий результат -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2

Следующее заявление Ruby

Синтаксис

next

Переход к следующей итерации самого внутреннего цикла. Завершает выполнение блока, если вызывается внутри блока (с yield или call, возвращающими nil).

пример

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      next
   end
   puts "Value of local variable is #{i}"
end

Это даст следующий результат -

Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Заявление повтора Ruby

Синтаксис

redo

Перезапускает эту итерацию самого внутреннего цикла без проверки условия цикла. Перезапускает yield или call, если вызывается внутри блока.

пример

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      puts "Value of local variable is #{i}"
      redo
   end
end

Это даст следующий результат и зайдет в бесконечный цикл:

Value of local variable is 0
Value of local variable is 0
............................

Заявление о повторной попытке Ruby

Синтаксис

retry

Если повторная попытка появляется в пункте спасательного начать выражение, перезапускать с начала начать тело.

begin
   do_something # exception raised
rescue
   # handles error
   retry  # restart from beginning
end

Если повтор появляется в итераторе, блоке или теле выражения for , перезапускает вызов итератора. Аргументы итератора переоцениваются.

for i in 1..5
   retry if some_condition # restart from i == 1
end

пример

#!/usr/bin/ruby
for i in 0..5
   retry if i > 2
puts "Value of local variable is #{i}"
end

Это даст следующий результат и зайдет в бесконечный цикл:

Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
............................

Методы Ruby очень похожи на функции любого другого языка программирования. Методы Ruby используются для объединения одного или нескольких повторяемых операторов в единый блок.

Имена методов должны начинаться с строчной буквы. Если вы начинаете имя метода с заглавной буквы, Ruby может подумать, что это константа, и, следовательно, может неправильно проанализировать вызов.

Методы должны быть определены перед их вызовом, иначе Ruby вызовет исключение для вызова неопределенного метода.

Синтаксис

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
   expr..
end

Итак, вы можете определить простой метод следующим образом:

def method_name 
   expr..
end

Вы можете представить метод, который принимает такие параметры:

def method_name (var1, var2)
   expr..
end

Вы можете установить значения по умолчанию для параметров, которые будут использоваться, если метод вызывается без передачи необходимых параметров -

def method_name (var1 = value1, var2 = value2)
   expr..
end

Всякий раз, когда вы вызываете простой метод, вы пишете только имя метода следующим образом:

method_name

Однако, когда вы вызываете метод с параметрами, вы пишете имя метода вместе с параметрами, например -

method_name 25, 30

Самый важный недостаток использования методов с параметрами заключается в том, что вам нужно помнить количество параметров всякий раз, когда вы вызываете такие методы. Например, если метод принимает три параметра, а вы передаете только два, Ruby отображает ошибку.

пример

#!/usr/bin/ruby

def test(a1 = "Ruby", a2 = "Perl")
   puts "The programming language is #{a1}"
   puts "The programming language is #{a2}"
end
test "C", "C++"
test

Это даст следующий результат -

The programming language is C
The programming language is C++
The programming language is Ruby
The programming language is Perl

Возвращаемые значения из методов

Каждый метод в Ruby по умолчанию возвращает значение. Это возвращаемое значение будет значением последнего оператора. Например -

def test
   i = 100
   j = 10
   k = 0
end

Этот метод при вызове вернет последнюю объявленную переменную k .

Заявление о возврате Ruby

Оператор return в ruby ​​используется для возврата одного или нескольких значений из метода Ruby.

Синтаксис

return [expr[`,' expr...]]

Если дано более двух выражений, возвращаемым значением будет массив, содержащий эти значения. Если выражение не задано, возвращается значение nil.

пример

return

OR

return 12

OR

return 1,2,3

Взгляните на этот пример -

#!/usr/bin/ruby

def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

Это даст следующий результат -

100
200
300

Переменное количество параметров

Предположим, вы объявляете метод, который принимает два параметра, всякий раз, когда вы вызываете этот метод, вам необходимо передавать вместе с ним два параметра.

Однако Ruby позволяет объявлять методы, которые работают с переменным числом параметров. Давайте рассмотрим образец этого -

#!/usr/bin/ruby

def sample (*test)
   puts "The number of parameters is #{test.length}"
   for i in 0...test.length
      puts "The parameters are #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

В этом коде вы объявили образец метода, который принимает тест с одним параметром. Однако этот параметр является переменным параметром. Это означает, что этот параметр может принимать любое количество переменных. Итак, приведенный выше код даст следующий результат -

The number of parameters is 3
The parameters are Zara
The parameters are 6
The parameters are F
The number of parameters is 4
The parameters are Mac
The parameters are 36
The parameters are M
The parameters are MCA

Методы класса

Когда метод определен вне определения класса, метод по умолчанию помечается как закрытый . С другой стороны, методы, определенные в определении класса, по умолчанию помечены как общедоступные. Видимость по умолчанию и закрытая отметка методов могут быть изменены на общедоступные или закрытые для модуля.

Всякий раз, когда вы хотите получить доступ к методу класса, вам сначала нужно создать экземпляр класса. Затем, используя объект, вы можете получить доступ к любому члену класса.

Ruby дает вам возможность получить доступ к методу без создания экземпляра класса. Давайте посмотрим, как объявляется метод класса и к нему осуществляется доступ -

class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end

Посмотрите, как объявлен метод return_date. Он объявляется с именем класса, за которым следует точка, за которой следует имя метода. Вы можете получить доступ к этому методу класса напрямую следующим образом:

Accounts.return_date

Чтобы получить доступ к этому методу, вам не нужно создавать объекты класса Accounts.

Заявление о псевдониме Ruby

Это дает псевдонимы методам или глобальным переменным. Псевдонимы не могут быть определены в теле метода. Псевдоним метода сохраняет текущее определение метода, даже если методы переопределены.

Создание псевдонимов для пронумерованных глобальных переменных ($ 1, $ 2, ...) запрещено. Переопределение встроенных глобальных переменных может вызвать серьезные проблемы.

Синтаксис

alias method-name method-name
alias global-variable-name global-variable-name

пример

alias foo bar
alias $MATCH $&

Здесь мы определили псевдоним foo для bar, а $ MATCH - псевдоним для $ &

Заявление Ruby undef

Это отменяет определение метода. UNDEF не может появиться в теле метода.

Используя undef и alias , интерфейс класса может быть изменен независимо от суперкласса, но обратите внимание, что это может привести к поломке программ из-за внутреннего вызова метода self.

Синтаксис

undef method-name

пример

Чтобы отменить определение метода под названием bar, сделайте следующее:

undef bar

Вы видели, как Ruby определяет методы, в которые вы можете поместить несколько операторов, а затем вызвать этот метод. Точно так же в Ruby есть концепция блока.

  • Блок состоит из фрагментов кода.

  • Вы назначаете имя блоку.

  • Код в блоке всегда заключен в фигурные скобки ({}).

  • Блок всегда вызывается из функции с тем же именем, что и у блока. Это означает, что если у вас есть блок с именем test , вы используете функциональный тест для вызова этого блока.

  • Вы вызываете блок с помощью оператора yield .

Синтаксис

block_name {
   statement1
   statement2
   ..........
}

Здесь вы научитесь вызывать блок с помощью простого оператора yield . Вы также научитесь использовать оператор yield с параметрами для вызова блока. Вы проверите образец кода с обоими типами операторов yield .

Заявление о доходности

Давайте посмотрим на пример заявления yield -

#!/usr/bin/ruby

def test
   puts "You are in the method"
   yield
   puts "You are again back to the method"
   yield
end
test {puts "You are in the block"}

Это даст следующий результат -

You are in the method
You are in the block
You are again back to the method
You are in the block

Вы также можете передавать параметры с помощью оператора yield. Вот пример -

#!/usr/bin/ruby

def test
   yield 5
   puts "You are in the method test"
   yield 100
end
test {|i| puts "You are in the block #{i}"}

Это даст следующий результат -

You are in the block 5
You are in the method test
You are in the block 100

Здесь записывается оператор yield, за которым следуют параметры. Вы даже можете передать более одного параметра. В блоке вы помещаете переменную между двумя вертикальными линиями (||), чтобы принять параметры. Поэтому в предыдущем коде оператор yield 5 передает значение 5 в качестве параметра в тестовый блок.

Теперь посмотрите на следующее утверждение -

test {|i| puts "You are in the block #{i}"}

Здесь значение 5 получено в переменной i . Теперь обратите внимание на следующий оператор put -

puts "You are in the block #{i}"

Результат этого оператора put :

You are in the block 5

Если вы хотите передать более одного параметра, тогда оператор yield становится -

yield a, b

а блок -

test {|a, b| statement}

Параметры будут разделены запятыми.

Блоки и методы

Вы видели, как блок и метод могут быть связаны друг с другом. Обычно вы вызываете блок с помощью оператора yield из метода, имя которого совпадает с именем блока. Поэтому вы пишете -

#!/usr/bin/ruby

def test
   yield
end
test{ puts "Hello world"}

Этот пример - самый простой способ реализовать блок. Вы вызываете тестовый блок с помощью оператора yield .

Но если последнему аргументу метода предшествует &, вы можете передать блок этому методу, и этот блок будет назначен последнему параметру. Если в списке аргументов присутствуют и *, и &, & должен появиться позже.

#!/usr/bin/ruby

def test(&block)
   block.call
end
test { puts "Hello World!"}

Это даст следующий результат -

Hello World!

Блоки BEGIN и END

Каждый исходный файл Ruby может объявлять блоки кода, которые будут запускаться при загрузке файла (блоки BEGIN) и после завершения выполнения программы (блоки END).

#!/usr/bin/ruby

BEGIN { 
   # BEGIN block code 
   puts "BEGIN code block"
} 

END { 
   # END block code 
   puts "END code block"
}
   # MAIN block code 
puts "MAIN code block"

Программа может включать в себя несколько блоков BEGIN и END. Блоки BEGIN выполняются в том порядке, в котором они встречаются. Блоки END выполняются в обратном порядке. При выполнении вышеуказанная программа дает следующий результат -

BEGIN code block
MAIN code block
END code block

Модули - это способ группировки методов, классов и констант. Модули дают вам два основных преимущества.

  • Модули предоставляют пространство имен и предотвращают конфликты имен .

  • Модули реализуют возможность микширования .

Модули определяют пространство имен, «песочницу», в которой ваши методы и константы могут играть, не беспокоясь о том, что на них наступят другие методы и константы.

Синтаксис

module Identifier
   statement1
   statement2
   ...........
end

Константы модуля называются так же, как константы класса, с начальной буквы в верхнем регистре. Определения методов тоже выглядят одинаково: методы модуля определяются так же, как методы класса.

Как и в случае с методами класса, вы вызываете метод модуля, предваряя его имя именем модуля и точкой, и вы ссылаетесь на константу, используя имя модуля и два двоеточия.

пример

#!/usr/bin/ruby

# Module defined in trig.rb file

module Trig
   PI = 3.141592654
   def Trig.sin(x)
   # ..
   end
   def Trig.cos(x)
   # ..
   end
end

Мы можем определить еще один модуль с тем же именем функции, но с другой функциональностью -

#!/usr/bin/ruby

# Module defined in moral.rb file

module Moral
   VERY_BAD = 0
   BAD = 1
   def Moral.sin(badness)
   # ...
   end
end

Как и методы класса, всякий раз, когда вы определяете метод в модуле, вы указываете имя модуля, за которым следует точка, а затем имя метода.

Заявление Ruby require

Оператор require аналогичен оператору include C и C ++ и оператору импорта Java. Если третья программа хочет использовать какой-либо определенный модуль, она может просто загрузить файлы модуля с помощью инструкции Ruby require -

Синтаксис

require filename

Здесь указывать .rb расширение вместе с именем файла.

пример

$LOAD_PATH << '.'

require 'trig.rb'
require 'moral'

y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

Здесь мы используем $LOAD_PATH << '.'чтобы Ruby знал, что включенные файлы нужно искать в текущем каталоге. Если вы не хотите использовать $ LOAD_PATH, вы можете использоватьrequire_relative для включения файлов из относительного каталога.

IMPORTANT- Здесь оба файла содержат одно и то же имя функции. Таким образом, это приведет к неоднозначности кода при включении в вызывающую программу, но модули избегают этой неоднозначности кода, и мы можем вызвать соответствующую функцию, используя имя модуля.

Заявление о включении Ruby

Вы можете встроить модуль в класс. Чтобы встроить модуль в класс, вы используете оператор include в классе -

Синтаксис

include modulename

Если модуль определен в отдельном файле, то перед внедрением модуля в класс необходимо включить этот файл с помощью оператора require .

пример

Рассмотрим следующий модуль, записанный в файле support.rb .

module Week
   FIRST_DAY = "Sunday"
   def Week.weeks_in_month
      puts "You have four weeks in a month"
   end
   def Week.weeks_in_year
      puts "You have 52 weeks in a year"
   end
end

Теперь вы можете включить этот модуль в класс следующим образом:

#!/usr/bin/ruby
$LOAD_PATH << '.'
require "support"

class Decade
include Week
   no_of_yrs = 10
   def no_of_months
      puts Week::FIRST_DAY
      number = 10*12
      puts number
   end
end
d1 = Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months

Это даст следующий результат -

Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120

Миксины в Ruby

Прежде чем перейти к этому разделу, мы предполагаем, что вы знакомы с объектно-ориентированными концепциями.

Когда класс может наследовать функции более чем одного родительского класса, предполагается, что у этого класса будет множественное наследование.

Ruby не поддерживает множественное наследование напрямую, но у модулей Ruby есть еще одно замечательное применение. Одним махом они в значительной степени устраняют необходимость множественного наследования, предоставляя возможность, называемую миксином .

Миксины дают вам чудесно управляемый способ добавления функциональности в классы. Однако их истинная сила проявляется, когда код в миксине начинает взаимодействовать с кодом в классе, который его использует.

Давайте рассмотрим следующий пример кода, чтобы понять миксин:

module A
   def a1
   end
   def a2
   end
end
module B
   def b1
   end
   def b2
   end
end

class Sample
include A
include B
   def s1
   end
end

samp = Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1

Модуль A состоит из методов a1 и a2. Модуль B состоит из методов b1 и b2. Класс Sample включает оба модуля A и B. Класс Sample может получить доступ ко всем четырем методам, а именно a1, a2, b1 и b2. Таким образом, вы можете видеть, что класс Sample наследуется от обоих модулей. Таким образом, можно сказать, что образец класса показывает множественное наследование или миксин .

Объект String в Ruby содержит и управляет произвольной последовательностью из одного или нескольких байтов, обычно представляющих символы, представляющие человеческий язык.

Простейшие строковые литералы заключаются в одинарные кавычки (символ апострофа). Текст в кавычках - это значение строки -

'This is a simple Ruby string literal'

Если вам нужно поместить апостроф в строковый литерал, заключенный в одинарные кавычки, поставьте перед ним обратную косую черту, чтобы интерпретатор Ruby не подумал, что он завершает строку -

'Won\'t you read O\'Reilly\'s book?'

Обратная косая черта также позволяет избежать другой обратной косой черты, так что вторая обратная косая черта сама по себе не интерпретируется как escape-символ.

Ниже приведены особенности Ruby, связанные со строками.

Замена выражения

Подстановка выражений - это способ встраивания значения любого выражения Ruby в строку с использованием # {и} -

#!/usr/bin/ruby

x, y, z = 12, 36, 72
puts "The value of x is #{ x }."
puts "The sum of x and y is #{ x + y }."
puts "The average was #{ (x + y + z)/3 }."

Это даст следующий результат -

The value of x is 12.
The sum of x and y is 48.
The average was 40.

Общие строки с разделителями

С помощью общих строк с разделителями вы можете создавать строки внутри пары совпадающих символов с произвольными разделителями, например,!, (, {, <И т. Д., Которым предшествует символ процента (%). Q, q и x имеют особое значение . Общие строки с разделителями могут быть -

%{Ruby is fun.}  equivalent to "Ruby is fun."
%Q{ Ruby is fun. } equivalent to " Ruby is fun. "
%q[Ruby is fun.]  equivalent to a single-quoted string
%x!ls! equivalent to back tick command output `ls`

Персонажи побега

NOTE- В строке, заключенной в двойные кавычки, интерпретируется escape-символ; в строке, заключенной в одинарные кавычки, сохраняется escape-символ.

Обозначение обратной косой черты Шестнадцатеричный символ Описание
\ а 0x07 Звонок или тревога
\ b 0x08 Backspace
\ cx   Ctrl-x
\ Cx   Ctrl-x
\ е 0x1b Побег
\ f 0x0c Formfeed
\ M- \ Cx   Мета-Control-x
\ п 0x0a Новая линия
\ nnn   Восьмеричная запись, где n находится в диапазоне 0,7
0x0d Возврат каретки
\ s 0x20 Космос
\ т 0x09 Вкладка
\ v 0x0b Вертикальная табуляция
\Икс   Символ x
\ xnn   Шестнадцатеричное представление, где n находится в диапазоне 0,9, af или AF.

Кодировка символов

Набор символов по умолчанию для Ruby - ASCII, символы которого могут быть представлены одиночными байтами. Если вы используете UTF-8 или другой современный набор символов, символы могут быть представлены от одного до четырех байтов.

Вы можете изменить свой набор символов, используя $ KCODE в начале вашей программы, например:

$KCODE = 'u'
Sr.No. Код и описание
1

a

ASCII (то же, что нет). Это значение по умолчанию.

2

e

EUC.

3

n

Нет (как ASCII).

4

u

UTF-8.

Встроенные строковые методы

Нам нужен экземпляр объекта String для вызова метода String. Ниже приведен способ создания экземпляра объекта String.

new [String.new(str = "")]

Это вернет новый строковый объект, содержащий копию str . Теперь, используя объект str , мы все можем использовать любые доступные методы экземпляра. Например -

#!/usr/bin/ruby

myStr = String.new("THIS IS TEST")
foo = myStr.downcase

puts "#{foo}"

Это даст следующий результат -

this is test
Sr.No. Методы и описание
1

str % arg

Форматирует строку, используя спецификацию формата. arg должен быть массивом, если он содержит более одной замены. Для получения информации о спецификации формата см. Sprintf в разделе «Модуль ядра».

2

str * integer

Возвращает новую строку, содержащую целое число, умноженное на str. Другими словами, str повторяется целое число раз.

3

str + other_str

Объединяет other_str в str.

4

str << obj

Присоединяет объект к str. Если объект является Fixnum в диапазоне 0,255, он преобразуется в символ. Сравните это с concat.

5

str <=> other_str

Сравнивает str с other_str, возвращая -1 (меньше), 0 (равно) или 1 (больше). При сравнении учитывается регистр.

6

str == obj

Проверяет str и obj на равенство. Если obj не является String, возвращает false; возвращает истину, если str <=> obj возвращает 0.

7

str =~ obj

Сопоставляет str с шаблоном регулярного выражения obj. Возвращает позицию начала матча; в противном случае - ложь.

8

str.capitalize

Делает строку заглавной.

9

str.capitalize!

То же, что и заглавные буквы, но изменения вносятся на месте.

10

str.casecmp

Выполняет сравнение строк без учета регистра.

11

str.center

Центрирует строку.

12

str.chomp

Удаляет разделитель записей ($ /), обычно \ n, из конца строки. Если разделитель записей не существует, ничего не делает.

13

str.chomp!

То же, что и chomp, но изменения вносятся на месте.

14

str.chop

Удаляет последний символ в str.

15

str.chop!

То же, что и chop, но изменения вносятся на месте.

16

str.concat(other_str)

Объединяет other_str в str.

17

str.count(str, ...)

Считает один или несколько наборов символов. Если существует более одного набора символов, считается пересечение этих наборов.

18

str.crypt(other_str)

Применяет односторонний криптографический хеш к str. Аргументом является строка соли, которая должна состоять из двух символов, каждый из которых находится в диапазоне az, AZ, 0.9,. или же /.

19

str.delete(other_str, ...)

Возвращает копию str со всеми удаленными символами на пересечении аргументов.

20

str.delete!(other_str, ...)

То же, что и удаление, но изменения вносятся на месте.

21 год

str.downcase

Возвращает копию str, в которой все прописные буквы заменены строчными.

22

str.downcase!

То же, что и нижний регистр, но изменения вносятся на месте.

23

str.dump

Возвращает версию str, в которой все непечатаемые символы заменены нотацией \ nnn, а все специальные символы экранированы.

24

str.each(separator = $/) { |substr| block }

Разделяет str, используя аргумент в качестве разделителя записей (по умолчанию $ /), передавая каждую подстроку в предоставленный блок.

25

str.each_byte { |fixnum| block }

Передает каждый байт из str в блок, возвращая каждый байт как десятичное представление байта.

26

str.each_line(separator=$/) { |substr| block }

Разделяет str, используя аргумент в качестве разделителя записей (по умолчанию $ /), передавая каждую подстроку в предоставленный блок.

27

str.empty?

Возвращает истину, если строка пуста (имеет нулевую длину).

28

str.eql?(other)

Две строки равны, если они имеют одинаковую длину и содержание.

29

str.gsub(pattern, replacement) [or]

str.gsub(pattern) { |match| block }

Возвращает копию str, в которой все вхождения шаблона заменены либо на замену, либо на значение блока. Шаблон обычно будет Regexp; если это строка, то метасимволы регулярного выражения не будут интерпретироваться (то есть / \ d / будет соответствовать цифре, но '\ d' будет соответствовать обратной косой черте, за которой следует 'd')

30

str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]

Ссылается на str, используя следующие аргументы: один Fixnum, возвращает код символа в fixnum; два фиксированных числа, возвращает подстроку, начиная со смещения (первое фиксированное число) до длины (второе фиксированное число); диапазон, возвращает подстроку в диапазоне; regexp возвращает часть совпавшей строки; regexp с fixnum, возвращает совпадающие данные с fixnum; other_str возвращает подстроку, соответствующую other_str. Отрицательное Fixnum начинается в конце строки с -1.

31 год

str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] = new_str [or] str[regexp, fixnum] = new_str [or] str[other_str] = new_str ]

Заменить (назначить) всю строку или ее часть. Синоним ломтика !.

32

str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match|block }

Выполняет замены String # gsub на месте, возвращая str или nil, если подстановки не выполнялись.

33

str.hash

Возвращает хэш на основе длины и содержимого строки.

34

str.hex

Обрабатывает ведущие символы из str как строку шестнадцатеричных цифр (с необязательным знаком и необязательным 0x) и возвращает соответствующее число. При ошибке возвращается ноль.

35 год

str.include? other_str [or] str.include? fixnum

Возвращает истину, если str содержит заданную строку или символ.

36

str.index(substring [, offset]) [or]

str.index(fixnum [, offset]) [or]

str.index(regexp [, offset])

Возвращает индекс первого вхождения данной подстроки, символа (fixnum) или шаблона (regexp) в str. Если не найдено, возвращает ноль. Если присутствует второй параметр, он указывает позицию в строке для начала поиска.

37

str.insert(index, other_str)

Вставляет other_str перед символом по данному индексу, изменяя str. Отрицательные индексы отсчитываются от конца строки и вставляются после заданного символа. Намерение состоит в том, чтобы вставить строку так, чтобы она начиналась с данного индекса.

38

str.inspect

Возвращает версию str для печати с экранированными специальными символами.

39

str.intern [or] str.to_sym

Возвращает символ, соответствующий str, создавая символ, если он ранее не существовал.

40

str.length

Возвращает длину str. Сравните размер.

41 год

str.ljust(integer, padstr = ' ')

Если integer больше длины str, возвращает новую строку длины integer с выравниванием str по левому краю и дополнением padstr; в противном случае возвращает str.

42

str.lstrip

Возвращает копию str с удаленными ведущими пробелами.

43 год

str.lstrip!

Удаляет начальные пробелы из str, возвращая nil, если не было сделано никаких изменений.

44

str.match(pattern)

Преобразует шаблон в Regexp (если это еще не так), затем вызывает его метод сопоставления для str.

45

str.oct

Обрабатывает ведущие символы str как строку восьмеричных цифр (с необязательным знаком) и возвращает соответствующее число. Возвращает 0, если преобразование не удалось.

46

str.replace(other_str)

Заменяет содержимое и испорченность str соответствующими значениями в other_str.

47

str.reverse

Возвращает новую строку с символами из str в обратном порядке.

48

str.reverse!

Меняет str на место.

49

str.rindex(substring [, fixnum]) [or]

str.rindex(fixnum [, fixnum]) [or]

str.rindex(regexp [, fixnum])

Возвращает индекс последнего вхождения данной подстроки, символа (fixnum) или шаблона (regexp) в str. Если не найдено, возвращает ноль. Если присутствует второй параметр, он указывает позицию в строке для завершения поиска. Символы за пределами этой точки не будут учитываться.

50.

str.rjust(integer, padstr = ' ')

Если integer больше длины str, возвращает новую строку длины integer с выравниванием str по правому краю и дополнением padstr; в противном случае возвращает str.

51

str.rstrip

Возвращает копию str с удаленными конечными пробелами.

52

str.rstrip!

Удаляет завершающие пробелы из str, возвращая nil, если не было сделано никаких изменений.

53

str.scan(pattern) [or]

str.scan(pattern) { |match, ...| block }

Обе формы повторяются через str в соответствии с шаблоном (который может быть Regexp или String). Для каждого совпадения генерируется результат, который либо добавляется в массив результатов, либо передается в блок. Если в шаблоне нет групп, каждый отдельный результат состоит из совпадающей строки $ &. Если шаблон содержит группы, каждый отдельный результат сам по себе представляет собой массив, содержащий по одной записи на группу.

54

str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or]

str.slice(range) [or] str.slice(regexp) [or]

str.slice(regexp, fixnum) [or] str.slice(other_str)

See str[fixnum], etc.

str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or]

str.slice!(range) [or] str.slice!(regexp) [or]

str.slice!(other_str)

Удаляет указанную часть из str и возвращает удаленную часть. Формы, которые принимают Fixnum, вызовут IndexError, если значение вне допустимого диапазона; форма Range вызовет RangeError, а формы Regexp и String молча игнорируют присвоение.

55

str.split(pattern = $, [limit])

Делит строку на подстроки на основе разделителя, возвращая массив этих подстрок.

Если шаблон является строкой, то ее содержимое используется в качестве разделителя при разделении str. Если шаблон представляет собой одиночный пробел, str разбивается на пробелы, при этом ведущие пробелы и серии непрерывных пробельных символов игнорируются.

Если pattern - это Regexp, str делится там, где соответствует шаблон. Каждый раз, когда шаблон соответствует строке нулевой длины, str разбивается на отдельные символы.

Если шаблон не указан, значение$; is used. If $; равно нулю (по умолчанию), str разбивается на пробелы, как если бы были указаны ``.

Если параметр limit опущен, завершающие пустые поля подавляются. Если limit является положительным числом, будет возвращено не более того количества полей (если limit равен 1, вся строка возвращается как единственная запись в массиве). Если отрицательный, нет ограничения на количество возвращаемых полей, и завершающие пустые поля не подавляются.

56

str.squeeze([other_str]*)

Создает набор символов из параметра (ов) other_str, используя процедуру, описанную для String # count. Возвращает новую строку, в которой строки одного и того же символа, встречающиеся в этом наборе, заменяются одним символом. Если аргументы не указаны, все серии одинаковых символов заменяются одним символом.

57

str.squeeze!([other_str]*)

Сжимает str на месте, возвращая либо str, либо nil, если не было сделано никаких изменений.

58

str.strip

Возвращает копию str с удаленными начальными и конечными пробелами.

59

str.strip!

Удаляет начальные и конечные пробелы из str. Возвращает nil, если str не изменялась.

60

str.sub(pattern, replacement) [or]

str.sub(pattern) { |match| block }

Возвращает копию str с заменой первого вхождения шаблона либо на замену, либо на значение блока. Шаблон обычно будет Regexp; если это строка, то метасимволы регулярного выражения не будут интерпретироваться.

61

str.sub!(pattern, replacement) [or]

str.sub!(pattern) { |match| block }

Выполняет замены String # sub на месте, возвращая str или nil, если подстановки не выполнялись.

62

str.succ [or] str.next

Возвращает преемника str.

63

str.succ! [or] str.next!

Эквивалентен String # succ, но изменяет получатель на месте.

64

str.sum(n = 16)

Возвращает базовую n-битную контрольную сумму символов в str, где n - необязательный параметр Fixnum, по умолчанию равный 16. Результатом является просто сумма двоичного значения каждого символа в str по модулю 2n - 1. Это не особенно хорошая контрольная сумма.

65

str.swapcase

Возвращает копию str с буквенными символами верхнего регистра, преобразованными в символы нижнего регистра, и символы нижнего регистра, преобразованными в символы верхнего регистра.

66

str.swapcase!

Эквивалентно String # swapcase, но изменяет получатель на месте, возвращая str или nil, если не было сделано никаких изменений.

67

str.to_f

> Возвращает результат интерпретации начальных символов в str как числа с плавающей запятой. Посторонние символы после конца допустимого числа игнорируются. Если в начале str нет действительного числа, возвращается 0,0. Этот метод никогда не вызывает исключения.

68

str.to_i(base = 10)

Возвращает результат интерпретации ведущих символов в str как целочисленного основания (основание 2, 8, 10 или 16). Посторонние символы после конца допустимого числа игнорируются. Если в начале str нет действительного числа, возвращается 0. Этот метод никогда не вызывает исключения.

69

str.to_s [or] str.to_str

Возвращает получателя.

70

str.tr(from_str, to_str)

Возвращает копию str с символами в from_str, замененными соответствующими символами в to_str. Если to_str короче from_str, он дополняется последним символом. Обе строки могут использовать нотацию c1.c2 для обозначения диапазонов символов, а from_str может начинаться с символа ^, который обозначает все символы, кроме перечисленных.

71

str.tr!(from_str, to_str)

Переводит str на место, используя те же правила, что и String # tr. Возвращает str или nil, если изменений не было.

72

str.tr_s(from_str, to_str)

Обрабатывает копию str, как описано в разделе String # tr, затем удаляет повторяющиеся символы в регионах, на которые повлияла трансляция.

73

str.tr_s!(from_str, to_str)

Выполняет обработку String # tr_s для str на месте, возвращая str или nil, если не было сделано никаких изменений.

74

str.unpack(format)

> Декодирует строку str (которая может содержать двоичные данные) в соответствии со строкой формата, возвращая массив каждого извлеченного значения. Строка формата состоит из последовательности односимвольных директив, обобщенных в Таблице 18. За каждой директивой может следовать номер, указывающий, сколько раз повторяется с этой директивой. Звездочка (*) использует все оставшиеся элементы. Каждая директива sSiIlL может сопровождаться знаком подчеркивания (_), чтобы использовать собственный размер базовой платформы для указанного типа; в противном случае используется согласованный размер, не зависящий от платформы. Пробелы в строке формата игнорируются.

75

str.upcase

Возвращает копию str, в которой все строчные буквы заменены прописными. Операция не зависит от языкового стандарта. Затрагиваются только символы от a до z.

76

str.upcase!

Изменяет содержимое str на верхний регистр, возвращая nil, если не было сделано никаких изменений.

77

str.upto(other_str) { |s| block }

Перебирает последовательные значения, начиная с str и заканчивая other_str включительно, передавая каждое значение по очереди блоку. Для создания каждого значения используется метод String # succ.

Директивы распаковки строк

Директива Возврат Описание
А Строка С удалением конечных нулей и пробелов.
а Строка Строка.
B Строка Извлекает биты из каждого символа (сначала старший бит).
б Строка Извлекает биты из каждого символа (сначала младший бит).
C Fixnum Извлекает символ как целое число без знака.
c Fixnum Извлекает символ как целое число.
D, d Плавать Обрабатывает символы sizeof (double) как собственные двойные.
E Плавать Обрабатывает символы sizeof (double) как двойные в порядке младших байтов.
е Плавать Обрабатывает символы sizeof (float) как float в младшем байтовом порядке.
F, F Плавать Обрабатывает символы sizeof (float) как собственные float.
г Плавать Обрабатывает sizeof (double) символов как double в сетевом порядке байтов.
г Строка Обрабатывает символы sizeof (float) как float в сетевом порядке байтов.
ЧАС Строка Извлекает шестнадцатеричные полубайты из каждого символа (сначала старший бит)
час Строка Извлекает шестнадцатеричные полубайты из каждого символа (сначала младший бит).
я Целое число Обрабатывает sizeof (int) (изменено на _) последовательные символы как беззнаковое собственное целое число.
я Целое число Обрабатывает sizeof (int) (изменено на _) последовательные символы как собственное целое число со знаком.
L Целое число Обрабатывает четыре (измененных _) последовательных символа как собственное длинное целое число без знака.
л Целое число Обрабатывает четыре (измененных _) последовательных символа как собственное длинное целое число со знаком.
M Строка Цитата-печать.
м Строка В кодировке Base64.
N Целое число Считает четыре символа длинными в сетевом порядке байтов беззнаковым длинным.
п Fixnum Считает два символа беззнаковым коротким в сетевом порядке байтов.
п Строка Обрабатывает символы sizeof (char *) как указатель и возвращает символы \ emph {len} из указанного места.
п Строка Обрабатывает символы sizeof (char *) как указатель на строку с завершающим нулем.
Q Целое число Считает восемь символов беззнаковым четверным словом (64 бита).
q Целое число Обрабатывает восемь символов как четверное слово со знаком (64 бита).
S Fixnum Обрабатывает два (разных, если используется _) последовательных символа как беззнаковое сокращение в собственном порядке байтов.
s Fixnum Обрабатывает два (разных, если используется _) последовательных символа как короткое со знаком в собственном порядке байтов.
U Целое число Символы UTF-8 как целые числа без знака.
ты Строка UU-кодированный.
V Fixnum Считает четыре символа длинными без знака в порядке байтов с прямым порядком байтов.
v Fixnum Считает два символа короткими без знака в порядке байтов с прямым порядком байтов.
ш Целое число BER-сжатое целое число.
Икс   Переход на один символ назад.
Икс   Переход на один символ вперед.
Z Строка С удалением конечных нулей до первого нуля с помощью *.
@   Переход к смещению, заданному аргументом длины.

пример

Попробуйте следующий пример, чтобы распаковать различные данные.

"abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3')           #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*')       #=> ["abc ", "abc "]
"aa".unpack('b8B8')                 #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c')               #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS')     #=> [-2, 65534]
"now = 20is".unpack('M*')           #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]

Массивы Ruby - это упорядоченные коллекции любого объекта с целочисленным индексом. Каждый элемент в массиве связан с индексом и упоминается по нему.

Индексация массива начинается с 0, как в C или Java. Отрицательный индекс предполагается относительно конца массива, то есть индекс -1 указывает последний элемент массива, -2 - предпоследний элемент в массиве и т. Д.

Массивы Ruby могут содержать такие объекты, как String, Integer, Fixnum, Hash, Symbol и даже другие объекты Array. Массивы Ruby не такие жесткие, как массивы в других языках. Массивы Ruby автоматически увеличиваются при добавлении к ним элементов.

Создание массивов

Есть много способов создать или инициализировать массив. Один из способов - использовать новый метод класса -

names = Array.new

Вы можете установить размер массива во время создания массива -

names = Array.new(20)

Имена массивов теперь имеют размер или длину 20 элементов. Вы можете вернуть размер массива с помощью методов размера или длины -

#!/usr/bin/ruby

names = Array.new(20)
puts names.size  # This returns 20
puts names.length # This also returns 20

Это даст следующий результат -

20
20

Вы можете присвоить значение каждому элементу в массиве следующим образом:

#!/usr/bin/ruby

names = Array.new(4, "mac")
puts "#{names}"

Это даст следующий результат -

["mac", "mac", "mac", "mac"]

Вы также можете использовать блок с новым, заполняя каждый элемент тем, что оценивает блок -

#!/usr/bin/ruby

nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"

Это даст следующий результат -

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Есть еще один метод Array, []. Это работает так -

nums = Array.[](1, 2, 3, 4,5)

Еще одна форма создания массива следующая:

nums = Array[1, 2, 3, 4,5]

Модуль ядра, доступный в ядре Ruby, имеет метод Array, который принимает только один аргумент. Здесь метод принимает диапазон в качестве аргумента для создания массива цифр -

#!/usr/bin/ruby

digits = Array(0..9)
puts "#{digits}"

Это даст следующий результат -

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Встроенные методы массива

Нам нужен экземпляр объекта Array для вызова метода Array. Как мы видели, следующий способ создать экземпляр объекта Array:

Array.[](...) [or] Array[...] [or] [...]

Это вернет новый массив, заполненный данными объектами. Теперь, используя созданный объект, мы можем вызывать любые доступные методы экземпляра. Например -

#!/usr/bin/ruby

digits = Array(0..9)
num = digits.at(6)
puts "#{num}"

Это даст следующий результат -

6
Sr.No. Методы и описание
1

array & other_array

Возвращает новый массив, содержащий элементы, общие для двух массивов, без дубликатов.

2

array * int [or] array * str

Возвращает новый массив, построенный путем объединения копий int типа self. С аргументом String, эквивалентным self.join (str).

3

array + other_array

Возвращает новый массив, построенный путем объединения двух массивов вместе для создания третьего массива.

4

array - other_array

Возвращает новый массив, который является копией исходного массива, удаляя все элементы, которые также появляются в other_array.

5

array <=> other_array

Сравнивает str с other_str, возвращая -1 (меньше), 0 (равно) или 1 (больше). При сравнении учитывается регистр.

6

array | other_array

Возвращает новый массив, объединяя массив с other_array, удаляя дубликаты.

7

array << obj

Помещает данный объект в конец массива. Это выражение возвращает сам массив, поэтому несколько добавлений могут быть связаны вместе.

8

array <=> other_array

Возвращает целое число (-1, 0 или +1), если этот массив меньше, равен или больше other_array.

9

array == other_array

Два массива равны, если они содержат одинаковое количество элементов и если каждый элемент равен (согласно Object. ==) соответствующему элементу в другом массиве.

10

array[index] [or] array[start, length] [or]

array[range] [or] array.slice(index) [or]

array.slice(start, length) [or] array.slice(range)

Возвращает элемент по индексу или возвращает подмассив, начинающийся с начала и продолжающийся для элементов длины , или возвращает подмассив, указанный диапазоном . Отрицательные индексы считаются в обратном порядке от конца массива (-1 - последний элемент). Возвращает nil, если индекс (или начальный индекс) выходит за пределы допустимого диапазона.

11

array[index] = obj [or]

array[start, length] = obj or an_array or nil [or]

array[range] = obj or an_array or nil

Устанавливает элемент по индексу или заменяет подмассив, начинающийся с начала и продолжающийся для элементов длины , или заменяет подмассив, указанный диапазоном . Если индексы превышают текущую емкость массива, массив автоматически увеличивается. Отрицательные индексы будут отсчитываться в обратном порядке от конца массива. Вставляет элементы, если длина равна нулю. Если nil используется во второй и третьей форме, удаляет элементы из self .

12

array.abbrev(pattern = nil)

Вычисляет набор однозначных сокращений для строк в self . Если передан шаблон или строка, учитываются только строки, соответствующие шаблону или начинающиеся со строки.

13

array.assoc(obj)

Выполняет поиск в массиве, элементы которого также являются массивами, сравнивая obj с первым элементом каждого содержащегося массива, используя obj. ==. Возвращает первый содержащий совпадение массив или ноль, если совпадение не найдено.

14

array.at(index)

Возвращает элемент по индексу. Отрицательный индекс отсчитывается от конца self. Возвращает ноль, если индекс вне допустимого диапазона.

15

array.clear

Удаляет все элементы из массива.

16

array.collect { |item| block } [or]

array.map { |item| block }

Вызывает блок один раз для каждого элемента self . Создает новый массив, содержащий значения, возвращаемые блоком.

17

array.collect! { |item| block } [or]

array.map! { |item| block }

Вызывает блок один раз для каждого элемента self , заменяя элемент значением, возвращаемым блоком .

18

array.compact

Возвращает копию self со всеми удаленными элементами nil .

19

array.compact!

Удаляет нулевые элементы из массива. Возвращает ноль, если никаких изменений не было.

20

array.concat(other_array)

Добавляет элементы в other_array к self .

21 год

array.delete(obj) [or]

array.delete(obj) { block }

Удаляет из себя элементы , которые равны obj . Если элемент не найден, возвращается ноль . Если указан дополнительный блок кода , возвращает результат блока, если элемент не найден.

22

array.delete_at(index)

Удаляет элемент по указанному индексу , возвращая этот элемент, или nil, если индекс выходит за пределы допустимого диапазона.

23

array.delete_if { |item| block }

Удаляет каждый элемент self, для которого блок имеет значение true.

24

array.each { |item| block }

Вызывает блок один раз для каждого элемента в self , передавая этот элемент в качестве параметра.

25

array.each_index { |index| block }

То же, что и Array # each, но передает индекс элемента вместо самого элемента.

26

array.empty?

Возвращает true, если массив self не содержит элементов.

27

array.eql?(other)

Возвращает истину, если array и other являются одним и тем же объектом или оба массива с одинаковым содержимым.

28

array.fetch(index) [or]

array.fetch(index, default) [or]

array.fetch(index) { |index| block }

Пытается вернуть элемент в позиции index . Если индекс находится вне массива, первая форма выдает исключение IndexError , вторая форма возвращает значение по умолчанию , а третья форма возвращает значение вызывающего блока , передавая индекс . Отрицательные значения индекса отсчитывают от конца массива.

29

array.fill(obj) [or]

array.fill(obj, start [, length]) [or]

array.fill(obj, range) [or]

array.fill { |index| block } [or]

array.fill(start [, length] ) { |index| block } [or]

array.fill(range) { |index| block }

Первые три формы устанавливают для выбранных элементов self значение obj . Начало с нуля эквивалентно нулю. Длина nil эквивалентна self.length . Последние три формы заполняют массив значением блока. Блок передается с абсолютный индекс каждого элемента, подлежащего заполнению.

30

array.first [or]

array.first(n)

Возвращает первый элемент или первые n элементов массива. Если массив пуст, первая форма возвращает ноль , а вторая форма возвращает пустой массив.

31 год

array.flatten

Возвращает новый массив, который является одномерным сглаживанием этого массива (рекурсивно).

32

array.flatten!

Сглаживает массив на месте. Возвращает ноль, если никаких изменений не было. (массив не содержит подмассивов.)

33

array.frozen?

Возвращает истину, если массив заморожен (или временно заморожен во время сортировки).

34

array.hash

Вычисляет хэш-код для массива. Два массива с одинаковым содержимым будут иметь одинаковый хэш-код.

35 год

array.include?(obj)

Возвращает true, если obj присутствует в self , иначе false.

36

array.index(obj)

Возвращает индекс первого объекта в self, который == для obj. Возвращает ноль, если совпадений не найдено.

37

array.indexes(i1, i2, ... iN) [or]

array.indices(i1, i2, ... iN)

Эти методы устарели в последней версии Ruby, поэтому используйте Array # values_at.

38

array.indices(i1, i2, ... iN) [or]

array.indexes(i1, i2, ... iN)

Эти методы устарели в последней версии Ruby, поэтому используйте Array # values_at.

39

array.insert(index, obj...)

Вставляет заданные значения перед элементом с заданным индексом (который может быть отрицательным).

40

array.inspect

Создает версию массива для печати.

41 год

array.join(sep = $,)

Возвращает строку, созданную преобразованием каждого элемента массива в строку, разделенную sep .

42

array.last [or] array.last(n)

Возвращает последний элемент (ы) self . Если массив пуст , первая форма возвращает ноль .

43 год

array.length

Возвращает количество элементов в себе . Может быть нулевым.

44

array.map { |item| block } [or]

array.collect { |item| block }

Вызывает блок один раз для каждого элемента self . Создает новый массив, содержащий значения, возвращаемые блоком.

45

array.map! { |item| block } [or]

array.collect! { |item| block }

Вызывает блок один раз для каждого элемента массива , заменяя элемент значением, возвращаемым блоком.

46

array.nitems

Возвращает количество ненулевых элементов в self . Может быть нулевым.

47

array.pack(aTemplateString)

Упаковывает содержимое массива в двоичную последовательность в соответствии с директивами в TemplateString. За директивами A, a и Z может следовать счетчик, который дает ширину результирующего поля. Остальные директивы также могут иметь счетчик, указывающий количество элементов массива для преобразования. Если счетчик отмечен звездочкой (*), все оставшиеся элементы массива будут преобразованы. Любая из директив по-прежнему может сопровождаться знаком подчеркивания (_), чтобы использовать собственный размер базовой платформы для указанного типа; в противном случае они используют размер, не зависящий от платформы. Пробелы в строке шаблона игнорируются.

48

array.pop

Удаляет последний элемент из массива и возвращает его или nil, если массив пуст.

49

array.push(obj, ...)

Помещает (добавляет) заданный объект в конец этого массива. Это выражение возвращает сам массив, поэтому несколько добавлений могут быть связаны вместе.

50

array.rassoc(key)

Выполняет поиск в массиве, элементы которого также являются массивами. Сравнивает ключ со вторым элементом каждого содержащегося массива, используя ==. Возвращает первый совпадающий содержащийся массив.

51

array.reject { |item| block }

Возвращает новый массив , содержащий всевозможное массив , для которого блок не является истинным .

52

array.reject! { |item| block }

Удаляет элементы из массива, для которых блок имеет значение true , но возвращает ноль, если не было сделано никаких изменений. Эквивалентно массиву # delete_if.

53

array.replace(other_array)

Заменяет содержимое массива содержимым other_array , усекая или расширяя при необходимости.

54

array.reverse

Возвращает новый массив, содержащий элементы массива в обратном порядке.

55

array.reverse!

Переворачивает массив на место.

56

array.reverse_each {|item| block }

То же, что и Array # each, но пересекает массив в обратном порядке.

57

array.rindex(obj)

Возвращает индекс последнего объекта в массиве == в obj. Возвращает ноль, если совпадений не найдено.

58

array.select {|item| block }

Вызывает блок, передавая последовательные элементы из массива, возвращая массив, содержащий те элементы, для которых блок возвращает истинное значение.

59

array.shift

Возвращает первый элемент self и удаляет его (сдвигая все остальные элементы на один вниз). Возвращает nil, если массив пуст.

60

array.size

Возвращает длину массива (количество элементов). Псевдоним длины.

61

array.slice(index) [or] array.slice(start, length) [or]

array.slice(range) [or] array[index] [or]

array[start, length] [or] array[range]

Возвращает элемент по индексу или возвращает подмассив, начинающийся с начала и продолжающийся для элементов длины , или возвращает подмассив, указанный диапазоном . Отрицательные индексы считаются в обратном порядке от конца массива (-1 - последний элемент). Возвращает ноль, если индекс (или начальный индекс) выходит за пределы допустимого диапазона.

62

array.slice!(index) [or] array.slice!(start, length) [or]

array.slice!(range)

Удаляет элемент (ы), заданный индексом (необязательно длиной) или диапазоном . Возвращает удаленный объект, подмассив или ноль, если индекс вне допустимого диапазона.

63

array.sort [or] array.sort { | a,b | block }

Возвращает новый массив, созданный путем сортировки self.

64

array.sort! [or] array.sort! { | a,b | block }

Сортирует себя.

65

array.to_a

Возвращает себя . Если вызывается в подклассе Array , преобразует получатель в объект Array.

66

array.to_ary

Возвращает себя.

67

array.to_s

Возвращает self.join.

68

array.transpose

Предполагает, что self является массивом массивов и меняет местами строки и столбцы.

69

array.uniq

Возвращает новый массив, удаляя повторяющиеся значения в массиве .

70

array.uniq!

Удаляет повторяющиеся элементы из себя . Возвращает nil, если не было внесено никаких изменений (то есть дубликаты не найдены).

71

array.unshift(obj, ...)

Добавляет объекты к началу массива, другие элементы - вверх.

72

array.values_at(selector,...)

Возвращает массив, содержащий элементы self, соответствующие заданному селектору (одному или нескольким). Селекторы могут быть целочисленными индексами или диапазонами.

73

array.zip(arg, ...) [or]

array.zip(arg, ...){ | arr | block }

Преобразует любые аргументы в массивы, затем объединяет элементы массива с соответствующими элементами из каждого аргумента.

Директивы пакета массивов

Sr.No. Директива и описание
1

@

Перемещается в абсолютное положение.

2

A

Строка ASCII (заполнена пробелами, количество равно ширине).

3

a

Строка ASCII (заполнена нулем, количество равно ширине).

4

B

строка (в порядке убывания битов).

5

b

Битовая строка (возрастающий битовый порядок).

6

C

Беззнаковый символ.

7

c

Char.

8

D, d

Число с плавающей запятой двойной точности, собственный формат.

9

E

Число с плавающей запятой двойной точности, порядок байтов с прямым порядком байтов.

10

e

Число с плавающей запятой одинарной точности, порядок байтов с прямым порядком байтов.

11

F, f

Число с плавающей запятой одинарной точности, собственный формат.

12

G

Число с плавающей запятой двойной точности, сетевой порядок байтов (с прямым порядком байтов).

13

g

Число с плавающей запятой одинарной точности, сетевой порядок байтов (с прямым порядком байтов).

14

H

Шестигранная струна (сначала большой полубайт)

15

h

Шестнадцатеричная строка (сначала малый полубайт).

16

I

Беззнаковое целое.

17

i

Целое число.

18

L

Без подписи долго.

19

l

Долго.

20

M

Цитируется для печати, кодировка MIME (см. RFC 2045).

21 год

m

Строка в кодировке Base64.

22

N

Длинный сетевой порядок байтов (с прямым порядком байтов).

23

n

Короткий сетевой порядок байтов (с прямым порядком байтов).

24

P

Указатель на структуру (строка фиксированной длины).

25

p

Указатель на строку с завершающим нулем.

26

Q, q

64-битное число.

27

S

Беззнаковый короткий.

28

s

Короткий.

29

U

UTF-8.

30

u

Строка в кодировке UU.

31 год

V

Длинный порядок байтов с прямым порядком байтов.

32

v

Короткий порядок байтов с прямым порядком байтов.

33

w

Целое число со сжатием BER \ fnm.

34

X

Сделайте резервную копию байта.

35 год

x

Нулевой байт.

36

Z

То же, что a, за исключением того, что null добавляется с *.

пример

Попробуйте следующий пример для упаковки различных данных.

a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3")   #=> "a  b  c  "
puts a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")      #=> "ABC"

Это даст следующий результат -

a  b  c
abc
ABC

Хеш - это набор таких пар ключ-значение: «сотрудник» => «зарплата». Он похож на массив, за исключением того, что индексация выполняется с помощью произвольных ключей любого типа объекта, а не целочисленного индекса.

Порядок, в котором вы проходите хэш по ключу или значению, может показаться произвольным и, как правило, не соответствует порядку вставки. Если вы попытаетесь получить доступ к хешу с ключом, которого не существует, метод вернет nil .

Создание хэшей

Как и в случае с массивами, существует множество способов создания хэшей. Вы можете создать пустой хеш с помощью нового метода класса -

months = Hash.new

Вы также можете использовать new для создания хеша со значением по умолчанию, которое в противном случае просто nil -

months = Hash.new( "month" )

or

months = Hash.new "month"

Когда вы получаете доступ к любому ключу в хэше, который имеет значение по умолчанию, если ключ или значение не существует, доступ к хешу вернет значение по умолчанию -

#!/usr/bin/ruby

months = Hash.new( "month" )

puts "#{months[0]}"
puts "#{months[72]}"

Это даст следующий результат -

month
month

#!/usr/bin/ruby

H = Hash["a" => 100, "b" => 200]

puts "#{H['a']}"
puts "#{H['b']}"

Это даст следующий результат -

100
200

Вы можете использовать любой объект Ruby в качестве ключа или значения, даже массив, поэтому следующий пример является допустимым:

[1,"jan"] => "January"

Встроенные методы хеширования

Нам нужен экземпляр объекта Hash для вызова метода Hash. Как мы видели, следующий способ создать экземпляр объекта Hash:

Hash[[key =>|, value]* ] or

Hash.new [or] Hash.new(obj) [or]
Hash.new { |hash, key| block }

Это вернет новый хэш, заполненный данными объектами. Теперь, используя созданный объект, мы можем вызывать любые доступные методы экземпляра. Например -

#!/usr/bin/ruby

$, = ", "
months = Hash.new( "month" )
months = {"1" => "January", "2" => "February"}

keys = months.keys
puts "#{keys}"

Это даст следующий результат -

["1", "2"]

Ниже приведены общедоступные методы хеширования (при условии, что хеш является объектом массива).

Sr.No. Методы и описание
1

hash == other_hash

Проверяет, равны ли два хэша, основываясь на том, одинаковое ли количество пар ключ-значение у них и совпадают ли пары ключ-значение с соответствующей парой в каждом хэше.

2

hash.[key]

Используя ключ, ссылается на значение из хеша. Если ключ не найден, возвращается значение по умолчанию.

3

hash.[key] = value

Связывает значение, заданное значением, с ключом, заданным ключом .

4

hash.clear

Удаляет все пары ключ-значение из хэша.

5

hash.default(key = nil)

Возвращает значение по умолчанию для хэша , nil, если по умолчанию не установлено =. ([] возвращает значение по умолчанию, если ключ не существует в хэше .)

6

hash.default = obj

Устанавливает значение по умолчанию для хэша .

7

hash.default_proc

Возвращает блок, если хеш был создан блоком.

8

hash.delete(key) [or]

array.delete(key) { |key| block }

Удаляет пару ключ-значение из хеша по ключу . Если используется блок, возвращает результат блока, если пара не найдена. Сравните delete_if .

9

hash.delete_if { |key,value| block }

Удаляет пару ключ-значение из хэша для каждой пары, для которой блок оценивается как истинное .

10

hash.each { |key,value| block }

Итерирует по хешу , вызывая блок один раз для каждого ключа, передавая значение ключа в виде двухэлементного массива.

11

hash.each_key { |key| block }

Итерирует по хешу , вызывая блок один раз для каждого ключа, передавая ключ в качестве параметра.

12

hash.each_key { |key_value_array| block }

Итерирует по хешу , вызывая блок один раз для каждого ключа , передавая ключ и значение в качестве параметров.

13

hash.each_key { |value| block }

Итерирует по хешу , вызывая блок один раз для каждого ключа , передавая значение в качестве параметра.

14

hash.empty?

Проверяет, является ли хеш пустым (не содержит пар ключ-значение), возвращает истину или ложь .

15

hash.fetch(key [, default] ) [or]

hash.fetch(key) { | key | block }

Возвращает значение из хеша для данного ключа . Если ключ не может быть найден и других аргументов нет, возникает исключение IndexError ; если задано значение по умолчанию , оно возвращается; если указан необязательный блок, возвращается его результат.

16

hash.has_key?(key) [or] hash.include?(key) [or]

hash.key?(key) [or] hash.member?(key)

Проверяет, присутствует ли данный ключ в хэше, возвращая истину или ложь .

17

hash.has_value?(value)

Проверяет, содержит ли хэш заданное значение .

18

hash.index(value)

Возвращает ключ для заданного значения в хэше, nil, если подходящего значения не найдено.

19

hash.indexes(keys)

Возвращает новый массив, состоящий из значений для данного ключа (ов). Вставит значение по умолчанию для ключей, которые не найдены. Этот метод устарел. Используйте select.

20

hash.indices(keys)

Возвращает новый массив, состоящий из значений для данного ключа (ов). Вставит значение по умолчанию для ключей, которые не найдены. Этот метод устарел. Используйте select.

21 год

hash.inspect

Возвращает версию хэша в виде красивой строки для печати.

22

hash.invert

Создает новый хеш , инвертируя ключи и значения из хеша ; то есть в новом хэше ключи от хеша становятся значениями, а значения становятся ключами.

23

hash.keys

Создает новый массив с ключами из хэша .

24

hash.length

Возвращает размер или длину хеша в виде целого числа.

25

hash.merge(other_hash) [or]

hash.merge(other_hash) { |key, oldval, newval| block }

Возвращает новый хэш, содержащий содержимое hash и other_hash , перезаписывая пары в хеше с дублирующимися ключами ключами из other_hash .

26

hash.merge!(other_hash) [or]

hash.merge!(other_hash) { |key, oldval, newval| block }

То же, что и слияние, но изменения вносятся на месте.

27

hash.rehash

Восстанавливает хэш на основе текущих значений для каждого ключа . Если значения изменились с момента вставки, этот метод переиндексирует хэш .

28

hash.reject { |key, value| block }

Создает новый хэш для каждой пары, для которой блок оценивает значение true

29

hash.reject! { |key, value| block }

То же, что и отклонение , но изменения вносятся на месте.

30

hash.replace(other_hash)

Заменяет содержимое хэша содержимым other_hash .

31 год

hash.select { |key, value| block }

Возвращает новый массив, состоящий из пар ключ-значение из хеша, для которого блок возвращает истину .

32

hash.shift

Удаляет пару "ключ-значение" из хэша , возвращая ее как двухэлементный массив.

33

hash.size

Возвращает размер или длину хеша в виде целого числа.

34

hash.sort

Преобразует хэш в двумерный массив, содержащий массивы пар ключ-значение, а затем сортирует его как массив.

35 год

hash.store(key, value)

Хранит пару "ключ-значение" в хеше .

36

hash.to_a

Создает двумерный массив из хэша. Каждая пара ключ / значение преобразуется в массив, и все эти массивы хранятся в содержащем массиве.

37

hash.to_hash

Возвращает хэш (себя).

38

hash.to_s

Преобразует хэш в массив, а затем преобразует этот массив в строку.

39

hash.update(other_hash) [or]

hash.update(other_hash) {|key, oldval, newval| block}

Возвращает новый хэш, содержащий содержимое hash и other_hash , перезаписывая пары в хеше с дублирующимися ключами ключами из other_hash .

40

hash.value?(value)

Проверяет, содержит ли хэш заданное значение .

41 год

hash.values

Возвращает новый массив, содержащий все значения хэша .

42

hash.values_at(obj, ...)

Возвращает новый массив, содержащий значения из хеша , связанные с данным ключом или ключами.

В Timeclass представляет дату и время в Ruby. Это тонкий слой над системной функцией даты и времени, предоставляемой операционной системой. Этот класс может не иметь возможности в вашей системе представлять даты до 1970 года или после 2038 года.

В этой главе вы познакомитесь со всеми наиболее востребованными понятиями даты и времени.

Получение текущей даты и времени

Ниже приведен простой пример получения текущей даты и времени:

#!/usr/bin/ruby -w

time1 = Time.new
puts "Current Time : " + time1.inspect

# Time.now is a synonym:
time2 = Time.now
puts "Current Time : " + time2.inspect

Это даст следующий результат -

Current Time : Mon Jun 02 12:02:39 -0700 2008
Current Time : Mon Jun 02 12:02:39 -0700 2008

Получение компонентов даты и времени

Мы можем использовать объект Time для получения различных компонентов даты и времени. Ниже приведен пример, показывающий то же самое -

#!/usr/bin/ruby -w

time = Time.new

# Components of a Time
puts "Current Time : " + time.inspect
puts time.year    # => Year of the date 
puts time.month   # => Month of the date (1 to 12)
puts time.day     # => Day of the date (1 to 31 )
puts time.wday    # => 0: Day of week: 0 is Sunday
puts time.yday    # => 365: Day of year
puts time.hour    # => 23: 24-hour clock
puts time.min     # => 59
puts time.sec     # => 59
puts time.usec    # => 999999: microseconds
puts time.zone    # => "UTC": timezone name

Это даст следующий результат -

Current Time : Mon Jun 02 12:03:08 -0700 2008
2008
6
2
1
154
12
3
8
247476
UTC

Функции Time.utc, Time.gm и Time.local

Эти две функции могут использоваться для форматирования даты в стандартном формате следующим образом:

# July 8, 2008
Time.local(2008, 7, 8)  
# July 8, 2008, 09:10am, local time
Time.local(2008, 7, 8, 9, 10)   
# July 8, 2008, 09:10 UTC
Time.utc(2008, 7, 8, 9, 10)  
# July 8, 2008, 09:10:11 GMT (same as UTC)
Time.gm(2008, 7, 8, 9, 10, 11)

Ниже приведен пример получения всех компонентов в массиве в следующем формате:

[sec,min,hour,day,month,year,wday,yday,isdst,zone]

Попробуйте следующее -

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
p values

Это даст следующий результат -

[26, 10, 12, 2, 6, 2008, 1, 154, false, "MST"]

Этот массив можно передать функциям Time.utc или Time.local, чтобы получить другой формат дат следующим образом:

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
puts Time.utc(*values)

Это даст следующий результат -

Mon Jun 02 12:15:36 UTC 2008

Ниже приведен способ представления времени внутренне в секундах с эпохи (зависящей от платформы):

# Returns number of seconds since epoch
time = Time.now.to_i  

# Convert number of seconds into Time object.
Time.at(time)

# Returns second since epoch which includes microseconds
time = Time.now.to_f

Часовые пояса и переход на летнее время

Вы можете использовать объект Time, чтобы получить всю информацию, связанную с часовыми поясами и переходом на летнее время, следующим образом:

time = Time.new

# Here is the interpretation
time.zone       # => "UTC": return the timezone
time.utc_offset # => 0: UTC is 0 seconds offset from UTC
time.zone       # => "PST" (or whatever your timezone is)
time.isdst      # => false: If UTC does not have DST.
time.utc?       # => true: if t is in UTC time zone
time.localtime  # Convert to local timezone.
time.gmtime     # Convert back to UTC.
time.getlocal   # Return a new Time object in local zone
time.getutc     # Return a new Time object in UTC

Форматирование времени и даты

Есть разные способы форматирования даты и времени. Вот один пример, показывающий несколько -

#!/usr/bin/ruby -w

time = Time.new
puts time.to_s
puts time.ctime
puts time.localtime
puts time.strftime("%Y-%m-%d %H:%M:%S")

Это даст следующий результат -

Mon Jun 02 12:35:19 -0700 2008
Mon Jun  2 12:35:19 2008
Mon Jun 02 12:35:19 -0700 2008
2008-06-02 12:35:19

Директивы форматирования времени

Эти директивы в следующей таблице используются с методом Time.strftime .

Sr.No. Директива и описание
1

%a

Сокращенное название дня недели (Солнце).

2

%A

Полное название дня недели (воскресенье).

3

%b

Сокращенное название месяца (янв).

4

%B

Полное название месяца (январь).

5

%c

Предпочтительное местное представление даты и времени.

6

%d

День месяца (с 01 по 31).

7

%H

Час дня в 24-часовом формате (с 00 до 23).

8

%I

Час дня в 12-часовом формате (с 01 до 12).

9

%j

День года (с 001 по 366).

10

%m

Месяц года (с 01 по 12).

11

%M

Минуты часа (от 00 до 59).

12

%p

Индикатор меридиана (AM или PM).

13

%S

Секунды минуты (от 00 до 60).

14

%U

Номер недели текущего года, начиная с первого воскресенья как первого дня первой недели (с 00 по 53).

15

%W

Номер недели текущего года, начиная с первого понедельника как первого дня первой недели (от 00 до 53).

16

%w

День недели (воскресенье - 0, 0 до 6).

17

%x

Предпочтительное представление только для даты, без времени.

18

%X

Предпочтительное представление только для времени, без даты.

19

%y

Год без века (от 00 до 99).

20

%Y

Год с веком.

21 год

%Z

Название часового пояса.

22

%%

Буквальный символ%.

Арифметика времени

Вы можете выполнить простую арифметику со временем следующим образом:

now = Time.now          # Current time
puts now

past = now - 10         # 10 seconds ago. Time - number => Time
puts past

future = now + 10  # 10 seconds from now Time + number => Time
puts future

diff = future - past     # => 10  Time - Time => number of seconds
puts diff

Это даст следующий результат -

Thu Aug 01 20:57:05 -0700 2013
Thu Aug 01 20:56:55 -0700 2013
Thu Aug 01 20:57:15 -0700 2013
20.0

Диапазоны встречаются везде: с января по декабрь, от 0 до 9, строки с 50 по 67 и так далее. Ruby поддерживает диапазоны и позволяет нам использовать диапазоны по-разному -

  • Диапазоны как последовательности
  • Диапазоны как условия
  • Диапазоны как интервалы

Диапазоны как последовательности

Первое и, возможно, наиболее естественное использование диапазонов - это выражение последовательности. Последовательности имеют начальную точку, конечную точку и способ получения последовательных значений в последовательности.

Ruby создает эти последовательности, используя ''..'' и ''...''операторы диапазона. Форма с двумя точками создает включающий диапазон, а форма с тремя точками создает диапазон, исключающий указанное максимальное значение.

(1..5)        #==> 1, 2, 3, 4, 5
(1...5)       #==> 1, 2, 3, 4
('a'..'d')    #==> 'a', 'b', 'c', 'd'

Последовательность 1..100 хранится как объект Range, содержащий ссылки на два объекта Fixnum . При необходимости вы можете преобразовать диапазон в список с помощью метода to_a . Попробуйте следующий пример -

#!/usr/bin/ruby

$, =", "   # Array value separator
range1 = (1..10).to_a
range2 = ('bar'..'bat').to_a

puts "#{range1}"
puts "#{range2}"

Это даст следующий результат -

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
["bar", "bas", "bat"]

Диапазоны реализуют методы, которые позволяют вам перебирать их и тестировать их содержимое различными способами:

#!/usr/bin/ruby

# Assume a range
digits = 0..9

puts digits.include?(5)
ret = digits.min
puts "Min value is #{ret}"

ret = digits.max
puts "Max value is #{ret}"

ret = digits.reject {|i| i < 5 }
puts "Rejected values are #{ret}"

digits.each do |digit|
   puts "In Loop #{digit}"
end

Это даст следующий результат -

true
Min value is 0
Max value is 9
Rejected values are 5, 6, 7, 8, 9
In Loop 0
In Loop 1
In Loop 2
In Loop 3
In Loop 4
In Loop 5
In Loop 6
In Loop 7
In Loop 8
In Loop 9

Диапазоны как условия

Диапазоны также могут использоваться как условные выражения. Например, следующий фрагмент коды печатает наборы строк из стандартного ввода, где первая строка в каждом наборе содержит слово начала и последнюю строку слова концов -

while gets
   print if /start/../end/
end

Диапазоны могут использоваться в операторах case -

#!/usr/bin/ruby

score = 70

result = case score
   when 0..40 then "Fail"
   when 41..60 then "Pass"
   when 61..70 then "Pass with Merit"
   when 71..100 then "Pass with Distinction"
   else "Invalid Score"
end

puts result

Это даст следующий результат -

Pass with Merit

Диапазоны как интервалы

Последнее использование универсального диапазона - это интервальный тест: проверка того, попадает ли какое-либо значение в интервал, представленный диапазоном. Это делается с помощью ===, оператора равенства регистра.

#!/usr/bin/ruby

if ((1..10) === 5)
   puts "5 lies in (1..10)"
end

if (('a'..'j') === 'c')
   puts "c lies in ('a'..'j')"
end

if (('a'..'j') === 'z')
   puts "z lies in ('a'..'j')"
end

Это даст следующий результат -

5 lies in (1..10)
c lies in ('a'..'j')

Итераторы - это не что иное, как методы, поддерживаемые коллекциями . Объекты, хранящие группу элементов данных, называются коллекциями. В Ruby массивы и хэши можно назвать коллекциями.

Итераторы возвращают все элементы коллекции один за другим. Здесь мы будем обсуждать два итератора, каждый и collect . Давайте рассмотрим их подробнее.

Ruby each Iterator

Каждый итератор возвращает все элементы массива или хеша.

Синтаксис

collection.each do |variable|
   code
end

Выполняет код для каждого элемента в коллекции . Здесь коллекция может быть массивом или рубиновым хешем.

пример

#!/usr/bin/ruby

ary = [1,2,3,4,5]
ary.each do |i|
   puts i
end

Это даст следующий результат -

1
2
3
4
5

Вы всегда связываете каждый итератор с блоком. Он возвращает в блок каждое значение массива одно за другим. Значение хранится в переменнойi а затем отобразится на экране.

Ruby collect Iterator

В Отобрать итератор возвращает все элементы коллекции.

Синтаксис

collection = collection.collect

Метод сбора не всегда должен быть связан с блоком. Метод collect возвращает всю коллекцию, независимо от того, является ли она массивом или хешем.

пример

#!/usr/bin/ruby

a = [1,2,3,4,5]
b = Array.new
b = a.collect
puts b

Это даст следующий результат -

1
2
3
4
5

NOTE- Метод сбора не является правильным способом копирования между массивами. Есть еще один метод, называемый clone , который следует использовать для копирования одного массива в другой.

Обычно вы используете метод collect, когда хотите что-то сделать с каждым из значений, чтобы получить новый массив. Например, этот код создает массив b, содержащий 10 раз каждое значение в a .

#!/usr/bin/ruby

a = [1,2,3,4,5]
b = a.collect{|x| 10*x}
puts b

Это даст следующий результат -

10
20
30
40
50

Ruby предоставляет целый набор связанных с вводом-выводом методов, реализованных в модуле ядра. Все методы ввода-вывода являются производными от класса IO.

Класс IO предоставляет все основные методы, такие как чтение, запись, получение, помещение, чтение, getc и printf .

В этой главе будут рассмотрены все основные функции ввода-вывода, доступные в Ruby. Дополнительные функции см. В Ruby Class IO .

Заявление пут

В предыдущих главах вы присвоили значения переменным, а затем распечатали результат с помощью оператора put .

Оператор put дает указание программе отобразить значение, хранящееся в переменной. Это добавит новую строку в конец каждой записываемой строки.

пример

#!/usr/bin/ruby

val1 = "This is variable one"
val2 = "This is variable two"
puts val1
puts val2

Это даст следующий результат -

This is variable one
This is variable two

Заявление о получении

Оператор gets может использоваться для получения любого ввода от пользователя со стандартного экрана STDIN.

пример

В следующем коде показано, как использовать оператор gets. Этот код предложит пользователю ввести значение, которое будет сохранено в переменной val и, наконец, будет напечатано в STDOUT.

#!/usr/bin/ruby

puts "Enter a value :"
val = gets
puts val

Это даст следующий результат -

Enter a value :
This is entered value
This is entered value

Заявление putc

В отличие от помещает заявление, который выводит всю строку на экран, то putc оператор можно использовать для вывода одного символа в то время.

пример

Результатом следующего кода является просто символ H -

#!/usr/bin/ruby

str = "Hello Ruby!"
putc str

Это даст следующий результат -

H

Заявление о печати

Оператор печати похож на оператор put . Единственное отличие состоит в том, что оператор put переходит на следующую строку после печати содержимого, тогда как с оператором печати курсор располагается на той же строке.

пример

#!/usr/bin/ruby

print "Hello World"
print "Good Morning"

Это даст следующий результат -

Hello WorldGood Morning

Открытие и закрытие файлов

До сих пор вы читали и записывали в стандартный ввод и вывод. Теперь посмотрим, как работать с реальными файлами данных.

Метод File.new

Вы можете создать объект File, используя метод File.new для чтения, записи или того и другого, в зависимости от строки режима. Наконец, вы можете использовать метод File.close, чтобы закрыть этот файл.

Синтаксис

aFile = File.new("filename", "mode")
   # ... process the file
aFile.close

Метод File.open

Вы можете использовать метод File.open для создания нового файлового объекта и присвоения этого файлового объекта файлу. Однако между методами File.open и File.new есть одно различие . Разница в том, что метод File.open может быть связан с блоком, тогда как вы не можете сделать то же самое, используя метод File.new .

File.open("filename", "mode") do |aFile|
   # ... process the file
end
Sr.No. Режимы и описание
1

r

Режим только для чтения. Указатель файла помещается в начало файла. Это режим "по умолчанию".

2

r+

Режим чтения-записи. Указатель файла будет в начале файла.

3

w

Режим только для записи. Заменяет файл, если он существует. Если файл не существует, создает новый файл для записи.

4

w+

Режим чтения-записи. Заменяет существующий файл, если он существует. Если файл не существует, создает новый файл для чтения и записи.

5

a

Режим только для записи. Указатель файла находится в конце файла, если файл существует. То есть файл находится в режиме добавления. Если файл не существует, создается новый файл для записи.

6

a+

Режим чтения и записи. Указатель файла находится в конце файла, если файл существует. Файл откроется в режиме добавления. Если файл не существует, создается новый файл для чтения и записи.

Чтение и запись файлов

Те же методы, которые мы использовали для «простого» ввода-вывода, доступны для всех файловых объектов. Итак, get читает строку из стандартного ввода, а aFile.gets читает строку из файлового объекта aFile.

Однако объекты ввода-вывода предоставляют дополнительный набор методов доступа, облегчающих нашу жизнь.

Метод sysread

Вы можете использовать метод sysread для чтения содержимого файла. Вы можете открыть файл в любом из режимов при использовании метода sysread. Например -

Ниже приведен входной текстовый файл -

This is a simple text file for testing purpose.

Теперь попробуем прочитать этот файл -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r")
if aFile
   content = aFile.sysread(20)
   puts content
else
   puts "Unable to open file!"
end

Этот оператор выведет первые 20 символов файла. Указатель файла теперь будет помещен на 21-й символ в файле.

Метод системной записи

Вы можете использовать метод syswrite для записи содержимого в файл. Вам нужно открыть файл в режиме записи при использовании метода syswrite. Например -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
else
   puts "Unable to open file!"
end

Этот оператор запишет в файл «ABCDEF».

Метод each_byte

Этот метод принадлежит к классу File . Метод each_byte всегда связан с блоком. Рассмотрим следующий пример кода -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
   aFile.each_byte {|ch| putc ch; putc ?. }
else
   puts "Unable to open file!"
end

Символы передаются один за другим в переменную ch, а затем отображаются на экране следующим образом:

s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...
.
.

Метод IO.readlines

Класс File является подклассом класса IO. Класс IO также имеет несколько методов, которые можно использовать для управления файлами.

Один из методов класса IO - IO.readlines . Этот метод по очереди возвращает содержимое файла. В следующем коде показано использование метода IO.readlines -

#!/usr/bin/ruby

arr = IO.readlines("input.txt")
puts arr[0]
puts arr[1]

В этом коде переменная arr представляет собой массив. Каждая строка файла input.txt будет элементом массива arr. Следовательно, arr [0] будет содержать первую строку, тогда как arr [1] будет содержать вторую строку файла.

The IO.foreach Method

Этот метод также возвращает вывод построчно. Разница между методом foreach и строкой чтения метода заключается в том, что метод foreach связан с блоком. Однако, в отличие от метода readlines , метод foreach не возвращает массив. Например -

#!/usr/bin/ruby

IO.foreach("input.txt"){|block| puts block}

Этот код будет передавать содержимое файла test построчно в блок переменных, а затем вывод будет отображаться на экране.

Переименование и удаление файлов

Вы можете переименовывать и удалять файлы программно с помощью Ruby с помощью методов переименования и удаления .

Ниже приведен пример , чтобы переименовать существующий файл test1.txt -

#!/usr/bin/ruby

# Rename a file from test1.txt to test2.txt
File.rename( "test1.txt", "test2.txt" )

Ниже приведен пример удаления существующего файла test2.txt -

#!/usr/bin/ruby

# Delete file test2.txt
File.delete("test2.txt")

Режимы работы с файлами и права собственности

Используйте метод chmod с маской, чтобы изменить режим или список разрешений / доступа для файла -

Ниже приведен пример изменения режима существующего файла test.txt на значение маски.

#!/usr/bin/ruby

file = File.new( "test.txt", "w" )
file.chmod( 0755 )
Sr.No. Маска и описание
1

0700

маска rwx для владельца

2

0400

r для владельца

3

0200

w для владельца

4

0100

x для владельца

5

0070

rwx маска для группы

6

0040

r для группы

7

0020

w для группы

8

0010

x для группы

9

0007

маска rwx для других

10

0004

r для других

11

0002

w для других

12

0001

x для других

13

4000

Установить идентификатор пользователя при выполнении

14

2000

Установить идентификатор группы при выполнении

15

1000

Сохраняйте замененный текст даже после использования

Запросы к файлам

Следующая команда проверяет, существует ли файл перед его открытием -

#!/usr/bin/ruby

File.open("file.rb") if File::exists?( "file.rb" )

Следующая команда запрашивает, действительно ли файл является файлом -

#!/usr/bin/ruby

# This returns either true or false
File.file?( "text.txt" )

Следующая команда выясняет, является ли данное имя файла каталогом -

#!/usr/bin/ruby

# a directory
File::directory?( "/usr/local/bin" ) # => true

# a file
File::directory?( "file.rb" ) # => false

Следующая команда определяет, доступен ли файл для чтения, записи или выполнения:

#!/usr/bin/ruby

File.readable?( "test.txt" )   # => true
File.writable?( "test.txt" )   # => true
File.executable?( "test.txt" ) # => false

Следующая команда определяет, имеет ли файл нулевой размер или нет -

#!/usr/bin/ruby

File.zero?( "test.txt" )      # => true

Следующая команда возвращает размер файла -

#!/usr/bin/ruby

File.size?( "text.txt" )     # => 1002

Следующая команда может использоваться для определения типа файла -

#!/usr/bin/ruby

File::ftype( "test.txt" )     # => file

Метод ftype определяет тип файла, возвращая одно из следующих значений: file, directory, characterSpecial, blockSpecial, fifo, link, socket или unknown.

Следующая команда может использоваться, чтобы узнать, когда файл был создан, изменен или последний раз доступ к нему:

#!/usr/bin/ruby

File::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008
File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008
File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008

Каталоги на Ruby

Все файлы содержатся в разных каталогах, и Ruby без проблем справляется с ними. В то время как класс File обрабатывает файлы, каталоги обрабатываются классом Dir .

Навигация по каталогам

Чтобы сменить каталог в программе Ruby, используйте Dir.chdir следующим образом. В этом примере текущий каталог изменяется на / usr / bin .

Dir.chdir("/usr/bin")

Вы можете узнать текущий каталог с помощью Dir.pwd -

puts Dir.pwd # This will return something like /usr/bin

Вы можете получить список файлов и каталогов в определенном каталоге, используя Dir.entries -

puts Dir.entries("/usr/bin").join(' ')

Dir.entries возвращает массив со всеми записями в указанном каталоге. Dir.foreach предоставляет ту же функцию -

Dir.foreach("/usr/bin") do |entry|
   puts entry
end

Еще более краткий способ получения списков каталогов - использовать метод массива классов Dir -

Dir["/usr/bin/*"]

Создание каталога

Dir.mkdir может быть использован для создания каталогов -

Dir.mkdir("mynewdir")

Вы также можете установить разрешения для нового каталога (а не того, который уже существует) с помощью mkdir -

NOTE - Маска 755 устанавливает владельца разрешений, группу, мир [любой] равным rwxr-xr-x, где r = чтение, w = запись и x = выполнение.

Dir.mkdir( "mynewdir", 755 )

Удаление каталога

Dir.delete может быть использован для удаления каталога. В Dir.unlink и Dir.rmdir выполняет точно такие же функции и предоставляются для удобства.

Dir.delete("testdir")

Создание файлов и временных каталогов

Временные файлы - это файлы, которые могут быть созданы на короткое время во время выполнения программы, но не являются постоянным хранилищем информации.

Dir.tmpdir предоставляет путь к временному каталогу в текущей системе, хотя этот метод по умолчанию недоступен. Чтобы сделать Dir.tmpdir доступным, необходимо использовать require 'tmpdir'.

Вы можете использовать Dir.tmpdir с File.join для создания независимого от платформы временного файла -

require 'tmpdir'
   tempfilename = File.join(Dir.tmpdir, "tingtong")
   tempfile = File.new(tempfilename, "w")
   tempfile.puts "This is a temporary file"
   tempfile.close
   File.delete(tempfilename)

Этот код создает временный файл, записывает в него данные и удаляет его. Стандартная библиотека Ruby также включает библиотеку под названием Tempfile, которая может создавать для вас временные файлы -

require 'tempfile'
   f = Tempfile.new('tingtong')
   f.puts "Hello"
   puts f.path
   f.close

Встроенные функции

Вот встроенные функции Ruby для обработки файлов и каталогов:

  • Класс файла и методы .

  • Класс и методы Dir .

Выполнение и исключение всегда идут вместе. Если вы открываете несуществующий файл, то, если вы не справились с этой ситуацией должным образом, ваша программа считается некачественной.

Программа останавливается, если возникает исключение. Таким образом, исключения используются для обработки различных типов ошибок, которые могут возникнуть во время выполнения программы, и принятия соответствующих мер вместо полной остановки программы.

Ruby предоставляет хороший механизм для обработки исключений. Мы заключаем код, который может вызвать исключение, в начальный / конечный блок и используем предложения rescue, чтобы сообщить Ruby типы исключений, которые мы хотим обработать.

Синтаксис

begin  
# -  
rescue OneTypeOfException  
# -  
rescue AnotherTypeOfException  
# -  
else  
# Other exceptions
ensure
# Always will be executed
end

Все, от начала до спасения , защищено. Если во время выполнения этого блока кода возникает исключение, управление передается блоку между спасением и завершением .

Для каждого предложения rescue в блоке begin Ruby по очереди сравнивает возбужденное исключение с каждым из параметров. Сопоставление будет успешным, если исключение, указанное в предложении rescue, совпадает с типом текущего исключения или является суперклассом этого исключения.

В случае, если исключение не соответствует ни одному из типов ошибок , указанных, нам разрешено использовать другое положение после всех спасательных пунктов.

пример

#!/usr/bin/ruby

begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
      file = STDIN
end
print file, "==", STDIN, "\n"

Это даст следующий результат. Вы можете видеть, что STDIN заменяется файлом из-за ошибки открытия .

#<IO:0xb7d16f84>==#<IO:0xb7d16f84>

Использование оператора повтора

Вы можете захватить исключение , используя спасательный блок , а затем использовать Повторить заявление для выполнения начать блок с самого начала.

Синтаксис

begin
   # Exceptions raised by this code will 
   # be caught by the following rescue clause
rescue
   # This block will capture all types of exceptions
   retry  # This will move control to the beginning of begin
end

пример

#!/usr/bin/ruby

begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
   fname = "existant_file"
   retry
end

Ниже приведен поток процесса -

  • Исключение при открытии.
  • Отправился на помощь. fname было переназначено.
  • По повторной попытке перейти к началу начала.
  • На этот раз файл открывается успешно.
  • Продолжил основной процесс.

NOTE- Обратите внимание, что если файл с заменяемым именем не существует, этот пример кода повторяется бесконечно. Будьте осторожны, если вы используете повтор для процесса исключения.

Использование инструкции Raise

Вы можете использовать рейз заявление сгенерирует исключение. Следующий метод вызывает исключение при каждом вызове. Будет напечатано второе сообщение.

Синтаксис

raise 

OR

raise "Error Message" 

OR

raise ExceptionType, "Error Message"

OR

raise ExceptionType, "Error Message" condition

Первая форма просто повторно вызывает текущее исключение (или RuntimeError, если текущего исключения нет). Это используется в обработчиках исключений, которым необходимо перехватить исключение перед его передачей.

Вторая форма создает новое исключение RuntimeError , устанавливая для своего сообщения заданную строку. Затем это исключение поднимается в стеке вызовов.

Третья форма использует первый аргумент для создания исключения, а затем устанавливает для связанного сообщения второй аргумент.

Четвертая форма похожа на третью, но вы можете добавить любой условный оператор, например, если не вызвать исключение.

пример

#!/usr/bin/ruby

begin  
   puts 'I am before the raise.'  
   raise 'An error has occurred.'  
   puts 'I am after the raise.'  
rescue  
   puts 'I am rescued.'  
end  
puts 'I am after the begin block.'

Это даст следующий результат -

I am before the raise.  
I am rescued.  
I am after the begin block.

Еще один пример, показывающий использование повышения -

#!/usr/bin/ruby

begin  
   raise 'A test exception.'  
rescue Exception => e  
   puts e.message  
   puts e.backtrace.inspect  
end

Это даст следующий результат -

A test exception.
["main.rb:4"]

Использование выражения обеспечения

Иногда вам нужно гарантировать, что некоторая обработка будет выполнена в конце блока кода, независимо от того, было ли вызвано исключение. Например, у вас может быть файл, открытый при входе в блок, и вам нужно убедиться, что он закрывается при выходе из блока.

Предложение обеспечения делает именно это. sure идет после последнего предложения rescue и содержит фрагмент кода, который всегда будет выполняться по завершении блока. Не имеет значения, выходит ли блок нормально, если он вызывает и спасает исключение, или если он завершается неперехваченным исключением, блок обеспечения будет запущен.

Синтаксис

begin 
   #.. process 
   #..raise exception
rescue 
   #.. handle error 
ensure 
   #.. finally ensure execution
   #.. This will always execute.
end

пример

begin
   raise 'A test exception.'
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
ensure
   puts "Ensuring execution"
end

Это даст следующий результат -

A test exception.
["main.rb:4"]
Ensuring execution

Использование оператора else

Если предложение else присутствует, оно идет после предложений rescue и до любого обеспечения .

Тело предложения else выполняется только в том случае, если основная часть кода не вызывает исключений.

Синтаксис

begin 
   #.. process 
   #..raise exception
rescue 
   # .. handle error
else
   #.. executes if there is no exception
ensure 
   #.. finally ensure execution
   #.. This will always execute.
end

пример

begin
   # raise 'A test exception.'
   puts "I'm not raising exception"
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
else
   puts "Congratulations-- no errors!"
ensure
   puts "Ensuring execution"
end

Это даст следующий результат -

I'm not raising exception
Congratulations-- no errors!
Ensuring execution

Сообщение об ошибке может быть записано с помощью $! переменная.

Поймай и брось

Хотя механизм исключения подъема и спасения отлично подходит для прекращения выполнения, когда что-то идет не так, иногда приятно иметь возможность выпрыгнуть из какой-то глубоко вложенной конструкции во время нормальной обработки. Вот здесь и пригодятся улов и бросок.

Улов определяет блок , который помечен с данным именем (которое может быть символ или строка). Блок выполняется нормально, пока не встретится бросок.

Синтаксис

throw :lablename
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end

OR

throw :lablename condition
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end

пример

В следующем примере бросок используется для прекращения взаимодействия с пользователем, если '!' вводится в ответ на любой запрос.

def promptAndGet(prompt)
   print prompt
   res = readline.chomp
   throw :quitRequested if res == "!"
   return res
end

catch :quitRequested do
   name = promptAndGet("Name: ")
   age = promptAndGet("Age: ")
   sex = promptAndGet("Sex: ")
   # ..
   # process information
end
promptAndGet("Name:")

Вам следует попробовать вышеуказанную программу на своем компьютере, потому что она требует ручного управления. Это даст следующий результат -

Name: Ruby on Rails
Age: 3
Sex: !
Name:Just Ruby

Исключение класса

Стандартные классы и модули Ruby вызывают исключения. Все классы исключений образуют иерархию с классом Exception вверху. Следующий уровень содержит семь разных типов -

  • Interrupt
  • NoMemoryError
  • SignalException
  • ScriptError
  • StandardError
  • SystemExit

Есть еще одно исключение на этом уровне, Fatal, но интерпретатор Ruby использует это только для внутренних целей.

И ScriptError, и StandardError имеют несколько подклассов, но нам не нужно вдаваться в подробности здесь. Важно то, что если мы создаем свои собственные классы исключений, они должны быть подклассами либо класса Exception, либо одного из его потомков.

Давайте посмотрим на пример -

class FileSaveError < StandardError
   attr_reader :reason
   def initialize(reason)
      @reason = reason
   end
end

Теперь посмотрите на следующий пример, в котором будет использоваться это исключение -

File.open(path, "w") do |file|
begin
   # Write out the data ...
rescue
   # Something went wrong!
   raise FileSaveError.new($!)
end
end

Важная строка здесь - поднять FileSaveError.new ($!) . Мы вызываем raise, чтобы сигнализировать о возникновении исключения, передавая ему новый экземпляр FileSaveError, по той причине, что это конкретное исключение привело к сбою записи данных.

Ruby - чистый объектно-ориентированный язык, и все кажется Ruby как объект. Каждое значение в Ruby - это объект, даже самые примитивные вещи: строки, числа и даже истина и ложь. Даже сам класс является объектом , являющимся экземпляром класса Class . В этой главе вы познакомитесь со всеми основными функциями, связанными с объектно-ориентированным Ruby.

Класс используется для определения формы объекта и объединяет представление данных и методы для управления этими данными в один аккуратный пакет. Данные и методы внутри класса называются членами класса.

Определение класса Ruby

Когда вы определяете класс, вы определяете схему для типа данных. Это фактически не определяет какие-либо данные, но определяет, что означает имя класса, то есть из чего будет состоять объект класса и какие операции могут быть выполнены с таким объектом.

Определение класса начинается с ключевого слова class за которым следует class name и ограничен end. Например, мы определили класс Box с использованием ключевого слова class следующим образом:

class Box
   code
end

Имя должно начинаться с заглавной буквы, и по соглашению имена, содержащие более одного слова, запускаются вместе с заглавными буквами и без разделительных символов (CamelCase).

Определить объекты Ruby

Класс предоставляет чертежи для объектов, поэтому в основном объект создается из класса. Объявляем объекты класса с помощьюnewключевое слово. Следующие утверждения объявляют два объекта класса Box -

box1 = Box.new
box2 = Box.new

Метод инициализации

В initialize method является стандартным методом класса Ruby и работает почти так же, как constructorработает на других объектно-ориентированных языках программирования. Метод инициализации полезен, когда вы хотите инициализировать некоторые переменные класса во время создания объекта. Этот метод может принимать список параметров и, как и любой другой метод Ruby, ему будет предшествоватьdef ключевое слово, как показано ниже -

class Box
   def initialize(w,h)
      @width, @height = w, h
   end
end

Переменные экземпляра

В instance variablesявляются своего рода атрибутами класса и становятся свойствами объектов после создания объектов с использованием класса. Атрибуты каждого объекта назначаются индивидуально и не имеют общего значения с другими объектами. Доступ к ним осуществляется с помощью оператора @ внутри класса, но для доступа к ним вне класса, который мы используемpublic методы, которые называются accessor methods. Если мы возьмем указанный выше классBox тогда @width и @height - переменные экземпляра для класса Box.

class Box
   def initialize(w,h)
      # assign instance variables
      @width, @height = w, h
   end
end

Методы доступа и установки

Чтобы переменные были доступны извне класса, они должны быть определены внутри accessor methodsэти методы доступа также известны как методы получения. В следующем примере показано использование методов доступа -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def printWidth
      @width
   end

   def printHeight
      @height
   end
end

# create an object
box = Box.new(10, 20)

# use accessor methods
x = box.printWidth()
y = box.printHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Когда приведенный выше код выполняется, он дает следующий результат:

Width of the box is : 10
Height of the box is : 20

Подобно методам доступа, которые используются для доступа к значениям переменных, Ruby предоставляет способ установить значения этих переменных извне класса, используя setter methods, которые определены ниже -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # setter methods
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# create an object
box = Box.new(10, 20)

# use setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Когда приведенный выше код выполняется, он дает следующий результат:

Width of the box is : 30
Height of the box is : 50

Методы экземпляра

В instance methods также определены так же, как мы определяем любой другой метод, используя defключевое слово, и их можно использовать, используя экземпляр класса, только как показано ниже. Их функциональность не ограничивается доступом к переменным экземпляра, но они также могут делать намного больше в соответствии с вашими требованиями.

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

Когда приведенный выше код выполняется, он дает следующий результат:

Area of the box is : 200

Методы и переменные класса

В class variables- это переменная, которая используется всеми экземплярами класса. Другими словами, существует один экземпляр переменной, и к нему обращаются экземпляры объекта. Переменные класса начинаются с двух символов @ (@@). Переменная класса должна быть инициализирована в определении класса, как показано ниже.

Метод класса определяется с использованием def self.methodname(), который заканчивается конечным разделителем и будет вызываться с использованием имени класса как classname.methodname как показано в следующем примере -

#!/usr/bin/ruby -w

class Box
   # Initialize our class variables
   @@count = 0
   def initialize(w,h)
      # assign instance avriables
      @width, @height = w, h

      @@count += 1
   end

   def self.printCount()
      puts "Box count is : #@@count"
   end
end

# create two object
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)

# call class method to print box count
Box.printCount()

Когда приведенный выше код выполняется, он дает следующий результат:

Box count is : 2

Метод to_s

Любой определяемый вами класс должен иметь to_sметод экземпляра, чтобы вернуть строковое представление объекта. Ниже приведен простой пример представления объекта Box с точки зрения ширины и высоты.

#!/usr/bin/ruby -w

class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # define to_s method
   def to_s
      "(w:#@width,h:#@height)"  # string formatting of the object.
   end
end

# create an object
box = Box.new(10, 20)

# to_s method will be called in reference of string automatically.
puts "String representation of box is : #{box}"

Когда приведенный выше код выполняется, он дает следующий результат:

String representation of box is : (w:10,h:20)

Контроль доступа

Ruby предоставляет вам три уровня защиты на уровне методов экземпляра, которые могут быть public, private, or protected. Ruby не применяет никакого контроля доступа к переменным экземпляра и класса.

  • Public Methods- Публичные методы могут быть вызваны кем угодно. По умолчанию методы являются общедоступными, за исключением инициализации, которая всегда является частной.

  • Private Methods- К закрытым методам нельзя получить доступ или даже просмотреть их извне. Только методы класса могут получить доступ к закрытым членам.

  • Protected Methods- Защищенный метод может быть вызван только объектами определяющего класса и его подклассов. Доступ сохраняется внутри семьи.

Ниже приведен простой пример, показывающий синтаксис всех трех модификаторов доступа.

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # instance method by default it is public
   def getArea
      getWidth() * getHeight
   end

   # define private accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end
   # make them private
   private :getWidth, :getHeight

   # instance method to print area
   def printArea
      @area = getWidth() * getHeight
      puts "Big box area is : #@area"
   end
   # make it protected
   protected :printArea
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

# try to call protected or methods
box.printArea()

Когда приведенный выше код выполняется, он дает следующий результат. Здесь первый метод вызывается успешно, но второй метод дал проблему.

Area of the box is : 200
test.rb:42: protected method `printArea' called for #
<Box:0xb7f11280 @height = 20, @width = 10> (NoMethodError)

Наследование класса

Одна из наиболее важных концепций объектно-ориентированного программирования - это наследование. Наследование позволяет нам определять класс в терминах другого класса, что упрощает создание и поддержку приложения.

Наследование также дает возможность повторно использовать функциональность кода и быстрое время реализации, но, к сожалению, Ruby не поддерживает несколько уровней наследования, но Ruby поддерживает mixins. Примесь похожа на специализированную реализацию множественного наследования, в которой наследуется только часть интерфейса.

При создании класса вместо написания полностью новых элементов данных и функций-членов программист может указать, что новый класс должен наследовать члены существующего класса. Этот существующий класс называетсяbase class or superclass, а новый класс называется derived class or sub-class.

Ruby также поддерживает концепцию создания подклассов, то есть наследования, и следующий пример объясняет эту концепцию. Синтаксис расширения класса прост. Просто добавьте символ <и имя суперкласса в оператор класса. Например, следующее определение класса BigBox как подкласса Box -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# define a subclass
class BigBox < Box

   # add a new instance method
   def printArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area
box.printArea()

Когда приведенный выше код выполняется, он дает следующий результат:

Big box area is : 200

Переопределение методов

Хотя вы можете добавить новую функциональность в производный класс, но иногда вы хотите изменить поведение уже определенного метода в родительском классе. Вы можете сделать это, просто оставив имя метода таким же и переопределив функциональность метода, как показано ниже в примере:

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# define a subclass
class BigBox < Box

   # change existing getArea method as follows
   def getArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area using overriden method.
box.getArea()

Перегрузка оператора

Мы хотели бы, чтобы оператор + выполнял векторное сложение двух объектов Box с помощью +, оператор * для умножения ширины и высоты Box на скаляр, а унарный оператор - для инвертирования ширины и высоты Box. Вот версия класса Box с определенными математическими операторами -

class Box
   def initialize(w,h)     # Initialize the width and height
      @width,@height = w, h
   end

   def +(other)       # Define + to do vector addition
      Box.new(@width + other.width, @height + other.height)
   end

   def -@           # Define unary minus to negate width and height
      Box.new(-@width, -@height)
   end

   def *(scalar)           # To perform scalar multiplication
      Box.new(@width*scalar, @height*scalar)
   end
end

Замораживание объектов

Иногда мы хотим предотвратить изменение объекта. Метод замораживания в Object позволяет нам делать это, эффективно превращая объект в константу. Любой объект можно заморозить, вызвавObject.freeze. Замороженный объект не может быть изменен: вы не можете изменить его переменные экземпляра.

Вы можете проверить, заморожен ли данный объект или нет, используя Object.frozen?метод, который возвращает истину, если объект заморожен, в противном случае возвращается ложное значение. Следующий пример проясняет концепцию -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # setter methods
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# create an object
box = Box.new(10, 20)

# let us freez this object
box.freeze
if( box.frozen? )
   puts "Box object is frozen object"
else
   puts "Box object is normal object"
end

# now try using setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Когда приведенный выше код выполняется, он дает следующий результат:

Box object is frozen object
test.rb:20:in `setWidth=': can't modify frozen object (TypeError)
   from test.rb:39

Константы класса

Вы можете определить константу внутри класса, присвоив переменной прямое числовое или строковое значение, которое определяется без использования @ или @@. По соглашению мы сохраняем постоянные имена в верхнем регистре.

После определения константы вы не можете изменить ее значение, но вы можете получить доступ к константе непосредственно внутри класса, как и к переменной, но если вы хотите получить доступ к константе за пределами класса, вам придется использовать classname::constant как показано в примере ниже.

#!/usr/bin/ruby -w

# define a class
class Box
   BOX_COMPANY = "TATA Inc"
   BOXWEIGHT = 10
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

Когда приведенный выше код выполняется, он дает следующий результат:

Area of the box is : 200
TATA Inc
Box weight is: 10

Константы класса наследуются и могут быть переопределены, как методы экземпляра.

Создать объект с помощью Allocate

Возможна ситуация, когда вы хотите создать объект, не вызывая его конструктор initializeт.е. используя новый метод, в таком случае вы можете вызвать allocate , который создаст для вас неинициализированный объект, как в следующем примере -

#!/usr/bin/ruby -w

# define a class
class Box
   attr_accessor :width, :height

   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # instance method
   def getArea
      @width * @height
   end
end

# create an object using new
box1 = Box.new(10, 20)

# create another object using allocate
box2 = Box.allocate

# call instance method using box1
a = box1.getArea()
puts "Area of the box is : #{a}"

# call instance method using box2
a = box2.getArea()
puts "Area of the box is : #{a}"

Когда приведенный выше код выполняется, он дает следующий результат:

Area of the box is : 200
test.rb:14: warning: instance variable @width not initialized
test.rb:14: warning: instance variable @height not initialized
test.rb:14:in `getArea': undefined method `*' 
   for nil:NilClass (NoMethodError) from test.rb:29

Информация о классе

Если определения классов являются исполняемым кодом, это означает, что они выполняются в контексте некоторого объекта: self должен ссылаться на что-то. Давайте узнаем, что это такое.

#!/usr/bin/ruby -w

class Box
   # print class information
   puts "Type of self = #{self.type}"
   puts "Name of self = #{self.name}"
end

Когда приведенный выше код выполняется, он дает следующий результат:

Type of self = Class
Name of self = Box

Это означает, что определение класса выполняется с этим классом в качестве текущего объекта. Это означает, что методы в метаклассе и его суперклассах будут доступны во время выполнения определения метода.

Регулярное выражение специальная последовательность символов , которая позволяет соответствовать или найти другие строки или наборы строк , используя специализированный синтаксис провел в шаблоне.

Регулярное выражение буквальное является шаблоном между косой чертой или между произвольными разделителями с последующими% г следующим образом: -

Синтаксис

/pattern/
/pattern/im    # option can be specified
%r!/usr/local! # general delimited regular expression

пример

#!/usr/bin/ruby

line1 = "Cats are smarter than dogs";
line2 = "Dogs also like meat";

if ( line1 =~ /Cats(.*)/ )
   puts "Line1 contains Cats"
end
if ( line2 =~ /Cats(.*)/ )
   puts "Line2 contains  Dogs"
end

Это даст следующий результат -

Line1 contains Cats

Модификаторы регулярного выражения

Литералы регулярных выражений могут включать необязательный модификатор для управления различными аспектами сопоставления. Модификатор указывается после второго символа косой черты, как показано ранее, и может быть представлен одним из этих символов -

Sr.No. Модификатор и описание
1

i

Игнорирует регистр при сопоставлении текста.

2

o

Выполняет интерполяцию # {} только один раз, при первом вычислении литерала регулярного выражения.

3

x

Игнорирует пробелы и разрешает комментарии в регулярных выражениях.

4

m

Соответствует нескольким строкам, распознавая символы новой строки как обычные символы.

5

u,e,s,n

Интерпретирует регулярное выражение как Unicode (UTF-8), EUC, SJIS или ASCII. Если ни один из этих модификаторов не указан, предполагается, что регулярное выражение использует исходную кодировку.

Подобно строковым литералам, разделенным% Q, Ruby позволяет начинать регулярные выражения с% r, за которым следует разделитель по вашему выбору. Это полезно, когда шаблон, который вы описываете, содержит много символов прямой косой черты, которые вы не хотите экранировать -

# Following matches a single slash character, no escape required
%r|/|

# Flag characters are allowed with this syntax, too
%r[</(.*)>]i

Шаблоны регулярных выражений

За исключением управляющих символов, (+ ? . * ^ $ ( ) [ ] { } | \), все символы совпадают. Вы можете экранировать управляющий символ, поставив перед ним обратную косую черту.

Sr.No. Узор и описание
1

^

Соответствует началу строки.

2

$

Соответствует концу строки.

3

.

Соответствует любому одиночному символу, кроме новой строки. Использование опции m также позволяет сопоставить новую строку.

4

[...]

Соответствует любому одиночному символу в скобках.

5

[^...]

Соответствует любому одиночному символу не в скобках

6

re*

Соответствует 0 или более вхождениям предыдущего выражения.

7

re+

Соответствует одному или нескольким вхождениям предыдущего выражения.

8

re?

Соответствует 0 или 1 вхождению предыдущего выражения.

9

re{ n}

Соответствует ровно n повторениям предыдущего выражения.

10

re{ n,}

Соответствует n или нескольким вхождениям предыдущего выражения.

11

re{ n, m}

Соответствует как минимум n и максимум m вхождениям предыдущего выражения.

12

a| b

Соответствует либо a, либо b.

13

(re)

Группирует регулярные выражения и запоминает совпадающий текст.

14

(?imx)

Временно переключает параметры i, m или x в регулярном выражении. Если указано в скобках, будет затронута только эта область.

15

(?-imx)

Временно отключает параметры i, m или x в регулярном выражении. Если указано в скобках, будет затронута только эта область.

16

(?: re)

Группирует регулярные выражения без запоминания совпадающего текста.

17

(?imx: re)

Временно переключает параметры i, m или x в скобках.

18

(?-imx: re)

Временно отключает параметры i, m или x в скобках.

19

(?#...)

Комментарий.

20

(?= re)

Определяет положение с помощью шаблона. Не имеет диапазона.

21 год

(?! re)

Определяет позицию с использованием отрицания шаблона. Не имеет диапазона.

22

(?> re)

Соответствует независимому шаблону без возврата.

23

\w

Соответствует символам слова.

24

\W

Соответствует несловесным символам.

25

\s

Соответствует пробелу. Эквивалентно [\ t \ n \ r \ f].

26

\S

Соответствует пробелам.

27

\d

Соответствует цифрам. Эквивалентно [0-9].

28

\D

Соответствует нецифровым значениям.

29

\A

Соответствует началу строки.

30

\Z

Соответствует концу строки. Если новая строка существует, она соответствует непосредственно перед новой строкой.

31 год

\z

Соответствует концу строки.

32

\G

Место, где закончился последний матч.

33

\b

Соответствует границам слова вне скобок. Соответствует пробелу (0x08) внутри скобок.

34

\B

Соответствует границам без слов.

35 год

\n, \t, etc.

Соответствует символам новой строки, возврата каретки, табуляции и т. Д.

36

\1...\9

Соответствует n-му сгруппированному подвыражению.

37

\10

Соответствует n-му сгруппированному подвыражению, если оно уже совпало. В противном случае относится к восьмеричному представлению символьного кода.

Примеры регулярных выражений

Sr.No. Пример и описание
1

/ruby/

Спички «рубин».

2

¥

Соответствует знаку иены. Многобайтовые символы поддерживаются в Ruby 1.9 и Ruby 1.8.

Sr.No. Пример и описание
1

/[Rr]uby/

Соответствует «Рубин» или «Рубин».

2

/rub[ye]/

Соответствует «рубин» или «рубин».

3

/[aeiou]/

Соответствует любой гласной в нижнем регистре.

4

/[0-9]/

Соответствует любой цифре; то же, что и / [0123456789] /.

5

/[a-z]/

Соответствует любой строчной букве ASCII.

6

/[A-Z]/

Соответствует любой заглавной букве ASCII.

7

/[a-zA-Z0-9]/

Соответствует любому из вышеперечисленных.

8

/[^aeiou]/

Соответствует чему-либо, кроме гласной строчной буквы.

9

/[^0-9]/

Соответствует чему-либо, кроме цифры.

Sr.No. Пример и описание
1

/./

Соответствует любому символу, кроме новой строки.

2

/./m

В многострочном режиме также соответствует новой строке.

3

/\d/

Соответствует цифре: / [0-9] /.

4

/\D/

Соответствует нецифровой: / [^ 0-9] /.

5

/\s/

Соответствует пробельному символу: / [\ t \ r \ n \ f] /.

6

/\S/

Соответствует пробелам: / [^ \ t \ r \ n \ f] /.

7

/\w/

Соответствует символу из одного слова: / [A-Za-z0-9 _] /.

8

/\W/

Соответствует несловному символу: / [^ A-Za-z0-9 _] /.

Sr.No. Пример и описание
1

/ruby?/

Соответствует "rub" или "ruby": y не является обязательным.

2

/ruby*/

Соответствует "руб" плюс 0 или более у.

3

/ruby+/

Соответствует «руб» плюс 1 и более у.

4

/\d{3}/

Соответствует ровно 3 цифрам.

5

/\d{3,}/

Соответствует 3 или более цифрам.

6

/\d{3,5}/

Соответствует 3, 4 или 5 цифрам.

Это соответствует наименьшему количеству повторений -

Sr.No. Пример и описание
1

/<.*>/

Жадное повторение: соответствует "<ruby> perl>".

2

/<.*?>/

Нежадный: соответствует "<ruby>" в "<ruby> perl>".

Sr.No. Пример и описание
1

/\D\d+/

Нет группы: + повторяет \ d

2

/(\D\d)+/

Сгруппировано: + повторяет пару \ D \ d

3

/([Rr]uby(, )?)+/

Матч «Рубин», «Рубин, рубин, рубин» и др.

Это снова соответствует ранее подобранной группе -

Sr.No. Пример и описание
1

/([Rr])uby&\1ails/

Соответствует Ruby & Rails или Ruby & Rails.

2

/(['"])(?:(?!\1).)*\1/

Строка в одинарных или двойных кавычках. \ 1 соответствует тому, что соответствует первой группе. \ 2 соответствует тому, что соответствует второй группе и т. Д.

Sr.No. Пример и описание
1

/ruby|rube/

Соответствует «рубин» или «рубин».

2

/rub(y|le))/

Соответствует «рубин» или «рубль».

3

/ruby(!+|\?)/

"рубин", за которым следует один или несколько! или один?

Необходимо указать позицию совпадения.

Sr.No. Пример и описание
1

/^Ruby/

Соответствует «Ruby» в начале строки или внутренней строки.

2

/Ruby$/

Соответствует «Ruby» в конце строки или строки.

3

/\ARuby/

Соответствует «Ruby» в начале строки.

4

/Ruby\Z/

Соответствует «Рубин» в конце строки.

5

/\bRuby\b/

Соответствует «Ruby» на границе слова.

6

/\brub\B/

\ B не является границей слова: соответствует «rub» в «rube» и «ruby», но не только.

7

/Ruby(?=!)/

Соответствует "Ruby", если после него стоит восклицательный знак.

8

/Ruby(?!!)/

Соответствует "Ruby", если после него не стоит восклицательный знак.

Sr.No. Пример и описание
1

/R(?#comment)/

Матчи «Р». Все остальное - комментарий.

2

/R(?i)uby/

Без учета регистра при сопоставлении "uby".

3

/R(?i:uby)/

То же, что и выше.

4

/rub(?:y|le))/

Группировать только без создания обратной ссылки \ 1.

Искать и заменить

Некоторые из наиболее важных методов String, использующих регулярные выражения: sub и gsub, и их варианты на месте sub! и gsub!.

Все эти методы выполняют операцию поиска и замены с использованием шаблона Regexp. Вsub & sub! заменяет первое вхождение шаблона и gsub & gsub! заменяет все вхождения.

В sub и gsub возвращает новую строку, оставляя исходную неизмененной, где как sub! и gsub! изменить строку, в которой они вызываются.

Ниже приведен пример -

#!/usr/bin/ruby

phone = "2004-959-559 #This is Phone Number"

# Delete Ruby-style comments
phone = phone.sub!(/#.*$/, "")   
puts "Phone Num : #{phone}"

# Remove anything other than digits
phone = phone.gsub!(/\D/, "")    
puts "Phone Num : #{phone}"

Это даст следующий результат -

Phone Num : 2004-959-559
Phone Num : 2004959559

Ниже приводится еще один пример -

#!/usr/bin/ruby

text = "rails are rails, really good Ruby on Rails"

# Change "rails" to "Rails" throughout
text.gsub!("rails", "Rails")

# Capitalize the word "Rails" throughout
text.gsub!(/\brails\b/, "Rails")
puts "#{text}"

Это даст следующий результат -

Rails are Rails, really good Ruby on Rails

В этой главе рассказывается, как получить доступ к базе данных с помощью Ruby. Модуль Ruby DBI предоставляет независимый от базы данных интерфейс для сценариев Ruby, аналогичный интерфейсу модуля Perl DBI.

DBI расшифровывается как Database Independent Interface для Ruby, что означает, что DBI обеспечивает уровень абстракции между кодом Ruby и базовой базой данных, что позволяет очень легко переключать реализации базы данных. Он определяет набор методов, переменных и соглашений, которые обеспечивают согласованный интерфейс базы данных, независимо от фактической используемой базы данных.

DBI может взаимодействовать со следующим:

  • ADO (объекты данных ActiveX)
  • DB2
  • Frontbase
  • mSQL
  • MySQL
  • ODBC
  • Oracle
  • OCI8 (Oracle)
  • PostgreSQL
  • Proxy/Server
  • SQLite
  • SQLRelay

Архитектура приложения DBI

DBI не зависит от какой-либо базы данных, доступной в серверной части. DBI можно использовать независимо от того, работаете ли вы с Oracle, MySQL или Informix и т. Д. Это ясно из следующей диаграммы архитектуры.

Общая архитектура Ruby DBI использует два уровня:

  • Уровень интерфейса базы данных (DBI). Этот уровень не зависит от базы данных и предоставляет набор общих методов доступа, которые используются одинаково независимо от типа сервера базы данных, с которым вы общаетесь.

  • Уровень драйвера базы данных (DBD). Этот уровень зависит от базы данных; разные драйверы предоставляют доступ к разным ядрам баз данных. Есть один драйвер для MySQL, другой для PostgreSQL, третий для InterBase, третий для Oracle и так далее. Каждый драйвер интерпретирует запросы от уровня DBI и отображает их на запросы, соответствующие данному типу сервера базы данных.

Предпосылки

Если вы хотите писать сценарии Ruby для доступа к базам данных MySQL, вам потребуется установить модуль Ruby MySQL.

Этот модуль действует как DBD, как описано выше, и может быть загружен с https://www.tmtm.org/en/mysql/ruby/

Получение и установка Ruby / DBI

Вы можете загрузить и установить модуль Ruby DBI из следующего места -

https://imgur.com/NFEuWe4/embed

Перед началом установки убедитесь, что у вас есть права root. Теперь следуйте инструкциям, приведенным ниже -

Шаг 1

$ tar zxf dbi-0.2.0.tar.gz

Шаг 2

Перейдите в каталог распространения dbi-0.2.0 и настройте его с помощью сценария setup.rb в этом каталоге. Самая общая команда конфигурации выглядит так, без аргументов после аргумента конфигурации. Эта команда настраивает дистрибутив на установку всех драйверов по умолчанию.

$ ruby setup.rb config

Чтобы быть более конкретным, укажите параметр --with, в котором перечислены определенные части дистрибутива, которые вы хотите использовать. Например, чтобы настроить только основной модуль DBI и драйвер уровня MySQL DBD, введите следующую команду -

$ ruby setup.rb config --with = dbi,dbd_mysql

Шаг 3

Последний шаг - собрать драйвер и установить его с помощью следующих команд:

$ ruby setup.rb setup $ ruby setup.rb install

Подключение к базе данных

Предполагая, что мы собираемся работать с базой данных MySQL, перед подключением к базе данных убедитесь в следующем:

  • Вы создали базу данных TESTDB.

  • Вы создали EMPLOYEE в TESTDB.

  • В этой таблице есть поля FIRST_NAME, LAST_NAME, AGE, SEX и INCOME.

  • Идентификатор пользователя testuser и пароль test123 установлены для доступа к TESTDB.

  • Ruby Module DBI правильно установлен на вашем компьютере.

  • Вы прошли обучение MySQL, чтобы понять основы MySQL.

Ниже приведен пример подключения к базе данных MySQL «TESTDB».

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   # get server version string and display it
   row = dbh.select_one("SELECT VERSION()")
   puts "Server version: " + row[0]
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

При запуске этого сценария он дает следующий результат на нашей машине с Linux.

Server version: 5.0.45

Если соединение установлено с источником данных, то дескриптор базы данных возвращается и сохраняется в dbh для дальнейшего использования в противном случае dbhустановлено значение nil, а e.err и e :: errstr возвращают код ошибки и строку ошибки соответственно.

И, наконец, перед выходом убедитесь, что соединение с базой данных закрыто и ресурсы освобождены.

ВСТАВИТЬ операцию

Операция INSERT требуется, если вы хотите создать свои записи в таблице базы данных.

Как только соединение с базой данных установлено, мы готовы создавать таблицы или записи в таблицах базы данных, используя do метод или prepare и execute метод.

Использование инструкции do

Операторы, которые не возвращают строки, могут быть выданы путем вызова doметод дескриптора базы данных. Этот метод принимает строковый аргумент оператора и возвращает количество строк, затронутых оператором.

dbh.do("DROP TABLE IF EXISTS EMPLOYEE")
dbh.do("CREATE TABLE EMPLOYEE (
   FIRST_NAME  CHAR(20) NOT NULL,
   LAST_NAME  CHAR(20),
   AGE INT,  
   SEX CHAR(1),
   INCOME FLOAT )" );

Точно так же вы можете выполнить инструкцию SQL INSERT, чтобы создать запись в таблице EMPLOYEE.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   dbh.do( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
      VALUES ('Mac', 'Mohan', 20, 'M', 2000)" )
   puts "Record has been created"
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Использование подготовить и выполнить

Вы можете использовать методы подготовки и выполнения класса DBI для выполнения оператора SQL через код Ruby.

Создание записи требует следующих шагов -

  • Подготовка оператора SQL с оператором INSERT. Это будет сделано с помощьюprepare метод.

  • Выполнение SQL-запроса для выбора всех результатов из базы данных. Это будет сделано с помощьюexecute метод.

  • Освобождение дескриптора заявления. Это будет сделано с помощьюfinish API

  • Если все будет хорошо, то commit эту операцию в противном случае вы можете rollback полная транзакция.

Ниже приведен синтаксис использования этих двух методов:

sth = dbh.prepare(statement)
sth.execute
   ... zero or more SQL operations ...
sth.finish

Эти два метода можно использовать для передачи bindзначения для операторов SQL. Возможен случай, когда значения для ввода не указаны заранее. В таком случае используются значения привязки. Знак вопроса (?) используется вместо фактических значений, а затем фактические значения передаются через API-интерфейс execute ().

Ниже приведен пример создания двух записей в таблице EMPLOYEE:

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
      VALUES (?, ?, ?, ?, ?)" )
   sth.execute('John', 'Poul', 25, 'M', 2300)
   sth.execute('Zara', 'Ali', 17, 'F', 1000)
   sth.finish
   dbh.commit
   puts "Record has been created"
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Если одновременно выполняется несколько INSERT, то сначала подготовка оператора, а затем его выполнение несколько раз в цикле более эффективна, чем вызов do каждый раз в цикле.

ПРОЧИТАТЬ операцию

READ Операция с любой базой данных означает получение некоторой полезной информации из базы данных.

Как только наше соединение с базой данных установлено, мы готовы сделать запрос в эту базу данных. Мы можем использовать либоdo метод или prepare и execute методы для получения значений из таблицы базы данных.

Получение записи требует следующих шагов -

  • Подготовка SQL-запроса на основе необходимых условий. Это будет сделано с помощьюprepare метод.

  • Выполнение SQL-запроса для выбора всех результатов из базы данных. Это будет сделано с помощьюexecute метод.

  • Получение всех результатов по одному и их печать. Это будет сделано с помощьюfetch метод.

  • Освобождение дескриптора заявления. Это будет сделано с помощьюfinish метод.

Ниже приведена процедура запроса всех записей из таблицы EMPLOYEE с зарплатой более 1000.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("SELECT * FROM EMPLOYEE WHERE INCOME > ?")
   sth.execute(1000)

   sth.fetch do |row|
   printf "First Name: %s, Last Name : %s\n", row[0], row[1]
   printf "Age: %d, Sex : %s\n", row[2], row[3]
   printf "Salary :%d \n\n", row[4]
end
   sth.finish
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Это даст следующий результат -

First Name: Mac, Last Name : Mohan
Age: 20, Sex : M
Salary :2000

First Name: John, Last Name : Poul
Age: 25, Sex : M
Salary :2300

Есть более короткие методы для получения записей из базы данных. Если вам интересно, пройдите через Получение результата, в противном случае переходите к следующему разделу.

Операция обновления

UPDATE Операция с любой базой данных означает обновление одной или нескольких записей, которые уже доступны в базе данных. Ниже приводится процедура обновления всех записей, в которых SEX обозначается буквой «M». Здесь мы увеличим ВОЗРАСТ всех мужчин на один год. Это займет три шага -

  • Подготовка SQL-запроса на основе необходимых условий. Это будет сделано с помощьюprepare метод.

  • Выполнение SQL-запроса для выбора всех результатов из базы данных. Это будет сделано с помощьюexecute метод.

  • Освобождение дескриптора заявления. Это будет сделано с помощьюfinish метод.

  • Если все пойдет хорошо, тогда commit эту операцию в противном случае вы можете rollback полная транзакция.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = ?")
   sth.execute('M')
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

УДАЛИТЬ операцию

Операция DELETE требуется, если вы хотите удалить некоторые записи из своей базы данных. Ниже приведена процедура удаления всех записей из EMPLOYEE, для которых ВОЗРАСТ больше 20. Эта операция потребует следующих шагов.

  • Подготовка SQL-запроса на основе необходимых условий. Это будет сделано с помощьюprepare метод.

  • Выполнение SQL-запроса для удаления необходимых записей из базы данных. Это будет сделано с помощьюexecute метод.

  • Освобождение дескриптора заявления. Это будет сделано с помощьюfinish метод.

  • Если все пойдет хорошо, тогда commit эту операцию в противном случае вы можете rollback полная транзакция.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("DELETE FROM EMPLOYEE WHERE AGE > ?")
   sth.execute(20)
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Выполнение транзакций

Транзакции - это механизм, обеспечивающий согласованность данных. Транзакции должны иметь следующие четыре свойства -

  • Atomicity - Либо транзакция завершается, либо вообще ничего не происходит.

  • Consistency - Транзакция должна начинаться в согласованном состоянии и выходить из системы в согласованном состоянии.

  • Isolation - Промежуточные результаты транзакции не видны вне текущей транзакции.

  • Durability - После фиксации транзакции последствия сохраняются даже после сбоя системы.

DBI предоставляет два метода для фиксации или отката транзакции. Есть еще один метод, называемый транзакцией, который можно использовать для выполнения транзакций. Есть два простых подхода к реализации транзакций:

Подход I

Первый подход использует методы фиксации и отката DBI для явной фиксации или отмены транзакции -

dbh['AutoCommit'] = false # Set auto commit to false.
begin
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
   dbh.commit
rescue
   puts "transaction failed"
   dbh.rollback
end
dbh['AutoCommit'] = true

Подход II

Второй подход использует метод транзакции . Это проще, потому что требуется блок кода, содержащий операторы, составляющие транзакцию. Метод транзакции выполняет блок, а затем автоматически вызывает фиксацию или откат , в зависимости от того, успешно или нет блок -

dbh['AutoCommit'] = false # Set auto commit to false.
dbh.transaction do |dbh|
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
end
dbh['AutoCommit'] = true

COMMIT Operation

Фиксация - это операция, которая дает зеленый сигнал базе данных о завершении изменений, и после этой операции никакие изменения не могут быть отменены.

Вот простой пример вызова commit метод.

dbh.commit

ROLLBACK Операция

Если вас не устраивает одно или несколько изменений и вы хотите полностью отменить эти изменения, используйте rollback метод.

Вот простой пример вызова rollback метод.

dbh.rollback

Отключение базы данных

Чтобы отключить соединение с базой данных, используйте API отключения.

dbh.disconnect

Если соединение с базой данных закрывается пользователем с помощью метода отключения, все невыполненные транзакции откатываются DBI. Однако вместо того, чтобы зависеть от каких-либо деталей реализации DBI, вашему приложению было бы лучше явно вызывать фиксацию или откат.

Обработка ошибок

Есть много источников ошибок. Несколько примеров - это синтаксическая ошибка в выполненном операторе SQL, сбой соединения или вызов метода выборки для уже отмененного или завершенного дескриптора оператора.

Если метод DBI не работает, DBI вызывает исключение. Методы DBI могут вызывать любой из нескольких типов исключений, но двумя наиболее важными классами исключений являются DBI :: InterfaceError и DBI :: DatabaseError .

Объекты-исключения этих классов имеют три атрибута с именами err , errstr и state , которые представляют номер ошибки, описательную строку ошибки и стандартный код ошибки. Атрибуты объяснены ниже -

  • err- Возвращает целочисленное представление произошедшей ошибки или ноль, если это не поддерживается DBD. Oracle DBD, например, возвращает числовую часть сообщения об ошибке ORA-XXXX .

  • errstr - Возвращает строковое представление произошедшей ошибки.

  • state- Возвращает код SQLSTATE возникшей ошибки. SQLSTATE представляет собой строку из пяти символов. Большинство DBD не поддерживают это и вместо этого возвращают nil.

Вы видели следующий код выше в большинстве примеров -

rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Чтобы получить отладочную информацию о том, что делает ваш скрипт при выполнении, вы можете включить трассировку. Для этого вы должны сначала загрузить модуль dbi / trace, а затем вызвать метод трассировки, который управляет режимом трассировки и местом назначения вывода -

require "dbi/trace"
..............

trace(mode, destination)

Значение режима может быть 0 (выключено), 1, 2 или 3, а местом назначения должен быть объект ввода-вывода. Значения по умолчанию - 2 и STDERR соответственно.

Блоки кода с методами

Есть несколько методов создания дескрипторов. Эти методы можно вызывать с помощью блока кода. Преимущество использования блока кода вместе с методами заключается в том, что они предоставляют дескриптор блока кода в качестве его параметра и автоматически очищают дескриптор при завершении блока. Есть несколько примеров для понимания концепции.

  • DBI.connect- Этот метод генерирует дескриптор базы данных, и рекомендуется вызвать отключение в конце блока, чтобы отключить базу данных.

  • dbh.prepare- Этот метод генерирует дескриптор оператора, и его рекомендуется завершить в конце блока. В блоке, вы должны вызвать выполнить метод выполнения оператора.

  • dbh.execute- Этот метод аналогичен, за исключением того, что нам не нужно вызывать выполнение внутри блока. Дескриптор оператора выполняется автоматически.

Пример 1

DBI.connect может взять блок кода, передать ему дескриптор базы данных и автоматически отсоединить дескриптор в конце блока следующим образом.

dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") do |dbh|

Пример 2

dbh.prepare может взять блок кода, передать ему дескриптор оператора и автоматически вызвать finish в конце блока, как показано ниже.

dbh.prepare("SHOW DATABASES") do |sth|
   sth.execute
   puts "Databases: " + sth.fetch_all.join(", ")
end

Пример 3

dbh.execute может взять блок кода, передать ему дескриптор оператора и автоматически вызвать finish в конце блока следующим образом:

dbh.execute("SHOW DATABASES") do |sth|
   puts "Databases: " + sth.fetch_all.join(", ")
end

Метод транзакции DBI также принимает блок кода, описанный выше.

Функции и атрибуты, специфичные для драйвера

DBI позволяет драйверам базы данных предоставлять дополнительные специфичные для базы данных функции, которые могут быть вызваны пользователем с помощью метода func любого объекта Handle.

Поддерживаются атрибуты, специфичные для драйвера, и их можно установить или получить с помощью []= или же [] методы.

Sr.No. Функции и описание
1

dbh.func(:createdb, db_name)

Создает новую базу данных.

2

dbh.func(:dropdb, db_name)

Удаляет базу данных.

3

dbh.func(:reload)

Выполняет операцию перезагрузки.

4

dbh.func(:shutdown)

Выключает сервер.

5

dbh.func(:insert_id) => Fixnum

Возвращает самое последнее значение AUTO_INCREMENT для соединения.

6

dbh.func(:client_info) => String

Возвращает информацию о клиенте MySQL с указанием версии.

7

dbh.func(:client_version) => Fixnum

Возвращает информацию о клиенте по версии. Это похоже на: client_info, но возвращает fixnum вместо sting.

8

dbh.func(:host_info) => String

Возвращает информацию о хосте.

9

dbh.func(:proto_info) => Fixnum

Возвращает протокол, используемый для связи.

10

dbh.func(:server_info) => String

Возвращает информацию о сервере MySQL с указанием версии.

11

dbh.func(:stat) => String

Возвращает текущее состояние базы данных.

12

dbh.func(:thread_id) => Fixnum

Возвращает идентификатор текущего потока.

пример

#!/usr/bin/ruby

require "dbi"
begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") 
   puts dbh.func(:client_info)
   puts dbh.func(:client_version)
   puts dbh.func(:host_info)
   puts dbh.func(:proto_info)
   puts dbh.func(:server_info)
   puts dbh.func(:thread_id)
   puts dbh.func(:stat)
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   dbh.disconnect if dbh
end

Это даст следующий результат -

5.0.45
50045
Localhost via UNIX socket
10
5.0.45
150621
Uptime: 384981  Threads: 1  Questions: 1101078  Slow queries: 4 \
Opens: 324  Flush tables: 1  Open tables: 64  \
Queries per second avg: 2.860

Ruby - это язык общего назначения; его вообще нельзя правильно назвать веб-языком . Тем не менее, веб-приложения и веб-инструменты в целом являются одними из наиболее распространенных применений Ruby.

Вы можете не только написать свой собственный SMTP-сервер, FTP-демон или веб-сервер на Ruby, но вы также можете использовать Ruby для более обычных задач, таких как программирование CGI или как замена PHP.

Пожалуйста, потратьте несколько минут на Учебник по программированию CGI, чтобы получить более подробную информацию о программировании CGI.

Написание сценариев CGI

Самый простой скрипт CGI на Ruby выглядит так:

#!/usr/bin/ruby

puts "HTTP/1.0 200 OK"
puts "Content-type: text/html\n\n"
puts "<html><body>This is a test</body></html>"

Если вы вызовете этот сценарий test.cgi и загрузите его поставщику веб-хостинга на базе Unix с соответствующими разрешениями, вы можете использовать его как сценарий CGI.

Например, если у вас есть веб-сайт https://www.example.com/размещается у поставщика веб-хостинга Linux, и вы загружаете test.cgi в основной каталог и даете ему права на выполнение, а затем посещаетеhttps://www.example.com/test.cgi должен вернуть HTML-страницу, говорящую This is a test.

Здесь, когда test.cgi запрашивается из веб-браузера, веб-сервер ищет test.cgi на веб-сайте, а затем выполняет его с помощью интерпретатора Ruby. Сценарий Ruby возвращает базовый заголовок HTTP, а затем - базовый документ HTML.

Использование cgi.rb

Ruby поставляется со специальной библиотекой под названием cgi это обеспечивает более сложные взаимодействия, чем в предыдущем сценарии CGI.

Давайте создадим базовый сценарий CGI, который использует cgi -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new

puts cgi.header
puts "<html><body>This is a test</body></html>"

Здесь вы создали CGI-объект и использовали его для печати строки заголовка.

Обработка форм

Использование класса CGI дает вам доступ к параметрам HTML-запроса двумя способами. Предположим, нам дан URL-адрес /cgi-bin/test.cgi?FirstName = Zara & LastName = Ali.

Вы можете получить доступ к параметрам FirstName и LastName с помощью CGI # [] напрямую следующим образом:

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi['FirstName'] # =>  ["Zara"]
cgi['LastName']  # =>  ["Ali"]

Есть другой способ получить доступ к этим переменным формы. Этот код даст вам хэш всех ключей и значений -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
h = cgi.params  # =>  {"FirstName"=>["Zara"],"LastName"=>["Ali"]}
h['FirstName']  # =>  ["Zara"]
h['LastName']   # =>  ["Ali"]

Ниже приведен код для получения всех ключей -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi.keys         # =>  ["FirstName", "LastName"]

Если форма содержит несколько полей с одинаковыми именами, соответствующие значения будут возвращены скрипту в виде массива. Аксессор [] возвращает только первый из these.index результат метода params, чтобы получить их все.

В этом примере предположим, что в форме есть три поля с названием «имя», и мы ввели три имени «Зара», «Хума» и «Нуха» -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi['name']        # => "Zara"
cgi.params['name'] # => ["Zara", "Huma", "Nuha"]
cgi.keys           # => ["name"]
cgi.params         # => {"name"=>["Zara", "Huma", "Nuha"]}

Note- Ruby автоматически позаботится о методах GET и POST. Для этих двух разных методов нет отдельного лечения.

Связанная, но базовая форма, которая могла бы отправлять правильные данные, имела бы такой HTML-код:

<html>
   <body>
      <form method = "POST" action = "http://www.example.com/test.cgi">
         First Name :<input type = "text" name = "FirstName" value = "" />
         <br />
         Last Name :<input type = "text" name = "LastName" value = "" /> 
         <input type = "submit" value = "Submit Data" />
      </form>
   </body>
</html>

Создание форм и HTML

CGI содержит огромное количество методов, используемых для создания HTML. Вы найдете один метод для каждого тега. Чтобы включить эти методы, вы должны создать объект CGI, вызвав CGI.new.

Чтобы упростить вложение тегов, эти методы принимают свое содержимое в виде блоков кода. Блоки кода должны возвращать строку , которая будет использоваться в качестве содержимого для тега. Например -

#!/usr/bin/ruby

require "cgi"
cgi = CGI.new("html4")
cgi.out {
   cgi.html {
      cgi.head { "\n"+cgi.title{"This Is a Test"} } +
      cgi.body { "\n"+
         cgi.form {"\n"+
            cgi.hr +
            cgi.h1 { "A Form: " } + "\n"+
            cgi.textarea("get_text") +"\n"+
            cgi.br +
            cgi.submit
         }
      }
   }
}

NOTE- Метод формы класса CGI может принимать параметр метода, который устанавливает метод HTTP (GET, POST и т. Д.), Который будет использоваться при отправке формы. По умолчанию в этом примере используется POST.

Это даст следующий результат -

Content-Type: text/html
Content-Length: 302

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Final//EN">

<HTML>
   <HEAD>
      <TITLE>This Is a Test</TITLE>
   </HEAD>
   <BODY>
      <FORM METHOD = "post" ENCTYPE = "application/x-www-form-urlencoded">
         <HR>
         <H1>A Form: </H1>
         <TEXTAREA COLS = "70" NAME = "get_text" ROWS = "10"></TEXTAREA>
         <BR>
         <INPUT TYPE = "submit">
      </FORM>
   </BODY>
</HTML>

Цитирование строк

Имея дело с URL-адресами и HTML-кодом, вы должны быть осторожны, заключая определенные символы в кавычки. Например, косая черта (/) имеет особое значение в URL-адресе, поэтому она должна бытьescaped если это не часть пути.

Например, любой / в части запроса URL-адреса будет преобразован в строку% 2F и должен быть переведен обратно в /, чтобы вы могли его использовать. Пробел и амперсанд также являются специальными символами. Чтобы справиться с этим, CGI предоставляет процедурыCGI.escape и CGI.unescape.

#!/usr/bin/ruby

require 'cgi'
puts CGI.escape(Zara Ali/A Sweet & Sour Girl")

Это даст следующий результат -

Zara+Ali%2FA Sweet+%26+Sour+Girl")

#!/usr/bin/ruby

require 'cgi'
puts CGI.escapeHTML('<h1>Zara Ali/A Sweet & Sour Girl</h1>')

Это даст следующий результат -

&lt;h1&gt;Zara Ali/A Sweet & Sour Girl&lt;/h1&gt;'

Полезные методы в классе CGI

Вот список методов, связанных с классом CGI -

  • В Рубиновые CGI - методы , связанные с библиотекой Standard CGI.

Файлы cookie и сеансы

Мы объяснили эти две концепции в разных разделах. Пожалуйста, следите за разделами -

  • Рубин CGI Куки - Как обращаться с CGI Cookies.

  • Рубин CGI Сессии - Как управлять CGI сессий.

Серверы веб-хостинга

Вы можете проверить следующую тему в Интернете, чтобы разместить свой веб-сайт на сервере на базе Unix:

  • Веб-хостинг на базе Unix

Простой протокол передачи почты (SMTP) - это протокол, который обрабатывает отправку электронной почты и маршрутизацию электронной почты между почтовыми серверами.

Ruby предоставляет класс Net :: SMTP для подключения на стороне клиента по протоколу SMTP и предоставляет два метода класса new и start .

  • В new принимает два параметра -

    • Имя сервера по умолчанию - localhost.

    • Номер порта по умолчанию - хорошо известный порт 25.

  • В start метод принимает эти параметры -

    • Сервер - имя IP сервера SMTP, недобросовестный на локальный.

    • Порт - номер порта, по умолчанию 25.

    • Домен - домен почтового отправителя, по умолчанию ENV [ «Hostname»].

    • Счет - Имя пользователя, по умолчанию равно нулю.

    • Пароль - пароль пользователя, по умолчанию ноль.

    • Тип авторизации - Тип авторизации, по умолчанию cram_md5 .

У объекта SMTP есть метод экземпляра, называемый sendmail, который обычно используется для отправки сообщения по почте. Требуется три параметра -

  • Источник - Строка или массив или что - нибудь с каждым итератором возвращением одну строки за один раз.

  • Отправитель - строка , которая будет появляться в из области электронной почты.

  • Получатели - строка или массив строк , представляющих адресат (ов) получателей.

пример

Вот простой способ отправить одно электронное письмо с помощью скрипта Ruby. Попробуй один раз -

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <[email protected]>
To: A Test User <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
  smtp.send_message message, '[email protected]', '[email protected]'
end

Здесь вы поместили базовое электронное письмо в сообщение, используя документ, позаботившись о правильном форматировании заголовков. Электронная почта требуетFrom, To, и Subject заголовок, отделенный от тела письма пустой строкой.

Для отправки почты вы используете Net :: SMTP для подключения к SMTP-серверу на локальном компьютере, а затем используете метод send_message вместе с сообщением, адресом отправителя и адресом назначения в качестве параметров (даже если адреса отправителя и получателя внутри самой электронной почты они не всегда используются для маршрутизации почты).

Если на вашем компьютере не установлен SMTP-сервер, вы можете использовать Net :: SMTP для связи с удаленным SMTP-сервером. Если вы не используете службу веб-почты (например, Hotmail или Yahoo! Mail), ваш провайдер электронной почты предоставит вам данные сервера исходящей почты, которые вы можете предоставить в Net :: SMTP, а именно:

Net::SMTP.start('mail.your-domain.com')

Эта строка кода подключается к SMTP-серверу через порт 25 mail.your-domain.com без использования имени пользователя или пароля. Однако, если вам нужно, вы можете указать номер порта и другие детали. Например -

Net::SMTP.start('mail.your-domain.com', 
                25, 
                'localhost', 
                'username', 'password' :plain)

В этом примере выполняется подключение к SMTP-серверу mail.your-domain.com с использованием имени пользователя и пароля в текстовом формате. Он определяет имя хоста клиента как localhost.

Отправка электронного письма в формате HTML с помощью Ruby

Когда вы отправляете текстовое сообщение с помощью Ruby, все содержимое будет рассматриваться как простой текст. Даже если вы включите HTML-теги в текстовое сообщение, оно будет отображаться как простой текст, а HTML-теги не будут отформатированы в соответствии с синтаксисом HTML. Но Ruby Net :: SMTP предоставляет возможность отправлять HTML-сообщение как фактическое HTML-сообщение.

При отправке сообщения электронной почты вы можете указать версию Mime, тип содержимого и набор символов для отправки электронного письма в формате HTML.

пример

Ниже приведен пример отправки HTML-содержимого по электронной почте. Попробуй один раз -

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <[email protected]>
To: A Test User <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
   smtp.send_message message, '[email protected]', '[email protected]'
end

Отправка вложений по электронной почте

Чтобы отправить электронное письмо со смешанным содержанием, необходимо установить Content-type заголовок в multipart/mixed. Затем можно указать разделы текста и вложения вboundaries.

Граница начинается с двух дефисов, за которыми следует уникальный номер, который не может отображаться в части сообщения электронной почты. Последняя граница, обозначающая последний раздел электронного письма, также должна заканчиваться двумя дефисами.

Прикрепленные файлы должны быть закодированы с помощью pack("m") функция должна иметь кодировку base64 перед передачей.

пример

Ниже приведен пример, который отправит файл /tmp/test.txt в виде вложения.

require 'net/smtp'

filename = "/tmp/test.txt"
# Read a file and encode it into base64 format
filecontent = File.read(filename)
encodedcontent = [filecontent].pack("m")   # base64

marker = "AUNIQUEMARKER"
body = <<EOF
This is a test email to send an attachement.
EOF

# Define the main headers.
part1 = <<EOF
From: Private Person <[email protected]>
To: A Test User <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary = #{marker}
--#{marker}
EOF

# Define the message action
part2 = <<EOF
Content-Type: text/plain
Content-Transfer-Encoding:8bit

#{body}
--#{marker}
EOF

# Define the attachment section
part3 = <<EOF
Content-Type: multipart/mixed; name = \"#{filename}\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename = "#{filename}"

#{encodedcontent}
--#{marker}--
EOF

mailtext = part1 + part2 + part3

# Let's put our code in safe area
begin 
   Net::SMTP.start('localhost') do |smtp|
      smtp.sendmail(mailtext, '[email protected]', ['[email protected]'])
   end
rescue Exception => e  
   print "Exception occured: " + e  
end

NOTE - Вы можете указать несколько адресатов внутри массива, но они должны быть разделены запятыми.

Ruby предоставляет два уровня доступа к сетевым службам. На низком уровне вы можете получить доступ к базовой поддержке сокетов в базовой операционной системе, что позволяет вам реализовывать клиентов и серверы как для протоколов с установлением соединения, так и без установления соединения.

В Ruby также есть библиотеки, которые обеспечивают доступ более высокого уровня к определенным сетевым протоколам уровня приложений, таким как FTP, HTTP и т. Д.

В этой главе вы познакомитесь с самой известной концепцией сети - программированием сокетов.

Что такое сокеты?

Сокеты - это конечные точки двунаправленного канала связи. Сокеты могут обмениваться данными внутри процесса, между процессами на одной машине или между процессами на разных континентах.

Сокеты могут быть реализованы по нескольким типам каналов: сокеты домена Unix, TCP, UDP и так далее. Розетка обеспечивает определенные классы для обработки общих транспортов, а также общий интерфейса для обработки остальные.

У сокетов есть свой словарный запас -

Sr.No. Срок и описание
1

domain

Семейство протоколов, которые будут использоваться в качестве транспортного механизма. Эти значения являются константами, такими как PF_INET, PF_UNIX, PF_X25 и т. Д.

2

type

Тип связи между двумя конечными точками, обычно SOCK_STREAM для протоколов с установлением соединения и SOCK_DGRAM для протоколов без установления соединения.

3

protocol

Обычно ноль, это может использоваться для идентификации варианта протокола в домене и типе.

4

hostname

Идентификатор сетевого интерфейса -

Строка, которая может быть именем хоста, адресом с четырьмя точками или адресом IPV6 в двоеточии (и, возможно, точкой).

Строка «<трансляция>», которая указывает адрес INADDR_BROADCAST.

Строка нулевой длины, указывающая INADDR_ANY, или

Целое число, интерпретируемое как двоичный адрес в байтовом порядке хоста.

5

port

Каждый сервер ожидает звонков клиентов на один или несколько портов. Порт может быть номером порта Fixnum, строкой, содержащей номер порта, или именем службы.

Простой клиент

Здесь мы напишем очень простую клиентскую программу, которая откроет соединение с заданным портом и заданным хостом. Рубиновый классTCPSocketпредоставляет функцию open для открытия такого сокета.

В TCPSocket.open(hosname, port )открывает TCP-соединение с именем хоста на порту .

Когда у вас открыт сокет, вы можете читать из него, как любой объект ввода-вывода. Когда закончите, не забудьте закрыть его, как если бы вы закрывали файл.

Следующий код представляет собой очень простой клиент, который подключается к заданному хосту и порту, считывает любые доступные данные из сокета, а затем выходит:

require 'socket'        # Sockets are in standard library

hostname = 'localhost'
port = 2000

s = TCPSocket.open(hostname, port)

while line = s.gets     # Read lines from the socket
   puts line.chop       # And print with platform line terminator
end
s.close                 # Close the socket when done

Простой сервер

Для написания интернет-серверов мы используем TCPServerкласс. Объект TCPServer - это фабрика для объектов TCPSocket.

Сейчас звоните TCPServer.open(hostname, portфункция, чтобы указать порт для вашей службы и создатьTCPServer объект.

Затем вызовите метод accept возвращенного объекта TCPServer. Этот метод ожидает, пока клиент не подключится к указанному вами порту, а затем возвращает объект TCPSocket , представляющий подключение к этому клиенту.

require 'socket'                 # Get sockets from stdlib

server = TCPServer.open(2000)    # Socket to listen on port 2000
loop {                           # Servers run forever
   client = server.accept        # Wait for a client to connect
   client.puts(Time.now.ctime)   # Send the time to the client
   client.puts "Closing the connection. Bye!"
   client.close                  # Disconnect from the client
}

Теперь запустите этот сервер в фоновом режиме, а затем запустите указанный выше клиент, чтобы увидеть результат.

Мультиклиентские TCP-серверы

Большинство серверов в Интернете предназначены для работы с большим количеством клиентов одновременно.

Класс Ruby Thread упрощает создание многопоточного сервера. One, который принимает запросы и немедленно создает новый поток выполнения для обработки соединения, позволяя основной программе ожидать дополнительных соединений -

require 'socket'                 # Get sockets from stdlib

server = TCPServer.open(2000)    # Socket to listen on port 2000
loop {                           # Servers run forever
   Thread.start(server.accept) do |client|
   client.puts(Time.now.ctime)   # Send the time to the client
   client.puts "Closing the connection. Bye!"
   client.close                  # Disconnect from the client
   end
}

В этом примере у вас есть постоянный цикл, и когда server.accept отвечает, новый поток создается и немедленно запускается для обработки только что принятого соединения с использованием объекта соединения, переданного в поток. Однако основная программа немедленно возвращается и ожидает новых подключений.

Такое использование потоков Ruby означает, что код переносим и будет работать одинаково в Linux, OS X и Windows.

Крошечный веб-браузер

Мы можем использовать библиотеку сокетов для реализации любого Интернет-протокола. Вот, например, код для получения содержимого веб-страницы -

require 'socket'
 
host = 'www.tutorialspoint.com'     # The web server
port = 80                           # Default HTTP port
path = "/index.htm"                 # The file we want 

# This is the HTTP request we send to fetch a file
request = "GET #{path} HTTP/1.0\r\n\r\n"

socket = TCPSocket.open(host,port)  # Connect to server
socket.print(request)               # Send request
response = socket.read              # Read complete response
# Split response at first blank line into headers and body
headers,body = response.split("\r\n\r\n", 2) 
print body                          # And display it

Чтобы реализовать аналогичный веб-клиент, вы можете использовать предварительно созданную библиотеку, например Net::HTTPдля работы с HTTP. Вот код, который выполняет эквивалент предыдущего кода -

require 'net/http'                  # The library we need
host = 'www.tutorialspoint.com'     # The web server
path = '/index.htm'                 # The file we want 

http = Net::HTTP.new(host)          # Create a connection
headers, body = http.get(path)      # Request the file
if headers.code == "200"            # Check the status code   
   print body                        
else                                
   puts "#{headers.code} #{headers.message}" 
end

Пожалуйста, проверьте аналогичные библиотеки для работы с протоколами FTP, SMTP, POP и IMAP.

Дополнительная литература

Мы дали вам быстрый старт по программированию сокетов. Это большая тема, поэтому рекомендуется пройти через библиотеку сокетов Ruby и методы классов, чтобы найти более подробную информацию.

Что такое XML?

Extensible Markup Language (XML) - это язык разметки, очень похожий на HTML или SGML. Это рекомендовано Консорциумом World Wide Web и доступно в качестве открытого стандарта.

XML - это переносимый язык с открытым исходным кодом, который позволяет программистам разрабатывать приложения, которые могут быть прочитаны другими приложениями, независимо от операционной системы и / или языка разработки.

XML чрезвычайно полезен для отслеживания небольших и средних объемов данных, не требуя магистрали на основе SQL.

Архитектуры синтаксического анализатора XML и API

Для парсеров XML доступны два разных варианта:

  • SAX-like (Stream interfaces)- Здесь вы регистрируете обратные вызовы для интересующих событий, а затем позволяете синтаксическому анализатору пройти через документ. Это полезно, когда ваши документы большие или у вас есть ограничения памяти, он анализирует файл при чтении его с диска, и весь файл никогда не сохраняется в памяти.

  • DOM-like (Object tree interfaces) - Это рекомендация Консорциума World Wide Web, согласно которой весь файл считывается в память и сохраняется в иерархической (древовидной) форме для представления всех функций XML-документа.

Очевидно, что SAX не может обрабатывать информацию так быстро, как DOM, при работе с большими файлами. С другой стороны, использование исключительно DOM может действительно убить ваши ресурсы, особенно если используется много небольших файлов.

SAX доступен только для чтения, а DOM позволяет вносить изменения в XML-файл. Поскольку эти два разных API буквально дополняют друг друга, нет причин, по которым вы не можете использовать их оба для больших проектов.

Разбор и создание XML с помощью Ruby

Наиболее распространенный способ манипулирования XML - использование библиотеки REXML Шона Рассела. С 2002 года REXML является частью стандартного дистрибутива Ruby.

REXML - это XML-процессор на чистом Ruby, соответствующий стандарту XML 1.0. Это непроверяющий процессор, прошедший все не подтверждающие тесты соответствия OASIS.

Парсер REXML имеет следующие преимущества перед другими доступными парсерами:

  • Он на 100 процентов написан на Ruby.
  • Его можно использовать как для синтаксического анализа SAX, так и для DOM.
  • Это легкий, менее 2000 строк кода.
  • Методы и классы действительно просты для понимания.
  • API на основе SAX2 и полная поддержка XPath.
  • Поставляется с установкой Ruby, отдельная установка не требуется.

Для всех наших примеров кода XML давайте использовать в качестве входных данных простой файл XML -

<collection shelf = "New Arrivals">
   <movie title = "Enemy Behind">
      <type>War, Thriller</type>
      <format>DVD</format>
      <year>2003</year>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Talk about a US-Japan war</description>
   </movie>
   <movie title = "Transformers">
      <type>Anime, Science Fiction</type>
      <format>DVD</format>
      <year>1989</year>
      <rating>R</rating>
      <stars>8</stars>
      <description>A schientific fiction</description>
   </movie>
   <movie title = "Trigun">
      <type>Anime, Action</type>
      <format>DVD</format>
      <episodes>4</episodes>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Vash the Stampede!</description>
   </movie>
   <movie title = "Ishtar">
      <type>Comedy</type>
      <format>VHS</format>
      <rating>PG</rating>
      <stars>2</stars>
      <description>Viewable boredom</description>
   </movie>
</collection>

DOM-подобный парсинг

Давайте сначала проанализируем наши XML-данные в виде дерева . Начнем с требованияrexml/documentбиблиотека; часто для удобства мы используем include REXML для импорта в пространство имен верхнего уровня.

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# Now get the root element
root = xmldoc.root
puts "Root element : " + root.attributes["shelf"]

# This will output all the movie titles.
xmldoc.elements.each("collection/movie"){ 
   |e| puts "Movie Title : " + e.attributes["title"] 
}

# This will output all the movie types.
xmldoc.elements.each("collection/movie/type") {
   |e| puts "Movie Type : " + e.text 
}

# This will output all the movie description.
xmldoc.elements.each("collection/movie/description") {
   |e| puts "Movie Description : " + e.text 
}

Это даст следующий результат -

Root element : New Arrivals
Movie Title : Enemy Behind
Movie Title : Transformers
Movie Title : Trigun
Movie Title : Ishtar
Movie Type : War, Thriller
Movie Type : Anime, Science Fiction
Movie Type : Anime, Action
Movie Type : Comedy
Movie Description : Talk about a US-Japan war
Movie Description : A schientific fiction
Movie Description : Vash the Stampede!
Movie Description : Viewable boredom

SAX-подобный синтаксический анализ

Чтобы обработать те же данные, файл movies.xml , в потоковом режиме, мы определим класс слушателя , методы которого будут целью обратных вызовов от парсера.

NOTE - Не рекомендуется использовать SAX-подобный синтаксический анализ для небольшого файла, это просто демонстрационный пример.

#!/usr/bin/ruby -w

require 'rexml/document'
require 'rexml/streamlistener'
include REXML

class MyListener
   include REXML::StreamListener
   def tag_start(*args)
      puts "tag_start: #{args.map {|x| x.inspect}.join(', ')}"
   end

   def text(data)
      return if data =~ /^\w*$/     # whitespace only
      abbrev = data[0..40] + (data.length > 40 ? "..." : "")
      puts "  text   :   #{abbrev.inspect}"
   end
end

list = MyListener.new
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile, list)

Это даст следующий результат -

tag_start: "collection", {"shelf"=>"New Arrivals"}
tag_start: "movie", {"title"=>"Enemy Behind"}
tag_start: "type", {}
   text   :   "War, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Talk about a US-Japan war"
tag_start: "movie", {"title"=>"Transformers"}
tag_start: "type", {}
   text   :   "Anime, Science Fiction"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "A schientific fiction"
tag_start: "movie", {"title"=>"Trigun"}
tag_start: "type", {}
   text   :   "Anime, Action"
tag_start: "format", {}
tag_start: "episodes", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Vash the Stampede!"
tag_start: "movie", {"title"=>"Ishtar"}
tag_start: "type", {}
tag_start: "format", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Viewable boredom"

XPath и Ruby

Альтернативный способ просмотра XML - XPath. Это своего рода псевдоязык, который описывает, как найти определенные элементы и атрибуты в XML-документе, рассматривая этот документ как логически упорядоченное дерево.

REXML поддерживает XPath через класс XPath . Он предполагает синтаксический анализ на основе дерева (объектная модель документа), как мы видели выше.

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# Info for the first movie found
movie = XPath.first(xmldoc, "//movie")
p movie

# Print out all the movie types
XPath.each(xmldoc, "//type") { |e| puts e.text }

# Get an array of all of the movie formats.
names = XPath.match(xmldoc, "//format").map {|x| x.text }
p names

Это даст следующий результат -

<movie title = 'Enemy Behind'> ... </>
War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
["DVD", "DVD", "DVD", "VHS"]

XSLT и Ruby

Доступны два парсера XSLT, которые может использовать Ruby. Здесь дано краткое описание каждого из них.

Рубин-Саблотрон

Этот парсер написан и поддерживается Масаеши Такахаши. Это написано в первую очередь для ОС Linux и требует следующих библиотек:

  • Sablot
  • Iconv
  • Expat

Вы можете найти этот модуль на Ruby-Sablotron.

XSLT4R

XSLT4R написан Майклом Нойманом, и его можно найти в RAA в разделе «Библиотека» в разделе XML. XSLT4R использует простой интерфейс командной строки, хотя в качестве альтернативы его можно использовать в стороннем приложении для преобразования XML-документа.

XSLT4R требует для работы XMLScan, который включен в архив XSLT4R и также является полностью модулем Ruby. Эти модули могут быть установлены с использованием стандартного метода установки Ruby (например, ruby ​​install.rb).

XSLT4R имеет следующий синтаксис -

ruby xslt.rb stylesheet.xsl document.xml [arguments]

Если вы хотите использовать XSLT4R из приложения, вы можете включить XSLT и ввести необходимые параметры. Вот пример -

require "xslt"

stylesheet = File.readlines("stylesheet.xsl").to_s
xml_doc = File.readlines("document.xml").to_s
arguments = { 'image_dir' => '/....' }
sheet = XSLT::Stylesheet.new( stylesheet, arguments )

# output to StdOut
sheet.apply( xml_doc )

# output to 'str'
str = ""
sheet.output = [ str ]
sheet.apply( xml_doc )

Дальнейшее чтение

  • Для получения полной информации о парсере REXML, пожалуйста, обратитесь к стандартной документации по REXML Parser Documentation .

  • Вы можете загрузить XSLT4R из репозитория RAA .

Что такое SOAP?

Протокол простого доступа к объектам (SOAP) - это кроссплатформенный и независимый от языка протокол RPC, основанный на XML и обычно (но не обязательно) HTTP.

Он использует XML для кодирования информации, которая вызывает удаленный вызов процедуры, и HTTP для передачи этой информации по сети от клиентов к серверам и наоборот.

SOAP имеет несколько преимуществ по сравнению с другими технологиями, такими как COM, CORBA и т. Д.: Например, его относительно дешевая стоимость развертывания и отладки, его расширяемость и простота использования, а также наличие нескольких реализаций для разных языков и платформ.

Пожалуйста, обратитесь к нашему простому руководству по SOAP, чтобы понять его подробно.

В этой главе вы познакомитесь с реализацией SOAP для Ruby (SOAP4R). Это базовое руководство, поэтому, если вам нужны подробные сведения, вам нужно будет обратиться к другим ресурсам.

Установка SOAP4R

SOAP4R - это реализация SOAP для Ruby, разработанная Хироши Накамура, которую можно загрузить с -

NOTE - Возможно, вы уже установили этот компонент.

Download SOAP

Если вы знаете о gem , то вы можете использовать следующую команду для установки SOAP4R и связанных пакетов.

$ gem install soap4r --include-dependencies

Если вы работаете в Windows, вам необходимо загрузить заархивированный файл из указанного выше места и установить его стандартным способом, запустив ruby install.rb .

Написание серверов SOAP4R

SOAP4R поддерживает два разных типа серверов:

  • На основе CGI / FastCGI (SOAP :: RPC :: CGIStub)
  • Автономный (SOAP :: RPC: StandaloneServer)

В этой главе подробно рассказывается о написании автономного сервера. Следующие шаги связаны с написанием SOAP-сервера.

Шаг 1 - Наследование класса SOAP :: RPC :: StandaloneServer

Чтобы реализовать свой собственный автономный сервер, вам необходимо написать новый класс, который будет дочерним по отношению к SOAP :: StandaloneServer следующим образом:

class MyServer < SOAP::RPC::StandaloneServer
  ...............
end

NOTE- Если вы хотите написать сервер на основе FastCGI, вам нужно взять SOAP :: RPC :: CGIStub в качестве родительского класса, остальная часть процедуры останется прежней.

Шаг 2 - Определите методы обработчика

Второй шаг - написать методы ваших веб-служб, которые вы хотели бы предоставить внешнему миру.

Их можно записать как простые методы Ruby. Например, давайте напишем два метода сложения двух чисел и деления двух чисел:

class MyServer < SOAP::RPC::StandaloneServer
   ...............

   # Handler methods
   def add(a, b)
      return a + b
   end
   def div(a, b) 
      return a / b 
   end
end

Шаг 3 - Раскройте методы обработчика

Следующим шагом будет добавление определенных нами методов на наш сервер. Метод инициализации используется для предоставления методов обслуживания одним из двух следующих методов:

class MyServer < SOAP::RPC::StandaloneServer
   def initialize(*args)
      add_method(receiver, methodName, *paramArg)
   end
end

Вот описание параметров -

Sr.No. Параметр и описание
1

receiver

Объект, содержащий метод methodName. Вы определяете методы службы в том же классе, что и метод methodDef, этот параметр имеет значение self .

2

methodName

Имя метода, вызываемого из-за запроса RPC.

3

paramArg

Задает, если дано, имена параметров и режимы параметров.

Чтобы понять использование параметров inout или out , рассмотрим следующий метод службы, который принимает два параметра (inParam и inoutParam), возвращает одно нормальное возвращаемое значение (retVal) и два дополнительных параметра: inoutParam и outParam -

def aMeth(inParam, inoutParam)
   retVal = inParam + inoutParam
   outParam = inParam . inoutParam
   inoutParam = inParam * inoutParam
   return retVal, inoutParam, outParam
end

Теперь мы можем раскрыть этот метод следующим образом:

add_method(self, 'aMeth', [
   %w(in inParam),
   %w(inout inoutParam),
   %w(out outParam),
   %w(retval return)
])

Шаг 4 - Запустите сервер

Последний шаг - запустить сервер, создав один экземпляр производного класса и вызвав start метод.

myServer = MyServer.new('ServerName', 'urn:ruby:ServiceName', hostname, port)

myServer.start

Вот описание необходимых параметров -

Sr.No. Параметр и описание
1

ServerName

Имя сервера, вы можете дать то, что вам больше всего нравится.

2

urn:ruby:ServiceName

Здесь urn: ruby является постоянным, но вы можете дать уникальное имя ServiceName для этого сервера.

3

hostname

Задает имя хоста, на котором будет слушать этот сервер.

4

port

Доступный номер порта, который будет использоваться для веб-службы.

пример

Теперь, используя вышеуказанные шаги, давайте напишем один автономный сервер -

require "soap/rpc/standaloneserver"

begin
   class MyServer < SOAP::RPC::StandaloneServer

      # Expose our services
      def initialize(*args)
         add_method(self, 'add', 'a', 'b')
         add_method(self, 'div', 'a', 'b')
      end

      # Handler methods
      def add(a, b)
         return a + b
      end
      def div(a, b) 
         return a / b 
      end
end
   server = MyServer.new("MyServer", 
            'urn:ruby:calculation', 'localhost', 8080)
   trap('INT){
      server.shutdown
   }
   server.start
rescue => err
   puts err.message
end

При выполнении это серверное приложение запускает автономный сервер SOAP на локальном хосте и прослушивает запросы на порту 8080. Оно предоставляет один метод службы, add и div , который принимает два параметра и возвращает результат.

Теперь вы можете запустить этот сервер в фоновом режиме следующим образом:

$ ruby MyServer.rb&

Написание клиентов SOAP4R

Класс SOAP :: RPC :: Driver обеспечивает поддержку написания клиентских приложений SOAP. В этой главе описывается этот класс и демонстрируется его использование на основе приложения.

Ниже приведена минимальная информация, которая может потребоваться для вызова службы SOAP.

  • URL-адрес службы SOAP (URL-адрес конечной точки SOAP).
  • Пространство имен методов службы (URI пространства имен метода).
  • Имена методов обслуживания и их параметры.

Теперь мы напишем SOAP-клиент, который будет вызывать методы службы, определенные в приведенном выше примере, с именами add и div .

Вот основные шаги по созданию клиента SOAP.

Шаг 1. Создайте экземпляр драйвера SOAP

Мы создаем экземпляр SOAP :: RPC :: Driver , вызывая его новый метод следующим образом:

SOAP::RPC::Driver.new(endPoint, nameSpace, soapAction)

Вот описание необходимых параметров -

Sr.No. Параметр и описание
1

endPoint

URL-адрес SOAP-сервера, к которому необходимо подключиться.

2

nameSpace

Пространство имен, используемое для всех RPC, выполненных с этим объектом SOAP :: RPC :: Driver.

3

soapAction

Значение поля SOAPAction заголовка HTTP. Если nil, по умолчанию используется пустая строка "".

Шаг 2 - Добавьте методы обслуживания

Чтобы добавить метод службы SOAP к SOAP :: RPC :: Driver, мы можем вызвать следующий метод, используя экземпляр SOAP :: RPC :: Driver:

driver.add_method(name, *paramArg)

Вот описание параметров -

Sr.No. Параметр и описание
1

name

Имя метода удаленной веб-службы.

2

paramArg

Задает имена параметров удаленных процедур.

Шаг 3 - Вызов службы SOAP

Последний шаг - выставить счет для службы SOAP с использованием экземпляра SOAP :: RPC :: Driver следующим образом:

result = driver.serviceMethod(paramArg...)

Здесь serviceMethod - это фактический метод веб-службы, а paramArg ... - это параметры списка, необходимые для передачи в метод службы.

Example

На основе описанных выше шагов мы напишем клиент SOAP следующим образом:

#!/usr/bin/ruby -w

require 'soap/rpc/driver'

NAMESPACE = 'urn:ruby:calculation'
URL = 'http://localhost:8080/'

begin
   driver = SOAP::RPC::Driver.new(URL, NAMESPACE)
   
   # Add remote sevice methods
   driver.add_method('add', 'a', 'b')

   # Call remote service methods
   puts driver.add(20, 30)
rescue => err
   puts err.message
end

Дополнительная литература

Я объяснил вам только самые основные концепции веб-служб с помощью Ruby. Если вы хотите подробнее изучить его, перейдите по следующей ссылке, чтобы найти более подробную информацию о веб-службах с Ruby .

Введение

Стандартный графический интерфейс пользователя (GUI) для Ruby - Tk. Tk начинался как графический интерфейс для языка сценариев Tcl, разработанный Джоном Остерхаутом.

Tk уникален тем, что является единственным кроссплатформенным графическим интерфейсом. Tk работает в Windows, Mac и Linux и обеспечивает естественный внешний вид в каждой операционной системе.

Базовый компонент приложения на основе Tk называется виджетом. Компонент также иногда называют окном, поскольку в Tk «окно» и «виджет» часто используются как синонимы.

Приложения Tk следуют иерархии виджетов, в которой любое количество виджетов может быть размещено внутри другого виджета, а эти виджеты - внутри другого виджета, до бесконечности. Главный виджет в программе Tk называется корневым виджетом и может быть создан путем создания нового экземпляра класса TkRoot.

  • Большинство приложений на основе Tk следуют одному и тому же циклу: создают виджеты, помещают их в интерфейс и, наконец, связывают события, связанные с каждым виджетом, с методом.

  • Есть три менеджера геометрии; place, grid и pack , которые отвечают за управление размером и расположением каждого из виджетов в интерфейсе.

Установка

Привязки Ruby Tk распространяются с Ruby, но Tk устанавливается отдельно. Пользователи Windows могут загрузить установку Tk одним щелчком мыши из ActiveTcl ActiveState .

Пользователям Mac и Linux может не потребоваться его установка, потому что велика вероятность, что он уже установлен вместе с ОС, но если нет, вы можете загрузить готовые пакеты или получить исходный код из Tcl Developer Xchange .

Простое приложение Tk

Типичная структура программ Ruby / Tk - это создание основного или root window (экземпляр TkRoot), добавьте в него виджеты для создания пользовательского интерфейса, а затем запустите основной цикл событий, вызвав Tk.mainloop.

Традиционный Hello, World! пример для Ruby / Tk выглядит примерно так -

require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
   text 'Hello, World!'
   pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop

Здесь, после загрузки модуля расширения tk, мы создаем фрейм корневого уровня с помощью TkRoot.new . Затем мы делаем виджет TkLabel дочерним по отношению к корневому фрейму, устанавливая несколько параметров для метки. Наконец, мы упаковываем корневой фрейм и входим в основной цикл событий графического интерфейса.

Если вы запустите этот скрипт, он даст следующий результат:

Классы виджетов Ruby / Tk

Существует список различных классов Ruby / Tk, которые можно использовать для создания желаемого графического интерфейса с использованием Ruby / Tk.

  • TkFrame Создает и управляет виджетами фреймов.

  • TkButton Создает виджеты кнопок и управляет ими.

  • TkLabel Создает виджеты меток и управляет ими.

  • TkEntry Создает виджеты входа и управляет ими.

  • TkCheckButton Создает виджеты с флажками и управляет ими.

  • TkRadioButton Создает виджеты радиокнопок и управляет ими.

  • TkListbox Создает и управляет виджетами списка.

  • TkComboBox Создает и управляет виджетами списка.

  • TkMenu Создает и управляет виджетами меню.

  • TkMenubutton Создает и манипулирует виджетами меню .

  • Tk.messageBox Создает диалоговое окно сообщения и управляет им.

  • TkScrollbar Создает и управляет виджетами полосы прокрутки.

  • TkCanvas Создает и управляет виджетами холста.

  • TkScale Создает масштабные виджеты и управляет ими.

  • TkText Создает текстовые виджеты и управляет ими.

  • TkToplevel Создает виджеты верхнего уровня и управляет ими.

  • TkSpinbox Создает и управляет виджетами Spinbox.

  • TkProgressBar Создает виджеты индикатора выполнения и управляет ими.

  • Диалоговое окно Создание и управление виджетами диалогового окна.

  • Tk :: Tile :: Notebook Отображение нескольких окон в ограниченном пространстве с помощью метафоры записной книжки.

  • Tk :: Tile :: Paned Отображает несколько подокон, расположенных вертикально или горизонтально.

  • Tk :: Tile :: Separator Отображает горизонтальную или вертикальную разделительную полосу.

  • Шрифт, цвета и изображения Ruby / Tk Общие сведения о шрифтах, цветах и ​​изображениях Ruby / Tk

Стандартные варианты конфигурации

Все виджеты имеют несколько различных параметров конфигурации, которые обычно управляют тем, как они отображаются или как ведут себя. Доступные параметры, конечно же, зависят от класса виджета.

Вот список всех стандартных параметров конфигурации, которые могут быть применимы к любому виджету Ruby / Tk.

Sr.No. Опции и описание
1

activebackground => Строка

Задает цвет фона для использования при рисовании активных элементов. Элемент является активным, если курсор мыши расположен над элементом и нажатие кнопки мыши вызовет какое-либо действие. Вы можете использовать такие названия цветов, как «красный», «синий», «розовый», «желтый» и т. Д.

2

activeborderwidth => Целое число

Задает неотрицательное значение, указывающее ширину трехмерной границы, нарисованной вокруг активных элементов.

3

activeforeground => Строка

Задает цвет переднего плана для использования при рисовании активных элементов.

4

anchor => Строка

Определяет, как информация в виджете (например, текст или растровое изображение) должна отображаться в виджете. Должно быть одно из значенийn, ne, e, se, s, sw, w, nw, или же center. Например,nw означает отображение информации таким образом, чтобы ее верхний левый угол находился в верхнем левом углу виджета.

5

background or bg => Строка

Задает нормальный цвет фона для использования при отображении виджета.

6

bitmap => Растровое изображение

Задает растровое изображение для отображения в виджете. На точный способ отображения растрового изображения могут влиять другие параметры, такие как привязка или выравнивание.

7

borderwidth or bd => Целое число

Определяет неотрицательное значение, указывающее ширину трехмерной границы, которая будет отображаться за пределами виджета.

8

compound => Строка

Определяет, должен ли виджет отображать текст и растровые изображения / изображения одновременно, и если да, то где растровое изображение / изображение должно быть размещено относительно текста. Должно быть одно из значенийnone, bottom, top, left, right, или же center.

9

cursor => Строка

Задает курсор мыши, который будет использоваться для виджета. Возможные значения: «часы», «стрелка» и т. Д.

10

disabledforeground => Строка

Задает цвет переднего плана для использования при рисовании отключенного элемента.

11

exportselection => Логическое

Определяет, должно ли выделение в виджете также быть выделением X. Значение может иметь любое изtrue, false, 0, 1, yes, или же no. Если выбор экспортируется, то выбор в виджете отменяет выбор текущего выбора X, выбор вне виджета отменяет выбор любого виджета, и виджет будет отвечать на запросы извлечения выбора, когда он имеет выбор.

12

font => Строка

Задает шрифт, используемый при рисовании текста внутри виджета.

13

foreground or fg => Строка

Задает нормальный цвет переднего плана для использования при отображении виджета.

14

highlightbackground => Строка

Задает цвет для отображения в области выделения обхода, когда виджет не имеет фокуса ввода.

15

highlightcolor => Строка

Задает цвет, который будет использоваться для выделенного прямоугольника обхода, который рисуется вокруг виджета, когда он имеет фокус ввода.

16

highlightthickness => Целое число

Задает неотрицательное значение, указывающее ширину выделенного прямоугольника для рисования за пределами виджета, когда он имеет фокус ввода.

17

image => Изображение

Задает изображение для отображения в виджете, которое должно быть создано с помощью создания изображения. Обычно, если указан параметр изображения, он переопределяет другие параметры, которые определяют растровое изображение или текстовое значение для отображения в виджете; параметр изображения может быть сброшен на пустую строку, чтобы повторно включить отображение растрового изображения или текста.

18

jump => Строка

Для виджетов с ползунком, который можно перетаскивать для настройки значения, например полос прокрутки и масштабов, этот параметр определяет, когда будут делаться уведомления об изменениях значения. Значение параметра должно быть логическим. Если значение равно false, обновления выполняются непрерывно при перемещении ползунка. Если значение истинно, обновления откладываются до тех пор, пока кнопка мыши не будет отпущена для завершения перетаскивания; в этот момент делается одно уведомление.

19

justify => Строка

Когда в виджете отображается несколько строк текста, этот параметр определяет, как строки выстраиваются друг с другом. Должен быть одним изleft, center, или же right. Left означает, что все левые края линий совпадают, center означает, что центры линий выровнены, а right означает, что правые края линий совпадают.

20

offset => Строка

Задает смещение плиток (см. Также tileвариант). Может иметь два разных форматаoffset x,y или же offset side, где сторона может быть n, ne, e, se, s, sw, w, nw, или же center.

21 год

orient => Строка

Для виджетов, которые могут располагаться в горизонтальной или вертикальной ориентации, таких как полосы прокрутки, этот параметр указывает, какую ориентацию следует использовать. Должно быть либоhorizontal или же vertical или сокращение одного из них.

22

padx => Целое число

Задает неотрицательное значение, показывающее, сколько дополнительного места следует запросить для виджета в направлении X.

23

pady => Целое число

Задает неотрицательное значение, указывающее, сколько дополнительного места следует запрашивать для виджета в направлении Y.

24

relief => Целое число

Задает желаемый для виджета трехмерный эффект. Допустимые значения:raised, sunken, flat, ridge, и groove.

25

repeatdelay => Целое число

Определяет количество миллисекунд, в течение которого кнопка или клавиша должны удерживаться нажатыми, прежде чем они начнут автоповтор. Используется, например, для стрелок вверх и вниз на полосах прокрутки.

26

repeatinterval => Целое число

Используется вместе с repeatdelay: после начала автоповтора эта опция определяет количество миллисекунд между автоповторами

27

selectbackground => Строка

Задает цвет фона для использования при отображении выбранных элементов.

28

selectborderwidth => Целое число

Определяет неотрицательное значение, указывающее ширину трехмерной границы для обрисовки выбранных элементов.

29

selectforeground => Строка

Задает цвет переднего плана для использования при отображении выбранных элементов.

30

setgrid => Логическое

Задает логическое значение, определяющее, управляет ли этот виджет сеткой изменения размера для своего окна верхнего уровня. Эта опция обычно используется в текстовых виджетах, где информация в виджете имеет естественный размер (размер символа), и имеет смысл, чтобы размеры окна были целыми числами этих единиц.

31 год

takefocus => Целое число

Предоставляет информацию, используемую при перемещении фокуса из окна в окно с помощью обхода клавиатуры (например, Tab и Shift-Tab). Перед установкой фокуса на окно сценарии обхода сначала проверяют, доступно ли окно для просмотра (оно и все его предки отображаются); в противном случае окно пропускается. Значение 0 означает, что это окно следует полностью пропустить при обходе клавиатуры. 1 означает, что это окно всегда должно получать фокус ввода.

32

text => Строка

Задает строку, отображаемую внутри виджета. Способ отображения строки зависит от конкретного виджета и может определяться другими параметрами, такими какanchor или же justify.

33

textvariable => Переменная

Задает имя переменной. Значение переменной - это текстовая строка, отображаемая внутри виджета; если значение переменной изменится, виджет автоматически обновится, чтобы отразить новое значение. Способ отображения строки в виджете зависит от конкретного виджета и может определяться другими параметрами, такими какanchor или же justify.

34

tile => Изображение

Задает изображение, используемое для отображения виджета. Если изображение представляет собой пустую строку, отображается нормальный цвет фона.

35 год

troughcolor => Строка

Задает цвет, который будет использоваться для прямоугольных желобов в виджетах, таких как полосы прокрутки и шкалы.

36

troughtile => Изображение

Задает изображение, используемое для отображения в прямоугольных областях желоба в виджетах, таких как полосы прокрутки и шкалы.

37

underline => Целое число

Задает целочисленный индекс символа, который нужно подчеркнуть в виджете. Этот параметр используется привязками по умолчанию для реализации обхода клавиатуры для кнопок меню и пунктов меню. 0 соответствует первому символу текста, отображаемому в виджете, 1 - следующему символу и так далее.

38

wraplength => Целое число

Для виджетов, которые могут выполнять перенос слов, этот параметр определяет максимальную длину строки.

39

xscrollcommand => функция

Задает обратный вызов, используемый для взаимодействия с горизонтальными полосами прокрутки.

40

yscrollcommand => функция

Задает обратный вызов, используемый для взаимодействия с вертикальными полосами прокрутки.

Управление геометрией Ruby / Tk

Geometry Management занимается размещением различных виджетов в соответствии с требованиями. Управление геометрией в Tk основано на концепции главных и подчиненных виджетов.

Мастер - это виджет, обычно окно верхнего уровня или фрейм, который будет содержать другие виджеты, которые называются подчиненными. Вы можете думать о диспетчере геометрии как о берущем под контроль главный виджет и решающем, что будет отображаться внутри.

Менеджер геометрии спросит у каждого подчиненного виджета его естественный размер или размер, который в идеале он хотел бы отображать. Затем он берет эту информацию и объединяет ее с любыми параметрами, предоставленными программой, когда он просит диспетчер геометрии управлять этим конкретным подчиненным виджетом.

Есть три менеджера геометрии: размещение, сетка и упаковка , которые отвечают за управление размером и расположением каждого из виджетов в интерфейсе.

  • grid Менеджер геометрии, который упорядочивает виджеты в сетке.

  • pack Менеджер геометрии, который упаковывает края полости.

  • place Диспетчер геометрии для фиксированного размещения или размещения резиновых листов.

Обработка событий Ruby / Tk

Ruby / Tk поддерживает цикл обработки событий , который получает события от операционной системы. Это такие вещи, как нажатия кнопок, нажатия клавиш, движение мыши, изменение размера окна и так далее.

Ruby / Tk позаботится об управлении этим циклом событий за вас. Он определит, к какому виджету относится событие (нажал ли пользователь эту кнопку? Была ли нажата клавиша, какое текстовое поле было в фокусе?), И отправит его соответствующим образом. Отдельные виджеты знают, как реагировать на события, поэтому, например, кнопка может менять цвет, когда мышь перемещается по ней, и возвращаться обратно, когда мышь покидает ее.

На более высоком уровне Ruby / Tk вызывает обратные вызовы в вашей программе, чтобы указать, что с виджетом произошло что-то существенное. В любом случае вы можете предоставить блок кода или объект Ruby Proc, который указывает, как приложение реагирует на событие или обратный вызов.

Давайте посмотрим, как использовать метод bind для связи основных событий оконной системы с процедурами Ruby, которые их обрабатывают. Простейшая форма привязки принимает в качестве входных данных строку, указывающую имя события и блок кода, который Tk использует для обработки события.

Например, чтобы поймать событие ButtonRelease для первой кнопки мыши на некотором виджете, вы должны написать:

someWidget.bind('ButtonRelease-1') {
   ....code block to handle this event...
}

Название события может включать дополнительные модификаторы и детали. Модификатор - это строка типа Shift , Control или Alt , указывающая, что была нажата одна из клавиш-модификаторов.

Так, например, чтобы поймать событие, которое генерируется, когда пользователь, удерживая клавишу Ctrl, щелкает правой кнопкой мыши.

someWidget.bind('Control-ButtonPress-3', proc { puts "Ouch!" })

Многие виджеты Ruby / Tk могут запускать обратные вызовы, когда пользователь активирует их, и вы можете использовать обратный вызов команды, чтобы указать, что в этом случае вызывается определенный блок кода или процедура. Как было показано ранее, вы можете указать процедуру обратного вызова команды при создании виджета -

helpButton = TkButton.new(buttonFrame) {
   text "Help"
   command proc { showHelp }
}

Или вы можете назначить его позже, используя метод команды виджета -

helpButton.command proc { showHelp }

Поскольку метод команды принимает либо процедуры, либо блоки кода, вы также можете написать предыдущий пример кода как -

helpButton = TkButton.new(buttonFrame) {
   text "Help"
   command { showHelp }
}
Sr.No. Тег и описание события
1

"1" (one)

Щелкнул левой кнопкой мыши.

2

"ButtonPress-1"

Щелкнул левой кнопкой мыши.

3

"Enter"

Переместили мышь внутрь.

4

"Leave"

Переместила мышь наружу.

5

"Double-1"

Дважды щелкнул.

6

"B3-Motion"

Перетащите правую кнопку из одного положения в другое.

7

Control-ButtonPress-3

Правая кнопка нажимается вместе с клавишей Ctrl .

8

Alt-ButtonPress-1

Кнопка Let нажимается вместе с клавишей Alt .

Метод настройки

Метод configure может использоваться для установки и получения любых значений конфигурации виджета. Например, чтобы изменить ширину кнопки, вы можете в любое время вызвать метод конфигурации следующим образом:

require "tk"

button = TkButton.new {
   text 'Hello World!'
   pack
}
button.configure('activebackground', 'blue')
Tk.mainloop

Чтобы получить значение для текущего виджета, просто укажите его без значения следующим образом:

color = button.configure('activebackground')

Вы также можете вызвать configure без каких-либо опций, что даст вам список всех опций и их значений.

Метод cget

Для простого получения значения параметра configure возвращает больше информации, чем вы обычно хотите. Метод cget возвращает только текущее значение.

color = button.cget('activebackground')

Ruby / LDAP - это библиотека расширений для Ruby. Он предоставляет интерфейс для некоторых библиотек LDAP, таких как OpenLDAP, UMich LDAP, Netscape SDK, ActiveDirectory.

Общий API для разработки приложений описан в RFC1823 и поддерживается Ruby / LDAP.

Установка Ruby / LDAP

Вы можете загрузить и установить полный пакет Ruby / LDAP с SOURCEFORGE.NET .

Перед установкой Ruby / LDAP убедитесь, что у вас есть следующие компоненты:

  • Ruby 1.8.x (по крайней мере 1.8.2, если вы хотите использовать ldap / control).
  • OpenLDAP, Netscape SDK, Windows 2003 или Windows XP.

Теперь вы можете использовать стандартный метод установки Ruby. Перед запуском, если вы хотите увидеть доступные параметры для extconf.rb, запустите его с параметром --help.

$ ruby extconf.rb [--with-openldap1|--with-openldap2| \
                   --with-netscape|--with-wldap32]
$ make $ make install

NOTE- Если вы собираете программное обеспечение в Windows, вам может потребоваться использовать nmake вместо make .

Установить соединение LDAP

Это двухэтапный процесс -

Шаг 1 - Создайте объект подключения

Ниже приведен синтаксис для создания подключения к каталогу LDAP.

LDAP::Conn.new(host = 'localhost', port = LDAP_PORT)
  • host- Это идентификатор хоста, на котором запущен каталог LDAP. Мы возьмем его как localhost .

  • port- Это порт, используемый для службы LDAP. Стандартные порты LDAP - 636 и 389. Убедитесь, что порт используется на вашем сервере, иначе вы можете использовать LDAP :: LDAP_PORT.

Этот вызов возвращает новое соединение LDAP :: Conn с сервером, хостом , через порт порт .

Шаг 2 - Привязка

Здесь мы обычно указываем имя пользователя и пароль, которые будем использовать до конца сеанса.

Ниже приведен синтаксис для привязки соединения LDAP с использованием DN, dn, учетные данные, pwd, и метод привязки, method -

conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)do
....
end

Вы можете использовать тот же метод без блока кода. В этом случае вам нужно будет явно отвязать соединение следующим образом:

conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)
....
conn.unbind

Если указан блок кода, блоку уступается self .

Теперь мы можем выполнять операции поиска, добавления, изменения или удаления внутри блока метода привязки (между привязкой и отменой привязки), если у нас есть соответствующие разрешения.

Example

Предполагая, что мы работаем на локальном сервере, давайте вместе укажем соответствующий хост, домен, идентификатор пользователя и пароль и т. Д.

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')
....
conn.unbind

Добавление записи LDAP

Добавление записи LDPA - это двухэтапный процесс:

Шаг 1 - Создание объекта LDAP :: Mod

Нам нужно передать объект LDAP :: Mod методу conn.add для создания записи. Вот простой синтаксис для создания объекта LDAP :: Mod -

Mod.new(mod_type, attr, vals)
  • mod_type - Один или несколько вариантов LDAP_MOD_ADD, LDAP_MOD_REPLACE или LDAP_MOD_DELETE.

  • attr - должно быть имя атрибута, с которым нужно работать.

  • vals- это массив значений, относящихся к attr . Если vals содержит двоичные данные, mod_type следует объединить логическим ИЛИ (|) с LDAP_MOD_BVALUES.

Этот вызов возвращает объект LDAP :: Mod , который может быть передан в методы класса LDAP :: Conn, такие как Conn # add, Conn # add_ext, Conn # modify и Conn # modify_ext.

Шаг 2 - Вызов метода conn.add

Когда мы будем готовы с объектом LDAP :: Mod , мы можем вызвать метод conn.add для создания записи. Вот синтаксис для вызова этого метода -

conn.add(dn, attrs)

Этот метод добавляет запись с DN, dn , и атрибутами attrs . Здесь attrs должен быть либо массивом объектов LDAP :: Mod, либо хешем пар массивов атрибут / значение.

Example

Вот полный пример, который создаст две записи в каталоге -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
entry1 = [
   LDAP.mod(LDAP::LDAP_MOD_ADD,'objectclass',['top','domain']),
   LDAP.mod(LDAP::LDAP_MOD_ADD,'o',['TTSKY.NET']),
   LDAP.mod(LDAP::LDAP_MOD_ADD,'dc',['localhost']),
]

entry2 = [
   LDAP.mod(LDAP::LDAP_MOD_ADD,'objectclass',['top','person']),
   LDAP.mod(LDAP::LDAP_MOD_ADD, 'cn', ['Zara Ali']),
   LDAP.mod(LDAP::LDAP_MOD_ADD | LDAP::LDAP_MOD_BVALUES, 'sn', 
                     ['ttate','ALI', "zero\000zero"]),
]

begin
   conn.add("dc = localhost, dc = localdomain", entry1)
   conn.add("cn = Zara Ali, dc = localhost, dc =  localdomain", entry2)
rescue LDAP::ResultError
   conn.perror("add")
   exit
end
conn.perror("add")
conn.unbind

Изменение записи LDAP

Изменение записи аналогично добавлению. Просто вызовите метод модификации вместо добавления атрибутов, которые нужно изменить. Вот простой синтаксис метода модификации .

conn.modify(dn, mods)

Этот метод изменяет запись с помощью DN, dn и атрибутов mods . Здесь моды должны быть либо массивом объектов LDAP :: Mod, либо хешем пар массивов атрибут / значение.

пример

Чтобы изменить фамилию записи, которую мы добавили в предыдущем разделе, мы должны написать -

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
entry1 = [
   LDAP.mod(LDAP::LDAP_MOD_REPLACE, 'sn', ['Mohtashim']),
]

begin
   conn.modify("cn = Zara Ali, dc = localhost, dc = localdomain", entry1)
rescue LDAP::ResultError
   conn.perror("modify")
   exit
end
conn.perror("modify")
conn.unbind

Удаление записи LDAP

Чтобы удалить запись, вызовите метод удаления с различающимся именем в качестве параметра. Вот простой синтаксис метода удаления .

conn.delete(dn)

Этот метод удаляет запись с DN, dn .

пример

Чтобы удалить запись Зары Мохташим , которую мы добавили в предыдущем разделе, мы должны написать:

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.delete("cn = Zara-Mohtashim, dc = localhost, dc = localdomain")
rescue LDAP::ResultError
   conn.perror("delete")
   exit
end
conn.perror("delete")
conn.unbind

Изменение отличительного имени

Невозможно изменить отличительное имя записи с помощью метода модификации . Вместо этого используйте метод modrdn . Вот простой синтаксис метода modrdn -

conn.modrdn(dn, new_rdn, delete_old_rdn)

Этот метод изменяет RDN записи на DN, dn , давая ему новое RDN new_rdn . Если delete_old_rdn это правда , старое значение RDN будет удалено из записи.

пример

Предположим, у нас есть следующая запись -

dn: cn = Zara Ali,dc = localhost,dc = localdomain
cn: Zara Ali
sn: Ali
objectclass: person

Затем мы можем изменить его отличительное имя с помощью следующего кода -

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.modrdn("cn = Zara Ali, dc = localhost, dc = localdomain", "cn = Zara Mohtashim", true)
rescue LDAP::ResultError
   conn.perror("modrdn")
   exit
end
conn.perror("modrdn")
conn.unbind

Выполнение поиска

Чтобы выполнить поиск в каталоге LDAP, используйте метод поиска с одним из трех различных режимов поиска:

  • LDAP_SCOPE_BASEM - Искать только базовый узел.

  • LDAP_SCOPE_ONELEVEL - Искать всех дочерних узлов базового узла.

  • LDAP_SCOPE_SUBTREE - Искать во всем поддереве, включая базовый узел.

пример

Здесь мы будем искать все поддерево входа постоянного тока = локальный, DC = LOCALDOMAIN для человека объектов -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

base = 'dc = localhost,dc = localdomain'
scope = LDAP::LDAP_SCOPE_SUBTREE
filter = '(objectclass = person)'
attrs = ['sn', 'cn']

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.search(base, scope, filter, attrs) { |entry|
      # print distinguished name
      p entry.dn
      # print all attribute names
      p entry.attrs
      # print values of attribute 'sn'
      p entry.vals('sn')
      # print entry as Hash
      p entry.to_hash
   }
rescue LDAP::ResultError
   conn.perror("search")
   exit
end
conn.perror("search")
conn.unbind

Это вызывает данный блок кода для каждой совпадающей записи, где запись LDAP представлена ​​экземпляром класса LDAP :: Entry. С помощью последнего параметра поиска вы можете указать интересующие вас атрибуты, опуская все остальные. Если вы передадите здесь nil, все атрибуты будут возвращены так же, как «SELECT *» в реляционных базах данных.

Метод dn (псевдоним для get_dn) класса LDAP :: Entry возвращает отличительное имя записи, а с помощью метода to_hash вы можете получить хэш-представление его атрибутов (включая отличительное имя). Чтобы получить список атрибутов записи, используйте метод attrs (псевдоним для get_attributes). Кроме того, чтобы получить список значений одного конкретного атрибута, используйте метод vals (псевдоним для get_values).

Обработка ошибок

Ruby / LDAP определяет два разных класса исключений -

  • В случае ошибки методы new, bind или unbind вызывают исключение LDAP :: Error.

  • В случае добавления, изменения, удаления или поиска в каталоге LDAP возникает ошибка LDAP :: ResultError.

Дальнейшее чтение

Полную информацию о методах LDAP см. В стандартной документации LDAP Documentation .

Традиционные программы имеют один поток выполнения: операторы или инструкции, составляющие программу, выполняются последовательно, пока программа не завершится.

Многопоточная программа имеет более одного потока выполнения. Внутри каждого потока операторы выполняются последовательно, но сами потоки могут выполняться параллельно, например, на многоядерном ЦП. Часто на машине с одним ЦП несколько потоков фактически не выполняются параллельно, но параллелизм моделируется путем чередования выполнения потоков.

Ruby позволяет легко писать многопоточные программы с помощью класса Thread . Потоки Ruby - это легкий и эффективный способ добиться параллелизма в вашем коде.

Создание потоков Ruby

Чтобы начать новый поток, просто свяжите блок с вызовом Thread.new . Будет создан новый поток для выполнения кода в блоке, и исходный поток немедленно вернется из Thread.new и возобновит выполнение со следующим оператором -

# Thread #1 is running here
Thread.new {
   # Thread #2 runs this code
}
# Thread #1 runs this code

пример

Вот пример, который показывает, как мы можем использовать многопоточную программу Ruby.

#!/usr/bin/ruby

def func1
   i = 0
   while i<=2
      puts "func1 at: #{Time.now}"
      sleep(2)
      i = i+1
   end
end

def func2
   j = 0
   while j<=2
      puts "func2 at: #{Time.now}"
      sleep(1)
      j = j+1
   end
end

puts "Started At #{Time.now}"
t1 = Thread.new{func1()}
t2 = Thread.new{func2()}
t1.join
t2.join
puts "End at #{Time.now}"

Это даст следующий результат -

Started At Wed May 14 08:21:54 -0700 2008
func1 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:55 -0700 2008
func1 at: Wed May 14 08:21:56 -0700 2008
func2 at: Wed May 14 08:21:56 -0700 2008
func1 at: Wed May 14 08:21:58 -0700 2008
End at Wed May 14 08:22:00 -0700 2008

Жизненный цикл потока

Новые потоки создаются с помощью Thread.new . Вы также можете использовать синонимы Thread.start и Thread.fork .

Нет необходимости запускать поток после его создания, он начинает работать автоматически, когда ресурсы ЦП становятся доступными.

Класс Thread определяет ряд методов для запроса и управления потоком во время его работы. Поток запускает код в блоке, связанном с вызовом Thread.new, а затем останавливается.

Значение последнего выражения в этом блоке является значением потока и может быть получено путем вызова метода value объекта Thread. Если поток завершился, значение сразу же возвращает значение потока. В противном случае метод значения блокируется и не возвращается, пока поток не завершится.

Метод класса Thread.current возвращает объект Thread, представляющий текущий поток. Это позволяет потокам манипулировать собой. Метод класса Thread.main возвращает объект Thread, представляющий основной поток. Это начальный поток выполнения, который начался при запуске программы Ruby.

Вы можете дождаться завершения определенного потока, вызвав его метод Thread.join . Вызывающий поток будет заблокирован, пока данный поток не завершится.

Потоки и исключения

Если исключение возникает в основном потоке и нигде не обрабатывается, интерпретатор Ruby выводит сообщение и завершает работу. В потоках, отличных от основного потока, необработанные исключения вызывают остановку потока.

Если нить t завершается из-за необработанного исключения, а другой поток sвызывает t.join или t.value, затем исключение, возникшее вt поднят в потоке s.

Если Thread.abort_on_exception имеет значение false , условие по умолчанию, необработанное исключение просто убивает текущий поток, а все остальные продолжают выполняться.

Если вы хотите, чтобы какое-либо необработанное исключение в каком-либо потоке вызывало завершение работы интерпретатора, установите для метода класса Thread.abort_on_exception значение true .

t = Thread.new { ... }
t.abort_on_exception = true

Переменные потока

Обычно поток может обращаться к любым переменным, которые находятся в области видимости при создании потока. Переменные, локальные для блока потока, являются локальными для потока и не являются общими.

Класс Thread имеет специальное средство, которое позволяет создавать локальные переменные потока и обращаться к ним по имени. Вы просто обрабатываете объект потока, как если бы это был хэш, записывая элементы с помощью [] = и считывая их обратно с помощью [].

В этом примере каждый поток записывает текущее значение переменной count в переменную threadlocal с ключом mycount .

#!/usr/bin/ruby

count = 0
arr = []

10.times do |i|
   arr[i] = Thread.new {
      sleep(rand(0)/10.0)
      Thread.current["mycount"] = count
      count += 1
   }
end

arr.each {|t| t.join; print t["mycount"], ", " }
puts "count = #{count}"

Это дает следующий результат -

8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10

Основной поток ожидает завершения подпотоков и затем распечатывает значение счетчика, захваченное каждым из них.

Приоритеты потоков

Первым фактором, влияющим на планирование потоков, является приоритет потока: потоки с высоким приоритетом планируются раньше потоков с низким приоритетом. Точнее, поток получит процессорное время только в том случае, если нет потоков с более высоким приоритетом, ожидающих запуска.

Вы можете установить и запросить приоритет объекта Ruby Thread с приоритетом = и приоритетом . Вновь созданный поток запускается с тем же приоритетом, что и поток, который его создал. Основной поток запускается с приоритетом 0.

Невозможно установить приоритет потока перед его запуском. Однако поток может повышать или понижать свой собственный приоритет в качестве первого действия, которое он выполняет.

Исключение темы

Если два потока имеют общий доступ к одним и тем же данным, и хотя бы один из потоков изменяет эти данные, вы должны позаботиться о том, чтобы ни один поток никогда не мог видеть данные в несогласованном состоянии. Это называется исключением потока .

Mutex- это класс, реализующий простую блокировку семафоров для взаимоисключающего доступа к некоторому общему ресурсу. То есть только один поток может удерживать блокировку в данный момент времени. Другие потоки могут выбрать ожидание в очереди, пока блокировка станет доступной, или могут просто выбрать немедленное получение ошибки, указывающей, что блокировка недоступна.

Помещая все обращения к общим данным под контроль мьютекса , мы обеспечиваем согласованность и атомарную работу. Давайте попробуем примеры, первый без mutax и второй с mutax -

Пример без Mutax

#!/usr/bin/ruby
require 'thread'

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      count1 += 1
      count2 += 1
   end
end
spy = Thread.new do
   loop do
      difference += (count1 - count2).abs
   end
end
sleep 1
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

Это даст следующий результат -

count1 :  1583766
count2 :  1583766
difference : 0
#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      mutex.synchronize do
         count1 += 1
         count2 += 1
      end
   end
end
spy = Thread.new do
   loop do
      mutex.synchronize do
         difference += (count1 - count2).abs
      end
   end
end
sleep 1
mutex.lock
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

Это даст следующий результат -

count1 :  696591
count2 :  696591
difference : 0

Обработка тупиков

Когда мы начинаем использовать объекты Mutex для исключения потоков, мы должны быть осторожны, чтобы избежать взаимоблокировки . Тупик - это состояние, которое возникает, когда все потоки ожидают получения ресурса, удерживаемого другим потоком. Поскольку все потоки заблокированы, они не могут снять удерживаемые блокировки. И поскольку они не могут снять блокировки, никакой другой поток не может получить эти блокировки.

Здесь на помощь приходят условные переменные . Переменная условия просто семафор , который связан с ресурсом и используется в защите определенного мьютекса . Когда вам нужен недоступный ресурс, вы ждете переменной условия. Это действие снимает блокировку соответствующего мьютекса . Когда какой-либо другой поток сигнализирует о доступности ресурса, исходный поток прекращает ожидание и одновременно восстанавливает блокировку критической области.

пример

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

cv = ConditionVariable.new
a = Thread.new {
   mutex.synchronize {
      puts "A: I have critical section, but will wait for cv"
      cv.wait(mutex)
      puts "A: I have critical section again! I rule!"
   }
}

puts "(Later, back at the ranch...)"

b = Thread.new {
   mutex.synchronize {
      puts "B: Now I am critical, but am done with cv"
      cv.signal
      puts "B: I am still critical, finishing up"
   }
}
a.join
b.join

Это даст следующий результат -

A: I have critical section, but will wait for cv
(Later, back at the ranch...)
B: Now I am critical, but am done with cv
B: I am still critical, finishing up
A: I have critical section again! I rule!

Состояния потоков

Существует пять возможных возвращаемых значений, соответствующих пяти возможным состояниям, как показано в следующей таблице. Метод статуса возвращает состояние потока.

Состояние потока Возвращаемое значение
Работоспособен бежать
Спать Спать
Прерывание прерывание
Прекращено нормально ложный
Прекращено за исключением ноль

Методы класса потока

Следующие методы предоставляются классом Thread и применимы ко всем потокам, доступным в программе. Эти методы будут вызываться с использованием имени класса Thread следующим образом:

Thread.abort_on_exception = true
Sr.No. Методы и описание
1

Thread.abort_on_exception

Возвращает состояние глобального прерывания при возникновении исключения . По умолчанию - false . Если установлено значение true , все потоки будут прерваны (процесс завершится (0)), если в каком-либо потоке возникнет исключение.

2

Thread.abort_on_exception=

Если установлено значение true , все потоки будут прерваны, если возникнет исключение. Возвращает новое состояние.

3

Thread.critical

Возвращает состояние критического состояния глобального потока .

4

Thread.critical=

Устанавливает состояние критического состояния глобального потока и возвращает его. Если установлено значение true , запрещает планирование любого существующего потока. Не блокирует создание и запуск новых потоков. Определенные операции потока (такие как остановка или завершение потока, засыпание в текущем потоке и создание исключения) могут привести к тому, что поток будет запланирован даже в критическом разделе.

5

Thread.current

Возвращает текущий выполняющийся поток.

6

Thread.exit

Завершает текущий запущенный поток и планирует запуск другого потока. Если этот поток уже отмечен для уничтожения, exit возвращает Thread. Если это основной поток или последний поток, выйдите из процесса.

7

Thread.fork { block }

Синоним Thread.new.

8

Thread.kill( aThread )

Заставляет данный поток выйти

9

Thread.list

Возвращает массив объектов Thread для всех потоков, которые либо выполняются, либо остановлены. Нить.

10

Thread.main

Возвращает основной поток процесса.

11

Thread.new( [ arg ]* ) {| args | block }

Создает новый поток для выполнения инструкций, заданных в блоке, и начинает его выполнение. Любые аргументы, переданные в Thread.new , передаются в блок.

12

Thread.pass

Вызывает планировщик потока для передачи выполнения другому потоку.

13

Thread.start( [ args ]* ) {| args | block }

В основном то же, что и Thread.new . Однако, если класс Thread является подклассом, то вызов start в этом подклассе не вызовет метод инициализации подкласса .

14

Thread.stop

Останавливает выполнение текущего потока, переводя его в состояние сна , и планирует выполнение другого потока. Сбрасывает критическое состояние на ложное.

Методы экземпляра потока

Эти методы применимы к экземпляру потока. Эти методы будут вызываться как использующие экземпляр потока следующим образом:

#!/usr/bin/ruby

thr = Thread.new do   # Calling a class method new
   puts "In second thread"
   raise "Raise exception"
end
thr.join   # Calling an instance method join
Sr.No. Методы и описание
1

thr[ aSymbol ]

Ссылка на атрибут - возвращает значение локальной переменной потока с использованием символа или имени aSymbol . Если указанная переменная не существует, возвращает ноль .

2

thr[ aSymbol ] =

Назначение атрибута - устанавливает или создает значение локальной переменной потока, используя символ или строку.

3

thr.abort_on_exception

Возвращает статус прерывания при условии исключения для thr . По умолчанию - false .

4

thr.abort_on_exception=

Если установлено значение true , все потоки (включая основную программу) прерываются, если в thr возникает исключение . Процесс фактически завершится (0) .

5

thr.alive?

Возвращает истину, если th работает или спит.

6

thr.exit

Завершает Чет и графики другой поток для запуска. Если этот поток уже отмечен для уничтожения, exit возвращает Thread . Если это основной поток или последний поток, завершает процесс.

7

thr.join

Вызывающий поток приостановит выполнение и запустит th . Не возвращается до Чет выходов. Любые не присоединенные потоки будут уничтожены при выходе из основной программы.

8

thr.key?

Возвращает истину, если данная строка (или символ) существует как локальная переменная потока.

9

thr.kill

Синоним Thread.exit .

10

thr.priority

Возвращает приоритет thr . По умолчанию - ноль; потоки с более высоким приоритетом будут выполняться раньше потоков с более низким приоритетом.

11

thr.priority=

Устанавливает приоритет th в целое число. Потоки с более высоким приоритетом будут выполняться перед потоками с более низким приоритетом.

12

thr.raise( anException )

Вызывает исключение из троллейбуса . Звонящий не должен быть заброшен .

13

thr.run

Просыпается Чет , что делает его пригодным для планирования. Если не в критическом разделе, то вызывает планировщик.

14

thr.safe_level

Возвращает действующий безопасный уровень для th .

15

thr.status

Возвращает статус thr : sleep, если th спит или ожидает ввода-вывода, запускается, если th выполняется, false, если th завершился нормально, и nil, если th завершился с исключением.

16

thr.stop?

Возвращает true, если th мертв или спит.

17

thr.value

Ожидает завершения th через Thread.join и возвращает его значение.

18

thr.wakeup

Знаки Thr в качестве приемлемых для планирования, он все еще может оставаться заблокированы на I / O, однако.

Поскольку модуль ядра включен в класс Object , его методы доступны повсюду в программе Ruby. Их можно вызывать без приемника (функциональная форма). Поэтому их часто называют функциями.

Sr.No. Методы и описание
1

abort

Завершает программу. Если возникает исключение (т. Е. $! Не равно нулю), отображается сообщение об ошибке.

2

Array( obj)

Возвращает obj после преобразования его в массив с помощью to_ary или to_a.

3

at_exit {...}

Регистрирует блок для выполнения при выходе из программы. Аналогично оператору END, но оператор END регистрирует блок только один раз.

4

autoload( classname, file)

Регистрирует имя класса класса, которое будет загружено из файла при его первом использовании. имя класса может быть строкой или символом.

5

binding

Возвращает текущую переменную и привязки метода. Связывание объект , который возвращается , может быть передан в Eval методы в качестве второго аргумента.

6

block_given?

Возвращает true, если метод был вызван с блоком .

7

callcc {| c|...}

Передает Продолжение объекта С к блоку и выполняет блок. callcc может использоваться для глобального выхода или построения цикла.

8

caller([ n])

Возвращает текущий стек выполнения в виде массива строк в форме file: line . Если указано n, возвращает элементы стека с уровня n и ниже.

9

catch( tag) {...}

Ловит нелокальный выход с помощью throw, вызываемого во время выполнения своего блока.

10

chomp([ rs = $/])

Возвращает значение переменной $_ with the ending newline removed, assigning the result back to $_. Значение строки новой строки можно указать с помощью rs.

11

chomp!([ rs = $/])

Удаляет новую строку из $ _, изменяя строку на месте.

12

chop

Возвращает значение $_ with its last character (one byte) removed, assigning the result back to $_.

13

chop!

Удаляет последний символ из $ _, изменяя строку на месте.

14

eval( str[, scope[, file, line]])

Выполняет str как код Ruby. Привязка, в которой будет выполняться оценка, может быть указана с помощью области действия . Имя файла и номер строки компилируемого кода могут быть указаны с использованием файла и строки.

15

exec( cmd[, arg...])

Заменяет текущий процесс, выполняя команду cmd . Если указано несколько аргументов, команда выполняется без расширения оболочки.

16

exit([ result = 0])

Выход из программы с результатом в виде кода состояния.

17

exit!([ result = 0])

Убивает программу, минуя обработку выхода, такую ​​как гарантия и т. Д.

18

fail(...)

Смотрите поднять (...)

19

Float( obj)

Возвращает obj после преобразования в число с плавающей запятой. Числовые объекты преобразуются напрямую; nil преобразуется в 0,0; строки конвертируются с учетом префикса основания 0x, 0b. Остальные конвертируются с помощью obj.to_f.

20

fork

fork {...}

Создает дочерний процесс. В дочернем процессе возвращается nil, а в родительском процессе возвращается идентификатор дочернего процесса (целое число). Если блок указан, он запускается в дочернем процессе.

21 год

format( fmt[, arg...])

См. Sprintf.

22

gets([ rs = $/])

Считывает имя файла, указанное в командной строке, или одну строку из стандартного ввода. Строку разделителя записей можно указать явно с помощью rs.

23

global_variables

Возвращает массив имен глобальных переменных.

24

gsub( x, y)

gsub( x) {...}

Заменяет все строки, соответствующие x в $_ with y. If a block is specified, matched strings are replaced with the result of the block. The modified result is assigned to $_.

25

gsub!( x, y)

gsub!( x) {...}

Выполняет ту же замену, что и gsub, за исключением того, что строка заменяется на место.

26

Integer( obj)

Возвращает obj после преобразования в целое число. Числовые объекты преобразуются напрямую; nil преобразуется в 0; строки конвертируются с учетом префикса основания 0x, 0b. Остальные конвертируются с помощью obj.to_i.

27

lambda {| x|...}

proc {| x|...}

lambda

proc

Преобразует блок в объект Proc . Если блок не указан, преобразуется блок, связанный с вызывающим методом.

28

load( file[, private = false])

Загружает программу Ruby из файла . В отличие от require , он не загружает библиотеки расширений. Если private - true , программа загружается в анонимный модуль, таким образом защищая пространство имен вызывающей программы.

29

local_variables

Возвращает массив имен локальных переменных.

30

loop {...}

Повторяет блок кода.

31 год

open( path[, mode = "r"])

open( path[, mode = "r"]) {| f|...}

Открывает файл . Если блок указан, блок выполняется с открытым потоком, переданным в качестве аргумента. Файл закрывается автоматически при выходе из блока. Если путь начинается с вертикальной черты |, следующая строка запускается как команда, и возвращается поток, связанный с этим процессом.

32

p( obj)

Отображает obj, используя его метод проверки (часто используемый для отладки).

33

print([ arg...])

Печатает arg в $ defout . Если аргументы не указаны, печатается значение $ _.

34

printf( fmt[, arg...])

Форматирует arg согласно fmt с помощью sprintf и выводит результат в $ defout . Подробные сведения о спецификациях форматирования см. В sprintf.

35 год

proc {| x|...}

proc

См. Ламду.

36

putc( c)

Печатает один символ для вывода по умолчанию ( $ defout ).

37

puts([ str])

Выводит строку на вывод по умолчанию ( $ defout ). Если строка не заканчивается символом новой строки, к строке добавляется новая строка.

38

raise(...)

fail(...)

Вызывает исключение. Предполагает RuntimeError, если класс исключения не указан. Вызов метода raise без аргументов в предложении rescue повторно вызывает исключение. Выполнение этого вне предложения rescue вызывает RuntimeError без сообщений .fail - устаревшее название повышения.

39

rand([ max = 0])

Генерирует псевдослучайное число, большее или равное 0, но меньшее max. Если max не указан или установлен в 0, случайное число возвращается как число с плавающей запятой больше или равно 0 и меньше 1. srand может использоваться для инициализации псевдослучайного потока.

40

readline([ rs = $/])

Эквивалентен get, за исключением того, что вызывает исключение EOFError при чтении EOF.

41 год

readlines([ rs = $/])

Возвращает массив строк, содержащих либо имена файлов, указанные в качестве аргументов командной строки, либо содержимое стандартного ввода.

42

require( lib)

Загружает библиотеку (включая библиотеки расширений) lib при ее первом вызове. require не будет загружать одну и ту же библиотеку более одного раза. Если расширение не указано в lib , require пытается добавить к нему .rb, .so и т. Д.

43 год

scan( re)

scan( re) {|x|...}

Эквивалентно $ _. Scan.

44

select( reads[, writes = nil[, excepts = nil[, timeout = nil]]])

Проверяет наличие изменений состояния трех типов ввода, вывода и исключений объектов ввода-вывода, которые передаются в виде массивов объектов ввода-вывода. nil передается для аргументов, которые не нуждаются в проверке. Возвращается трехэлементный массив, содержащий массивы объектов ввода-вывода, состояние которых было изменено. nil возвращается по таймауту.

45

set_trace_func( proc)

Устанавливает обработчик трассировки. proc может быть строкой или объектом proc . set_trace_func используется отладчиком и профилировщиком.

46

sleep([ sec])

Приостанавливает выполнение программы на sec секунд. Если sec не указан, программа приостанавливается навсегда.

47

split([ sep[, max]])

Эквивалентно $ _. Split.

48

sprintf( fmt[, arg...])

format( fmt[, arg...])

Возвращает строку, в которой аргумент отформатирован в соответствии с fmt. Спецификации форматирования по сути такие же, как и для sprintf на языке программирования C. Спецификаторы преобразования (%, за которым следует спецификатор поля преобразования) в fmt заменяются форматированной строкой соответствующего аргумента. Список поданных конверсий приведен ниже в следующем разделе.

49

srand([ seed])

Инициализирует массив случайных чисел. Если начальное число не указано, инициализация выполняется с использованием времени и другой системной информации для начального числа.

50

String( obj)

Возвращает obj после преобразования его в строку с помощью obj.to_s.

51

syscall( sys[, arg...])

Вызывает функцию вызова операционной системы, заданную числом sys . Числа и значение sys зависят от системы.

52

system( cmd[, arg...])

Выполняет cmd как вызов командной строки. Если указано несколько аргументов, команда запускается напрямую без расширения оболочки. Возвращает истину, если статус возврата равен 0 (успех).

53

sub( x, y)

sub( x) {...}

Заменяет первую строку, совпадающую с x в $ _, на y. Если указан блок, совпавшие строки заменяются результатом блока. Измененный результат присваивается $ _.

54

sub!( x, y)

sub!( x) {...}

Выполняет ту же замену, что и sub, за исключением того, что строка заменяется на месте.

55

test( test, f1[, f2])

Выполняет различные проверки файлов, указанные в символьном тесте . Чтобы улучшить читаемость, вы должны использовать методы класса File (например, File :: readable?), А не эту функцию. Список аргументов приводится ниже в следующем разделе.

56

throw( tag[, value = nil])

Переходит к ожидающей функции catch с символом или строковым тегом . value - это возвращаемое значение, которое будет использоваться функцией catch .

57

trace_var( var, cmd)

trace_var( var) {...}

Устанавливает трассировку для глобальной переменной. Имя переменной указывается в виде символа. cmd может быть строкой или объектом Proc.

58

trap( sig, cmd)

trap( sig) {...}

Устанавливает обработчик сигнала. sig может быть строкой (например, SIGUSR1) или целым числом. В названии сигнала можно не указывать SIG. Обработчик сигнала EXIT или сигнала номер 0 вызывается непосредственно перед завершением процесса.

59

untrace_var( var[, cmd])

Удаляет трассировку для глобальной переменной. Если указан cmd , удаляется только эта команда.

Функции для чисел

Вот список встроенных функций, связанных с числом. Их следует использовать следующим образом -

#!/usr/bin/ruby

num = 12.40
puts num.floor      # 12
puts num + 10       # 22.40
puts num.integer?   # false  as num is a float.

Это даст следующий результат -

12
22.4
false
Sr.No. Методы и описание
1

n + num

n - num

n * num

n / num

Выполняет арифметические операции: сложение, вычитание, умножение и деление.

2

n % num

Возвращает модуль n.

3

n ** num

Возведение в степень.

4

n.abs

Возвращает абсолютное значение n.

5

n.ceil

Возвращает наименьшее целое число, большее или равное n.

6

n.coerce( num)

Возвращает массив, содержащий num и n, которые, возможно, преобразованы в тип, позволяющий работать с ними взаимно. Используется при автоматическом преобразовании типов в числовых операторах.

7

n.divmod( num)

Возвращает массив, содержащий частное и модуль от деления n на num.

8

n.floor

Возвращает наибольшее целое число, меньшее или равное n.

9

n.integer?

Возвращает истину, если n - целое число.

10

n.modulo( num)

Возвращает модуль, полученный делением n на число и округлением частного до пола.

11

n.nonzero?

Возвращает n, если оно не равно нулю, иначе - nil.

12

n.remainder( num)

Возвращает остаток, полученный от деления n по numи удаление десятичных знаков из частного. Вresult и n всегда имеют один и тот же знак.

13

n.round

Возвращает n, округленное до ближайшего целого числа.

14

n.truncate

Возвращает n как целое число без десятичных знаков.

15

n.zero?

Возвращает ноль, если n равно 0.

16

n & num

n | num

n ^ num

Побитовые операции: И, ИЛИ, XOR и инверсия.

17

n << num

n >> num

Побитовый сдвиг влево и вправо.

18

n[num]

Возвращает значение numth бит от младшего бита, который равен n [0].

19

n.chr

Возвращает строку, содержащую символ для кода символа. n.

20

n.next

n.succ

Возвращает следующее целое число после n. Эквивалентно n + 1.

21 год

n.size

Возвращает количество байтов в машинном представлении n.

22

n.step( upto, step) {|n| ...}

Итерирует блок из n к upto, увеличиваясь на step каждый раз.

23

n.times {|n| ...}

Итерирует блок n раз.

24

n.to_f

Конвертирует nв число с плавающей запятой. Преобразование с плавающей запятой может привести к потере точной информации.

25

n.to_int

Возврат n после преобразования в целое число.

Функции для Float

Sr.No. Методы и описание
1

Float::induced_from(num)

Возвращает результат преобразования num в число с плавающей запятой.

2

f.finite?

Возвращает true, если f не бесконечно, а f.nan - false.

3

f.infinite?

Возвращает 1, если f - положительная бесконечность, -1, если отрицательная бесконечность, или nil, если что-то еще.

4

f.nan?

Возвращает истину, если f не является допустимым числом с плавающей запятой IEEE.

Функции для математики

Sr.No. Методы и описание
1

atan2( x, y)

Вычисляет арктангенс.

2

cos( x)

Вычисляет косинус x.

3

exp( x)

Вычисляет экспоненциальную функцию (e в степени x).

4

frexp( x)

Возвращает двухэлементный массив, содержащий номинальную дробь и показатель степени x.

5

ldexp( x, exp)

Возвращает значение x, умноженное на 2, в степени exp.

6

log( x)

Вычисляет натуральный логарифм x.

7

log10( x)

Вычисляет десятичный логарифм x.

8

sin( x)

Вычисляет синус x.

9

sqrt( x)

Возвращает квадратный корень из x. x должен быть положительным.

10

tan( x)

Вычисляет тангенс x.

Спецификатор поля преобразования

Функция sprintf (fmt [, arg ...]) и format (fmt [, arg ...]) возвращает строку, в которой arg отформатирован согласно fmt. Спецификации форматирования по сути такие же, как и для sprintf на языке программирования C. Спецификаторы преобразования (%, за которым следует спецификатор поля преобразования) в fmt заменяются форматированной строкой соответствующего аргумента.

Sr.No. Спецификатор и описание
1

b

Двоичное целое число

2

c

Одиночный персонаж

3

d,i

Десятичное целое число

4

e

Экспоненциальная запись (например, 2.44e6)

5

E

Экспоненциальная запись (например, 2.44E6)

6

f

Число с плавающей запятой (например, 2,44)

7

g

используйте% e, если показатель степени меньше -4, иначе% f

8

G

используйте% E, если показатель степени меньше -4, иначе% f

9

o

Восьмеричное целое число

10

s

Строка или любой объект, преобразованный с использованием to_s

11

u

Десятичное целое без знака

12.

x

Шестнадцатеричное целое число (например, 39ff)

13

X

Шестнадцатеричное целое число (например, 39FF)

Ниже приведен пример использования -

#!/usr/bin/ruby

str = sprintf("%s\n", "abc")   # => "abc\n" (simplest form)
puts str 

str = sprintf("d=%d", 42)      # => "d=42" (decimal output)
puts str 

str = sprintf("%04x", 255)     # => "00ff" (width 4, zero padded)
puts str 

str = sprintf("%8s", "hello")  # => " hello" (space padded)
puts str 

str = sprintf("%.2s", "hello") # => "he" (trimmed by precision)
puts str

Это даст следующий результат -

abc
d = 42
00ff
   hello
he

Аргументы тестовой функции

Функциональный тест (тест, f1 [, f2]) выполняет один из следующих файловых тестов, указанных в символьном тесте . Чтобы улучшить читаемость, вы должны использовать методы класса File (например, File :: readable?), А не эту функцию.

Sr.No. Аргумент и описание
1

?r

Может ли f1 считываться эффективным идентификатором вызывающего абонента?

2

?w

Может ли f1 записываться эффективным идентификатором вызывающего абонента?

3

?x

Исполняется ли f1 действующим uid вызывающего?

4

?o

Принадлежит ли f1 эффективному идентификатору вызывающего абонента?

5

?R

Читается ли f1 настоящим uid вызывающего абонента?

6

?W

Может ли f1 записываться настоящим uid вызывающего абонента?

7

?X

Исполняется ли f1 настоящим uid вызывающего абонента?

8

?O

Принадлежит ли f1 настоящий uid вызывающего абонента?

9

?e

Есть ли f1?

10

?z

Имеет ли f1 нулевую длину?

11

?s

Размер файла f1 (ноль, если 0)

12

?f

Это обычный файл?

13

?d

F1 - это каталог?

14

?l

Является ли f1 символической ссылкой?

15

?p

Является ли f1 именованным каналом (FIFO)?

16

?S

F1 - это сокет?

17

?b

Является ли f1 блочным устройством?

18

?c

Является ли f1 символьным устройством?

19

?u

Установлен ли бит setuid в f1?

20

?g

Установлен ли бит setgid в f1?

21 год

?k

Установлен ли липкий бит в f1?

22

?M

Время последней модификации для f1.

23

?A

Время последнего доступа для f1.

24

?C

Время последней смены inode для f1.

Sr.No. Аргумент и описание
1

?=

Равны ли времена модификации f1 и f2?

2

?>

Является ли время модификации f1 более поздним, чем f2?

3

?<

Время модификации f1 старше, чем f2?

4

?-

Является ли f1 жесткой ссылкой на f2?

Ниже приведен пример использования. Предполагая, что main.rb существует с разрешениями на чтение, запись и не выполнение -

#!/usr/bin/ruby

puts test(?r, "main.rb" )   # => true
puts test(?w, "main.rb" )   # => true
puts test(?x, "main.rb" )   # => false

Это даст следующий результат -

true
false
false

Ruby - предопределенные переменные

Предопределенные переменные Ruby влияют на поведение всей программы, поэтому их использование в библиотеках не рекомендуется.

К значениям в большинстве предопределенных переменных можно получить доступ альтернативными способами.

В следующей таблице перечислены все предопределенные переменные Ruby.

Sr.No. Имя и описание переменной
1

$!

Последний возникший объект исключения. К объекту исключения также можно получить доступ, используя => в предложении rescue .

2

$@

Трассировка стека для последнего возникшего исключения. Информация об обратной трассировке стека может быть получена методом Exception # backtrace последнего исключения.

3

$/

Разделитель входной записи (по умолчанию новая строка). get, readline и т. д. принимают разделитель входной записи в качестве необязательного аргумента.

4

$\

Разделитель выходной записи (по умолчанию ноль).

5

$,

Разделитель вывода между аргументами для печати и Array # join (по умолчанию ноль). Вы можете явно указать разделитель для Array # join.

6

$;

Разделитель по умолчанию для разделения (по умолчанию ноль). Вы можете явно указать разделитель для String # split.

7

$.

Номер последней строки, прочитанной из текущего входного файла. Эквивалент ARGF.lineno.

8

$<

Синоним ARGF.

9

$>

Синоним слова $ defout.

10

$0

Имя текущей исполняемой программы Ruby.

11

$$

Идентификатор процесса текущей исполняемой программы Ruby.

12

$?

Статус выхода последнего процесса прекращен.

13

$:

Синоним для $ LOAD_PATH.

14

$DEBUG

Истинно, если указан параметр командной строки -d или --debug.

15

$defout

Целевой вывод для print и printf ( по умолчанию $ stdout ).

16

$F

Переменная, которая получает вывод от split, если указан -a. Эта переменная устанавливается, если параметр командной строки -a указан вместе с параметром -p или -n.

17

$FILENAME

Имя файла, который в данный момент читается из ARGF. Эквивалентно ARGF.filename.

18

$LOAD_PATH

An array holding the directories to be searched when loading files with the load and require methods.

19

$SAFE

The security level

0 → No checks are performed on externally supplied (tainted) data. (default)

1 → Potentially dangerous operations using tainted data are forbidden.

2 → Potentially dangerous operations on processes and files are forbidden.

3 → All newly created objects are considered tainted.

4 → Modification of global data is forbidden.

20

$stdin

Standard input (STDIN by default).

21

$stdout

Standard output (STDOUT by default).

22

$stderr

Standard error (STDERR by default).

23

$VERBOSE

True if the -v, -w, or --verbose command-line option is specified.

24

$- x

The value of interpreter option -x (x=0, a, d, F, i, K, l, p, v). These options are listed below

25

$-0

The value of interpreter option -x and alias of $/.

26

$-a

The value of interpreter option -x and true if option -a is set. Read-only.

27

$-d

The value of interpreter option -x and alias of $DEBUG

28

$-F

The value of interpreter option -x and alias of $;.

29

$-i

The value of interpreter option -x and in in-place-edit mode, holds the extension, otherwise nil. Can enable or disable in-place-edit mode.

30

$-I

The value of interpreter option -x and alias of $:.

31

$-l

The value of interpreter option -x and true if option -lis set. Read-only.

32

$-p

The value of interpreter option -x and true if option -pis set. Read-only.

33

$_

The local variable, last string read by gets or readline in the current scope.

34

$~

The local variable, MatchData relating to the last match. Regex#match method returns the last match information.

35

$ n ($1, $2, $3...)

The string matched in the nth group of the last pattern match. Equivalent to m[n], where m is a MatchData object.

36

$&

The string matched in the last pattern match. Equivalent to m[0], where m is a MatchData object.

37

$`

The string preceding the match in the last pattern match. Equivalent to m.pre_match, where m is a MatchData object.

38

$'

The string following the match in the last pattern match. Equivalent to m.post_match, where m is a MatchData object.

39

$+

The string corresponding to the last successfully matched group in the last pattern match.

Ruby - Predefined Constants

The following table lists all the Ruby's Predefined Constants −

NOTE − TRUE, FALSE, and NIL are backward-compatible. It's preferable to use true, false, and nil.

Sr.No. Constant Name & Description
1

TRUE

Synonym for true.

2

FALSE

Synonym for false.

3

NIL

Synonym for nil.

4

ARGF

An object providing access to virtual concatenation of files passed as command-line arguments or standard input if there are no command-line arguments. A synonym for $<.

5

ARGV

An array containing the command-line arguments passed to the program. A synonym for $*.

6

DATA

An input stream for reading the lines of code following the __END__ directive. Not defined if __END__ isn't present in code.

7

ENV

A hash-like object containing the program's environment variables. ENV can be handled as a hash.

8

RUBY_PLATFORM

A string indicating the platform of the Ruby interpreter.

9

RUBY_RELEASE_DATE

A string indicating the release date of the Ruby interpreter

10

RUBY_VERSION

A string indicating the version of the Ruby interpreter.

11

STDERR

Standard error output stream. Default value of $stderr.

12

STDIN

Standard input stream. Default value of $stdin.

13

STDOUT

Standard output stream. Default value of $stdout.

14

TOPLEVEL_BINDING

A binding object at Ruby's top level.

Ruby - Associated Tools

Standard Ruby Tools

The standard Ruby distribution contains useful tools along with the interpreter and standard libraries −

These tools help you debug and improve your Ruby programs without spending much effort. This tutorial will give you a very good start with these tools.

  • RubyGems −

    RubyGems is a package utility for Ruby, which installs Ruby software packages and keeps them up-to-date.

  • Ruby Debugger −

    To help deal with bugs, the standard distribution of Ruby includes a debugger. This is very similar to gdb utility, which can be used to debug complex programs.

  • Interactive Ruby (irb) −

    irb (Interactive Ruby) was developed by Keiju Ishitsuka. It allows you to enter commands at the prompt and have the interpreter respond as if you were executing a program. irb is useful to experiment with or to explore Ruby.

  • Ruby Profiler −

    Ruby profiler helps you to improve the performance of a slow program by finding the bottleneck.

Additional Ruby Tools

There are other useful tools that don't come bundled with the Ruby standard distribution. However, you do need to install them yourself.

  • eRuby: Embeded Ruby −

    eRuby stands for embedded Ruby. It's a tool that embeds fragments of Ruby code in other files, such as HTML files similar to ASP, JSP and PHP.

  • ri: Ruby Interactive Reference −

    When you have a question about the behavior of a certain method, you can invoke ri to read the brief explanation of the method.

For more information on Ruby tool and resources, have a look at Ruby Useful Resources.