Modificadores de Acesso em TypeScript

Os modificadores de acesso permitem ocultar o estado de um objeto do acesso externo e gerenciar o acesso a esse estado. No TypeScript, existem três modificadores: public, protected e private.

Se nenhum modificador for aplicado às propriedades e métodos das classes, essas propriedades e métodos são considerados como se fossem definidos com o modificador public. Ou seja, a seguinte definição de classe:

class Person {
  name: string;
  year: number;
}

Será equivalente a:

class Person {
  public name: string;
  public year: number;
}

private

Se o modificador private for aplicado às propriedades e métodos, não será possível acessá-los de fora ao criar um objeto dessa classe.

Por exemplo, vamos criar uma classe com propriedades e métodos privados:

class Person {
  private _name: string;
  private _year: number;

  constructor(name: string, age: number) {
    this._name = name;
    this._year = this.setYear(age);
  }

  public print(): void {
    console.log(`Nome: ${this._name}  Ano de nascimento: ${this._year}`);
  }

  private setYear(age: number): number {
    return new Date().getFullYear() - age;
  }
}

let tom = new Person("Tom", 24);
tom.print();
// console.log(tom._name); // não é possível acessar, pois _name é private
// tom.setYear(45);        // não é possível acessar, pois o método é private

As duas propriedades _name e _year são declaradas com o modificador private, portanto, não podemos usá-las fora da classe, por exemplo, em console.log(tom._name). O mesmo se aplica ao método setYear(). Os demais métodos estão disponíveis.

protected

O modificador protected define campos e métodos que são visíveis apenas em classes derivadas, não podendo ser acessados de fora da classe:

class Person {
  protected name: string;
  private year: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.year = this.setYear(age);
  }

  protected printPerson(): void {
    console.log(`Nome: ${this.name}  Ano de nascimento: ${this.year}`);
  }

  private setYear(age: number): number {
    return new Date().getFullYear() - age;
  }
}

class Employee extends Person {
  protected company: string;

  constructor(name: string, age: number, company: string) {
    super(name, age);
    this.company = company;
  }

  public printEmployee(): void {
    // console.log("Year: " + this.year); // não disponível, pois year é private
    // this.setYear(25);                  // não disponível, pois setYear é private
    this.printPerson(); // disponível, pois printPerson é protected
    console.log(`Empresa: ${this.company}`);
  }
}

let sam = new Employee("Sam", 31, "Microsoft");
sam.printEmployee();

Na classe Employee, o campo name e o método printPerson() estão disponíveis, pois possuem o modificador protected. Porém, a propriedade privada year e o método privado setYear() não estão acessíveis.

Definindo campos através do construtor

O uso de modificadores nos parâmetros do construtor permite reduzir a quantidade de código escrita. Por exemplo, suponha que temos a seguinte classe:

class Person {
  private name: string;
  private age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  printPerson(): void {
    console.log(`Nome: ${this.name}  Idade: ${this.age}`);
  }
}

Essa classe é equivalente à seguinte:

class Person {
  constructor(private name: string, private age: number) {}

  printPerson(): void {
    console.log(`Nome: ${this.name}  Idade: ${this.age}`);
  }
}

Ao usar modificadores nos parâmetros do construtor, não precisamos mais criar explicitamente propriedades para esses parâmetros. As propriedades são criadas automaticamente, recebem o nome dos parâmetros e possuem os mesmos modificadores.

Da mesma forma, se quisermos tornar as propriedades públicas, devemos usar o modificador public:

class Person {
  constructor(public name: string, public age: number) {}

  printPerson(): void {
    console.log(`Nome: ${this.name}  Idade: ${this.age}`);
  }
}

Se for necessário tornar o campo somente leitura, adiciona-se o modificador readonly ao modificador de acesso:

class Person {
  constructor(private readonly name: string, private age: number) {}
}