Valoración del tipo de, instancia de, constructor, tipo de datos Object.prototype.toString.call(target)

1. tipo de operador (aplicable para juzgar el tipo básico)

• Solo se reconocen los tipos base y los tipos de referencia.

typeof 2; // => 'number'
typeof true; // => 'boolean'
typeof 'str'; // => 'string'

typeof []; // => 'object'
typeof {}; // => 'object'

typeof function a() {} // => 'function'

Nota: nulo , NaN

console.log(typeof null); // object
console.log(typeof NaN); // number

Los diferentes objetos se expresan como binarios en la capa inferior. En JavaScript, si los primeros tres dígitos del binario son todos 0, se considerará como un tipo de objeto . La representación binaria de nulo es todo 0 y, naturalmente, los primeros tres dígitos también son 0, por lo que al ejecutar typeof, devolverá "objeto", este es un problema histórico.

2. operador de instancia (aplicable al tipo de referencia del juez)

El operador instanceof es adecuado para juzgar el tipo de datos de referencia . Devuelve false para los tipos de datos básicos y no se puede juzgar . El operador instanceof no se puede usar para nulo e indefinido .

// 基础类型
2 instanceof Number; //=> false
true instanceof Boolean; //=> false
'str' instanceof String; //=> false

// 引用类型
{} instanceof Object; //=> true
[] instanceof Array; //=> true

new Date() instanceof Date; //=> true
new Error() instanceof Error; //=> true
new Set([1, 2, 3]) instanceof Set; //=> true
new Map([['name', 'Jack'],['age', 18]]) instanceof Map; //=> true
const fn = function (){}
fn instanceof Function; //=> true

Tres, atributo constructor

No se puede juzgar nulo e indefinido , porque estos dos no tienen atributo de constructor

(2).constructor === Number; //=> true
(true).constructor === Boolean; //=> true
('str').constructor === String; //=> true

(Symbol()).constructor === Symbol; //=> true
(BigInt('999446646455454')).constructor === BigInt; //=> true
(new Object).constructor === Object; //=> true
([]).constructor === Array; //=> true
(/^666/).constructor === RegExp; //=>  true
(new Date()).constructor === Date; //=> true
(new Error()).constructor === Error; //=> true
(new Set([1, 2, 3])).constructor === Set; //=> true
(new Map([['name', 'Jack'],['age', 18]])).constructor === Map; //=> true
const fn = function (){}
(fn).constructor === Function; //=> true

4. Préstamo de funciones: Object.prototype.toString.call(target)

La función de préstamo del método toString() puede juzgar todos los tipos .

Object.prototype.toString.call(2); //=> '[object Number]'
Object.prototype.toString.call(true); //=> '[object Boolean]'
Object.prototype.toString.call('str'); //=> '[object String]'
Object.prototype.toString.call(Symbol()); //=> '[object Symbol]'
Object.prototype.toString.call(BigInt('999446646455454')); //=> '[object BigInt]'
Object.prototype.toString.call(null); //=> '[object Null]'
Object.prototype.toString.call(undefined); //=> '[object Undefined]'
Object.prototype.toString.call(new Object); //=> '[object Object]'
Object.prototype.toString.call([]); //=> '[object Array]'
Object.prototype.toString.call(/^666/); //=> '[object RegExp]'
Object.prototype.toString.call(new Date()); //=> '[object Date]'
Object.prototype.toString.call(new Error()); //=> '[object Error]'
Object.prototype.toString.call(new Set([1, 2, 3])); //=> '[object Set]'
Object.prototype.toString.call(new Map([['name', 'Jack'],['age', 18]])); //=> '[object Map]'
const fn = function (){}
Object.prototype.toString.call(fn); //=> '[object Function]'