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) {
this.color = cor;
this.Doors = Door;
this.showcolor = function () {
alerta (this.color)
};
}
var car1 = novo carro ("vermelho", 4);
var car2 = novo carro ("azul", 4);
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, usando o 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:
function car () {
}
Car.prototype.color = "vermelho";
Car.prototype.doors = 4;
Car.prototype.showcolor = function () {
alerta (this.color);
}
var car1 = novo carro ();
var car2 = novo carro ();
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
5. 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.
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.
O exposto acima é tudo sobre este artigo, espero que gostem.