js juicio de tipo de datos de uso común

1. Utilice el operador typeof:

typeof es un operador unario que devuelve la cadena de tipo de datos de un valor. Proporciona información de tipo básica para la mayoría de los tipos de datos, incluidos "número", "cadena", "booleano", "indefinido", "símbolo", "objeto" (incluido nulo) y "función". Por ejemplo:

typeof 42; // "number"
typeof "Hello"; // "string"
typeof true; // "boolean"
typeof undefined; // "undefined"
typeof Symbol("symbol"); // "symbol"
typeof {
    
    }; // "object"
typeof []; // "object"
typeof null; // "object"（这是 typeof 的一个历史性 bug）
typeof function(){
    
    }; // "function"

Cabe señalar que typeof null devuelve "objeto", que es un problema heredado, de hecho, null es un tipo de datos básico especial.

2. Utilice el operador instanceof:

instanceof se usa para determinar si un objeto es una instancia creada por un constructor. Por ejemplo:

[] instanceof Array; // true
{
    
    } instanceof Object; // true
new Date() instanceof Date; // true

instanceof solo puede juzgar datos de tipo de referencia y no se puede usar para tipos de datos básicos.

3. Utilice el método Object.prototype.toString.call():

Este es un método general que se puede utilizar para obtener información de tipo precisa para las variables. Por ejemplo:

Object.prototype.toString.call(42); // "[object Number]"
Object.prototype.toString.call("Hello"); // "[object String]"
Object.prototype.toString.call(true); // "[object Boolean]"
Object.prototype.toString.call(undefined); // "[object Undefined]"
Object.prototype.toString.call(Symbol("symbol")); // "[object Symbol]"
Object.prototype.toString.call({
    
    }); // "[object Object]"
Object.prototype.toString.call([]); // "[object Array]"
Object.prototype.toString.call(null); // "[object Null]"
Object.prototype.toString.call(function(){
    
    }); // "[object Function]"

Al llamar al método Object.prototype.toString.call(), puede obtener una cadena expresada en el formato de "[tipo de objeto]", donde el tipo es el tipo exacto de la variable.

4. Usa el operador de igualdad estricta ===

1 === 1; // true，数值相等且类型相同
"hello" === "hello"; // true，字符串相等且类型相同
true === true; // true，布尔值相等且类型相同
undefined === undefined; // true，undefined 相等且类型相同
null === null; // true，null 相等且类型相同

1 === "1"; // false，数值类型与字符串类型不同
true === 1; // false，布尔值类型与数值类型不同
null === undefined; // false，null 和 undefined 是不同的类型

El uso de === puede hacer juicios de tipo de datos más precisos, porque requiere el mismo tipo al comparar valores. Pero debe tenerse en cuenta que para la comparación de tipos de referencia, === comparará si sus direcciones de referencia son las mismas, no si sus valores son iguales. Por ejemplo:

Symbol("symbol") === Symbol("symbol"); // false，Symbol 值是唯一的
{
    
    } === {
    
    }; // false，对象是引用类型，比较的是引用地址
[] === []; // false，同样的原因，数组是引用类型

const obj1 = {
    
    };
const obj2 = {
    
    };
const obj3 = obj1;

obj1 === obj2; // false，obj1 和 obj2 指向不同的对象
obj1 === obj3; // true，obj1 和 obj3 指向同一个对象