¿Qué significa "opciones = opciones || {}" en Javascript? [duplicar]
El otro día encontré un fragmento de código que me dio curiosidad, pero no estoy muy seguro de lo que realmente hace;
options = options || {};
Mi pensamiento hasta ahora; establece la variable optionscomo valor optionssi existe; si no, se establece como objeto vacío.
¿Sí No?
Esto es útil para establecer valores predeterminados para argumentos de función, por ejemplo:
function test (options) {
options = options || {};
}
Si llama testsin argumentos, optionsse inicializará con un objeto vacío.
El operador lógico OR ||devolverá su segundo operando si el primero es falso .
Los valores falsos son: 0, null, undefinedla cadena vacía ( ""), NaNy por supuesto false.
ACTUALIZACIÓN DE ES6: Ahora, tenemos valores de parámetros predeterminados reales en el lenguaje desde ES6.
function test (options = {}) {
//...
}
Si llama a la función sin argumentos, o si se llama explícitamente con el valor undefined, el optionsargumento tomará el valor predeterminado. A diferencia del ||ejemplo del operador, otros valores falsos no provocarán el uso del valor predeterminado.
Es el patrón predeterminado .
Lo que tiene en su fragmento es la forma más común de implementar el patrón predeterminado ; devolverá el valor del primer operando que produce un valor verdadero cuando se convierte a booleano.
var some_data = undefined;
var some_obj_1 = undefined;
var some_obj_2 = {foo: 123};
var str = some_data || "default";
var obj = some_obj1 || some_obj2 || {};
/* str == "default", obj == {foo: 123} */
lo anterior es básicamente equivalente a hacer la siguiente alternativa más detallada
var str = undefined;
var obj = undefined;
if (some_data) str = some_data;
else str = "default";
if (some_obj1) obj = some_obj1;
else if (some_obj2) obj = some_obj2;
else obj = {};
Ejemplos de valores obtenidos por el operador lógico OR:
1 || 3 -> 1
0 || 3 -> 3
undefined || 3 -> 3
NaN || 3 -> 3
"" || "default" -> "default"
undefined || undefined -> undefined
false || true -> true
true || false -> true
null || "test" -> "test"
undefined || {} -> {}
{} || true -> {}
null || false || {} -> {}
0 || "!!" || 9 -> "!!"
Como puede ver, si no se encuentra ninguna coincidencia, el valor del último operando es rendimiento.
¿Cuándo es esto útil?
Hay varios casos, aunque el más popular es establecer el valor predeterminado de los argumentos de la función, como se muestra a continuación:
function do_something (some_value) {
some_value = some_value || "hello world";
console.log ("saying: " + some_value);
}
...
do_something ("how ya doin'?");
do_something ();
saying: how ya doin'?
saying: hello world
Notas
Esta es notablemente una de las diferencias que tiene JavaScript en comparación con muchos otros lenguajes de programación populares.
El operador ||no genera implícitamente un valor booleano , pero mantiene los tipos de operandos y genera el primero que se evaluará como verdadero en una expresión booleana.
Muchos programadores que provienen de lenguajes donde este no es el caso (C, C++, PHP, Python, etc, etc) encuentran esto bastante confuso al principio y, por supuesto, siempre ocurre lo contrario; las personas que vienen de javascript ( perl , etc.) se preguntan por qué esta característica no está implementada en otros lugares.
Sí. La muestra es equivalente a esto:
if (options) {
options = options;
} else {
options = {};
}
El operador OR ( ||) provocará un cortocircuito y devolverá el primer valor verdadero.
