Apakah mod ketat dalam javascript

Mod ketat JavaScript merujuk kepada kod yang dijalankan di bawah syarat ketat Mod ini mentakrifkan model penghuraian dan pelaksanaan yang berbeza untuk JavaScript. Ia akan menyemak ralat kod pembangun di bawah keadaan yang lebih ketat (digunakan di dalam sesuatu fungsi).

Persekitaran pengendalian tutorial ini: sistem Windows 7, versi JavaScript 1.8.5, komputer Dell G3.

1. Apakah itu mod ketat

Dalam ES5, JS memperkenalkan konsep mod ketat buat kali pertama. Mod ketat JavaScript berjalan di bawah syarat yang ketat.

Mod ketat mentakrifkan model penghuraian dan pelaksanaan yang berbeza untuk JavaScript Ia akan menyemak ralat kod anda di bawah keadaan yang lebih ketat. Ia boleh digunakan secara global atau setempat (digunakan dalam fungsi ). Adalah sangat perlu untuk memahami peraturan mod ketat Pada masa hadapan, ECMAScript akan memaksa penggunaan mod ketat secara global.

Seperti namanya, mod ini menjadikan Javascript dijalankan dalam keadaan yang lebih ketat.

Tujuan utama mewujudkan "mod ketat" adalah seperti berikut:

- Hapuskan beberapa aspek sintaks Javascript yang tidak munasabah dan kurangkan beberapa tingkah laku pelik; rasa tidak selamat dalam menjalankan kod dan memastikan keselamatan kod berjalan;

　 - Meningkatkan kecekapan pengkompil dan meningkatkan kelajuan berjalan;

"Mod Ketat" mencerminkan hala tuju pembangunan Javascript yang lebih munasabah, lebih selamat dan lebih ketat, termasuk IE 10, sudah menyokongnya dan banyak projek besar telah mula menerimanya sepenuhnya.

Sebaliknya, kod yang sama mungkin mempunyai hasil larian yang berbeza dalam "mod ketat"; beberapa pernyataan yang boleh dijalankan dalam "mod biasa" tidak akan dapat dijalankan dalam "mod ketat". Menguasai kandungan ini akan membantu anda memahami Javascript dengan lebih terperinci dan menjadikan anda seorang pengaturcara yang lebih baik.

Artikel ini akan memperkenalkan "mod ketat" secara terperinci.

2. Tanda masuk

Tanda memasuki "mod ketat" ialah baris pernyataan berikut:

　　"use strict";

3. Cara memanggil

"Mod ketat" mempunyai dua kaedah panggilan, sesuai untuk majlis yang berbeza.

letakkan "use strict" pada baris pertama fail skrip, kemudian keseluruhan skrip akan berjalan dalam "strict mode". Jika baris pernyataan ini bukan baris pertama, ia tidak mempunyai kesan dan keseluruhan skrip berjalan dalam "mod biasa". Ini memerlukan perhatian khusus jika fail kod daripada mod berbeza digabungkan menjadi satu fail. (Tegasnya, selagi pernyataan sebelumnya bukan pernyataan yang menghasilkan hasil operasi sebenar, "gunakan ketat" tidak perlu berada pada baris pertama, seperti mengikuti koma bernoktah kosong secara langsung.)

　　<script>
　　　　&quot;use strict&quot;;
　　　　console.log("这是严格模式。");
　　</script>
　　<script>
　　　　console.log("这是正常模式。");kly, it&#39;s almost 2 years ago now. I can admit it now - I run it on my school&#39;s network that has about 50 computers.
　　</script>

letakkan "use strict" pada baris pertama badan fungsi, kemudian keseluruhan fungsi akan berjalan dalam "strict mode".

3.3 Cara alternatif menulis fail skrip

　　function strict(){
　　　　"use strict";
　　　　return "这是严格模式。";
　　}
　　function notStrict() {
　　　　return "这是正常模式。";
　　}

Oleh kerana kaedah panggilan pertama tidak kondusif untuk penggabungan fail, pendekatan yang lebih baik ialah meminjam kaedah kedua , letakkan keseluruhan fail skrip dalam fungsi tanpa nama yang dilaksanakan serta-merta.

　　(function (){
　　　　"use strict";
　　　　// some code here
　　 })();

Mod ketat telah membuat beberapa perubahan pada sintaks dan gelagat Javascript.

Dalam mod biasa, jika pembolehubah diberikan nilai tanpa diisytiharkan, lalai ialah pembolehubah global. Mod ketat melarang penggunaan ini dan pembolehubah global mesti diisytiharkan secara eksplisit.

"use strict";
　　v = 1; // 报错，v未声明
　　for(i = 0; i < 2; i++) { // 报错，i未声明
　　}

Ciri bahasa Javascript ialah ia membenarkan "pengikatan dinamik", iaitu objek yang dimiliki oleh sesetengah sifat dan kaedah, bukan dalam objek mana yang mereka miliki. Ia ditentukan pada masa penyusunan, tetapi pada masa jalan. Mod ketat mengenakan beberapa sekatan pada pengikatan dinamik. Dalam sesetengah kes, hanya pengikatan statik dibenarkan. Dalam erti kata lain, objek yang dimiliki oleh sifat dan kaedah ditentukan semasa peringkat penyusunan. Ini akan membantu meningkatkan kecekapan penyusunan, menjadikan kod lebih mudah dibaca dan menyebabkan lebih sedikit kejutan.

