Existem muitas maneiras de definir classes em JS:
1. Método da fábrica
A cópia do código é a seguinte:
function car () {
var ocar = novo objeto;
ocar.color = "azul";
ocar.Doors = 4;
ocar.showcolor = function () {
document.write (this.color)
};
retornar ocar;
}
var car1 = car ();
var car2 = car ();
Quando essa função é chamada, um novo objeto é criado e todas as propriedades e métodos são atribuídos. Use esta função para criar 2 objetos com exatamente as mesmas propriedades. Obviamente, minha irmã pode modificar esse método passando parâmetros para ele.
A cópia do código é a seguinte:
Carro de função (cor, porta) {
var ocar = novo objeto;
ocar.color = cor;
ocar.doors = porta;
ocar.showcolor = function () {
document.write (this.color)
};
retornar ocar;
}
var car1 = carro ("vermelho", 4);
var car2 = carro ("azul", 4);
car1.showcolor () // saída: "vermelho"
car2.showcolor () // saída: "azul"
Agora você pode obter objetos com valores diferentes passando parâmetros diferentes para a função.
No exemplo anterior, cada vez que o carro da função () é chamado, o showColor () é criado, o que significa que cada objeto possui seu próprio método ShowColor ().
Mas, de fato, cada objeto compartilha a mesma função.
Embora um método possa ser definido fora da função, apontando as propriedades da função para o método.
A cópia do código é a seguinte:
Função ShowColor () {
alerta (this.color);
}
function car () {
var ocar = new Object ();
ocar.color = cor;
ocar.doors = porta;
ocar.showcolor = showColor;
retornar ocar;
}
Mas isso não parece um método de função.
2. Método construtor
O método construtor é tão simples quanto o método da fábrica, como mostrado abaixo:
A cópia do código é a seguinte:
Carro de função (cor, porta)
Você pode ver que o método do construtor não cria objetos dentro da função e a palavra -chave que é usada. Porque um objeto foi criado ao chamar o construtor, e isso só pode ser usado para acessar as propriedades do objeto dentro da função.
Agora use novo para criar objetos, parece assim! Mas é o mesmo que a fábrica. Cada chamada cria seu próprio método para o objeto.
3. Método do protótipo
Este método aproveita o atributo protótipo do objeto. Primeiro, crie o nome da classe com uma função vazia e, em seguida, todos os atributos e métodos são atribuídos ao atributo do protótipo.
A cópia do código é a seguinte:
Carro de função ()
Neste código, uma função vazia é definida pela primeira vez e, em seguida, as propriedades do objeto são definidas através do atributo protótipo. Quando essa função é chamada, todas as propriedades do protótipo serão atribuídas ao objeto a ser criado imediatamente. Todos os objetos nesta função armazenam ponteiros para exibir (), que sintaticamente parece pertencer ao mesmo objeto.
No entanto, essa função não possui parâmetros e o atributo não pode ser inicializado pela passagem de parâmetros. O valor padrão do atributo deve ser alterado após a criação do objeto.
Um problema muito sério com o método do protótipo é que quando o atributo aponta para um objeto, como uma matriz.
A cópia do código é a seguinte:
function car () {
}
Car.prototype.color = "vermelho";
Car.prototype.doors = 4;
Car.prototype.arr = new Array ("A", "B");
Car.prototype.showcolor = function () {
alerta (this.color);
}
var car1 = novo carro ();
var car2 = novo carro ();
car1.arr.push ("cc");
alerta (car1.arr); // Saída: AA, BB, CC
alerta (car2.arr); // Saída: AA, BB, CC
Aqui, devido ao valor de referência da matriz, ambos os objetos do carro apontam para a mesma matriz; portanto, quando o valor é adicionado no CAR1, você também pode vê -lo no CAR2.
Union é um método que pode criar objetos como outras linguagens de programação usando o construtor/protótipo. É um método que usa construtores para definir propriedades não funcionais de objetos e usa protótipos para definir objetos.
A cópia do código é a seguinte:
Carro de função (cor, porta) {
this.color = cor;
this.Doors = Door;
this.arr = new Array ("AA", "BB");
}
Car.prototype.showcolor () {
alerta (this.color);
}
var car1 = novo carro ("vermelho", 4);
var car2 = novo carro ("azul", 4);
car1.arr.push ("cc");
alerta (car1.arr); // Saída: AA, BB, CC
alerta (car2.arr); // saída: aa, bb
4. Método de protótipo dinâmico
O método de protótipo dinâmico é semelhante ao método de construtor/protótipo misto. A única diferença é a posição dada ao método do objeto.
A cópia do código é a seguinte:
Carro de função (cor, porta) {
this.color = cor;
this.Doors = Door;
this.arr = new Array ("AA", "BB");
if (typeof car._initialized == "indefinido") {
Car.prototype.showcolor = function () {
alerta (this.color);
};
Car._initialized = true;
}
}
O método de protótipo dinâmico é usar um sinalizador para determinar se o protótipo foi atribuído um método. Isso garante que o método seja criado apenas uma vez
6. Método de fábrica mista
Seu professor de propósito cria um construtor falso que retorna apenas novas instâncias de outro objeto.
A cópia do código é a seguinte:
function car () {
var ocar = new Object ();
ocar.color = "vermelho";
ocar.Doors = 4;
ocar.showcolor = function () {
alerta (this.color)
};
retornar ocar;
}
Ao contrário do método da fábrica, esse método usa o novo operador.
PS (entendimento pessoal):
1) Os membros (métodos ou atributos) definidos pela classe através do protótipo são compartilhados por cada objeto de classe. Eles geralmente não são usados para definir atributos de membros. Se um objeto modificar o valor do atributo, todos os objetos serão modificados;
2) A classe possui um atributo de protótipo, mas o objeto de classe não;
3) Sempre que um novo objeto de classe ou classe é chamado diretamente (o seguinte formulário de método de fábrica), a afirmação que define a classe (função) será executada uma vez (o padrão Singleton pode evitar essa situação);
4) A classe é o tipo de função, o objeto de classe é o tipo de objeto e apenas o tipo de função é o atributo de protótipo;
5) O método definido pelo protótipo não pode acessar as variáveis privadas da classe (variáveis locais definidas pela classe), mas as propriedades do membro e os métodos de membros da classe (variáveis e métodos definidos por isso) podem ser acessados por isso;
6) Como definir uma classe:
um. Método da fábrica (objeto)
B. Método de Heritância (protótipo)
C. Método do Construtor (isto)
d. Método misto
7) [Pergunta] Por que os atributos definidos através do protótipo podem ser alterados através de algum objeto? Os atributos definidos no método do construtor pertencem apenas ao objeto e não afetarão os valores do atributo de outros objetos?
Os acima são todos os métodos de criação de objetos. O método mais utilizado é o método do construtor/protótipo híbrido, e o método de protótipo dinâmico também é muito popular. Funcionalmente equivalente ao método construtor/protótipo.