TypeScript do zero em 2025: guia prático

Introdução: por que aprender TypeScript em 2025?

O mundo do desenvolvimento front-end muda rapidamente, mas uma coisa permanece constante — o TypeScript continua fortalecendo sua posição como padrão de fato para grandes projetos. Em 2025, não é apenas uma "extensão do JavaScript", mas uma ferramenta completa que ajuda a escrever código mais confiável, previsível e escalável. Se você é um desenvolvedor iniciante ou está migrando do JavaScript puro, este guia o conduzirá pelos primeiros passos: da instalação à escrita de código significativo.

Neste artigo, abordaremos aspectos práticos: como configurar o ambiente, dominar os tipos básicos, conhecer interfaces e generics. Você verá que o TypeScript não complica o desenvolvimento, mas sim economiza horas de depuração.

1. Instalação e configuração do TypeScript em 2025

O primeiro passo é instalar o compilador TypeScript. Em 2025, a maneira mais conveniente é usar o Node.js e o gerenciador de pacotes npm (ou yarn). Certifique-se de que o Node.js versão 20+ está instalado.

# Instalação global do TypeScriptnpm install -g typescript

# Verificação da versãotsc --version

Agora crie uma pasta para o projeto e inicialize-o:

mkdir my-first-tscd my-first-tsnpm init -y

Em seguida, criaremos um arquivo de configuração tsconfig.json. Este é o coração de qualquer projeto TypeScript, onde você define as configurações de compilação.

tsc --init

Após executar o comando, um arquivo com várias opções será criado. Para começar, basta manter as configurações padrão. O principal é garantir que o parâmetro strict: true esteja ativado (ele está ativado por padrão). Isso o forçará a escrever código de melhor qualidade.

A estrutura do projeto em 2025 geralmente inclui as pastas src (código-fonte) e dist (arquivos compilados). Crie-as:

mkdir src dist

E adicione ao tsconfig.json:

{  "compilerOptions": {    "outDir": "./dist",    "rootDir": "./src",    "strict": true,    "target": "ES2022",    "module": "ESNext"  },  "include": ["src/**/*"]}

Agora crie o primeiro arquivo src/index.ts e escreva um código simples:

// src/index.tsfunction greet(name: string): string {  return `Olá, ${name}! Bem-vindo ao TypeScript.`;}

const userName: string = "Alexei";console.log(greet(userName));

Compile-o com o comando tsc. Na pasta dist, aparecerá o arquivo index.js. Execute-o via Node.js: node dist/index.js. Você verá a saudação. Parabéns, você escreveu seu primeiro programa em TypeScript!

2. Fundamentos dos tipos: tipagem estática na prática

A principal vantagem do TypeScript é o sistema de tipos. Em 2025, ele se tornou ainda mais flexível. Vamos explorar os tipos básicos que você usará diariamente.

Tipos primitivos

Eles incluem string, number, boolean, null, undefined, symbol e bigint. O TypeScript infere automaticamente o tipo quando é óbvio:

let age: number = 25;        // declaração explícitalet name = "Maria";          // TypeScript inferirá stringlet isActive = true;         // inferirá boolean

Arrays e tuplas

Arrays em TypeScript podem ser homogêneos ou heterogêneos (tuplas).

// Array de númeroslet scores: number[] = [10, 20, 30];

// Notação alternativalet scores2: Array<number> = [10, 20, 30];

// Tupla (tamanho e tipos fixos)let person: [string, number] = ["Ivan", 30];

Tipo any e unknown

Evite any — ele desativa a verificação de tipos. Em vez disso, use unknown se o tipo for desconhecido:

                
                

                    

                        Blogs                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Concorrência em C++: de threads a corrotinas e async/await
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Concorrência em Swift: threads, goroutines e async/await — como não enlouquecer
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Zeros à esquerda em Java: desempenho e elegância do código
                                
                            
                                            
                

                
                

                    

                        Book Recommendations                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Entrevista de JavaScript (Node.js): 200 perguntas e respostas
                                
                            
                                            
                
            
    

  
Leia também
  

                
                  
                 CI/CD para projetos PHP: GitHub Actions nível avançado
      
                
                  
                 Implantação de aplicação Rust em VPS: passo a passo do A ao Z
      
                
                  
                 Como organizar um projeto PHP: Arquitetura Hexagonal sem dor
      
                
                  
                 Filas e tarefas em segundo plano em Swift: escrevendo código que não trava
      
                
                  
                 Tratamento de erros em Go: try/catch e além — guia completo