Secara khusus, ia melibatkan aspek berikut.

(1) Dilarang menggunakan pernyataan with

kerana pernyataan with tidak boleh menentukan pada masa penyusunan objek mana yang dimiliki oleh atribut tersebut.

　　"use strict";
　　var v = 1;
　　with (o){ // 语法错误
　　　　v = 2;
　　}

正常模式下，eval语句的作用域，取决于它处于全局作用域，还是处于函数作用域。严格模式下，eval语句本身就是一个作用域，不再能够生成全局变量了，它所生成的变量只能用于eval内部。

　　"use strict";
　　var x = 2;
　　console.info(eval("var x = 5; x")); // 5
　　console.info(x); // 2

4.3 增强的安全措施

（1）禁止this关键字指向全局对象

　　function f(){
　　　　return !this;
　　}
　　// 返回false，因为"this"指向全局对象，"!this"就是false
　　function f(){
　　　　"use strict";
　　　　return !this;
　　}
　　// 返回true，因为严格模式下，this的值为undefined，所以"!this"为true。

因此，使用构造函数时，如果忘了加new，this不再指向全局对象，而是报错。

　　function f(){
　　　　"use strict";
　　　　this.a = 1;
　　};
　　f();// 报错，this未定义

（2）禁止在函数内部遍历调用栈

　　function f1(){
　　　　"use strict";
　　　　f1.caller; // 报错
　　　　f1.arguments; // 报错
　　}
　　f1();

4.4 禁止删除变量

严格模式下无法删除变量。只有configurable设置为true的对象属性，才能被删除。

　　"use strict";
　　var x;
　　delete x; // 语法错误
　　var o = Object.create(null, {'x': {
　　　　　　value: 1,
　　　　　　configurable: true
　　}});
　　delete o.x; // 删除成功

4.5 显式报错

正常模式下，对一个对象的只读属性进行赋值，不会报错，只会默默地失败。严格模式下，将报错。

　　"use strict";
　　var o = {};
　　Object.defineProperty(o, "v", { value: 1, writable: false });
　　o.v = 2; // 报错

严格模式下，对一个使用getter方法读取的属性进行赋值，会报错。

　　"use strict";
　　var o = {
　　　　get v() { return 1; }
　　};
　　o.v = 2; // 报错

严格模式下，对禁止扩展的对象添加新属性，会报错。

　　"use strict";
　　var o = {};
　　Object.preventExtensions(o);
　　o.v = 1; // 报错

严格模式下，删除一个不可删除的属性，会报错。

　　"use strict";
　　delete Object.prototype; // 报错

4.6 重名错误

严格模式新增了一些语法错误。

（1）对象不能有重名的属性

正常模式下，如果对象有多个重名属性，最后赋值的那个属性会覆盖前面的值。严格模式下，这属于语法错误。

　　"use strict";
　　var o = {
　　　　p: 1,
　　　　p: 2
　　}; // 语法错误

（2）函数不能有重名的参数

正常模式下，如果函数有多个重名的参数，可以用arguments[i]读取。严格模式下，这属于语法错误。

　　"use strict";
　　function f(a, a, b) { // 语法错误
　　　　return ;
　　}

4.7 禁止八进制表示法

正常模式下，整数的第一位如果是0，表示这是八进制数，比如0100等于十进制的64。严格模式禁止这种表示法，整数第一位为0，将报错。

　　"use strict";
　　var n = 0100; // 语法错误

4.8 arguments对象的限制

arguments是函数的参数对象，严格模式对它的使用做了限制。

（1）不允许对arguments赋值

　　"use strict";
　　arguments++; // 语法错误
　　var obj = { set p(arguments) { } }; // 语法错误
　　try { } catch (arguments) { } // 语法错误
　　function arguments() { } // 语法错误
　　var f = new Function("arguments", "'use strict'; return 17;"); // 语法错误

（2）arguments不再追踪参数的变化

　　function f(a) {
　　　　a = 2;
　　　　return [a, arguments[0]];
　　}
　　f(1); // 正常模式为[2,2]
　　function f(a) {
　　　　"use strict";
　　　　a = 2;
　　　　return [a, arguments[0]];
　　}
　　f(1); // 严格模式为[2,1]

（3）禁止使用arguments.callee

这意味着，你无法在匿名函数内部调用自身了。

　　"use strict";
　　var f = function() { return arguments.callee; };
　　f(); // 报错

4.9 函数必须声明在顶层

将来Javascript的新版本会引入"块级作用域"。为了与新版本接轨，严格模式只允许在全局作用域或函数作用域的顶层声明函数。也就是说，不允许在非函数的代码块内声明函数。

　　"use strict";
　　if (true) {
　　　　function f() { } // 语法错误
　　}
　　for (var i = 0; i < 5; i++) {
　　　　function f2() { } // 语法错误
　　}

4.10 保留字

为了向将来Javascript的新版本过渡，严格模式新增了一些保留字：implements, interface, let, package, private, protected, public, static, yield。

使用这些词作为变量名将会报错。

　　function package(protected) { // 语法错误
　　　　"use strict";
　　　　var implements; // 语法错误
　　}

此外，ECMAscript第五版本身还规定了另一些保留字（class, enum, export, extends, import, super），以及各大浏览器自行增加的const保留字，也是不能作为变量名的。

【相关推荐：javascript学习教程】

Atas ialah kandungan terperinci Apakah mod ketat dalam javascript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!