Node.js बैकएंड विकास बूटकैंप · पाठ

Node बैकएंड परियोजनाओं के लिए tsconfig कॉन्फ़िगर करना

मज़बूत सर्वर-साइड TypeScript सेटअप के लिए कंपाइलर विकल्प, मॉड्यूल रिज़ॉल्यूशन और पथ उपनाम ट्यून कीजिए।

पाठ 2, कुल 4 में से13 चरण

Node बैकएंड परियोजनाओं के लिए tsconfig कॉन्फ़िगर करना, CoddyKit पर Node.js बैकएंड विकास बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Node.js बैकएंड विकास बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Node.js बैकएंड विकास बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

सर्वर पर tsconfig क्यों महत्वपूर्ण है

जब आप Node.js बैकएंड पर TypeScript चलाते हैं, तो tsconfig.json आपके कोड की प्रकार-जाँच और JavaScript में संकलन को नियंत्रित करने वाला सत्य का एकमात्र स्रोत होता है।

compilerOptions आउटपुट, कठोरता और मॉड्यूल प्रणाली को समायोजित करते हैं।
include / exclude तय करते हैं कि कौन-सी फ़ाइलें प्रोजेक्ट का हिस्सा हैं।

बैकएंड का कॉन्फ़िगरेशन फ़्रंटएंड से अलग होता है: यहाँ DOM या बंडलर नहीं होता और Node सीधे निर्मित JavaScript लोड करता है। इन विकल्पों को सही ढंग से चुनने से सूक्ष्म रनटाइम क्रैश और टूटे हुए आयात रुकते हैं।

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

सही target चुनना

target विकल्प नियंत्रित करता है कि कंपाइलर JavaScript का कौन-सा संस्करण बनाए। बैकएंड में आप पुराने ब्राउज़र से सीमित नहीं होते, केवल अपने Node.js रनटाइम से सीमित होते हैं।

Node 18 अधिकतम ES2022 का समर्थन करता है; Node 20+ ES2023 का समर्थन करता है।
आधुनिक target का अर्थ है कि शीर्ष-स्तरीय await, क्लास फ़ील्ड और Array.at() जैसी सुविधाएँ भारी पॉलीफ़िल के बजाय मूल कोड में संकलित होती हैं।

target को उस न्यूनतम Node संस्करण से मिलाएं जिस पर आप तैनात करते हैं। इसे बहुत ऊँचा रखने पर ऐसा वाक्यविन्यास बन सकता है जिसे आपका रनटाइम पढ़ न सके।

// 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 और moduleResolution

ये दोनों विकल्प तय करते हैं कि import और require कथन कैसे बनाए और खोजे जाएंगे।

module: कंपाइलर किस प्रकार का मॉड्यूल वाक्यविन्यास बनाए।
moduleResolution: TypeScript प्रत्येक आयात निर्दिष्टकर्ता के पीछे की फ़ाइलों को कैसे खोजे।

आधुनिक Node बैकएंड के लिए "module": "NodeNext" और "moduleResolution": "NodeNext" की जोड़ी अनुशंसित है। यह TypeScript को Node के वास्तविक समाधान नियमों का सम्मान करना सिखाती है, जिनमें package.json का type फ़ील्ड और CommonJS तथा ESM के बीच का अंतर शामिल है।

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

CommonJS बनाम ESM का निर्णय

Node बैकएंड के लिए सबसे बड़ा एकल निर्णय मॉड्यूल प्रणाली है। यह अकेले tsconfig से नहीं, बल्कि package.json के type फ़ील्ड से संचालित होती है।

"type": "commonjs" (या अनुपस्थित): फ़ाइलें require / module.exports का उपयोग करती हैं।
"type": "module": फ़ाइलें ESM होती हैं और import / export का उपयोग करती हैं।

ESM से आपको शीर्ष-स्तरीय await और एकल आयात वाक्यविन्यास मिलता है, लेकिन सापेक्ष आयातों में स्पष्ट फ़ाइल विस्तार लिखने पड़ते हैं। CommonJS से पुरानी लाइब्रेरी के साथ अधिक व्यापक संगतता मिलती है। जब तक कोई निर्भरता CommonJS के लिए बाध्य न करे, नए प्रोजेक्ट के लिए ESM चुनें।

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

ESM में फ़ाइल विस्तार आवश्यक हैं

ESM पर जाने वाले लगभग सभी लोगों को यह समस्या आती है। जब module का मान NodeNext हो और आपका पैकेज "type": "module" हो, तो आपके स्रोत में सापेक्ष आयातों में .js विस्तार शामिल होना चाहिए, भले ही डिस्क पर फ़ाइल का अंत .ts से होता हो।

TypeScript आयात पथों को दोबारा नहीं लिखता, इसलिए आप जो निर्दिष्टकर्ता लिखते हैं, रनटाइम पर Node को ठीक वही मिलता है। आप .js इसलिए लिखते हैं क्योंकि संकलन के बाद मौजूद रहने वाली फ़ाइल वही होगी।

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

strict मोड चालू करना

"strict": true बैकएंड की विश्वसनीयता के लिए सबसे मूल्यवान विकल्प है। यह एक ऐसा समग्र विकल्प है जो एक साथ जाँचों के पूरे समूह को सक्षम करता है।

strictNullChecks: null और undefined अब हर जगह असाइन नहीं किए जा सकते, जिससे अनुपस्थित-मान संबंधी त्रुटियाँ पकड़ी जाती हैं।
noImplicitAny: हर मान का ज्ञात या अनुमानित प्रकार होना आवश्यक है।
strictFunctionTypes, strictBindCallApply और अन्य।

सर्वर पर ये जाँचें उत्पादन में होने वाली कई प्रकार की क्रैश रोकती हैं, जैसे ऐसे ऑब्जेक्ट की प्रॉपर्टी पढ़ना जो 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 और बिल्ड लेआउट

