टिप्पणियों को देखते हुए, पहला भाग , मिश्रित राय का कारण बना, विशेष रूप से एनम भाग के संबंध में। कहीं मैं भी असहमत हो सकता हूं, दोनों मूल के लेखक के साथ, और कुछ टिप्पणियों के साथ। लेकिन जैसा कि पहले भाग के प्रारंभिक विवरण में संकेत दिया गया है, स्वच्छ कोड का पालन करने के लिए एक हठधर्मिता नहीं है, यह सिर्फ सिफारिशें हैं, जिसका पालन हर कोई अपनी आवश्यकताओं और विचारों के अनुरूप करता है।

ऑब्जेक्ट और डेटा संरचनाएं

प्रतिरक्षा का उपयोग करें

टाइपस्क्रिप्ट में टाइप सिस्टम आपको इंटरफ़ेस / क्लास के व्यक्तिगत गुणों को आसानी से फ़ील्ड (रीड-ओनली) के रूप में चिह्नित करने की अनुमति देता है। यह आपको कार्यात्मक रूप से काम करने की अनुमति देता है (अप्रत्याशित म्यूटेशन खराब है)। अधिक जटिल परिदृश्यों के लिए, एक अंतर्निहित Readonly प्रकार है जो T प्रकार लेता है और मैप किए गए प्रकारों ( मैप किए गए प्रकार देखें) का उपयोग करके अपने सभी केवल-पढ़ने के गुणों को चिह्नित करता है।

खराब:

 interface Config { host: string; port: string; db: string; } 

अच्छा:

 interface Config { readonly host: string; readonly port: string; readonly db: string; } 

किसी सरणी के मामले में, आप ReadonlyArray<T> का उपयोग करके ReadonlyArray<T> -पढ़ने के लिए सरणी बना सकते हैं। जो push() और fill() का उपयोग करके परिवर्तन की अनुमति नहीं देता है, लेकिन आप concat() और slice() उपयोग कर सकते हैं, वे मान नहीं बदलते हैं।

खराब:

 const array: number[] = [ 1, 3, 5 ]; array = []; // error array.push(100); // array will updated 

अच्छा:

 const array: ReadonlyArray<number> = [ 1, 3, 5 ]; array = []; // error array.push(100); // error 

