TypeScript: Tipos básicos do TypeScript

Última atualização: 2026-08-26

O sistema de tipos do TypeScript começa com sete tipos básicos — domine-os e você terá dominado o “alfabeto” das anotações de tipos.

1. Sete tipos básicos

O TypeScript herda os sete tipos básicos do JavaScript e oferece uma sintaxe de anotação de tipos para cada um deles:

(1) string

As cadeias de caracteres podem ser representadas usando aspas simples, aspas duplas ou crases (cadeias de caracteres de modelo):

let firstName: string = "Charlie";
let lastName: string = 'Wang';
let greeting: string = `Hello, ${firstName} ${lastName}`;

As strings de modelo (crase) suportam variáveis e expressões incorporadas; essa sintaxe foi introduzida no ES6 e é totalmente compatível com o TypeScript.

(2) número

Assim como o JavaScript, o TypeScript não faz distinção entre números inteiros e números de ponto flutuante — ambos são do tipo number:

let age: number = 25;         // Integer
let price: number = 9.99;     // Decimals
let hex: number = 0xFF;       // Hexadecimal
let binary: number = 0b1010;  // Binary
let octal: number = 0o744;    // Octal

(3) booleano

Existem apenas dois valores: true e false. Eles são comumente usados para verificações condicionais e como sinalizadores de alternância:

let isActive: boolean = true;
let hasPermission: boolean = false;

▶ Exemplo: Anotações de tipos primitivos

// Defining Different Types of Variables
let title: string = "TypeScript Getting Started";
let version: number = 5.3;
let isPublished: boolean = true;

console.log("Courses：" + title);
console.log("Version：" + version);
console.log("Published：" + isPublished);

Saída:

Courses：TypeScript Getting Started
Version：5.3
Published：true

2. nulo e indefinido

No TypeScript, null e undefined são tanto valores quanto tipos. A diferença entre eles pode parecer sutil, mas é importante no sistema de tipos.

(1) Diferenças de significado

(2) Anotações de tipo

let notAssigned: undefined = undefined;
let emptyValue: null = null;

(3) O impacto de strictNullChecks

// strictNullChecks: false（Default Relaxed Mode）
let name: string = null;         // ✅ No errors，But at runtime name.toUpperCase() It will crash

// strictNullChecks: true（Strict Mode，Recommendations）
let name2: string = null;        // ❌ Error：You cannot null Assign to string
let name3: string | null = null; // ✅ Correct：An explicit declaration might be null

3. O tipo symbol

symbol é um tipo primitivo introduzido no ES6, utilizado para criar identificadores globalmente únicos. Cada chamada ao Symbol() gera um valor único:

let id1: symbol = Symbol("id");
let id2: symbol = Symbol("id");

console.log(id1 === id2);  // false —— Even if the descriptions are the same，Each symbol They are all unique.

▶ Exemplo: Como usar um símbolo como chave única para um objeto

let uniqueKey: symbol = Symbol("secret");

let user = {
  name: "Diana",
  age: 20
};

// Use symbol as a property key，Does not conflict with other attributes
user[uniqueKey] = "Hide Data";

console.log(user.name);        // Normal Access
console.log(user[uniqueKey]);  // Visit symbol Key value

Saída:

Diana
Hide Data

4. O tipo bigint

bigint é um tipo introduzido no ES2020 que representa grandes números inteiros além do intervalo seguro de number. Um número seguido por n é um bigint:

let big1: bigint = 100n;                        // Literal Notation
let big2: bigint = BigInt(9007199254740991);     // Function Syntax

// number Upper Limit for Secure Integers
let maxSafe: number = Number.MAX_SAFE_INTEGER;  // 9007199254740991
let overflow: number = 9007199254740992;        // Outside the safety range，Loss of Accuracy！

// bigint No loss of precision
let safe: bigint = 9007199254740992n;           // Precise representation

▶ Exemplo: Comparando a precisão do tipo bigint

// number Accuracy is lost when the safe range is exceeded
let a: number = 9007199254740992;
let b: number = 9007199254740993;
console.log(a === b);  // true！Two different numbers are actually equal

