เมื่อเร็ว ๆ นี้ฉันรันโค้ด JavaScript บางส่วนผ่านJSLintของ Crockford และให้ข้อผิดพลาดต่อไปนี้:

ปัญหาที่บรรทัด 1 อักขระ 1: ไม่มีคำสั่ง "use เข้มงวด"

เมื่อทำการค้นหาฉันรู้ว่ามีบางคนเพิ่ม"use strict";ลงในรหัส JavaScript ของพวกเขา เมื่อฉันเพิ่มคำสั่งข้อผิดพลาดหยุดปรากฏขึ้น น่าเสียดายที่ Google ไม่ได้เปิดเผยประวัติส่วนใหญ่ที่อยู่เบื้องหลังคำสั่งสตริงนี้ แน่นอนว่ามันต้องมีบางสิ่งเกี่ยวกับวิธีที่เบราว์เซอร์ตีความ JavaScript แต่ฉันไม่รู้ว่าจะมีผลกระทบอย่างไร

แล้วมัน"use strict";เกี่ยวกับอะไรมันบอกเป็นนัย ๆ และมันยังเกี่ยวข้อง?

เบราว์เซอร์ปัจจุบันตอบสนองต่อ"use strict";สตริงหรือไม่เพื่อใช้ในอนาคต

บทความเกี่ยวกับโหมดเข้มงวดของจาวาสคริปต์อาจสนใจคุณ: John Resig - ECMAScript 5 Strict Mode, JSON และอื่น ๆ

ในการอ้างถึงส่วนที่น่าสนใจ:

โหมดเข้มงวดเป็นคุณลักษณะใหม่ใน ECMAScript 5 ที่ช่วยให้คุณสามารถวางโปรแกรมหรือฟังก์ชันในบริบทการทำงาน "เข้มงวด" บริบทที่เข้มงวดนี้ป้องกันไม่ให้มีการดำเนินการบางอย่างและส่งข้อยกเว้นเพิ่มเติม

และ:

โหมดเข้มงวดช่วยออกได้หลายวิธี:

• มันจับ bloopers การเข้ารหัสที่พบบ่อยบางอย่างโยนข้อยกเว้น
• มันป้องกันหรือโยนข้อผิดพลาดเมื่อมีการกระทำที่ "ไม่ปลอดภัย" (เช่นการเข้าถึงวัตถุระดับโลก)
• มันปิดการใช้งานคุณสมบัติที่ทำให้สับสนหรือคิดไม่ดี

นอกจากนี้โปรดทราบว่าคุณสามารถใช้ "โหมดเข้มงวด" กับไฟล์ทั้งหมด ... หรือคุณสามารถใช้งานได้เฉพาะสำหรับฟังก์ชั่นเฉพาะ(ยังคงอ้างถึงจากบทความของ John Resig) :

// Non-strict code...

(function(){
  "use strict";

  // Define your library strictly...
})();

// Non-strict code... 

ซึ่งอาจเป็นประโยชน์หากคุณต้องผสมรหัสเก่าและใหม่ ;-)

ดังนั้นฉันคิดว่ามันเป็นเหมือนที่"use strict"คุณสามารถใช้ใน Perl (ชื่อจึง?) : ช่วยให้คุณทำผิดพลาดน้อยลงโดยการตรวจสอบสิ่งต่าง ๆ ที่อาจนำไปสู่การแตก

โหมดเข้มงวดอยู่ในขณะนี้ได้รับการสนับสนุนจากเบราว์เซอร์ที่สำคัญทั้งหมด

ภายในโมดูล ECMAScript ดั้งเดิม (พร้อมimportและexportข้อความ) และคลาส ES6โหมดเข้มงวดจะเปิดใช้งานเสมอและไม่สามารถปิดใช้งานได้

มันเป็นคุณสมบัติใหม่ของ ECMAScript 5 John Resig เขียนบทสรุปที่ดีของมัน

เป็นเพียงสตริงที่คุณใส่ในไฟล์ JavaScript (ที่ด้านบนของไฟล์หรือภายในฟังก์ชั่น) ที่มีลักษณะดังนี้:

"use strict";

การวางไว้ในโค้ดของคุณตอนนี้ไม่ควรทำให้เกิดปัญหากับเบราว์เซอร์ปัจจุบันเนื่องจากเป็นเพียงสตริง มันอาจทำให้เกิดปัญหากับรหัสของคุณในอนาคตหากรหัสของคุณละเมิด pragma ตัวอย่างเช่นหากปัจจุบันคุณfoo = "bar"ไม่มีการกำหนดfooรหัสของคุณจะเริ่มล้มเหลว ... ซึ่งเป็นสิ่งที่ดีในความคิดของฉัน

ข้อความ"use strict";สั่งให้เบราว์เซอร์ใช้โหมด Strict ซึ่งเป็นชุดคุณสมบัติที่ลดลงและปลอดภัยยิ่งขึ้นของ JavaScript

รายการคุณสมบัติ (ไม่ครบถ้วนสมบูรณ์)

1. ไม่อนุญาตตัวแปรส่วนกลาง (จับvarประกาศที่หายไปและการพิมพ์ผิดในชื่อตัวแปร)

2. การมอบหมายที่ล้มเหลวเงียบจะทำให้เกิดข้อผิดพลาดในโหมดเข้มงวด (การกำหนดNaN = 5;)

3. ความพยายามที่จะลบคุณสมบัติที่ไม่สามารถลบได้จะส่งผลให้ ( delete Object.prototype)

4. ต้องการชื่อคุณสมบัติทั้งหมดในวัตถุตามตัวอักษรให้ไม่ซ้ำกัน ( var x = {x1: "1", x1: "2"})

5. ชื่อพารามิเตอร์ฟังก์ชั่นจะต้องไม่ซ้ำกัน ( function sum (x, x) {...})

6. ห้ามใช้ไวยากรณ์ฐานแปด ( var x = 023;บาง devs คิดผิดว่าศูนย์ก่อนหน้าไม่ทำอะไรเลยเพื่อเปลี่ยนหมายเลข)

7. ห้ามwithคำหลัก

8. eval ในโหมดเข้มงวดไม่แนะนำตัวแปรใหม่

9. ห้ามลบชื่อธรรมดา ( delete x;)

10. ห้ามมิให้มีผลผูกพันหรือการมอบหมายชื่อevalและargumentsในรูปแบบใด ๆ

11. โหมดเข้มงวดไม่ได้ใช้นามแฝงคุณสมบัติของargumentsวัตถุด้วยพารามิเตอร์ที่เป็นทางการ (เช่นในใช้function sum (a,b) { return arguments[0] + b;}งานได้เพราะarguments[0]ถูกผูกไว้aและอื่น ๆ )

12. arguments.callee ไม่รองรับ

[Ref: โหมดเข้มงวด , Mozilla Developer Network ]

หากผู้คนกังวลเกี่ยวกับการใช้use strictมันอาจคุ้มค่าที่จะดูบทความนี้:

การสนับสนุน ECMAScript 5 'โหมดเข้มงวด' ในเบราว์เซอร์ สิ่งนี้หมายความว่า?
NovoGeek.com - บล็อกของ Krishna

มันพูดถึงการสนับสนุนเบราว์เซอร์ แต่ที่สำคัญกว่านั้นคือวิธีจัดการกับมันอย่างปลอดภัย:

function isStrictMode(){
    return !this;
} 
/*
   returns false, since 'this' refers to global object and 
   '!this' becomes false
*/

function isStrictMode(){   
    "use strict";
    return !this;
} 
/* 
   returns true, since in strict mode the keyword 'this'
   does not refer to global object, unlike traditional JS. 
   So here, 'this' is 'undefined' and '!this' becomes true.
*/

