1. || (lógico o),
Literalmente, False se devuelve solo cuando se devuelve tanto antes y después del falso, de lo contrario.
alerta (verdadero || falso); // TRUEALERT (falso || verdadero); // TRUEALERT (verdadero || verdadero); // TRUEALERT (FALSO || FALSO); // FALSO
Este tonto lo sabe ~~
Sin embargo, en un sentido más profundo, hay otro mundo. Prueba el siguiente código
alerta (0 || 1); // 1
Obviamente, sabemos que el primero 0 significa falso, y el segundo 1 significa verdadero, entonces el resultado anterior debe ser verdadero, y el hecho devuelve el resultado es 1. Mire el siguiente código:
alerta (2 || 1); // 2
Sabemos que los primeros 2 son verdaderos y el último 1 es cierto. Entonces, ¿cuál es el resultado de retorno? El resultado de la prueba es 2, continúa leyendo:
alerta ('a' || 1); // 'a'Del mismo modo, el primero 'a' es verdadero, y el siguiente 1 es verdadero; El resultado de la prueba es 'A', y el siguiente
alerta ('' '|| 1); // 1De lo anterior, sabemos que el frente "es falso, la parte posterior 1 es verdadera y el resultado de retorno es 1. Mira lo siguiente
alerta ('a' || 0); // 'a'El primero 'a' es verdadero, y el siguiente 0 es falso, el resultado de retorno es 'A', continúe con lo siguiente
alerta ('' '|| 0); // 0El anterior "es falso, y el siguiente 0 también es falso, y el resultado de retorno es 0
alerta (0 || ''); // ''
El primer 0 es falso, el siguiente "es falso, el resultado de retorno es"
Esto significa
1. Mientras "||" es falso frente a "||", no importa si "||" es verdadero o falso en la parte posterior de "||", el valor después de "||" será devuelto.
2. Mientras "||" es cierto, independientemente de si "||" es verdadero o falso, el valor anterior "||" será devuelto.
Llamo a esto el principio de cortocircuito: si conoce el resultado del primero, sabrá la salida después. Si el primero es verdadero, tome el valor del primero, y si el primero es falso, entonces tome el valor del segundo.
6 pelotas que JS debe recordar: Recuerde: en las operaciones lógicas JS, 0, "", nulo, falso, indefinido y nan se juzgará como falso, y los otros son verdaderos (parece que no hay omisión, confirme). Debe recordar esto, de lo contrario habrá problemas con la aplicación || y &&.
Por cierto: a menudo te pregunto por qué no escribo si (attr) directamente si (attr);
De hecho, esta es una forma de escribir más rigurosa:
Por favor pruebe la diferencia entre typeof 5 y typeOf !! 5. La función de !! es convertir una variable de otros tipos en un tipo de bool.
2. && (logística y)
Literalmente, verdadero se devolverá solo cuando antes y después sean verdaderos, de lo contrario se devolverá falso.
alerta (true && false); // falsealert (true && true); // trueLert (falso && false); // falsealert (falso && true); // FALSO
Luego, según la experiencia anterior, veamos la situación en la que los números "&&" no son solo tipos booleanos.
alerta ('' && 1); // ''El nudo se regresa "," && "antes" es falso, y el 1 es verdadero después de él.
alerta ('' && 0); // ''El nudo se devuelve "," && "antes" es falso, y el 0 también es falso.
alerta ('a' && 1); // 1El nudo devuelve 1, "&&" antes "A es verdadero, y el siguiente es 1 también es verdadero.
alerta ('a' && 0); // 0El nudo devuelve 0, "&&" antes "a es verdadero, y el siguiente es 0 es falso.
alerta ('a' && ''); // ''El nudo se regresa "," && "antes de" A es verdadero, y "después" es falso.
alerta (0 && 'a'); // 0
El nudo devuelve 0, "&&" antes "0 es falso, y el 'a' es verdadero.
alerta (0 && ''); // 0
El nudo devuelve 0, "&&" antes "0 es falso, y el After" también es falso.
Principio de cortocircuito
1. Mientras "&&" sea falso, no importa si "&&" es verdadero o falso, se devolverá el valor anterior "&&";
2. Mientras "&&" sea verdadero, sin importar si "&&" es verdadero o falso, el resultado devolverá el valor después de "&&";
3. Aplicación en desarrollo
Los siguientes tres códigos son equivalentes:
a = a || "DefaultValue"; if (! a) {a = "defaultValue"; } if (a == null || a == "" || a == undefined) {a = "defaultValue"; }¿Cuál quieres usar?
2. Como Var Yahoo = Yahoo || {}; es muy ampliamente utilizado. ¿No es elegante la forma de obtener el valor inicial? que si. . . . de lo contrario ... mucho mejor, mejor que? : Es mucho mejor.
3. Callback && Callback ()
En las devoluciones de llamada, esto a menudo se escribe de esta manera, y es más riguroso. Primero, determine si existe la devolución de llamada. Si existe, ejecutarlo. El propósito de escribir de esta manera es evitar que se informen errores.
Si escribe devolución de llamada () directamente; El código informará un error cuando la devolución de llamada no existe.
4. Ejemplos completos
Los requisitos se muestran en la figura:
Escribe una descripción de una imagen aquí
Suponga que la tasa de crecimiento se especifica de la siguiente manera:
1 flecha se muestra cuando la tasa de crecimiento es 5;
Se muestran 2 flechas cuando la tasa de crecimiento es 10;
Se muestran 3 flechas cuando la tasa de crecimiento es 12;
Se muestran 4 flechas cuando la tasa de crecimiento es 15;
Todos los demás muestran 0 flechas.
¿Cómo implementarlo con código?
Un poco si, de lo contrario:
var add_level = 0; if (add_step == 5) {add_level = 1; } else if (add_step == 10) {add_level = 2; } else if (add_step == 12) {add_level = 3; } else if (add_step == 15) {add_level = 4; } else {add_level = 0; }Un interruptor ligeramente mejor:
var add_level = 0; switch (add_step) {caso 5: add_level = 1; romper; Caso 10: add_level = 2; romper; Caso 12: add_level = 3; romper; Caso 15: add_level = 4; romper; predeterminado: add_level = 0; romper;}Si el requisito se cambia a:
La tasa de crecimiento es> 12 y se muestran 4 flechas;
Se muestran 3 flechas cuando la tasa de crecimiento es> 10;
La velocidad de crecimiento es> 5 y se muestran 2 flechas;
La velocidad de crecimiento> 0 muestra 1 flecha;
La velocidad de crecimiento es <= 0 y 0 flechas se muestran.
Entonces será muy problemático implementarse con Switch.
Entonces, ¿alguna vez has pensado en implementarlo en una línea?
Ok, echemos un vistazo a la poderosa expresividad de JS:
var add_level = (add_step == 5 && 1) || (add_step == 10 && 2) || (add_step == 12 && 3) || (add_step == 15 && 4) || 0;
Más poderoso y mejor:
var add_level = {'5': 1, '10 ': 2, '12': 3, '15 ': 4} [add_step] || 0;El segundo requisito:
var add_level = (add_step> 12 && 4) || (add_step> 10 && 3) || (add_step> 5 && 2) || (add_step> 0 && 1) || 0;
Lo anterior es un análisis completo de "&&" y "||" Los operadores en JavaScript le presentan el editor. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!