Ruby Operators

Выражения и операторы Ruby

Синтаксис Ruby ориентирован на использование выражений. Такие управляющие структуры, как if, которые в других языках программирования назывались бы операторами, в Ruby представляют собой выражения. У них, как и у других, более простых выражений, есть значения (операнды), позволяющие написать следующий код: minimum = if х < у then х else у end. Хотя все «операторы» в Ruby по своей сути являются выражениями, не все из них возвращают содержательные значения. К примеру, циклы while и определения методов являются выражениями, которые, как правило, возвращают значение nil. Как и во многих других языках, выражения в Ruby обычно выстраиваются из значений и операторов. Большинство использующихся в Ruby знаков операций знакомы всем, кто знает Си, Java, JavaScript или подобные им языки программирования.

Посмотрите на примеры самых обычных и самых необычных Ruby-операторов:

1 + 2 # => 3: сложение

1 * 2 # => 2: умножение

1 + 2 == 3 # => true: == проверка равенства

2 ** 1024 # 2 в степени 1024: в Ruby произвольная размерность целых чисел

"Ruby" + " rocks!" # => "Ruby rocks!": объединение строк

"Ruby! ” * 3 # => "Ruby! Ruby! Ruby!": повторение строки

"?d *s" % [3. "rubies"] # => "3 Rubies": Форматирование в стиле имеющегося в Python оператора printf

max = x > у ? x : у # Условный оператор

Многие Ruby-операторы реализованы в виде методов, и классы могут определять (или переопределять) эти методы как угодно. (Но они не могут определять совершенно новые операторы; существует лишь фиксированный набор общепринятых операторов.) Обратите, к примеру, внимание, что знаки операций + и * для целых чисел и строк ведут себя по-разному. Но в своих собственных классах вы можете определить эти операторы как угодно. Другим подходящим примером может послужить оператор « . Целочисленные классы Fixnum и Bignum, следуя правилам, принятым в языке программирования Си, используют этот оператор для операции поразрядного сдвига влево. В то же время (следуя C++) другие классы — строки, массивы и потоки — используют этот оператор для операции добавления. Если вы создаете новый класс, способный иметь значения, которые каким-то образом к нему добавляются, то неплохо было бы определить для него оператор « .

Одним из самых мощных переопределяемых операторов является []. Классы Array и Hash используют этот оператор для доступа к элементам массива по индексу и значениям хэша по ключу. Но в своих классах вы можете определить [ ] для чего угодно. Его можно даже определить в качестве метода, ожидающего использование нескольких аргументов, которые заключены в квадратные скобки и разделены запятыми. (Для указания подмассива или «вырезки» из массива класс Array воспринимает индекс и длину, заключенные в квадратные скобки.) И если нужно, чтобы квадратные скобки использовались в левой части выражения присваивания, то можно определить соответствующий оператор []=. Значение в правой части присваивания будет передано в качестве конечного аргумента для метода, являющегося реализацией этого оператора.

Ruby поддерживает богатый набор операторов, как и следовало ожидать от современного языка. Как говорилось выше большинство операторов на самом деле являются вызовами методов и вот пример: a + b интерпретируется как a. + (B), где метод + в объекте, на который указывает переменная a, вызывается с b в качестве аргумента.

Для каждого оператора (+ - * /% ** & | ^ << >> && ||) существует соответствующая форма сокращенного оператора присваивания (+ = - = и т. Д.)

Арифметические операторы Ruby:

Предположим, что переменная a равна 10, а переменная b равна 20, тогда:

Арифметические операторы Ruby

Операторы сравнения Ruby (Ruby Comparison Operators):

Предположим, что переменная a содержит 10, а переменная b содержит 20, тогда:

Операторы сравнения Ruby

Операторы присваивания Ruby (Ruby Assignment Operators):

Предположим, что переменная a содержит 10, а переменная b содержит 20, тогда:

Операторы присваивания Ruby

Параллельное присвоение Ruby (Ruby Parallel Assignment):

Ruby также поддерживает параллельное присвоение переменных. Это позволяет инициализировать несколько переменных с помощью одной строки кода Ruby. Например:

а = 10

б = 20

в = 30

можно быстрее объявить с помощью параллельного присваивания:

а, б, в = 10, 20, 30

