Variáveis e Tipos de Dados em TypeScript

Para construir qualquer programa, primeiro precisamos aprender a armazenar e manipular informações. É aqui que entram as variáveis e os tipos de dados. Eles são os blocos de construção fundamentais de qualquer lógica de programação.

Neste curso, usaremos o TypeScript, uma linguagem que nos ajuda a escrever um código mais seguro e claro desde o início.

O que são Variáveis?

Pense em uma variável como uma caixa com uma etiqueta. A caixa guarda uma informação (um dado), e a etiqueta é o nome que damos a ela para que possamos encontrá-la e usá-la mais tarde no programa.

Em TypeScript, podemos ser muito específicos sobre o que cada caixa pode guardar, definindo seu tipo.

Declarando Variáveis

Para criar uma variável, usamos as palavras-chave let (para valores que podem mudar) ou const (para valores constantes, que não mudam após serem definidos). A sintaxe explícita é:

let nomeDaVariavel: tipo = valor;

// Uma variável para guardar um nome, que é um texto (string)
let nome: string = "Ana";

// Uma constante para guardar a idade, que é um número (number)
const idade: number = 30;

// Uma variável para indicar se o usuário está ativo, um valor verdadeiro/falso (boolean)
let estaAtivo: boolean = true;

Definir o tipo (: string, : number) ajuda a evitar erros. Se você tentar colocar um dado do tipo errado na "caixa", o TypeScript irá te avisar.

let preco: number = 19.99;
// preco = "vinte"; // Erro! A variável 'preco' foi definida para aceitar apenas números.

Inferência de Tipos: Deixando o TypeScript Trabalhar por Você

Embora seja uma boa prática ser explícito, o TypeScript é inteligente. Na maioria das vezes, quando você declara e inicializa uma variável ao mesmo tempo, ele consegue adivinhar (inferir) o tipo sozinho.

let nomeCompleto = "Carlos Silva"; // TypeScript infere que é do tipo string
const anoNascimento = 1990;      // TypeScript infere que é do tipo number

Nesses casos, o código funciona exatamente como se você tivesse anotado o tipo, mas fica mais limpo e conciso. O TypeScript ainda garantirá que você não atribua um tipo diferente a essas variáveis mais tarde.

Regras de Nomeação de Variáveis

Ao criar variáveis, é importante seguir algumas regras e convenções para que seu código seja válido e legível:

1. Comece com uma letra, _ ou $: Nomes de variáveis não podem começar com números.
2. Sem espaços ou caracteres especiais: Use apenas letras, números, _ ou $ no restante do nome.
3. Nomes descritivos: Use nomes que descrevam o dado que a variável guarda (ex: precoProduto em vez de p).
4. Use camelCase: A convenção em TypeScript é começar com letra minúscula e capitalizar a primeira letra de cada palavra subsequente (ex: nomeCompletoDoUsuario).
5. Evite palavras reservadas: Não use nomes que já têm um significado na linguagem, como let, const, class, function, etc.

Tipos de Dados Essenciais

Todo dado em programação tem um tipo. Vamos conhecer os mais básicos:

