Kem Intensif Pembangunan Backend Node.js · Pelajaran

Mengkonfigurasi tsconfig untuk Projek Pelayan Node

Perhalus pilihan penyusun, penyelesaian modul dan alias laluan untuk persediaan TypeScript sisi pelayan yang kukuh.

Pelajaran 2 daripada 413 langkah

Mengkonfigurasi tsconfig untuk Projek Pelayan Node ialah pelajaran Kem Intensif Pembangunan Backend Node.js percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Backend Node.js, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Backend Node.js merangkumi sejumlah 4 pelajaran.

Mengapa tsconfig Penting pada Pelayan

Apabila anda menjalankan TypeScript pada bahagian belakang Node.js, tsconfig.json ialah sumber kebenaran tunggal yang mengawal cara kod anda disemak jenisnya dan disusun kepada JavaScript.

compilerOptions melaraskan output, keketatan dan sistem modul.
include / exclude menentukan fail yang menjadi sebahagian daripada projek.

Konfigurasi bahagian belakang berbeza daripada konfigurasi bahagian hadapan: tiada DOM, tiada penggabung, dan Node memuatkan JavaScript yang dihasilkan secara terus. Menetapkan pilihan ini dengan betul mengelakkan ranap masa jalan yang sukar dikesan dan import yang rosak.

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

Memilih target yang Betul

Pilihan target mengawal versi JavaScript yang dihasilkan oleh compiler. Pada bahagian belakang, anda tidak dikekang oleh pelayar lama, sebaliknya hanya oleh masa jalan Node.js anda.

Node 18 menyokong sehingga ES2022; Node 20+ menyokong ES2023.
target moden bermaksud ciri seperti await tahap atas, medan class dan Array.at() disusun kepada kod natif dan bukannya polyfill yang besar.

Padankan target dengan versi Node terendah yang anda gunakan untuk pelancaran. Menetapkannya terlalu tinggi boleh menghasilkan sintaks yang tidak dapat dihuraikan oleh masa jalan anda.

// 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 dan moduleResolution

Kedua-dua pilihan ini menentukan cara pernyataan import dan require dihasilkan serta diselesaikan.

module: jenis sintaks modul yang dihasilkan oleh compiler.
moduleResolution: cara TypeScript mencari fail di sebalik setiap penentu import.

Untuk bahagian belakang Node moden, "module": "NodeNext" bersama "moduleResolution": "NodeNext" ialah pasangan yang disyorkan. Pasangan ini mengajar TypeScript supaya mematuhi peraturan penyelesaian sebenar Node, termasuk medan type dalam package.json serta perbezaan antara CommonJS dan ESM.

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

Keputusan CommonJS berbanding ESM

Keputusan terbesar untuk bahagian belakang Node ialah sistem modul. Sistem ini ditentukan oleh medan type dalam package.json, bukan oleh tsconfig sahaja.

"type": "commonjs" (atau tidak disertakan): fail menggunakan require / module.exports.
"type": "module": fail ialah ESM dan menggunakan import / export.

Dengan ESM, anda mendapat await tahap atas dan satu sintaks import, tetapi mesti menulis sambungan fail secara jelas dalam import relatif. Dengan CommonJS, anda mendapat keserasian yang lebih luas dengan pustaka lama. Pilih ESM untuk projek baharu kecuali kebergantungan memaksa penggunaan CommonJS.

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

ESM Memerlukan Sambungan Fail

Perkara ini hampir menyusahkan semua orang yang beralih kepada ESM. Apabila module ialah NodeNext dan pakej anda ialah "type": "module", import relatif dalam kod sumber mesti menyertakan sambungan .js, walaupun fail pada cakera berakhir dengan .ts.

TypeScript tidak menulis semula laluan import, jadi penentu yang anda tulis adalah tepat seperti yang diterima oleh Node semasa masa jalan. Anda menulis .js kerana itulah fail yang akan wujud selepas penyusunan.

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

Hidupkan Mod strict

"strict": true ialah pilihan paling bernilai untuk kebolehpercayaan bahagian belakang. Pilihan ini ialah payung yang mengaktifkan sekumpulan pemeriksaan serentak.

strictNullChecks: null dan undefined tidak lagi boleh ditetapkan kepada semua perkara, sekali gus mengesan pepijat nilai yang tiada.
noImplicitAny: setiap nilai mesti mempunyai jenis yang diketahui atau boleh disimpulkan.
strictFunctionTypes, strictBindCallApply dan banyak lagi.

Pada pelayan, pemeriksaan ini menghalang keseluruhan kelas ranap dalam pengeluaran, seperti membaca sifat daripada objek yang mungkin 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 dan Susun Atur Binaan

Pilihan ini memastikan output tersusun anda diasingkan dengan kemas daripada sumber anda.

rootDir: folder asas bagi fail input anda, biasanya src.
outDir: lokasi JavaScript yang dijana, biasanya dist.

