2013-08-18 08:44:31 +00:00
|
|
|
|
---
|
2024-10-20 21:46:35 +00:00
|
|
|
|
language: Ruby
|
2013-08-18 08:52:30 +00:00
|
|
|
|
filename: learnruby-ru.rb
|
2013-08-18 08:44:31 +00:00
|
|
|
|
contributors:
|
2013-08-18 10:59:29 +00:00
|
|
|
|
- ["David Underwood", "http://theflyingdeveloper.com"]
|
|
|
|
|
- ["Joel Walden", "http://joelwalden.net"]
|
|
|
|
|
- ["Luke Holder", "http://twitter.com/lukeholder"]
|
|
|
|
|
- ["Tristan Hume", "http://thume.ca/"]
|
|
|
|
|
- ["Nick LaMuro", "https://github.com/NickLaMuro"]
|
2013-09-13 17:28:48 +00:00
|
|
|
|
translators:
|
2013-08-18 10:59:29 +00:00
|
|
|
|
- ["Alexey Makarov", "https://github.com/Anakros"]
|
2017-09-17 18:00:30 +00:00
|
|
|
|
- ["Vasiliy Petrov", "https://github.com/Saugardas"]
|
2013-08-18 08:44:31 +00:00
|
|
|
|
---
|
|
|
|
|
|
|
|
|
|
```ruby
|
|
|
|
|
# Это комментарий
|
|
|
|
|
|
|
|
|
|
=begin
|
|
|
|
|
Это многострочный комментарий
|
|
|
|
|
Никто их не использует
|
|
|
|
|
И они не рекомендуются к использованию
|
|
|
|
|
=end
|
|
|
|
|
|
|
|
|
|
# Первое и самое главное: Всё является объектом.
|
|
|
|
|
|
|
|
|
|
# Числа это объекты
|
|
|
|
|
|
|
|
|
|
3.class #=> Fixnum
|
|
|
|
|
|
|
|
|
|
3.to_s #=> "3"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Немного простой арифметики
|
|
|
|
|
1 + 1 #=> 2
|
|
|
|
|
8 - 1 #=> 7
|
|
|
|
|
10 * 2 #=> 20
|
|
|
|
|
35 / 5 #=> 7
|
2017-09-17 18:00:30 +00:00
|
|
|
|
2**5 #=> 32
|
|
|
|
|
5 % 3 #=> 2
|
|
|
|
|
|
|
|
|
|
# Побитовые операторы
|
|
|
|
|
3 & 5 #=> 1
|
|
|
|
|
3 | 5 #=> 7
|
|
|
|
|
3 ^ 5 #=> 6
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
|
|
|
|
# Арифметика -- это синтаксический сахар
|
|
|
|
|
# над вызовом метода для объекта
|
|
|
|
|
1.+(3) #=> 4
|
|
|
|
|
10.* 5 #=> 50
|
|
|
|
|
|
|
|
|
|
# Логические величины -- это объекты
|
|
|
|
|
nil # Здесь ничего нет
|
2013-09-28 17:19:08 +00:00
|
|
|
|
true # истина
|
2013-08-18 08:44:31 +00:00
|
|
|
|
false # ложь
|
|
|
|
|
|
|
|
|
|
nil.class #=> NilClass
|
|
|
|
|
true.class #=> TrueClass
|
|
|
|
|
false.class #=> FalseClass
|
|
|
|
|
|
|
|
|
|
# Операция равенства
|
|
|
|
|
1 == 1 #=> true
|
|
|
|
|
2 == 1 #=> false
|
|
|
|
|
|
|
|
|
|
# Операция неравенства
|
|
|
|
|
1 != 1 #=> false
|
|
|
|
|
2 != 1 #=> true
|
|
|
|
|
|
|
|
|
|
# nil -- имеет такое же логическое значение, как и false
|
|
|
|
|
|
|
|
|
|
!nil #=> true
|
|
|
|
|
!false #=> true
|
|
|
|
|
!0 #=> false
|
|
|
|
|
|
|
|
|
|
# Больше операций сравнения
|
|
|
|
|
1 < 10 #=> true
|
|
|
|
|
1 > 10 #=> false
|
|
|
|
|
2 <= 2 #=> true
|
|
|
|
|
2 >= 2 #=> true
|
|
|
|
|
|
2017-09-17 18:00:30 +00:00
|
|
|
|
# Оператор сравнения <=>
|
|
|
|
|
1 <=> 10 #=> -1
|
|
|
|
|
10 <=> 1 #=> 1
|
|
|
|
|
1 <=> 1 #=> 0
|
|
|
|
|
|
|
|
|
|
# Булевы операторы
|
|
|
|
|
true && false #=> false
|
|
|
|
|
true || false #=> true
|
|
|
|
|
!true #=> false
|
|
|
|
|
|
|
|
|
|
# Существуют альтернативные версии логических операторов с гораздо меньшим
|
|
|
|
|
# приоритетом. Они используются для связывания операций, пока одна из них
|
|
|
|
|
# не вернёт false или true
|
|
|
|
|
|
|
|
|
|
# `do_something_else` будет вызван если `do_something` вернёт истинное значение
|
|
|
|
|
do_something() and do_something_else()
|
|
|
|
|
# `log_error` будет вызван если `do_something` вернёт (nil/false)
|
|
|
|
|
do_something() or log_error()
|
|
|
|
|
|
|
|
|
|
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Строки -- это объекты
|
|
|
|
|
|
|
|
|
|
'Я строка'.class #=> String
|
|
|
|
|
"Я тоже строка".class #=> String
|
|
|
|
|
|
|
|
|
|
placeholder = "использовать интерполяцию строк"
|
|
|
|
|
"Я могу #{placeholder}, когда создаю строку с двойными кавычками"
|
2013-09-28 17:19:08 +00:00
|
|
|
|
#=> "Я могу использовать интерполяцию строк,
|
|
|
|
|
# когда создаю строку с двойными кавычками"
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
2017-09-17 18:00:30 +00:00
|
|
|
|
# Конкатенация строк
|
|
|
|
|
'hello ' + 'world' #=> "hello world"
|
|
|
|
|
'hello ' + 3 #=> TypeError: can't convert Fixnum into String
|
|
|
|
|
'hello ' + 3.to_s #=> "hello 3"
|
|
|
|
|
|
|
|
|
|
# Умножение строк
|
|
|
|
|
'hello ' * 3 #=> "hello hello hello "
|
|
|
|
|
|
|
|
|
|
# Добавление к строке
|
|
|
|
|
'hello' << ' world' #=> "hello world"
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
|
|
|
|
# печатать в стандартный вывод
|
|
|
|
|
puts "Я печатаюсь!"
|
|
|
|
|
|
|
|
|
|
# Переменные
|
|
|
|
|
x = 25 #=> 25
|
|
|
|
|
x #=> 25
|
|
|
|
|
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Присваивание значения возвращает то самое присвоенное значение.
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Это позволяет делать множественные присваивания:
|
|
|
|
|
|
|
|
|
|
x = y = 10 #=> 10
|
|
|
|
|
x #=> 10
|
|
|
|
|
y #=> 10
|
|
|
|
|
|
|
|
|
|
# По соглашению, используйте snake_case для имён переменных
|
|
|
|
|
snake_case = true
|
|
|
|
|
|
|
|
|
|
# Используйте подробные имена для переменных
|
|
|
|
|
# Но не переборщите!
|
|
|
|
|
path_to_project_root = '/good/name/'
|
|
|
|
|
path = '/bad/name/'
|
|
|
|
|
|
|
|
|
|
# Идентификаторы (тоже объекты)
|
|
|
|
|
|
|
|
|
|
# Идентификаторы -- это неизменяемые, многоразовые константы.
|
2013-09-28 17:19:08 +00:00
|
|
|
|
# Для каждого идентификатора (кроме текста) сохраняется цифровой хэш.
|
|
|
|
|
# При последующем использовании идентификатора, заместо создания нового объекта,
|
|
|
|
|
# будет найден уже существующий по цифровому хэшу.
|
|
|
|
|
# Они часто используются вместо строк для ускорения работы приложений
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
|
|
|
|
:pending.class #=> Symbol
|
|
|
|
|
|
|
|
|
|
status = :pending
|
|
|
|
|
|
|
|
|
|
status == :pending #=> true
|
|
|
|
|
|
|
|
|
|
status == 'pending' #=> false
|
|
|
|
|
|
|
|
|
|
status == :approved #=> false
|
|
|
|
|
|
|
|
|
|
# Массивы
|
|
|
|
|
|
|
|
|
|
# Это массив
|
|
|
|
|
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
|
|
|
|
|
|
|
|
|
|
# Массив может содержать различные типы значений
|
|
|
|
|
|
|
|
|
|
[1, "hello", false] #=> [1, "hello", false]
|
|
|
|
|
|
|
|
|
|
# Значение в массиве можно получить по индексу с левой границы
|
|
|
|
|
array[0] #=> 1
|
2017-09-17 18:00:30 +00:00
|
|
|
|
array.first #=> 1
|
2013-08-18 08:44:31 +00:00
|
|
|
|
array[12] #=> nil
|
|
|
|
|
|
|
|
|
|
# Как и арифметика, доступ к значению в массиве
|
|
|
|
|
# это синтаксический сахар над вызовом метода для объекта
|
|
|
|
|
array.[] 0 #=> 1
|
|
|
|
|
array.[] 12 #=> nil
|
|
|
|
|
|
|
|
|
|
# Также, можно получить по индексу с правой границы
|
|
|
|
|
array[-1] #=> 5
|
2017-09-17 18:00:30 +00:00
|
|
|
|
array.last #=> 5
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
2017-10-17 09:45:02 +00:00
|
|
|
|
# Задавая индекс и количество элементов
|
|
|
|
|
array[0,2] #=> [1, 2]
|
|
|
|
|
array[0,999] #=> [1, 2, 3, 4, 5]
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
|
|
|
|
# Или с использованием диапазона значений
|
|
|
|
|
array[1..3] #=> [2, 3, 4]
|
|
|
|
|
|
2017-09-17 18:00:30 +00:00
|
|
|
|
# Перестановка элементов в обратном порядке
|
|
|
|
|
a = [1, 2, 3]
|
|
|
|
|
a.reverse #=> [3, 2, 1]
|
|
|
|
|
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Вот так можно добавить значение в массив
|
|
|
|
|
array << 6 #=> [1, 2, 3, 4, 5, 6]
|
2017-09-17 18:00:30 +00:00
|
|
|
|
# Или так
|
|
|
|
|
array.push(6) #=> [1, 2, 3, 4, 5, 6]
|
|
|
|
|
|
|
|
|
|
# Проверка включения элемента в массив
|
|
|
|
|
array.include?(1) #=> true
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Хэши -- это массив пар "ключ => значение".
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Хэши объявляются с использованием фигурных скобок:
|
|
|
|
|
hash = {'color' => 'green', 'number' => 5}
|
|
|
|
|
|
|
|
|
|
hash.keys #=> ['color', 'number']
|
2015-10-05 10:01:46 +00:00
|
|
|
|
hash.values #=> ['green', 5]
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
|
|
|
|
# Значение в хэше легко может быть найдено по ключу:
|
|
|
|
|
hash['color'] #=> 'green'
|
|
|
|
|
hash['number'] #=> 5
|
|
|
|
|
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Поиск по ключу, которого в хэше нет вернёт nil:
|
2013-08-18 08:44:31 +00:00
|
|
|
|
hash['nothing here'] #=> nil
|
|
|
|
|
|
|
|
|
|
# начиная с Ruby 1.9, существует специальный синтаксис
|
|
|
|
|
# при использовании идентификаторов как ключей хэша:
|
|
|
|
|
|
|
|
|
|
new_hash = { defcon: 3, action: true}
|
|
|
|
|
|
|
|
|
|
new_hash.keys #=> [:defcon, :action]
|
|
|
|
|
|
2017-09-17 18:00:30 +00:00
|
|
|
|
# Проверка существования ключа и значения в хеше
|
|
|
|
|
new_hash.key?(:defcon) #=> true
|
|
|
|
|
new_hash.value?(3) #=> true
|
|
|
|
|
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Массивы и Хэши -- перечисляемые типы данных
|
|
|
|
|
# У них есть много полезных методов, например: each, map, count и другие
|
|
|
|
|
|
|
|
|
|
# Управление ходом выполнения (Управляющие структуры)
|
|
|
|
|
|
2019-09-05 08:06:51 +00:00
|
|
|
|
# Условия
|
2013-08-18 08:44:31 +00:00
|
|
|
|
if true
|
2017-09-17 18:00:30 +00:00
|
|
|
|
'Если истина'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
elsif false
|
2017-09-17 18:00:30 +00:00
|
|
|
|
'Иначе, если ложь (опционально)'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
else
|
2017-09-17 18:00:30 +00:00
|
|
|
|
'Во всех других случаях (тоже опционально)'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
end
|
|
|
|
|
|
2019-09-05 08:06:51 +00:00
|
|
|
|
# Если условие контролирует выполнение не блока кода, а единственного выражения,
|
|
|
|
|
# можно использовать постфиксную запись условного оператора
|
|
|
|
|
warnings = ['Отсутствует отчество', 'Слишком короткий адрес']
|
|
|
|
|
puts("Обратите внимание:\n" + warnings.join("\n")) if !warnings.empty?
|
|
|
|
|
|
|
|
|
|
# Иногда условие лучше звучит с `unless`, чем с `if`
|
|
|
|
|
puts("Обратите внимание:\n" + warnings.join("\n")) unless warnings.empty?
|
|
|
|
|
|
|
|
|
|
# Циклы
|
2013-08-18 08:44:31 +00:00
|
|
|
|
for counter in 1..5
|
2013-09-28 17:19:08 +00:00
|
|
|
|
puts "итерация #{counter}"
|
2013-08-18 08:44:31 +00:00
|
|
|
|
end
|
|
|
|
|
#=> итерация 1
|
|
|
|
|
#=> итерация 2
|
|
|
|
|
#=> итерация 3
|
|
|
|
|
#=> итерация 4
|
|
|
|
|
#=> итерация 5
|
|
|
|
|
|
|
|
|
|
# Однако, никто не использует "for" для циклов.
|
|
|
|
|
# Вместо него Вы должны использовать метод "each" вместе с блоком кода.
|
|
|
|
|
#
|
2013-09-28 17:19:08 +00:00
|
|
|
|
# Блок кода -- это один из вариантов создания замыканий (лямбды,
|
|
|
|
|
# анонимные функции).
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Блок может только передаваться методу, сам по себе он существовать не может.
|
|
|
|
|
# "for" не имеет своей области видимости и все переменные, объявленные в нём
|
2013-09-28 17:19:08 +00:00
|
|
|
|
# будут доступны отовсюду. "each" вместе с блоком создаёт свою область видимости
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Метод "each" для диапазона значений запускает блок кода один раз
|
|
|
|
|
# для каждого из значений диапазона
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Блок передаёт счётчик (counter) в качестве параметра.
|
|
|
|
|
# Вызов метода "each" с блоком выглядит следующим образом:
|
|
|
|
|
|
|
|
|
|
(1..5).each do |counter|
|
|
|
|
|
puts "итерация #{counter}"
|
|
|
|
|
end
|
|
|
|
|
#=> итерация 1
|
|
|
|
|
#=> итерация 2
|
|
|
|
|
#=> итерация 3
|
|
|
|
|
#=> итерация 4
|
|
|
|
|
#=> итерация 5
|
|
|
|
|
|
|
|
|
|
# Вы также можете ограничивать блоки фигурными скобками:
|
2017-09-17 18:00:30 +00:00
|
|
|
|
(1..5).each { |counter| puts "итерация #{counter}" }
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
2013-09-28 17:19:08 +00:00
|
|
|
|
# Содержимое структурных данных также можно перебирать используя "each":
|
2013-08-18 08:44:31 +00:00
|
|
|
|
array.each do |element|
|
|
|
|
|
puts "#{element} -- часть массива"
|
|
|
|
|
end
|
|
|
|
|
hash.each do |key, value|
|
|
|
|
|
puts "#{key} -- это #{value}"
|
|
|
|
|
end
|
|
|
|
|
|
2017-09-17 18:00:30 +00:00
|
|
|
|
# Если вам нужен индекс вы можете использовать "each_with_index"
|
|
|
|
|
# В этом случае индекс будет начинаться с 0
|
|
|
|
|
array.each_with_index do |element, index|
|
|
|
|
|
puts "#{element} is number #{index} in the array"
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
# Если индекс должен начинаться с произвольного значения,
|
|
|
|
|
# используйте "each.with_index"
|
|
|
|
|
[:q, :w, :e].each.with_index(100) do |element, index|
|
|
|
|
|
puts "#{element} -> #{index}"
|
|
|
|
|
end
|
|
|
|
|
#=> :q -> 100
|
|
|
|
|
#=> :w -> 101
|
|
|
|
|
#=> :e -> 102
|
|
|
|
|
|
2013-08-18 08:44:31 +00:00
|
|
|
|
counter = 1
|
|
|
|
|
while counter <= 5 do
|
|
|
|
|
puts "итерация #{counter}"
|
|
|
|
|
counter += 1
|
|
|
|
|
end
|
|
|
|
|
#=> итерация 1
|
|
|
|
|
#=> итерация 2
|
|
|
|
|
#=> итерация 3
|
|
|
|
|
#=> итерация 4
|
|
|
|
|
#=> итерация 5
|
|
|
|
|
|
2017-09-17 18:00:30 +00:00
|
|
|
|
# Существует большое количество других полезных функций,
|
|
|
|
|
# например "map", "reduce", "inject", и так далее. Например, "map"
|
|
|
|
|
# выполняет связанный с ним блок для каждого элемента перечисляемого объекта,
|
|
|
|
|
# возвращая массив результатов.
|
|
|
|
|
array = [1, 2, 3, 4, 5]
|
|
|
|
|
doubled = array.map do |element|
|
|
|
|
|
element * 2
|
|
|
|
|
end
|
|
|
|
|
puts doubled
|
|
|
|
|
#=> [2, 4, 6, 8, 10]
|
|
|
|
|
puts array
|
|
|
|
|
#=> [1, 2, 3, 4, 5]
|
|
|
|
|
|
2013-08-18 08:44:31 +00:00
|
|
|
|
grade = 'B'
|
|
|
|
|
|
|
|
|
|
case grade
|
|
|
|
|
when 'A'
|
2017-09-17 18:00:30 +00:00
|
|
|
|
puts 'Так держать, детка!'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
when 'B'
|
2017-09-17 18:00:30 +00:00
|
|
|
|
puts 'Тебе повезёт в следующий раз'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
when 'C'
|
2017-09-17 18:00:30 +00:00
|
|
|
|
puts 'Ты можешь сделать лучше'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
when 'D'
|
2017-09-17 18:00:30 +00:00
|
|
|
|
puts 'Выскоблил последнее'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
when 'F'
|
2017-09-17 18:00:30 +00:00
|
|
|
|
puts 'Ты провалился!'
|
|
|
|
|
else
|
|
|
|
|
puts 'Альтернативная система оценок, да?'
|
|
|
|
|
end
|
|
|
|
|
#=> 'Тебе повезёт в следующий раз'
|
|
|
|
|
|
|
|
|
|
# в when также можно использовать диапазоны
|
|
|
|
|
grade = 82
|
|
|
|
|
case grade
|
|
|
|
|
when 90..100
|
|
|
|
|
puts 'Ура!'
|
|
|
|
|
when 80...90
|
|
|
|
|
puts 'Хорошая работа!'
|
|
|
|
|
else
|
|
|
|
|
puts 'Вы не справились!'
|
|
|
|
|
end
|
|
|
|
|
#=> 'Хорошая работа!'
|
|
|
|
|
|
|
|
|
|
# Обработка исключений
|
|
|
|
|
begin
|
|
|
|
|
# здесь код, который может вызвать исключение
|
|
|
|
|
raise NoMemoryError, 'У вас закончилась память.'
|
|
|
|
|
rescue NoMemoryError => exception_variable
|
|
|
|
|
puts 'Был вызван NoMemoryError', exception_variable
|
|
|
|
|
rescue RuntimeError => other_exception_variable
|
|
|
|
|
puts 'Был вызван RuntimeError'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
else
|
2017-09-17 18:00:30 +00:00
|
|
|
|
puts 'Этот код будет выполнятся, если исключения не были вызваны'
|
|
|
|
|
ensure
|
|
|
|
|
puts 'Этот код выполняется всегда'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
end
|
2017-09-17 18:00:30 +00:00
|
|
|
|
#=> Был вызван NoMemoryError
|
|
|
|
|
#=> У вас закончилась память.
|
|
|
|
|
#=> Этот код выполняется всегда
|
2013-08-18 08:44:31 +00:00
|
|
|
|
|
|
|
|
|
# Функции
|
|
|
|
|
|
|
|
|
|
def double(x)
|
|
|
|
|
x * 2
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
# Функции (и все блоки) неявно возвращают значение последней операции
|
|
|
|
|
double(2) #=> 4
|
|
|
|
|
|
|
|
|
|
# Скобки необязательны, если возвращаемый результат однозначен
|
|
|
|
|
double 3 #=> 6
|
|
|
|
|
|
|
|
|
|
double double 3 #=> 12
|
|
|
|
|
|
|
|
|
|
def sum(x,y)
|
|
|
|
|
x + y
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
# Аргументы метода разделены запятой
|
|
|
|
|
sum 3, 4 #=> 7
|
|
|
|
|
|
|
|
|
|
sum sum(3,4), 5 #=> 12
|
|
|
|
|
|
|
|
|
|
# yield
|
|
|
|
|
# Все методы имеют неявный, опциональный параметр,
|
|
|
|
|
# который может быть вызван с помощью инструкции "yield"
|
|
|
|
|
|
|
|
|
|
def surround
|
|
|
|
|
puts "{"
|
|
|
|
|
yield
|
|
|
|
|
puts "}"
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
surround { puts 'hello world' }
|
|
|
|
|
|
|
|
|
|
# {
|
|
|
|
|
# hello world
|
|
|
|
|
# }
|
|
|
|
|
|
|
|
|
|
|
2017-09-17 18:00:30 +00:00
|
|
|
|
# Вы можете передать блок методу
|
|
|
|
|
# "&" отмечает ссылку на переданный блок
|
|
|
|
|
def guests(&block)
|
|
|
|
|
block.call 'some_argument'
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
# Чтобы метод принимал произвольное количество аргументов, спереди
|
|
|
|
|
# одного из параметров ставится префикс "*"
|
|
|
|
|
def method(first, *rest)
|
|
|
|
|
p rest
|
|
|
|
|
end
|
|
|
|
|
method(1, 2, 3, 4) #=> [2, 3, 4]
|
|
|
|
|
|
|
|
|
|
# Если метод возвращает массив. можно использовать множественное присваивание
|
|
|
|
|
def foods
|
|
|
|
|
['pancake', 'sandwich', 'quesadilla']
|
|
|
|
|
end
|
|
|
|
|
breakfast, lunch, dinner = foods
|
|
|
|
|
breakfast #=> 'pancake'
|
|
|
|
|
dinner #=> 'quesadilla'
|
|
|
|
|
|
|
|
|
|
# По соглашению, все методы, возвращающие булево значение
|
|
|
|
|
# оканчиваются символом "?"
|
|
|
|
|
5.even? #=> false
|
|
|
|
|
5.odd? #=> true
|
|
|
|
|
|
|
|
|
|
# Если метод заканчивается восклицательным знаком, значит он делает что-то
|
|
|
|
|
# опасное или необратимое, например изменяет внутреннее состояние объекта.
|
|
|
|
|
# Многие из таких методов-мутаторов часто имеют "безопасную" версию без "!"
|
|
|
|
|
# которая возвращает новое значение
|
|
|
|
|
company_name = "Dunder Mifflin"
|
|
|
|
|
company_name.upcase #=> "DUNDER MIFFLIN"
|
|
|
|
|
company_name #=> "Dunder Mifflin"
|
|
|
|
|
company_name.upcase! # Изменяем зачение company_name!
|
|
|
|
|
company_name #=> "DUNDER MIFFLIN"
|
|
|
|
|
|
|
|
|
|
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Определение класса с помощью ключевого слова "class"
|
|
|
|
|
class Human
|
|
|
|
|
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Переменная класса, она является общей для всех экземпляров класса
|
2013-08-18 08:44:31 +00:00
|
|
|
|
@@species = "H. sapiens"
|
|
|
|
|
|
|
|
|
|
# Базовый метод-конструктор
|
|
|
|
|
def initialize(name, age=0)
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Присвоить аргумент "name" переменной "name" экземпляра класса
|
2013-08-18 08:44:31 +00:00
|
|
|
|
@name = name
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Если аргумент "age" не задан,
|
|
|
|
|
# мы используем значение по умолчанию из списка аргументов
|
2013-08-18 08:44:31 +00:00
|
|
|
|
@age = age
|
|
|
|
|
end
|
|
|
|
|
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Базовый метод установки значения для переменной (setter)
|
2013-08-18 08:44:31 +00:00
|
|
|
|
def name=(name)
|
|
|
|
|
@name = name
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
# Базовый метод получения значения переменной (getter)
|
|
|
|
|
def name
|
|
|
|
|
@name
|
|
|
|
|
end
|
|
|
|
|
|
2020-04-19 14:48:39 +00:00
|
|
|
|
# Тоже самое можно определить с помощью attr_accessor
|
2017-09-17 18:00:30 +00:00
|
|
|
|
attr_accessor :name
|
|
|
|
|
|
|
|
|
|
# Также можно создать методы только для записи или чтения
|
|
|
|
|
attr_reader :name
|
|
|
|
|
attr_writer :name
|
|
|
|
|
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Метод класса определяется с ключевым словом "self",
|
|
|
|
|
# чтобы можно было отличить его от метода экземпляра класса.
|
|
|
|
|
# Он может быть вызван только на уровне класса, но не экземпляра.
|
2013-08-18 08:44:31 +00:00
|
|
|
|
def self.say(msg)
|
|
|
|
|
puts "#{msg}"
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
def species
|
|
|
|
|
@@species
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Создание экземпляра класса
|
|
|
|
|
jim = Human.new("Jim Halpert")
|
|
|
|
|
|
|
|
|
|
dwight = Human.new("Dwight K. Schrute")
|
|
|
|
|
|
2013-08-18 10:59:29 +00:00
|
|
|
|
# Давайте вызовем несколько методов
|
2013-08-18 08:44:31 +00:00
|
|
|
|
jim.species #=> "H. sapiens"
|
|
|
|
|
jim.name #=> "Jim Halpert"
|
|
|
|
|
jim.name = "Jim Halpert II" #=> "Jim Halpert II"
|
|
|
|
|
jim.name #=> "Jim Halpert II"
|
|
|
|
|
dwight.species #=> "H. sapiens"
|
|
|
|
|
dwight.name #=> "Dwight K. Schrute"
|
|
|
|
|
|
|
|
|
|
# Вызов метода класса
|
|
|
|
|
Human.say("Hi") #=> "Hi"
|
|
|
|
|
|
2013-09-28 17:19:08 +00:00
|
|
|
|
# Область видимости переменной определяется тем, как мы даём имя переменной.
|
|
|
|
|
# Переменные, имя которых начинается с "$" имеют глобальную область видимости
|
|
|
|
|
$var = "I'm a global var"
|
|
|
|
|
defined? $var #=> "global-variable"
|
|
|
|
|
|
|
|
|
|
# Переменная экземпляра класса, она видна только в экземпляре
|
|
|
|
|
@var = "I'm an instance var"
|
|
|
|
|
defined? @var #=> "instance-variable"
|
|
|
|
|
|
|
|
|
|
# Переменная класса, видна для всех экземпляров этого класса и в самом классе
|
|
|
|
|
@@var = "I'm a class var"
|
|
|
|
|
defined? @@var #=> "class variable"
|
|
|
|
|
|
|
|
|
|
# Имена переменных с большой буквы используются для создания констант
|
|
|
|
|
Var = "I'm a constant"
|
|
|
|
|
defined? Var #=> "constant"
|
|
|
|
|
|
|
|
|
|
# Класс тоже объект в Ruby. Класс может иметь переменные экземпляра.
|
2013-08-18 08:44:31 +00:00
|
|
|
|
# Переменная класса доступна в классе, его экземплярах и его потомках.
|
|
|
|
|
|
2013-09-28 17:19:08 +00:00
|
|
|
|
# Пример класса
|
2013-08-18 08:44:31 +00:00
|
|
|
|
class Human
|
|
|
|
|
@@foo = 0
|
|
|
|
|
|
|
|
|
|
def self.foo
|
|
|
|
|
@@foo
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
def self.foo=(value)
|
|
|
|
|
@@foo = value
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
# Производный класс (класс-потомок)
|
|
|
|
|
class Worker < Human
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
Human.foo # 0
|
|
|
|
|
Worker.foo # 0
|
|
|
|
|
|
|
|
|
|
Human.foo = 2 # 2
|
|
|
|
|
Worker.foo # 2
|
|
|
|
|
|
|
|
|
|
# Переменная экземпляра класса недоступна в потомках этого класса.
|
|
|
|
|
|
|
|
|
|
class Human
|
|
|
|
|
@bar = 0
|
|
|
|
|
|
|
|
|
|
def self.bar
|
|
|
|
|
@bar
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
def self.bar=(value)
|
|
|
|
|
@bar = value
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
class Doctor < Human
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
Human.bar # 0
|
|
|
|
|
Doctor.bar # nil
|
|
|
|
|
|
2013-09-28 17:19:08 +00:00
|
|
|
|
module ModuleExample
|
|
|
|
|
def foo
|
|
|
|
|
'foo'
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
# Включение модулей в класс добавляет их методы в экземпляр класса
|
|
|
|
|
# Или в сам класс, зависит только от метода подключения
|
|
|
|
|
class Person
|
|
|
|
|
include ModuleExample
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
class Book
|
|
|
|
|
extend ModuleExample
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
Person.foo # => NoMethodError: undefined method `foo' for Person:Class
|
|
|
|
|
Person.new.foo # => 'foo'
|
|
|
|
|
Book.foo # => 'foo'
|
|
|
|
|
Book.new.foo # => NoMethodError: undefined method `foo'
|
|
|
|
|
|
|
|
|
|
# Коллбэки при подключении модуля
|
|
|
|
|
|
|
|
|
|
module ConcernExample
|
|
|
|
|
def self.included(base)
|
|
|
|
|
base.extend(ClassMethods)
|
|
|
|
|
base.send(:include, InstanceMethods)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
module ClassMethods
|
|
|
|
|
def bar
|
|
|
|
|
'bar'
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
module InstanceMethods
|
|
|
|
|
def qux
|
|
|
|
|
'qux'
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
class Something
|
|
|
|
|
include ConcernExample
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
Something.bar # => 'bar'
|
|
|
|
|
Something.qux # => NoMethodError: undefined method `qux'
|
|
|
|
|
Something.new.bar # => NoMethodError: undefined method `bar'
|
|
|
|
|
Something.new.qux # => 'qux'
|
2013-08-18 08:44:31 +00:00
|
|
|
|
```
|