Ruby Операторы

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

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

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

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

OperatorОписаниеПример
+Сложение - Складывает операнды с обеих сторон оператора.a + b даст 30
-Вычитание — вычитает правый операнд из левого операнда.a - b даст -10
*Умножение — умножает операнды с обеих сторон оператора.a * b даст 200
/Деление — делит левый операнд на правый операнд.b / a даст 2
%Деление по модулю — делит левый операнд на правый операнд и возвращает остаток.b % a даст 0
**Возведение в степень — выполняет возведение в степень.a**b даст 10 в 20-й степени

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

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

OperatorОписаниеПример
==Проверяет, равны ли значения двух операндов; если да, условие становится истинным.(a == b) не является истинным.
!=Проверяет, равны ли значения двух операндов; если они не равны, условие становится истинным.(a != b) истинно.
>Проверяет, является ли значение левого операнда большим, чем значение правого операнда; если да, условие становится истинным.(a > b) не является истинным.
<Проверяет, является ли значение левого операнда меньшим, чем значение правого операнда; если да, условие становится истинным.(a < b) истинно.
>=Проверяет, является ли значение левого операнда большим или равным значению правого операнда; если да, условие становится истинным.(a >= b) не является истинным.
<=Проверяет, является ли значение левого операнда меньшим или равным значению правого операнда; если да, условие становится истинным.(a <= b) истинно.
<=>Комбинированный оператор сравнения. Возвращает 0, если первый операнд равен второму операнду, 1, если первый операнд больше второго операнда, и -1, если первый операнд меньше второго операнда.(a <=> b) возвращает -1.
===Используется для проверки равенстваcaseв предложении when оператора case.(1...10) === 5 возвращает true.
.eql?Возвращает true, если получатель и аргумент имеют одинаковый тип и равные значения.1 == 1.0 возвращает true, но 1.eql?.eql?(1.0) возвращает false.
equal?Возвращает true, если получатель и аргумент имеют одинаковый идентификатор объекта.Если aObj — копия bObj, то aObj == bObj возвращает true, a.equal?.equal? bObj возвращает false, но a.equal?.equal? aObj возвращает true.

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

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

OperatorОписаниеПример
=Простой оператор присваивания. Присваивает значение правого операнда левому операнду.c = a + b присвоит значение a + b переменной c.
+=Оператор сложения и присваивания. Прибавляет правый операнд к левому операнду и присваивает результат левому операнду.c += a эквивалентно c = c + a.
-=Оператор вычитания и присваивания. Вычитает правый операнд из левого операнда и присваивает результат левому операнду.c -= a эквивалентно c = c - a.
*=Оператор умножения и присваивания. Умножает правый операнд на левый операнд и присваивает результат левому операнду.c *= a эквивалентно c = c * a.
/=Оператор деления и присваивания. Делит левый операнд на правый операнд и присваивает результат левому операнду.c /= a эквивалентно c = c / a.
%=Оператор взятия остатка и присваивания. Берёт остаток от двух операндов и присваивает его левому операнду.c %= a эквивалентно c = c % a.
**=Оператор возведения в степень и присваивания. Выполняет возведение в степень и присваивает результат левому операнду.c **= a эквивалентно c = c ** a.

Параллельное присваивание в Ruby

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

a = 10 b = 20 c = 30

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

a, b, c = 10, 20, 30

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

a, b = b, c

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

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

Предположим, если a = 60 и b = 13, то в двоичном формате они выглядят следующим образом:

a = 0011 1100

b = 0000 1101

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

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

В следующей таблице перечислены побитовые операторы, поддерживаемые Ruby.

OperatorОписаниеПример
&Двоичный оператор AND копирует бит в результат, если он присутствует в обоих операндах.(a & b) даст 12, что равно 0000 1100
|Двоичный оператор OR копирует бит в результат, если он присутствует в любом из операндов.(a | b) даст 61, что равно 0011 1101
^Двоичный оператор XOR копирует бит в результат, если он присутствует в одном из операндов, но не в обоих.(a ^ b) даст 49, что равно 0011 0001
~Двоичный оператор дополнения — это унарный оператор, который выполняет "переворачивание" битов, т. е. 0 становится 1, а 1 становится 0.(~a ) даст -61, что равно 1100 0011 в форме дополнительного кода знакового двоичного числа.
<<Оператор сдвига влево. Значение левого операнда сдвигается влево на число битов, заданное правым операндом.a << 2 даст 240, что равно 1111 0000
>>Оператор двоичного сдвига вправо. Значение левого операнда сдвигается вправо на число битов, указанное правым операндом.a >> 2 даст 15, что равно 0000 1111

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

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

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

