Bootcamp i backendudvikling med Node.js · Lektion

Konfiguration af tsconfig til Node-backendprojekter

Finjustér compilerindstillinger, modulopløsning og path aliases til en robust TypeScript-opsætning på serversiden.

Lektion 2 af 413 trin

Konfiguration af tsconfig til Node-backendprojekter er en gratis Bootcamp i backendudvikling med Node.js-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Bootcamp i backendudvikling med Node.js, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.

Hvorfor tsconfig er vigtig på serveren

Når du kører TypeScript på en Node.js-backend, er tsconfig.json den fælles sandhedskilde, der styrer, hvordan din kode typekontrolleres og kompileres til JavaScript.

compilerOptions justerer output, strenghed og modulsystem.
include / exclude afgør, hvilke filer der er en del af projektet.

En backend-konfiguration adskiller sig fra en frontend-konfiguration: Der er ingen DOM, ingen bundler, og Node indlæser den genererede JavaScript direkte. De rigtige indstillinger forebygger subtile fejl under kørsel og ødelagte importeringer.

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

Vælg den rigtige target

Indstillingen target styrer, hvilken JavaScript-version compileren genererer. På en backend er du ikke begrænset af gamle browsere, men kun af din Node.js-kørselstid.

Node 18 understøtter op til ES2022; Node 20+ understøtter ES2023.
En moderne target betyder, at funktioner som await på øverste niveau, klassefelter og Array.at() kompileres til naturlig kode i stedet for omfattende polyfills.

Tilpas target til den laveste Node-version, du udruller til. En for høj indstilling kan generere syntaks, som din kørselstid ikke kan fortolke.

// Works natively when target is ES2022 on Node 18+
const nums = [10, 20, 30];
console.log(nums.at(-1)); // 30

class Cache {
  store = new Map(); // class field
  set(k, v) { this.store.set(k, v); return this; }
}
console.log(new Cache().set("a", 1).store.get("a")); // 1

module og moduleResolution

Disse to indstillinger afgør, hvordan import- og require-sætninger genereres og løses.

module: Hvilken type modulsyntaks compileren genererer.
moduleResolution: Hvordan TypeScript finder filerne bag hver importspecificering.

For moderne Node-backends er "module": "NodeNext" sammen med "moduleResolution": "NodeNext" den anbefalede kombination. Den lærer TypeScript at respektere Nodes faktiske regler for opløsning, herunder type-feltet i package.json og forskellen mellem CommonJS og ESM.

{
  "compilerOptions": {
    "module": "NodeNext",
    "moduleResolution": "NodeNext"
  }
}

Valg mellem CommonJS og ESM

Den største enkeltbeslutning for en Node-backend er modulsystemet. Det styres af type-feltet i package.json, ikke af tsconfig alene.

"type": "commonjs" (eller udeladt): Filer bruger require / module.exports.
"type": "module": Filer er ESM og bruger import / export.

Med ESM får du await på øverste niveau og én samlet importsætning, men du skal skrive eksplicitte filendelser i relative importeringer. Med CommonJS får du bredere kompatibilitet med ældre biblioteker. Vælg ESM til nye projekter, medmindre en afhængighed kræver CommonJS.

{
  "name": "my-api",
  "type": "module",
  "main": "dist/index.js"
}

ESM kræver filendelser

Dette giver næsten alle problemer, når de skifter til ESM. Når module er NodeNext, og din pakke er "type": "module", skal relative importeringer i din kildekode indeholde .js-endelsen, selvom filen på disken ender med .ts.

TypeScript omskriver ikke importstier, så den specificering, du skriver, er præcis den, Node modtager under kørsel. Du skriver .js, fordi det er den fil, der findes efter kompileringen.

// src/user.service.ts
export function findUser(id) {
  return { id, name: "Ada" };
}

// src/index.ts  -- note the .js extension on a .ts file
import { findUser } from "./user.service.js";
console.log(findUser(7));

Slå strict-tilstand til

"strict": true er den mest værdifulde indstilling for backendens pålidelighed. Det er en samleindstilling, der aktiverer en gruppe kontroller på én gang.

strictNullChecks: null og undefined kan ikke længere tildeles overalt, hvilket fanger fejl med manglende værdier.
noImplicitAny: Alle værdier skal have en kendt eller udledelig type.
strictFunctionTypes, strictBindCallApply og flere.

På en server forebygger disse kontroller hele klasser af nedbrud i produktion, f.eks. når en egenskab læses fra et objekt, der kan være undefined.

function getPort(env) {
  // With strictNullChecks, env.PORT is string | undefined
  const raw = env.PORT;
  const port = raw ? Number(raw) : 3000;
  return port;
}
console.log(getPort({ PORT: "8081" })); // 8081
console.log(getPort({}));               // 3000

outDir, rootDir og build-layoutet

Disse indstillinger holder dit kompilerede output adskilt fra din kildekode.