Menetapkan rootDir menjamin struktur direktori di bawah src dicerminkan tepat di bawah dist. Tanpanya, TypeScript membuat inferens akar berdasarkan fail anda, dan fail tersesat di luar src boleh mengubah keseluruhan pepohon output, lalu merosakkan laluan main anda.

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

Alias Laluan dengan baseUrl dan paths

Import relatif yang panjang seperti ../../../config/db mudah rosak. Alias laluan membolehkan anda menulis penentu yang stabil dan mudah dibaca.

baseUrl: direktori yang menjadi titik mula penyelesaian import bukan relatif.
paths: pemetaan corak alias kepada folder sebenar.

Konvensyen yang biasa digunakan ialah memetakan @/* kepada src/*, supaya mana-mana modul boleh mengimport daripada @/services/user.service.js tanpa mengira kedalamannya sendiri.

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

Alias Tidak Wujud semasa Runtime

Inilah perangkap penting: paths hanya mempengaruhi pemeriksaan jenis. Pengompil TypeScript tidak menulis semula @/services/user.service.js kepada laluan relatif sebenar dalam JavaScript yang dijana.

Oleh itu, Node akan gagal semasa runtime dengan ralat modul tidak ditemui melainkan anda merapatkan jurang ini. Penyelesaian yang biasa digunakan:

Penyelesai runtime seperti tsconfig-paths (CommonJS) atau pemuat.
Penghimpun seperti tsup atau esbuild yang memasukkan alias secara terus.
Langkah selepas binaan yang menulis semula laluan.

Sentiasa ingat: tsconfig menerangkan jenis; runtime memerlukan pelannya sendiri untuk alias.

Jenis Node dan Mempercepat Binaan

Untuk menggunakan global seperti process, Buffer dan modul fs dengan penaipan penuh, pasang @types/node dan biarkan TypeScript menggunakannya.

types: mengehadkan pakej jenis global yang disertakan (contohnya, hanya ["node"]).
skipLibCheck: melangkau pemeriksaan jenis bagi fail .d.ts dalam kebergantungan, sekali gus mengurangkan masa binaan dengan ketara.
esModuleInterop: membolehkan anda menulis import express from "express" untuk eksport lalai CommonJS.

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

tsconfig Backend yang Lengkap

Dengan menggabungkan semuanya, berikut ialah titik permulaan yang kukuh untuk backend Node.js ESM moden. Ia menyusun src kepada dist, menguatkuasakan ketegasan dan menggunakan penyelesaian asli Node.

Gabungkan ini dengan "type": "module" dalam package.json serta skrip binaan tsc -p tsconfig.json. Ingat untuk mengendalikan alias laluan semasa runtime jika anda mendayakan 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"]
}

Semakan Pantas

Uji pemahaman anda tentang alias laluan dalam binaan backend Node.

Jawab dalam pelajaran interaktif

Imbas Kembali

Sekarang anda tahu cara mengkonfigurasi tsconfig.json untuk projek TypeScript pada sisi pelayan.

target: sepadankan dengan versi Node terendah anda (ES2022 untuk Node 18+).
module / moduleResolution: gunakan NodeNext untuk penyelesaian Node yang tepat.
medan type dalam package.json menentukan CommonJS berbanding ESM; import relatif ESM memerlukan sambungan .js.
strict: hidupkannya untuk mengesan pepijat null dan any sebelum pengeluaran.
rootDir / outDir: kekalkan susun atur binaan src kepada dist yang kemas.
paths: bagus untuk kebolehbacaan, tetapi alias mesti diselesaikan semasa runtime oleh pemuat atau penghimpun.

Dengan pilihan ini ditetapkan dengan betul, backend Node anda memperoleh keselamatan jenis yang boleh dipercayai dan binaan yang boleh dijangka.

Percuma untuk bermula

Pelajari JavaScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 22
Pelajaran: 92

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengkonfigurasi tsconfig untuk Projek Pelayan Node” percuma?

Ya — teks penuh “Mengkonfigurasi tsconfig untuk Projek Pelayan Node” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Kem Intensif Pembangunan Backend Node.js, tingkat taraf kepada CoddyKit PRO. Kursus Kem Intensif Pembangunan Backend Node.js merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengkonfigurasi tsconfig untuk Projek Pelayan Node”?

Perhalus pilihan penyusun, penyelesaian modul dan alias laluan untuk persediaan TypeScript sisi pelayan yang kukuh. Anda berlatih Kem Intensif Pembangunan Backend Node.js menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Backend Node.js?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Backend Node.js di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Mengkonfigurasi tsconfig untuk Projek Pelayan Node” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Backend Node.js ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Backend Node.js menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Berpindah daripada CommonJS kepada Modul ES Asli
Mengkonfigurasi tsconfig untuk Projek Pelayan Node
Konfigurasi Persekitaran Selamat Jenis dan Pengesahan Masa Jalan
Lelaran Pantas dengan tsx, Muat Semula Panas dan Peta Sumber

← Kembali ke Kem Intensif Pembangunan Backend Node.js