הבנת מצב ה-Strict של Javascript ויתרונותיה

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

מה זה מצב מסובך?

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

ECMAScript 5 הציג מצב קפדני בשנת 2009 כדרך לפתח את השפה ללא שינוי לאחור.מפתחים יכולים לבחור את ההתנהגות החדשה, קפדנית יותר על ידי פשוט הוספת FLT:2 בראש התסריט או הפונקציה. מאז, מצב קפדני הפך לתרגול מומלץ במדריכי סגנון רבים והוא מוחל באופן אוטומטי בצורות מודרניות של JavaScript כמו ES (import /port) והבנת גופים מקצועיים קפדניים.

כיצד ניתן לתת מצב Strict

מצב נוקשה הוא פשוט: אתה מוסיף את המילולי של ה-FLT 3: (או LT:4) בתחילת תסריט או פונקציה.ההנחיות האלה אינן הצהרה אלא הצהרה אשר אומרת למנוע ליישב את הקוד הבא במצב נוקשה.זה יכול להיות מיושם בשני מישורים: ברחבי העולם (עבור תסריט שלם) או מקומי (לתפקיד יחיד).

שם הסרטון: Levelel Strict Mode

כדי לאפשר מצב נוקשה עבור קובץ JavaScript שלם או InlineFLT:5 בלוק, מקום ;FLT:6 כשורה הראשונה של התסריט (לפני כל הצהרות אחרות).

// script.js
'use strict';

var x = 10;
console.log(x); // works normally

// Attempting to use undeclared variables throws an error
y = 20; // ReferenceError: y is not defined

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

המונחים: Function-Level Strict Mode

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

function strictFunction() {
 'use strict';
 // Inside this function, strict mode applies
 var a = 1;
 b = 2; // ReferenceError: b is not defined
}

function sloppyFunction() {
 // Outside strictFunction, sloppy mode still applies
 c = 3; // creates global variable c
}

מצב נוקשה ברמת תפקוד חל רק על הקוד של הפונקציה, לא על כל פונקציות מקונן (אלא אם כן הם גם מכריזים על FLT:11).

מודולים וכיתות

עם כניסתם של ES6 (ES2015), JavaScript הציג מודולים ושיעורים באופן אוטומטי במצב נוקשה על ידי ברירת מחדל, אם אתה כותב את הקוד שלך באמצעות FLT:12/IRLT:13 syntax או להגדיר aFLT:14, אתה לא צריך להוסיף FLT:15 - מצב מוגבל הוא מאויש באופן אוטומטי.

// module.js (no 'use strict' needed)
export function add(a, b) {
 // strict mode is active here
 return a + b;
}

// class definition (strict mode active)
class MyClass {
 constructor(value) {
 this.value = value;
 }
}

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

יתרונות מרכזיים של שימוש במצב Strict

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

מונעים שינויים גלובליים בתאונות

במצב לא מוגבל, הקצאת ערך למשתנה בלתי מוצהר באופן אוטומטי יוצר נכס על האובייקט העולמי (ראה FLT:17 בדפדפנים, FLT 18 ב Node.js) זה יכול לקרות בקלות בשל שגיאות אפיזוגרפיות או הצהרות נשכחות, מזהמים את המרחב העולמי וגורם באגים עדינים.

// Non-strict: silently creates global variable
function setup() {
 developer = "Alice"; // accidentally global
}

// Strict: throws ReferenceError
function setup() {
 'use strict';
 developer = "Alice"; // ReferenceError: developer is not defined
}

כוחות אכיפת החוק הללו מבססים במפורש את המשתנים עם FLT:21, או ,(FLT:22) , או , הקטנת באגים הקשורים להיקף.

« ביטול שגיאות שקטות

