Vamos falar sobre a diferença entre typeof e instanceof

typeof e instanceof são usados ​​para determinar os tipos de dados, mas seus cenários de uso são diferentes e alguns detalhes requerem atenção especial. Vamos descobrir a seguir, dominar a fundo esse ponto de conhecimento e não ter mais medo das perguntas do entrevistador.

typeof

typeof um operador unário colocado na frente de um operando, que pode ser de qualquer tipo. Ele retorna uma string descrevendo o tipo do operando. Por favor, olhe para a castanha:

const type = typeof 'Long Live China' // string;
tipo de 666;
tipo de verdadeiro; // booleano
tipo de indefinido; // indefinido
typeofSímbolo();
tipo de 1n; // bigint
typeof() => {};

tipo de [];
tipo de {};
typeof new String('xxx');

typeof null; // object

Como pode ser visto nos exemplos acima, typeof só pode determinar com precisão tipos de dados e funções básicas (funções são na verdade objetos e não pertencem a outro tipo de dados, mas também podem ser distinguidas usando typeof) e não podem ser determinado com precisão. Tipo de dados de referência de saída (todos os objetos de retorno).

Uma coisa a observar é que chamar typeof null retorna object . Isso ocorre porque o valor especial null é considerado uma referência a um objeto nulo (também chamado de ponteiro de objeto nulo).

Se quiser determinar com precisão o tipo de dados de referência, você pode usar instanceof .

instanceof

O operador instanceof é colocado após um operando e antes do objeto fornecido. Retorna um valor booleano indicando se o operando é uma instância do objeto fornecido:

const result = [] instanceof Array;

const Pessoa = função() {};
const p = nova Pessoa();
p instância de Pessoa; // verdadeiro

mensagem const = new String('xxx');
mensagem instanceof String; // verdadeira

diferença

• typeof retornará o tipo básico de um operando, instanceof retorna um valor booleano

• instanceof pode determinar com precisão o tipo de dados de referência, mas não pode determinar corretamente o tipo de dados básico

• typeof embora possa determinar o tipo de dados básico ( exceto null), mas é impossível determinar o tipo de dados de referência (exceto função)

estendendo

Object.prototype.toString.call().

typeof e instanceof têm certas desvantagens e não podem atender às necessidades de todos os cenários. Se precisar detectar tipos de dados universalmente, você pode usar Object.prototype.toString.call() :

Object.prototype.toString.call({});
Object.prototype.toString.call([]); // "[array de objetos]"
Object.prototype.toString.call(666); // "[Número do objeto]"
Object.prototype.toString.call('xxx'); // "[object String]"

Observe que este método retorna uma string no formato de "[object Object]" .

Função encapsulada

Para uso mais conveniente, podemos encapsular este método:

function getType(value) {
    deixe tipo = tipo de valor;
    if (type !== 'object') { // Se for um tipo de dados básico, retorne diretamente return type;
    }
    // Se for um tipo de dados de referência, um julgamento adicional será feito e o resultado de retorno regular será return Object.prototype.toString.call(value).replace(/^[object (S+)]$/, ' $1');
}

getType(123);
getType('xxx'); //string
getType(() => {}); //função
getType([]);
getType({}); // Objeto
getType(nulo); // Nulo