Strict Mode ב-JavaScript: מה 'use strict' באמת עושה

Strict Mode הוא גרסה מחמירה יותר של JavaScript

ל-JavaScript יש היסטוריה ארוכה, והיא סוחבת איתה לא מעט החלטות מפוקפקות: השמות שיוצרות משתנים גלובליים בשקט, this שמשנה משמעות לפי האופן שבו קוראים לפונקציה, שמות פרמטרים כפולים שפשוט... עבדו. שבירה של כל אחד מאלה הייתה שוברת את הרשת, אז TC39 (הוועדה שמתחזקת את השפה) בחרה בדרך אחרת: מצב אופציונלי שבו הפינות החדות משוייפות.

המצב הזה נקרא strict mode. מפעילים אותו בשורה אחת בראש קובץ או פונקציה:

'use strict';

x = 10;
console.log(x);

הריצו את זה ותקבלו ReferenceError: x is not defined. בלי ההנחיה, אותו קוד יוצר בשמחה משתנה גלובלי בשם x ומדפיס 10. אותה שפה, שתי מערכות כללים שונות.

ההנחיה 'use strict'

ההנחיה היא פשוט מחרוזת ליטרלית: 'use strict'; או "use strict";. היא חייבת להיות ההוראה הראשונה בסקריפט או בפונקציה. אם משהו מופיע לפניה, אפילו ביטוי תועה, המנוע מתייחס אליה כמחרוזת רגילה ומתעלם ממנה.

'use strict';

function demo() {
    'use strict';  // also legal at the top of a function
    undeclared = 1;
}

try {
    demo();
} catch (err) {
    console.log(err.message);
}

אפשר להגביל את strict mode לפונקציה אחת על ידי הכנסת ההנחיה לתוכה. בפועל, אף אחד כבר לא עושה את זה: או שכותבים מודולים (strict כברירת מחדל) או שמפעילים את המצב על כל הקובץ.

מה strict mode משנה בפועל

Strict mode הוא לא כלל אחד, אלא חבילה. הנקודות העיקריות:

• השמה למשתנה שלא הוצהר זורקת שגיאה במקום ליצור משתנה גלובלי.
• this בתוך קריאה רגילה לפונקציה הוא undefined, לא האובייקט הגלובלי.
• שמות פרמטרים כפולים (function f(a, a) {}) הם שגיאת תחביר.
• השמה למאפיינים לקריאה בלבד זורקת שגיאה במקום להיכשל בשקט.
• מחיקה של משתנה או פונקציה רגילים זורקת שגיאה.
• כמה מילים שמורות לעתיד (implements, interface, package, private, protected, public, static, yield) לא יכולות לשמש כשמות משתנים.

סיור קצר:

'use strict';

// 1. Undeclared assignment
try {
    count = 5;
} catch (err) {
    console.log('undeclared:', err.message);
}

// 2. this in a plain function call
function who() {
    return this;
}
console.log('this is:', who());

// 3. Duplicate param names would be a SyntaxError:
// function bad(a, a) {}   // <-- won't even parse

כל אחד מהמקרים האלה הוא "המנוע זיהה טעות סבירה מוקדם יותר". זה כל הערך שבדבר.

באג המשתנה הגלובלי השקט

זו הסיבה הגדולה ביותר לקיומו של strict mode. בלעדיו, שגיאת הקלדה הופכת למשתנה גלובלי:

// Non-strict mode (don't do this)
function setup() {
    usernmae = 'Ada';   // typo - creates window.usernmae
}

setup();
console.log(username);  // undefined - the real variable was never set

התוכנית רצה. אין שגיאה. הבאג מופיע רק מאוחר יותר, כשמשהו ש_היה אמור_ לקרוא את username מוצא undefined. ב-strict mode, אותה שגיאת הקלדה זורקת שגיאה ברגע שהיא רצה, ומתקנים אותה בשניות במקום בשעות.

JavaScript מודרני הוא strict כברירת מחדל

זה החלק שמבלבל אנשים: רוב ה-JavaScript שאתם כותבים היום כבר נמצא ב-strict mode, ולא הקלדתם 'use strict' בשום מקום.

שני מקורות גדולים ל-strict אוטומטי:

• מודולי ES. כל קובץ .mjs, כל <script type="module"> וכל דבר שמיובא עם import/export רץ ב-strict mode. לא צריך הנחיה.
• גופי מחלקות. כל הוראה בתוך class { ... } היא strict, גם אם הקובץ שמסביב לא.

class Counter {
    tick() {
        // Strict here automatically.
        // count = 1 would throw ReferenceError.
        return this;
    }
}

const c = new Counter();
console.log(c.tick() === c);

אז מתי באמת צריך לכתוב 'use strict'; בעצמכם? רק ב_סקריפטים קלאסיים_: JS בסגנון הישן שנטען עם תגית <script> רגילה, או קבצי Node.js ישנים שמשתמשים ב-require בלי איגוד מודולים. לכל דבר חדש, המודולים עושים את העבודה בשבילכם.

Strict Mode משנה את this בפונקציות רגילות

התנהגות אחת ששווה להדגיש, כי היא מפילה מתחילים. במצב לא מחמיר, קריאה לפונקציה רגילה בלי אובייקט לפניה קושרת את this לאובייקט הגלובלי (window בדפדפנים, global ב-Node). ב-strict mode, הוא נקשר ל-undefined:

'use strict';

function showThis() {
    console.log(this);
}

showThis();          // undefined
showThis.call(42);   // 42 - not boxed into a Number object

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

מה strict mode לא עושה

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

והוא גם לא אותו דבר כמו "JavaScript מודרני". אפשר לכתוב קוד גרוע ב-strict mode וקוד מצוין בלי ההנחיה. הוא רק מקשה לעשות כמה טעויות מסוימות.

מה לקחת מכאן

• 'use strict'; בראש קובץ או פונקציה מפעיל גרסה מחמירה יותר של JavaScript.
• שגיאות הקלדה מפסיקות ליצור משתנים גלובליים, this מפסיק להפוך בשקט לאובייקט הגלובלי, וכמה מלכודות נוספות הופכות לשגיאות.
• מודולי ES וגופי class הם strict אוטומטית, כך שכמעט אף פעם לא צריך לכתוב את ההנחיה ידנית.
• המטרה היא לתפוס באגים מוקדם יותר, לא להפעיל יכולות חדשות.

הבא בתור: הערות

ראיתם הנחיות, נקודה-פסיק ואת הכללים שחשובים למנוע. עכשיו: ההערות ש_אתם_ משאירים לקוראים עתידיים, איך הערות עובדות ב-JavaScript ומתי שווה לכתוב אותן.