[Perguntas da entrevista inicial] JavaScript - tipos de dados

1. Quais tipos de dados existem

Stack: Tipos básicos: Undefined, Null, Boolean, Number, String
Heap: Tipos de referência: Array, Object, Function
Symbol e BigInt são novos tipos de dados no ES6:
Symbol: Cria um tipo de dado único e imutável, principalmente para resolver Possível variável global conflitos.
BigInt: é um tipo numérico de dados que pode representar números inteiros em formato de precisão arbitrário. Para armazenar e manipular big data com segurança.

A diferença entre os dois tipos é o local de armazenamento :
1. O tipo de dado original é armazenado na pilha , ocupa um espaço pequeno, tem tamanho fixo e é usado com frequência.
2. Os objetos do tipo referência armazenados no heap

2. Quais são os métodos de detecção de tipo de dados

1. typeof: Os valores dos tipos object, null e array são todos objetos, e todos os outros tipos estão corretos.

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: Seu mecanismo de operação interno é determinar se o protótipo deste tipo pode ser encontrado em sua cadeia de protótipos . (Não é possível detectar tipos primitivos, apenas tipos de referência)

//基本类型无法检测
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, construtor

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、Object.prototype.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. Quais são as maneiras de julgar a matriz

1. Julgando por Object.prototype.toString.call()

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

2. Julgamento através da cadeia de protótipos

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

3. A julgar pelo Array.isArray() do ES6

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

4. Julgando por instância 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

Quarto, a diferença entre nulo e indefinido

O mesmo: todos são tipos de dados básicos, todos armazenados na pilha.
Diferente:
1. Significado: null é um objeto vazio, que é usado principalmente para inicialização, undefined é undefined, que define uma variável não atribuída, e o valor é indefinido.
2. Palavras reservadas: null é uma palavra reservada e não pode ser usada como nome de variável, undefined não é uma palavra reservada e pode ser usada como nome de variável. A saída não relatará um erro, mas ocorrerão conflitos.
3. typeof: typeof null === 'object'; typeof undefined === 'undefined'.

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

5. Por que 0,1+0,2 ! == 0,3 e como torná-lo igual?

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

Como o computador armazena os dados em binário, ao calcular 0,1+0,2, ele precisa ser convertido em binário e então somado.Existem alguns erros de precisão, 0,1+0,2=0,30000000000000004.

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

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

6. Qual é o resultado do tipo de NaN?

NaN significa "não é um número", NaN é um "valor sentinela" (valor regular com um propósito especial) usado para indicar uma condição de erro em tipos numéricos, ou seja, "executando uma operação matemática sem sucesso, Este é o resultado retornado após a falha" .

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

7. Qual é a diferença entre as funções isNaN e Number.isNaN?

1. Após a função isNaN receber um parâmetro, ela tentará converter o parâmetro em um valor numérico. Qualquer valor que não puder ser convertido em um valor numérico retornará true. Portanto, se um valor não numérico for passado, ele também retornará true, o que afetará o julgamento de NaN.

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

2. A função Number.isNaN julgará primeiro o parâmetro 是否为数字de entrada 如果是数字e, em seguida, continuará a julgar se é NaN e não converterá o tipo de dados. Esse método é mais preciso para o julgamento 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. Quais são as regras de coerção para o operador ==?

Para ==, se os tipos dos dois lados da comparação forem diferentes, a conversão de tipo será executada. Se for comparado se x e y são iguais, será realizado o seguinte processo de julgamento:
1. Primeiro, julgará se os dois 类型são iguais e, se forem iguais, será comparado o tamanho dos dois ;
2. Se os tipos não forem iguais, a conversão de tipo será realizada;
3. Primeiro julgará se compara nulo e indefinido, se sim, retornará verdadeiro;
4. Julgará se os dois tipos são string e número, se sim, converterá **string para número**;
5. Julgar se um deles é booleano, se sim, converterá booleano em número e depois julgar;
6. Julgar se um deles é objeto e o outro é string, número ou símbolo, se assim for, ele converterá o objeto para o tipo primitivo e depois julgará.

