[Preguntas de la entrevista inicial] JavaScript: tipos de datos

1. ¿Qué tipos de datos hay?

Pila: Tipos básicos: Indefinido, Nulo, Booleano, Número,
Montón de cadenas: Tipos de referencia: Matriz, Objeto,
Símbolo de función y BigInt son nuevos tipos de datos en ES6:
Símbolo: Crea un tipo de datos único e inmutable, principalmente para resolver una posible variable global conflictos
BigInt: es un tipo numérico de datos que puede representar números enteros en formato de precisión arbitraria. Para almacenar y manipular big data de forma segura.

La diferencia entre los dos tipos es la ubicación de almacenamiento :
1. El tipo de datos original se almacena en la pila , ocupa un espacio pequeño, tiene un tamaño fijo y se usa con frecuencia.
2. Los objetos de tipo de referencia almacenados en el montón

2. ¿Cuáles son los métodos de detección de tipos de datos?

1. typeof: los valores de los tipos object, null y array son todos objetos, y todos los demás tipos son correctos.

console.log(typeof 2);               // number
console.log(typeof true);            // boolean
console.log(typeof 'str');           // string
console.log(typeof []);              // object    
console.log(typeof function(){
    
    });    // function
console.log(typeof {
    
    });              // object
console.log(typeof undefined);       // undefined
console.log(typeof null);            // object

2. instanceof: Su mecanismo operativo interno es determinar si el prototipo de este tipo se puede encontrar en su cadena de prototipos . (No se pueden detectar tipos primitivos, solo tipos de referencia)

//基本类型无法检测
console.log(2 instanceof Number);                    // false
console.log(true instanceof Boolean);                // false 
console.log('str' instanceof String);                // false 
//引用类型可以检测
console.log([] instanceof Array);                    // true
console.log(function(){
    
    } instanceof Function);       // true
console.log({
    
    } instanceof Object);                   // true

3, constructor

console.log((2).constructor === Number); // true
console.log((true).constructor === Boolean); // true
console.log(('str').constructor === String); // true
console.log(([]).constructor === Array); // true
console.log((function() {
    
    }).constructor === Function); // true
console.log(({
    
    }).constructor === Object); // true

4、Objeto.prototipo.toString.call()

var a = Object.prototype.toString;

console.log(a.call(2));//[object Number]
console.log(a.call(true));//[object Boolean]
console.log(a.call('str'));//[object String]
console.log(a.call([]));//[object Array]
console.log(a.call(function () {
    
     }));//[object Function]
console.log(a.call({
    
    }));//[object Object]
console.log(a.call(undefined));//[object Undefined]
console.log(a.call(null));//[object Null]

3. ¿Cuáles son las formas de juzgar la matriz?

1. A juzgar por Object.prototype.toString.call()

var arr = [];
console.log(Object.prototype.toString.call(arr).slice(8,-1) === 'Array');//true

2. Juicio a través de la cadena de prototipos

var arr = [112, 2]
console.log(arr.__proto__ === Array.prototype);//true

3. A juzgar por Array.isArray() de ES6

var arr = [112, 2]
console.log(Array.isArray(arr));//true

4. A juzgar por instancia de

var arr = [112, 2]
console.log(arr instanceof Array);//true

5、通过Array.prototype.isPrototypeOf

var arr = [112, 2]
console.log(Array.prototype.isPrototypeOf(arr));//true

Cuarto, la diferencia entre nulo e indefinido.

Lo mismo: todos son tipos de datos básicos, todos almacenados en la pila.
Diferente:
1. Significado: nulo es un objeto vacío, que se utiliza principalmente para la inicialización, indefinido es indefinido, que define una variable no asignada, y el valor es indefinido.
2. Palabras reservadas: null es una palabra reservada y no se puede usar como nombre de variable; undefined no es una palabra reservada y se puede usar como nombre de variable. La salida no informará un error, pero se producirán conflictos.
3. typeof: typeof null === 'objeto', typeof indefinido === 'indefinido'.

console.log(null == undefined);//true
console.log(null === undefined);//false

5. ¿Por qué 0.1+0.2 ! == 0.3, y cómo hacerlo igual?

console.log(0.1 + 0.2 === 0.3)  // false 为什么呢？

Debido a que la computadora almacena datos en binario, al calcular 0.1+0.2, debe convertirse a binario y luego sumarse Hay algunos errores de precisión, 0.1+0.2=0.30000000000000004.

可以通过四舍五入进行判断

console.log((0.1+0.2).toFixed(2)==0.3);//true

6. ¿Cuál es el resultado de typeof NaN?

NaN significa "no es un número", NaN es un "valor centinela" (valor regular con un propósito especial) que se utiliza para indicar una condición de error en los tipos numéricos, es decir, "realizar una operación matemática sin éxito, este es el resultado devuelto después de la falla" .

console.log(typeof NaN); // "number"
console.log(NaN !== NaN)

7. ¿Cuál es la diferencia entre las funciones isNaN y Number.isNaN?

1. Después de que la función isNaN recibe un parámetro, intentará convertir el parámetro en un valor numérico. Cualquier valor que no se pueda convertir en un valor numérico devolverá verdadero. Por lo tanto, si se pasa un valor no numérico, lo hará. también devuelve verdadero, lo que afectará el juicio de NaN.

console.log(isNaN(1));//false
console.log(isNaN('1'));//false
console.log(isNaN('a'));//true
console.log(isNaN('a'/2));//true

2. La función Number.isNaN primero juzgará el parámetro entrante 是否为数字, 如果是数字y luego continuará juzgando si es NaN , y no convertirá el tipo de datos.Este método es más preciso para el juicio de NaN.

console.log(Number.isNaN(1));//false
console.log(Number.isNaN('1'));//false
console.log(Number.isNaN('a'));//false
console.log(Number.isNaN('a' / 2));//true

