כיצד להשתמש במרחבי שמות ב-TypeScript

התנגשות שמות מתרחשת כאשר שני רכיבי קוד או יותר משתמשים באותו שם עבור משתנה, פונקציה או מחלקה. הם נפוצים בפרויקטים גדולים שבהם אנשים רבים עובדים על אותו בסיס קוד. הם יכולים להקשות לקבוע איזה רכיב קוד אחראי לבאגים.

באמצעות מרחבי שמות, אתה יכול לארגן ולנהל את הקוד שלך כך שקבוצות של רכיבים קשורים יהיו תחת מזהה משותף. זה יפחית את הסיכון של התנגשויות שמות.

יצירת מרחב שמות

אתה יכול ליצור מרחבי שמות ב-TypeScript באמצעות ה מרחב שמות מילת מפתח. עקוב אחריו עם מזהה כדי לתת שם למרחב השמות ובלוק מוקף בסוגרים מסולסלים. התחביר דומה לזה שהיית משתמש בו ליצור מחלקה ב-JavaScript.

לדוגמה:

מרחב שמות דוגמא {}

לאחר מכן תוכל להכריז על חברים במרחב השמות - משתנים, פונקציות ומחלקות - בתוך בלוק מרחב השמות:

מרחב שמות דוגמא {
יְצוּאפוּנקצִיָהפו(): בָּטֵל{
לְנַחֵם.עֵץ("זוהי פונקציה בתוך מרחב השמות לדוגמה");
 }
יְצוּאמעמד בר {
 תכונה: חוּט;
בַּנַאִי(תכונה: חוּט) {
זֶה.property = נכס;
 }
 }
יְצוּאconst baz = "זהו משתנה מרחב שמות"
}

בדוגמה למעלה, פו, בַּר, ו baz חברים ב- דוגמא מרחב שמות. כברירת מחדל, אתה יכול לגשת רק לחברים של מרחב שמות בתוך אותו מרחב שמות. להשתמש ב יְצוּא מילת מפתח כדי להפוך כל חבר במרחב השמות לנגיש מחוצה לו.

אתה יכול לגשת לכל החברים הזמינים לציבור של מרחב שמות על ידי קריאה לשם החבר של מרחב השמות באמצעות סימון נקודות:

Example.foo(); // זוהי פונקציה בתוך מרחב השמות לדוגמה
const בר = חָדָשׁ דוגמא. בַּר("חוּט");
לְנַחֵם.log (bar.property); // מחרוזת
לְנַחֵם.log (Example.baz); // זהו משתנה מרחב שמות

מקנון מרחבי שמות

TypeScript מאפשר לך לקנן מרחבי שמות בתוך מרחבי שמות אחרים כדי ליצור מבנה היררכי עבור הקוד שלך. קינון מרחבי שמות יכול להפחית עוד יותר את הסיכונים של התנגשויות שמות על ידי קיבוץ מרחבי שמות קשורים תחת מזהה משותף.

לדוגמה:

מרחב שמות דוגמא {
יְצוּאconst property_1 = "פו";
יְצוּאמרחב שמות בר {
יְצוּאconst printFoo = פוּנקצִיָה () {
לְנַחֵם.log (property_1);
 };
 }
יְצוּאמרחב שמות Baz {
יְצוּאמעמד פו {
 תכונה: חוּט;
בַּנַאִי(תכונה: חוּט) {
זֶה.property = נכס;
 }
 }
 }
}

גוש הקוד שלמעלה מספק דוגמה למרחב שמות מקונן. ה דוגמא מרחב השמות הוא מרחב השמות ברמה העליונה, המכיל את בַּר מרחב השמות וה- באז מרחב שמות.

אתה יכול לגשת למאפיינים במרחב שמות מקונן באמצעות סימון נקודות העוקב אחר המבנה ההיררכי שיצרת.

לדוגמה:

לְנַחֵם.log (Example.property_1); // פו
דוגמא. Bar.printFoo() // פו
const פו = חָדָשׁ דוגמא. באז. פו("דוגמא")

קוד דוגמה זה ניגש לכל חבר במרחב השמות דרך מרחב השמות האב. גישה ישירה למאפיין, במקום דרך מרחב השמות האב שלו, תגרום לשגיאה:

Example.printFoo()
// שגיאה TS2339: המאפיין 'printFoo' אינו קיים בסוג 'typeof Example'

למרות שמרחבי שמות יכולים לעזור לך לארגן את הקוד שלך, מרחבי שמות מקוננים עמוקים עשויים לייצר אפקט הפוך. מרחבי שמות מקוננים עמוקים הופכים את הקוד שלך לקשה יותר לקריאה ולתחזוקה.

