¿Qué significa / / = (o-igual) en Ruby?

a ||= b es un "operador de asignación condicional". Es una especie-de-pero-no-del todo (*) abreviatura de a || a = b.

Significa " si a es indefinido o falsey (false o nil), luego evalúe b y establezca a en el resultado".

Por ejemplo:

> a ||= nil
=> nil
> a ||= 0;
=> 0
> a ||= 2;
=> 0

> foo = false;
=> false
> foo ||= true;
=> true
> foo ||= false;
=> true

La evaluación de cortocircuito de Ruby significa que si a se define y evalúa a truthy, entonces el lado derecho del operador no se evalúa, y no se realiza ninguna asignación. Este la distinción no es importante si a y b son ambas variables locales, pero es significativa si cualquiera de ellas es un método getter/setter de una clase.

Confusamente, se ve similar a otros operadores de asignación (como +=) pero se comporta de manera diferente.

a += b se traduce como a = a + b

a ||= b se traduce como* a || a = b

*Excepto que, cuando a no está definido, a || a = b sería NameError, mientras que a ||= b establece a a b.

Además lectura:

• http://www.rubyinside.com/what-rubys-double-pipe-or-equals-really-does-5488.html

Respuesta concisa y completa

a ||= b

Evalúa de la misma manera que cada de las siguientes líneas

a || a = b
a ? a : a = b
if a then a else a = b end

-

Por otro lado,

a = a || b

Evalúa de la misma manera que cada de las siguientes líneas

a = a ? a : b
if a then a = a else a = b end

-

Editar: Como AJedi32 señaló en los comentarios, esto solo es cierto si: 1. a es una variable definida. 2. Evaluar una y dos veces no da lugar a una diferencia en el estado del programa o del sistema.

En resumen, a||=b significa: Si a es undefined, nil or false, asignar b a a. De lo contrario, mantenga a intacto.

Basicamente,

x ||= y significa

Si x tiene algún valor déjelo solo y no cambie el valor, de lo contrario establezca x en y.

Significa o-igual a. Comprueba si el valor de la izquierda está definido, y luego lo usa. Si no lo es, usa el valor de la derecha. Puede usarlo en Rails para almacenar en caché variables de instancia en modelos.

Un ejemplo basado en quick Rails, donde creamos una función para recuperar el usuario actualmente registrado:

class User > ActiveRecord::Base

  def current_user
    @current_user ||= User.find_by_id(session[:user_id])
  end

end

Comprueba si la variable de instancia @current_user está establecida. Si lo es, lo devolverá, guardando así una llamada a la base de datos. Sin embargo, si no está configurado, hacemos la llamada y luego establezca la variable @current_user en eso. Es una técnica de almacenamiento en caché muy simple, pero es ideal para cuando se obtiene la misma variable de instancia a través de la aplicación varias veces.

x ||= y

Es

x || x = y

"si x es falso o indefinido, entonces x apunta a y"

Para ser precisos, a ||= b significa "si a es indefinido o falso (false o nil), establezca a a b y evalúe (es decir, devuelva) b, de lo contrario evalúe a a".

Otros a menudo tratan de ilustrar esto diciendo que a ||= b es equivalente a a || a = b o a = a || b. Estas equivalencias pueden ser útiles para entender el concepto, pero tenga en cuenta que son no exactas bajo todas las condiciones. Permítanme explicar:

• a ||= b ⇔ a || a = b?

  El comportamiento de estas sentencias difiere cuando a es una variable local indefinida. En ese caso, a ||= b establecerá a a b (y evaluar a b), mientras que a || a = b elevará NameError: undefined local variable or method 'a' for main:Object.

• a ||= b ⇔ a = a || b?

  A menudo se asume la equivalencia de estas declaraciones, ya que una equivalencia similar es cierta para otros operadores de asignación abreviada (i. e. +=,-=,*=,/=,%=,**=,&=,|=,^=,<<=, y >>=). Sin embargo, para ||= el comportamiento de estas declaraciones puede diferir cuando a= es un método sobre un objeto y a es veraz. En ese caso, a ||= b no hará nada (aparte de evaluar a a), mientras que a = a || b llamará a a=(a) al receptor de a. Como otros han señalado, esto puede hacer una diferencia cuando llamar a a=a tiene efectos secundarios, como agregar claves a un hash.

• a ||= b ⇔ a = b unless a??

  El comportamiento de estas declaraciones difiere solo en lo que evalúan cuando a es verdadero. En ese caso, a = b unless a evaluará a nil (aunque a todavía no se establecerá, como se esperaba), mientras que a ||= b evaluará a a.

• a ||= b ⇔ defined?(a) ? (a || a = b) : (a = b)????

  Todavía no. Estas sentencias pueden diferir cuando existe un método method_missing que devuelve un valor truth para a. En este caso, a ||= b evaluará a lo que method_missing devuelve, y no intentará establecer a, mientras que defined?(a) ? (a || a = b) : (a = b) establecerá a a b y evaluará a b.

Vale, vale, entonces lo que es a ||= b equivalente a? ¿Hay alguna manera de expresar esto en Ruby?

Bueno, suponiendo que no estoy pasando por alto nada, creo que a ||= b es funcionalmente equivalente a... (redoble de tambores )

begin
  a = nil if false
  a || a = b
end

