[ruby/ru] Add missing from English version

ru-ru/ruby-ru.html.markdown

@@ -10,6 +10,7 @@ contributors:
   - ["Nick LaMuro", "https://github.com/NickLaMuro"]
 translators:
   - ["Alexey Makarov", "https://github.com/Anakros"]
+  - ["Vasiliy Petrov", "https://github.com/Saugardas"]
 ---
 
 ```ruby
@@ -35,6 +36,13 @@ translators:
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
+
+# Побитовые операторы
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
 
 # Арифметика -- это синтаксический сахар
 # над вызовом метода для объекта
@@ -57,8 +65,6 @@ false.class #=> FalseClass
 # Операция неравенства
 1 != 1 #=> false
 2 != 1 #=> true
-!true  #=> false
-!false #=> true
 
 # nil -- имеет такое же логическое значение, как и false
 
@@ -72,6 +78,26 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
+# Оператор сравнения <=>
+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()
+
+
 # Строки -- это объекты
 
 'Я строка'.class #=> String
@@ -82,6 +108,16 @@ placeholder = "использовать интерполяцию строк"
 #=> "Я могу использовать интерполяцию строк,
 # когда создаю строку с двойными кавычками"
 
+# Конкатенация строк
+'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"
 
 # печатать в стандартный вывод
 puts "Я печатаюсь!"
@@ -134,6 +170,7 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 
 # Значение в массиве можно получить по индексу с левой границы
 array[0] #=> 1
+array.first #=> 1
 array[12] #=> nil
 
 # Как и арифметика, доступ к значению в массиве
@@ -143,6 +180,7 @@ array.[] 12 #=> nil
 
 # Также, можно получить по индексу с правой границы
 array[-1] #=> 5
+array.last #=> 5
 
 # С заданными левой и правой границами индексов
 array[2, 4] #=> [3, 4, 5]
@@ -150,8 +188,17 @@ array[2, 4] #=> [3, 4, 5]
 # Или с использованием диапазона значений
 array[1..3] #=> [2, 3, 4]
 
+# Перестановка элементов в обратном порядке
+a = [1, 2, 3]
+a.reverse #=> [3, 2, 1]
+
 # Вот так можно добавить значение в массив
 array << 6 #=> [1, 2, 3, 4, 5, 6]
+# Или так
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Проверка включения элемента в массив
+array.include?(1) #=> true
 
 # Хэши -- это массив пар "ключ => значение".
 # Хэши объявляются с использованием фигурных скобок:
@@ -174,17 +221,21 @@ new_hash = { defcon: 3, action: true}
 
 new_hash.keys #=> [:defcon, :action]
 
+# Проверка существования ключа и значения в хеше
+new_hash.key?(:defcon) #=> true
+new_hash.value?(3) #=> true
+
 # Массивы и Хэши -- перечисляемые типы данных
 # У них есть много полезных методов, например: each, map, count и другие
 
 # Управление ходом выполнения (Управляющие структуры)
 
 if true
-  "Если истина"
+  'Если истина'
 elsif false
-  "Иначе, если ложь (опционально)"
+  'Иначе, если ложь (опционально)'
 else
-  "Во всех других случаях"
+  'Во всех других случаях (тоже опционально)'
 end
 
 for counter in 1..5
@@ -220,7 +271,7 @@ end
 #=> итерация 5
 
 # Вы также можете ограничивать блоки фигурными скобками:
-(1..5).each {|counter| puts "итерация #{counter}"}
+(1..5).each { |counter| puts "итерация #{counter}" }
 
 # Содержимое структурных данных также можно перебирать используя "each":
 array.each do |element|
@@ -230,6 +281,21 @@ hash.each do |key, value|
   puts "#{key} -- это #{value}"
 end
 
+# Если вам нужен индекс вы можете использовать "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
+
 counter = 1
 while counter <= 5 do
   puts "итерация #{counter}"
@@ -241,22 +307,65 @@ end
 #=> итерация 4
 #=> итерация 5
 
+# Существует большое количество других полезных функций,
+# например "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]
+
 grade = 'B'
 
 case grade
 when 'A'
-  puts "Так держать, детка!"
+  puts 'Так держать, детка!'
 when 'B'
-  puts "Тебе повезёт в следующий раз"
+  puts 'Тебе повезёт в следующий раз'
 when 'C'
-  puts "Ты можешь сделать лучше"
+  puts 'Ты можешь сделать лучше'
 when 'D'
-  puts "Выскоблил последнее"
+  puts 'Выскоблил последнее'
 when 'F'
-  puts "Ты провалился!"
+  puts 'Ты провалился!'
 else
-  puts "Альтернативная система оценок, да?"
+  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'
+else
+  puts 'Этот код будет выполнятся, если исключения не были вызваны'
+ensure
+  puts 'Этот код выполняется всегда'
+end
+#=> Был вызван NoMemoryError
+#=> У вас закончилась память.
+#=> Этот код выполняется всегда
 
 # Функции
 
@@ -298,6 +407,43 @@ surround { puts 'hello world' }
 # }
 
 
+# Вы можете передать блок методу
+# "&" отмечает ссылку на переданный блок
+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"
+
+
 # Определение класса с помощью ключевого слова "class"
 class Human
 
@@ -323,6 +469,13 @@ class Human
     @name
   end
 
+  # Тоже самое можно определить с помощью att_accessor
+  attr_accessor :name
+
+  # Также можно создать методы только для записи или чтения
+  attr_reader :name
+  attr_writer :name
+
   # Метод класса определяется с ключевым словом "self",
   # чтобы можно было отличить его от метода экземпляра класса.
   # Он может быть вызван только на уровне класса, но не экземпляра.