คำเตือนนักเขียนโปรแกรมที่ชาร์จไฟยาก: การใช้"use strict"โค้ดที่มีอยู่อาจเป็นอันตรายได้! สิ่งนี้ไม่ใช่ความรู้สึกที่ดีและสติกเกอร์ใบหน้าที่มีความสุขที่คุณสามารถตบรหัสเพื่อให้ 'ดีขึ้น' ด้วย"use strict"pragma เบราว์เซอร์จะขว้างข้อยกเว้นในสถานที่แบบสุ่มซึ่งไม่เคยเกิดขึ้นมาก่อน ณ จุดนั้นคุณกำลังทำสิ่งที่ JavaScript เริ่มต้น / หลวมเปิดใช้งานอย่างมีความสุข คุณอาจมีการละเมิดอย่างเข้มงวดซ่อนตัวอยู่ในการโทรที่ไม่ค่อยใช้ในรหัสของคุณที่จะโยนข้อยกเว้นเมื่อพวกเขาจะได้รับในที่สุด - พูดในสภาพแวดล้อมการผลิตที่ลูกค้าจ่ายเงินของคุณใช้!

หากคุณกำลังจะกระโดดมันเป็นความคิดที่ดีที่จะใช้"use strict"ควบคู่ไปกับการทดสอบหน่วยที่ครอบคลุมและงานสร้าง JSHint ที่กำหนดค่าอย่างเคร่งครัดซึ่งจะทำให้คุณมั่นใจว่าไม่มีมุมมืดของโมดูลของคุณที่จะระเบิดขึ้นอย่างน่ากลัวเพียงเพราะคุณ เปิดใช้งานโหมดเข้มงวดแล้ว หรือนี่คือตัวเลือกอื่น: เพียงแค่ไม่เพิ่ม"use strict"รหัสดั้งเดิมใด ๆ ของคุณมันอาจปลอดภัยกว่าด้วยวิธีนี้ กำหนดไม่เพิ่ม"use strict"ในโมดูลใด ๆ ที่คุณไม่ได้เป็นเจ้าของหรือบำรุงรักษาเช่นโมดูลบุคคลที่สาม

ฉันคิดว่าถึงแม้ว่ามันจะเป็นสัตว์ที่ถูกขังอยู่ในสภาพร้ายแรง แต่"use strict"ก็สามารถทำสิ่งที่ดีได้ แต่คุณต้องทำมันให้ถูกต้อง เวลาที่ดีที่สุดที่จะเข้มงวดคือโครงการของคุณคือกรีนฟิลด์และคุณเริ่มจากศูนย์ กำหนดค่าJSHint/JSLintกับทุกคำเตือนและตัวเลือก cranked ขึ้นเป็นแน่นเป็นทีมงานของคุณสามารถท้องได้ดีสร้าง / ทดสอบ / ระบบยืนยันแบบหวือหวาเหมือนหัวเรือใหญ่และเพียงแล้วเริ่มต้นทำเครื่องหมายโมดูลใหม่ทั้งหมดของคุณGrunt+Karma+Chai "use strict"ได้เตรียมที่จะรักษาข้อผิดพลาดและคำเตือน niggly มากมาย ตรวจสอบให้แน่ใจว่าทุกคนเข้าใจถึงแรงโน้มถ่วงด้วยการกำหนดค่า build เป็น FAIL หากJSHint/JSLintสร้างการละเมิดใด ๆ

โครงการของฉันไม่ใช่โครงการกรีนฟิลด์เมื่อฉันนำ"use strict"ไปใช้ เป็นผลให้ IDE ของฉันเต็มไปด้วยเครื่องหมายสีแดงเพราะฉันไม่ได้"use strict"ครึ่งโมดูลของฉันและ JSHint บ่นเกี่ยวกับเรื่องนั้น มันเป็นเครื่องเตือนใจฉันเกี่ยวกับสิ่งที่ฉันควรทำในอนาคต เป้าหมายของฉันคือการทำเครื่องหมายสีแดงฟรีเนื่องจากข้อความที่หายไปทั้งหมดของฉัน"use strict"แต่ตอนนี้ผ่านไปหลายปีแล้ว

การใช้'use strict';ไม่ได้ทำให้โค้ดของคุณดีขึ้นในทันที

โหมด JavaScript เข้มงวดเป็นคุณลักษณะในECMAScript 5 คุณสามารถเปิดใช้งานโหมดเข้มงวดโดยการประกาศสิ่งนี้ที่ด้านบนของสคริปต์ / ฟังก์ชั่นของคุณ

'use strict';

เมื่อเอ็นจิ้น JavaScript มองเห็นคำสั่งนี้มันจะเริ่มตีความรหัสในโหมดพิเศษ ในโหมดนี้ข้อผิดพลาดจะถูกโยนออกมาเมื่อมีการตรวจพบวิธีการเข้ารหัสที่อาจทำให้เกิดข้อบกพร่องที่อาจเกิดขึ้นได้ (ซึ่งเป็นเหตุผลที่อยู่เบื้องหลังโหมดเข้มงวด)

ลองพิจารณาตัวอย่างนี้:

var a = 365;
var b = 030;

ในความหลงใหลของพวกเขาในการเรียงตัวอักษรตัวเลขผู้พัฒนาได้เริ่มต้นตัวแปรโดยไม่ได้ตั้งใจbกับตัวอักษรแปด โหมดที่ไม่เข้มงวดจะตีความว่านี่เป็นตัวอักษรตัวเลขที่มีค่า24(ในฐาน 10) อย่างไรก็ตามโหมดเข้มงวดจะส่งข้อผิดพลาด

สำหรับรายการพิเศษที่ไม่ครบถ้วนสมบูรณ์ในโหมดเข้มงวดดูคำตอบนี้

ฉันควรใช้'use strict';ที่ไหน

• ในแอปพลิเคชัน JavaScript ใหม่ของฉัน: แน่นอน! โหมดเข้มงวดสามารถใช้เป็นผู้แจ้งเบาะแสเมื่อคุณกำลังทำอะไรโง่ ๆ ด้วยรหัสของคุณ

• ในรหัส JavaScript ที่มีอยู่ของฉัน: อาจไม่! หากรหัส JavaScript ปัจจุบันของคุณมีข้อความที่ห้ามใช้ในโหมดเข้มงวดแอปพลิเคชันจะหยุดทำงาน หากคุณต้องการโหมดเข้มงวดคุณควรเตรียมพร้อมที่จะทำการดีบั๊กและแก้ไขรหัสที่มีอยู่ของคุณ นี่คือสาเหตุที่การใช้'use strict';ไม่ได้ทำให้โค้ดของคุณดีขึ้นในทันที

ฉันจะใช้โหมดเข้มงวดได้อย่างไร

1. แทรก'use strict';คำสั่งที่ด้านบนของสคริปต์ของคุณ:

   // File: myscript.js
   
   'use strict';
   var a = 2;
   ....

   โปรดทราบว่าทุกอย่างในไฟล์myscript.jsจะถูกตีความในโหมดเข้มงวด

2. หรือแทรก'use strict';คำสั่งที่ด้านบนของตัวฟังก์ชันของคุณ:

   function doSomething() {
       'use strict';
       ...
   }

   ทุกอย่างในขอบเขตของฟังก์ชันdoSomethingจะถูกตีความในโหมดเข้มงวด คำศัพท์ขอบเขตที่สำคัญที่นี่ ตัวอย่างเช่นหากรหัสที่เข้มงวดของคุณเรียกใช้ฟังก์ชันของไลบรารีที่ไม่เข้มงวดเฉพาะรหัสของคุณเท่านั้นที่จะถูกดำเนินการในโหมดเข้มงวดและไม่ใช่ฟังก์ชั่นที่เรียกว่า ดูคำตอบนี้สำหรับคำอธิบายที่ดีกว่า

สิ่งใดบ้างที่ห้ามใช้ในโหมดเข้มงวด

ฉันพบบทความที่ดีที่อธิบายสิ่งต่าง ๆ ที่ต้องห้ามในโหมดเข้มงวด (โปรดทราบว่านี่ไม่ใช่รายการพิเศษ):

