Exemplos explicam o uso do operador da instância em JavaScript

Introdução à instância do operador

No JavaScript, julgando o tipo de variável, você usará o operador TIPEOF. Ao usar o operador TIPOOF, você terá um problema em usar um tipo de referência para armazenar o valor. Não importa que tipo de objeto seja referenciado, ele retornará "objeto". O ECMAScript apresenta outra instância do operador Java para resolver esse problema. A instância do operador é semelhante ao operador TIPOOF e é usado para identificar o tipo de objeto que está sendo processado. Ao contrário do método TIPOOF, o método da instância do desenvolvedor exige que o objeto seja explicitamente um tipo específico. Por exemplo:

Listagem 1. Instância de exemplo

 var ostringObject = new String ("Hello World"); console.log (OSTRINGOBJECT INSTEAFOF STRING); // saída "true"

Este código pergunta "A variável OstringObject é uma instância do objeto String?" OstringObject é realmente uma instância do objeto String, portanto o resultado é "verdadeiro". Embora não seja tão flexível quanto o método TIPOOF, a instância do método é útil quando o método TypeOf retorna "objeto".

Uso geral do Operador de Instância de:

De um modo geral, o uso de instância é determinar se uma instância pertence a um determinado tipo. Por exemplo:

Listagem 2. Uso geral de instância

 // Determine se Foo é uma instância da classe Foo function foo () {} var foo = new Foo (); console.log (Foo Instância de foo) // true

Além disso, um ponto mais mais pesado é que a instância de pode ser usada nas relações de herança para determinar se uma instância pertence ao seu tipo pai. Por exemplo:

Listagem 3. Uso de instância em relacionamentos de herança

 // Determine se o Foo é uma instância da classe Foo e se é uma instância de sua função do tipo pai () {} function foo () {} foo.prototype = new aoo (); // herança protótipo de javascript var foo = new foo (); console.log (Foo Instância de Foo) // True Console.log (Foo Instância de Aoo) // true

No código acima, a classe pai em uma camada de relacionamento de herança é julgada. Na relação de herança de várias camadas, a instância do operador também é aplicável.

Você realmente entende a instância do operador?

Depois de ler o exemplo de código acima, você acha que o operador da instância é muito simples? Vamos dar uma olhada em algum uso complicado.

Listagem 4. Instância de uso complexo

 console.log (instância do objeto de objeto); // True Console.log (função da functionof); // True Console.log (número da instância do número); // false console.log (string instanceof string); // false console.log (function Instância do objeto);

Você está confuso novamente depois de ler o código acima? Por que o objeto e a função de si próprio é igual a verdade, enquanto outros não são verdadeiros verdadeiros? Como explicar isso? Para entender fundamentalmente o mistério do exemplo, precisamos começar de dois aspectos: 1. Como definir esse operador na especificação do idioma. 2. Mecanismo de herança do protótipo JavaScript.

Listagem 5. JavaScript Instância do código do operador

 function instance_of (l, r) {// l representa a expressão esquerda, r representa a expressão direita var o = r.prototype; // pegue o protótipo de exibição de r l = l .__ proto __; // pegue o protótipo implícito de l while (true) {if (l ==== null) retorn; if (o === l) // aqui está o ponto: quando o é estritamente igual a l, retorne true; L = l .__ proto__; }}

Listagem 6. Instância do objeto de objeto

 // Por uma questão de conveniência de expressão, primeiro distingue entre a expressão esquerda e a expressão direita objeto = objeto, object = objeto; // O seguinte é gradualmente deduzir o = object.prototype = object.prototype l = objectl .__ proto__ = function.prototype // O primeiro julgamento é o! = L // loop para descobrir se L ainda tem __proto__ l = função.prototipo .__ proto__ = objeto.Protype //

Listagem 7. Função da funçãof Função

 // Por uma questão de conveniência de expressão, primeiro distingue entre a expressão esquerda e a expressão direita functionl = functionl, functionr = function; // o seguinte é deduzir gradualmente o = functionr.prototype = function.prototype l = functionl .__ proto__ = function.prototype // o primeiro julgamento o == l // retorna true true

Listagem 8. FOO Instância de Foo

 // Por uma questão de conveniência de expressão, primeiro distingue entre a expressão esquerda e a expressão direita tolo = foo, foor = foo; // o seguinte é deduzir gradualmente de acordo com as especificações o = foor.prototype = foo.prototipo l = tolo .__ proto__ = function.prototype // O primeiro julgamento é o! = L // o primeiro julgamento é o! // O ciclo é descobrir se L ainda possui __proto__ l = object.prototype .__ proto__ = null // o terceiro julgamento l == null // retorna false

Analise brevemente a aplicação de instância do mecanismo de herança do dojo

Em JavaScript, não há conceito de herança múltipla, assim como Java. No entanto, ao declarar classes em Dojo, é permitida a herança de várias classes. Vamos tomar o dojo 1.6.1 como exemplo.

Listagem 9. Herança múltipla em dojo

 dojo.declare ("AOO", null, {}); dojo.declare ("boo", null, {}); dojo.declare ("foo", [aoo, boo], {}); var foo = new Foo (); console.log (fao instância de aoo); // true console.log (fao instanceof boo); // false console.log (foo.isinsinStanceof (aoo)); // true console.log (foo.isinStancef (boo);

No exemplo acima, o Foo herda do AOO e do Boo, mas ao usar o operador da instância para verificar se o Foo é uma instância de boo, ele retorna false. De fato, dentro do dojo, o Foo ainda herda apenas do AOO e usa o mecanismo de mixin para copiar os métodos e propriedades na classe Boo para foo. Portanto, quando a instância do operador é usada para verificar se é uma instância de boo, False será retornado. Então, o Dojo adiciona um novo método chamado ISinstanceOF para cada instância da classe e usa esse método para verificar várias heranças.