Hay 5 valores originales en JS, 6 tipos de jueces y 9 constructores incorporados nativos.
Este 569 forma la base del idioma JS.
Los 5 valores originales son: números, caracteres, booleanos, nulos, indefinidos
El tipo de types puede juzgar: números, caracteres, booleanos, objeto, función, indefinido. Tenga en cuenta que NULL y matrices, tipo de ambos objeto de salida.
TypeOf no puede distinguir matrices y objetos. ¿Cómo juzgar los tipos? Use Object.Prototype.ToString.apply ().
if (value && typeof value === 'objeto' && value.constructor === Array)
Si la detección anterior se crea en diferentes cuadros y ventanas, se dará FALSE y el objeto de la ventana será diferente.
Un método confiable es if (object.prototype.tostring.apply (valor) === "[Array de objetos]")
La matriz de argumentos no es una matriz, es solo un objeto con un atributo de miembro de longitud.
Como se muestra en el siguiente ejemplo, los argumentos no son matrices ordinarias
La copia del código es la siguiente:
var a = function () {
var b = object.prototype.ToString.apply (argumentos);
console.log (b);
}
A (); // Salida [Argumentos de objeto]
La copia del código es la siguiente:
var a = function () {
var c = [];
var b = object.prototype.ToString.apply (c);
console.log (b);
}
a (); // salida [matriz de objetos]
¿Cómo se instala?
Las propiedades en el prototipo tienen constructor.
La propiedad prototipo predeterminada es un objeto de objeto que se puede establecer en cualquier valor complejo, ignore la configuración en el valor original.
Aunque es todo un objeto, es especial, y la cadena circular vincula cada instancia a la propiedad prototipo de su constructor. Hay un enlace oculto entre la instancia y el atributo prototipo del constructor, que es el __proto__ de la instancia. Al mismo tiempo, el atributo de constructor de la instancia se obtiene a través del constructor del constructor del prototipo de función del constructor.
Sin embargo, debemos retener el constructor, para que la nueva instancia pueda tener el atributo del constructor, y también podemos usar instancia para juzgar.
La copia del código es la siguiente:
var foo = function () {}
Foo.prototype = {constructor: foo}
var fooinstance = new foo;
Fooinstance .__ proto __ === foo.prototype; // verdadero
Fooinstance.constructor === foo; //verdadero
De hecho, la instancia del juicio no se basa en el constructor, sino en la cadena prototipo, como se muestra en el siguiente ejemplo
La copia del código es la siguiente:
var foo = function () {};
Foo.prototype = {};
var fooinstance = {};
Fooinstance .__ Proto __ = foo.prototype;
console.log (FooInstance instancia de foo); // Verdadero
Utilice valores originales, sin constructores
Qué valores son falsos: falsos, "", nulo, 0, -0, nan, indefinidos, estos son falsos, otros son verdaderos
Pero preste atención al siguiente ejemplo
La copia del código es la siguiente:
var a = boolean (falso);
var b = nuevo booleano ("");
if (a) {console.log (a);} // no puede salir
if (b) {console.log (b);} // boolean {[[primitiveValue]]: falso} nuevo es equivalente a un objeto, no es falso
El artículo anterior es un poco más teórico, pero estas son la base del lenguaje JavaScript, y debe entenderlo claramente.