• Во многих языках, и в Ruby в том числе, есть цикл

. Рано или поздно возникает вопрос, можно ли модифицировать индексную переменную. В некоторых языках эту управляющую переменную запрещено изменять вовсе (выводится предупреждение либо сообщение об ошибке на этапе компиляции или выполнения); в других это допустимо, хотя и приводит к изменению поведения цикла. В Ruby принят третий подход. Переменная, управляющая циклом , считается обычной переменной, которую можно изменять в любой момент, но это изменение не оказывает влияния на поведение цикла! Цикл for присваивает этой переменной последовательные значения, что бы с ней ни происходило внутри тела цикла. Например, следующий цикл будет выполнен ровно 10 раз и напечатает значения от 1 до 10:

• Имена переменных не всегда легко «на глаз» отличить от имен методов. Как решает этот вопрос анализатор? Правило такое: если анализатор видит, что идентификатору присваивается значение до его использования, то он считается переменной; в противном случае это имя метода. (Отметим, что операция присваивания может и не выполняться: достаточно того, что интерпретатор ее видел.)

Во всех современных языках есть та или иная форма многопутевого ветвления. В C/C++ и Java это предложение

, а в Pascal — предложение . Служат они одной и той же цели и функционируют примерно одинаково.

Предложение

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

Выше мы уже рассматривали синтаксис этого предложения, а теперь сосредоточимся на его семантике.

• Для начала рассмотрим тривиальный пример. Выражение

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

В Ruby для этой цели есть специальный оператор

(называется оператором отношения). Иногда его еще называют (не совсем правильно) оператором ветвящегося равенства. Неправильность в том, что он не всегда относится именно к проверке на равенство.

• Предыдущее предложение можно записать и так:

• Не путайте оператор отношения с оператором проверки на равенство (

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

• Не думайте, что проверяемое выражение — это объект, которому сравниваемое значение передается в качестве параметра. На самом деле как раз наоборот (мы это только что видели).

• Это подводит нас к наблюдению, что

означает вовсе не то же самое, что ! Иногда результат совпадает, но в общем случае оператор отношения не коммутативен. (Именно поэтому нам не нравится термин «оператор ветвящегося равенства» — ведь проверка на равенство всегда коммутативна.) Если перевернуть исходный пример, окажется, что следующий код ведет себя иначе:

• В качестве примера рассмотрим строку

и образец (регулярное выражение) , с которым эта строка успешно сопоставляется.

Выражение

истинно, как в языке Perl. Поскольку Ruby определяет противоположную семантику оператора в классе , можно также сказать, что выражение истинно. Следуя той же логике, мы обнаруживаем, что истинно и (исходя из того, как определен оператор в классе ). Однако выражение истинным не является. А значит, фрагмент

делает не то же самое, что фрагмент

Если это вас смущает, просто постарайтесь запомнить. А если не смущает, тем лучше!