Skip to content

2. Configuração do ambiente de trabalho

O documento original (2019) explicava em detalhes como instalar o [Laragon], o [Netbeans] e o [Visual Studio Code] no Windows 10, com numerosas capturas de tela ilustrando a configuração do PATH. Em 2026, a instalação é bem mais simples: usaremos as ferramentas a seguir.

  • [Visual Studio Code] para escrever o código TypeScript;
  • [Node.js], versão 26 ou posterior—é a versão que tornou o objeto [Temporal], apresentado no último capítulo deste documento, disponível sem nenhuma opção especial;
  • [TypeScript], versão 6;
  • [tsx], uma ferramenta que executa um arquivo .ts diretamente, sem etapa prévia de compilação—é o que usaremos para todos os scripts deste documento;
  • [npm] (Node Package Manager), incluído no Node.js, para instalar as bibliotecas de que precisaremos;

2.1. Verificação das ferramentas instaladas

Depois de instalar o Node.js e o Visual Studio Code, abra um terminal (dentro do VSCode ou fora dele) e verifique as versões instaladas:

node --version

Resultado (a versão exata pode variar; recomenda-se a 26.x ou superior para este curso):

v22.22.2
npx tsc --version

Resultado da execução:

Version 6.0.3

2.2. Configuração do projeto no VSCode

A pasta de código deste curso é a seguinte:

Image

Esta pasta corresponde à estrutura completa de diretórios de scripts (typescript-nestjs-course-scripts/) apresentada na introdução deste documento, que você baixou. Abra a subpasta typescript-fundamentals/ no VSCode: é nela que estão os scripts dos primeiros capítulos deste curso. Ela já contém, na raiz, os dois arquivos package.json e tsconfig.json—vamos examiná-los.

2.2.1. O arquivo package.json

Este arquivo lista as dependências do projeto. Ele também especifica "type": "module", para que o Node.js trate nativamente nossos arquivos como módulos ECMAScript (com import/export), sem precisar de uma ferramenta intermediária, como era o caso em 2019 com o pacote esm.

{
  "type": "module",
  "scripts": {
    "check": "tsc --noEmit"
  },
  "devDependencies": {
    "eslint": "^8.57.0",
    "@typescript-eslint/eslint-plugin": "^7.18.0",
    "@typescript-eslint/parser": "^7.18.0",
    "typescript": "^6.0.3",
    "tsx": "^4.19.0",
    "@types/node": "^22.7.0"
  },
  "dependencies": {
    "axios": "^1.7.0",
    "moment": "^2.30.0",
    "qs": "^6.12.0",
    "sprintf-js": "^1.1.3"
  }
}

2.2.2. O arquivo tsconfig.json

Este arquivo configura o compilador TypeScript. O modo estrito está ativado: essa é a configuração recomendada, pois permite que o TypeScript detecte o maior número possível de erros durante a compilação.

{
  "compilerOptions": {
    "target": "ES2023",
    "lib": ["ESNext"],
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "esModuleInterop": true,
    "strict": true,
    "types": ["node"],
    "noEmit": true
  },
  "include": ["**/*.ts"]
}
Importante: A partir do TypeScript 6.0, a linha "types" : ["node"] é essencial: sem ela, o TypeScript deixa de reconhecer automaticamente objetos globais do Node.js, como `console` ou `process`, ao contrário das versões anteriores à 6.0.
Nota: Não há nada a instalar aqui. Como em todas as outras pastas da árvore de diretórios, as dependências de `typescript-fundamentals/`—e de todos os scripts deste curso—já foram instaladas por um único comando `npm install`, executado uma vez na raiz de `typescript-nestjs-course-scripts/` (veja a introdução deste documento): isso é mostrado pela pasta node_modules já presente na raiz na captura de tela acima, graças aos [npm workspaces]. O projeto, portanto, está pronto para uso assim que for baixado.

Se você ainda não baixou a estrutura de diretórios, ou se precisar reinstalar suas dependências, aqui está um lembrete do comando único a executar—apenas uma vez—no diretório raiz; ele instalará todos os módulos Node.js necessários para todos os scripts do curso:

npm install

Os comandos a seguir são digitados em um terminal do VSCode, com o diretório definido como [typescript-fundamentals].

Image

2.3. Primeiro script

Vamos criar um arquivo chamado tests/test-01.ts:

// um 1º programa TypeScript
console.log("hello world!");

Execute-o a partir do terminal, no diretório raiz do projeto:

npx tsx tests/test-01.ts

Resultado da execução:

hello world!

2.4. Segundo script: verificação de tipos

Vamos criar um segundo arquivo, tests/test-02.ts, com uma variável tipada explicitamente:

'use strict'
let x: number = 4;
console.log("x=", x);
npx tsx tests/test-02.ts

Resultado da execução:

x= 4

Agora vamos tentar atribuir uma string a essa variável declarada como número:

x = "abc";

Mesmo sem executar o script, o VSCode destaca imediatamente a linha em vermelho, e o comando de verificação de tipos falha:

npx tsc --noEmit

Resultado da execução:

tests/test-02.ts(4,1): error TS2322: Type 'string' is not assignable to type 'number'.

Essa é a principal vantagem do TypeScript sobre o JavaScript: toda uma categoria de erros (mistura acidental de tipos) é detectada antes da execução, diretamente no editor, em vez de ser descoberta quando o código falha em produção.

2.5. ESLint

O [ESLint] é uma ferramenta que verifica se o código segue um conjunto de regras de estilo e boas práticas (variáveis não utilizadas, comparações suspeitas etc.). O arquivo de configuração .eslintrc.cjs (a extensão .cjs , e não .js, é necessária porque o package.json declara "type": "module") usa o parser @typescript-eslint, que entende a sintaxe do TypeScript (tipos, interfaces, campos privados #x...):

module.exports = {
  root: true,
  env: { node: true, es2024: true },
  extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
  parser: "@typescript-eslint/parser",
  plugins: ["@typescript-eslint"],
  parserOptions: { ecmaVersion: "latest", sourceType: "module" }
};

Em seguida, analisamos o projeto inteiro com:

npx eslint . --ext .ts

2.6. ESLint no VSCode

A extensão do VSCode chamada [ESLint] (a ser instalada pela aba Extensões) exibe os avisos do ESLint diretamente no editor, em tempo real—sem precisar executar o comando manualmente a cada vez.

Agora temos um ambiente de trabalho completo. O próximo capítulo trata dos fundamentos da linguagem TypeScript.