Operadores Ruby

Operadores aritméticos do Ruby

Supondo que o valor da variável a seja 10O valor da variável b é 2Se 0, então:

Operadores de comparação do Ruby

Supondo que o valor da variável a seja 10O valor da variável b é 2Se 0, então:

Operador de atribuição do Ruby

Supondo que o valor da variável a seja 10O valor da variável b é 2Se 0, então:

Atribuição paralela do Ruby

O Ruby também suporta a atribuição paralela de variáveis. Isso permite que várias variáveis sejam inicializadas em uma linha de código Ruby. Por exemplo:

a =　10
b =　20
c =　30

A atribuição paralela permite declarar mais rapidamente:

a, b, c =　10,　20,　30

A atribuição paralela é muito útil ao trocar os valores de duas variáveis:

a, b = b, c

Operadores de bit do Ruby

Os operadores de bit agem sobre os bits e executam operações bit a bit.

Supondo que se a = 60, e b = 13Agora, em formato binário, eles são assim:

a = 0011 1100

b = 0000 1101

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

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

A tabela a seguir lista os operadores de bit suportados pelo Ruby.

Operadores lógicos do Ruby

A tabela a seguir lista os operadores lógicos suportados pelo Ruby.

Supondo que o valor da variável a seja 10O valor da variável b é 2Se 0, então:

operador ternário do Ruby

Há mais de uma operação chamada operador ternário. A primeira calcula o valor verdadeiro ou falso da expressão, e então decide qual dos dois comandos seguintes executar com base no resultado. A sintaxe do operador condicional é a seguinte:

operador de intervalo do Ruby

No Ruby, os intervalos de sequência são usados para criar uma série de valores contínuos - inclusivo do valor de início, valor de fim (dependendo do caso) e os valores entre eles.

No Ruby, essas sequências são criadas usando os operadores de intervalo ".." e "...". O formato de dois pontos cria um intervalo que inclui o valor de início e o valor de fim, enquanto o formato de três pontos cria um intervalo que inclui apenas o valor de início e não inclui o valor de fim.

operador defined? do Ruby

definido? é um operador especial, que usa a forma de chamada de método para determinar se uma expressão foi definida. Ele retorna a string de descrição da expressão, retornando nil.

A seguir estão várias usos do operador defined?

usabilidade 1

definido? variável # Se a variável já foi inicializada, é True

por exemplo:

foo =　42
definido? foo # => "local"-variável"
definido? $_ # => "global"-variável"
definido? bar # => nil (não definido)

usabilidade 2

definido? method_call # Se o método já foi definido, é True

por exemplo:

definido? puts # => "método"
definido? puts(bar) # => nil (aqui bar não definido)
definido? unpack # => nil (aqui não definido)

usabilidade 3

# Se há um método chamável super para o usuário, é True
definido? super

por exemplo:

definido? super # => "super" (se pode ser chamado)
definido? super # => nil (se não pode ser chamado)

usabilidade 4

definido? yield # Se um bloco foi passado, é True

por exemplo:

definido? yield # => "yield" (se um bloco foi passado)
defined? yield # => nil (se não for passado um bloco)

O operador ponto "." e o operador de dois dois-pontos "::" do Ruby

Você pode chamar métodos dentro da classe ou módulo adicionando o nome da classe ou módulo e . ao nome do método. Você pode usar o nome da classe ou módulo e dois dois-pontos :: para referenciar constantes dentro da classe ou módulo.

:: é um operador unário, que permite definir constantes, métodos de exemplo e métodos de classe dentro de uma classe ou módulo, e pode ser acessado de qualquer lugar fora da classe ou módulo.

Lembre-se:Em Ruby, classes e métodos também podem ser usados como constantes.

Você precisa apenas adicionar o nome do constante antes da expressão. :: Prefixo, para retornar o objeto apropriado da classe ou módulo.

Se a expressão antes de :: for o nome de uma classe ou módulo, retorna o valor da constante correspondente dentro da classe ou módulo; se não houver expressão prefixada antes de ::, retorna o valor da constante correspondente na classe principal Object. .

A seguir estão dois exemplos:

MR_COUNT = 0 # Definido na classe principal Object
module Foo
　　MR_COUNT = 0
　　::MR_COUNT =　1　　　　# Define o contador global　1
　　MR_COUNT =　2　　　　　　# Define o contador local　2
end
puts MR_COUNT # É a constante global
puts Foo::MR_COUNT # É a constante local do "Foo"

Segundo exemplo:

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

Prioridade dos operadores do Ruby

A tabela a seguir lista todos os operadores em ordem de prioridade, de alta para baixa.

Atenção:Listado em métodos como é Os operadores são métodos, portanto, podem ser sobrecarregados.