Переменные и константы
В этом курсе мы будем использовать так называемые локальные переменные. Имена локальных переменных начинаются со строчной латинской буквы (от a до z) или символа подчеркивания и продолжаются любой комбинацией латинских букв, цифр и символа подчеркивания. Те же правила распространяются и на имена методов.
В языке имеется небольшое множество зарезервированных слов, которые нельзя использовать в качестве имен переменных и методов.
| Зарезервированные слова | |||||||
|---|---|---|---|---|---|---|---|
| __FILE__ | and | def | end | in | or | self | unless |
| __LINE__ | begin | defined? | ensure | module | redo | super | until |
| BEGIN | break | do | false | next | rescue | then | when |
| END | case | else | for | nil | retry | true | while |
| alias | class | elsif | if | not | return | undef | yield |
Кроме локальных переменных Ruby поддерживает и другие их виды — глобальные переменные, переменные классов и экземпляров. Принадлежность к каждому из этих видов определяются символом, стоящим перед именем переменной (префиксом): символ $ задает глобальную переменную, @ — переменную экземпляра, @@ — переменную класса. Локальные переменные не имеют префикса. Имена констант и классов должны начинаться с прописной латинской буквы (A-Z) и, аналогично переменным, продолжаются любой комбинацией латинских букв, цифр и символа подчеркивания.
Локальная переменная создается динамически в момент, когда ей в процессе выполнения программы первый раз присваивается какое-то значение. Оператор присваивания имеет вид знака = (равно), например, a = 1; b = a; name = «Иван». Переменные могут использоваться во всех выражениях Ruby аналогично соответствующим объектам:
a = "Привет всем!" puts a
В Ruby переменные есть ссылки на объекты. Их следует трактовать как некие метки. Для того чтобы лучше понять эту концепцию проведем следующую аналогию: пусть у вас есть некоторая коробка (объект), вы берете наклейку (переменную), подписываете ее (даете имя переменной), после чего наклеиваете ее на коробку (объект). В Ruby переменные не имеют типа, так как они есть всего лишь ссылки на объекты произвольных типов. Проиллюстрируем сказанное следующим примером:
a = "one" puts a puts a.type a = 23 puts a puts a.type
Обратите внимание на метод type, возвращающий тип объекта. При первом использовании переменная a есть ссылка на объект класса String, затем мы присваиваем этой переменной другое значение (наклеиваем ту же этикетку на новый объект), после чего она становится ссылкой на экземпляр класса Fixnum.
Ruby поддерживает также и присваивание с операцией. Результат выполнения следующих двух операторов одинаковы:
a+=12 a=a+12
Общая форма подобных операторов выглядит так:
выражение1 операция= выражение2
что соответствует оператору
выражение1 = выражение1 операция выражение2
Между знаком операции и символом равенства не должно быть пробела. Такой синтаксис допустим для следующих операций:
Когда требуется присвоить значение нескольким переменным, можно использовать множественное присваивание:
a, b, c = 1, 2, 3
Пример
Пусть требуется обменять значения двух переменных, не вводя вспомогательную переменную. С использованием множественного присваивания это можно записать так:
a, b = b, a
Данный пример объясняет, почему эту форму оператора присваивания называют также «параллельным присваиванием».
Мы уже упоминали одну из замечательных возможностей Ruby — подстановку. Она позволяет выполнять разнообразные трюки со строкой, заключенной в двойные кавычки, например,
magic = 42 puts "Секретное число равно #!!"
Когда Ruby находит конструкцию # внутри строки, заключенной в двойные кавычки, то заменяет эту ее часть на результат вычисления выражения.
Пример
Дано трехзначное число. Напечатать число, получающееся при перестановке цифр десятков и единиц заданного числа.
number = 342 puts "Исходное число равно #" n1 = number/100 # число сотен n2 = (number/10)%10 # число десятков n3 = number%10 # число единиц answer = n1*100 + n3*10 + n2 puts "Результат #"
Иногда возникает необходимость указать, что тот или иной объект в программе является неизменяемым. Такие объекты называются константами. В Ruby имена констант, также как и имена классов, должны начинаться с заглавной буквы (есть определенная традиция задавать имена констант, состоящие из одних заглавных букв). Рассмотрим следующий фрагмент программы:
NUM = 234 p NUM # 234 NUM = "qq" # warning: already initialized constant NUM p NUM # "qq"
Как видим, интерпретатор выдал предупреждение о том, что константа NUM уже была определена ранее. Тем не менее значение константы было изменено.
Задания
- Напишите программу, печатающую количество квадратов со стороной 130 мм, которое можно отрезать от прямоугольника со сторонами 543×130 мм.
- Напишите программу, которая по данному числу a, не используя никаких арифметических операций, кроме умножения, получает a 8 за три операции.
Ruby on Rails c нуля!
RubyDev Ruby Tutorial > О переменных и константах
сентября 1, 2012 | Published in Ruby, Основы | 6 Comments
Честно говоря я не очень понимаю в чем возникает путаница с переменными в Ruby, однако мне уже не раз задавали вопросы типа: Что такое @-переменная? Что такое @@-переменная? А в чем их разница?
В этой статье я постараюсь рассказать обо всех типах переменных и константах языка Ruby, а на подобные вопросы буду давать ссылку на эту статью.
В Ruby существует 4 вида переменных и константы.
Локальные переменные
product , users , file , user_rights — все это примеры имен локальных переменных. Локальные переменные замкнуты в той области видимости, где они объявлены: тело модуля, тело класса, тело метода, объект, блок кода. Снаружи той области где они объявлены эти переменные не видны, потому область объявления включая вложенные области является областью видимости локальных переменных. Пример:
def my_method message = "Bye!" lmbd = ->(message) < puts message >lmbd.call("Hello!") puts message end my_method # Hello! # Bye!
Как видите, в нашем методе имеется 2 переменных с именем message, первая создается в самом начале тела метода и хранит строку «Bye!», а вторая принадлежит лямбде и хранит переданное в вызов лямбды значение. Областью видимости первой является все тело метода, а областью видимости второй — объект типа Proc — лямбда. Именно по этой причине message не меняет свое значение при вызове лямбды, так как у лямбды создается своя собственная переменная с тем же именем.
Переменные экземпляра
Следующий тип переменных — это переменные экземпляра класса или переменные объекта (экземпляр класса и объект — два названия одного и того же). Имена этих переменных начинаются со знака @, например:
@user , @articles , @attributes_hash , и т.д.
Областью видимости этих переменных является объект. Пример:
class User def initialize(login, password, email) @login = login @password = password @email = email end def user_data @user_data ||= < login: @login, password: @password, email: @email >end end user = User.new "admin", "qwerty", "admin@admin.com" #=> # user.user_data #=> "admin", :password=>"qwerty", :email=>"admin@admin.com">
Не смотря на то, что переменные @login, @password и @email были объявлены внутри метода #initialize, одни доступны и в методе #user_data. Областью видимости переменных экземпляра класса является весь объект.
Список переменных объекта можно получить используя метод #instance_variables:
user.instance_variables #=> [:@login, :@password, :@email, :@user_data]
Получить значение переменной экземпляра класса можно используя метод #instance_variable_get :
user.instance_variable_get :@email #=> "admin@admin.com"
Объявить новую переменную экземпляра класса или переопределить существующую можно используя метод #instance_variable_set :
user.instance_variable_set :@email, "admin@rubydev.ru" #=> "admin@rubydev.ru"
user.instance_variable_set :@name, «Vladimir»
#=> «Vladimir»
user.instance_variables
#=> [:@login, :@password, :@email, :@user_data, :@name]
Проверить объявлена ли определенная переменная экземпляра можно используя метод #instance_variable_defined? :
user.instance_variable_defined? :@name #=> true user.instance_variable_defined? :@last_name #=> false
Стоит отметить, что классы будучи также объектами также имеют переменные экземпляра класса.
class User def initialize(login, password, email) @id = User.increment_users_count @login = login @password = password @email = email end def user_data @user_data ||= < id: @id, login: @login, password: @password, email: @email >end def users_count self.class.instance_variable_get :@users_count end def self.users_count @users_count ||= 0 end def self.users_count=(value) @users_count = value end def self.increment_users_count self.users_count += 1 end end user = User.new "Vladimir", "123456", "admin@rubydev.ru" #=> # User.users_count #=> 1 user2 = User.new "Vitaly", "qwerty", "vitaly@rubydev.ru" #=> # User.users_count #=> 2 User.instance_variables #=> [:@users_count]
Переменные объекта самого класса недоступны в его экземплярах, точнее вы не можете обращаться к ним напрямую, но можете использовать методы #instance_variable_get или #instance_variable_set, например так:
def users_count self.class.instance_variable_get :@users_count end
Объявив такой метод для экземпляра класса User, мы можем получать значение счетчика экземпляров следующим образом:
user.users_count #=> 2
Переменные класса
Теперь рассмотрим переменные класса. Переменные класса — это переменные, имена которых начинаются с @@, например:
@@users , @@table_name , @@sql_adapter , @@very_very_long_class_variable_name
Переменные классов отличаются от переменных экземпляра класса тем, что будучи объявлены в любом месте, их областью видимости будет класс и все его экземпляры. То есть в отличие от переменных объекта самого класса, к переменным класса можно обратиться напрямую. Для того, чтобы продемонстрировать это я перепишу код класса User, что мы использовали ранее, с применением переменных класса.
class User @@users_count = 0 def initialize(login, password, email) @id = @@users_count += 1 @login = login @password = password @email = email end def user_data @user_data ||= < id: @id, login: @login, password: @password, email: @email >end def users_count @@users_count end def self.users_count @@users_count end end user = User.new "Vladimir", "123456", "admin@rubydev.ru" #=> # User.users_count #=> 1 user.users_count #=> 1 User.class_variables #=> [:@@users_count] User.class_variable_get :@@users_count #=> 1 User.class_variable_set :@@users_count, 100 #=> 100 User.users_count #=> 100 user.users_count #=> 100 User.class_variable_defined? :@@users_count #=> true
В общем работа с переменными класса очень похожа на работу с переменными экземпляра класса. Основная рекомендация к использованию переменных класса такая: Используйте переменные класса, если объекты нуждаются в данных из класса или для синхронизации между экземплярами класса. Примером обмена данными между объектами служит используемый нами в примерах счетчик экземпляров класса User.
Глобальные переменные
Глобальные переменные — это переменные, имена которых начинаются с символа $, например:
$: , $LOAD_PATH , $binding и т.д.
Глобальные переменные так называются так, потому, что независимо от области в которой они объявлены, они видны везде.
Получить список глобальных переменных можно используя метод global_variables. Вызвав global_variables в IRB REPL я получил следующий результат:
global_variables #=> [:$;, :$-F, :$@, :$!, :$SAFE, :$~, :$&, :$`, :$', :$+, :$=, :$KCODE, :$-K, :$,, :$/, :$-0, :$\, :$_, :$stdin, :$stdout, :$stderr, :$>, :$Вам лучше избегать создания глобальных переменных и переопределения значения уже существующих. В Ruby глобальные переменные используются в служебных целях, все приведенные выше глобальные переменные являются предопределенными и хранят определенные данные важные для работы вашего приложения. С ними нужно работать осторожно. Список предопределенных глобальных переменных с описанием доступен здесь: http://ruby.runpaint.org/globals
Теперь подошло время разобраться с константами. Константы — это «переменные», чье значение не изменяется, а имя начинается с заглавной литеры, наприме:User , UsersController , ProductsHelper и т.д.
Имена классов и модулей являются константами.
Несмотря на то, что в других языках переопределить значение константы нельзя, в Ruby это возможно, однако вы получете предупреждение.
MyConst = "rubydev.ru" MyConst = ["Rubydev.ru"] #(irb):77: warning: already initialized constant MyConst MyConst #=> ["Rubydev.ru"]Что еще можно сказать о константах? — Немного о метамагии!
Немного метамагии работы с константамиЕсли вы совсем взрослы и даже умеете работать с Rails, то вы, должно быть, использовали код вроде такого:
belongs_to :author, class_name: "User"Как же по строке «User» удается понять, что подразумевается использование класса User? Я не смотрел в исходники и потому не могу достоверно утверждать, но я подозреваю, что там используется следующий прием:
Kernel.const_get "User" #=> UserТаким простым образом мы «преобразуем» строку в константу, а посколько имена классов — константы, то в такой образ наше приложение способно понять, что мы хотим сделать.
Responses
- says:
сентября 1, 2012 at 17:57 (#) Ну не Kernel.const_get тогда уж, а Object.const_get, и вообще несколько сложнее все, тк нужно учитывать неймспейсы.. В общем в рельсе у строк есть метод #constantize — там все это и происходит.- says:
сентября 1, 2012 at 18:32 (#) Есть неочевидная, но существенная разница между переменными объекта класса и переменными класса (кроме того, что к первым нельзя напрямую обратиться из экземпляра). При наследовании переменные объекта класса у каждого класса будут свои, тогда как переменные класса наследуются, и изменение такой переменной где-то в потомке повлияет и на родителя и на прочих потомков.- admin says:
сентября 1, 2012 at 21:36 (#) Спасибо, Иван, это момент я забыл осветить, в ближайшее время добавлю. Михаил, насчет неймспейсов — это да, но здесь самый простой пример для новичков. Если его понять, то и как в случае с вложениями быть будет понятно. Да, ActiveSupport содержит такой метод расширяющий String, но статья исключительно о Ruby. Сейчас вникаю в разницу между Kernel.const_get и Object.const_get.- Shogun says:
сентября 13, 2012 at 18:40 (#) А разве в руби не 6 переменных?
1. константа — TEST
2. локальная — test
3. глобальная — $test
class Tester
@test # 4. переменная экземпляра класса (!)
@@test # 5. переменная класса
def testing
print @test # 6. переменная экземпляра (!)
end
end В книге «Язык программирования Ruby» делается различие между 4 и 6.
Объясни пожалуйста этот момент.- admin says:
сентября 13, 2012 at 21:27 (#) Shogun, в Ruby класс — это объект. В первом случае @test будет переменной объекта Tester, а во втором переменной объекта Tester.new. В любом случае обе переменные являются переменными объекта или экземпляра или instance, но только объект/экземпляр/instance которомы они принадлежат — разные.- sooik says:
августа 16, 2013 at 11:18 (#) Не работает ссылка =(Ruby/Переменные
Переменные используются, чтобы сохранить промежуточный результат вычислений. Имя переменной в Ruby должно:
- начинаться с буквы или знака подчёркивания;
- состоять из латинских букв, цифр или знака подчёркивания.
array variable another_variable 3element # неправильное имя. Начинается с цифры _3element # а вот как можно __ # немного странное, но допустимое имя переменной
Переменная может иметь имя не только латинское, но и русское. Для этого, правда, требуется, чтобы весь текст программы был написан в кодировке UTF-8, а интерпретатор запускался с параметром -KU .
Присваивание осуществляется знаком равенства ( = ), вот так:
array = [1, 2, 3, 4] variable = array + [1, 2] another_variable = variable - array
То, что справа от = , прежде чем стать значением переменной, обычно полностью вычисляется. Наша переменная variable будет содержать массив [1, 2, 3, 4, 1, 2] , потому что именно таков результат действия array + [1, 2] . Плюс ( + ) с массивами поступает именно так: прицепляет второй массив в хвост первого. Переменная another_variable теперь содержит пустой массив, поскольку операция минус убирает все вхождения элементов массива array из массива variable .
Переменные указывают на объект [ править ]
girlfriend = "Татьяна" goes_on_a_visit = girlfriend puts girlfriend #=> Татьяна goes_on_a_visit[0] = "Б" # меняем первую (номер ноль) букву у переменной-строки puts girlfriend #=> Батьяна # На первый взгляд странно и неожиданно
Значение, возвращаемое первой переменной, изменилось потому, что в Ruby переменные содержат лишь ссылку на то, что вы им присваиваете.
Сами данные (объект) лежат где-то в другом месте. Ввиду этого естественно, что при прямом изменении самого объекта, на который указывает переменная, все другие переменные, указывающие на этот объект, будут возвращать изменённое значение (также будут изменяться).
Чтобы girlfriend наша осталась "Татьяна" , надо в переменную занести её клон:
girlfriend = "Татьяна" goes_on_a_visit = girlfriend.clone goes_on_a_visit[0] = "М" # Но изменили мы лишь клон. Дома в сохранности сидит настоящая: puts girlfriend #=> Татьяна
Можно создавать копии объектов ещё методом .dup . Разница между ними будет понятна позже.
Для безвредного присваивания новых значений переменным их редко приходится клонировать, ибо большинство методов делают это и так. Даже если вы просто присвоите переменной новое значение, Ruby создаст объект с новым значением и поместит в (уже существующую) переменную ссылку на тот объект:
# … goes_on_a_visit = "Аристарх" # Создаётся новый объект, переменная переводится на него p girlfriend #=> "Татьяна"
Ruby — переменные, константы и литералы
Добавить в избранное
(2 оценок, среднее: 5,00 из 5)
Переменные — это ячейки памяти, в которых хранятся любые данные, которые будут использоваться любой программой.
Ruby поддерживает пять типов переменных. Вы уже прошли небольшое описание этих переменных в предыдущей главе. Эти пять типов переменных описаны в этой главе.
Глобальные переменные Ruby
Глобальные переменные начинаются с $. Неинициализированные глобальные переменные имеют значение nil и создают предупреждения с параметром -w.
Присвоение глобальных переменных изменяет глобальный статус. Не рекомендуется использовать глобальные переменные. Они делают программы загадочными.
Ниже приведен пример использования глобальной переменной.
#!/usr/bin/ruby $global_variable = 10 class Class1 def print_global puts "Глобальная переменная в Class1 есть #$global_variable" end end class Class2 def print_global puts "Глобальная переменная в Class2 есть #$global_variable" end end class1obj = Class1.new class1obj.print_global class2obj = Class2.new class2obj.print_global
Здесь $ global_variable является глобальной переменной. Это приведет к следующему результату:
Примечание
В Ruby вы можете получить доступ к значению любой переменной или константы, помещая символ хеша (#) непосредственно перед этой переменной или константой.
Глобальная переменная в Class1 есть 10 Глобальная переменная в Class2 есть 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 # Создание объектов cust1 = Customer.new("1", "AndreyEx", "Home, Krasnodar") cust2 = Customer.new("2", "Max", "Works, Rostov") # Вызов методов cust1.display_details() cust2.display_details()
Здесь @cust_id, @cust_name и @cust_addr являются переменными экземпляра. Это приведет к следующему результату:
Customer id 1 Customer name AndreYEx Customer address Home, Krasnodar Customer id 2 Customer name Max Customer address Works, Rostov
Переменные класса 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 # Создание объектов cust1 = Customer.new("1", "AndreyEx", "Home, Krasnodar") cust2 = Customer.new("2", "Max", "Works, Rostov") # CВызов методов cust1.total_no_of_customers() cust2.total_no_of_customers()
Здесь @@ no_of_customers — это переменная класса. Это приведет к следующему результату:
Total number of customers: 1 Total number of customers: 2
Локальные переменные Ruby
Локальные переменные начинаются с строчной буквы или _. Объем локальной переменной варьируется от класса, модуля, def или до соответствующего конца или от скобки открытия блока до его близкой привязки <>.
Когда ссылается неинициализированная локальная переменная, она интерпретируется как вызов метода, который не имеет аргументов.
Назначение неинициализированных локальных переменных также служит объявлением переменной. Переменные начинают существовать до тех пор, пока не будет достигнут конец текущей области. Время жизни локальных переменных определяется, когда Ruby анализирует программу.
В приведенном выше примере локальными переменными являются id, name и addr.
Константы Ruby
Константы начинаются с прописной буквы. Константы, определенные в классе или модуле, могут быть доступны из этого класса или модуля, а те, которые определены вне класса или модуля, могут быть доступны по всему миру.
Константы не могут быть определены в методах. Обращение к неинициализированной константе вызывает ошибку. Выполнение задания константе, которая уже инициализирована, выдает предупреждение.
#!/usr/bin/ruby class Example VAR1 = 100 VAR2 = 200 def show puts "Значение первой константы есть #" puts "Значение второй константы есть #" end end # Create Objects object = Example.new() object.show
Здесь VAR1 и VAR2 являются константами. Это приведет к следующему результату:
Значение первой константы есть 100 Значение второй константы есть 200
Псевдо-переменные Ruby
Это специальные переменные, которые имеют локальные переменные, но ведут себя как константы. Вы не можете присвоить значения этим переменным.
- self — Объект приемника текущего метода.
- true — значение, представляющее true.
- false — значение, представляющее 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
Примечание
Класс и объекты объясняются в отдельной главе этого руководства.
Плавающие числа
Ruby поддерживает плавающие числа. Они также являются числами, но с десятичными знаками. Числа с плавающей запятой являются объектами класса Float и могут быть любыми из следующих:
Пример
123.4 # значение с плавающей запятой 1.0e6 # экспоненциальное представление 4E20 # точка не требуется 4e+20 # знак перед экспоненциальным
Строковые литералы
Строки Ruby — это просто последовательности 8-битных байтов, и они являются объектами класса String. Строки с двойными кавычками допускают замещение и обратную косую черту, но строки с одним кавычком не позволяют замену и позволяют обозначать обратную косую черту только для \\ и \
Пример
#!/usr/bin/ruby -w puts 'пробел с помощью "\\"'; puts 'That\'s right';
Это приведет к следующему результату:
пробел с помощью "\" That's right
Вы можете подставить значение любого выражения Ruby в строку, используя последовательность # . Здесь expr может быть любым выражением ruby.
#!/usr/bin/ruby -w puts "Значение Умножения : #";
Это приведет к следующему результату:
Значение Умножения : 86400
Обозначения с обратной косой чертой
Ниже приведен список обозначений Backslash, поддерживаемых Ruby:
| \n | Новая линия (0x0a) |
| \r | Возврат каретки (0x0d) |
| \f | Подача бумаги (0x0c) |
| \b | клавиша Backspace (0x08) |
| \a | звонок (0x07) |
| \e | Escape (0x1b) |
| \s | Пробел (0x20) |
| \nnn | Восьмеричная запись (n being 0-7) |
| \xnn | Шестнадцатеричное представление (n being 0-9, a-f, or A-F) |
| \cx, \C-x | Control-x |
| \M-x | Meta-x (c | 0x80) |
| \M-\C-x | Meta-Control-x |
| \x | Символ x |
Массивы в Ruby
Для более подробной информации о Ruby Strings, пройдите на страницу Ruby. Строки.
Литералы массивов в Ruby создаются путем размещения разделенных запятыми рядов ссылок на объекты между квадратными скобками. Задняя запятая игнорируется.
Пример
#!/usr/bin/ruby ary = [ "AndreyEx", 10, 3.14, "Это строка", "последний элемент", ] ary.each do |i| puts i end
Это приведет к следующему результату:
AndreyEx 10 3.14 Это строка последний элемент
Для более подробной информации о Ruby Arrays, пройдите на страницу Ruby. Массивы.
Хеши в Ruby
Буквальный Хэш в Ruby создается путем размещения списка пар ключ / значение между фигурными скобками с запятой или последовательностью => между ключом и значением. Задняя запятая игнорируется.
Пример
#!/usr/bin/ruby hsh = colors = < "красный" =>0xf00, "зеленый" => 0x0f0, "синий" => 0x00f > hsh.each do |key, value| print key, " есть ", value, "\n" end
Это приведет к следующему результату:
красный есть 3840 зеленый есть 240 синий есть 15
Для более подробной информации о Ruby Hashes, пройдите на страницу Ruby. Хэши.
Диапазоны в Ruby
Диапазон представляет собой интервал, который представляет собой набор значений с началом и концом. Диапазоны могут быть построены с использованием литералов 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. Диапазоны.
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.