Classes TypeScript: como defini-las e utilizá-las
As classes do TypeScript oferecem uma forma clara e estruturada de organizar dados e comportamentos dentro de um objeto. Dessa forma, é possível modelar entidades e conceitos no código de maneira mais fácil e compreensível.
Para que servem as aulas de TypeScript?
As classes são fundamentais na linguagem de programação TypeScript, que é baseada em JavaScript. Elas fornecem um método estruturado para definir objetos e aplicar a programação orientada a objetos (OOP). As classes do TypeScript são como uma espécie de planos para a criação de objetos, que agrupam dados e métodos relacionados de maneira lógica.
O TypeScript contém todas as funções do JavaScript e inclui tipagem estática, o que permite especificar tipos de dados para funções no TypeScript, variáveis e classes, bem como detectar erros em tempo de compilação. Além da segurança de tipos, as classes do TypeScript também suportam conceitos como herança e abstração, o que facilita o desenvolvimento de aplicações complexas.
As classes do TypeScript permitem estabelecer uma hierarquia clara de classes que herdam propriedades e métodos. Isso incentiva a reutilização e a estruturação do código. Os construtores nas classes possibilitam a inicialização de instâncias e garantem uma criação de objetos consistente.
A sintaxe das classes do TypeScript
A sintaxe das classes no TypeScript é semelhante à do ECMAScript 6 (ES6) e é uma versão ampliada da sintaxe das classes do JavaScript. Uma classe pode conter vários elementos para definir a estrutura e o comportamento dos objetos. Estes são os seus principais componentes:
- Propriedades,
- construtor e
- métodos.
Propriedades
As propriedades ou properties determinam o estado de um objeto. Elas armazenam valores de dados e podem ser anotadas com tipos de dados para garantir que contenham apenas valores válidos.
class ClassName {
propertyName: propertyType;
}- ClassName: o nome da classe.
- propertyName: o nome da propriedade que pretende definir.
- propertyType: o tipo de dados da propriedade.
Veja este exemplo:
class Person {
name: string;
}Primeiro, define-se uma classe chamada Person (pessoa) com uma propriedade denominada name (nome) do tipo string. Isso significa que as instâncias da classe Person têm uma propriedade name que armazena cadeias de texto (strings).
Construtor
O construtor em TypeScript é um método especial que é chamado ao criar uma instância (um objeto) de uma classe. Ele é usado para inicializar as propriedades (properties) de um objeto. Basicamente, o construtor define o estado inicial de uma instância. Você pode especificar parâmetros no construtor para passar valores ao instanciar classes de TypeScript.
A estrutura básica de um construtor em TypeScript tem a seguinte aparência:
class ClassName {
constructor(parameter1: Type1, parameter2: Type2, ...) {
}
}- construtor: cada classe pode ter apenas um construtor. Se nenhum for definido, um construtor vazio é criado por padrão.
- parâmetro: Tipo: os parâmetros podem ser necessários ou não, dependendo do que a classe precisa fazer. É útil indicar que tipo de dados se espera para cada parâmetro.
Aqui apresentamos um exemplo de construtor:
class Person {
firstName: string;
lastName: string;
constructor(firstName: string, lastName: string) {
this.firstName = firstName;
this.lastName = lastName;
}
}No exemplo anterior, a classe Person tem um construtor que aceita dois parâmetros: firstName (nome) e lastName (sobrenome). Ao criar uma instância dessa classe, esses parâmetros são passados e o construtor inicializa as propriedades firstName e lastName da instância com os valores correspondentes. A palavra-chave this refere-se à instância atual da classe na qual o código está a ser executado.
Métodos
Em TypeScript, os métodos são funções que podem ser definidas nas classes e aplicadas às suas instâncias. Com eles, é possível realizar determinadas ações ou operações no contexto de uma classe.
class ClassName {
// ...
methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType {
}
// ...
}- methodName: nome do método.
- parameter: Tipo: parâmetros opcionais que o método aceita.
- ReturnType: é o tipo de dados que determina qual valor o método retorna. Se o método não retorna nada, pode especificar
void.
Para chamar uma propriedade ou um método numa instância de uma classe, utilize o operador ponto . seguido do nome do método e dos argumentos necessários, se o método esperar parâmetros.
class Person {
firstName: string;
lastName: string;
constructor(firstName: string, lastName: string) {
this.firstName = firstName;
this.lastName = lastName;
}
getFullName(): string {
return this.firstName + " " + this.lastName;
}
}
const person = new Person("John", "Doe");
const fullName = person.getFullName();O método getFullName serve para criar o nome completo da pessoa e devolvê-lo. Recorre aos valores das propriedades firstName e lastName que foram definidas na classe e inicializadas no construtor. O objeto person é gerado utilizando a palavra-chave new seguida do nome da classe e dos parâmetros correspondentes. Quando o método é chamado, ele concatena as duas cadeias e retorna o nome completo como uma cadeia ou string. Portanto, a saída para o objeto person é “John Doe”.
Exemplos de aplicação das classes do TypeScript
As classes do TypeScript têm vários mecanismos para organizar e controlar a estrutura e o comportamento dos objetos. A seguir, apresentamos alguns conceitos para sua utilização.
Visibilidade
A visibilidade nas classes do TypeScript controla o acesso às propriedades e métodos dentro e fora da classe. O TypeScript fornece três modificadores de visibilidade: public, private e protected.
- público (padrão): as propriedades e métodos marcados com
publicpodem ser chamados de qualquer lugar, tanto dentro como fora da classe. - private: refere-se a propriedades e métodos que só podem ser chamados dentro da própria classe. São inacessíveis para partes de código externas.
- protected: as propriedades e métodos marcados com
protectedpodem ser chamados pela própria classe e pelas classes derivadas (por herança), mas não por código externo.
class Person {
private socialSecurityNumber: string;
constructor(ssn: string) {
this.socialSecurityNumber = ssn;
}
greet() {
console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber);
}
}
const person = new Person("123-45-6789");
person.greet();No exemplo anterior, socialSecurityNumber (número da Segurança Social) é uma propriedade privada que só pode ser acedida dentro da classe Person. Em contrapartida, o método greet pode ser chamado a partir do exterior.
Herencia
A herança é um conceito fundamental na programação orientada a objetos (POO) que é usado no TypeScript e em muitas outras linguagens de programação web. Ela permite criar uma nova classe a partir de uma classe base ou superclasse existente. A classe derivada (subclasse) herda as propriedades e métodos da classe base e pode ampliá-los ou adaptá-los.
class Animal {
name: string;
constructor(name: string) {
this.name = name;
}
makeSound() {
console.log("Some generic sound");
}
}
class Dog extends Animal {
makeSound() {
console.log(this.name + " barks");
}
}
const myDog = new Dog("Buddy");
myDog.makeSound();No código anterior, a classe Dog (cão) herda da classe base Animal utilizando a palavra-chave extends. A classe derivada Dog sobrescreve o método makeSound para adicionar um comportamento específico enquanto assume a propriedade name de Animal.
Somente leitura
Ao utilizar a palavra-chave readonly, pode declarar propriedades das classes TypeScript ou objetos como somente leitura. Isso significa que, uma vez que uma propriedade é inicializada como somente leitura, o seu valor não poderá ser alterado posteriormente.
class Circle {
readonly pi: number = 3.14159;
radius: number;
constructor(radius: number) {
this.radius = radius;
}
getArea() {
return this.pi *this.radius* this.radius;
}
}
const myCircle = new Circle(5);
console.log(myCircle.getArea()); // Output: ≈ 78,54Neste exemplo, a propriedade pi é somente leitura e é inicializada no construtor. Após a inicialização, pi não pode ser modificada. Se você tentar modificar o valor de pi após a inicialização, o TypeScript gerará um erro de compilação.