Funções Construtoras de Objetos - JavaScript

Além de criar novos objetos, o JavaScript nos oferece a possibilidade de criar novos tipos de objetos usando funções especiais chamadas construtoras. Um construtor permite definir um novo tipo de objeto. A definição de tipo pode incluir a função construtora, métodos e propriedades.

Primeiramente, vamos definir um construtor:

function Person(pName, pAge) {
    this.name = pName;
    this.age = pAge;
    this.print = function() {
        console.log("Name: ", this.name);
        console.log("Age: ", this.age);
    };
}

Um construtor é uma função comum, exceto pelo fato de que podemos estabelecer propriedades e métodos usando a palavra-chave this:

this.name = pName;

Neste caso, duas propriedades (nome e idade) e um método (imprimir) são definidos.

Geralmente, os nomes dos construtores começam com uma letra maiúscula, ao contrário dos nomes de funções comuns.

Após isso, no programa, podemos definir um objeto do tipo Person e usar suas propriedades e métodos:

// definição do construtor do tipo Person
function Person(pName, pAge) {
    this.name = pName;
    this.age = pAge;
    this.print = function() {
        console.log(`Name: ${this.name}  Age: ${this.age}`);
    };
}

// criação de um objeto do tipo Person
const tom = new Person("Tom", 39);
// acessando a propriedade do objeto
console.log(tom.name); // Tom
// acessando o método do objeto
tom.print();    // Name: Tom  Age: 39

Para chamar o construtor, ou seja, criar um objeto do tipo Person, deve-se usar a palavra-chave new:

const tom = new Person("Tom", 39);

Depois, através do nome do objeto, pode-se acessar suas propriedades e métodos, que são definidos dentro da função construtora.

Vale mencionar que poderíamos definir um objeto de maneira padrão:

const tom = {
    name: "Tom",
    age: 39,
    print: function() {
        console.log(`Name: ${this.name}  Age: ${this.age}`);
    }
};

No entanto, o uso de funções construtoras facilita a criação repetida de objetos semelhantes que possuem o mesmo conjunto de propriedades e métodos, ou seja, estamos definindo um novo tipo de objetos. Por exemplo:

function Person(pName, pAge) {
    this.name = pName;
    this.age = pAge;
    this.print = function() {
        console.log(`Name: ${this.name}  Age: ${this.age}`);
    };
}
const tom = new Person("Tom", 39);
const bob = new Person("Bob", 43);
const sam = new Person("Sam", 28);

tom.print();    // Name: Tom  Age: 39
bob.print();    // Name: Bob  Age: 43
sam.print();    // Name: Sam  Age: 28

Objetos desse tipo também podem ser passados para funções ou retornados de funções, podem atuar como propriedades de outros objetos, podem ser armazenados em arrays, etc. Por exemplo:

function printPersonName(person) {
    console.log(person.name);
}
// array com três objetos Person
const people = [new Person("Tom", 39), new Person("Bob", 43), new Person("Sam", 28)];

for (person of people) {
    printPersonName(person);
}

Operador instanceof

O operador instanceof permite verificar através de qual construtor um objeto foi criado. Se o objeto foi criado usando um determinado construtor, o operador retorna true:

function Person(pName, pAge) {
    this.name = pName;
    this.age = pAge;
    this.print = function() {
        console.log(`Name: ${this.name}  Age: ${this.age}`);
    };
}

function Employee(eName, eCompany) {
    this.name = eName;
    this.company = eCompany;
    this.print = function() {
        console.log(`Name: ${this.name}  Company: ${this.company}`);
    };
}

const tom = new Person("Tom", 39); 
const bob = new Employee("Bob", "Google");

console.log(tom instanceof Person);       // true - Tom é um objeto do tipo Person
console.log(bob instanceof Employee);     // true - Bob é um objeto do tipo Employee
console.log(tom instanceof Employee);     // false - Tom NÃO é um objeto do tipo Employee