Transformaciones implícitas en JavaScript y resumen (recomendado)

Las reglas de comparación y conversión entre diferentes tipos de datos en JavaScript son las siguientes:

1. Comparación de objetos y valores booleanos

对象和布尔值进行比较时，对象先转换为字符串，然后再转换为数字，布尔值直接转换为数字

[] == true; //false []转换为字符串'',然后转换为数字0,true转换为数字1，所以为false

2. 对象和字符串比较

对象和字符串进行比较时，对象转换为字符串，然后两者进行比较。

[1,2,3] == '1,2,3' // true [1,2,3]转化为'1,2,3'，然后和'1,2,3'， so结果为true;

3. 对象和数字比较

对象和数字进行比较时，对象先转换为字符串，然后转换为数字，再和数字进行比较。

[1] == 1; // true `对象先转换为字符串再转换为数字，二者再比较 [1] => '1' => 1 所以结果为true

4. 字符串和数字比较

字符串和数字进行比较时，字符串转换成数字，二者再比较。

'1' == 1 // true

5. 字符串和布尔值比较

字符串和布尔值进行比较时，二者全部转换成数值再比较。

'1' == true; // true

6. 布尔值和数字比较

布尔值和数字进行比较时，布尔转换为数字，二者比较。

true == 1 // true

许多刚接触js的童鞋看到这么多的转换规则就懵圈了，其实规律很简单，大家可以记下边这个图

如图，任意两种类型比较时，如果不是同一个类型比较的话，则按如图方式进行相应类型转换，如对象和布尔比较的话，对象 => 字符串 => 数值 布尔值 => 数值。
另外，我们来看下一些需要"特别照顾"的。

来看一个有趣的题

[] == false;
![] == false;

这两个的结果都是true,第一个是，对象 => 字符串 => 数值0 false转换为数字0,这个是true应该没问题，
第二个前边多了个!，则直接转换为布尔值再取反，转换为布尔值时，空字符串(''),NaN,0，null,undefined这几个外返回的都是true, 所以! []这个[] => true 取反为false,所以[] == false为true。

还有一些需要记住的，像：

undefined == null //true undefined和null 比较返回true，二者和其他值比较返回false
Number(null) //0

曾经看到过这样一个代码：　 (!(~+[])+{})[--[~+"+[]]*[~+[]]+~~!+[]]+({}+[[¡¡!+*~+[]]] = sb, ¿te lo crees, en ese momento me asusté mucho.

Cuando me encontré con él por primera vez, JS me confundió mucho, debido a su 'capricho', a continuación, resumiré:

7. Tipos de datos de JS: Number, Boolean, String, Undefined, Null, Symbol (es6Nuevamente definido) y Object (nota: Array es un tipo especial de Object)

　　　　El valor devuelto por typeof7Tipos: number boolean string object undefined object function

MDN así describe JavaScript: JavaScript es un lenguaje de tipo débil o dinámico. Esto significa que no es necesario declarar previamente el tipo de variable, el tipo se determina automáticamente durante la ejecución del programa. Esto también significa que se puede usar el mismo variable para almacenar diferentes tipos de datos

8. Vamos a ver algunos casos comunes de conversión implícita:

　　Tipos primitivos:

　　　Operador (+,-,*,/,%) en la operación, se convierten los tipos

　　　　"+Operador "": 　　

　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　

　　　　　　Resumen: Cuando el operador es el símbolo +, String y otros tipos se convierten a String; en otros casos, se convierten a tipo Number, nota: undefined se convierte a Number como 'NaN', cualquier Number más NaN es NaN.

　　　　　　　 　　En otros operadores, los tipos primitivos se convierten a Number, los tipos String con caracteres, por ejemplo: '1a' ,'a1' se convierte en NaN como undefined.

　　　　　　tip：(1) NaN no es igual a ningún valor, ni siquiera a sí mismo, por lo que para determinar si un valor es NaN, se puede usar "!==".　　

　　　　　　　　 （2) Los que se convierten a Boolean false son: null, 0, '', undefined, NaN, false　　

　　　　　　　　（3）number（） y parseInt（） pueden convertir un objeto a tipo Number, la función Number es mucho más estricta que la función parseInt. Básicamente, si hay un carácter que no se puede convertir en número, toda la cadena se convertirá en NaN.　　

　　

　　Tipo Object

　　　　Cuando el objeto se opera con tipos primitivos:

var obj = {
  toString: function(){
    return 6;
  },
  valueOf: function(){
    return 5;
  }
};
var obj1 = {
  valueOf: function(){
    return 'a';
  },
  toString: function(){
    return 'b';
  }
};

　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　

　　　　　　

　　　　　　　　　　　　Cuando se opera con obj,obj1 Al usar Number() y String() para convertir

　　　　　　　　

　　　　　　　　　　　　Resumen: El tipo Number primero llama a valueOf(), el tipo String primero llama a toString(), si el resultado es un valor original, se devuelve el valor original, de lo contrario, se sigue utilizando toString o valueOf para calcular, si el resultado aún no es un valor original, se lanza un error de tipo.　

　　　　Vea el siguiente caso:

　　　　

¿Por qué {} + [] = 063; Porque JavaScript considera el primer {} como un bloque de código vacío al ejecutarse, por lo que es equivalente a +[] = 0. Además de {} +5 = 5, del mismo modo.

Resumen:

1.Los errores de tipo pueden ocultarse en la conversión de tipo.

2. "+Puede representar la concatenación de cadenas o la adición aritmética, dependiendo de sus operandos. Si uno de ellos es una cadena, entonces es una concatenación de cadenas.

3.Los objetos se convierten en números a través del método valueOf y en cadenas a través del método toString.

4.Los objetos que tienen el método valueOf deben definir un método toString correspondiente para devolver la forma de cadena de números iguales.

5.Al detectar variables no definidas, debe usar typeof o comparar con undefined, en lugar de usar directamente operaciones de verdadero/falso.

Resumen

Lo mencionado anteriormente es una serie de conversiones implícitas y resúmenes (recomendados) en JavaScript que presentamos al editor, esperamos que les sean útiles. Si tienen alguna pregunta, deje un mensaje y el editor responderá a tiempo. También muy agradecido por el apoyo a los tutoriales de alarido!

Declaración: El contenido de este artículo se ha obtenido de la red, pertenece a los propietarios originales, el contenido ha sido contribuido y subido por los usuarios de Internet de manera autónoma, este sitio no posee los derechos de propiedad, no ha sido editado por humanos y no asume responsabilidad alguna por ellas. Si encuentra contenido sospechoso de copyright, le invitamos a enviar un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, por favor reemplace # con @) para denunciar y proporcionar evidencia relevante. Una vez verificada, este sitio eliminará inmediatamente el contenido sospechoso de infracción.