mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
Added Russian Translation of Ruby
This commit is contained in:
Alexey
parent
9c2e4b17ed
commit
2e465d0e7c
390
ru-ru/ruby-ru.html.markdown
Normal file
390
ru-ru/ruby-ru.html.markdown
Normal file
@ -0,0 +1,390 @@
|
||||
---
|
||||
language: ruby
|
||||
filename: learnruby.rb
|
||||
contributors:
|
||||
- ["Alexey Makarov", "https://github.com/Anakros"]
|
||||
---
|
||||
|
||||
```ruby
|
||||
# Это комментарий
|
||||
|
||||
=begin
|
||||
Это многострочный комментарий
|
||||
Никто их не использует
|
||||
И они не рекомендуются к использованию
|
||||
=end
|
||||
|
||||
# Первое и самое главное: Всё является объектом.
|
||||
|
||||
# Числа это объекты
|
||||
|
||||
3.class #=> Fixnum
|
||||
|
||||
3.to_s #=> "3"
|
||||
|
||||
|
||||
# Немного простой арифметики
|
||||
1 + 1 #=> 2
|
||||
8 - 1 #=> 7
|
||||
10 * 2 #=> 20
|
||||
35 / 5 #=> 7
|
||||
|
||||
# Арифметика -- это синтаксический сахар
|
||||
# над вызовом метода для объекта
|
||||
1.+(3) #=> 4
|
||||
10.* 5 #=> 50
|
||||
|
||||
# Логические величины -- это объекты
|
||||
nil # Здесь ничего нет
|
||||
true # правда
|
||||
false # ложь
|
||||
|
||||
nil.class #=> NilClass
|
||||
true.class #=> TrueClass
|
||||
false.class #=> FalseClass
|
||||
|
||||
# Операция равенства
|
||||
1 == 1 #=> true
|
||||
2 == 1 #=> false
|
||||
|
||||
# Операция неравенства
|
||||
1 != 1 #=> false
|
||||
2 != 1 #=> true
|
||||
!true #=> false
|
||||
!false #=> true
|
||||
|
||||
# nil -- имеет такое же логическое значение, как и false
|
||||
|
||||
!nil #=> true
|
||||
!false #=> true
|
||||
!0 #=> false
|
||||
|
||||
# Больше операций сравнения
|
||||
1 < 10 #=> true
|
||||
1 > 10 #=> false
|
||||
2 <= 2 #=> true
|
||||
2 >= 2 #=> true
|
||||
|
||||
# Строки -- это объекты
|
||||
|
||||
'Я строка'.class #=> String
|
||||
"Я тоже строка".class #=> String
|
||||
|
||||
placeholder = "использовать интерполяцию строк"
|
||||
"Я могу #{placeholder}, когда создаю строку с двойными кавычками"
|
||||
#=> "Я могу использовать интерполяцию строк, когда создаю строку с двойными кавычками"
|
||||
|
||||
|
||||
# печатать в стандартный вывод
|
||||
puts "Я печатаюсь!"
|
||||
|
||||
# Переменные
|
||||
x = 25 #=> 25
|
||||
x #=> 25
|
||||
|
||||
# Присваивание значения возвращает присвоенное значение
|
||||
# Это позволяет делать множественные присваивания:
|
||||
|
||||
x = y = 10 #=> 10
|
||||
x #=> 10
|
||||
y #=> 10
|
||||
|
||||
# По соглашению, используйте snake_case для имён переменных
|
||||
snake_case = true
|
||||
|
||||
# Используйте подробные имена для переменных
|
||||
# Но не переборщите!
|
||||
path_to_project_root = '/good/name/'
|
||||
path = '/bad/name/'
|
||||
|
||||
# Идентификаторы (тоже объекты)
|
||||
|
||||
# Идентификаторы -- это неизменяемые, многоразовые константы.
|
||||
# Для каждого идентификатора (кроме текста) сохраняется цифровой хэш. При последующем
|
||||
# использовании идентификатора, заместо создания нового объекта, будет найден уже
|
||||
# существующий по цифровому хэшу. Они часто используются вместо строк
|
||||
# для ускорения работы приложений
|
||||
|
||||
: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
|
||||
array[12] #=> nil
|
||||
|
||||
# Как и арифметика, доступ к значению в массиве
|
||||
# это синтаксический сахар над вызовом метода для объекта
|
||||
array.[] 0 #=> 1
|
||||
array.[] 12 #=> nil
|
||||
|
||||
# Также, можно получить по индексу с правой границы
|
||||
array[-1] #=> 5
|
||||
|
||||
# С заданными левой и правой границами индексов
|
||||
array[2, 4] #=> [3, 4, 5]
|
||||
|
||||
# Или с использованием диапазона значений
|
||||
array[1..3] #=> [2, 3, 4]
|
||||
|
||||
# Вот так можно добавить значение в массив
|
||||
array << 6 #=> [1, 2, 3, 4, 5, 6]
|
||||
|
||||
# Хэши -- это массив пар ключ => значение.
|
||||
# Хэши объявляются с использованием фигурных скобок:
|
||||
hash = {'color' => 'green', 'number' => 5}
|
||||
|
||||
hash.keys #=> ['color', 'number']
|
||||
|
||||
# Значение в хэше легко может быть найдено по ключу:
|
||||
hash['color'] #=> 'green'
|
||||
hash['number'] #=> 5
|
||||
|
||||
# Поиск по ключу, которого в хэше нет, вернёт nil:
|
||||
hash['nothing here'] #=> nil
|
||||
|
||||
# начиная с Ruby 1.9, существует специальный синтаксис
|
||||
# при использовании идентификаторов как ключей хэша:
|
||||
|
||||
new_hash = { defcon: 3, action: true}
|
||||
|
||||
new_hash.keys #=> [:defcon, :action]
|
||||
|
||||
# Массивы и Хэши -- перечисляемые типы данных
|
||||
# У них есть много полезных методов, например: each, map, count и другие
|
||||
|
||||
# Управление ходом выполнения (Управляющие структуры)
|
||||
|
||||
if true
|
||||
"if условие"
|
||||
elsif false
|
||||
"else if, условие"
|
||||
else
|
||||
"else, условие"
|
||||
end
|
||||
|
||||
for counter in 1..5
|
||||
puts "#итерация {counter}"
|
||||
end
|
||||
#=> итерация 1
|
||||
#=> итерация 2
|
||||
#=> итерация 3
|
||||
#=> итерация 4
|
||||
#=> итерация 5
|
||||
|
||||
# Однако, никто не использует "for" для циклов.
|
||||
# Вместо него Вы должны использовать метод "each" вместе с блоком кода.
|
||||
#
|
||||
# Блок кода -- это один из вариантов создания замыканий (лямбды, анонимные функции).
|
||||
# Блок может только передаваться методу, сам по себе он существовать не может.
|
||||
# "for" не имеет своей области видимости и все переменные, объявленные в нём
|
||||
# будут доступны отовсюду. "each" вместе с блоком создаёт свою область видимости.
|
||||
|
||||
# Метод "each" для диапазона значений запускает блок кода один раз для каждого из значений диапазона
|
||||
# Блок передаёт счётчик (counter) в качестве параметра.
|
||||
# Вызов метода "each" с блоком выглядит следующим образом:
|
||||
|
||||
(1..5).each do |counter|
|
||||
puts "итерация #{counter}"
|
||||
end
|
||||
#=> итерация 1
|
||||
#=> итерация 2
|
||||
#=> итерация 3
|
||||
#=> итерация 4
|
||||
#=> итерация 5
|
||||
|
||||
# Вы также можете ограничивать блоки фигурными скобками:
|
||||
(1..5).each {|counter| puts "итерация #{counter}"}
|
||||
|
||||
# Содержимое управляющих структур также можно перебирать используя "each":
|
||||
array.each do |element|
|
||||
puts "#{element} -- часть массива"
|
||||
end
|
||||
hash.each do |key, value|
|
||||
puts "#{key} -- это #{value}"
|
||||
end
|
||||
|
||||
counter = 1
|
||||
while counter <= 5 do
|
||||
puts "итерация #{counter}"
|
||||
counter += 1
|
||||
end
|
||||
#=> итерация 1
|
||||
#=> итерация 2
|
||||
#=> итерация 3
|
||||
#=> итерация 4
|
||||
#=> итерация 5
|
||||
|
||||
grade = 'B'
|
||||
|
||||
case grade
|
||||
when 'A'
|
||||
puts "Так держать, детка!"
|
||||
when 'B'
|
||||
puts "Тебе повезёт в следующий раз"
|
||||
when 'C'
|
||||
puts "Ты можешь сделать лучше"
|
||||
when 'D'
|
||||
puts "Выскоблил последнее"
|
||||
when 'F'
|
||||
puts "Ты провалился!"
|
||||
else
|
||||
puts "Альтернативная система оценок, да?"
|
||||
end
|
||||
|
||||
# Функции
|
||||
|
||||
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
|
||||
# }
|
||||
|
||||
|
||||
# Определение класса с помощью ключевого слова "class"
|
||||
class Human
|
||||
|
||||
# Переменная класса, она является общей для всех экземпляров класса
|
||||
@@species = "H. sapiens"
|
||||
|
||||
# Базовый метод-конструктор
|
||||
def initialize(name, age=0)
|
||||
# Присвоить аргумент "name" переменной "name" экземпляра класса
|
||||
@name = name
|
||||
# Если аргумент "age" не задан, мы используем значение по умолчанию из списка аргументов
|
||||
@age = age
|
||||
end
|
||||
|
||||
# Базовый метод установки значения для переменной (setter)
|
||||
def name=(name)
|
||||
@name = name
|
||||
end
|
||||
|
||||
# Базовый метод получения значения переменной (getter)
|
||||
def name
|
||||
@name
|
||||
end
|
||||
|
||||
# Метод класса определяется с ключевым словом "self",
|
||||
# чтобы можно было отличить его от метода экземпляра класса.
|
||||
# Он может быть вызван только на уровне класса, не экземпляра.
|
||||
def self.say(msg)
|
||||
puts "#{msg}"
|
||||
end
|
||||
|
||||
def species
|
||||
@@species
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
|
||||
# Создание экземпляра класса
|
||||
jim = Human.new("Jim Halpert")
|
||||
|
||||
dwight = Human.new("Dwight K. Schrute")
|
||||
|
||||
# Давайте вызовем несколько методов этого класса
|
||||
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"
|
||||
|
||||
# Класс тоже объект в Ruby. Потому класс может иметь переменные экземпляра.
|
||||
# Переменная класса доступна в классе, его экземплярах и его потомках.
|
||||
|
||||
# Базовый класс
|
||||
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
|
||||
|
||||
```
|
||||
Loading…
Reference in New Issue
Block a user