Хэл Фултон - Программирование на языке Ruby

• Ключевое слово retry применяется также при обработке исключений. Не путайте два этих вида использования.

• Метод объекта initialize всегда является закрытым.

• Когда итератор заканчивается левой фигурной скобкой (или словом end) и возвращает значение, это значение можно использовать для вызова последующих методов, например:

squares = [1,2,3,4,5].collect do |x| x**2 end.reverse

# squares теперь равно [25,16,9,4,1]

• В конце программы на Ruby часто можно встретить идиому

if $0 == __FILE__

Таким образом проверяется, исполняется ли файл как автономный кусок кода (true) или как дополнительный, например библиотека (false). Типичное применение — поместить некую «главную программу» (обычно с тестовым кодом) в конец библиотеки.

• Обычное наследование (порождение подкласса) обозначается символом <:

class Dog < Animal

 # ...

end

Однако для создания синглетного класса (анонимного класса, который расширяет единственный экземпляр) применяется символ <<:

class << platypus

 # ...

end

• При передаче блока итератору есть тонкое различие между фигурными скобками ({}) и операторными скобками do-end. Связано оно с приоритетом:

mymethod param1, foobar do ... end

# Здесь do-end связано с mymethod.

mymethod param1, foobar { ... }

# А здесь {} связано с именем foobar, предполагается, что это метод.

• Традиционно в Ruby однострочные блоки заключают в фигурные скобки, а многострочные — в скобки do-end, например:

my_array.each { |x| puts x }

my_array.each do |x|

 print x

 if x % 2 == 0

  puts " четно."

 else

  puts " нечетно."

 end

end

Это необязательно и в некоторых случаях даже нежелательно.

• Помните, что строки (strings) в некотором смысле двулики: их можно рассматривать как последовательность символов или как последовательность строчек (lines). Кому-то покажется удивительным, что итератор each оперирует строками (здесь под «строкой» понимается группа символов, завершающаяся разделителем записей, который по умолчанию равен символу новой строки). У each есть синоним each_line. Если вы хотите перебирать символы, можете воспользоваться итератором each_byte. Итератор sort также оперирует строками. Для строк (strings) не существует итератора each_index из-за возникающей неоднозначности. Действительно, хотим ли мы обрабатывать строку посимвольно или построчно? Все это со временем войдет в привычку.

• Замыкание (closure) запоминает контекст, в котором было создано. Один из способов создать замыкание — использование объекта Proc. Например:

def power(exponent)

 proc {|base| base**exponent}

end

square = power(2)

cube = power(3)

a = square.call(11) # Результат равен 121.

b = square.call(5)  # Результат равен 25.

с = cube.call(6)    # Результат равен 216.

d = cube.call(8)    # Результат равен 512.

Обратите внимание, что замыкание «знает» значение показателя степени, переданное ему в момент создания.

• Однако помните: в замыкании используется переменная, определенная во внешней области видимости (что вполне допустимо). Это свойство может оказаться полезным, но приведем пример неправильного использования:

$exponent = 0

def power

 proc {|base| base**$exponent}

end

$exponent = 2

square = power

$exponent = 3

cube = power

a = square.call(11) # Неверно! Результат равен 1331.

b = square.call(5) # Неверно! Результат равен 125.

# Оба результата неверны, поскольку используется ТЕКУЩЕЕ

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

# используется локальная переменная, покинувшая область

# видимости (например, с помощью define_method).

с = cube.call(6) # Результат равен 216.

d = cube.call(8) # Результат равен 512.

• Напоследок рассмотрим несколько искусственный пример. Внутри блока итератора times создается новый контекст, так что x — локальная переменная. Переменная closure уже определена на верхнем уровне, поэтому для блока она не будет локальной.

closure = nil # Определим замыкание, чтобы его имя было известно.

1.times do    # Создаем новый контекст.

 x = 5        # Переменная x локальная в этом блоке,

 closure = Proc.new { puts "В замыкании, x = #{x}" }

end

x = 1

# Определяем x на верхнем уровне.

closure.call # Печатается: В замыкании, x = 5

Обратите внимание, что переменная x, которой присвоено значение 1, — это новая переменная, определенная на верхнем уровне. Она не совпадает с одноименной переменной, определенной внутри блока. Замыкание печатает 5, так как запоминает контекст своего создания, в котором была определена переменная x со значением 5.

• Переменные с именами, начинающимися с одного символа @, определенные внутри класса, — это, вообще говоря, переменные экземпляра. Однако если они определены вне любого метода, то становятся переменными экземпляра класса. (Это несколько противоречит общепринятой терминологии ООП, в которой «экземпляр класса» — то же самое, что и «экземпляр>> или «объект».) Пример:

class Myclass

 @x = 1  # Переменная экземпляра класса.

 @y = 2  # Еще одна.

 def mymethod

  @x = 3 # Переменная экземпляра.

  # Заметим, что в этой точке @y недоступна.

 end

end

Переменная экземпляра класса (@y в предыдущем примере — в действительности атрибут объекта класса Myclass, являющегося экземпляром класса Class. (Напомним, что Class — это объект, a Object — это класс.) На переменные экземпляра класса нельзя ссылаться из методов экземпляра и, вообще говоря, они не очень полезны.

• attr, attr_reader, attr_writer и attr_accessor — сокращенная запись для определения методов чтения и установки атрибутов. В качестве аргументов они принимают символы (экземпляры класса Symbol).

• Присваивание переменной, имя которой содержит оператор разрешения области видимости, недопустимо. Например, Math::Pi = 3.2 — ошибка.

1.5.5. Ориентация на выражения и прочие вопросы

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

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

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

x = y = z = 0  # Все переменные сейчас равны 0.

а = b = с = [] # Опасно! a, b и с ссылаются

               # на ОДИН И ТОТ ЖЕ пустой массив.

x = 5

y = x += 2 # Сейчас x и у равны 7.

Напомним однако, что значения типа Fixnum и им подобные хранятся непосредственно, а не как ссылки на объекты.

• Многие управляющие конструкции возвращают значения, в частности if, unless и case. Следующий код корректен; он показывает, что при принятии решения ветви могут быть выражениями, а не полноценными предложениями.

а = 5

x = if а < 8 then 6 else 7 end # x равно 6.

y= if a<8 # y тоже равно 6;

 6        # предложение if может располагаться

else      # на одной строке

 7        # или на нескольких.

end

# unless тоже работает; z присваивается значение 4.

z = unless x == y then 3 else 4 end

t = case a # t получает

 when 0..3 # значение

  "low"    # medium,

 when 4..6

  "medium"

 else

  "high"

end

Здесь мы сделали такие отступы, будто case является присваиванием. Мы воспринимаем такую запись спокойно, хотя вам она может не понравиться.

• Отметим, что циклы while и until, напротив, не возвращают никаких полезных значений; обычно их значением является nil:

i = 0

x = while (i < 5) # x равно nil.

 puts i+=1

end

• Тернарный оператор можно использовать как в предложениях, так и в выражениях. В силу синтаксических причин (или ограничений анализатора) скобки здесь обязательны: