Operadores de rubi

Rubi operadores aritméticos

Suponha que a variável de um valor de 10, o valor b variável de 20, então:

comparação rubi

Suponha que a variável de um valor de 10, o valor b variável de 20, então:

Rubi operador de atribuição

Suponha que a variável de um valor de 10, o valor b variável de 20, então:

atribuição paralela de rubi

Ruby também suporta variáveis ​​de atribuição paralelas. Isso permite múltiplas variáveis ​​podem ser inicializados por uma linha de código Ruby. Por exemplo:

A = 10
b = 20
C = 30

Usando atribuição paralela mais rápida Disclaimer:

a, b, c = 10, 20, 30

Atribuição paralela ao trocar os valores das duas variáveis ​​também são úteis:

a, b = b, c

Operadores bit a bit do Ruby

Operadores bit a bit que actuam sobre o pouco e pouco a operação bits.

Se se considerar que a = 60, b = 13 e, agora num formato binário, que é como se segue:

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 o rubi apoiar operadores bit a bit.

operadores lógicos rubi

A tabela a seguir lista o rubi apoiar os operadores lógicos.

Suponha que a variável de um valor de 10, o valor b variável de 20, então:

Rubi operador ternário

Há mais de uma ação é chamado de operador ternário. O primeiro valor de verdade de computação da expressão, e então decidiu implementar dois atrás em uma declaração com base no resultado. operador condicional tem a seguinte sintaxe:

Rubi operador de intervalo

Em Ruby, a sequência é usada para criar uma série de valor intervalo consecutivo - contém começar valor, o valor final (sujeito a disponibilidade) e os valores entre eles.

Em Ruby, estas sequências é o uso de ".." e "..." operadores de intervalo para criar. Intervalo contém duas formas criar valores iniciais e finais, o intervalo de três para criar um formulário que contém apenas o valor final valor inicial não está incluída.

Rubi definida? Operator

definido? é um operador especial, quer sob a forma de uma chamada de método para passar julgamento expressão é definido. Ele retorna a descrição expressão de cadeia, se a expressão é retornos indefinidosnulo.

A seguir estão os vários operadores definidos uso ?:

Uso 1

definido? variável # Se a variável foi inicializada É verdade,

Por exemplo:

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

Uso 2

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

Por exemplo:

definido? coloca # "método" =>
puts definidos? (bar) # => nil (undefined aqui bar)
definido? descompactar # => nil (undefined aqui)

Uso 3

# Se o método pode ser invocado como super usuário existe, então Verdadeiro
definido? Super

Por exemplo:

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

Uso 4

definido? render # Se o bloco de código passado verdadeiro,

Por exemplo:

definido? rendimento # => "yield" (se o bloco de transferência)
definido? render # => nil (se não passar bloco)

Rubi operador ponto "." E o operador dois pontos duplos "::"

Você pode adicionar o nome do módulo e sublinhado para chamar um método do módulo antes do nome do método. Você pode usar o nome do módulo e dois dois pontos para fazer referência a uma constante.

:: É um operador unário, permitindo constantes, métodos de instância e métodos de classe definidas dentro da classe ou módulo que pode ser acessado em qualquer lugar na classe ou módulo do lado de fora.

Recorde: Em Ruby, classes e métodos também podem ser utilizados como uma constante.

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

Se a expressão prefixo não é usado, a master class de objetos padrão.

Aqui estão dois exemplos:

MR_COUNT = 0 # classe Object definidos nos principais constantes módulo Foo
  MR_COUNT = 0
  :: MR_COUNT = 1 # para definir a uma contagem global
  MR_COUNT = 2 # definir a contagem local dos dois
final
coloca MR_COUNT # Esta é uma constante global coloca Foo :: MR_COUNT # O que é "foo" constantes locais 

Segunda instância:

CONST = "lá fora"
classe Inside_one
   CONST = proc { 'lá'}
   def where_is_my_CONST
      :: CONST + 'dentro de um'
   final
final
classe Inside_two
   CONST = 'dentro de dois'
   def where_is_my_CONST
      CONST
   final
final
coloca Inside_one.new.where_is_my_CONST
coloca Inside_two.new.where_is_my_CONST
coloca Objeto :: CONST + Inside_two :: CONST
coloca Inside_two :: CONST + CONST
coloca Inside_one :: CONST
coloca Inside_one :: CONST.call + Inside_two :: CONST

Rubi precedência do operador

A tabela a seguir com base no operador prioridade lista todos os operadores.

Nota: A colunaéidentificado como o método de operador é, na verdade, um método, que pode ser sobrecarregado.