Tipos de Dados no TypeScript

TypeScript é uma linguagem fortemente tipada, o que significa que cada variável e constante tem um tipo de dado específico. Ao contrário do JavaScript, não é possível alterar dinamicamente o tipo de uma variável após ela ter sido definido.

Em TypeScript, existem os seguintes tipos básicos:

• boolean: valor lógico, true ou false
• number: valor numérico
• bigint: valores inteiros arbitrariamente grandes
• string: cadeias de caracteres
• array: arrays
• tuples: tuplas
• Enum: enumerações
• any: tipo arbitrário
• symbol: símbolos
• null e undefined: correspondem aos valores null e undefined do JavaScript
• never: representa a ausência de valor e é usado como tipo de retorno para funções que lançam erros ou nunca retornam.

A maioria desses tipos se relaciona diretamente com os tipos primitivos do JavaScript.

Para definir o tipo de uma variável, usa-se o sinal de dois-pontos seguido do nome do tipo. Veja alguns exemplos de como criar variáveis:

let x: number = 10;
let hello: string = "hello world";
let isValid: boolean = true;

Nesse caso, a expressão let hello: string = "hello world" especifica que a variável hello será do tipo string e terá o valor "hello world".

Caso se tente alterar o tipo posteriormente, como no exemplo abaixo:

let hello: string = "hello world";
hello = 23;

O compilador TypeScript lançará um erro durante a compilação.

Agora vamos explorar os tipos primitivos de dados em TypeScript.

boolean

O tipo boolean representa valores lógicos, podendo ser true ou false:

let isEnabled: boolean = true;
let isAlive: boolean = false;

console.log(isEnabled);
console.log(isAlive);

number

O tipo number abrange todos os números em TypeScript, que assim como em JavaScript, são representados por números de ponto flutuante. Isso inclui tanto números inteiros quanto decimais:

let age: number = 36;
let height: number = 1.68;

TypeScript também suporta várias notações numéricas, como binária, octal, decimal e hexadecimal:

let decimal: number = 6;
let hex: number = 0xf00d; // 61453 em decimal
let binary: number = 0b1010; // 10 em decimal
let octal: number = 0o744; // 484 em decimal

console.log(decimal);
console.log(hex);
console.log(binary);
console.log(octal);

bigint

Para representar números extremamente grandes, TypeScript introduziu o tipo bigint, que pode armazenar valores maiores do que o tipo number permite. Há duas formas de definir um valor desse tipo. A primeira é utilizando a função BigInt():

const num1: bigint = BigInt(100);
console.log(num1);

A segunda é adicionando o sufixo n ao número:

const num2: bigint = 100n;
console.log(num2);

Vale lembrar que esse tipo faz parte do padrão ES2020, então é necessário configurar o compilador para usar essa versão do ECMAScript no arquivo tsconfig.json:

{
    "compilerOptions": {
        "target": "es2020",
        "outFile": "app.js"
    }
}

string

O tipo string é utilizado para representar cadeias de caracteres. Assim como em JavaScript, as strings podem ser delimitadas por aspas simples ou duplas:

let firstName: string = "Tom";
let lastName = "Johns";

TypeScript também oferece suporte a templates de strings, que permitem a inserção de expressões dentro de cadeias de caracteres usando a sintaxe ${} e as crases ``:

let firstName: string = "Tom";
let age: number = 28;
let info: string = `Nome: ${firstName}, Idade: ${age}`;

console.log(info); // Nome: Tom, Idade: 28

Templates de strings também permitem a criação de textos em várias linhas:

let sentence: string = `Hello World!
Goodbye World!`;

Inferência de Tipo

Embora seja possível definir explicitamente o tipo de uma variável, TypeScript também pode inferir o tipo com base no valor atribuído:

let hello = "hello world";
hello = 23;

No exemplo acima, o TypeScript inferirá que a variável hello é do tipo string com base no valor "hello world". Se tentarmos atribuir um número a essa variável posteriormente, o compilador retornará um erro.

Tipo any

O tipo any descreve dados cujo tipo pode não ser conhecido durante o desenvolvimento:

let someVar: any = "hello";
console.log(someVar); // agora someVar é string

someVar = 20;
console.log(someVar); // agora someVar é number

Como estamos usando o tipo any, o código acima será compilado sem erros, mesmo com a mudança de um valor de string para número. Arrays também podem ser definidos como sendo do tipo any:

var someArray: any[] = [24, "Tom", false];

Se uma variável é definida sem um valor inicial ou sem um tipo explícito, ela será considerada do tipo any:

let x; // tipo any
x = 10;
x = "hello";

O uso de any pode ser prático, mas perde-se a vantagem da tipagem estática do TypeScript, potencialmente introduzindo erros que o compilador não será capaz de detectar.

Verificação de Tipo

Com o operador typeof, podemos verificar o tipo de uma variável. Isso é útil quando não conhecemos o tipo exato de uma variável (como uma variável do tipo any), e desejamos garantir que a operação que estamos realizando seja adequada:

let sum: any;
sum = 1200;
sum = "mil e duzentos";

let result: number = sum / 12;
console.log(result); // NaN - não é possível dividir uma string por um número

Para evitar esse tipo de erro, podemos verificar o tipo antes de realizar a operação:

let sum: any;
sum = 1200;

if (typeof sum === "number") {
  let result: number = sum / 12;
  console.log(result);
} else {
  console.log("Operação inválida");
}

O operador typeof retorna o tipo do valor. Por exemplo, typeof sum retornará "number" se sum for um número.

Os possíveis valores que typeof pode retornar são:

• "string"
• "number"
• "bigint"
• "boolean"
• "symbol"
• "undefined"
• "object"
• "function"