Управляющие выражения

В Ruby существует множество способов управления выполнением. Все описанные здесь выражения возвращают значение.

Для тестов в этих управляющих выражениях nil и false являются ложными значениями, а true и любой другой объект — истинными значениями. В этом документе «истина» означает «истинное значение», а «ложь» — «ложное значение».

if выражение

Простейшее if выражение состоит из двух частей: выражения «проверки» и выражения «then». Если выражение «проверки» вычисляет истинное значение, то выполняется выражение «then».

Вот пример простого оператора if:

if true then
  puts "the test resulted in a true-value"
end

Это выведет «тест вернул истинное значение».

then часть является необязательной:

if true
  puts "the test resulted in a true-value"
end

В этом документе необязательная then часть будет опущена для всех выражений, так как это наиболее распространённое использование if.

Вы также можете добавить выражение else. Если выражение проверки не вычисляет истинного значения, то будет выполнено выражение else:

if false
  puts "the test resulted in a true-value"
else
  puts "the test resulted in a false-value"
end

Это выведет «тест вернул ложное значение».

Вы можете добавить любое количество дополнительных проверок в выражение if с помощью elsif. Выражение elsif выполняется, когда все проверки выше elsif являются ложными.

a = 1

if a == 0
  puts "a is zero"
elsif a == 1
  puts "a is one"
else
  puts "a is some other value"
end

Это выведет «a равно одному», так как 1 не равно 0. Поскольку else выполняется только тогда, когда нет совпадающих условий.

Как только условие совпадёт, либо с if условием, либо с любым elsif условием, то выражение if завершено, и дальнейшие проверки не будут выполняться.

Как и в if, elsif условие может быть последо мной за then.

В этом примере выводится только «a равно одному»:

a = 1

if a == 0
  puts "a is zero"
elsif a == 1
  puts "a is one"
elsif a >= 1
  puts "a is greater than or equal to one"
else
  puts "a is some other value"
end

Проверки для if и elsif могут иметь побочные эффекты. Наиболее распространённое применение побочных эффектов — кеширование значения в локальной переменной:

if a = object.some_value
  # do something to a
end

Значение результата выражения if — это последнее выполненное значение в выражении.

Тernary if

Вы также можете записать выражение if-then-else, используя ? и :. Этот тернарный if:

input_type = gets =~ /hello/i ? "greeting" : "other"

Эквивалентен этому if выражению:

input_type =
  if gets =~ /hello/i
    "greeting"
  else
    "other"
  end

Хотя тернарный if гораздо короче, чем более подробная форма, для лучшей читабельности рекомендуется использовать тернарный if только для простых условных операторов. Также следует избегать использования нескольких тернарных условий в одном выражении, так как это может быть запутанно.

unless выражение

Выражение unless является противоположностью выражению if. Если значение ложно, то выполняется выражение «then»:

unless true
  puts "the value is a false-value"
end

Это не выводит ничего, так как true не является ложным значением.

Вы можете использовать необязательную then часть с unless так же, как и с if.

Обратите внимание, что вышеприведённое выражение unless эквивалентно:

if not true
  puts "the value is a false-value"
end

Как и выражение if, вы можете использовать else условие с unless:

unless true
  puts "the value is false"
else
  puts "the value is true"
end

Это выводит «значение истинно» из else условия.

Вы не можете использовать elsif с выражением unless.

Значение результата выражения unless — это последнее выполненное значение в выражении.

Модификаторы if и unless

if и unless также могут быть использованы для модификации выражения. При использовании в качестве модификатора левая часть — это оператор «then», а правая — это выражение «проверки»:

a = 0

a += 1 if a.zero?

p a

Это выведет 1.

a = 0

a += 1 unless a.zero?

p a

Это выведет 0.

Хотя модифицированная и стандартная версии имеют выражение «проверки» и оператор «then», они не являются точными преобразованиями друг друга из-за порядка парсинга. Вот пример, демонстрирующий разницу:

p a if a = 0.zero?

Это вызывает NameError «неопределённая локальная переменная или метод 'a'».

При парсинге Ruby встречает a как вызов метода в выражении «then», а затем позже видит присвоение a в выражении «проверки» и отмечает a как локальную переменную.

При выполнении этой строки сначала выполняется выражение «проверки», a = 0.zero?.

Так как проверка истинна, выполняется выражение «then», p a. Так как a в теле был записан как метод, которого нет, то возникает NameError.

То же самое верно и для unless.

case выражение

Выражение case может быть использовано двумя способами.

Наиболее распространённый способ — сравнить объект с несколькими шаблонами. Шаблоны сопоставляются с помощью метода +===+, который является псевдонимом для +==+ для Object. Другие классы должны переопределять его, чтобы обеспечить осмысленное поведение. См. Module#=== и Regexp#=== для примеров.

Вот пример использования case для сравнения String со шаблоном:

case "12345"
when /^1/
  puts "the string starts with one"
else
  puts "I don't know what the string starts with"
end

Здесь строка "12345" сравнивается с /^1/ путём вызова /^1/ === "12345" , который возвращает true. Как и в выражении if, выполняется первое when , которое соответствует, а все остальные игнорируются.

Если совпадений не найдено, выполняется else.

else и then являются необязательными, это case выражение даёт тот же результат, что и предыдущее:

case "12345"
when /^1/
  puts "the string starts with one"
end

Вы можете поместить несколько условий в одно when:

case "2"
when /^1/, "2"
  puts "the string starts with one or is '2'"
end

Ruby будет пытаться выполнить каждое условие по очереди, поэтому сначала /^1/ === "2" возвращает false, затем "2" === "2" возвращает true, поэтому выводится «строка начинается с одного или равна ‘2’».

Вы можете использовать then после условия when . Это чаще всего используется для размещения тела when в одну строку.

case a
when 1, 2 then puts "a is one or two"
when 3    then puts "a is three"
else           puts "I don't know what a is"
end

Другой способ использования выражения case — как выражение if-elsif:

a = 2

case
when a == 1, a == 2
  puts "a is one or two"
when a == 3
  puts "a is three"
else
  puts "I don't know what a is"
end

Опять же, then и else являются необязательными.

Значение результата выражения case — это последнее выполненное значение в выражении.

Начиная с Ruby 2.7, выражения case также предоставляют более мощную экспериментальную функцию сопоставления с образцом с помощью ключевого слова in:

case {a: 1, b: 2, c: 3}
in a: Integer => m
  "matched: #{m}"
else
  "not matched"
end
# => "matched: 1"

Синтаксис сопоставления с образцом описан на своей собственной странице.

while цикл

Цикл while выполняется, пока условие истинно:

a = 0

while a < 10 do
  p a
  a += 1
end

p a

Выводит числа от 0 до 10. Условие a < 10 проверяется до входа в цикл, затем выполняется тело, затем условие проверяется снова. Когда условие становится ложным, цикл завершается.

Ключевое слово do является необязательным. Следующий цикл эквивалентен циклу выше:

while a < 10
  p a
  a += 1
end

Результат цикла while — nil , если не используется break для задания значения.

until цикл

Цикл until выполняется, пока условие ложно:

a = 0

until a > 10 do
  p a
  a += 1
end

p a

Это выводит числа от 0 до 11. Как и в цикле while, условие a > 10 проверяется при входе в цикл и каждый раз при выполнении тела цикла. Если условие ложно, цикл будет продолжать выполняться.

Как и в цикле while, ключевое слово do является необязательным.

Как и в цикле while, результат цикла until — nil, если не используется break.

for цикл

Цикл for состоит из for за которым следует переменная для хранения аргумента итерации, за которым следует in и значение для итерации с помощью each. do является необязательным:

for value in [1, 2, 3] do
  puts value
end

Выводит 1, 2 и 3.

Как и в циклах while и until, do является необязательным.

Цикл for похож на использование each, но не создаёт новую область видимости переменных.

Значение результата цикла for — это значение, по которому происходит итерация, если не используется break.

Цикл for редко используется в современных программах на Ruby.

Модификаторы while и until

Как и if и unless, while и until могут использоваться как модификаторы:

a = 0

a += 1 while a < 10

p a # prints 10

until используется как модификатор:

a = 0

a += 1 until a > 10

p a # prints 11

Вы можете использовать begin и end для создания цикла while , который выполняет тело один раз до проверки условия:

a = 0

begin
  a += 1
end while a < 10

p a # prints 10

Если вы не используете rescue или ensure, Ruby оптимизирует обработку исключений.

break оператор

Используйте break , чтобы прервать блок раньше. Это остановит итерацию по элементам в values , если один из них является чётным:

values.each do |value|
  break if value.even?

  # ...
end

Вы также можете прервать цикл while с помощью break:

a = 0

while true do
  p a
  a += 1

  break if a < 10
end

p a