ขอบเขต

ในอดีต JavaScript ได้สับสนเกี่ยวกับวิธีการกำหนดขอบเขต บางครั้งพวกเขาดูเหมือนจะถูกกำหนดขอบเขตแบบคงที่ แต่คุณสมบัติบางอย่างทำให้พวกเขาทำงานเหมือนพวกเขาจะถูกกำหนดขอบเขตแบบไดนามิก สิ่งนี้ทำให้เกิดความสับสนทำให้โปรแกรมอ่านและเข้าใจยาก ความเข้าใจผิดทำให้เกิดข้อบกพร่อง มันเป็นปัญหาสำหรับประสิทธิภาพ การกำหนดขอบเขตแบบคงที่จะอนุญาตให้การรวมตัวแปรเกิดขึ้นในเวลารวบรวม แต่ข้อกำหนดสำหรับขอบเขตแบบไดนามิกหมายถึงการรวมจะต้องถูกเลื่อนออกไปถึงรันไทม์ซึ่งมาพร้อมกับการลงโทษประสิทธิภาพที่สำคัญ

โหมดเข้มงวดต้องการให้การเชื่อมตัวแปรทั้งหมดทำแบบสแตติก นั่นหมายความว่าฟีเจอร์ที่ต้องการการเชื่อมโยงแบบไดนามิกก่อนหน้านี้จะต้องถูกกำจัดหรือแก้ไข โดยเฉพาะอย่างยิ่งคำสั่ง with จะถูกกำจัดออกไปและความสามารถของฟังก์ชั่น eval ในการแก้ไขสภาพแวดล้อมของผู้โทรจะถูก จำกัด อย่างรุนแรง

ข้อดีอย่างหนึ่งของรหัสที่เข้มงวดคือเครื่องมือเช่นYUI Compressor สามารถทำงานได้ดีขึ้นเมื่อทำการประมวลผล

ตัวแปรโกลบอลโดยนัย

JavaScript มีตัวแปรทั่วโลกโดยนัย หากคุณไม่ได้ประกาศตัวแปรอย่างชัดเจนตัวแปรโกลบอลจะถูกประกาศให้คุณโดยปริยาย ทำให้การเขียนโปรแกรมง่ายขึ้นสำหรับผู้เริ่มต้นเนื่องจากพวกเขาสามารถละเลยงานบ้านขั้นพื้นฐานบางอย่างได้ แต่มันทำให้การจัดการโปรแกรมขนาดใหญ่ยากขึ้นและลดความน่าเชื่อถือลงอย่างมาก ดังนั้นในโหมดเข้มงวดไม่สามารถสร้างตัวแปรโกลบอลได้อีกต่อไป คุณควรประกาศตัวแปรทั้งหมดของคุณอย่างชัดเจน

การรั่วไหลทั่วโลก

มีหลายสถานการณ์ที่อาจทำให้เกิดthis การผูกกับวัตถุส่วนกลาง ตัวอย่างเช่นถ้าคุณลืมใส่newคำนำหน้าเมื่อเรียกใช้ฟังก์ชันคอนสตรัคเตอร์คอนสตรัคเตอร์thisจะถูกผูกไว้กับวัตถุทั่วโลกโดยไม่คาดคิดดังนั้นแทนที่จะเริ่มต้นวัตถุใหม่มันจะถูกดัดแปลงอย่างเงียบ ๆ ด้วยตัวแปรส่วนกลาง ในสถานการณ์เหล่านี้โหมดเข้มงวดจะเชื่อมโยงthisกับundefinedซึ่งจะทำให้ตัวสร้างสร้างข้อยกเว้นแทนทำให้ตรวจพบข้อผิดพลาดได้เร็วขึ้น

ความล้มเหลวที่มีเสียงดัง

JavaScript มีคุณสมบัติแบบอ่านอย่างเดียวเสมอ แต่คุณไม่สามารถสร้างมันเองได้จนกว่าObject.createProperty ฟังก์ชันของ ES5 จะเปิดเผยความสามารถนั้น หากคุณพยายามกำหนดค่าให้กับคุณสมบัติแบบอ่านอย่างเดียวมันจะล้มเหลวอย่างเงียบ ๆ การมอบหมายจะไม่เปลี่ยนแปลงมูลค่าของทรัพย์สิน แต่โปรแกรมของคุณจะดำเนินการต่อราวกับว่ามันมี นี่คืออันตรายด้านความสมบูรณ์ที่อาจทำให้โปรแกรมเข้าสู่สถานะไม่สอดคล้องกัน ในโหมดเข้มงวดการพยายามเปลี่ยนคุณสมบัติแบบอ่านอย่างเดียวจะทำให้เกิดข้อยกเว้น

Octal

การแสดงตัวเลขฐานแปด (หรือฐาน 8) มีประโยชน์อย่างยิ่งเมื่อทำการตั้งโปรแกรมระดับเครื่องจักรบนเครื่องที่มีขนาดคำเท่ากับ 3 คุณต้องใช้เลขฐานแปดเมื่อทำงานกับเมนเฟรม CDC 6600 ซึ่งมีขนาดคำเท่ากับ 60 บิต หากคุณสามารถอ่านเลขฐานแปดคุณสามารถดูคำได้ 20 หลัก ตัวเลขสองหลักแสดงรหัส op และหนึ่งหลักระบุหนึ่งใน 8 การลงทะเบียน ในช่วงการเปลี่ยนภาพช้าจากรหัสเครื่องเป็นภาษาระดับสูงมีความคิดว่าจะเป็นประโยชน์ในการจัดเตรียมรูปแบบฐานแปดในภาษาการเขียนโปรแกรม

ใน C มีการเลือกตัวแทนที่เป็นโชคร้ายอย่างยิ่งของค่าแปด: นำหน้าศูนย์ ดังนั้นใน C 0100หมายถึง 64 ไม่ใช่ 100 และ08เป็นข้อผิดพลาดไม่ใช่ 8 ยิ่งไปกว่านั้นโชคร้ายที่สมัยนี้ได้ถูกคัดลอกไปเป็นภาษาสมัยใหม่เกือบทั้งหมดรวมถึง JavaScript ซึ่งใช้เพื่อสร้างข้อผิดพลาดเท่านั้น มันไม่มีวัตถุประสงค์อื่น ดังนั้นในโหมดเข้มงวดไม่อนุญาตให้ใช้แบบฟอร์มฐานแปด

เป็นต้น

อาเรย์อาร์กิวเมนต์หลอกจะกลายเป็นอาเรย์ที่คล้ายกันมากขึ้นใน ES5 ในโหมดเข้มงวดจะสูญเสียcalleeและcaller คุณสมบัติ สิ่งนี้ทำให้สามารถส่งรหัสของคุณargumentsไปยังรหัสที่ไม่น่าเชื่อถือได้โดยไม่ต้องละทิ้งบริบทที่เป็นความลับจำนวนมาก นอกจากนี้ argumentsคุณสมบัติของฟังก์ชั่นจะถูกกำจัดออก

ในโหมดเข้มงวดปุ่มที่ซ้ำกันในตัวอักษรฟังก์ชันจะสร้างข้อผิดพลาดทางไวยากรณ์ ฟังก์ชั่นไม่สามารถมีสองพารามิเตอร์ที่มีชื่อเดียวกัน ฟังก์ชั่นไม่สามารถมีตัวแปรที่มีชื่อเดียวกันกับหนึ่งในพารามิเตอร์ของมัน ฟังก์ชั่นไม่สามารถdeleteใช้ตัวแปรของตัวเอง ความพยายามใน deleteการใช้คุณสมบัติที่ไม่สามารถกำหนดค่าได้เกิดข้อยกเว้น ค่าดั้งเดิมไม่ได้ถูกห่อโดยปริยาย

คำที่สงวนไว้สำหรับเวอร์ชัน JavaScript ในอนาคต