OperatorОписаниеПример
иНазывается логическим оператором AND. Если оба операнда истинны, условие становится истинным.(a and b) истинно.
илиНазывается логическим оператором OR. Если хотя бы один операнд не равен нулю, условие становится истинным.(a or b) истинно.
&&Называется логическим оператором AND. Если оба операнда не равны нулю, условие становится истинным.(a && b) истинно.
||Называется логическим оператором OR. Если хотя бы один операнд не равен нулю, условие становится истинным.(a || b) истинно.
!Называется логическим оператором NOT. Используется для инвертирования логического состояния операнда. Если условие истинно, логический оператор NOT делает его ложным.!(a && b) ложно.
notНазывается логическим оператором NOT. Используется для инвертирования логического состояния операнда. Если условие истинно, логический оператор NOT делает его ложным.not(a && b) ложно.

Тернарный оператор в Ruby

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

OperatorОписаниеПример
? :Условное выражениеЕсли условие истинно ? то значение X : иначе значение Y

Операторы диапазонов в Ruby

В Ruby диапазоны последовательностей используются для создания серии последовательных значений, включающей начальное значение, конечное значение (в зависимости от ситуации) и значения между ними.

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

OperatorОписаниеПример
..Создаёт диапазон от начальной точки до конечной точки (включая конечную точку)1..10 создаёт диапазон от 1 до 10
...Создаёт диапазон от начальной точки до конечной точки (не включая конечную точку)1...10 создаёт диапазон от 1 до 9

Оператор defined? в Ruby

defined? — это специальный оператор, имеющий форму вызова метода; он определяет, определено ли переданное выражение. Он возвращает строку с описанием выражения, а если выражение не определено, возвращаетnil。

Ниже приведены различные способы использования оператора defined?:

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

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

Пример:

foo = 42 defined? foo # => "local-variable" defined? $_ # => "global-variable" defined? bar #=> nil (не определено)

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

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

Пример:

defined? puts # => "method" defined? puts(bar) #=> nil (bar здесь не определён) defined? unpack #=> nil (здесь не определено)

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

#Истина, если существует метод, который можно вызвать с помощью super defined? super

Пример:

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

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

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

Пример:

defined? yield #=> "yield" (если был передан блок) defined? yield #=> nil (если блок не был передан)

Оператор точки "." и оператор двойного двоеточия "::" в Ruby

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

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

Помните:В Ruby классы и методы также можно рассматривать как константы.

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

Если::выражение перед префиксом является именем класса или модуля, оно возвращает соответствующее значение константы внутри этого класса или модуля; если::перед ним нет выражения-префикса, оно возвращает соответствующее значение константы в главном классе Object.

Ниже приведены два примера:

MR_COUNT = 0 #Константа, определённая в главном классе Object 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

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

МетодOperatorОписание
Да :: Оператор разрешения констант
Да [ ] [ ]= Обращение к элементу, присваивание элементу
Да ** Возведение в степень
Да ! ~ + - Логическое НЕ, дополнение, унарный плюс, унарный минус (у последних двух имена методов — +@ и -@)
Да * / % Умножение, деление, остаток от деления
Да + - Сложение и вычитание
Да >> << Побитовый сдвиг вправо, побитовый сдвиг влево
Да & Побитовое И
Да ^ | Побитовое исключающее ИЛИ, побитовое ИЛИ
Да <= < > >= Операторы сравнения
Да <=> == === != =~ !~ Операторы равенства и сопоставления с образцом (!= и !~ нельзя определять как методы)
&& Логическое И
|| Логическое ИЛИ
.. ... Диапазон (включающий, исключающий)
? : Тернарный оператор if-then-else
= %= { /= -= += |= &= >>= <<= *= &&= ||= **= Присваивание
defined? Проверка, определён ли указанный символ
not Логическое отрицание
or and Логическая композиция

Примечание:В столбце «Метод» операторы, помеченные какДа, на самом деле являются методами и поэтому могут быть перегружены.

Другие расширения