operadores - variables globales javascript

JavaScript OR(||) explicación de la asignación de variables

Question

Dado este fragmento de JavaScript ...

var a;
var b = null;
var c = undefined;
var d = 4;
var e = ''five'';

var f = a || b || c || d || e;

alert(f); // 4

¿Puede alguien explicarme cómo se llama esta técnica (mi mejor conjetura está en el título de esta pregunta)? ¿Y cómo / por qué funciona exactamente?

Según tengo entendido, a la variable f se le asignará el valor más cercano (de izquierda a derecha) de la primera variable que tiene un valor que no es nulo o no definido, pero no he podido encontrar mucho material de referencia sobre esta técnica y Lo he visto usado mucho.

Además, ¿esta técnica es específica de JavaScript? Sé que hacer algo similar en PHP daría lugar a que f tenga un verdadero valor booleano, en lugar del valor de d sí mismo.

Answer 1

Devuelve el primer valor verdadero de la salida.

Si todos son falsos, devuelve el último valor falso.

Ejemplo:-

  null || undefined || false || 0 || ''apple''  // Return apple

Answer 2

Está configurando la nueva variable ( z ) en el valor de x si es "sincero" (distinto de cero, un objeto / matriz / función válido / lo que sea) o y contrario. Es una forma relativamente común de proporcionar un valor predeterminado en caso de que x no exista.

Por ejemplo, si tiene una función que toma un parámetro de devolución de llamada opcional, podría proporcionar una devolución de llamada predeterminada que no haga nada:

function doSomething(data, callback) {
    callback = callback || function() {};
    // do stuff with data
    callback(); // callback will always exist
}

Answer 3

Esta pregunta ya ha recibido varias buenas respuestas.

En resumen, esta técnica está aprovechando una característica de cómo se compila el lenguaje. Es decir, JavaScript "cortocircuita" la evaluación de los operadores booleanos y devolverá el valor asociado con el primer valor de la variable no falsa o lo que contenga la última variable. Vea la explicación de Anurag de aquellos valores que se evaluarán como falsos.

Usar esta técnica no es una buena práctica por varias razones; sin embargo.

1. Código de legibilidad: este es el uso de operadores booleanos, y si no se comprende el comportamiento de cómo se compila, el resultado esperado sería un valor booleano.
2. Estabilidad: esta es una característica de cómo se compila el idioma que es inconsistente en múltiples idiomas, y debido a esto, es algo que podría ser potencialmente un cambio en el futuro.

3. Características documentadas: existe una alternativa existente que satisface esta necesidad y es consistente en más idiomas. Este sería el operador ternario:

   ()? valor 1: valor 2

El uso del operador ternario requiere un poco más de escritura, pero distingue claramente entre la expresión booleana que se evalúa y el valor que se asigna. Además, se puede encadenar, por lo que los tipos de asignaciones predeterminadas que se realizan arriba podrían recrearse.

var a;
var b = null;
var c = undefined;
var d = 4;
var e = ''five'';

var f =  ( a ) ? a : 
                ( b ) ? b :
                       ( c ) ? c :
                              ( d ) ? d :
                                      e;

alert(f); // 4

Answer 4

Esto se hace para asignar un valor predeterminado , en este caso el valor de y , si la variable x es falsy .

Los operadores booleanos en JavaScript pueden devolver un operando, y no siempre un resultado booleano como en otros idiomas.

El operador OR lógico ( || ) devuelve el valor de su segundo operando, si el primero es falsy, de lo contrario, se devuelve el valor del primer operando.

Por ejemplo:

"foo" || "bar"; // returns "foo"
false || "bar"; // returns "bar"

Los valores de false son aquellos que obligan a false cuando se usan en un contexto booleano, y son 0 , null , undefined , una cadena vacía, NaN y, por supuesto, false .

Answer 5

Esto significa que si se establece x , el valor para z será x , de lo contrario, si se establece y, entonces su valor se establecerá como el valor de z .

es lo mismo que

if(x)
  z = x;
else
  z = y;

Es posible porque los operadores lógicos en JavaScript no devuelven valores booleanos, pero el valor del último elemento necesario para completar la operación (en una oración OR sería el primer valor no falso, en una oración AND sería la última) ). Si la operación falla, entonces se devuelve false .

Answer 6

Evaluará X y, si X no es nulo, la cadena vacía o 0 (lógica falsa), entonces la asignará a z. Si X es nulo, la cadena vacía o 0 (lógica falsa), entonces asignará y a z.