כינויי מרחב שמות

כינוי מרחב שמות הוא שם מקוצר שניתן לחבר מרחב שמות, מה שמקל על ההפניה.

אתה יכול ליצור כינוי מרחב שמות באמצעות ה יְבוּא מילת מפתח ואחריה השם שברצונך להקצות לכינוי. לאחר מכן, הקצה את יְבוּא מילת מפתח ושם הכינוי לחבר מרחב שמות.

לדוגמה:

מרחב שמות אוטו {
יְצוּאמרחב שמות טסלה {
יְצוּאמעמד ModelX {
 לִיצוֹר(): חוּט {
לַחֲזוֹר'דגם X נוצר'
 }
 }
 }
יְצוּאמרחב שמות טויוטה {
יְצוּאמעמד קאמרי {}
 }
יְצוּאמרחב שמות פורד {
יְצוּאמעמד מוסטנג {}
 }
}
// יצירת הכינוי
יְבוּא טסלה = מכונית. טסלה
const modelX = חָדָשׁ טסלה. ModelX()
modelX.create() // דגם X נוצר

דוגמה זו יוצרת כינוי עבור אוטו. טסלה מרחב שמות. אתה יכול להשתמש בכינוי זה כדי לגשת למאפיינים של טסלה מרחב שמות, כמו מחלקת ModelX, בקלות רבה יותר.

שימוש במרחבי שמות במספר קבצים

כדי להשתמש במרחב שמות בקובץ אחר, עליך לייבא אותו. ייבוא ​​מרחבי שמות שונה מייבוא ​​משתנים, פונקציות, מחלקות וכו'. תלוי בפרויקט שלך מערכת מודול, אתה יכול לייבא אותם באמצעות לִדרוֹשׁ או ה יְבוּא מילת מפתח.

עם זאת, ניתן לייבא רק מרחבי שמות באמצעות ההנחיה המשולשת, שהיא הערה בשורה אחת המכילה תג XML.

לדוגמה:

// main.ts
/// 
Example.foo()

דוגמה זו משתמשת בהנחיית האלכסון המשולש בתוך a main.ts קוֹבֶץ. ההוראה מתייחסת ל index.ts קובץ, המכיל את דוגמא מרחב שמות. ללא ייבוא, מרחב השמות זמין רק בתוך אותו קובץ שמגדיר אותו.

לאחר הפניה ל index.ts קובץ, אתה יכול לגשת ל דוגמא מרחב השמות והחברים הזמינים לציבור שלו. לדוגמה, אתה יכול להתקשר ל- פו שיטה על דוגמא מרחב שמות.

לאחר שתשתמש במספר קבצים, תצטרך לוודא ש-TypeScript ירכיב וטוען את כל הקוד הדרוש. אתה יכול לעשות זאת על ידי שרשור פלט מהמהדר TypeScript באמצעות ה outFile אוֹפְּצִיָה. זה יקמפל את כל קבצי הקלט לקובץ פלט יחיד של JavaScript. התחביר הכללי להפעלת המהדר כך הוא:

tsc --outFile 

החלף עם השם של קובץ JavaScript היעד שלך. החלף עם שם קובץ ה-TypeScript המכיל את הנחיית ה-triple-slash.

לדוגמה:

tsc --outFile index.js main.ts

פקודה זו תרכיב את התוכן של main.ts קובץ, יחד עם כל הקבצים שאליהם מתייחסים הוראת ה-triple-slash, לתוך index.js קוֹבֶץ.

לחלופין, תוכל לציין כל קובץ בנפרד:

tsc --outFile 

חשוב לציין שההנחיה המשולשת תקפה רק כאשר היא מוצהרת בראש הקובץ. אם תנסה להשתמש בו בכל מקום אחר, TypeScript יתייחס אליו כהערה רגילה בשורה אחת ללא משמעות מיוחדת.

האם עליך להשתמש במרחבי שמות או מודולים?

למרות שמרחבי השמות אינם מוציאים משימוש, ארגון וניהול הקוד שלך באמצעות מודולי ES6 מומלץ לעתים קרובות. קל יותר לתחזק ולנהל מודולים וניתן להרחיב אותם על פני מספר קבצים.

בנוסף, אתה יכול לציין את הקשרים בין מודולים מבחינת יבוא ויצוא ברמת הקובץ. מרחבי שמות אינם יכולים להגדיר את התלות שלהם.

בסופו של דבר, הבחירה בין מרחבי שמות ומודולים תהיה תלויה בצרכים ובדרישות הספציפיות של הפרויקט שלך, שכן שניהם מציעים דרך חשובה לארגון וניהול קוד ב-TypeScript.