// bigint Precise representation
let c: bigint = 9007199254740992n;
let d: bigint = 9007199254740993n;
console.log(c === d);  // false —— Distinguish Correctly

Saída:

true
false

5. Omissão de anotações de tipo e melhores práticas

(1) Quando é necessário incluir uma anotação de tipo?

(2) Melhores práticas

// ✅ Recommendations：Omit the type annotation when a variable has an initial value（Type inference is sufficient）
let name = "Charlie";
let age = 20;

// ✅ Recommendations：Explicitly Labeling Function Parameters and Return Values
function greet(name: string): string {
  return "Hello, " + name;
}

// ✅ Recommendations：Explicitly label when there is no initial value
let userId: number;
let isActive: boolean;

// ❌ Not recommended：Why include annotations when there are initial values?（Redundancy）
let name2: string = "Charlie";  // Superfluous——TypeScript It has already been deduced.

❓ Perguntas Frequentes

P: O TypeScript possui tipos float ou double? R: Não. Assim como o JavaScript, o TypeScript possui apenas um tipo numérico, que abrange tanto números inteiros quanto números de ponto flutuante. Todos os números no JavaScript são números de ponto flutuante de precisão dupla de 64 bits (IEEE 754); portanto, 1 e 1,0 são exatamente iguais em termos de tipo.

P: Qual é a diferença prática entre null e undefined? Quando cada um deve ser usado? R: undefined indica “ainda não atribuído” (um estado gerado automaticamente pelo sistema), enquanto null indica “intencionalmente vazio” (um valor definido explicitamente pelo desenvolvedor). No desenvolvimento prático, recomenda-se usar null para indicar “sem valor” — pois undefined pode resultar do esquecimento de atribuir um valor, enquanto null representa uma escolha deliberada.

P: O tipo bigint é comumente usado? R: Na verdade, não. Na grande maioria dos casos, o tipo number é suficiente (com um intervalo seguro de inteiros de até 2^53-1 ≈ 900 trilhões). O bigint é usado principalmente em cenários como algoritmos criptográficos, cálculos com números grandes e campos bigint em bancos de dados. Iniciantes precisam apenas saber que ele existe; eles poderão se aprofundar no assunto quando realmente precisarem usá-lo.

P: O uso excessivo de anotações de tipo afeta o desempenho? R: De forma alguma. As anotações de tipo existem apenas na fase de compilação; todas as informações de tipo são removidas do código JavaScript compilado, portanto, não há nenhuma sobrecarga em tempo de execução. Da mesma forma que os comentários não tornam um programa mais lento.

📖 Resumo

• O TypeScript possui sete tipos básicos: string, number, booleano, nulo, indefinido, symbol e bigint
• O tipo number não faz distinção entre números inteiros e decimais; o bigint é usado para números inteiros muito grandes e não pode ser utilizado em operações mistas com o number.
• No modo estrito, null ou undefined não podem ser atribuídos arbitrariamente a outros tipos; é necessário usar um tipo de união (string | null).
• símbolo: Gera um identificador globalmente único, utilizado principalmente em cenários avançados
• As anotações de tipo podem ser omitidas quando as variáveis possuem valores iniciais (inferência de tipo); os parâmetros de função e as variáveis sem valores iniciais devem ser anotados.

📝 Exercícios

1. Problema básico (Dificuldade ⭐): Declare cinco variáveis correspondentes a cinco tipos comuns (string, número, booleano, nulo, indefinido), atribua valores apropriados a elas e use console.log para exibi-las uma a uma.
2. Problema avançado (Dificuldade ⭐⭐): Escreva uma função formatPrice(price: number, currency: string): string que formate um preço numérico em uma string com o símbolo da moeda. Por exemplo, formatPrice(99.5, "¥") retorna "¥99.5".
3. Problema de desafio (Dificuldade ⭐⭐⭐): Verifique a precisão de number — escreva um código para comparar se 0.1 + 0.2 e 0.3 são iguais e explique o resultado. Em seguida, use bigint para calcular a soma de dois números inteiros grandes que excedam Number.MAX_SAFE_INTEGER e verifique se bigint não perde precisão.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós