¡Hay caminos y diligencia en la montaña de libros, y no hay límite para el mar de aprendizaje y trabajo duro! ! ! Oro, tres, plata, cuatro, vamos a la entrevista, ¡apúrate! ! !

1. tipo de

1. ¿Cuáles son las ventajas de typeof? ¿defecto?

Ventajas : puede distinguir rápidamente los tipos de datos básicos

Desventajas : Object, Array y Null no se pueden distinguir, todos devuelven objeto

2. ¿Cuál es el papel de typeof?

Distinguir entre tipos de datos, se pueden devolver 7 tipos de datos: y recién agregados number、string、boolean、undefined、object、function ES6 symbol

3. ¿Puede typeof distinguir correctamente los tipos de datos?

no puedo Para los tipos primitivos, todas las excepciones null se pueden juzgar correctamente; para los tipos de referencia, function todas las excepciones devolverán"object"

4. Notas sobre el tipo de

typeof El valor de retorno está string en el formato, preste atención a preguntas como esta: typeof(typeof(undefined)) -> "string"
typeof Las variables indefinidas no reportarán un error, regresan "undefiend"
typeof(null) -> "object": de larga data bug
typeofLas matrices no se pueden distinguir de los objetos ordinarios: typeof([]) -> "object"
typeof(NaN) -> "number"

5. ¿Por qué typeof muestra errores nulos?

Es solo un error de larga data en JS. En la versión inicial de JS, se utilizó un sistema de 32 bits. Por consideraciones de rendimiento, se utilizó la información de tipo de variables de almacenamiento de bajo orden. El comienzo de 000 representaba un objeto, mientras que nulo representaba todos los ceros, por lo que se juzgó erróneamente. como un objeto

6. Tanto typeof('abc') como typeof 'abc' son cadenas, entonces, ¿typeof es un operador o una función?

Respuesta: typeof es el operador

razón:

typeof Uno de los valores de retorno de es 'function', si typeof es function, typeof(typeof) devolverá 'function', pero después de la prueba, el navegador de código anterior arrojará un error. Entonces se puede probar typeof que no es una función.
Dado que typeof no es una función, typeof ¿cuál es la función de los paréntesis detrás de él?

Los paréntesis son para agrupar en lugar de llamadas a funciones. —— "Programación Avanzada Javascript"

En segundo lugar, implementar un typeof

function _typeof(value){
    
    return Object.prototype.toString.call(value).slice(8,-1).toLowerCase();
}

3. El principio de instancia de

Ventajas: puede distinguir entre matriz, objeto y función, adecuado para juzgar objetos de instancia de clase personalizada. Desventajas: los tipos de datos básicos numéricos, booleanos y de cadena no se pueden juzgar.

① instanceof Determine si el prototipo del constructor existe en la cadena de prototipos del objeto. Solo se puede juzgar el tipo de referencia.

② instanceof Un ejemplo comúnmente utilizado para juzgar A si es B

// A es una instancia de B, devuelve verdadero, de lo contrario devuelve falso

// Determinar si hay un prototipo de B en la cadena de prototipos de A

Una instancia de B

Cuarto, la diferencia entre typeof y instanceof

Tanto typeof como instanceof son métodos para juzgar los tipos de datos, las diferencias son las siguientes :

typeof devuelve el tipo básico de una variable, instanceof devuelve un valor booleano
instanceof puede juzgar con precisión los tipos de datos de referencia complejos, pero no puede juzgar correctamente los tipos de datos básicos
Y typeof también tiene desventajas, aunque puede juzgar el tipo de datos básico (excepto nulo), no puede juzgar otros tipos de datos de referencia excepto el tipo de función.

Cinco, simule una instancia de

Idea: buscar a lo largo de la cadena de prototipos

    instance_of (Case, Constructor) {
      // 基本数据类型 返回false
      if ((typeof (Case) != 'object' && typeof (Case) != 'function') || Case == 'null') return false
      let CaseProto = Object.getPrototypeOf(Case);

      while (true) {
        // 查到原型链顶端，仍未查到，返回false
        if (CaseProto == null) return false;
        // 找到相同类型
        if (CaseProto == Constructor.prototype) return true;
        CaseProto = Object.getPrototypeOf(CaseProto)
      }
    },

    function A () { }
    function B () { }
    const C = new A();
    const D = new B();
    console.log(this.instance_of(C, A)); // true
    console.log(this.instance_of(D, B)); // true
    console.log(this.instance_of(C, Array)); // false

6. Tipo de datos de monitoreo general: Object.prototype.toString.call()

Ventajas: juzgue con precisión el tipo de datos Desventajas: el método de escritura es engorroso y no es fácil de recordar, se recomienda usarlo después de la encapsulación

Object.prototype.toString.call(()=>{}) // [Función de objeto]
Objeto.prototipo.toString.call({}) // [objeto Objeto]
Object.prototype.toString.call([]) // [matriz de objetos]
Object.prototype.toString.call('') // [cadena de objeto]
Object.prototype.toString.call(22) // [Número de objeto]
Object.prototype.toString.call(indefinido) // [objeto indefinido]
Object.prototype.toString.call(null) // [objeto nulo]
Object.prototype.toString.call(nueva fecha) // [fecha del objeto]
Object.prototype.toString.call(Math) // [objeto Math]
Object.prototype.toString.call(ventana) // [ventana del objeto]

Typeof e instanceof, cómo simular una instancia de, ¿hay un tipo de datos de detección general?