Operadores

Ruby tem os seguintes operadores (em ordem decrescente de precedência):

Operador Função É método? (redefinível)
:: Escopo Não
[] Referência (Array) Sim
** Expoenciação Sim
-, +, !, ~ -, +, Neg., Compl. (unários) Sim
*, /, % Mult., Div., Mód. Sim
+, - Adic., Subtr. Sim
<<, >> Deslocamento Sim
& "E" binário Sim
|, ^ "Ou", "Ou exclusivo" Sim
>, >=, <, <= Comparação Sim
<=>, ==, ===, !=, ~=, !~ Igualdade Sim*
&& "E" lógico Não
|| "Ou" lógico Não
.., ... "Faixas" incl. e excl. Não
?: if-then-else Não
=, +=, -=, etc. Atribuição Não*
defined? Testa definição de um símbolo Não
not "Não" lógico Não
and, or "E", "Ou" lógicos Não
if, unless, while, until Modificadores Não
begin, end Expressão em bloco Não

Os operadores redefiníveis são, na verdade, métodos em uma forma especial, para maior comodidade. Por isso podem ser redefinidos.

Note que, por serem redefiníveis, os significados dos operadores dependem das suas implementações. Por exemplo, a classe Array implementa o operador & como intersecção de conjuntos.

a = ["a",2,3,4]
b = ["a",2,5,6]

a & b  # >> ["a", 2]

Símbolos e caracteres

Apesar de não serem operadores nesses casos, os caracteres ':' e '?' têm usos especiais, para gerar símbolos e o código numérico de um caractere, quando prefixam uma seqüência de caracteres e um único caractere, respectivamente.

:aie.class  # >> Symbol
?a          # >> 97

Símbolos são a representação interna dos nomes. Duas ocorrências de um símbolo sempre se referem ao mesmo objeto da classe Symbol.

a = :aie
b = :aie
a == b    # >> true

Símbolos também são valores imediatos, e estão sujeitos às mesmas restrições. Um uso para símbolos é como chaves de um Hash, sendo que são mais eficientes que strings. Pode-se obter o símbolo correspondente a uma String usando o método intern, e obter a String correspondente a um símbolo usando o método to_s de Symbol.

Há vários métodos, como os attr, que aceitam strings ou símbolos como argumentos.

Nota: Os operadores de desigualdade (!= e !~) são redefinidos automaticamente a partir dos de igualdade correspondentes, e não podem ser redefinidos "manualmente".
Nota: Os operadores de auto-atribuição (+=, -=, etc.) são redefinidos automaticamente a partir dos seus correspondentes normais (+, -, etc.), e do operador de atribuição normal (=), e não podem ser redefinidos "manualmente".

topo da página

<< Página Anterior | índice | Próxima Página >>
Apostilas de Ruby e RGSS

nossos tutoriais

navegue

livros recomendados