Operadores de Ruby

Operadores aritméticos de Ruby

Supongamos que el valor de la variable a es 10La variable b tiene el valor de 20, entonces:

Operadores de comparación en Ruby

Supongamos que el valor de la variable a es 10La variable b tiene el valor de 20, entonces:

Operador de asignación en Ruby

Supongamos que el valor de la variable a es 10La variable b tiene el valor de 20, entonces:

Asignación paralela de Ruby

Ruby también admite la asignación paralela de variables. Esto permite que múltiples variables se inicialicen a través de una sola línea de código Ruby. Por ejemplo:

a =　10
b =　20
c =　30

La asignación paralela permite declarar más rápidamente:

a, b, c =　10,　20,　30

La asignación paralela es muy útil para intercambiar los valores de dos variables:

a, b = b, c

Operadores de bits de Ruby

Los operadores de bits actúan sobre los bits y ejecutan las operaciones bit a bit.

Supongamos que si a = 60, y b = 13Ahora, en formato binario, se ven así:

a = 0011 1100

b = 0000 1101

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

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

La siguiente tabla enumera los operadores de bits soportados por Ruby.

Operadores lógicos de Ruby

La siguiente tabla enumera los operadores lógicos soportados por Ruby.

Supongamos que el valor de la variable a es 10La variable b tiene el valor de 20, entonces:

operador ternario en Ruby

Tener más de una operación se llama operador ternario. La primera calcula el valor verdadero o falso de la expresión, y luego según este resultado decide ejecutar una de las dos siguientes sentencias. La sintaxis del operador condicional es la siguiente:

operadores de rango en Ruby

En Ruby, los rangos de secuencia se utilizan para crear una serie de valores consecutivos - Incluye el valor de inicio, el valor de final (según el caso) y los valores entre ellos.

En Ruby, estas secuencias se crean utilizando los operadores de rango ".." y "...". El rango en forma de puntos duros incluye tanto el valor de inicio como el valor de final, mientras que el rango en forma de puntos medios solo incluye el valor de inicio y no incluye el valor de final.

operador defined? en Ruby

defined? es un operador especial que, en forma de llamada a método, determina si una expresión ha sido definida. Devuelve la cadena de descripción de la expresión, y si la expresión no está definida, devuelve nil.

Aquí hay varios usos del operador defined?

usos 1

definido? variable # Si variable ya ha sido inicializada, es True

por ejemplo:

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

usos 2

definido? method_call # Si el método ya está definido, es True

por ejemplo:

definido? puts # => "método"
definido? puts(bar) # => nil (aquí bar no está definido)
definido? unpack # => nil (aquí no está definido)

usos 3

# Si existe un método que puede ser llamado por super, es True
definido? super

por ejemplo:

definido? super # => "super" (si puede ser llamado)
definido? super # => nil (si no puede ser llamado)

usos 4

definido? yield # Si se ha pasado un bloque de código, es True

por ejemplo:

definido? yield # => "yield" (si se ha pasado un bloque)
defined? yield # => nil (si no se pasa un bloque)}

El operador de punto "." y el operador de dos puntos "::" de Ruby

Puedes llamar métodos dentro de una clase o módulo utilizando el nombre de la clase o módulo y .; puedes referirte a constantes dentro de una clase o módulo utilizando el nombre de la clase o módulo y ::.

:: es un operador unario, que permite definir constantes, ejemplos de métodos y métodos de clase dentro de una clase o módulo, y puede ser accedido desde cualquier lugar fuera de la clase o módulo.

Recuerda:En Ruby, las clases y métodos también pueden ser tratados como constantes.

Sólo tienes que añadir el nombre del constante antes de la expresión. :: Un prefijo, se puede devolver el objeto de clase o módulo apropiado.

Si el expresión antes de :: es el nombre de una clase o módulo, devuelve el valor de la constante correspondiente dentro de la clase o módulo; si no hay expresión de prefijo antes de ::, devuelve el valor de la constante correspondiente en la clase principal Object. .

Aquí hay dos ejemplos:

MR_COUNT = 0 # Definido en la clase principal Object
module Foo
　　MR_COUNT = 0
　　::MR_COUNT =　1　　　　# Establecer el recuento global　1
　　MR_COUNT =　2　　　　　　# Establecer el recuento local　2
end
puts MR_COUNT # Esto es la constante global
puts Foo::MR_COUNT # Esto es la constante local de "Foo"

Segundo ejemplo:

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

Prioridad de operadores de Ruby

La siguiente tabla enumera todos los operadores en orden de prioridad desde la más alta a la más baja.

Nota:Se identifica en la lista de métodos como es Los operadores son métodos, por lo tanto, pueden ser sobrecargados.