8. ¿Cuáles son las reglas de coerción para el operador ==?

Para ==, si los tipos de los dos lados de la comparación son diferentes, se realizará la conversión de tipo. Si se compara si x e y son iguales, se llevará a cabo el siguiente proceso de juicio:
1. Primero, juzgará si los dos 类型son iguales , y si son iguales, se comparará el tamaño de los dos. ;
2. Si los tipos no son los mismos, se realizará la conversión de tipos;
3. Primero juzgará si comparar nulo e indefinido, si es así, devolverá verdadero
4. Juzgará si los dos tipos son cadena y número, en caso afirmativo, convertirá **cadena en número**;
5. Juzgue si uno de ellos es booleano; en caso afirmativo, convertirá booleano en número y luego juzgará;
6. Juzgue si uno de ellos es objeto y el otro es cadena, número o símbolo, si es así, convertirá el objeto en un tipo primitivo y luego lo juzgará.

9. ¿Reglas de conversión de otros valores a cadenas?

1. Tipos nulo e indefinido, nulo se convierte en "nulo", indefinido se convierte en "indefinido",
2. Tipo booleano, verdadero se convierte en "verdadero" y falso se convierte en "falso".
3. El valor del tipo Número se convierte directamente, pero los números extremadamente pequeños y extremadamente grandes usarán la forma exponencial.
4. El valor del tipo Símbolo se puede convertir directamente, pero solo se permite la conversión de tipo explícita. El uso de la conversión de tipo implícita provocará un error.
5. Para objetos ordinarios, a menos que el método toString() esté definido por sí mismo, se llamará a toString() (Object.prototype.toString()) para devolver el valor de la propiedad interna [[Clase]], como "[ objeto Objeto]" . Si el objeto tiene su propio método toString(), se llama a ese método y se usa su valor devuelto al encadenar.

obj={
    
    }
console.log(Object.prototype.toString.call(obj));//[object Object]

10. ¿Cuáles son las reglas de conversión de otros valores a valores numéricos?

1. El valor del tipo Indefinido se convierte a NaN.
2. El valor de tipo nulo se convierte en 0.
3. El valor de tipo booleano, verdadero se convierte en 1 y falso se convierte en 0.
4. La conversión de valor del tipo String es como usar la función Number() para la conversión. Si contiene valores no numéricos, se convierte a NaN y la cadena vacía es 0.
5. El valor del tipo de símbolo no se puede convertir a un número y se informará un error.
6. Los objetos (incluidas las matrices) se convertirán primero al valor de tipo básico correspondiente. Si el valor devuelto es un valor de tipo básico no numérico, se convertirá en un número de acuerdo con las reglas anteriores.

11. ¿Cuáles son las reglas de conversión de otros valores a valores booleanos?

Los siguientes son valores falsos: • indefinido • nulo • falso • +0, -0 y NaN • "".
Una coerción booleana de un valor falso da como resultado falso. Lógicamente, todo lo que esté fuera de la lista de valores falsos debería ser verdadero.

valor	convertir digital	convertir cadena	convertir booleano
indefinido	Yaya	"indefinido"	falso
nulo	0	"nulo"	falso
cierto	1	"cierto"
falso	0	"falso"
0		"0"	falso
-0		"0"	falso
Yaya		"Yaya"	falso
infinito		"Infinito"	cierto
-Infinito		"-Infinito"	cierto
1 (distinto de cero)		"1"	cierto
{} (cualquier objeto)	véase más arriba	véase más arriba	cierto
[](任意数组)	0	””	cierto
[9](包含一个数字元素)	9	“9”	cierto
[”a”](其他数组)	Yaya	Usa el método .join()	cierto
function(){}(cualquier función)	Yaya	véase más arriba	cierto

12. ¿Valores de retorno de los operadores || y &&?

Primero, se convertirá a un valor booleano.
||: Si el resultado del juicio es verdadero, devuelve el primer valor verdadero; si el resultado del juicio es falso, devuelve el segundo resultado falso.
&&: Si el resultado del juicio es verdadero, devuelve el segundo valor que es verdadero; si el resultado del juicio es falso, entonces devuelve el primer valor que es falso.

console.log( 5 && 4 );//当结果为真时，返回第二个为真的值4 
console.log( 0 && 4 );//当结果为假时，返回第一个为假的值0 
console.log( 5 || 4 );//当结果为真时，返回第一个为真的值5 
console.log( 0 || 0 );//当结果为假时，返回第二个为假的值0 
console.log((3||2)&&(5||0));//5 
console.log(!5);//false 

13. ¿Cuál es la diferencia entre Object.is() y los operadores de comparación "===" y "=="?

1. ===: compara tipos y valores, si los tipos no son los mismos, es directamente falso.
2. ==: Primero juzga el tipo, convierte los diferentes tipos en el mismo tipo y luego compara el valor
3. Object.is(): La situación general es básicamente la misma que ===, y situaciones especiales como - 0 y +0 ya no son iguales, dos NaN son iguales

Object.is(NaN,NaN);//true

14. ¿Qué son los tipos de contenedor en JavaScript?

Tipo base -> Tipo de envoltorio: Objeto

var a = 'abc'
Object(a) // String {"abc"}

Tipo de envoltorio -> Tipo primitivo: valueOf

var a = 'abc'
var b = Object(a)
var c = b.valueOf() // 'abc'

En JavaScript, los tipos primitivos no tienen propiedades ni métodos , pero para facilitar la manipulación de los valores primitivos, JavaScript convierte implícitamente los valores primitivos en objetos en segundo plano al llamar a las propiedades o métodos de los tipos primitivos .

var str = '123';
console.log(str.length);//3

'123' -> String('123') -> String('123').length