Resumen del juicio en el código JavaScript

Juicio comparativo

El juicio de comparación es comparar dos valores y devolver un valor booleano para indicar si se cumplen las condiciones de comparación. JavaScript proporciona un total de 8 operadores de comparación. Aquí hablamos principalmente de la diferencia entre los estrictos operadores de igualdad y los operadores de igualdad.

Operador de igualdad estricto ===

 Determine que el retorno de dos valores es diferente, falso, ambos valores son nulos/indefinidos/true/falso verdadero. Uno de los dos valores es nan, falsos, ambos valores son numéricos e iguales, verdaderos, ambas valores son cadenas, y los valores iguales son verdaderos, ambos valores apuntan al mismo tipo de referencia True1 === "1" // falsetRue === true // trueDefined === Undefined // true1 === 1 // TRUENAN === Nan // falso+0 === = -0 // True ({{} === falso [] === [] // false (function () {} === function () {}) // falseavar v1 = {}; var v2 = v1; // Dos valores se refieren al mismo objeto v1 === v2 // verdadero

El operador de igualdad estricto tiene un operador de desigualdad estricto correspondiente (! ==), y los resultados de la operación de los dos son exactamente lo contrario.

Operador de igualdad ==

 Si el operador de igualdad compara datos del mismo tipo, el mismo operador de igualdad estricto de lo contrario si el operador de igualdad compara diferentes tipos de datos: el tipo original de datos se convertirá en tipos numéricos, convierte ambas cadenas y booleanos con valores numéricos, y luego compara nulo == Indefinido Devuelto Real uno es un objeto, el otro es un número o cadena, convierte el objeto de un tipo básico y luego compare el valor de tipo básico y luego compare el más floal 123. // true'123 '== 123; // Verdadero, '123' se convertirá en valores numéricos 123false == 0; // Verdadero, False convertir a valores numéricos es 0'A '==' a '; // falso, la codificación convertida es diferente 123 == {}; // falso, ejecutar toString () o valueOf () cambiará 123 == = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ¡= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =) = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = De = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ¡Nan; // falso, siempre que haya nan, es falso {} == {}; // Falso, la comparación es su dirección. La dirección de referencia de cada objeto recién creado es diferente null == Undefined // true'nan '== nan // false123 == nan // falsenan == nan // falsefalse == 0 // truetrue == 1 // trueTrue == 2 // falseedefined == 0 // falsenull == 0 // false'123' == 123 // 123 // 123 '== //FALSO

El operador de igualdad tiene un operador desigual correspondiente (! =), Y los resultados de la operación de los dos son exactamente lo contrario.

!!juez

!! equivalente al Boolean , es muy útil cuando se escribe código !! convertirlo al tipo Boolean para el juicio es muy útil

 !! 'xzavier'; // ¡¡verdadero!!''; // falso !! '0'; // verdad! '1'; // verdadero !! '-1' // verdadero !! 0 // falso !! Undefined // false !! null // false !! nan // false !! {}; // true !! {nombre: 'xz'} // true !! []; // Verdadero !! [1,2,3]; // Verdadero !! verdadero; // verdadero

!juez

Operador inverso! se usa para cambiar el valor booleano al valor opuesto, es decir, el verdadero se vuelve falso y falso se vuelve verdadero. Para los datos que no son booleanos, el operador de inversión lo convierte automáticamente en un booleano. La regla es que los siguientes seis valores están invertidos a verdaderos, y los otros valores están invertidos a falsos

 Undefinado NULL FALSE 0 (incluyendo +0 y -0) nan vacía cadena ('')! Undefined // verdadero! NULL // verdadero! Falso // verdadero! 0 // true! Nan // true! "" // true! 54 // falso! 'Hello' // falso

[] y {} juicio

Para [] y {}, definitivamente haremos juicios en ellos en el código de negocio, como se indica anteriormente

 !! {}; // true !! {nombre: 'xz'} // true !! []; // Verdadero !! [1,2,3]; // verdadero

¡No se puede usar para juicios! ¡y!. Para las matrices, utilizamos su atributo length para juzgar

 [] .length // 0 falso [1,2,3] .length // 3 verdadero

Para los objetos, puede usar el método de jQuery $.isEmptyObject(obj) , o puede encapsular un método imitando a JQuery para escribir un

 función isEtimtyObject (obj) {nombre var; para (nombre en obj) {return false; } return true;} isEtimtyObject ({}); // trueIsEmptyObject ({nombre: 'xzavier'}); FALSO

Recomendar un underscore de biblioteca de herramientas, que también tiene un método isEmpty(object)

 const _ = require ('subscore'); _. isEmpty ({}); // verdadero

&&juez

Utilizado en expresiones condicionales, las reglas son:

 num1 && num2true true verdadero verdadero falso falso falso falso falso

Utilizado en una declaración, las reglas son:

 resultado = Expression1 && Expression2

Si Expression1 se evalúa en FALSO, el resultado es expresión1. De lo contrario, el resultado es expresión2

 (1 - 1) && (x + = 1) // 0 (2> 1) && (5 + 5) // 10 (2 + 1) && (5 + 5) // 10

|| Juicio

Utilizado en expresiones condicionales, las reglas son:

 num1 || num2true true verdadero verdadero verdadero falso verdadero verdadero verdadero falso falso

Utilizado en una declaración, las reglas son:

Si el valor booleano del primer operador es verdadero, se devuelve el valor del primer operador y el segundo operador ya no se evalúa.

Si el valor booleano del primer operador es falso, se devuelve el valor del segundo operador

|| Los operadores generalmente realizan un juicio de expresión condicional y procesamiento de tolerancia a fallas en el código de negocio. Si no podemos obtener los datos al obtenerlo, no puede afectar el código comercial posterior, por lo que debemos ser tolerancia a las fallas. || es un muy buen método de escritura tolerante a fallas, que es equivalente a proporcionar datos de copia de seguridad.

 data var = indefinido || backup_data; // Cuando hay un error en la solicitud y los datos están indefinidos, vaya a Backup Data Backup_data

Juicio de tres ojos

regla:

 condición ? Expression1: Expression2; function ABSN (XZAVIER) {return xzavier> 0? xzavier: -xzavier;} ABSN (-123); // 123ABSN (123); // 123

Si el valor booleano de la primera expresión es verdadero, se devuelve el valor de la segunda expresión, de lo contrario se devuelve el valor de la tercera expresión.

Resumir

Lo anterior es todo el contenido del juicio en el código JavaScript para todos. Espero que el contenido de este artículo sea útil para todos los que usan JavaScript.