Ruby - Операторы

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

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

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

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

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

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

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

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

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

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

Оператор	Описание	пример
знак равно	Простой оператор присваивания, присваивает значения из правых операндов левому операнду.	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.

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

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

Следующие логические операторы поддерживаются языком Ruby.

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

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

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

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

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

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

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

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

Оператор	Описание	пример
..	Создает диапазон от начальной до конечной точки включительно.	1..10 Создает диапазон от 1 до 10 включительно.
...	Создает исключительный диапазон от начальной до конечной точки.	1 ... 10 Создает диапазон от 1 до 9.

Определение Ruby? Операторы

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

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

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

defined? variable # True if variable is initialized

For Example

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

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

defined? method_call # True if a method is defined

For Example

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

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

# True if a method exists that can be called with super user
defined? super

For Example

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

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

defined? yield   # True if a code block has been passed

For Example

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

Рубиновая точка "." and Double Colon "::" Операторы

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

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

Remember в Ruby классы и методы также можно считать константами.

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

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

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

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

Second Example

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

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

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

NOTE- Операторы, для которых в столбце метода указано « Да», на самом деле являются методами и могут быть переопределены.