Ruby - Operadores

Ruby suporta um rico conjunto de operadores, como você esperaria de uma linguagem moderna. A maioria dos operadores são, na verdade, chamadas de método. Por exemplo, a + b é interpretado como a. + (B), onde o método + no objeto referido pela variável a é chamado com b como seu argumento.

Para cada operador (+ - * /% ** & | ^ << >> && ||), existe uma forma correspondente de operador de atribuição abreviado (+ = - = etc.).

Operadores Aritméticos Ruby

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Operador	Descrição	Exemplo
+	Adição - adiciona valores em ambos os lados do operador.	a + b dará 30
-	Subtração - subtrai o operando direito do operando esquerdo.	a - b dará -10
*	Multiplicação - Multiplica os valores em ambos os lados do operador.	a * b dará 200
/	Divisão - Divide operando esquerdo pelo operando direito.	b / a dará 2
%	Módulo - Divide o operando esquerdo pelo operando direito e retorna o resto.	b% a dará 0
**	Expoente - Executa cálculo exponencial (potência) nos operadores.	a ** b dará 10 à potência 20

Operadores de comparação Ruby

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Operador	Descrição	Exemplo
==	Verifica se os valores de dois operandos são iguais ou não, se sim a condição torna-se verdadeira.	(a == b) não é verdade.
! =	Verifica se o valor de dois operandos é igual ou não; se os valores não são iguais, a condição se torna verdadeira.	(a! = b) é verdade.
>	Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se sim, a condição torna-se verdadeira.	(a> b) não é verdade.
<	Verifica se o valor do operando esquerdo é menor que o valor do operando direito; se sim, a condição torna-se verdadeira.	(a <b) é verdade.
> =	Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim a condição torna-se verdadeira.	(a> = b) não é verdade.
<=	Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito, se sim a condição torna-se verdadeira.	(a <= b) é verdadeiro.
<=>	Operador de comparação combinada. Retorna 0 se o primeiro operando for igual ao segundo, 1 se o primeiro operando for maior que o segundo e -1 se o primeiro operando for menor que o segundo.	(a <=> b) retorna -1.
===	Usado para testar a igualdade dentro de uma cláusula when de uma instrução case .	(1 ... 10) === 5 retorna verdadeiro.
.eql?	Verdadeiro se o receptor e o argumento tiverem o mesmo tipo e valores iguais.	1 == 1.0 retorna verdadeiro, mas 1.eql? (1.0) é falso.
igual?	Verdadeiro se o receptor e o argumento tiverem o mesmo id de objeto.	se aObj é duplicado de bObj então aObj == bObj é verdadeiro, a.equal? ​​bObj é falso mas a.equal? ​​aObj é verdadeiro.

Operadores de atribuição Ruby

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Operador	Descrição	Exemplo
=	Operador de atribuição simples, atribui valores de operandos do lado direito ao operando do lado esquerdo.	c = a + b atribuirá o valor de a + b em c
+ =	Adicionar operador de atribuição AND, adiciona operando direito ao operando esquerdo e atribui o resultado ao operando esquerdo.	c + = a é equivalente a c = c + a
- =	Subtrai o operador de atribuição AND, subtrai o operando direito do operando esquerdo e atribui o resultado ao operando esquerdo.	c - = a é equivalente a c = c - a
* =	Operador de atribuição Multiply AND, multiplica o operando direito pelo operando esquerdo e atribui o resultado ao operando esquerdo.	c * = a é equivalente a c = c * a
/ =	Operador de atribuição Dividir AND, divide o operando esquerdo com o operando direito e atribui o resultado ao operando esquerdo.	c / = a é equivalente a c = c / a
% =	O operador de atribuição de módulo AND pega o módulo usando dois operandos e atribui o resultado ao operando esquerdo.	c% = a é equivalente a c = c% a
** =	O operador de atribuição de expoente AND executa cálculo exponencial (potência) nos operadores e atribui valor ao operando esquerdo.	c ** = a é equivalente a c = c ** a

Atribuição Paralela Ruby

Ruby também suporta a atribuição paralela de variáveis. Isso permite que várias variáveis ​​sejam inicializadas com uma única linha de código Ruby. Por exemplo -

a = 10
b = 20
c = 30

Isso pode ser declarado mais rapidamente usando atribuição paralela -

a, b, c = 10, 20, 30

A atribuição paralela também é útil para trocar os valores mantidos em duas variáveis ​​-

a, b = b, c

Operadores Ruby Bitwise

O operador bit a bit funciona em bits e executa operação bit a bit.

Suponha que a = 60; e b = 13; agora em formato binário serão os seguintes -

a    =  0011 1100
 b    =  0000 1101
 ------------------
 a&b  =  0000 1100
 a|b  =  0011 1101
 a^b  =  0011 0001
 ~a   =  1100 0011

Os seguintes operadores Bitwise são suportados pela linguagem Ruby.

Operador	Descrição	Exemplo
E	O operador binário AND copia um bit para o resultado se ele existir em ambos os operandos.	(a & b) dará 12, que é 0000 1100
|	O operador binário OR copia um bit se ele existir em qualquer operando.	(a | b) dará 61, que é 0011 1101
^	O operador binário XOR copia o bit se estiver definido em um operando, mas não em ambos.	(a ^ b) dará 49, que é 0011 0001
~	O operador de complemento binários é unário e tem o efeito de 'inverter' bits.	(~ a) resultará em -61, que é 1100 0011 na forma de complemento de 2 devido a um número binário com sinal.
<<	Operador binário de deslocamento à esquerda. O valor dos operandos à esquerda é movido para a esquerda pelo número de bits especificado pelo operando à direita.	um << 2 dará 240, que é 1111 0000
>>	Operador binário de deslocamento à direita. O valor dos operandos à esquerda é movido para a direita pelo número de bits especificado pelo operando à direita.	a >> 2 dará 15, que é 0000 1111

Operadores lógicos Ruby

Os seguintes operadores lógicos são suportados pela linguagem Ruby

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Operador	Descrição	Exemplo
e	Operador lógico chamado AND. Se ambos os operandos forem verdadeiros, a condição se torna verdadeira.	(aeb) é verdade.
ou	Operador lógico ou chamado. Se qualquer um dos dois operandos for diferente de zero, a condição se torna verdadeira.	(a ou b) é verdadeiro.
&&	Operador lógico chamado AND. Se ambos os operandos forem diferentes de zero, a condição se torna verdadeira.	(a && b) é verdadeiro.
||	Operador lógico ou chamado. Se qualquer um dos dois operandos for diferente de zero, a condição se torna verdadeira.	(a || b) é verdade.
!	Operador lógico chamado NOT. Use para reverter o estado lógico de seu operando. Se uma condição for verdadeira, o operador lógico NOT tornará falsa.	! (a && b) é falso.
não	Operador lógico chamado NOT. Use para reverter o estado lógico de seu operando. Se uma condição for verdadeira, o operador lógico NOT tornará falsa.	not (a && b) é falso.

Operador Ternário Ruby

Existe mais um operador chamado Operador Ternário. Ele primeiro avalia uma expressão para um valor verdadeiro ou falso e, em seguida, executa uma das duas instruções fornecidas, dependendo do resultado da avaliação. O operador condicional tem esta sintaxe -

Operador	Descrição	Exemplo
? :	Expressão Condicional	Se a condição for verdadeira? Então valor X: Caso contrário, valor Y

Operadores Ruby Range

Os intervalos de sequência em Ruby são usados ​​para criar um intervalo de valores sucessivos - consistindo em um valor inicial, um valor final e um intervalo de valores intermediários.

Em Ruby, essas sequências são criadas usando os operadores de intervalo ".." e "...". O formato de dois pontos cria um intervalo inclusivo, enquanto o formato de três pontos cria um intervalo que exclui o valor alto especificado.

Operador	Descrição	Exemplo
..	Cria um intervalo do ponto inicial ao ponto final, inclusive.	1..10 Cria um intervalo de 1 a 10 inclusive.
...	Cria um intervalo do ponto inicial ao ponto final exclusivo.	1 ... 10 Cria um intervalo de 1 a 9.

Ruby definido? Operadores

definiram? é um operador especial que assume a forma de uma chamada de método para determinar se a expressão passada está definida ou não. Ele retorna uma string de descrição da expressão ou nil se a expressão não estiver definida.

Existem vários usos de definido? Operador

Uso 1

defined? variable # True if variable is initialized

For Example

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

Uso 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)

Uso 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)

Uso 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)

Ruby Dot "." e dois-pontos duplos "::" Operadores

Você chama um método de módulo precedendo seu nome com o nome do módulo e um ponto, e faz referência a uma constante usando o nome do módulo e dois dois-pontos.

o :: é um operador unário que permite: constantes, métodos de instância e métodos de classe definidos dentro de uma classe ou módulo, para serem acessados ​​de qualquer lugar fora da classe ou módulo.

Remember em Ruby, classes e métodos também podem ser considerados constantes.

Você precisa apenas prefixar o :: Const_name com uma expressão que retorna a classe ou objeto de módulo apropriado.

Se nenhuma expressão de prefixo for usada, a classe Object principal será usada por padrão.

Aqui estão dois exemplos -

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

Precedência de operadores Ruby

A tabela a seguir lista todos os operadores da precedência mais alta para a mais baixa.

Método	Operador	Descrição
sim	::	Operador de resolução constante
sim	[] [] =	Referência de elemento, conjunto de elementos
sim	**	Exponenciação (elevar à potência)
sim	! ~ + -	Não, complemento, mais e menos unários (os nomes dos métodos para os dois últimos são + @ e - @)
sim	* /%	Multiplique, divida e modulo
sim	+ -	Adição e subtração
sim	>> <<	Deslocamento bit a bit para direita e esquerda
sim	E	'E' bit a bit
sim	^ |	"OR" exclusivo bit a bit e "OR" regular
sim	<= <>> =	Operadores de comparação
sim	<=> == ===! = = ~! ~	Operadores de igualdade e correspondência de padrão (! = E! ~ Não podem ser definidos como métodos)
	&&	'E' lógico
	||	'OU' lógico
	.. ...	Alcance (inclusivo e exclusivo)
	? :	Ternário if-then-else
	=% = {/ = - = + = | = & = >> = << = * = && = || = ** =	Tarefa
	definiram?	Verifique se o símbolo especificado está definido
	não	Negação lógica
	ou e	Composição lógica

NOTE- Os operadores com um Sim na coluna do método são, na verdade, métodos e, como tal, podem ser substituídos.