9. Regras de conversão de outros valores para strings?

1. Tipos Null e Undefined, null é convertido em "null", undefined é convertido em "undefined",
2. Tipo booleano, true é convertido em "true" e false é convertido em "false".
3. O valor do tipo Number é convertido diretamente, mas esses números extremamente pequenos e extremamente grandes usarão a forma exponencial.
4. O valor do tipo Symbol pode ser convertido diretamente, mas somente a conversão explícita de tipo é permitida. Usar a conversão implícita de tipo causará um erro.
5. Para objetos comuns, a menos que o método toString() seja definido sozinho, toString() (Object.prototype.toString()) será chamado para retornar o valor da propriedade interna [[Class]], como "[ objeto Objeto]" . Se o objeto tiver seu próprio método toString(), esse método será chamado e seu valor de retorno será usado na stringificação.

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

10. Quais são as regras de conversão de outros valores para valores numéricos?

1. O valor de Tipo indefinido é convertido em NaN.
2. O valor do tipo Nulo é convertido em 0.
3. O valor do tipo booleano, true é convertido em 1 e false é convertido em 0.
4. A conversão de valor do tipo String é como usar a função Number() para conversão. Se contiver valores não numéricos, será convertido em NaN e a string vazia será 0.
5. O valor do tipo de símbolo não pode ser convertido em um número e um erro será relatado.
6. Objetos (incluindo arrays) serão primeiro convertidos para o valor de tipo básico correspondente.Se o valor retornado for um valor de tipo básico não numérico, ele será forçado a um número de acordo com as regras acima.

11. Quais são as regras de conversão de outros valores para valores booleanos?

Os valores a seguir são falsos: • indefinido • nulo • falso • +0, -0 e NaN • "".
Uma coerção booleana de um valor falso resulta em falso. Logicamente, tudo fora da lista de valores falsos deve ser verdadeiro.

valor	virar digital	converter string	converter booleano
Indefinido	NaN	"Indefinido"	falso
nulo	0	"nulo"	falso
verdadeiro	1	"verdadeiro"
falso	0	"falso"
0		"0"	falso
-0		"0"	falso
NaN		“NaN”	falso
Infinidade		"Infinidade"	verdadeiro
-Infinidade		"-Infinidade"	verdadeiro
1 (diferente de zero)		"1"	verdadeiro
{} (qualquer objeto)	Veja acima	Veja acima	verdadeiro
[](任意数组)	0	””	verdadeiro
[9](包含一个数字元素)	9	“9”	verdadeiro
[”a”](其他数组)	NaN	Use o método .join()	verdadeiro
function(){}(qualquer função)	NaN	Veja acima	verdadeiro

12. Retorna os valores dos operadores || e &&?

Primeiro, ele será convertido em um valor booleano.
||: Se o resultado do julgamento for verdadeiro, retorne o primeiro valor verdadeiro; se o resultado do julgamento for falso, retorne o segundo resultado falso.
&&: Se o resultado do julgamento for verdadeiro, então retorne o segundo valor que é verdadeiro; se o resultado do julgamento for falso, então retorne o primeiro valor que é 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. Qual é a diferença entre Object.is() e os operadores de comparação "===" e "=="?

1. === : Comparar tipos e valores, se os tipos não forem iguais, é diretamente falso.
2. ==: Primeiro julgue o tipo, converta os diferentes tipos no mesmo tipo, e então compare o valor
3. Object.is(): A situação geral é basicamente a mesma que ===, e situações especiais como - 0 e +0 não são mais iguais, dois NaNs são iguais

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

14. O que são tipos de wrapper em JavaScript?

Tipo de base -> Tipo de wrapper: Objeto

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

Tipo de wrapper -> Tipo primitivo: valueOf

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

Em JavaScript, tipos primitivos não possuem propriedades e métodos , mas para facilitar a manipulação de valores primitivos, JavaScript converte implicitamente valores primitivos em objetos em segundo plano ao chamar propriedades ou métodos de tipos primitivos .

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

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