Usando TypeScript com Node.js: um guia completo

Apr 19 2023

Se você estiver trabalhando com Node.js, talvez esteja familiarizado com os desafios de gerenciar e dimensionar uma grande base de código.

Se você estiver trabalhando com Node.js, talvez esteja familiarizado com os desafios de gerenciar e dimensionar uma grande base de código. Uma maneira de superar isso é usar o TypeScript, um superconjunto de JavaScript com tipagem estática que adiciona anotações de tipo opcionais e recursos avançados à linguagem. Neste artigo, exploraremos como usar TypeScript com Node.js e forneceremos exemplos para ajudá-lo a começar.

Índice

Introdução ao TypeScript
Configurando um projeto TypeScript
Executando TypeScript com Node.js
Usando recursos TypeScript no Node.js
Depurando código TypeScript
Usando TypeScript com bibliotecas Node.js populares
Práticas recomendadas para usar TypeScript com Node.js
Conclusão
perguntas frequentes

TypeScript é uma linguagem que fornece verificação de tipo estático para JavaScript. Foi desenvolvido pela Microsoft e é um projeto de código aberto amplamente adotado pela comunidade de desenvolvimento. Com o TypeScript, você pode detectar erros antes do tempo de execução, melhorar a legibilidade e a capacidade de manutenção do código e usar recursos avançados como classes, interfaces e enums. O TypeScript também é compatível com estruturas e bibliotecas JavaScript populares, como React, Angular e Node.js.

Configurando um projeto TypeScript

Para começar a usar o TypeScript, você precisa configurar um projeto com as dependências e configurações necessárias. Primeiro, você precisa instalar o Node.js e o npm em sua máquina. Em seguida, você pode criar um novo diretório de projeto e executar o seguinte comando para inicializar um novo projeto Node.js:

$ npm init -y

$ npm install --save-dev typescript

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": [
    "src/**/*.ts"
  ]
}jj

Executando TypeScript com Node.js

Depois de configurar um projeto TypeScript, você pode usar o compilador TypeScript ( tsc) para compilar seu código TypeScript em código JavaScript que pode ser executado pelo Node.js. Você pode executar o compilador usando o seguinte comando:

$ npx tsc

Para executar os arquivos JavaScript compilados, você pode usar o nodecomando seguido do caminho para o arquivo de entrada. Por exemplo, se seu arquivo de entrada for dist/index.js, você pode executá-lo usando o seguinte comando:

$ node dist/index.js

O TypeScript fornece recursos avançados como classes, interfaces e enums que podem ser usados em aplicativos Node.js. aqui estão alguns exemplos:

Aulas

class Person {
  constructor(public name: string, public age: number) {}

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}
const john = new Person('John', 30);
john.greet();

interface Animal {
  name: string;
  age: number;
  speak(): void;
}
class Dog implements Animal {
  constructor(public name: string, public age: number) {}
  speak() {
    console.log('Woof!');
  }
}
const rex: Animal = new Dog('Rex', 5);
rex.speak();

//typescript code
enum Color {
  Red = 'RED',
  Green = 'GREEN',
  Blue = 'BLUE'
}

function printColor(color: Color) {
  console.log(`The color is ${color}`);
}
printColor(Color.Red);

Ao trabalhar com TypeScript, você pode encontrar erros que não são detectados pelo compilador TypeScript. Para depurar seu código TypeScript, você pode usar o --inspectsinalizador com o nodecomando para iniciar uma sessão de depuração. Você pode usar um depurador, como o VS Code, para definir pontos de interrupção e percorrer seu código.

$ node --inspect dist/index.js

O TypeScript é compatível com muitas bibliotecas e estruturas Node.js populares. aqui estão alguns exemplos:

Expressar

//typescript code

import express from 'express';

const app = express();
app.get('/', (req, res) => {
  res.send('Hello World!');
});
app.listen(3000, () => {
  console.log('Server started on port 3000');
});

typescript code
//typescript code

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
yt
@Entity()
class User {
  @PrimaryGeneratedColumn()
  id: number;
  @Column()
  name: string;
  @Column()
  age: number;
}

Aqui estão algumas práticas recomendadas para usar TypeScript com Node.js:

Use o modo estrito para capturar mais erros em tempo de compilação.
Use interfaces e tipos para definir a forma de seus dados e melhorar a legibilidade do código.
Use tsconfig.jsonpara especificar as opções de configuração do TypeScript para seu projeto.
Use ferramentas como ESLint e Prettier para reforçar a qualidade e a consistência do código.

Ao habilitar o modo estrito no TypeScript, você pode detectar possíveis erros e problemas no tempo de compilação, e não no tempo de execução. Isso pode economizar tempo e esforço a longo prazo, evitando erros difíceis de depurar que podem ocorrer na produção.

Para habilitar o modo estrito, adicione "strict": trueao seu arquivo tsconfig.json. Isso permitirá uma série de verificações rigorosas, como:

Proibindo quaisquer tipos implícitos
Aplicação de verificações nulas
Proibição de variáveis e importações não utilizadas

O uso de interfaces e tipos pode ajudar a tornar seu código mais legível e fácil de manter, fornecendo uma definição clara da forma de seus dados. Isso também pode facilitar a captura de erros relacionados ao tipo em tempo de compilação.

Por exemplo, considere o seguinte código:

function printUser(user: { name: string, age: number }) {
  console.log(`Name: ${user.name}, Age: ${user.age}`);
}

interface User {
  name: string;
  age: number;
}
function printUser(user: User) {
  console.log(`Name: ${user.name}, Age: ${user.age}`);
}

O arquivo tsconfig.json é usado para especificar as opções de configuração do TypeScript para seu projeto. Isso pode incluir coisas como:

A versão do TypeScript a ser usada
O diretório raiz do seu projeto
O diretório de saída para arquivos JavaScript compilados

Use ferramentas como ESLint e Prettier para reforçar a qualidade e a consistência do código.

ESLint e Prettier são ferramentas que podem ajudar a reforçar a qualidade e a consistência do código em sua base de código TypeScript. O ESLint pode ser usado para detectar erros comuns e impor padrões de codificação, enquanto o Prettier pode ser usado para formatar automaticamente seu código em um estilo consistente.

Ao usar essas ferramentas, você pode ajudar a garantir que seu código seja sustentável e consistente em todo o projeto.

No geral, essas práticas recomendadas podem ajudar a melhorar a qualidade e a capacidade de manutenção de sua base de código TypeScript ao usar o Node.js.

Conclusão

Neste artigo, exploramos como usar TypeScript com Node.js e fornecemos exemplos para ajudá-lo a começar. O TypeScript pode ajudá-lo a detectar erros antes do tempo de execução, melhorar a legibilidade e a capacidade de manutenção do código e usar recursos avançados como classes, interfaces e enums. Seguindo as práticas recomendadas e usando bibliotecas e estruturas populares, você pode criar aplicativos Node.js escalonáveis e sustentáveis com TypeScript.