Existem 5 valores originais em JS, 6 tipos de julgamento e 9 construtores internos nativos.
Este 569 forma a base do idioma JS.
Os 5 valores originais são: números, caracteres, booleanos, nulos, indefinidos
O tipo de pode julgar: números, caracteres, booleanos, objeto, função, indefinido. Observe que nulo e matrizes, digite o objeto de saída.
O TypeOf não pode distinguir matrizes e objetos. Como julgar os tipos? Use object.prototype.toString.apply ().
if (value && typeof value === 'object' && value.constructor === Array)
Se a detecção acima for criada em diferentes quadros e janelas, false será fornecido e o objeto da janela será diferente.
Um método confiável é se (object.prototype.ToString.Apply (Value) === "[Array do objeto]")
A matriz de argumentos não é uma matriz, é apenas um objeto com um atributo de membro do comprimento.
Como mostrado no exemplo a seguir, os argumentos não são matrizes comuns
A cópia do código é a seguinte:
var a = function () {
var b = object.prototype.toString.Apply (Argumentos);
console.log (b);
}
a (); // saída [argumentos do objeto]
A cópia do código é a seguinte:
var a = function () {
var c = [];
var b = object.prototype.toString.Apply (c);
console.log (b);
}
a (); // saída [matriz de objeto]
Como a instância determina se uma instância é uma instância
As propriedades no protótipo têm construtor.
A propriedade Prototype padrão é um objeto que pode ser definido como qualquer valor complexo, ignore a configuração no valor original.
Embora ele seja um objeto, ele é especial e a cadeia circular liga cada instância à propriedade do protótipo de seu construtor. Existe um link oculto entre a instância e o atributo de protótipo do construtor, que é o __proto__ da instância. Ao mesmo tempo, o atributo construtor da instância é obtido através do construtor do construtor do protótipo da função do construtor.
No entanto, devemos manter o construtor, para que a nova instância possa ter o atributo do construtor e também podemos usar a instância para julgar.
A cópia do código é a seguinte:
var foo = function () {}
Foo.prototype = {construtor: foo}
var fooInstance = novo Foo;
FooInstance .__ proto __ === foo.prototype; // true
FooInstance.Constructor === Foo; //verdadeiro
De fato, o exemplo do julgamento não se baseia no construtor, mas na cadeia de protótipo, como mostrado no exemplo a seguir
A cópia do código é a seguinte:
var foo = function () {};
Foo.prototype = {};
var fooInstance = {};
FooInstance .__ proto __ = foo.prototype;
console.log (instância fooInstanceOf foo); // true
Use valores originais, sem construtores
Quais valores são falsos: falsos, "", nulo, 0, -0, nan, indefinido, estes são falsos, outros são verdadeiros
Mas preste atenção ao exemplo a seguir
A cópia do código é a seguinte:
var a = booleano (falso);
var b = novo booleano ("");
if (a) {console.log (a);} // não puder sair
if (b) {console.log (b);} // boolean {[[primitivoValue]]: false} novo é equivalente a um objeto, não é falso
O artigo acima é um pouco mais teórico, mas essa é a base para a linguagem JavaScript, e você deve entendê -lo claramente.