Espera! ¿No es solo el primer ejemplo con un noop antes? Bueno, no del todo. ¿Recuerdas cómo dije antes que a ||= b no es equivalente a a || a = b cuando a es una variable local indefinida? Bueno, a = nil if false asegura que a nunca esté indefinido, aunque esa línea nunca se ejecute. Las variables locales en Ruby son de ámbito léxico.

unless x x = y end

A menos que x tenga un valor (no es nil o false), póngalo igual a y

Es equivalente a

x ||= y

Supongamos a = 2 y b = 3

ENTONCES, a ||= b se dará como resultado el valor de a, es decir, 2.

Como cuando a evalúa a algún valor que no resulta en false o nil.. Es por eso que ll no evalúa el valor de b.

Ahora supongamos a = nil y b = 3.

Entonces a ||= b será el resultado de 3, es decir, el valor de b.

Ya que primero intenta evaluar el valor de a que resultó en nil.. así que evaluó el valor de b.

El mejor ejemplo utilizado en la aplicación ror es:

#To get currently logged in iser
def current_user
  @current_user ||= User.find_by_id(session[:user_id])
end

# Make current_user available in templates as a helper
helper_method :current_user

Donde, User.find_by_id(session[:user_id]) se dispara si y solo si @current_user no se inicializa antes.

Esta es la notación de asignación predeterminada

Por ejemplo: x / / = 1
esto comprobará si x es nil o no. Si x es nil entonces le asignará ese nuevo valor (1 en nuestro ejemplo)

Más explícito:
si x = = nil
x = 1
fin

a ||= b

Es equivalente a

a || a = b

Y no

a = a || b

Debido a la situación en la que se define un hash con un valor predeterminado (el hash devolverá el valor predeterminado para cualquier clave indefinida)

a = Hash.new(true) #Which is: {}

Si usa:

a[10] ||= 10 #same as a[10] || a[10] = 10

A sigue siendo:

{}

Pero cuando lo escribes así:{[11]]}

a[10] = a[10] || 10

A se convierte en:

{10 => true}

Porque ha asignado el valor de sí mismo en la clave 10, que por defecto es true, por lo que ahora se define el hash para la clave 10, en lugar de nunca realizar la tarea en primer lugar.

Es como una instanciación perezosa. Si la variable ya está definida, tomará ese valor en lugar de volver a crear el valor.

irb(main):001:0> a = 1
=> 1
irb(main):002:0> a ||= 2
=> 1

Porque a ya estaba establecido en 1

irb(main):003:0> a = nil
=> nil
irb(main):004:0> a ||= 2
=> 2

Porque a era nil

Por favor, también recuerde que ||= no es una operación atómica y por lo tanto, no es seguro hilo. Como regla general, no lo use para métodos de clase.

b = 5
a ||= b

Esto se traduce como:

a = a || b

Que será

a = nil || 5

Así que finalmente

a = 5

Ahora si llamas a esto de nuevo:

a ||= b
a = a || b
a = 5 || 5
a = 5

b = 6

Ahora si llamas a esto de nuevo:

a ||= b
a = a || b
a = 5 || 6
a = 5 

Si observas, b el valor no será asignado a a. a todavía tendrá 5.

Es un Patrón de Memoización que se está utilizando en Ruby para acelerar los accesores.

def users
  @users ||= User.all
end

Esto se traduce básicamente como:

@users = @users || User.all

Así que usted hará una llamada a base de datos por primera vez que llame a este método.

Las futuras llamadas a este método solo devolverán el valor de la variable de instancia @users.

Como un error común a||=b no es equivalente a a = a||b, pero que es, pero se comporta como un || a = b

Pero aquí viene un caso complicado

Si a no está definido, a || a = 42 genera un error de nombre, mientras que a ||= 42 devuelve 42. Por lo tanto, no parecen ser expresiones equivalentes.

||= se llama operador de asignación condicional.

Básicamente funciona como = pero con la excepción de que si una variable ya ha sido asignada no hará nada.

Primer ejemplo:

x ||= 10

Segundo ejemplo:

x = 20
x ||= 10

En el primer ejemplo x es ahora igual a 10. Sin embargo, en el segundo ejemplo x ya se define como 20. Así que el operador condicional no tiene efecto. x sigue siendo 20 después de ejecutar x ||= 10.

a ||= b es lo mismo que decir: a = b if a.nil? o a = b unless a

¿Pero las 3 opciones muestran el mismo rendimiento? Con Ruby 2.5.1 esto

1000000.times do
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
end

Tarda 0.099 Segundos en mi PC, mientras que

1000000.times do
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
end

Tarda 0.062 Segundos. Eso es casi un 40% más rápido.

Y luego también tenemos:

1000000.times do
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
end

Que tarda 0.166 Segundos.

No es que esto tenga un impacto significativo en el rendimiento en general, pero si necesita ese último poco de optimización, considere este resultado. Por cierto: a = 1 unless a es más fácil de leer para el novato, se explica por sí mismo.

Nota 1: la razón para repetir la línea de asignación varias veces es para reducir la sobrecarga del bucle en el tiempo medido.

Nota 2: Los resultados son similares si hago a=nil nada antes de cada asignación.

||= es un operador de asignación condicional

  x ||= y

Es equivalente a

  x = x || y

O bien

if defined?(x) and x
    x = x
else 
    x = y
end