As variáveis no TypeScript são fundamentais para qualquer desenvolvedor que deseja criar aplicações seguras e eficientes. Neste post, você aprenderá como declarar, inicializar e utilizar variáveis para melhorar a qualidade do seu código.
O que são Variáveis em TypeScript?
Em TypeScript, uma variável é utilizada para armazenar valores que podem ser manipulados durante a execução do programa. Diferente do JavaScript, o TypeScript é um superset que adiciona tipos ao JavaScript, promovendo um código mais robusto e menos propenso a erros. Declarar variáveis corretamente é crucial para garantir o bom funcionamento e a manutenibilidade do seu código.
As variáveis em TypeScript possuem tipos explícitos, o que permite ao desenvolvedor especificar o tipo de dado que será armazenado. Esse controle de tipos facilita a detecção de erros durante a fase de desenvolvimento, promovendo um código mais seguro e eficiente.
Como Declarar e Inicializar Variáveis
Existem várias formas de declarar e inicializar variáveis em TypeScript, utilizando var, let e const. Vamos abordar cada uma delas com exemplos práticos.
Usando var
A declaração de variáveis com var tem um escopo de função ou global, e pode ser redeclarada e atualizada. Veja um exemplo:
var nome: string = 'João';
console.log(nome); // Saída: João
Usando let
A palavra-chave let foi introduzida com o ES6 (ECMAScript 2015) e é amplamente utilizada em TypeScript. Ela possui escopo de bloco, o que significa que a variável declarada com let só está acessível dentro do bloco onde foi declarada. Exemplo:
let idade: number = 30;
if (idade > 25) {
let mensagem: string = 'Você é adulto.';
console.log(mensagem); // Saída: Você é adulto.
}
console.log(mensagem); // Erro: mensagem não está definida
Usando const
A palavra-chave const é utilizada para declarar variáveis que não podem ser redeclaradas ou ressignificadas. Veja um exemplo:
const cidade: string = 'São Paulo';
cidade = 'Rio de Janeiro'; // Erro: não podemos atribuir um novo valor a uma constante
Tipos de Variáveis e Anotações de Tipo
O TypeScript permite a declaração de variáveis com anotações de tipo, garantindo que a variável armazene apenas valores do tipo especificado. Aqui estão alguns tipos de variáveis comuns e como anotá-los:
Tipo string
Uma variável do tipo string armazena uma sequência de caracteres. Veja um exemplo:
let nome: string = 'Maria';
console.log(nome); // Saída: Maria
Tipo number
Uma variável do tipo number pode armazenar valores inteiros e de ponto flutuante. Exemplo:
let idade: number = 25;
let altura: number = 1.75;
console.log(idade); // Saída: 25
console.log(altura); // Saída: 1.75
Tipo boolean
Variáveis do tipo boolean armazenam apenas dois valores: true ou false. Veja:
let estáAtivo: boolean = true;
let éAdulto: boolean = idade > 18;
console.log(estáAtivo); // Saída: true
console.log(éAdulto); // Saída: true
Tipo array
Arrays em TypeScript podem ser tipados para garantir que todos os elementos do array sejam do mesmo tipo. Exemplos:
let listaDeNúmeros: number[] = [1, 2, 3, 4, 5];
let listaDeNomes: string[] = ['Ana', 'Bruno', 'Carlos'];
console.log(listaDeNúmeros); // Saída: [1, 2, 3, 4, 5]
console.log(listaDeNomes); // Saída: ['Ana', 'Bruno', 'Carlos']
Tipo tuple
Tuples (tuplas) permitem armazenar múltiplos valores de tipos diferentes em uma única variável. Veja:
let pessoa: [string, number];
pessoa = ['João', 35];
console.log(pessoa); // Saída: ['João', 35]
Tipo enum
Enums são uma forma de nomear conjuntos de valores numéricos, melhorando a legibilidade do código. Exemplos:
enum Cores { Vermelho, Verde, Azul }
let corFavorita: Cores = Cores.Verde;
console.log(corFavorita); // Saída: 1
Anotações de Tipo Personalizadas
TypeScript permite criar tipos personalizados usando a palavra-chave type ou interface. Veja:
type Pessoa = { nome: string; idade: number; };
interface Carro { marca: string; ano: number; }
let aluno: Pessoa = { nome: 'Luís', idade: 22 };
let meuCarro: Carro = { marca: 'Toyota', ano: 2020 };
console.log(aluno); // Saída: { nome: 'Luís', idade: 22 }
console.log(meuCarro); // Saída: { marca: 'Toyota', ano: 2020 }
Boas Práticas para o Uso de Variáveis em TypeScript
Implementar boas práticas na declaração e uso de variáveis em TypeScript ajuda a manter o código claro, eficiente e livre de erros. Aqui estão algumas recomendações:
Prefira let e const
Evite usar var para declarar variáveis. Prefira o uso de let para variáveis que podem ter seu valor alterado e const para variáveis que não mudam.
Use Anotações de Tipo Sempre que Possível
Adicionar anotações de tipo torna o código mais legível e ajuda na detecção de erros. Sempre que possível, especifique os tipos das variáveis explicitamente:
let idade: number = 30;
let nome: string = 'Ana';
Escolha Nomes Significativos para Variáveis
Use nomes de variáveis que sejam descritivos e façam sentido. Isso facilita a compreensão do código:
let altura: number = 1.75; // Bom
let a: number = 1.75; // Ruim
Aproveite o Controle de Tipos do TypeScript
Utilize a verificação de tipos do TypeScript para garantir que o seu código funcione corretamente. Isso ajuda a evitar erros em tempo de execução:
// Código sem verificação rigorosa de tipos
let valor: any = "texto";
valor = 100; // Aceito
// Com verificação rigorosa
let valor: number = 100;
valor = "texto"; // Erro: Tipo 'string' não é atribuível a tipo 'number'
Evite Variáveis Globais
Variáveis globais podem causar problemas, pois qualquer parte do código pode alterar seu valor. Prefira variáveis locais com escopo de função ou bloco:
// Declarando variáveis localmente
function calcular() {
let resultado: number = 0;
// código para calcular resultado
return resultado;
}
Seguindo essas boas práticas e entendendo os conceitos básicos da declaração de variáveis em TypeScript, você garantirá um código mais seguro, eficiente e fácil de manter. Experimente implementar esses conceitos e ajuste conforme as necessidades do seu projeto.