ECMAScript 5 เพิ่มรายการคำที่สงวนไว้ หากคุณใช้พวกเขาเป็นตัวแปรหรือข้อโต้แย้งโหมดเข้มงวดจะโยนข้อผิดพลาด คำสงวนคือ:

implements, interface, let, package, private, protected, public, staticและyield

อ่านเพิ่มเติม

• โหมดเข้มงวด - JavaScript | MDN
• การสนับสนุนเบราว์เซอร์สำหรับโหมดเข้มงวด
• การเปลี่ยนเป็นโหมดที่เข้มงวด

ฉันขอแนะนำให้นักพัฒนาซอฟต์แวร์ทุกคนเริ่มใช้โหมดเข้มงวดตอนนี้ มีเบราว์เซอร์เพียงพอที่สนับสนุนโหมดที่เข้มงวดจะช่วยให้เราประหยัดจากข้อผิดพลาดที่เราไม่ทราบว่าอยู่ในรหัสของคุณ

เห็นได้ชัดว่าในระยะแรกจะมีข้อผิดพลาดที่เราไม่เคยพบมาก่อน เพื่อให้ได้ประโยชน์เต็มที่เราต้องทำการทดสอบที่เหมาะสมหลังจากเปลี่ยนเป็นโหมดเข้มงวดเพื่อให้แน่ใจว่าเราได้จับทุกอย่าง แน่นอนเราไม่เพียงแค่โยนuse strictรหัสของเราและถือว่าไม่มีข้อผิดพลาด ดังนั้นเวลาปั่นป่วนก็ถึงเวลาที่จะเริ่มใช้คุณลักษณะภาษาที่มีประโยชน์อย่างเหลือเชื่อเพื่อเขียนโค้ดที่ดีกว่านี้

ตัวอย่างเช่น,

var person = {
    name : 'xyz',
    position : 'abc',
    fullname : function () {  "use strict"; return this.name; }
};

JSLintเป็นดีบักเกอร์ที่เขียนโดย Douglas Crockford เพียงวางในสคริปต์ของคุณแล้วมันจะสแกนหาปัญหาและข้อผิดพลาดในรหัสของคุณอย่างรวดเร็ว

ฉันต้องการที่จะให้คำตอบที่ก่อตั้งขึ้นค่อนข้างมากซึ่งจะช่วยเติมเต็มคำตอบอื่น ๆ ฉันหวังว่าจะแก้ไขคำตอบที่ได้รับความนิยมสูงสุด แต่ล้มเหลว ฉันพยายามทำให้มันครอบคลุมและครบถ้วนเท่าที่จะทำได้

คุณสามารถอ้างอิงเอกสาร MDNสำหรับข้อมูลเพิ่มเติม

"use strict" คำสั่งที่แนะนำใน ECMAScript 5

คำสั่งนั้นคล้ายกับข้อความ แต่แตกต่างกัน

• use strictไม่มีคำสำคัญ: คำสั่งเป็นคำสั่งแสดงออกง่ายซึ่งประกอบด้วยสตริงตัวอักษรพิเศษ (ในคำพูดเดียวหรือสองครั้ง) เอ็นจิ้น JavaScript ที่ไม่ได้ใช้ ECMAScript 5 เพียงเห็นคำสั่งการแสดงออกโดยไม่มีผลข้างเคียง คาดว่ามาตรฐาน ECMAScript เวอร์ชันอนาคตจะuseเป็นคำสำคัญที่แท้จริง คำพูดจะล้าสมัย
• use strictสามารถใช้ได้เฉพาะตอนเริ่มต้นของสคริปต์หรือฟังก์ชั่นเท่านั้นเช่นจะต้องนำหน้าคำสั่ง (จริง) อื่น ๆ มันไม่จำเป็นต้องเป็นคำสั่งแรกในสคริปต์ของฟังก์ชั่น: มันสามารถนำหน้าด้วยการแสดงออกของคำสั่งอื่น ๆ ที่ประกอบด้วยสตริงตัวอักษร (และการใช้งาน JavaScript สามารถถือว่าพวกเขาเป็นแนวทางเฉพาะการใช้งาน) คำสั่งตัวอักษรสตริงซึ่งตามคำสั่งจริงแรก (ในสคริปต์หรือฟังก์ชั่น) เป็นคำสั่งการแสดงออกที่ง่าย ล่ามจะต้องไม่ตีความพวกเขาเป็นคำสั่งและพวกเขาจะไม่มีผลกระทบ

use strictสั่งระบุว่ารหัสต่อไปนี้ (ในสคริปต์หรือฟังก์ชั่น) เป็นรหัสที่เข้มงวด รหัสในระดับสูงสุดของสคริปต์ (รหัสที่ไม่ได้อยู่ในฟังก์ชั่น) ถือเป็นรหัสที่เข้มงวดเมื่อสคริปต์มีuse strictคำสั่ง เนื้อหาของฟังก์ชั่นถือว่าเป็นรหัสที่เข้มงวดเมื่อฟังก์ชั่นของตัวเองถูกกำหนดในรหัสที่เข้มงวดหรือเมื่อฟังก์ชั่นมีuse strictคำสั่ง โค้ดที่ถูกส่งผ่านไปยังeval()เมธอดจะถือว่าเป็นโค้ดที่เข้มงวดเมื่อeval()ถูกเรียกจากโค้ดที่เข้มงวดหรือมีuse strictคำสั่งนั้น

โหมดเข้มงวดของ ECMAScript 5 เป็นชุดย่อยที่ จำกัด ของภาษา JavaScript ซึ่งจะช่วยลดการขาดดุลที่เกี่ยวข้องของภาษาและคุณสมบัติการตรวจสอบข้อผิดพลาดที่เข้มงวดมากขึ้นและความปลอดภัยที่สูงขึ้น รายการต่อไปนี้แสดงความแตกต่างระหว่างโหมดเข้มงวดและโหมดปกติ (ซึ่งสามข้อแรกมีความสำคัญอย่างยิ่ง):

• คุณไม่สามารถใช้with-statement ในโหมดเข้มงวดได้
• ในโหมดที่เข้มงวดตัวแปรทั้งหมดจะต้องมีการประกาศ: ถ้าคุณกำหนดค่าให้กับตัวระบุว่ายังไม่ได้รับการประกาศให้เป็นตัวแปรฟังก์ชันพารามิเตอร์ของฟังก์ชันพารามิเตอร์จับประโยคหรือทรัพย์สินของทั่วโลกแล้วคุณจะได้รับObject ReferenceErrorในโหมดปกติตัวบ่งชี้จะถูกประกาศโดยปริยายว่าเป็นตัวแปรโกลบอล (เป็นคุณสมบัติของโกลบอลObject)
• ในโหมดเข้มงวดคำหลักthisมีค่าundefinedในฟังก์ชันที่ถูกเรียกใช้เป็นฟังก์ชัน (ไม่ใช่วิธีการ) (ในโหมดปกติthisชี้ไปที่ทั่วโลกObjectเสมอ) ความแตกต่างนี้สามารถใช้เพื่อทดสอบว่าการใช้งานรองรับโหมดเข้มงวดหรือไม่:

var hasStrictMode = (function() { "use strict"; return this===undefined }());

• นอกจากนี้เมื่อฟังก์ชั่นถูกเรียกใช้ด้วยcall()หรือapplyในโหมดเข้มงวดจากนั้นthisเป็นค่าของการโต้แย้งแรกของcall()หรือapply()การภาวนา (ในโหมดปกติnullและundefinedถูกแทนที่ด้วยโลกObjectและค่าที่ไม่ใช่วัตถุจะถูกโยนลงในวัตถุ)

• ในโหมดเข้มงวดคุณจะได้รับTypeErrorเมื่อคุณพยายามกำหนดให้กับคุณสมบัติแบบอ่านอย่างเดียวหรือเพื่อกำหนดคุณสมบัติใหม่สำหรับวัตถุที่ไม่สามารถขยายได้ (ในโหมดปกติทั้งคู่ล้มเหลวโดยไม่มีข้อความแสดงข้อผิดพลาด)

