Używanie TypeScript z Node.js: obszerny przewodnik

Apr 19 2023

Jeśli pracujesz z Node.js, możesz być zaznajomiony z wyzwaniami związanymi z zarządzaniem i skalowaniem dużej bazy kodu.

Jeśli pracujesz z Node.js, możesz być zaznajomiony z wyzwaniami związanymi z zarządzaniem i skalowaniem dużej bazy kodu. Jednym ze sposobów przezwyciężenia tego problemu jest użycie TypeScript, nadzbioru JavaScript o typie statycznym, który dodaje do języka opcjonalne adnotacje typu i zaawansowane funkcje. W tym artykule zbadamy, jak używać TypeScript z Node.js i przedstawimy przykłady, które pomogą Ci zacząć.

Spis treści

Wprowadzenie do TypeScriptu
Konfigurowanie projektu TypeScript
Uruchamianie TypeScript z Node.js
Korzystanie z funkcji TypeScript w Node.js
Debugowanie kodu TypeScript
Używanie TypeScript z popularnymi bibliotekami Node.js
Najlepsze praktyki dotyczące używania TypeScript z Node.js
Wniosek
Często zadawane pytania

TypeScript to język, który zapewnia statyczne sprawdzanie typów dla JavaScript. Został opracowany przez firmę Microsoft i jest projektem typu open source, który jest szeroko stosowany przez społeczność programistów. Dzięki TypeScript możesz wychwytywać błędy przed uruchomieniem, poprawiać czytelność kodu i łatwość konserwacji oraz korzystać z zaawansowanych funkcji, takich jak klasy, interfejsy i wyliczenia. TypeScript jest również kompatybilny z popularnymi frameworkami i bibliotekami JavaScript, takimi jak React, Angular i Node.js.

Konfigurowanie projektu TypeScript

Aby rozpocząć pracę z TypeScript, musisz skonfigurować projekt z niezbędnymi zależnościami i konfiguracją. Najpierw musisz zainstalować Node.js i npm na swoim komputerze. Następnie możesz utworzyć nowy katalog projektu i uruchomić następujące polecenie, aby zainicjować nowy projekt 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

Uruchamianie TypeScript z Node.js

Po skonfigurowaniu projektu TypeScript możesz użyć kompilatora TypeScript ( tsc) do skompilowania kodu TypeScript do kodu JavaScript, który może być uruchamiany przez Node.js. Możesz uruchomić kompilator za pomocą następującego polecenia:

$ npx tsc

Aby uruchomić skompilowane pliki JavaScript, możesz użyć polecenia, nodepo którym następuje ścieżka do pliku wejściowego. Na przykład, jeśli plik wejściowy to dist/index.js, możesz go uruchomić za pomocą następującego polecenia:

$ node dist/index.js

TypeScript zapewnia zaawansowane funkcje, takie jak klasy, interfejsy i wyliczenia, których można używać w aplikacjach Node.js. Oto kilka przykładów:

Klasy

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);

Podczas pracy z językiem TypeScript mogą wystąpić błędy, które nie zostaną przechwycone przez kompilator języka TypeScript. Aby debugować kod TypeScript, możesz użyć --inspectflagi z nodepoleceniem rozpoczęcia sesji debugowania. Następnie możesz użyć debugera, takiego jak VS Code, aby ustawić punkty przerwania i przejść przez kod.

$ node --inspect dist/index.js

TypeScript jest kompatybilny z wieloma popularnymi bibliotekami i frameworkami Node.js. Oto kilka przykładów:

Wyrazić

//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;
}

Oto kilka najlepszych praktyk dotyczących używania TypeScript z Node.js:

Użyj trybu ścisłego, aby wychwycić więcej błędów w czasie kompilacji.
Używaj interfejsów i typów, aby definiować kształt swoich danych i poprawiać czytelność kodu.
Służy tsconfig.jsondo określania opcji konfiguracji języka TypeScript dla projektu.
Używaj narzędzi, takich jak ESLint i Prettier, aby egzekwować jakość i spójność kodu.

Włączając tryb ścisły w TypeScript, możesz wykryć potencjalne błędy i problemy w czasie kompilacji, a nie w czasie wykonywania. Może to zaoszczędzić czas i wysiłek na dłuższą metę, unikając trudnych do debugowania błędów, które mogą wystąpić w środowisku produkcyjnym.

Aby włączyć tryb ścisły, dodaj "strict": truedo pliku tsconfig.json. Umożliwi to szereg ścisłych kontroli, takich jak:

Zakaz niejawnych typów
Wymuszanie kontroli zerowych
Nie zezwalanie na nieużywane zmienne i importy

Korzystanie z interfejsów i typów może sprawić, że kod będzie bardziej czytelny i łatwiejszy w utrzymaniu, zapewniając jasną definicję kształtu danych. Może to również ułatwić wychwytywanie błędów związanych z typem w czasie kompilacji.

Rozważmy na przykład następujący kod:

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}`);
}

Plik tsconfig.json służy do określania opcji konfiguracji TypeScript dla twojego projektu. Może to obejmować takie rzeczy jak:

Wersja języka TypeScript do użycia
Katalog główny twojego projektu
Katalog wyjściowy dla skompilowanych plików JavaScript

Używaj narzędzi, takich jak ESLint i Prettier, aby egzekwować jakość i spójność kodu.

ESLint i Prettier to narzędzia, które mogą pomóc w egzekwowaniu jakości i spójności kodu w bazie kodu TypeScript. ESLint może służyć do wychwytywania typowych błędów i egzekwowania standardów kodowania, podczas gdy Prettier może służyć do automatycznego formatowania kodu w spójny styl.

Korzystając z tych narzędzi, możesz zapewnić, że Twój kod jest łatwy do utrzymania i spójny w całym projekcie.

Ogólnie rzecz biorąc, te najlepsze praktyki mogą pomóc poprawić jakość i łatwość konserwacji bazy kodu TypeScript podczas korzystania z Node.js.

Wniosek

W tym artykule zbadaliśmy, jak używać TypeScript z Node.js i przedstawiliśmy przykłady, które pomogą Ci zacząć. TypeScript może pomóc wychwycić błędy przed uruchomieniem, poprawić czytelność kodu i łatwość konserwacji oraz korzystać z zaawansowanych funkcji, takich jak klasy, interfejsy i wyliczenia. Postępując zgodnie z najlepszymi praktykami i korzystając z popularnych bibliotek i struktur, możesz tworzyć skalowalne i łatwe w utrzymaniu aplikacje Node.js za pomocą języka TypeScript.