var x = '''';
var y = ''bob'';
var z = x || y;
alert(z);

Saldrá ''bob'';

Answer 7

Javacript utiliza evaluación de cortocircuito para operadores lógicos || y && . Sin embargo, es diferente a otros idiomas en que devuelve el resultado del último valor que detuvo la ejecución, en lugar de un valor true o false .

Los siguientes valores se consideran falsos en JavaScript.

• falso
• nulo
• "" (cadena vacía)
• 0
• Yaya
• indefinido

Al ignorar las reglas de precedencia del operador y mantener las cosas simples, los siguientes ejemplos muestran qué valor detuvo la evaluación y se devuelve como resultado.

false || null || "" || 0 || NaN || "Hello" || undefined // "Hello"

Los primeros 5 valores hasta NaN son falsos, por lo que se evalúan de izquierda a derecha, hasta que cumplan con el primer valor verdadero: "Hello" que hace que toda la expresión sea verdadera, por lo que no se evaluará nada más arriba, y "Hello" aparece devuelto como resultado de la expresión. Del mismo modo, en este caso:

1 && [] && {} && true && "World" && null && 2010 // null

Los primeros 5 valores son todos veraces y se evalúan hasta que cumplen con el primer valor falso ( null ), lo que hace que la expresión sea falsa, por lo que 2010 ya no se evalúa, y el null se devuelve como resultado de la expresión.

El ejemplo que has dado es hacer uso de esta propiedad de JavaScript para realizar una tarea. Puede usarse en cualquier lugar donde necesite obtener el primer valor verdadero o falso entre un conjunto de valores. Este código a continuación asignará el valor "Hello" a b , ya que facilita la asignación de un valor predeterminado, en lugar de hacer comprobaciones if-else.

var a = false;
var b = a || "Hello";

Podría llamar al ejemplo de abajo una explotación de esta característica, y creo que hace que el código sea más difícil de leer.

var messages = 0;
var newMessagesText = "You have " + messages + " messages.";
var noNewMessagesText = "Sorry, you have no new messages.";
alert((messages && newMessagesText) || noNewMessagesText);

Dentro de la alerta, verificamos si los messages son falsos y, en caso afirmativo, evaluamos y devolvemos noNewMessagesText , de lo contrario evaluamos y devolvemos newMessagesText . Como es falso en este ejemplo, nos detenemos en NoNewMessagesText y alertamos "Sorry, you have no new messages." .

Answer 8

Las variables de Javascript no se escriben, por lo que a f se le puede asignar un valor entero aunque se haya asignado a través de operadores booleanos.

A f se le asigna el valor más cercano que no es equivalente a falso . Entonces 0, falso, nulo, indefinido, se pasan por alto:

alert(null || undefined || false || '''' || 0 || 4 || ''bar''); // alerts ''4''

Answer 9

No hay magia en ello. Expresiones booleanas como a || b || c || d a || b || c || d a || b || c || d son perezosamente evaluados Interpeter busca el valor de a , está indefinido, por lo que es falso, por lo que se mueve, luego ve b que es nulo, lo que aún da un resultado falso por lo que avanza, luego ve c : la misma historia. Finalmente ve d y dice ''eh, no es nulo, así que tengo mi resultado'' y lo asigna a la variable final.

Este truco funcionará en todos los lenguajes dinámicos que realizan evaluaciones perezosas de cortocircuito de expresiones booleanas. En lenguajes estáticos no compilará (error de tipo). En los idiomas que están ansiosos por evaluar expresiones booleanas, devolverá un valor lógico (es decir, verdadero en este caso).

Answer 10

Se llama operador de cortocircuito.

La evaluación de cortocircuito dice que el segundo argumento se ejecuta o evalúa solo si el primer argumento no es suficiente para determinar el valor de la expresión. cuando el primer argumento de la función OR (||) se evalúa como verdadero, el valor global debe ser verdadero.

También podría usarse para establecer un valor predeterminado para el argumento de la función.

function theSameOldFoo(name){ 
  name = name || ''Bar'' ;
  console.log("My best friend''s name is " + name);
}
theSameOldFoo();  // My best friend''s name is Bar
theSameOldFoo(''Bhaskar'');  // My best friend''s name is Bhaskar`

Answer 11

Según la publicación del blog de Bill Higgins ; el lenguaje de asignación OR lógico de Javascript (febrero de 2007), este comportamiento es verdadero a partir de la v1.2 (al menos)

También sugiere otro uso para él (citado): " normalización ligera de las diferencias entre navegadores "

// determine upon which element a Javascript event (e) occurred
var target = /*w3c*/ e.target || /*IE*/ e.srcElement;

Answer 12

Ver evaluación de cortocircuito para la explicación. Es una forma común de implementar estos operadores; no es exclusivo de JavaScript.