• ในโหมดเข้มงวดเมื่อส่งรหัสไปที่eval()คุณไม่สามารถประกาศหรือกำหนดตัวแปรหรือฟังก์ชั่นในขอบเขตของผู้โทร (เช่นที่คุณสามารถทำได้ในโหมดปกติ) แต่จะสร้างขอบเขตใหม่eval()และตัวแปรและฟังก์ชันจะอยู่ภายในขอบเขตดังกล่าว ขอบเขตนั้นถูกทำลายหลังจากeval()ดำเนินการเสร็จสิ้น
• ในโหมดเข้มงวดอาร์กิวเมนต์-object ของฟังก์ชันมีสำเนาค่าคงที่ซึ่งส่งผ่านไปยังฟังก์ชันนั้น ในโหมดปกติอาร์กิวเมนต์ - ออบเจ็กต์จะมีพฤติกรรม "เสก" ค่อนข้างมาก: องค์ประกอบของอาเรย์และพารามิเตอร์ฟังก์ชั่นที่ตั้งชื่อนั้นอ้างอิงทั้งค่าเดียวกัน
• ในโหมดเข้มงวดคุณจะได้รับSyntaxErrorเมื่อตัวdeleteดำเนินการถูกตามด้วยตัวระบุที่ไม่ผ่านการรับรอง (ตัวแปรฟังก์ชันหรือพารามิเตอร์ฟังก์ชัน) ในโหมดปกติแสดงออกจะทำอะไรและมีการประเมินเพื่อdeletefalse
• ในโหมดเข้มงวดคุณจะได้รับTypeErrorเมื่อคุณพยายามลบคุณสมบัติที่ไม่สามารถกำหนดค่าได้ (ในโหมดปกติความพยายามจะล้มเหลวและdeleteนิพจน์ได้รับการประเมินfalse)
• ในโหมดเข้มงวดจะถือว่าเป็นข้อผิดพลาดทางไวยากรณ์เมื่อคุณพยายามกำหนดคุณสมบัติหลายอย่างที่มีชื่อเดียวกันสำหรับวัตถุตามตัวอักษร (ในโหมดปกติไม่มีข้อผิดพลาด)
• ในโหมดเข้มงวดถือเป็นข้อผิดพลาดทางไวยากรณ์เมื่อประกาศฟังก์ชันมีพารามิเตอร์หลายตัวที่มีชื่อเดียวกัน (ในโหมดปกติไม่มีข้อผิดพลาด)
• ในโหมดตัวอักษรฐานแปดแบบเข้มงวดไม่ได้รับอนุญาต (สิ่งเหล่านี้เป็นตัวอักษรที่ขึ้นต้นด้วย0x(ในโหมดปกติการใช้งานบางอย่างจะอนุญาตให้ใช้ตัวอักษรฐานแปด)
• ในโหมดเข้มงวดตัวบ่งชี้evalและargumentsถือว่าเป็นคำหลัก คุณไม่สามารถเปลี่ยนค่าของพวกเขาไม่สามารถกำหนดค่าให้กับพวกเขาและคุณไม่สามารถใช้พวกเขาเป็นชื่อสำหรับตัวแปรฟังก์ชั่นพารามิเตอร์ฟังก์ชั่นหรือตัวระบุของ catch block
• ในโหมดเข้มงวดมีข้อ จำกัด เพิ่มเติมเกี่ยวกับความเป็นไปได้ในการตรวจสอบสแตกการโทร arguments.callerและarguments.calleeทำให้ a TypeErrorในฟังก์ชั่นในโหมดเข้มงวด นอกจากนี้คุณสมบัติผู้โทรและข้อโต้แย้งบางส่วนของฟังก์ชั่นในโหมดเข้มงวดทำให้เกิดTypeErrorเมื่อคุณพยายามอ่าน

สองเซ็นต์ของฉัน:

หนึ่งในเป้าหมายของโหมดเข้มงวดคือการอนุญาตให้ทำการดีบักปัญหาได้เร็วขึ้น ช่วยนักพัฒนาโดยการโยนข้อยกเว้นเมื่อมีสิ่งผิดปกติเกิดขึ้นซึ่งอาจทำให้หน้าเว็บของคุณเงียบและผิดปกติ ทันทีที่เราใช้use strictรหัสจะส่งข้อผิดพลาดออกไปซึ่งจะช่วยให้นักพัฒนาสามารถแก้ไขได้ล่วงหน้า

สิ่งสำคัญบางอย่างที่ฉันได้เรียนรู้หลังจากใช้use strict:

ป้องกันการประกาศตัวแปรทั่วโลก:

var tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000};

function Tree(typeOfTree) {
    var age;
    var leafCount;

    age = typeOfTree.age;
    leafCount = typeOfTree.leafCount;
    nameoftree = typeOfTree.name;
};

var tree1 = new Tree(tree1Data);
console.log(window);

ตอนนี้รหัสนี้สร้างในขอบเขตทั่วโลกที่สามารถเข้าถึงได้โดยใช้nameoftree window.nameoftreeเมื่อเราใช้use strictรหัสจะเกิดข้อผิดพลาด

Uncaught ReferenceError: nameoftree ไม่ได้ถูกกำหนดไว้

Sample

กำจัดwithคำสั่ง:

withงบไม่สามารถลดขนาดลงโดยใช้เครื่องมือเช่นทำให้น่าเกลียด-js พวกเขายังเลิกใช้และลบออกจากรุ่น JavaScript ในอนาคต

Sample

ป้องกันการซ้ำ:

เมื่อเรามีคุณสมบัติที่ซ้ำกันมันจะส่งข้อยกเว้น

Uncaught SyntaxError: คุณสมบัติข้อมูลซ้ำในวัตถุตามตัวอักษรไม่ได้รับอนุญาตในโหมดเข้มงวด

"use strict";
var tree1Data = {
    name: 'Banana Tree',
    age: 100,
    leafCount: 100000,
    name:'Banana Tree'
};

มีอีกไม่กี่ แต่ฉันต้องได้รับความรู้เพิ่มเติมเกี่ยวกับเรื่องนั้น

หากคุณใช้เบราว์เซอร์ที่วางจำหน่ายในปีที่ผ่านมาเป็นไปได้มากว่ามันรองรับโหมด JavaScript ที่เข้มงวด เฉพาะเบราว์เซอร์ที่เก่ากว่าก่อนที่ ECMAScript 5 จะกลายเป็นมาตรฐานปัจจุบันไม่รองรับ

เครื่องหมายคำพูดรอบคำสั่งตรวจสอบให้แน่ใจว่ารหัสจะยังคงทำงานในเบราว์เซอร์รุ่นเก่าได้เช่นกัน (แม้ว่าสิ่งที่สร้างข้อผิดพลาดทางไวยากรณ์ในโหมดเข้มงวดจะทำให้สคริปต์ทำงานผิดปกติในบางเบราว์เซอร์รุ่นเก่า)

เมื่อเพิ่ม"use strict";กรณีต่อไปนี้จะโยนSyntaxErrorก่อนที่สคริปต์จะทำงาน:

• ปูทางสำหรับรุ่นอนาคต ECMAScriptโดยใช้คำหลักของลิขสิทธิ์ใหม่ (ในทำนายสำหรับECMAScript 6 ): implements, interface, let, package, private, protected, public, และstaticyield

• ประกาศฟังก์ชันในบล็อก

  if(a<b){ function f(){} }

• ไวยากรณ์ฐานแปด

  var n = 023;

• this ชี้ไปที่วัตถุระดับโลก

   function f() {
        "use strict";
        this.a = 1;
   };
   f(); 

• การประกาศชื่อเดียวกันสองครั้งสำหรับชื่อคุณสมบัติในวัตถุตามตัวอักษร

   {a: 1, b: 3, a: 7} 

  นี่ไม่ใช่กรณีใน ECMAScript 6 ( ข้อผิดพลาด 1041128 )