rootDir: basismappen for dine inputfiler, normalt src.
outDir: her placeres den genererede JavaScript, normalt dist.

Hvis du indstiller rootDir, garanteres det, at mappestrukturen under src spejles nøjagtigt under dist. Uden denne indstilling udleder TypeScript roden fra dine filer, og en fil, der ligger uden for src, kan forskyde hele outputtræet og ødelægge din main-sti.

{
  "compilerOptions": {
    "rootDir": "src",
    "outDir": "dist",
    "sourceMap": true,
    "declaration": false
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Stialiaser med baseUrl og paths

Dybe relative importer som ../../../config/db er skrøbelige. Stialiaser giver dig mulighed for at skrive stabile og letlæselige specifikationer.

baseUrl: den mappe, som ikke-relative importer løses fra.
paths: en maplægning fra aliasmønstre til rigtige mapper.

En almindelig konvention er at mappe @/* til src/*, så ethvert modul kan importere fra @/services/user.service.js uanset sin egen dybde.

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]
    }
  }
}

Aliaser findes ikke ved kørsel

Her er den afgørende faldgrube: paths påvirker kun typekontrollen. TypeScript-kompileren omskriver ikke @/services/user.service.js til en rigtig relativ sti i den genererede JavaScript.

Derfor mislykkes Node ved kørsel med en fejl om et modul, der ikke blev fundet, medmindre du bygger bro over forskellen. Almindelige løsninger er:

En resolver til kørsel som tsconfig-paths (CommonJS) eller en loader.
En bundler som tsup eller esbuild, der indlejrer aliaserne.
Et trin efter bygningen, der omskriver stierne.

Husk altid: tsconfig beskriver typer; køretiden har brug for sin egen plan for aliaser.

Node-typer og hurtigere bygninger

Hvis du vil bruge globale værdier som process, Buffer og modulet fs med fuld typeunderstøttelse, skal du installere @types/node og lade TypeScript indlæse dem.

types: begrænser, hvilke globale typepakker der inkluderes (for eksempel kun ["node"]).
skipLibCheck: springer typekontrollen af .d.ts-filer i afhængigheder over, hvilket reducerer byggetiden markant.
esModuleInterop: giver dig mulighed for at skrive import express from "express" for standardeksporter fra CommonJS.

{
  "compilerOptions": {
    "types": ["node"],
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true
  }
}

En komplet backend-tsconfig

Her er det hele samlet i et robust udgangspunkt for en moderne ESM-backend til Node.js. Den kompilerer src til dist, håndhæver streng typning og bruger Node-indbygget modulopløsning.

Kombinér dette med "type": "module" i package.json og et byggescript med tsc -p tsconfig.json. Husk at håndtere stialiaser ved kørsel, hvis du aktiverer paths.

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "rootDir": "src",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "sourceMap": true,
    "types": ["node"],
    "baseUrl": ".",
    "paths": { "@/*": ["src/*"] }
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Hurtigt tjek

Test din forståelse af stialiaser i en backend-bygning til Node.

Besvar den i den interaktive lektion

Opsummering

Du ved nu, hvordan du konfigurerer tsconfig.json til et TypeScript-projekt på serversiden.

target: skal passe til din ældste Node-version (ES2022 til Node 18+).
module / moduleResolution: brug NodeNext for en korrekt Node-modulopløsning.
Feltet type i package.json styrer CommonJS kontra ESM; relative ESM-importer kræver .js-endelser.
strict: slå det til for at finde fejl med null og any før produktion.
rootDir / outDir: bevar et rent layout for bygningen fra src til dist.
paths: er fremragende for læsbarheden, men aliaser skal løses ved kørsel af en loader eller bundler.

Med disse indstillinger på plads får din Node-backend pålidelig typesikkerhed og en forudsigelig bygning.

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 22
Lektioner: 92

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Konfiguration af tsconfig til Node-backendprojekter” gratis?

Ja — hele teksten til “Konfiguration af tsconfig til Node-backendprojekter” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Bootcamp i backendudvikling med Node.js-kurset, skal du opgradere til CoddyKit PRO. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Konfiguration af tsconfig til Node-backendprojekter”?

Finjustér compilerindstillinger, modulopløsning og path aliases til en robust TypeScript-opsætning på serversiden. Du øver dig i Bootcamp i backendudvikling med Node.js med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Bootcamp i backendudvikling med Node.js?

Der kræves ingen tidligere erfaring. Bootcamp i backendudvikling med Node.js på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Konfiguration af tsconfig til Node-backendprojekter”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Bootcamp i backendudvikling med Node.js-lektion?

Ja. Alle Bootcamp i backendudvikling med Node.js-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Migrering fra CommonJS til native ES-moduler
Konfiguration af tsconfig til Node-backendprojekter
Typesikker miljøkonfiguration og runtime-validering
Hurtig iteration med tsx, hot reload og source maps

← Tilbage til Bootcamp i backendudvikling med Node.js