Параллельное присвоение также полезно для обмена значениями двух переменных:

а, б = б, c

Побитовые операторы Ruby (Ruby Bitwise Operators):

Побитовый оператор работает с битами и выполняет побитовую операцию.

Допустим, если a = 60; и b = 13; Теперь в двоичном формате они будут такими:

а = 0011 1100

б = 0000 1101

-----------------

а&b = 0000 1100

а|Ь = 0011 1101

а^Ь = 0011 0001

~а = 1100 0011

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

Побитовые операторы

Логические операторы Ruby (Ruby Logical Operators):

Язык Ruby поддерживает следующие логические операторы:

Предположим, что переменная a содержит 10, а переменная b содержит 20, тогда:

Логические операторы Ruby


Ruby тернарный(условный) оператор (Ruby Ternary Operator):

Есть еще один оператор - Ternary Operator. Сначала выполняется оценка выражения для истинного или ложного значения, а затем выполняется одно из двух заданных операторов в зависимости от результата оценки. Оператор conditioanl имеет следующий синтаксис:

Оператор Описание Пример

? : Условное выражение if condition is true? then value X: otherwise - Y

Операторы Ruby Range (Ruby Range Operators):

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

В Ruby эти последовательности создаются с помощью операторов диапазона ".." и "...". Форма с двумя точками создает включающий диапазон, а форма с тремя точками создает диапазон, исключающий указанное максимальное значение.

Operator Description Example

.. Создает диапазон от начальной до конечной точки включительно 1..10 Создает диапазон от 1 до 10 включительно

... Создает диапазон от начальной точки до конечной точки, исключая 1 ... 10 Создает диапазон от 1 до 9

Ruby defined? операторы:

defined? - это специальный оператор, который принимает форму вызова метода, чтобы определить, определено ли переданное выражение. Он возвращает строку описания выражения или ноль, если выражение не определено.

Есть различные варианты использования определенных? оператор:

Использование 1

defined? variable # Истина, если переменная инициализирована

Например:

foo = 42

defined? foo # => "локальная переменная"

defined? $ _ # => "глобальная переменная"

defined? bar # => nil (не определено)

Использование 2

defined? method_call # Истинно, если метод определен

Например:

defined? puts # => "method"

defined? puts(bar) # => nil (bar здесь не определяется)

defined? unpack # => nil (здесь не определено)

Использование 3

# Верно ли, что существует метод, который можно вызывать с определением суперпользователя?

defined? super

Например:

defined? super # => "super" (если его можно вызвать)

defined? super # => nil (если не может быть)

Использование 4

defined? yield # Истина, если блок кода был передан

Например:

defined? yield # => "yield" (if there is a block passed)

defined? yield # => nil (если нет блока)

Ruby точка "." и двойное двоеточие "::"

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

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

Помните: в Ruby классы и методы также могут считаться константами.

Вам нужно просто добавить к :: Const_name префикс выражения, которое возвращает соответствующий объект класса или модуля.

Если префиксное выражение не используется, по умолчанию используется основной класс Object.

Вот два примера:

MR_COUNT = 0 # константа, определенная в основном классe объекта

module Foo

MR_COUNT = 0

:: MR_COUNT = 1 # установить глобальный счет на 1

MR_COUNT = 2 # установить локальный счет на 2

end

puts MR_COUNT # это глобальная константа

puts Foo :: MR_COUNT # это локальная константа "Foo"

Второй пример:

CONST = 'out there'

class Inside_one

CONST = proc {' in there'}

def where_is_my_CONST

:: CONST + ' inside one'

end

end

class Inside_two

CONST = ' inside two'

def where_is_my_CONST

CONST

end

end

puts Inside_one.new.where_is_my_CONST

puts Inside_two .new.where_is_my_CONST

puts Object :: CONST + Inside_two :: CONST

puts Inside_two :: CONST + CONST

puts Inside_one :: CONST

puts Inside_one :: CONST.call + Inside_two :: CONST

Приоритет операторов Ruby (Ruby Operators Precedents)

В следующей таблице перечислены все операторы от самого высокого до самого низкого приоритета.

ПРИМЕЧАНИЕ. Операторы, для которых в столбце метода указано «Да», на самом деле являются методами и могут быть переопределены.

Приоритет операторов Ruby
Операторы Ruby