• ประกาศอาร์กิวเมนต์สองฟังก์ชันด้วยฟังก์ชันชื่อเดียวกัน

  f(a, b, b){}

• การตั้งค่าเป็นตัวแปรที่ไม่ได้ประกาศ

  function f(x){
     "use strict";
     var a = 12;
     b = a + x*35; // error!
  }
  f();

• การใช้deleteชื่อตัวแปรdelete myVariable;

• การใช้evalหรือargumentsเป็นตัวแปรหรือชื่ออาร์กิวเมนต์ของฟังก์ชัน

  "use strict";
  arguments++;
  var obj = { set p(arguments) { } };
  try { } catch (arguments) { }
  function arguments() { } 

แหล่งที่มา:

• การเปลี่ยนเป็นโหมดเข้มงวดบน MDN

• โหมดเข้มงวดใน MDN

• โหมดเข้มงวดของ JavaScript และสาเหตุที่คุณควรใช้ในบล็อกของ Colin J. Ihrig (เวอร์ชันที่เก็บถาวร)

โหมดเข้มงวดทำการเปลี่ยนแปลงหลายอย่างกับซีแมนทิกส์ JavaScript ปกติ:

• กำจัดข้อผิดพลาดเงียบจาวาสคริปต์บางส่วนโดยเปลี่ยนให้เป็นข้อผิดพลาด

• แก้ไขข้อผิดพลาดที่ทำให้เอ็นจิ้น JavaScript ทำการเพิ่มประสิทธิภาพได้ยาก

• ห้ามไม่ให้มีการกำหนดไวยากรณ์บางอย่างใน ECMAScript เวอร์ชันในอนาคต

สำหรับข้อมูลเพิ่มเติมเยี่ยมชมStrict Mode- Javascript

"ใช้อย่างเข้มงวด"; เป็นประกันที่โปรแกรมเมอร์จะไม่ใช้คุณสมบัติหลวมหรือไม่ดีของ JavaScript มันเป็นแนวทางเช่นเดียวกับไม้บรรทัดที่จะช่วยคุณสร้างเส้นตรง "ใช้อย่างเข้มงวด" จะช่วยให้คุณทำ "รหัสตรง"

ผู้ที่ไม่ต้องการใช้ไม้บรรทัดในการทำเส้นตรงมักจะจบลงในหน้าเว็บเหล่านั้นเพื่อขอให้ผู้อื่นดีบักรหัสของพวกเขา

เชื่อฉัน. โอเวอร์เฮดนั้นเล็กน้อยเมื่อเปรียบเทียบกับโค้ดที่ออกแบบมาไม่ดี ดั๊กครอกที่ได้รับการพัฒนา JavaScript อาวุโสเป็นเวลาหลายปีที่ผ่านมามีการโพสต์ที่น่าสนใจมากที่นี่ โดยส่วนตัวฉันชอบกลับไปที่ไซต์ของเขาตลอดเวลาเพื่อให้แน่ใจว่าฉันจะไม่ลืมแนวปฏิบัติที่ดีของฉัน

การฝึกจาวาสคริปต์ที่ทันสมัยควรทำให้ "ใช้อย่างเข้มงวด" เสมอ pragma เหตุผลเดียวที่กลุ่ม ECMA ได้เลือกโหมด "เข้มงวด" คืออนุญาตให้ผู้ใช้โคเดอร์ที่มีประสบการณ์น้อยสามารถเข้าถึง JavaScript และให้เวลาในการปรับตัวเข้ากับแนวทางการเข้ารหัสใหม่และปลอดภัยยิ่งขึ้น

การรวมuse strictไว้ในจุดเริ่มต้นของไฟล์ JavaScript ที่ละเอียดอ่อนทั้งหมดของคุณจากจุดนี้เป็นวิธีเล็ก ๆ ในการเป็นโปรแกรมเมอร์ JavaScript ที่ดีขึ้นและหลีกเลี่ยงตัวแปรแบบสุ่มที่กลายเป็นส่วนกลางและสิ่งต่าง ๆ เปลี่ยนไปอย่างเงียบ ๆ

ข้อความจาก w3schools :

คำสั่ง "ใช้อย่างเข้มงวด"

คำสั่ง "use เข้มงวด" เป็นสิ่งใหม่ใน JavaScript 1.8.5 (ECMAScript เวอร์ชัน 5)

มันไม่ใช่คำสั่ง แต่เป็นนิพจน์ที่เป็นตัวอักษรซึ่งถูกละเว้นโดย JavaScript รุ่นก่อนหน้า

วัตถุประสงค์ของ "ใช้เข้มงวด" คือเพื่อระบุว่าควรเรียกใช้รหัสใน "โหมดเข้มงวด"

ด้วยโหมดที่เข้มงวดคุณไม่สามารถใช้ตัวแปรที่ไม่ได้ประกาศ

ทำไมต้องใช้โหมดเข้มงวด

โหมดเข้มงวดทำให้ง่ายต่อการเขียน JavaScript "ปลอดภัย"

การเปลี่ยนแปลงโหมดเข้มงวดก่อนหน้านี้ยอมรับ "ไวยากรณ์ที่ไม่ดี" เป็นข้อผิดพลาดจริง

ตัวอย่างเช่นใน JavaScript ปกติการพิมพ์ชื่อตัวแปรผิดจะสร้างตัวแปรโกลบอลใหม่ ในโหมดเข้มงวดสิ่งนี้จะทำให้เกิดข้อผิดพลาดทำให้ไม่สามารถสร้างตัวแปรส่วนกลางได้โดยไม่ตั้งใจ

ใน JavaScript ปกติผู้พัฒนาจะไม่ได้รับข้อเสนอแนะข้อผิดพลาดที่กำหนดค่าให้กับคุณสมบัติที่ไม่สามารถเขียนได้

ในโหมดเข้มงวดการกำหนดให้กับคุณสมบัติที่ไม่สามารถเขียนได้คุณสมบัติ getter-only คุณสมบัติที่ไม่มีอยู่ตัวแปรที่ไม่มีอยู่หรือวัตถุที่ไม่มีอยู่จะทำให้เกิดข้อผิดพลาด

โปรดดูhttp://www.w3schools.com/js/js_strict.aspเพื่อทราบข้อมูลเพิ่มเติม

"use strict"ทำให้โค้ด JavaScript ทำงานในโหมดเข้มงวดซึ่งโดยทั่วไปหมายความว่าทุกอย่างจะต้องมีการกำหนดไว้ก่อนการใช้งาน เหตุผลหลักสำหรับการใช้โหมดเข้มงวดคือการหลีกเลี่ยงการใช้วิธีการที่ไม่ได้กำหนดในระดับโลกโดยไม่ตั้งใจ

นอกจากนี้ในโหมดเข้มงวดสิ่งต่าง ๆ ทำงานได้เร็วขึ้นคำเตือนหรือคำเตือนแบบเงียบจะทำให้เกิดข้อผิดพลาดร้ายแรงควรใช้รหัสนี้เพื่อสร้างรหัส neater

"use strict"จำเป็นต้องใช้กันอย่างแพร่หลายใน ECMA5 ใน ECMA6 เป็นส่วนหนึ่งของ JavaScript ตามค่าเริ่มต้นดังนั้นจึงไม่จำเป็นต้องเพิ่มถ้าคุณใช้ ES6

ดูข้อความเหล่านี้และตัวอย่างจาก MDN:

คำสั่ง
"use เข้มงวด" คำสั่ง "use เข้มงวด" เป็นสิ่งใหม่ใน JavaScript 1.8.5 (ECMAScript เวอร์ชัน 5) มันไม่ใช่คำสั่ง แต่เป็นนิพจน์ที่เป็นตัวอักษรซึ่งถูกละเว้นโดย JavaScript รุ่นก่อนหน้า วัตถุประสงค์ของ "ใช้เข้มงวด" คือเพื่อระบุว่าควรเรียกใช้รหัสใน "โหมดเข้มงวด" ด้วยโหมดที่เข้มงวดคุณไม่สามารถใช้ตัวแปรที่ไม่ได้ประกาศ

