הבנת כיצד פועלת ההרמה ב-JavaScript

קוראים כמוך עוזרים לתמוך ב-MUO. כאשר אתה מבצע רכישה באמצעות קישורים באתר שלנו, אנו עשויים להרוויח עמלת שותף.

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

למד הכל על אופן ההרמה ב-JavaScript וכיצד לנהל אותו בצורה הטובה ביותר כדי למנוע שגיאות בקוד שלך.

משתני הנפה עם var, let ו-const

ההרמה אפשרית מכיוון ש-JavaScript משתמש במערכת ההידור JIT (Just-in-Time), אשר סורקת את הקוד שלך כדי לזהות את כל המשתנים בהיקפים שלהם.

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

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

var

גישה למשתנה לא מאותחל המוצהר עם ה- var מילת המפתח תחזור לא מוגדר. לדוגמה:

לְנַחֵם.log (foo); // לא מוגדר
var פו = 2;

יומני הקוד לעיל לא מוגדר כי זה מתקשר console.log לפני שהוא מאתחל את המשתנה.

מהדר JavaScript מציג את בלוק הקוד הקודם כך:

var foo;
לְנַחֵם.log (foo); // לא מוגדר
foo = 2;

במהלך ההנפה, משתנים מצייתים ל- כללים של היקף JavaScript. Javascript יניף רק משתנה לראש ההיקף שבו הכרזת עליו. ניסיון לרשום את הערך של משתנה מחוץ להיקף המוצהר שלו יגרום ל-a ReferenceError. לדוגמה, אם אתה מצהיר על משתנה בתוך פונקציה, הוא לא יהיה גלוי מחוץ לטווח זה:

פוּנקצִיָהmyFunction() {
לְנַחֵם.log (foo); // לא מוגדר
var פו = 10;
}
myFunction();
לְנַחֵם.log (foo); // ReferenceError: foo אינו מוגדר

ניסיון לגשת למשתנה מחוץ להיקפו יגרום ל-a ReferenceError.

לתת וקונסט

על פי MDN תיעוד על לתת ו const הנפה, JavaScript גם מניף משתנים המוצהרים עם ה- לתת ו const מילות מפתח. עם זאת, בניגוד למשתנים המוצהרים עם ה var מילת מפתח, הם לא מאותחלים עם an לא מוגדר ערך.

לדוגמה:

פוּנקצִיָהmyFunction() {
לְנַחֵם.log (foo); // לא מוגדר
לְנַחֵם.log (סרגל); // ReferenceError: לא ניתן לגשת אל 'סרגל' לפני האתחול
לְנַחֵם.log (baz); // ReferenceError: לא ניתן לגשת ל-'baz' לפני האתחול
var פו = 5;
לתת בר = 10;
const baz = 15;
}
myFunction();

אינך יכול לגשת למשתנים המוצהרים עם מילות המפתח let ו-const לפני שאתחולם עם ערך.

פונקציות הרמה

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

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

פוּנקצִיָהפו() {
// הצהרת פונקציה
}
const bar = () => {
// ביטוי פונקציה
}

JavaScript מניף הצהרות פונקציות אך לא ביטויי פונקציה. לדוגמה:

foo(); // 5
בַּר(); // TypeError: bar() אינה פונקציה
// הצהרת פונקציה
פוּנקצִיָהפו() {
לְנַחֵם.עֵץ(5);
}
// ביטוי פונקציה
var בר = פוּנקצִיָהביטוי() {
לְנַחֵם.עֵץ(10);
};

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

ניהול הרמה

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

הצהר על משתנים בתוך פונקציות

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

הצהר על משתנים עם let או const

אתה תמיד צריך להשתמש ב-let ו-גonst מילות מפתח במקום var מילת מפתח בעת הצהרת משתנים. תרגול זה מועיל בעת הצהרת משתנים מקומיים בתוך פונקציה. לדעת את הדרכים הנכונות להצהיר על משתנים ב-JavaScript מקטין את הסיכויים לשגיאות הנגרמות מהנפה בקוד שלך.

הכריז על משתנים בראש ההיקף שלהם

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

שימוש במצב קפדני

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

לדוגמה, ב"מצב מרושל", עקב הנפה, אתה יכול לגשת למשתנה מחוץ לפונקציה המאותחלת, למרות שהוא לא הוכרז:

myFunction();
לְנַחֵם.log (foo); // 20
פוּנקצִיָהmyFunction() {
 foo = 20; 
}

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

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

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

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

"להשתמשקַפְּדָנִי"; // או 'להשתמשקַפְּדָנִי'

כדי להצטרף למצב קפדני ברמת פונקציה, הכריז על התחביר בחלק העליון של גוף פונקציה לפני כל הצהרות:

פוּנקצִיָהmyStrictFunction() {
 "להשתמשקַפְּדָנִי";
}

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

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

"להשתמשקַפְּדָנִי";
myFunction();
לְנַחֵם.log (foo); // ReferenceError: foo אינו מוגדר
פוּנקצִיָהmyFunction() {
 foo = 20; 
}

כאשר מצב קפדני מופעל, המהדר של JavaScript יופעל myFunction() לראש ההיקף שלו ללא המשתנה הלא מוכרז.

הבן מה משפיע על הרמה

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

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