• string: Para representar texto. Deve estar entre aspas ("" ou '') ou crases (`).

  let cidade: string = "Recife";

• number: Para representar números, sejam eles inteiros ou decimais.

  let quantidade: number = 10;
  let altura: number = 1.75;

• boolean: Para representar valores lógicos de true (verdadeiro) ou false (falso).

  let cadastroCompleto: boolean = false;

• null e undefined: Tipos especiais que representam a ausência de valor. null é uma ausência intencional, enquanto undefined significa que uma variável foi criada, mas ainda não tem valor.

• any e unknown: Quando não sabemos o tipo de um dado, podemos usar any (que desliga a verificação de tipos, use com cuidado!) ou unknown (uma alternativa mais segura que exige verificação antes do uso).

Operações com Variáveis

Podemos realizar diferentes operações dependendo do tipo de dado.

1. Operações Aritméticas

Usadas com o tipo number para fazer cálculos.

• Soma (+): let soma = 10 + 5; // 15
• Subtração (-): let subtracao = 10 - 5; // 5
• Multiplicação (*): let multiplicacao = 10 * 5; // 50
• Divisão (/): let divisao = 10 / 5; // 2
• Módulo (%): Retorna o resto de uma divisão. let resto = 10 % 3; // 1

2. Concatenação de Strings

O operador +, quando usado com strings, junta (concatena) os textos.

let saudacao: string = "Olá";
let nome: string = "Maria";
let mensagem: string = saudacao + ", " + nome + "!"; // "Olá, Maria!"

Uma forma mais moderna e legível de fazer isso é com template strings (usando crases):

let mensagemModerna: string = `${saudacao}, ${nome}!`; // "Olá, Maria!"

3. Operadores de Comparação

Usados para comparar valores. O resultado é sempre um boolean (true ou false).

• === (Igualdade Estrita): Verifica se dois valores são iguais e do mesmo tipo. É o mais recomendado.

  console.log(5 === 5);     // true
  console.log(5 === "5");   // false (tipos diferentes)

• !== (Desigualdade Estrita): Verifica se dois valores são diferentes ou de tipos diferentes.

  console.log(5 !== 10);    // true
  console.log(5 !== "5");   // true

• Outros operadores: > (maior que), < (menor que), >= (maior ou igual), <= (menor ou igual).

4. Operadores de Incremento e Decremento

Estes são operadores unários (atuam em um único valor) que servem como atalhos para adicionar ou subtrair 1 de uma variável numérica.

• Incremento (++): Adiciona 1 ao valor da variável.

  let contador: number = 10;
  contador++; // Agora, contador é 11
  console.log(contador);

• Decremento (--): Subtrai 1 do valor da variável.

  let placar: number = 5;
  placar--; // Agora, placar é 4
  console.log(placar);

Conversão de Tipos (Type Casting)

Às vezes, recebemos um dado em um formato, mas precisamos usá-lo em outro. Por exemplo, um número que foi digitado em um campo de texto chega para nós como uma string. O processo de transformar um tipo de dado em outro é chamado de conversão de tipos.

Em TypeScript, preferimos fazer isso de forma explícita, para que nosso código seja claro sobre o que está acontecendo.

Convertendo para number

Para converter uma string (ou outro tipo) em um number, usamos a função Number().

let idadeTexto: string = "30";
let idadeNumero: number = Number(idadeTexto);
console.log(idadeNumero); // 30 (agora é um número)

let precoTexto: string = "49.99";
let precoNumero: number = Number(precoTexto);
console.log(precoNumero); // 49.99 (agora é um número)

Se a conversão não for possível, o resultado será NaN (Not a Number).

Convertendo para string

Para converter um number ou boolean para uma string, usamos a função String().

let quantidade: number = 5;
let quantidadeTexto: string = String(quantidade); // "5"

let ativo: boolean = true;
let ativoTexto: string = String(ativo); // "true"

Convertendo para boolean

Podemos usar a função Boolean() para converter qualquer valor em true ou false. Isso é útil para verificar se uma variável tem um valor "real".

Em TypeScript, alguns valores são considerados "falsy" (falsos):

• 0
• "" (uma string vazia)
• null
• undefined
• NaN

Qualquer outro valor é considerado "truthy" (verdadeiro).

console.log(Boolean(10));        // true
console.log(Boolean("Olá"));     // true

console.log(Boolean(0));         // false
console.log(Boolean(""));        // false
console.log(Boolean(null));      // false

Para praticar

Vamos testar seus conhecimentos com um desafio usando TypeScript.

Cenário: Crie um pequeno script que calcule o preço total de um produto com desconto.

Requisitos:

1. Crie uma variável nomeProduto do tipo string.
2. Crie uma variável preco do tipo number.
3. Crie uma constante percentualDesconto do tipo number com o valor 0.1 (10%).
4. Calcule o valor do desconto (preco * percentualDesconto).
5. Calcule o preço final (preco - valorDoDesconto).
6. Exiba uma mensagem no console: "O produto [nomeProduto] custa R$[precoFinal] com desconto."

let nomeProduto = "Fone de Ouvido Bluetooth"; // Inferência de tipo: string
let preco = 150.00;                       // Inferência de tipo: number
const percentualDesconto = 0.1;           // Inferência de tipo: number

let valorDoDesconto = preco * percentualDesconto;
let precoFinal = preco - valorDoDesconto;

console.log(`O produto ${nomeProduto} custa R$${precoFinal.toFixed(2)} com desconto.`);
// Usamos toFixed(2) para formatar o número com duas casas decimais.

Conclusão

Entender variáveis e tipos é o primeiro passo para construir qualquer programa. Com o TypeScript, você ganha uma camada extra de segurança que te ajuda a escrever um código mais robusto e com menos erros.

Agora que sabemos como armazenar, tipar e operar com dados, o próximo passo é aprender a usar esses dados para tomar decisões. Vamos explorar como criar lógica condicional com as estruturas de controle de fluxo.