ตัวอย่างการใช้ "use เคร่งครัด":
โหมด Strict สำหรับฟังก์ชั่น: ในทำนองเดียวกันหากต้องการเรียกใช้โหมดเข้มงวดสำหรับฟังก์ชั่น (หรือ 'ใช้เข้มงวด';) ในเนื้อหาของฟังก์ชันก่อนข้อความอื่น ๆ

1) โหมดเข้มงวดในฟังก์ชั่น

 function strict() {
     // Function-level strict mode syntax
     'use strict';
     function nested() { return 'And so am I!'; }
     return "Hi!  I'm a strict mode function!  " + nested();
 }
 function notStrict() { return "I'm not strict."; }

 console.log(strict(), notStrict());

2) โหมดที่เข้มงวดทั้งสคริปต์

'use strict';
var v = "Hi! I'm a strict mode script!";
console.log(v);

3) การมอบหมายให้กับโลกที่ไม่สามารถเขียนได้

'use strict';

// Assignment to a non-writable global
var undefined = 5; // throws a TypeError
var Infinity = 5; // throws a TypeError

// Assignment to a non-writable property
var obj1 = {};
Object.defineProperty(obj1, 'x', { value: 42, writable: false });
obj1.x = 9; // throws a TypeError

// Assignment to a getter-only property
var obj2 = { get x() { return 17; } };
obj2.x = 5; // throws a TypeError

// Assignment to a new property on a non-extensible object.
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = 'ohai'; // throws a TypeError

คุณสามารถอ่านเพิ่มเติมเกี่ยวกับ MDN

มีการพูดคุยที่ดีจากบางคนที่อยู่ในคณะกรรมการ ECMAScript คือ: การเปลี่ยนแปลงจาวา, ส่วนที่ 1: ECMAScript 5 "เกี่ยวกับวิธีการใช้งานที่เพิ่มขึ้นของ"use strict"สวิตช์ที่ช่วยให้ผู้ใช้งาน JavaScript สามารถล้างคุณสมบัติที่เป็นอันตรายของ JavaScript ได้โดยไม่ทำลายทุกเว็บไซต์ ในโลก.

แน่นอนว่ามันยังพูดถึงความผิดพลาดเหล่านั้นอีกมากมายและ ECMAScript 5 แก้ไขอย่างไร

ตัวอย่างเล็ก ๆ ที่จะเปรียบเทียบ:

โหมดไม่เข้มงวด:

for (i of [1,2,3]) console.log(i)
    
// output:
// 1
// 2
// 3

โหมดเข้มงวด:

'use strict';
for (i of [1,2,3]) console.log(i)

// output:
// Uncaught ReferenceError: i is not defined

โหมดไม่เข้มงวด:

String.prototype.test = function () {
  console.log(typeof this === 'string');
};

'a'.test();

// output
// false

String.prototype.test = function () {
  'use strict';
  
  console.log(typeof this === 'string');
};

'a'.test();

// output
// true

โปรดทราบว่าuse strictถูกนำมาใช้ในEcmaScript 5และถูกเก็บไว้ตั้งแต่นั้น

ด้านล่างนี้เป็นเงื่อนไขในการเรียกใช้โหมดเข้มงวดในES6และES7 :

• รหัสสากลเป็นรหัสโหมดเข้มงวดหากเริ่มต้นด้วยคำสั่ง Directive ที่มีการใช้คำสั่งที่เข้มงวด (ดู 14.1.1)
• รหัสโมดูลเป็นรหัสโหมดเข้มงวดเสมอ
• ทุกส่วนของClassDeclarationหรือ ClassExpressionเป็นรหัสโหมดเข้มงวด
• รหัส Eval เป็นรหัสโหมดเข้มงวดหากเริ่มต้นด้วย Directive Prologue ที่มี Use Strict Directive หรือหากการเรียกไปยัง eval เป็น eval โดยตรง (ดู 12.3.4.1) ที่อยู่ในรหัสโหมดเข้มงวด
• รหัสฟังก์ชั่นเป็นรหัสโหมดเข้มงวดหากFunctionDeclaration ที่เกี่ยวข้อง, Function Expression, GeneratorDeclaration, Generator Expression, MethodDefinition หรือ ArrowFunctionมีอยู่ในรหัสโหมดเข้มงวดหรือหากรหัสที่สร้างมูลค่าของฟังก์ชั่นภายใน [[ECMAScriptCode]] เริ่มต้นด้วยที่มีการใช้คำสั่งที่เข้มงวด
• รหัสฟังก์ชั่นที่ให้มาเป็นอาร์กิวเมนต์ของตัวสร้างฟังก์ชั่นและเครื่องกำเนิดไฟฟ้าในตัวเป็นรหัสโหมดเข้มงวดหากอาร์กิวเมนต์สุดท้ายคือสตริงที่เมื่อประมวลผลเป็นFunctionBodyที่เริ่มต้นด้วยคำสั่ง Directive ที่มีการใช้คำสั่งที่เข้มงวด

สาเหตุหลักที่ผู้พัฒนาควรใช้"use strict"คือ:

1. ป้องกันการประกาศตัวแปรโกลบอลโดยไม่ตั้งใจการใช้"use strict()"จะทำให้แน่ใจว่ามีการประกาศตัวแปรด้วยvarก่อนการใช้งาน เช่น:

   function useStrictDemo(){
    'use strict';
    //works fine
    var a = 'No Problem';
   
    //does not work fine and throws error
    k = "problem"
   
    //even this will throw error
    someObject = {'problem': 'lot of problem'};
   }

2. หมายเหตุ: "use strict"คำสั่งจะได้รับการยอมรับเฉพาะที่จุดเริ่มต้นของสคริปต์หรือฟังก์ชั่น

3. "arguments"ไม่สามารถใช้สตริงเป็นตัวแปร:

   "use strict";
   var arguments = 3.14;    // This will cause an error

4. จะ จำกัด การใช้คำหลักเป็นตัวแปร การพยายามใช้มันจะทำให้เกิดข้อผิดพลาด

ในระยะสั้นจะทำให้รหัสของคุณเกิดข้อผิดพลาดน้อยลงและในทางกลับกันจะทำให้คุณเขียนโค้ดที่ดี

เพื่ออ่านข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้คุณสามารถดูได้ที่นี่

"ใช้อย่างเข้มงวด"; ความพยายามของ ECMA คือการทำให้ JavaScript แข็งแกร่งขึ้นเล็กน้อย มันนำมาซึ่งความพยายามในการทำให้ JS อย่างน้อย "เข้มงวด" (ภาษาอื่นใช้กฎที่เข้มงวดตั้งแต่ 90s) จริงๆแล้วมัน "บังคับ" นักพัฒนา JavaScript เพื่อปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดในการเขียนโค้ด ถึงกระนั้น JavaScript ก็บอบบางมาก ไม่มีสิ่งเช่นตัวแปรที่พิมพ์วิธีการพิมพ์ ฯลฯ ฉันขอแนะนำให้นักพัฒนา JavaScript เรียนรู้ภาษาที่มีประสิทธิภาพมากขึ้นเช่น Java หรือ ActionScript3 และใช้แนวทางปฏิบัติที่ดีที่สุดแบบเดียวกันในรหัส JavaScript ของคุณมันจะทำงานได้ดีขึ้นและง่ายขึ้น การแก้ปัญหา

มีการแนะนำโหมด JavaScript "เข้มงวด" ใน ECMAScript 5

(function() {
  "use strict";
  your code...
})();

การเขียน"use strict";ที่ด้านบนสุดของไฟล์ JS ของคุณจะเป็นการตรวจสอบไวยากรณ์ที่เข้มงวด มันทำงานดังต่อไปนี้สำหรับเรา:

