Sabemos que o JS é orientado a objetos. Quando se trata de orientação para objetos, é inevitável envolver o conceito de classes. Geralmente, idiomas fortemente digitados como C# e Java fixam sintaxe para definir classes. A diferença entre JS é que ele pode usar vários métodos para implementar suas próprias classes e objetos. Existem vários métodos gerais de implementação:
1. Método da fábrica
O método da fábrica refere -se à criação de uma função de fábrica que retorna um tipo de objeto específico.
A cópia do código é a seguinte:
Função CreateCar (Scolor, Idoors, IMPG)
{
var otempcar = novo objeto;
otempcar.color = scolor;
otempcar.doors = iDoors;
otempcar.mpg = impg;
otempcar.showcolor = function ()
{
alerta (this.color);
}
retornar otempcar;
}
var ocar1 = createCar ("vermelho", 4,23);
var ocar2 = createCar ("azul", 3,25);
ocar1.showcolor ();
ocar2.showcolor ();
Dessa forma, toda vez que chama sua função de fábrica, um novo objeto será criado. Mas o problema é que, toda vez que um novo objeto é gerado, uma nova função é criada, o que faz com que cada objeto tenha sua própria versão do ShowColor e, de fato, todos os objetos compartilham a mesma função. é o método do objeto é definido fora da função da fábrica e, em seguida, o objeto recebe um ponteiro para a função, como segue
A cópia do código é a seguinte:
Função ShowColor ()
{
alerta (this.color);
}
Função CreateCar (Scolor, Idoors, IMPG)
{
var otempcar = novo objeto;
otempcar.color = scolor;
otempcar.doors = iDoors;
otempcar.mpg = impg;
otempcar.showcolor = showColor;
retornar otempcar;
}
var ocar1 = createCar ("vermelho", 4,23);
var ocar2 = createCar ("azul", 3,25);
ocar1.showcolor ();
ocar2.showcolor ();
Dessa forma, não há necessidade de criar sua própria função de exibição para cada objeto, mas apenas criar um ponteiro para essa função. Portanto, o método do construtor é introduzido.
2. Método construtor
O construtor é muito semelhante à função de fábrica, o código de exemplo é o seguinte:
A cópia do código é a seguinte:
Carro de função (Scolor, Idoors, IMP)
{
this.color = scolor;
this.Doors = Idoors;
this.mpg = impg;
this.showcolor = function ()
{
alerta (this.color);
}
}
var ocar1 = novo carro ("vermelho", 4,23);
var ocar2 = novo carro ("azul", 3,25);
No construtor, não há objeto criado internamente, mas a palavra -chave que é usada. Ao chamar o construtor usando o novo operador, um objeto é criado antes de executar a primeira linha de código. Mas que problemas acontecerão com isso? Obviamente, cada objeto também criará sua própria versão da função Showcolor. Para resolver esse problema, foi introduzido o seguinte método de protótipo.
3. Método do protótipo
Este método aproveita a propriedade do protótipo do objeto, que pode ser considerado como o protótipo do qual um novo objeto depende. Aqui, use o construtor vazio para definir o nome da classe. Em seguida, todos os métodos e atributos são atribuídos diretamente ao atributo do protótipo. do seguinte modo:
A cópia do código é a seguinte:
Carro de função ()
{}
Car.prototype.color = "vermelho";
Car.prototype.doors = 4;
Car.prototype.mpg = 23;
Car.prototype.drivers = new Array ("Mike", "Sue");
Car.prototype.showcolor = function ()
{
alerta (this.color);
}
O método do protótipo pode atribuir apenas valores diretamente e não pode passar parâmetros ao construtor o valor da inicialização do atributo. Ao usar esse método, você encontrará dois problemas. O primeiro problema é que cada objeto deve ser criado antes que o valor padrão do atributo possa ser alterado dessa maneira. Não é possível ter diretamente os valores da propriedade que você precisa ao criar cada objeto. Isso é irritante. O segundo problema é quando o atributo se refere ao objeto. Não haverá problemas com o compartilhamento de funções, mas haverá problemas com o compartilhamento de objetos. Porque cada instância geralmente precisa implementar seu próprio objeto.
Do seguinte modo:
A cópia do código é a seguinte:
var ocar1 = novo carro ();
var ocar2 = novo carro ();
ocar1.drivers.push ("Matt");
alerta (Ocar1.Drivers); // Saída "Mike, Sue, Matt"
alerta (Ocar2.Drivers); // Saída "Mike, Sue, Matt"
Portanto, o atributo Drivers é apenas um ponteiro para o objeto; portanto, todas as instâncias compartilham o mesmo objeto. Devido a esses problemas, introduzimos o seguinte método de construtor de uso conjunto e protótipo.
4. Método de construtor/protótipo misto
A idéia desse método é usar um construtor para definir todas as propriedades não funcionais de um objeto (incluindo propriedades e atributos ordinários apontando para o objeto) e usar um protótipo para definir as propriedades da função (métodos) de um objeto. O resultado é que todas as funções são criadas apenas uma vez e cada objeto tem sua própria instância de atributo de objeto. O código de amostra é o seguinte:
A cópia do código é a seguinte:
Carro de função (Scolor, Idoors, IMP)
{
this.color = scolor;
this.Doors = Idoors;
this.mpg = impg;
this.drivers = new Array ("Mike", "Sue");
}
Car.prototype.showcolor = function ()
{
alerta (this.color);
}
var ocar1 = novo carro ("vermelho", 4,23);
var ocar2 = novo carro ("azul", 3,25);
ocar1.drivers.push ("Matt");
alerta (Ocar1.Drivers); // Saída "Mike, Sue, Matt"
alerta (Ocar2.Drivers); // Saída "Mike, Sue"
Como pode ser visto no código de exemplo, esse método resolve dois problemas no método anterior ao mesmo tempo. No entanto, dessa maneira, alguns desenvolvedores ainda sentem que não é perfeito.
5. Método de protótipo dinâmico
Podemos ver que a maioria dos idiomas orientados a objetos encapsulam visualmente propriedades e métodos. No entanto, o método mostrando o método acima é definido fora da classe. Portanto, eles projetaram uma abordagem de protótipo dinâmico. A idéia básica dessa abordagem é a mesma que a abordagem de construtor/protótipo misto, a única diferença é a localização do método do objeto. Como mostrado abaixo:
A cópia do código é a seguinte:
Carro de função (Scolor, Idoors, IMP)
{
this.color = scolor;
this.Doors = Idoors;
this.mpg = impg;
this.drivers = new Array ("Mike", "Sue");
if (typeof car._initialized == "indefinido")
{
Car.prototype.showcolor = function ()
{
alerta (this.color);
}
}
Car._initialized = true;
}
Dessa forma, car.prototype.showcolor é criado apenas uma vez. Essa dependência torna esse código mais parecido com a definição de classe em outros idiomas.
6. Método de fábrica mista
Essa abordagem geralmente é uma solução alternativa que não pode ser usada como a abordagem anterior. Seu objetivo é criar um construtor falso que retorne apenas novas instâncias de outro objeto.
A cópia do código é a seguinte:
função createCar ()
{
var otempcar = novo objeto;
otempcar.color = "vermelho";
otempcar.doors = 4;
otempcar.mpg = 23;
otempcar.showcolor = function ()
{
alerta (this.color);
};
retornar otempcar;
}
var carro = novo carro ();
Como o novo operador é chamado Inside the Car () construtor, o segundo novo operador é automaticamente ignorado. Os objetos criados dentro do construtor são transmitidos de volta à variável var. Essa abordagem tem os mesmos problemas que a abordagem clássica em termos de gerenciamento interno de métodos de objetos. Portanto, é altamente recomendado: evite usar esse método, a menos que seja absolutamente necessário.