Acerca del juicio de tipo de datos de JavaScript

1. Tipos de datos en jsvascript

1. Tipos primitivos : booleano, cadena, número, nulo, indefinido, símbolo, BigInt (los números enteros se pueden representar con precisión arbitraria)

especial:

• símbolo :

ES6 es nuevo y representa un valor único. El tipo de datos "símbolo" es un tipo de datos primitivo. La naturaleza de este tipo es que el valor de este tipo se puede utilizar para crear propiedades de objeto anónimas. Este tipo de datos se usa generalmente como el valor clave de una propiedad de objeto, cuando desea que sea privado. Un valor con el tipo de datos "símbolo" puede denominarse "valor de tipo de símbolo". En el entorno de ejecución de JavaScript, se puede crear un valor de tipo de símbolo llamando a la función Symbol (), que genera dinámicamente un valor único y anónimo. El único uso razonable del tipo Símbolo es usar una variable para almacenar el valor del símbolo y luego usar el valor almacenado para crear una propiedad de objeto.

• BigInt :

Puede representar números enteros con precisión arbitraria. Con BigInt, puede almacenar y manipular de forma segura números enteros grandes, incluso superando el límite seguro de números enteros. BigInt se crea agregando n al final del número entero o llamando al constructor.

3. Tipo de referencia (tipo de objeto) : los tipos de objeto incluyen: matriz (matriz), función (función) y dos objetos especiales: regular (RegExp) y fecha (fecha).

Dos. Juzgue el tipo de datos

1. tipo de

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
const bar = Symbol()
console.log(typeof bar )//symbol
const x = 2n ** 53n//BigInt类型
console.log(typeof x)//bigint
const y = typeof x
console.log(typeof y)//string

para resumir:

• Los valores que typeof puede devolver son:number,string,undefined,Boolean,object,function,symbol,bigint
• Los resultados devueltos por typeof son todos tipos de cadenas

2. instancia de

Tanto el tipo de matrices de detección como los objetos anteriores devuelven "objeto", por lo que no podemos juzgar con precisión el tipo de datos del tipo de referencia, y no podemos juzgar con precisión el nulo.

El operador instanceof se utiliza para detectar si la propiedad de prototipo del constructor aparece en la cadena de prototipos de un objeto de instancia.

Simular la ejecución interna de instanceof: cuando el proto de A apunta al prototipo de B, A se considera una instancia de B

instanceof (A,B) = {
    
    
    var L = A.__proto__;
    var R = B.prototype;
    if(L === R) {
    
    
        //A的内部属性__proto__指向B的原型对象
        return true;
    }
    return false;
}

P.ej

function Car(make, model, year) {
    
    
  this.make = make;
  this.model = model;
  this.year = year;
}
const auto = new Car('Honda', 'Accord', 1998);

console.log(auto instanceof Car);
// expected output: true

console.log(auto instanceof Object);
// expected output: true

Se utiliza para detectar el tipo de datos.

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([] instanceof Object)    //true
console.log(function(){
    
    } instanceof Function);//true
console.log({
    
    } instanceof Object)    //true
console.log(null instanceof Object) //false
//通过实例构造函数得到的值是原始类型也是可以使用instanceof判断数据类型
var bool2 = new Boolean()
console.log(bool2 instanceof Boolean);// true
var num2 = new Number()
console.log(num2 instanceof Number);// true
var str2 = new String()
console.log(str2 instanceof String);//  true

para resumir:

• instanceof no puede distinguir entre indefinido y nulo
• Y para el tipo básico, si no se declara con new, no se puede probar El valor obtenido a través del constructor de instancia es el tipo primitivo, y instanceof también se puede usar para determinar el tipo de datos.
• Para el tipo declarado con new, también puede detectar múltiples relaciones de herencia, como cuando se detectan matrices: aunque instanceof puede determinar que [] es una instancia de Array, piensa que [] también es una instancia de Object, lo cual se debe a la especialidad de la cadena de prototipos

3. constructor

La función del atributo constructor es saber qué constructor genera un objeto de instancia.

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(([]).constructor===Object );       //false
console.log((function(){
    
    }).constructor === Function);//true
console.log(({
    
    }).constructor === Object)    //true

Sin embargo, el constructor se puede reescribir durante el desarrollo.

function Fn(){
    
    }
Fn.prototype = new Array(); //prototype==原型
var f = new Fn();
console.log(f.constructor === Fn)//false
console.log(f.constructor === Array)//true

para resumir:

• El constructor se puede reescribir y el juicio después de reescribir es inexacto
• undefined y null no tienen propiedades de constructor, y el constructor no puede juzgar undefined y null

4. Object.prototype.toString.call ***

toString es un método en el objeto prototipo Object. Este método devuelve el tipo específico de su llamador por defecto. Hablando más estrictamente, es el tipo de objeto al que apunta cuando se ejecuta toString. El formato de tipo devuelto es [objeto, xxx], xxx es el tipo específico. Tipo de datos

console.log(Object.prototype.toString.call('')) ;   // [object String]
console.log(Object.prototype.toString.call(2)) ;    // [object Number]
console.log(Object.prototype.toString.call(true)) ; // [object Boolean]
console.log(Object.prototype.toString.call(undefined)) ; // [object Undefined]
console.log(Object.prototype.toString.call(null)) ; // [object Null]
console.log(Object.prototype.toString.call(new Function())) ; // [object Function]
console.log(Object.prototype.toString.call(new Date())) ; // [object Date]
console.log(Object.prototype.toString.call([])) ; // [object Array]
console.log(Object.prototype.toString.call(new RegExp()) ); // [object RegExp]
console.log(Object.prototype.toString.call(new Error())) ; // [object Error]
console.log(Object.prototype.toString.call(window) ); //[object Window]
console.log(Object.prototype.toString.call( Symbol()))//[object Symbol]
console.log(Object.prototype.toString.call( 3n))//[object BigInt]

para resumir:

• String, Number, Boolean, Undefined, Symbol, Null, Function, BigInt, Date, Array, RegExp, Error, HTMLDocument, ... Básicamente, todos los tipos de objetos se pueden obtener a través de este método.
• Debe obtenerse a través de Object.prototype.toString.call en lugar de directamente new Date (). ToString (). Desde la perspectiva de la cadena de prototipos, la cadena de prototipos de todos los objetos finalmente apunta a Object. De acuerdo con las reglas de búsqueda de variables de JS , otros objetos También debería ser posible acceder directamente al método toString de Object. De hecho, la mayoría de los objetos implementan su propio método toString, lo que puede provocar la terminación de toString de Object. Por lo tanto, use una llamada para forzar el método toString de Object .