JavaScript: conversión implícita de tipos de datos, operadores

Ocho tipos de datos de js

1. Tipos de datos básicos:
   número, cadena, booleano, indefinido, nulo
2. Tipo de datos de referencia:
   objeto, matriz de matriz, función de función
3. Dos nuevos tipos agregados por ES6:
   Símbolo, Bigint

operadores aritméticos js

1. Cuando hay una forma de cadena en ambos lados del signo más +, se realiza el empalme de cadenas

console.log("num"+100);   //num100
console.log(100+"undefined");  //100undefined

2. La resta (-), la multiplicación (*), la división (/) y el resto (%) se convierten a tipos numéricos para operaciones, y los valores que no se pueden convertir son NaN.

Sustracción:

console.log(100-"100")//0
console.log(true-"100")//-99,把true转换成1 
console.log(true - "aa"); //NaN

Multiplicación:
indefinido no se puede convertir a un tipo numérico:

console.log(1*false);  //0   false转为0
console.log(3*true);  //3    true转为1
console.log(1*undefined);  //NaN   undefined不能转换为数值型
console.log(2*"3"); //6    转为数值3
console.log(2*"a");  //NaN`在这里插入代码片

división:

console.log(100/true);  //100
console.log(false/100); //0   
console.log(100/"aa");  //NaN
console.log(100/'4');   //25

Toma el resto:

console.log(100%'3');  //1
console.log(100%true); //0

operadores lógicos js (obtendrá un resultado)

Operadores lógicos > Operadores aritméticos, primero ejecute operadores lógicos y luego realice operadores aritméticos

1. ! (NO lógico): Negar

console.log(!true + 1);  //1

console.log(!(true+1));  //false
console.log(!(1+1));  //false 

2. && (Y lógico): Y
   cuando todas las condiciones dadas son verdaderas, se obtiene el valor de verdad.

var age = 18;
var sex = '女';
console.log(age == 18 && sex == '女' ? true :false);  //true

2. || (lógica o): o
   Cuando solo una de las condiciones dadas es verdadera, se puede obtener el valor verdadero.

  var age = 18;
  var sex = '女';
  console.log(age == 18 || sex == '男' ? true : false);  //true

operador de comparación js (debe obtener un valor booleano)

<，>，=，>=，<=，==，!= ，!= =，= ==

La diferencia entre == y ===:

• Cuando se utiliza el doble signo igual ==, si los tipos en los lados izquierdo y derecho del signo igual son diferentes, se convertirá y luego se comparará;
• Cuando se usa el triple signo igual ===, es necesario comparar el tamaño del valor y si los tipos en ambos lados son iguales. Si el tamaño y el tipo del valor son iguales, devuelve verdadero, lo cual es indispensable. de lo contrario, devuelve falso

console.log(100 == '100'); //true
console.log(1 == true);  //ture

console.log(100 === '100'); //false
console.log(100 === 100);  //true

conversión implícita js

1. En el proceso anterior, los operadores aritméticos y los signos dobles iguales realizarán una conversión implícita. Además, hay algunas otras conversiones implícitas, que se presentan y resumen aquí.

2. Las reglas de conversión para convertir a una cadena de caracteres:

Cuando hay un signo más, siempre que haya una cadena, conviértala en una cadena y realice una concatenación de cadenas
(1) Conversión de tipos básicos

console.log(100+"100")  //100100

(2) Conversión del tipo de referencia
La matriz devolverá la matriz misma;
el objeto devolverá el objeto mismo
Principio: al realizar la conversión implícita, si es un tipo numérico, ejecute el método toString, luego ejecute valueOf();
si es un objeto , primero ejecute el método valueOf(), ejecutando toString()