Это выводит числа 0 и 1.

break принимает значение, которое предоставляет результат выражения, из которого происходит «прерывание»:

result = [1, 2, 3].each do |value|
  break value * 2 if value.even?
end

p result # prints 4

next оператор

Используйте next , чтобы пропустить оставшуюся часть текущей итерации:

result = [1, 2, 3].map do |value|
  next if value.even?

  value * 2
end

p result # prints [2, nil, 6]

next принимает аргумент, который может быть использован как результат текущей итерации блока:

result = [1, 2, 3].map do |value|
  next value if value.even?

  value * 2
end

p result # prints [2, 2, 6]

redo оператор

Используйте redo , чтобы повторить текущую итерацию:

result = []

while result.length < 10 do
  result << result.length

  redo if result.last.even?

  result << result.length + 1
end

p result

Это выводит [0, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11]

В Ruby 1.8, вы также могли использовать retry, где использовали redo. Это больше неверно, теперь вы получите SyntaxError, когда используете retry вне блока rescue. Обратитесь к Исключениям для правильного использования retry.

Управляющие операторы

Грамматика Ruby различает операторы и выражения. Все выражения являются операторами (выражение — это тип оператора), но не все операторы являются выражениями. Некоторые части грамматики принимают выражения, а не другие типы операторов, что приводит к тому, что похожий код анализируется по-разному.

Например, когда они не используются как модификаторы, if, else, while, until, и begin являются выражениями (и также операторами). Однако, когда используются как модификаторы, if, else, while, until и rescue являются операторами, но не выражениями.

if true; 1 end # expression (and therefore statement)
1 if true      # statement (not expression)

Операторы, которые не являются выражениями, нельзя использовать в контекстах, где ожидается выражение, например, в качестве аргументов методов.

puts( 1 if true )      #=> SyntaxError

Вы можете заключить оператор в скобки, чтобы создать выражение.

puts((1 if true))      #=> 1

Если вы поместите пробел между именем метода и открывающей скобкой, вам не нужны две пары скобок.

puts (1 if true)       #=> 1, because of optional parentheses for method

Это потому, что это анализируется как вызов метода без скобок. Это эквивалентно следующему коду без создания локальной переменной:

x = (1 if true)
p x

В управляющем операторе левая часть должна быть оператором, а правая — выражением.

Таким образом, в a if b rescue c, поскольку b rescue c — это оператор, который не является выражением, и поэтому не допускается в качестве правой части оператора модификации if, код обязательно анализируется как (a if b) rescue c.

Это взаимодействует с приоритетом операторов таким образом, что:

stmt if v = expr rescue x
stmt if v = expr unless x

анализируются как:

stmt if v = (expr rescue x)
(stmt if v = expr) unless x

Потому что модификатор rescue имеет более высокий приоритет, чем =, а модификатор if имеет более низкий приоритет, чем =.

Триггер

Триггер — это редко используемое условное выражение. Его основное применение — для обработки текста из однострочных программ Ruby, используемых с ruby -n или ruby -p.

Форма триггера — это выражение, указывающее, когда триггер включается, .. (или ...), а затем выражение, указывающее, когда триггер выключится. Пока триггер включён, он продолжает оцениваться как true, и false при выключении.

Вот пример:

selected = []

0.upto 10 do |value|
  selected << value if value==2..value==8
end

p selected # prints [2, 3, 4, 5, 6, 7, 8]

В приведённом выше примере условие включения — n==2. Триггер изначально выключен (false) для 0 и 1, но включается (true) для 2 и остаётся включённым до 8. После 8 он выключается и остаётся выключенным для 9 и 10.

Триггер должен использоваться внутри условного оператора, такого как if, while, unless, until и т. д., включая модифицированные формы.

Когда вы используете включительный диапазон (..), условие выключения оценивается при изменении условия включения:

selected = []

0.upto 5 do |value|
  selected << value if value==2..value==2
end

p selected # prints [2]

Здесь обе части триггера оцениваются, поэтому триггер включается и выключается только когда value равно 2. Поскольку триггер включился в итерации, он возвращает true.

Когда вы используете исключительный диапазон (...), условие выключения оценивается на следующей итерации:

selected = []

0.upto 5 do |value|
  selected << value if value==2...value==2
end

p selected # prints [2, 3, 4, 5]

Здесь триггер включается, когда value равно 2, но не выключается в той же итерации. Условие выключения не оценивается до следующей итерации, и value никогда не будет равно двум снова.