ये विकल्प आपके संकलित आउटपुट को आपके स्रोत से साफ़ तौर पर अलग रखते हैं।

rootDir: आपकी input files का base folder, आमतौर पर src।
outDir: जहाँ उत्सर्जित JavaScript रखा जाता है, आमतौर पर dist।

rootDir सेट करने से यह सुनिश्चित होता है कि src के अंदर की directory structure हूबहू dist के अंदर दोहराई जाए। इसके बिना TypeScript आपकी files से root का अनुमान लगाता है, और src के बाहर की कोई अनचाही file पूरे output tree को बदल सकती है, जिससे आपका main path टूट सकता है।

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

baseUrl और paths के साथ पाथ उपनाम

../../../config/db जैसे गहरे relative imports अस्थिर होते हैं। पाथ उपनाम आपको स्थिर और आसानी से पढ़े जाने वाले specifiers लिखने देते हैं।

baseUrl: वह directory जहाँ से non-relative imports का समाधान किया जाता है।
पाथ: alias patterns को वास्तविक folders से जोड़ने वाला map।

एक सामान्य convention है कि @/* को src/* से map किया जाए, ताकि कोई भी module अपनी गहराई की परवाह किए बिना @/services/user.service.js से import कर सके।

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

उपनाम रनटाइम पर मौजूद नहीं होते

यहाँ महत्वपूर्ण बात है: paths केवल type-checking को प्रभावित करता है। TypeScript compiler नहीं करता कि उत्सर्जित JavaScript में @/services/user.service.js को वास्तविक relative path में बदल दे।

इसलिए gap को पाटे बिना Node रनटाइम पर module-not-found error के साथ विफल हो जाएगा। सामान्य समाधान:

tsconfig-paths (CommonJS) जैसा runtime resolver या कोई loader।
tsup या esbuild जैसा bundler, जो aliases को inline कर दे।
build के बाद चलने वाला step, जो paths को फिर से लिख दे।

हमेशा याद रखें: tsconfig types का वर्णन करता है; aliases के लिए runtime को अपनी योजना चाहिए।

Node types और builds को तेज़ करना

process, Buffer और fs module जैसे globals को पूर्ण typing के साथ इस्तेमाल करने के लिए @types/node install करें और TypeScript को उन्हें अपने-आप लेने दें।

types: शामिल किए जाने वाले global type packages को सीमित करता है, जैसे केवल ["node"]।
skipLibCheck: dependencies में मौजूद .d.ts files की type-checking छोड़ देता है, जिससे build time बहुत कम हो जाता है।
esModuleInterop: CommonJS default exports के लिए आपको import express from "express" लिखने देता है।

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

एक पूर्ण backend tsconfig

सब कुछ एक साथ रखते हुए, यहाँ आधुनिक ESM Node.js backend के लिए एक भरोसेमंद शुरुआती बिंदु है। यह src को dist में compile करता है, strictness लागू करता है और Node-native resolution का इस्तेमाल करता है।

इसे package.json में "type": "module" और tsc -p tsconfig.json की build script के साथ इस्तेमाल करें। यदि आप paths सक्षम करते हैं, तो runtime पर path aliases को संभालना याद रखें।

{
  "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"]
}

त्वरित जाँच

Node backend build में path aliases की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

अब आप जानते हैं कि server-side TypeScript project के लिए tsconfig.json को कैसे configure करना है।

target: अपने सबसे पुराने Node version से मिलाएँ, जैसे Node 18+ के लिए ES2022।
module / moduleResolution: वास्तविक Node resolution के लिए NodeNext का इस्तेमाल करें।
package.json में मौजूद type field CommonJS और ESM के बीच चयन करता है; ESM relative imports में .js extensions आवश्यक हैं।
strict: production से पहले null और any bugs पकड़ने के लिए इसे चालू करें।
rootDir / outDir: src से dist तक का साफ़ build layout बनाए रखें।
पाथ: readability के लिए उपयोगी हैं, लेकिन aliases का runtime पर loader या bundler द्वारा समाधान होना चाहिए।

इन विकल्पों को सही ढंग से सेट करने पर आपके Node backend को भरोसेमंद type safety और अनुमानित build मिलता है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ JavaScript सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 22
पाठ: 92

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Node बैकएंड परियोजनाओं के लिए tsconfig कॉन्फ़िगर करना” पाठ निःशुल्क है?

हाँ—“Node बैकएंड परियोजनाओं के लिए tsconfig कॉन्फ़िगर करना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Node.js बैकएंड विकास बूटकैंप पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Node.js बैकएंड विकास बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Node बैकएंड परियोजनाओं के लिए tsconfig कॉन्फ़िगर करना” में मैं क्या सीखूँगा?

मज़बूत सर्वर-साइड TypeScript सेटअप के लिए कंपाइलर विकल्प, मॉड्यूल रिज़ॉल्यूशन और पथ उपनाम ट्यून कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Node.js बैकएंड विकास बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Node.js बैकएंड विकास बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Node.js बैकएंड विकास बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“Node बैकएंड परियोजनाओं के लिए tsconfig कॉन्फ़िगर करना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Node.js बैकएंड विकास बूटकैंप पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Node.js बैकएंड विकास बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

CommonJS से नेटिव ES मॉड्यूल में स्थानांतरण
Node बैकएंड परियोजनाओं के लिए tsconfig कॉन्फ़िगर करना
टाइप-सुरक्षित पर्यावरण कॉन्फ़िगरेशन और रनटाइम सत्यापन
tsx, हॉट रीलोड और सोर्स मैप से तेज़ पुनरावृत्ति

← Node.js बैकएंड विकास बूटकैंप पर वापस जाएँ