JavaScript הוא לעתים קרובות סלחן כאשר פעולות נכשלות בשקט.לדוגמה, הקצאה לנכס לקריאה בלבד (כמו FLT:24 או אובייקט קפוא) פשוט אינה עושה דבר במצב מזחלות.במצב נוקשה, משימות כאלה משליכות מגבלת 25 (כמו כן, ניסיונות למחוק נכסים בלתי חוקיים (למשל, FLT:26) לזרוק טעות במקום לחזור בשקט.

// Non-strict: assignment silently fails
var obj = Object.freeze({name: "Bob"});
obj.name = "Charlie"; // silently ignored

// Strict: TypeError thrown
'use strict';
var obj = Object.freeze({name: "Bob"});
obj.name = "Charlie"; // TypeError: Cannot assign to read-only property 'name'

מניעת שמות פרדוקסליים

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

// Non-strict: allowed
function sum(a, a, c) {
 return a + a + c; // a equals the second argument passed
}

// Strict: SyntaxError
'use strict';
function sum(a, a, c) { // SyntaxError: Duplicate parameter name not allowed in strict mode
 return a + a + c;
}

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

« « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « § § « « « « « « « « « « « « « « « « « « « « « « « « « « « «

ההצהרה של ה-FLT:32 כבר נחשבה מזיקה כי היא יוצרת עמימות לגבי פתרון משתנה ועיוות ביצועים.מצב Strict מבטל לחלוטין את ההצהרה FLT:33, זריקת AFLT:34 בזמן.הסרה זו מעודדת מפתחים להשתמש בדפוסים צפויים יותר, כגון הרס או גישה רכוש מפורש.

שם מקור: FLT:35

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

// Non-strict: eval creates variable in outer scope
var x = 1;
eval("var x = 2;");
console.log(x); // 2

// Strict: eval has its own scope
'use strict';
var x = 1;
eval("var x = 2;");
console.log(x); // 1

איסור על לימוזינה

מבחינה היסטורית, JavaScript פרש מספרים עם אפס מוביל (למשל, FLT:39) כ-octal (בסיס 8) התנהגות זו גרמה לעתים קרובות לבלבול באגים, במיוחד כאשר מדובר במחרוזת כמו "010" להיות מפורשים כמו מספרים.מצב Strict אוסר על ליטרים octal octal octal octal octal ocal numericals (מלבד LT6 +F:40 לפני תיקון) וזרק כל הכיתה.

// Non-strict: 010 means octal 8
console.log(010); // 8

// Strict: SyntaxError
'use strict';
console.log(010); // SyntaxError: Octal literals are not allowed in strict mode

המונחים: Deleting Plain Variables

במצב לא מוגבל, אתה יכול לנסות למחוק משתנים או לפקד הצהרות, אבל הפעולה נכשלת בשקט (ראה פרק: 43) מחזירה את FLT:44). מצב Strict זורק AFLT:45:45 אם אתה מנסה למחוק משתנה, תפקוד או פרמטר פונקציה פשוטה.זה מונע ניסיונות מקריים למחוק דברים שלא ניתן למחוק, ובהיר את כוונת המפתח.

// Non-strict: attempt silently fails
var a = 1;
delete a; // false; a still exists

// Strict: SyntaxError
'use strict';
var a = 1;
delete a; // SyntaxError: Delete of an unqualified identifier in strict mode

שיפורים נוספים של אבטחה וביצועים

מעבר למגבלות הספציפיות, מצב קפדני מאפשר למנועי JavaScript לבצע אופטימיזציה מסוימים שאינם אפשריים אחרת, כי מצב קפדני מבטל התנהגויות דינמיות (כמו ההצהרה FLT:47 וגלובלים בלתי חוקיים), המנוע יכול לחזות כיצד משתנים ישמשו, המוביל לביצוע מהיר יותר במקרים מסוימים, יתר על כן, מצב קפדני מקלקל את הרכוש FLT:48 ואת רכוש LT:49 של פונקציות היסטוריות, אשר שימשו גם להגבלות על ידי מגבלות מסוימות של אבטחה.

דוגמאות מעשיות למצב Strict בפעולה

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

דוגמה: אישור משתנה

// sloppy.js
function userInfo() {
 name = "John"; // silently creates global 'name'
}
userInfo();
console.log(window.name); // "John" (in browsers)

// strict.js
'use strict';
function userInfo() {
 name = "John"; // ReferenceError: name is not defined
}
userInfo();

