p>JavaScript é um protótipo-linguagem baseada. Vamos desconstruir a definição de protótipos em JavaScript.
Quando se começa a aprender programação orientada a objectos com JavaScript, rapidamente se encontrará a herança de protótipos.
Um protótipo é um membro de um objecto, e pode ser referenciado a partir de uma instância. Antes de criarmos o nosso próprio protótipo. Vamos apenas ver um exemplo rápido de como já estamos a lidar com protótipos.
Vamos criar um array:
let x =
x.map(a => a + 1) //
x detém um array. x é uma instância de Array. x tem uma referência a todas as propriedades do protótipo de Array. Por exemplo, poderíamos chamar a função Array.prototype.map() em x
p>p> Começo a ver protótipos em todo o lado!
Vamos definir o nosso próprio protótipo:
// Creates a constructor called Country
class Country {
constructor(country) {
this.country = country
}
}// Create a new instance of Country
let sweden = new Country('Sweden')// sweden is now an object called Country
sweden // Country { country: 'Sweden' }
Agora queremos que a Suécia diga olá ao mundo. É aqui que os protótipos e a cadeia de protótipos entram em jogo
// Add method to the prototype of the constructor
Country.prototype.helloWorld = function() {
return `I am a country called ${this.country}`
}
O país tem o método helloWorld como propriedade protótipo. a suécia continua a ser o mesmo objecto, mas agora podemos fazer referência ao helloWorld.
sweden.helloWorld() // 'I am a country called Sweden'
O intérprete procura o helloWorld Se não forem encontradas referências, começará a saltar a cadeia do protótipo até que o pedido seja satisfeito. Neste caso, o helloWorld pode ser relacionado com a suécia através da cadeia do protótipo.
E se criarmos um novo país:
let canada = new Country('Canada')
O mesmo se aplica ao Canadá, a nova instância de País também pode aceder aos protótipos. É assim que funciona um protótipo e a cadeia de protótipos. Funciona como um elo entre a função e os seus objectos.
Quero partilhar o meu protótipo de construtores com outro construtor?
Vamos dizer que queremos adicionar o objecto protótipo PlanetA a PlanetB
// Constructor PlanetA
class PlanetA {
constructor(instance) {
this.instance = instance
}
// prototype method
helloWorld() {
return `I am a instance called ${this.instance}`
}
}let x = new PlanetA('x')x.helloWorld() // I am a instance called x
Para demonstrar a flexibilidade da herança protótipo, ligaremos os protótipos da nossa instância de PlanetA a PlanetB. Podemos usar Object.setPrototypeOf() para fazer isso.
// Constructor PlanetB
class PlanetB {
constructor(instance) {
this.instance = instance
}
}let y = new PlanetB('y')Object.setPrototypeOf(y, x)y.helloWorld() // I am a instance called y
Esta foi uma introdução básica ao conceito de herança em JavaScript. A chave é saber que tem a capacidade de dinamizar objectos instanciados sem quaisquer propriedades internas, mas que ainda assim pode aceder a métodos na cadeia de protótipos.
Há mais detalhes sobre protótipos e formas de lidar com a herança em JavaScript, dependendo de como opta por factorar os seus objectos. A palavra-chave ‘classe’ é açúcar sintáctico sobre funções de construtor. Não existe tal coisa como herança de classe em JavaScript apenas uma forma protótipo de herança.
Espero que tenha achado isto útil e que agora possa sentir-se mais confortável a falar sobre protótipos e como funciona o OOP em JavaScript.
Desfrute do seu código.