1. แสดงข้อผิดพลาดถ้าคุณพยายามที่จะกำหนดให้กับตัวแปรที่ไม่ได้ประกาศ

2. หยุดคุณจากการเขียนทับไลบรารีระบบ JS ที่สำคัญ

3. ห้ามคุณสมบัติภาษาบางอย่างที่ไม่ปลอดภัยหรือผิดพลาด

use strictยังทำงานในฟังก์ชั่นของแต่ละบุคคล เป็นวิธีปฏิบัติที่ดีกว่าเสมอuse strictในการใส่รหัสของคุณ

ปัญหาความเข้ากันได้ของเบราว์เซอร์: คำสั่ง "ใช้" มีไว้เพื่อให้ใช้งานร่วมกับระบบย้อนหลังได้ เบราว์เซอร์ที่ไม่รองรับพวกเขาจะเห็นสตริงตัวอักษรที่ไม่ได้อ้างอิงเพิ่มเติม ดังนั้นพวกเขาจะผ่านมันและเดินหน้าต่อไป

use strictเป็นวิธีที่ทำให้โค้ดของคุณปลอดภัยยิ่งขึ้นเพราะคุณไม่สามารถใช้คุณสมบัติที่เป็นอันตรายที่ไม่สามารถทำงานได้ตามที่คุณคาดหวัง และอย่างที่เขียนไว้ก่อนหน้านี้มันทำให้รหัสเข้มงวดยิ่งขึ้น

Use Strict ใช้เพื่อแสดงข้อผิดพลาดทั่วไปและข้อผิดพลาดซ้ำ ๆ เพื่อให้การจัดการแตกต่างกันและเปลี่ยนแปลงวิธีที่จาวาสคริปต์ทำงานการเปลี่ยนแปลงดังกล่าวคือ:

• ป้องกันการเกิดอุบัติเหตุแบบไม่ตั้งใจ

• ไม่มีการซ้ำซ้อน

• กำจัดด้วย

• กำจัดการบีบบังคับนี้

• ปลอดภัยกว่า eval ()

• ข้อผิดพลาดสำหรับสิ่งที่ไม่สามารถเปลี่ยนแปลงได้

คุณสามารถอ่านบทความนี้สำหรับรายละเอียด

โดยปกติแล้ว JavaScript จะไม่ปฏิบัติตามกฎระเบียบที่เข้มงวดซึ่งจะเป็นการเพิ่มโอกาสของข้อผิดพลาด หลังการใช้งาน"use strict"งานรหัสจาวาสคริปต์ควรเป็นไปตามกฎระเบียบที่เข้มงวดเช่นเดียวกับในภาษาการเขียนโปรแกรมอื่นเช่นการใช้งานเทอร์มินัล

หาก"use strict"มีการใช้งานรหัสควรจะถูกเขียนโดยทำตามกฎที่เข้มงวดซึ่งจะช่วยลดโอกาสของข้อผิดพลาดและความคลุมเครือ

"ใช้อย่างเข้มงวด"; กำหนดว่ารหัส JavaScript ควรถูกเรียกใช้งานใน "โหมดเข้มงวด"

• คำสั่ง "use เข้มงวด" เป็นสิ่งใหม่ใน ECMAScript เวอร์ชัน 5
• มันไม่ใช่คำสั่ง แต่เป็นนิพจน์ที่เป็นตัวอักษรซึ่งถูกละเว้นโดย JavaScript รุ่นก่อนหน้า
• วัตถุประสงค์ของ "ใช้เข้มงวด" คือเพื่อระบุว่าควรเรียกใช้รหัสใน "โหมดเข้มงวด"
• ด้วยโหมดที่เข้มงวดคุณไม่สามารถใช้ตัวแปรที่ไม่ได้ประกาศ

เบราว์เซอร์ที่ทันสมัยทั้งหมดสนับสนุน "ใช้อย่างเข้มงวด" ยกเว้นInternet Explorer 9 และล่าง

ข้อเสียเปรียบ

หากนักพัฒนาใช้ไลบรารีที่อยู่ในโหมดเข้มงวด แต่นักพัฒนาซอฟต์แวร์เคยทำงานในโหมดปกติพวกเขาอาจเรียกการกระทำบางอย่างในไลบรารีที่ไม่ทำงานตามที่คาดไว้

ที่แย่กว่านั้นเนื่องจากผู้พัฒนาอยู่ในโหมดปกติพวกเขาไม่มีข้อได้เปรียบจากข้อผิดพลาดพิเศษที่ถูกส่งออกไปดังนั้นข้อผิดพลาดอาจล้มเหลวอย่างเงียบ ๆ

นอกจากนี้ตามที่กล่าวข้างต้นโหมดเข้มงวดจะห้ามไม่ให้คุณทำบางสิ่ง

โดยทั่วไปคนคิดว่าคุณไม่ควรใช้สิ่งเหล่านั้นในตอนแรก แต่นักพัฒนาบางคนไม่ชอบข้อ จำกัด และต้องการใช้คุณสมบัติทั้งหมดของภาษา

• สำหรับตัวอย่างพื้นฐานและสำหรับการอ้างอิงผ่าน:

  https://www.tutorialsteacher.com/javascript/javascript-strict

โหมดเข้มงวดสามารถป้องกันการรั่วไหลของหน่วยความจำ

โปรดตรวจสอบฟังก์ชั่นด้านล่างที่เขียนในโหมดไม่เข้มงวด:

function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name); // Stack Overflow

ในฟังก์ชั่นนี้เราใช้ตัวแปรที่เรียกว่า nameภายในฟังก์ชั่น ภายในคอมไพเลอร์จะตรวจสอบก่อนว่ามีตัวแปรใด ๆ ที่ประกาศด้วยชื่อนั้นในขอบเขตของฟังก์ชันนั้นหรือไม่ เนื่องจากคอมไพเลอร์เข้าใจว่าไม่มีตัวแปรดังกล่าวจึงจะตรวจสอบในขอบเขตด้านนอก ในกรณีของเรามันเป็นขอบเขตทั่วโลก อีกครั้งคอมไพเลอร์เข้าใจว่าไม่มีตัวแปรที่ประกาศในพื้นที่โลกด้วยชื่อนั้นดังนั้นมันจึงสร้างตัวแปรดังกล่าวสำหรับเราในพื้นที่โลก แนวคิดตัวแปรนี้จะถูกสร้างขึ้นในขอบเขตทั่วโลกและจะสามารถใช้ได้ในการสมัครทั้งหมด

อีกสถานการณ์คือพูดตัวแปรถูกประกาศในฟังก์ชั่นเด็ก ในกรณีนั้นคอมไพเลอร์ตรวจสอบความถูกต้องของตัวแปรนั้นในขอบเขตด้านนอกเช่นฟังก์ชั่นหลัก เท่านั้นมันจะตรวจสอบในพื้นที่โลกและสร้างตัวแปรให้เรา นั่นหมายถึงต้องทำการตรวจสอบเพิ่มเติม สิ่งนี้จะส่งผลต่อประสิทธิภาพของแอปพลิเคชัน

ทีนี้ลองเขียนฟังก์ชั่นเดียวกันในโหมดเข้มงวด

"use strict"
function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name); 

เราจะได้รับข้อผิดพลาดดังต่อไปนี้

Uncaught ReferenceError: name is not defined
at getname (<anonymous>:3:15)
at <anonymous>:6:5

ที่นี่คอมไพเลอร์โยนข้อผิดพลาดการอ้างอิง ในโหมดเข้มงวดคอมไพเลอร์ไม่อนุญาตให้เราใช้ตัวแปรโดยไม่ต้องประกาศ ดังนั้นหน่วยความจำรั่วสามารถป้องกันได้ นอกจากนี้เราสามารถเขียนโค้ดที่ปรับให้เหมาะสมยิ่งขึ้น