ללא מצב קפדני, הקלדה פשוטה כמו FLT:51 במקום [13] יכול להדיח את ההיקף הגלובלי עם מצב קפדני, השגיאה נתפסת מיד.

דוגמה 2: אישור לנכסי קריאה בלבד

// sloppy mode
undefined = 5; // silently fails (undefined remains undefined)
NaN = 6; // silently fails
console.log(undefined, NaN); // undefined, NaN

// strict mode
'use strict';
undefined = 5; // TypeError: Cannot assign to read-only property 'undefined' of object '#<Window>'
NaN = 6; // TypeError

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

דוגמה: שמות רכוש אובייקטים

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

// sloppy: works, last value wins
var config = {
 host: "example.com",
 host: "backup.com" // no error
};
console.log(config.host); // "backup.com"

// strict: SyntaxError
'use strict';
var config = {
 host: "example.com",
 host: "backup.com" // SyntaxError: Duplicate data property in object literal not allowed in strict mode
};

מלכודות נפוצות ומיגר למצב Strict

בעוד מצב קפדני מביא יתרונות רבים, הגירה של בסיס קוד קיים גדול יכול להציג אתגרים. כמה דפוסים ישנים יותר שנחשבו מקובלים ב-ES3/5 עשויים להיכשל כעת.

(ב) [ה]ההסברה של משימות משתנה: קוד המסתמך על עולמות בלתי חוקיים חייב להיות מעודכן כדי להכריז על משתנים.
(ב) ,0) , אמירות של נפת': יש להחזיר את הדברים לנכסים מפורשים.
(ב) ויקרא י"א: "וַיָּבְהִיא הוּא הוּא הוּא הוּא" (בראשית כ"ד, ט"ד)
(ב) ,0) ,1,5 ,5 , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
(ב) ⁇ (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
(ב) [15] ,9.19: ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

תהליך ההגירה הוא לעתים קרובות מצטבר.אתה יכול לאפשר תפקוד מצב קפדני באמצעות הפונקציה FLT:62 פרגמה בתוך פונקציות, בדיקה ביסודיות, ולאחר מכן לאפשר לו ברחבי העולם ברגע שאתה בטוח. כלים כמו ESLint עם ה-FLT:63 לשלוט יכול לעזור לזהות הפרות באופן אוטומטי.בנוסף, באמצעות מודולים או שיעורים נותן לך התנהגות קפדנית, כך נודדת ל- סינתזה מודרנית היא נתיב טבעי לכיוון קוד נוקשה.

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

מסקנות ועיסוקים טובים

(המצב הקפדני של JavaScript הוא כלי רב עוצמה לכתיבת קוד חזק יותר, אמין ובטוח.על ידי אופטימיזציה לתוך תת-קבוצה מוגבלת זו של השפה, מפתחים להשיג גילוי מוקדם של טעויות נפוצות, להימנע מצורות מסוכנות, ותועלת מביצועים טובים יותר במקרים רבים. Enabling נוקשה הוא פשוט כמו הוספת FLT:64 בתחילת תסריט או תפקוד, והוא פעיל באופן אוטומטי ב ES ו-Fgging הטבות פחות פוגעניות:64 להורדת שגיאות באופן מקרי, כמו תפוצה מהירה יותר, כמו תפוצה מהירה יותר, כמו LT:64 במקרים מזיקים, פתור שגיאות פתור שגיאות , פתור שגיאות פתור שגיאות פתור שגיאות פתורים:64 במקרים חמורים יותר, כמו פתור שגיאות פתור שגיאות פתורים:

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

(ב) לעיין בתיעוד ה-FLT:0.MDN על מצב נוקשה של ספקטרום 1 עבור רשימה מלאה של מגבלות ודוגמאות. עבור ההקשר ההיסטורי, ה-FLT:2ECMAScript מפרט את מפרט ה-FLT 3: 3 מסביר את הכללים הרשמיים.בנוסף, ה-FLT:4ESLint נוקשה:5 מספק דרך אוטומטית לאכיפת שימוש עקבי לאורך כל האפקטיביות והקוד הנית של ה-המתנה.