केवल-पढ़ने के तर्क टाइपस्क्रिप्ट 3.4 की घोषणा करना थोड़ा आसान है ।

 function hoge(args: readonly string[]) { args.push(1); // error } 

शाब्दिक मूल्यों के लिए वरीयता का दावा ।

खराब:

 const config = { hello: 'world' }; config.hello = 'world'; //   const array = [ 1, 3, 5 ]; array[0] = 10; //   //    function readonlyData(value: number) { return { value }; } const result = readonlyData(100); result.value = 200; //   

अच्छा:

 //     const config = { hello: 'world' } as const; config.hello = 'world'; //  //     const array = [ 1, 3, 5 ] as const; array[0] = 10; //  //        function readonlyData(value: number) { return { value } as const; } const result = readonlyData(100); result.value = 200; //  

प्रकार बनाम इंटरफेस

जब आपको संघ या चौराहे की आवश्यकता हो तब प्रकारों का उपयोग करें। जब आप extends या implements करना चाहते हैं तो इंटरफ़ेस का उपयोग करें। हालांकि, एक सख्त नियम मौजूद नहीं है, जो आपके लिए काम करता है उसका उपयोग करें। अधिक विस्तृत विवरण के लिए, टाइपस्क्रिप्ट में type और interface बीच अंतर के बारे में इन उत्तरों को देखें।

खराब:

 interface EmailConfig { // ... } interface DbConfig { // ... } interface Config { // ... } //... type Shape = { // ... } 

अच्छा:

 type EmailConfig = { // ... } type DbConfig = { // ... } type Config = EmailConfig | DbConfig; // ... interface Shape { // ... } class Circle implements Shape { // ... } class Square implements Shape { // ... } 

कक्षाएं

कक्षाएं छोटी होनी चाहिए

एक वर्ग का आकार उसकी जिम्मेदारी से मापा जाता है। एकमात्र जिम्मेदारी के सिद्धांत का पालन करते हुए, कक्षा छोटा होना चाहिए।

खराब:

 class Dashboard { getLanguage(): string { /* ... */ } setLanguage(language: string): void { /* ... */ } showProgress(): void { /* ... */ } hideProgress(): void { /* ... */ } isDirty(): boolean { /* ... */ } disable(): void { /* ... */ } enable(): void { /* ... */ } addSubscription(subscription: Subscription): void { /* ... */ } removeSubscription(subscription: Subscription): void { /* ... */ } addUser(user: User): void { /* ... */ } removeUser(user: User): void { /* ... */ } goToHomePage(): void { /* ... */ } updateProfile(details: UserDetails): void { /* ... */ } getVersion(): string { /* ... */ } // ... } 

अच्छा:

 class Dashboard { disable(): void { /* ... */ } enable(): void { /* ... */ } getVersion(): string { /* ... */ } } //  ,       // ... 

उच्च सामंजस्य कम बंधन

सामंजस्य उस डिग्री को निर्धारित करता है जिससे एक वर्ग के सदस्य एक दूसरे से संबंधित हैं। आदर्श रूप से, एक कक्षा के सभी क्षेत्रों का उपयोग प्रत्येक विधि द्वारा किया जाना चाहिए। हम कहते हैं कि वर्ग जितना संभव हो उतना जुड़ा हुआ है । व्यवहार में, हालांकि, यह हमेशा संभव नहीं है और यहां तक ​​कि अवांछनीय भी है। हालांकि, आपको यह सुनिश्चित करना होगा कि सामंजस्य अधिक हो।

कनेक्टिविटी यह भी बताती है कि दो वर्ग कैसे संबंधित हैं या एक-दूसरे पर निर्भर हैं। यदि उनमें से एक में परिवर्तन दूसरे को प्रभावित नहीं करते हैं तो कक्षाएं शिथिल युग्मित मानी जाती हैं।

खराब:

 class UserManager { // :         . //   ,    ,    //      ,     , //       `emailSender`. constructor( private readonly db: Database, private readonly emailSender: EmailSender) { } async getUser(id: number): Promise<User> { return await db.users.findOne({ id }); } async getTransactions(userId: number): Promise<Transaction[]> { return await db.transactions.find({ userId }); } async sendGreeting(): Promise<void> { await emailSender.send('Welcome!'); } async sendNotification(text: string): Promise<void> { await emailSender.send(text); } async sendNewsletter(): Promise<void> { // ... } } 

अच्छा:

 class UserService { constructor(private readonly db: Database) { } async getUser(id: number): Promise<User> { return await this.db.users.findOne({ id }); } async getTransactions(userId: number): Promise<Transaction[]> { return await this.db.transactions.find({ userId }); } } class UserNotifier { constructor(private readonly emailSender: EmailSender) { } async sendGreeting(): Promise<void> { await this.emailSender.send('Welcome!'); } async sendNotification(text: string): Promise<void> { await this.emailSender.send(text); } async sendNewsletter(): Promise<void> { // ... } } 

वंशानुक्रम पर रचना को प्राथमिकता दें

जैसा कि फोर्थ गैंग के डिज़ाइन पैटर्न में कहा गया है, आपको करना चाहिए
जहाँ भी आप कर सकते हैं, विरासत की संरचना को प्राथमिकता दें । वंशानुक्रम का उपयोग करने के कई अच्छे कारण हैं और रचना का उपयोग करने के कई अच्छे कारण हैं। इस सिद्धांत का सार यह है कि यदि आपका दिमाग सहज रूप से विरासत में आता है, तो यह सोचने की कोशिश करें कि क्या रचना आपकी समस्या को बेहतर बना सकती है। कुछ मामलों में, यह कर सकता है।

तब आप पूछ सकते हैं: "मुझे विरासत का उपयोग कब करना चाहिए?" यह आपकी समस्या पर निर्भर करता है, लेकिन यह एक सभ्य सूची है जब विरासत रचना की तुलना में अधिक समझ में आता है:

1. आपका वंशानुक्रम एक "है-एक" संबंध है और "एक" संबंध नहीं है (मानव-> पशु बनाम उपयोगकर्ता-> उपयोगकर्ता-विवरण)।
2. आप बेस कक्षाओं से कोड का पुन: उपयोग कर सकते हैं (लोग सभी जानवरों की तरह आगे बढ़ सकते हैं)।
3. आप बेस क्लास को बदलकर व्युत्पन्न कक्षाओं में वैश्विक परिवर्तन करना चाहते हैं। (उन्हें स्थानांतरित करते समय सभी जानवरों में कैलोरी व्यय में परिवर्तन)।

खराब:

 class Employee { constructor( private readonly name: string, private readonly email: string) { } // ... } // ,   Employees ""  . EmployeeTaxData    Employee class EmployeeTaxData extends Employee { constructor( name: string, email: string, private readonly ssn: string, private readonly salary: number) { super(name, email); } // ... } 

अच्छा:

 class Employee { private taxData: EmployeeTaxData; constructor( private readonly name: string, private readonly email: string) { } setTaxData(ssn: string, salary: number): Employee { this.taxData = new EmployeeTaxData(ssn, salary); return this; } // ... } class EmployeeTaxData { constructor( public readonly ssn: string, public readonly salary: number) { } // ... } 

कॉल चेन का उपयोग करें

यह पैटर्न बहुत उपयोगी है और आमतौर पर कई पुस्तकालयों में उपयोग किया जाता है। इससे आपका कोड अभिव्यंजक और कम क्रिया हो सकता है। इस कारण से, तरीकों की एक श्रृंखला का उपयोग करें और देखें कि आपका कोड कितना साफ होगा।

खराब:

 class QueryBuilder { private collection: string; private pageNumber: number = 1; private itemsPerPage: number = 100; private orderByFields: string[] = []; from(collection: string): void { this.collection = collection; } page(number: number, itemsPerPage: number = 100): void { this.pageNumber = number; this.itemsPerPage = itemsPerPage; } orderBy(...fields: string[]): void { this.orderByFields = fields; } build(): Query { // ... } } // ... const queryBuilder = new QueryBuilder(); queryBuilder.from('users'); queryBuilder.page(1, 100); queryBuilder.orderBy('firstName', 'lastName'); const query = queryBuilder.build(); 

अच्छा:

 class QueryBuilder { private collection: string; private pageNumber: number = 1; private itemsPerPage: number = 100; private orderByFields: string[] = []; from(collection: string): this { this.collection = collection; return this; } page(number: number, itemsPerPage: number = 100): this { this.pageNumber = number; this.itemsPerPage = itemsPerPage; return this; } orderBy(...fields: string[]): this { this.orderByFields = fields; return this; } build(): Query { // ... } } // ... const query = new QueryBuilder() .from('users') .page(1, 100) .orderBy('firstName', 'lastName') .build(); 

जारी रखने के लिए ...