No JavaScript, a classe pode ser usada para implementar a programação orientada a objetos. No entanto, as classes em JavaScript são diferentes das do Java, e suas definições e usos correspondentes também são diferentes.
Definição de classes em JavaScript
No JavaScript, todos os objetos derivados do mesmo objeto de protótipo (protótipo) formam uma classe; Ou seja, as classes em JavaScript são conceitos de uma coleção de objetos. Se dois objetos tiverem o mesmo protótipo, eles pertencem à mesma classe; As classes em JavaScript nem precisam de nomes de classe. O código a seguir é um exemplo:
A cópia do código é a seguinte:
var p = {x: 42};
var a = object.create (p);
var b = object.create (p);
console.log (a === b); // false
console.log (object.getPrototypeof (a) === object.getPrototypeof (b)); // true
No exemplo acima, os objetos A e B têm o mesmo objeto de protótipo (protótipo) P, então A e B pertencem à mesma classe (embora nenhum deles tenha um nome de classe) e eles herdem a propriedade X com um valor de 42 do protótipo objeto p.
A partir deste exemplo, podemos ver que a função de um objeto de protótipo é equivalente a um modelo, e vários objetos podem ser derivados/criados dele. Seu status é o mesmo do código de classe no idioma Java e é o núcleo da definição de classe em JavaScript. O objeto de protótipo no exemplo a seguir parecerá mais como código de classe:
A cópia do código é a seguinte:
var p = {
Increment_by: 1,
incremento: função (x) {
return x + this.increment_by;
}
}
var a = object.create (p);
var b = object.create (p);
console.log (A. -InCrement (7)); // 8
console.log (b. -incremento (9)); // 10
No exemplo acima, o protótipo objeto P define uma propriedade (increment_by) com um valor de 1 e uma função chamada increment; Os objetos A e B obtêm as funções increment_by e incremento do modelo p. Ao chamar a função de incremento do objeto A ou B, o JavaScript tentará obter o valor increment_by de A ou B (this.increment_by); Como o increment_by é obtido a partir de p, seus valores são todas as variáveis 1 - com os mesmos valores, semelhantes às variáveis de classe estática em Java. Portanto, no exemplo acima, todos os caracteres de capital são usados ao nomear a variável increment_by.
No exemplo acima, todos os objetos criados a partir do modelo P (os objetos pertencentes à mesma classe) têm as mesmas propriedades e comportamento. Mas, de fato, para diferentes objetos da mesma classe, além de ter atributos/comportamentos definidos pela classe, eles geralmente têm alguns atributos e comportamentos únicos. Portanto, se você precisar usar o modelo de protótipo como classe, deve personalizar cada objeto derivado dele:
A cópia do código é a seguinte:
var p = {
Increment_by: 1,
incremento: função (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
var a = object.create (p);
var b = object.create (p);
a.custom_increment_by = 0;
b.custom_increment_by = 1;
console.log (A. -InCrement (7)); // 8
console.log (b. -incremento (9)); // 11
Neste exemplo, os objetos A e B criados a partir do modelo P têm uma variável custom_increment_by cujos valores não são necessariamente iguais um ao outro, e o resultado final de seu comportamento de função increment () está relacionado ao valor de custom_increntled_by. De um modo geral, o trabalho de personalizar novos objetos é frequentemente realizado em uma função unificada:
A cópia do código é a seguinte:
var p = {
Increment_by: 1,
incremento: função (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
função getincroMentalClassObject (customIncrementByValue) {
var incrementalobj = object.create (p);
incrementalObj.custom_increment_by = customIncrementByValue;
retornar incrementalobj;
}
var a = getIncrementalClassObject (0);
var b = getIncrementalClassObject (1);
console.log (A. -InCrement (7)); // 8
console.log (b. -incremento (9)); // 11
Dessa maneira, uma definição de classe é concluída através do protótipo Objeto P e GetincrementalClassObject () Funções: os objetos do protótipo cujos objetos de protótipo são P podem ser obtidos chamando a função GetincrementalClassObject (), e esses novos objetos podem ser personalizados para uma determinada extensão durante a chamada para o getinCrendtalClAlctJuncia (). Vale a pena notar que essa classe definida não tem um nome de classe no momento. Por uma questão de descrição, será chamado de incremental.
Olhando para o trabalho realizado na função getincrementalClassObject (), você pode ver que o processo de criação de um novo objeto a partir da classe incremental é a seguinte:
1. Crie um objeto vazio e defina seu objeto de protótipo como p.
2. Personalize esse objeto vazio recém -criado de acordo com diferentes valores de parâmetros.
3. Retorne um novo objeto que foi personalizado.
No JavaScript, você pode concluir rapidamente a definição da classe e a criação de novos objetos usando o construtor.
Construtor (construtor) em JavaScript
A partir do exemplo da classe incremental acima, podemos ver que a definição de uma nova classe requer duas partes do código: criando um objeto de protótipo como um modelo, criando uma função personalizada para inicializar o novo objeto; Criar um novo objeto de uma classe passa por três processos: especificando o protótipo objeto do novo objeto, personalizando/inicializando o novo objeto e retornando esse novo objeto. No JavaScript, tudo isso pode ser feito através do construtor (construtor).
O construtor em JavaScript é uma função que assume a responsabilidade de inicializar um novo objeto; O protótipo dessa função do construtor é usado como um modelo para criar um novo objeto. Tomando a classe incremental acima como um exemplo, depois de usar o construtor para reescrever o código, parece assim:
A cópia do código é a seguinte:
função incremental (customIncrementByValue) {
this.custom_increment_by = customIncrementByValue;
}
Incremental.prototype = {
Increment_by: 1,
incremento: função (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
var a = novo incremental (0);
var b = novo incremental (1);
console.log (A. -InCrement (7)); // 8
console.log (b. -incremento (9)); // 11
O processo de criação de um novo objeto usando a função do construtor através da nova palavra -chave realmente passa pelos seguintes estágios:
Crie um novo objeto vazio.
1. Aponte o protótipo objeto desse objeto para a propriedade do protótipo da função do construtor.
2. Use este objeto como este parâmetro e execute a função do construtor.
3. É a mesma coisa que o trabalho anterior realizado na função getincrementalClassObject ().
Nome da classe
Ao criar um objeto usando o construtor, o objeto correspondente possui um "nome da classe", que pode ser verificado a partir do resultado da instância do operador:
A cópia do código é a seguinte:
console.log (uma instância de incremental); // true
console.log (B Instância de incremental); // true
No entanto, a instância do operador não determina se o objeto é criado pelo construtor incremental. A instância do operador determina apenas se o objeto de protótipo do objeto é incremental. Quando houver dois construtores com o mesmo protótipo, o operador da instância retornará uniformemente sem distinguir qual construtor é usado para criar o objeto.
A cópia do código é a seguinte:
função incremental2 (customIncrementByValue) {
this.custom_increment_by = customIncrementByValue + 3;
}
Incremental2.prototipo = incremental.prototipo;
console.log (uma instância de incremental2); // true