Baru-baru ini, saya menjalankan beberapa kode JavaScript saya melalui Crockford's JSLint , dan memberikan kesalahan berikut:

Masalah pada baris 1 karakter 1: Tidak ada pernyataan "gunakan ketat".

Melakukan pencarian, saya menyadari bahwa beberapa orang menambahkan "use strict";ke dalam kode JavaScript mereka. Setelah saya menambahkan pernyataan, kesalahan berhenti muncul. Sayangnya, Google tidak mengungkapkan banyak sejarah di balik pernyataan string ini. Tentu saja itu ada hubungannya dengan bagaimana JavaScript ditafsirkan oleh browser, tapi saya tidak tahu apa efeknya.

Jadi ada apa "use strict";, apa implikasinya, dan apakah itu masih relevan?

Apakah ada dari browser saat ini menanggapi "use strict";string atau apakah untuk digunakan di masa depan?

Artikel ini tentang Mode Ketat Javascript mungkin menarik bagi Anda: John Resig - ECMAScript 5 Strict Mode, JSON, dan Lainnya

Mengutip beberapa bagian menarik:

Mode Ketat adalah fitur baru dalam ECMAScript 5 yang memungkinkan Anda menempatkan program, atau fungsi, dalam konteks operasi "ketat". Konteks ketat ini mencegah tindakan tertentu yang diambil dan melemparkan lebih banyak pengecualian.

Dan:

Mode ketat membantu dalam beberapa cara:

• Ini menangkap beberapa kode kesalahan umum, melempar pengecualian.
• Ini mencegah, atau melempar kesalahan, ketika tindakan yang relatif "tidak aman" diambil (seperti mendapatkan akses ke objek global).
• Ini menonaktifkan fitur yang membingungkan atau dipikirkan dengan buruk.

Perhatikan juga Anda dapat menerapkan "mode ketat" ke seluruh file ... Atau Anda dapat menggunakannya hanya untuk fungsi tertentu (masih mengutip dari artikel John Resig) :

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

Yang mungkin bisa membantu jika Anda harus mencampur kode lama dan baru ;-)

Jadi, saya kira itu agak seperti yang "use strict"dapat Anda gunakan di Perl (karena itu namanya?) : Ini membantu Anda membuat lebih sedikit kesalahan, dengan mendeteksi lebih banyak hal yang dapat menyebabkan kerusakan.

Mode ketat sekarang didukung oleh semua browser utama .

Di dalam modul ECMAScript asli (dengan importdan exportpernyataan) dan kelas ES6 , mode ketat selalu diaktifkan dan tidak dapat dinonaktifkan.

Ini adalah fitur baru dari ECMAScript 5. John Resig menulis ringkasan yang bagus tentang itu.

Ini hanya string yang Anda masukkan ke file JavaScript (baik di bagian atas file Anda atau di dalam suatu fungsi) yang terlihat seperti ini:

"use strict";

Menempatkannya dalam kode Anda sekarang seharusnya tidak menyebabkan masalah dengan browser saat ini karena itu hanya string. Ini dapat menyebabkan masalah dengan kode Anda di masa mendatang jika kode Anda melanggar pragma. Misalnya, jika saat ini Anda memiliki foo = "bar"tanpa mendefinisikan footerlebih dahulu, kode Anda akan mulai gagal ... yang merupakan hal yang baik menurut saya.

Pernyataan itu "use strict";menginstruksikan browser untuk menggunakan mode Strict, yang merupakan set fitur yang diperkecil dan lebih aman dari JavaScript.

Daftar fitur (tidak lengkap)

1. Melarang variabel global. (Menangkap vardeklarasi dan kesalahan ketik yang hilang dalam nama variabel)

2. Tugas gagal yang gagal akan membuat kesalahan dalam mode ketat (menetapkan NaN = 5;)

3. Upaya untuk menghapus properti yang tidak dapat dihapus akan melempar ( delete Object.prototype)

4. Membutuhkan semua nama properti dalam literal objek menjadi unik ( var x = {x1: "1", x1: "2"})

5. Nama parameter fungsi harus unik ( function sum (x, x) {...})

6. Melarang sintaks oktal ( var x = 023;beberapa devs berasumsi salah bahwa nol sebelumnya tidak mengubah angka.)

7. Melarang withkata kunci

8. eval dalam mode ketat tidak memperkenalkan variabel baru

9. Melarang menghapus nama biasa ( delete x;)

10. Melarang pengikatan atau penugasan nama evaldan argumentsdalam bentuk apa pun

11. Mode ketat tidak alias properti argumentsobjek dengan parameter formal. (Yaitu dalam function sum (a,b) { return arguments[0] + b;}Ini bekerja karena arguments[0]terikat adan sebagainya.)

12. arguments.callee tidak didukung

[Ref: Mode Ketat , Jaringan Pengembang Mozilla ]

Jika orang khawatir tentang penggunaannya use strict, mungkin ada baiknya memeriksa artikel ini:

Dukungan ECMAScript 5 'Mode ketat' di browser. Apa artinya ini?
NovoGeek.com - weblog Krishna

Ini berbicara tentang dukungan browser, tetapi yang lebih penting bagaimana menghadapinya dengan aman:

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.
*/

Satu kata peringatan, semua yang Anda isi ulang oleh pemrogram: menerapkan "use strict"kode yang ada bisa berbahaya! Benda ini bukan stiker yang membuat Anda merasa lebih baik dan bahagia, sehingga Anda bisa menampar kode itu untuk membuatnya lebih baik. Dengan "use strict"pragma, browser akan tiba-tiba MELALUI pengecualian di tempat-tempat acak yang tidak pernah dilontarkan sebelumnya hanya karena di tempat itu Anda melakukan sesuatu yang JavaScript default / longgar dengan senang hati mengizinkan tetapi membenci JavaScript yang ketat! Anda mungkin memiliki pelanggaran ketat bersembunyi di panggilan yang jarang digunakan dalam kode Anda yang hanya akan melemparkan pengecualian ketika mereka akhirnya dijalankan - katakanlah, dalam lingkungan produksi yang digunakan pelanggan membayar Anda!

Jika Anda ingin mengambil risiko, itu adalah ide yang baik untuk diterapkan "use strict"bersamaan dengan tes unit komprehensif dan tugas pembangunan JSHint yang dikonfigurasi secara ketat yang akan memberi Anda keyakinan bahwa tidak ada sudut gelap modul Anda yang akan meledak mengerikan hanya karena Anda Sudah menyalakan Mode Ketat. Atau, hei, ini opsi lain: jangan tambahkan "use strict"kode warisan Anda, mungkin lebih aman, jujur. PASTI JANGAN menambah "use strict"modul yang tidak Anda miliki atau pertahankan, seperti modul pihak ketiga.

Saya pikir meskipun itu adalah binatang sangkar yang mematikan, "use strict"bisa menjadi hal yang baik, tetapi Anda harus melakukannya dengan benar. Waktu terbaik untuk bertindak ketat adalah ketika proyek Anda adalah greenfield dan Anda mulai dari awal. Konfigurasikan JSHint/JSLintdengan semua peringatan dan opsi yang dipasang sekencang yang dapat diterima tim Anda, dapatkan kecocokan sistem build / test / assert du jour seperti Grunt+Karma+Chai, dan hanya MAKA mulai menandai semua modul baru Anda sebagai "use strict". Bersiaplah untuk menyembuhkan banyak kesalahan dan peringatan yang picik. Pastikan semua orang memahami gravitasi dengan mengkonfigurasi bangunan ke FAIL jika JSHint/JSLintmenghasilkan pelanggaran.

Proyek saya bukan proyek greenfield ketika saya mengadopsi "use strict". Akibatnya, IDE saya penuh dengan tanda merah karena saya tidak memiliki "use strict"setengah modul saya, dan JSHint mengeluh tentang itu. Ini mengingatkan saya tentang apa yang harus saya lakukan di masa depan. Tujuan saya adalah menjadi tanda merah gratis karena semua "use strict"pernyataan saya yang hilang , tetapi itu masih bertahun-tahun lagi.

Menggunakannya 'use strict';tidak tiba-tiba membuat kode Anda lebih baik.

The JavaScript modus ketat adalah fitur di ECMAScript 5 . Anda dapat mengaktifkan mode ketat dengan mendeklarasikan ini di bagian atas skrip / fungsi Anda.

'use strict';

Ketika mesin JavaScript melihat arahan ini , itu akan mulai menafsirkan kode dalam mode khusus. Dalam mode ini, kesalahan dilontarkan ketika praktik pengkodean tertentu yang akhirnya berpotensi menjadi bug terdeteksi (yang merupakan alasan di balik mode ketat).

Pertimbangkan contoh ini:

var a = 365;
var b = 030;

Dalam obsesi mereka untuk berbaris literal numerik, pengembang secara tidak sengaja menginisialisasi variabel bdengan literal oktal. Mode non-ketat akan menafsirkan ini sebagai numerik literal dengan nilai 24(dalam basis 10). Namun, mode ketat akan menimbulkan kesalahan.

Untuk daftar spesialisasi yang tidak lengkap dalam mode ketat, lihat jawaban ini .

Di mana saya harus menggunakan 'use strict';?

• Di aplikasi JavaScript saya yang baru : Tentu saja! Mode ketat dapat digunakan sebagai pelapor ketika Anda melakukan sesuatu yang bodoh dengan kode Anda.

• Dalam kode JavaScript saya yang ada : Mungkin tidak! Jika kode JavaScript Anda saat ini memiliki pernyataan yang dilarang dalam mode ketat, aplikasi hanya akan rusak. Jika Anda menginginkan mode ketat, Anda harus siap untuk debug dan memperbaiki kode Anda yang ada. Inilah sebabnya mengapa menggunakan 'use strict';tidak tiba-tiba membuat kode Anda lebih baik .

Bagaimana cara menggunakan mode ketat?

1. Masukkan 'use strict';pernyataan di atas skrip Anda:

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

   Perhatikan bahwa semua yang ada di file myscript.jsakan ditafsirkan dalam mode ketat.

2. Atau, masukkan 'use strict';pernyataan di atas badan fungsi Anda:

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

   Segala sesuatu dalam lingkup fungsi leksikaldoSomething akan ditafsirkan dalam mode ketat. Kata lingkup leksikal penting di sini. Misalnya, jika kode ketat Anda memanggil fungsi pustaka yang tidak ketat , hanya kode Anda yang dijalankan dalam mode ketat, dan bukan fungsi yang dipanggil. Lihat jawaban ini untuk penjelasan yang lebih baik.

Hal-hal apa yang dilarang dalam mode ketat?

Saya menemukan artikel bagus yang menggambarkan beberapa hal yang dilarang dalam mode ketat (perhatikan bahwa ini bukan daftar eksklusif):

Cakupan

Secara historis, JavaScript telah bingung tentang bagaimana fungsi-fungsi dilingkupi. Terkadang mereka kelihatannya memiliki cakupan yang statis, tetapi beberapa fitur membuat mereka berperilaku seperti mereka memiliki cakupan yang dinamis. Ini membingungkan, membuat program sulit dibaca dan dipahami. Kesalahpahaman menyebabkan bug. Ini juga merupakan masalah kinerja. Pelingkupan statis akan memungkinkan pengikatan variabel terjadi pada waktu kompilasi, tetapi persyaratan untuk lingkup dinamis berarti pengikatan harus ditangguhkan ke runtime, yang disertai dengan penalti kinerja yang signifikan.

Mode ketat mengharuskan semua pengikatan variabel dilakukan secara statis. Itu berarti bahwa fitur yang sebelumnya memerlukan pengikatan dinamis harus dihilangkan atau dimodifikasi. Secara khusus, pernyataan with dihilangkan, dan kemampuan fungsi eval untuk mengutak-atik lingkungan pemanggilnya sangat dibatasi.

Salah satu manfaat dari kode ketat adalah alat seperti YUI Compressor dapat melakukan pekerjaan yang lebih baik saat memprosesnya.

Variabel Global Tersirat

JavaScript telah menyiratkan variabel global. Jika Anda tidak secara eksplisit mendeklarasikan variabel, variabel global secara implisit dideklarasikan untuk Anda. Ini membuat pemrograman lebih mudah bagi pemula karena mereka dapat mengabaikan beberapa pekerjaan rumah tangga dasar mereka. Tetapi itu membuat pengelolaan program yang lebih besar jauh lebih sulit dan secara signifikan menurunkan keandalan. Jadi dalam mode ketat, variabel global tersirat tidak lagi dibuat. Anda harus secara eksplisit mendeklarasikan semua variabel Anda.

Kebocoran Global

Ada sejumlah situasi yang dapat menyebabkan this terikat pada objek global. Misalnya, jika Anda lupa untuk memberikan newawalan saat memanggil fungsi konstruktor, konstruktor thisakan terikat secara tak terduga ke objek global, jadi alih-alih menginisialisasi objek baru, alih-alih akan diam-diam merusak variabel global. Dalam situasi ini, modus yang ketat akan gantinya mengikat thisuntuk undefined, yang akan menyebabkan konstruktor untuk melemparkan pengecualian sebaliknya, memungkinkan kesalahan terdeteksi lebih cepat.

Kegagalan Bising

JavaScript selalu memiliki properti hanya-baca, tetapi Anda tidak dapat membuatnya sendiri hingga Object.createProperty fungsi ES5 mengekspos kemampuan itu. Jika Anda mencoba untuk menetapkan nilai ke properti hanya-baca, itu akan gagal diam-diam. Penugasan tidak akan mengubah nilai properti, tetapi program Anda akan melanjutkan seolah-olah itu terjadi. Ini adalah bahaya integritas yang dapat menyebabkan program masuk ke kondisi tidak konsisten. Dalam mode ketat, mencoba mengubah properti read-only akan mengeluarkan pengecualian.

Oktal

Representasi angka oktal (atau basis 8) sangat berguna ketika melakukan pemrograman tingkat mesin pada mesin yang ukuran kata-nya adalah kelipatan 3. Anda membutuhkan oktal ketika bekerja dengan mainframe CDC 6600, yang memiliki ukuran kata 60 bit. Jika Anda bisa membaca oktal, Anda bisa melihat kata sebanyak 20 digit. Dua digit mewakili kode op, dan satu digit mengidentifikasi satu dari 8 register. Selama transisi yang lambat dari kode mesin ke bahasa tingkat tinggi, dianggap berguna untuk menyediakan bentuk oktal dalam bahasa pemrograman.

Di C, representasi oktalitas yang sangat disayangkan dipilih: Leading zero. Jadi dalam C, 0100berarti 64, bukan 100, dan 08merupakan kesalahan, bukan 8. Bahkan lebih sayangnya, anakronisme ini telah disalin ke hampir semua bahasa modern, termasuk JavaScript, di mana ia hanya digunakan untuk membuat kesalahan. Tidak ada tujuan lain. Jadi dalam mode ketat, bentuk oktal tidak lagi diizinkan.

Dll

Argumen pseudo array menjadi sedikit lebih mirip array di ES5. Dalam mode ketat, ia kehilangan properti calleedan callerpropertinya. Ini memungkinkan Anda meneruskan argumentskode yang tidak tepercaya tanpa menyerahkan banyak konteks rahasia. Juga, argumentsproperti fungsi dihilangkan.

Dalam mode ketat, duplikat kunci dalam fungsi literal akan menghasilkan kesalahan sintaksis. Fungsi tidak dapat memiliki dua parameter dengan nama yang sama. Fungsi tidak dapat memiliki variabel dengan nama yang sama dengan salah satu parameternya. Suatu fungsi tidak dapat deletevariabelnya sendiri. Upaya ke deleteproperti yang tidak dapat dikonfigurasi sekarang melempar pengecualian. Nilai-nilai primitif tidak dibungkus secara implisit.

Kata-kata yang dicadangkan untuk versi JavaScript yang akan datang

ECMAScript 5 menambahkan daftar kata-kata yang dipesan. Jika Anda menggunakannya sebagai variabel atau argumen, mode ketat akan menimbulkan kesalahan. Kata-kata yang dicadangkan adalah:

implements, interface, let, package, private, protected, public, static, Danyield

Bacaan lebih lanjut

• Mode Ketat - JavaScript | MDN
• Dukungan browser untuk mode ketat
• Transisi ke mode ketat

Saya sangat menyarankan setiap pengembang untuk mulai menggunakan mode ketat sekarang. Ada cukup banyak browser yang mendukungnya sehingga mode ketat secara sah akan membantu menyelamatkan kami dari kesalahan yang bahkan tidak kami ketahui ada dalam kode Anda.

Ternyata, pada tahap awal akan ada kesalahan yang belum pernah kami temui sebelumnya. Untuk mendapatkan manfaat penuh, kita perlu melakukan pengujian yang tepat setelah beralih ke mode ketat untuk memastikan kita telah menangkap semuanya. Jelas kami tidak hanya membuang use strictkode kami dan menganggap tidak ada kesalahan. Jadi churnnya adalah saatnya untuk mulai menggunakan fitur bahasa yang sangat berguna ini untuk menulis kode yang lebih baik.

Sebagai contoh,

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

JSLint adalah debugger yang ditulis oleh Douglas Crockford. Cukup tempel di skrip Anda, dan itu akan dengan cepat memindai segala masalah dan kesalahan yang terlihat dalam kode Anda.

Saya ingin menawarkan jawaban yang agak lebih mapan melengkapi jawaban yang lain. Saya berharap untuk mengedit jawaban paling populer, tetapi gagal. Saya mencoba membuatnya selengkap dan selengkap mungkin.

Anda dapat merujuk ke dokumentasi MDN untuk informasi lebih lanjut.

"use strict" arahan yang diperkenalkan dalam ECMAScript 5.

Arahan mirip dengan pernyataan, namun berbeda.

• use stricttidak mengandung kata-kata kunci: Arahan adalah pernyataan ekspresi sederhana, yang terdiri dari string literal khusus (dalam tanda kutip tunggal atau ganda). Mesin JavaScript, yang tidak menerapkan ECMAScript 5, hanya melihat pernyataan ekspresi tanpa efek samping. Diharapkan bahwa versi mendatang dari standar ECMAScript memperkenalkan usesebagai kata kunci nyata; kutipan dengan demikian akan menjadi usang.
• use strictdapat digunakan hanya pada awal naskah atau fungsi, yaitu harus mendahului setiap pernyataan (nyata) lainnya. Itu tidak harus menjadi instruksi pertama dalam skrip fungsi: itu dapat didahului oleh pernyataan pernyataan lain yang terdiri dari string literal (dan implementasi JavaScript dapat memperlakukannya sebagai arahan khusus implementasi). Pernyataan literal string, yang mengikuti pernyataan nyata pertama (dalam skrip atau fungsi) adalah pernyataan ekspresi sederhana. Penerjemah tidak boleh menafsirkannya sebagai arahan dan mereka tidak memiliki efek.

The use strictdirektif menunjukkan bahwa kode berikut (dalam naskah atau fungsi) adalah kode yang ketat. Kode di tingkat tertinggi skrip (kode yang tidak berfungsi) dianggap kode ketat ketika skrip berisi use strictarahan. Konten dari suatu fungsi dianggap kode ketat ketika fungsi itu sendiri didefinisikan dalam kode ketat atau ketika fungsi tersebut mengandung use strictarahan. Kode yang diteruskan ke suatu eval()metode dianggap kode ketat ketika eval()dipanggil dari kode ketat atau mengandung use strictarahan itu sendiri.

Mode ketat ECMAScript 5 adalah subset terbatas dari bahasa JavaScript, yang menghilangkan defisit bahasa yang relevan dan menampilkan pengecekan kesalahan yang lebih ketat dan keamanan yang lebih tinggi. Berikut ini daftar perbedaan antara mode ketat dan mode normal (di mana tiga yang pertama sangat penting):

• Anda tidak dapat menggunakan withpernyataan-dalam mode ketat.
• Dalam mode ketat, semua variabel harus dideklarasikan: jika Anda menetapkan nilai ke pengenal yang belum dinyatakan sebagai variabel, fungsi, parameter fungsi, parameter catch-clause atau properti global Object, maka Anda akan mendapatkan ReferenceError. Dalam mode normal, pengidentifikasi secara implisit dinyatakan sebagai variabel global (sebagai properti global Object)
• Dalam mode ketat, kata kunci thismemiliki nilai undefineddalam fungsi yang dipanggil sebagai fungsi (bukan sebagai metode). (Dalam mode normal thisselalu menunjuk ke global Object). Perbedaan ini dapat digunakan untuk menguji apakah suatu implementasi mendukung mode ketat:

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

• Juga ketika suatu fungsi dipanggil dengan call()atau applydalam mode ketat, maka thistepat nilai argumen pertama dari call()atau apply()doa. (Dalam mode normal nulldan undefineddigantikan oleh global Objectdan nilai-nilai, yang bukan objek, dilemparkan ke objek.)

• Dalam mode ketat Anda akan mendapatkan TypeError, ketika Anda mencoba menetapkan untuk properti hanya baca atau untuk mendefinisikan properti baru untuk objek yang tidak dapat diperluas. (Dalam mode normal keduanya gagal tanpa pesan kesalahan.)

• Dalam mode ketat, saat meneruskan kode ke eval(), Anda tidak dapat mendeklarasikan atau mendefinisikan variabel atau fungsi dalam ruang lingkup pemanggil (seperti yang dapat Anda lakukan dalam mode normal). Sebagai gantinya, ruang lingkup baru dibuat untuk eval()dan variabel dan fungsi berada dalam ruang lingkup itu. Lingkup itu hancur setelah eval()eksekusi selesai.
• Dalam mode ketat argumen-objek suatu fungsi berisi salinan statis dari nilai-nilai, yang diteruskan ke fungsi itu. Dalam mode normal, argumen-objek memiliki perilaku yang agak "ajaib": Elemen-elemen dari array dan parameter fungsi yang dinamai keduanya memiliki nilai yang sama.
• Dalam mode ketat Anda akan mendapatkan SyntaxErrorketika deleteoperator diikuti oleh pengidentifikasi yang tidak memenuhi syarat (variabel, fungsi atau parameter fungsi). Dalam mode normal, deleteekspresi tidak akan melakukan apa pun dan dievaluasi false.
• Dalam mode ketat Anda akan mendapatkan TypeErrorketika Anda mencoba untuk menghapus properti yang tidak dapat dikonfigurasi. (Dalam mode normal, upaya tersebut gagal dan deleteekspresi dievaluasi menjadi false).
• Dalam mode ketat ini dianggap sebagai kesalahan sintaksis ketika Anda mencoba mendefinisikan beberapa properti dengan nama yang sama untuk objek literal. (Dalam mode normal tidak ada kesalahan.)
• Dalam mode ketat itu dianggap sebagai kesalahan sintaksis ketika deklarasi fungsi memiliki beberapa parameter dengan nama yang sama. (Dalam mode normal tidak ada kesalahan.)
• Dalam mode ketat literal oktal tidak diperbolehkan (ini adalah literal yang dimulai dengan 0x. (Dalam mode normal beberapa implementasi memang memungkinkan literal oktal.)
• Dalam mode ketat pengidentifikasi evaldan argumentsdiperlakukan seperti kata kunci. Anda tidak dapat mengubah nilainya, tidak dapat memberikan nilainya, dan Anda tidak dapat menggunakannya sebagai nama untuk variabel, fungsi, parameter fungsi, atau pengidentifikasi blok tangkap.
• Dalam mode ketat ada lebih banyak pembatasan pada kemungkinan untuk memeriksa tumpukan panggilan. arguments.callerdan arguments.calleemenyebabkan suatu TypeErrorfungsi dalam mode ketat. Selain itu, beberapa properti penelepon dan argumen fungsi dalam mode ketat menyebabkan TypeErrorketika Anda mencoba untuk membacanya.

Dua sen saya:

Salah satu tujuan dari mode ketat adalah untuk memungkinkan debugging masalah lebih cepat. Ini membantu pengembang dengan melemparkan pengecualian ketika terjadi kesalahan tertentu yang dapat menyebabkan perilaku diam & aneh laman web Anda. Saat kami menggunakan use strict, kode akan membuang kesalahan yang membantu pengembang untuk memperbaikinya terlebih dahulu.

Beberapa hal penting yang saya pelajari setelah menggunakan use strict:

Mencegah Deklarasi Variabel Global:

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);

Sekarang, kode ini dibuat nameoftreedalam lingkup global yang dapat diakses menggunakan window.nameoftree. Ketika kami menerapkan use strictkode akan membuang kesalahan.

Referensi Tidak Tertangkap: nameoftree tidak didefinisikan

Sample

Hilangkan withpernyataan:

withpernyataan tidak dapat dikecilkan menggunakan alat seperti uglify-js . Mereka juga sudah tidak digunakan lagi dan dihapus dari versi JavaScript yang akan datang.

Sample

Mencegah Duplikat:

Ketika kami memiliki properti duplikat, itu melempar pengecualian

Uncaught SyntaxError: Properti data duplikat dalam objek literal tidak diizinkan dalam mode ketat

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

Ada beberapa lagi tetapi saya perlu mendapatkan lebih banyak pengetahuan tentang itu.

Jika Anda menggunakan browser yang dirilis pada tahun lalu atau lebih maka kemungkinan besar mendukung mode JavaScript Strict. Hanya browser lama yang ada sebelum ECMAScript 5 menjadi standar saat ini yang tidak mendukungnya.

Kutipan di sekitar perintah memastikan bahwa kode juga akan tetap bekerja di browser lama (meskipun hal-hal yang menghasilkan kesalahan sintaks dalam mode ketat umumnya hanya akan menyebabkan skrip tidak berfungsi dalam beberapa cara yang sulit dideteksi di browser lama itu).

Saat menambahkan "use strict";, kasus-kasus berikut akan melempar SyntaxError sebelum skrip dijalankan:

• Membuka jalan untuk versi ECMAScript masa depan , menggunakan salah satu kata kunci yang baru disediakan (di ramalan untuk ECMAScript 6 ): implements, interface, let, package, private, protected, public, static, dan yield.

• Mendeklarasikan fungsi dalam blok

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

• Sintaks oktal

  var n = 023;

• this arahkan ke objek global.

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

• Mendeklarasikan dua kali nama yang sama untuk nama properti dalam objek literal

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

  Ini bukan lagi kasus di ECMAScript 6 ( bug 1041128 ).

• Mendeklarasikan dua argumen fungsi dengan fungsi nama yang sama

  f(a, b, b){}

• Menetapkan nilai ke variabel yang tidak dideklarasikan

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

• Menggunakan deletenama variabeldelete myVariable;

• Menggunakan evalatau argumentssebagai variabel atau nama argumen fungsi

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

Sumber:

• Transisi ke mode ketat di MDN

• Mode ketat pada MDN

• Mode Ketat JavaScript dan Mengapa Anda Harus Menggunakannya di blog Colin J. Ihrig (versi arsip)

Mode ketat membuat beberapa perubahan pada semantik JavaScript normal:

• menghilangkan beberapa kesalahan diam JavaScript dengan mengubahnya untuk membuang kesalahan.

• memperbaiki kesalahan yang menyulitkan mesin JavaScript untuk melakukan optimasi.

• melarang beberapa sintaks yang kemungkinan akan didefinisikan dalam versi ECMAScript berikutnya.

untuk informasi lebih lanjut, vistit Mode Ketat - Javascript

"Gunakan Ketat"; adalah asuransi yang programmer tidak akan menggunakan sifat longgar atau buruk dari JavaScript. Ini adalah panduan, sama seperti penggaris akan membantu Anda membuat garis lurus. "Gunakan Strict" akan membantu Anda melakukan "Straight coding".

Mereka yang memilih untuk tidak menggunakan penggaris untuk melakukan garis lurus biasanya berakhir di halaman tersebut meminta orang lain untuk men-debug kode mereka.

Percayalah padaku. Biaya overhead dapat diabaikan dibandingkan dengan kode yang dirancang dengan buruk. Doug Crockford, yang telah menjadi pengembang senior JavaScript selama beberapa tahun, memiliki posting yang sangat menarik di sini . Secara pribadi, saya suka kembali ke situsnya setiap saat untuk memastikan saya tidak melupakan praktik baik saya.

Praktik JavaScript modern harus selalu membangkitkan "Use Strict"; pragma. Satu-satunya alasan ECMA Group menjadikan mode "Strict" menjadi opsional adalah untuk mengizinkan akses coders yang kurang berpengalaman ke JavaScript dan kemudian memberi waktu untuk beradaptasi dengan praktik pengkodean yang baru dan lebih aman.

Termasuk use strictdi awal semua file JavaScript sensitif Anda dari titik ini adalah cara kecil untuk menjadi programmer JavaScript yang lebih baik dan menghindari variabel acak menjadi global dan segala sesuatunya berubah secara diam-diam.

Mengutip dari w3schools :

Petunjuk "use strict"

Arahan "gunakan ketat" adalah baru dalam JavaScript 1.8.5 (ECMAScript versi 5).

Ini bukan pernyataan, tetapi ekspresi literal, diabaikan oleh versi JavaScript sebelumnya.

Tujuan dari "gunakan ketat" adalah untuk menunjukkan bahwa kode harus dieksekusi dalam "mode ketat".

Dengan mode ketat, Anda tidak dapat, misalnya, menggunakan variabel yang tidak dideklarasikan.

Mengapa Mode Yang Ketat?

Mode ketat membuatnya lebih mudah untuk menulis JavaScript "aman".

Mode ketat mengubah "bad syntax" yang diterima sebelumnya menjadi kesalahan nyata.

Sebagai contoh, dalam JavaScript normal, salah ketik nama variabel membuat variabel global baru. Dalam mode ketat, ini akan menimbulkan kesalahan, sehingga tidak mungkin untuk secara tidak sengaja membuat variabel global.

Dalam JavaScript normal, pengembang tidak akan menerima umpan balik kesalahan yang menetapkan nilai ke properti yang tidak bisa ditulisi.

Dalam mode ketat, setiap penugasan ke properti yang tidak bisa ditulisi, properti pengambil-saja, properti yang tidak ada, variabel yang tidak ada, atau objek yang tidak ada, akan menimbulkan kesalahan.

Silakan merujuk ke http://www.w3schools.com/js/js_strict.asp untuk tahu lebih banyak

"use strict"membuat kode JavaScript untuk dijalankan dalam mode ketat , yang pada dasarnya berarti semuanya harus didefinisikan sebelum digunakan. Alasan utama untuk menggunakan mode ketat adalah untuk menghindari penggunaan global dari metode yang tidak ditentukan.

Juga dalam mode ketat, segalanya berjalan lebih cepat, beberapa peringatan atau peringatan diam membuat kesalahan fatal, lebih baik untuk selalu menggunakannya untuk membuat kode yang lebih rapi.

"use strict"secara luas diperlukan untuk digunakan dalam ECMA5, di ECMA6 itu adalah bagian dari JavaScript secara default , jadi tidak perlu ditambahkan jika Anda menggunakan ES6.

Lihatlah pernyataan dan contoh ini dari MDN:

Petunjuk "use strict"
The directive "use strict" adalah baru dalam JavaScript 1.8.5 (ECMAScript versi 5). Ini bukan pernyataan, tetapi ekspresi literal, diabaikan oleh versi JavaScript sebelumnya. Tujuan dari "gunakan ketat" adalah untuk menunjukkan bahwa kode harus dieksekusi dalam "mode ketat". Dengan mode ketat, Anda tidak dapat, misalnya, menggunakan variabel yang tidak dideklarasikan.

Contoh penggunaan "gunakan ketat":
Mode ketat untuk fungsi: Demikian juga, untuk mengaktifkan mode ketat untuk suatu fungsi, tulis pernyataan persis "gunakan ketat"; (atau 'gunakan ketat';) di badan fungsi sebelum pernyataan lainnya.

1) mode ketat dalam fungsi

 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) mode ketat seluruh skrip

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

3) Penugasan untuk global yang tidak dapat ditulis

'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

Anda dapat membaca lebih lanjut tentang MDN .

Ada pembicaraan yang baik oleh beberapa orang yang ada di komite ECMAScript: Perubahan pada JavaScript, Bagian 1: ECMAScript 5 " tentang bagaimana penambahan penggunaan "use strict"sakelar memungkinkan para pelaksana JavaScript untuk membersihkan banyak fitur berbahaya JavaScript tanpa tiba-tiba merusak setiap situs web Di dalam dunia.

Tentu saja ini juga berbicara tentang betapa banyak kesalahan tersebut dan bagaimana ECMAScript 5 memperbaikinya.

Contoh kecil untuk dibandingkan:

Mode tidak ketat:

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

Mode yang ketat:

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

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

Mode tidak ketat:

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

Catatan yang use strictdiperkenalkan di EcmaScript 5 dan disimpan sejak saat itu.

Di bawah ini adalah kondisi untuk memicu mode ketat di ES6 dan ES7 :

• Kode global adalah kode mode yang ketat jika dimulai dengan Prolog Arahan yang berisi Arahan Penggunaan Ketat (lihat 14.1.1).
• Kode modul selalu merupakan kode mode ketat.
• Semua bagian dari ClassDeclaration atau ClassExpression adalah kode mode yang ketat.
• Kode Eval adalah kode mode ketat jika diawali dengan Direktif Prolog yang berisi Use Strict Directive atau jika panggilan untuk eval adalah eval langsung (lihat 12.3.4.1) yang terdapat dalam kode mode ketat.
• Kode fungsi adalah kode mode yang ketat jika terkait FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition, atau ArrowFunction terkandung dalam kode mode yang ketat atau jika kode yang menghasilkan nilai slot fungsi [[ECMAScriptCode]] fungsi dimulai dengan Prolog Directive yang berisi Use Strict Directive.
• Kode fungsi yang disediakan sebagai argumen untuk Konstruktor Fungsi dan Generator bawaan adalah kode mode yang ketat jika argumen terakhir adalah String yang ketika diproses adalah FunctionBody yang dimulai dengan Prolog Arahan yang berisi Use Strict Directive.

Alasan utama mengapa pengembang harus menggunakan "use strict"adalah:

1. Mencegah deklarasi variabel global yang tidak disengaja . Menggunakan "use strict()"akan memastikan bahwa variabel dideklarasikan dengan varsebelum digunakan. Misalnya:

   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. NB: "use strict"Arahan hanya dikenali pada awal skrip atau fungsi.

3. String "arguments"tidak dapat digunakan sebagai variabel:

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

4. Akan membatasi penggunaan kata kunci sebagai variabel. Mencoba menggunakannya akan menimbulkan kesalahan.

Singkatnya akan membuat kode Anda lebih sedikit rawan kesalahan dan pada gilirannya akan membuat Anda menulis kode yang baik.

Untuk membaca lebih lanjut tentang hal ini, Anda dapat merujuk di sini .

"gunakan ketat"; adalah upaya ECMA untuk membuat JavaScript sedikit lebih kuat. Ini membawa JS upaya untuk membuatnya setidaknya sedikit "ketat" (bahasa lain menerapkan aturan ketat sejak tahun 90-an). Ini sebenarnya "memaksa" pengembang JavaScript untuk mengikuti semacam praktik terbaik pengkodean. Namun, JavaScript masih sangat rapuh. Tidak ada variabel yang diketik, metode yang diketik, dll. Saya sangat menyarankan pengembang JavaScript untuk mempelajari bahasa yang lebih kuat seperti Java atau ActionScript3, dan menerapkan praktik terbaik yang sama dalam kode JavaScript Anda, itu akan bekerja lebih baik dan lebih mudah untuk debug.

Mode JavaScript "ketat" diperkenalkan di ECMAScript 5.

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

Menulis "use strict";di bagian paling atas dari file JS Anda mengaktifkan pemeriksaan sintaks yang ketat. Itu melakukan tugas-tugas berikut untuk kita:

1. menunjukkan kesalahan jika Anda mencoba untuk menetapkan ke variabel yang tidak dideklarasikan

2. menghentikan Anda dari menimpa pustaka sistem kunci JS

3. melarang beberapa fitur bahasa yang tidak aman atau rentan kesalahan

use strictjuga berfungsi di dalam fungsi individu. Itu selalu merupakan praktik yang lebih baik untuk dimasukkan use strictdalam kode Anda.

Masalah kompatibilitas browser: Arahan "use" dimaksudkan untuk kompatibel dengan mundur. Browser yang tidak mendukungnya hanya akan melihat string literal yang tidak dirujuk lebih lanjut. Jadi, mereka akan melewatinya dan melanjutkan.

use strictadalah cara untuk membuat kode Anda lebih aman, karena Anda tidak dapat menggunakan fitur berbahaya yang dapat bekerja tidak seperti yang Anda harapkan. Dan, seperti yang ditulis sebelumnya, itu membuat kode lebih ketat.

Use Strict digunakan untuk menampilkan kesalahan umum dan berulang sehingga ditangani secara berbeda, dan mengubah cara skrip java berjalan, perubahan tersebut adalah:

• Mencegah global yang tidak disengaja

• Tidak ada duplikat

• Eliminasi dengan

• Hilangkan paksaan ini

• Eval aman ()

• Kesalahan untuk kekal

Anda juga dapat membaca artikel ini untuk detailnya

Biasanya, JavaScript tidak mengikuti aturan ketat, sehingga meningkatkan kemungkinan kesalahan. Setelah menggunakan "use strict", kode JavaScript harus mengikuti serangkaian aturan ketat seperti dalam bahasa pemrograman lain seperti penggunaan terminator, deklarasi sebelum inisialisasi, dll.

Jika "use strict"digunakan, kode harus ditulis dengan mengikuti seperangkat aturan yang ketat, sehingga mengurangi kemungkinan kesalahan dan ambiguitas.

"gunakan ketat"; Menentukan bahwa kode JavaScript harus dieksekusi dalam "mode ketat".

• Arahan "use strict" adalah baru dalam ECMAScript versi 5.
• Ini bukan pernyataan, tetapi ekspresi literal, diabaikan oleh versi JavaScript sebelumnya.
• Tujuan dari "gunakan ketat" adalah untuk menunjukkan bahwa kode harus dieksekusi dalam "mode ketat".
• Dengan mode ketat, Anda tidak dapat, misalnya, menggunakan variabel yang tidak dideklarasikan.

Semua browser modern mendukung "penggunaan yang ketat" kecuali Internet Explorer 9 dan yang lebih rendah .

Kerugian

Jika pengembang menggunakan pustaka yang berada dalam mode ketat, tetapi pengembang terbiasa bekerja dalam mode normal, mereka mungkin memanggil beberapa tindakan pada pustaka yang tidak akan berfungsi seperti yang diharapkan.

Lebih buruk lagi, karena pengembang berada dalam mode normal, mereka tidak memiliki kelebihan dari kesalahan tambahan yang dilemparkan, sehingga kesalahan tersebut bisa gagal secara diam-diam.

Juga, seperti yang tercantum di atas, mode ketat menghentikan Anda dari melakukan hal-hal tertentu.

Orang-orang pada umumnya berpikir bahwa Anda seharusnya tidak menggunakan hal-hal itu sejak awal, tetapi beberapa pengembang tidak suka kendala dan ingin menggunakan semua fitur bahasa.

• Untuk contoh dasar dan untuk referensi melalui:

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

Mode yang ketat dapat mencegah kebocoran memori.

Silakan periksa fungsi di bawah ini yang ditulis dalam mode tidak ketat:

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

Dalam fungsi ini, kami menggunakan variabel yang disebut namedi dalam fungsi. Secara internal, kompiler akan terlebih dahulu memeriksa apakah ada variabel yang dideklarasikan dengan nama tertentu dalam lingkup fungsi tertentu. Karena kompiler mengerti bahwa tidak ada variabel seperti itu, ia akan memeriksa dalam lingkup luar. Dalam kasus kami, ini adalah ruang lingkup global. Sekali lagi, kompiler mengerti bahwa juga tidak ada variabel yang dideklarasikan di ruang global dengan nama itu, sehingga ia membuat variabel seperti itu bagi kita di ruang global. Secara konseptual, variabel ini akan dibuat dalam lingkup global dan akan tersedia di seluruh aplikasi.

Skenario lain adalah bahwa, katakanlah, variabel dideklarasikan dalam fungsi anak. Dalam kasus itu, kompilator memeriksa validitas variabel itu di lingkup luar, yaitu fungsi induk. Hanya kemudian akan memeriksa di ruang global dan membuat variabel untuk kita di sana. Itu berarti pemeriksaan tambahan perlu dilakukan. Ini akan mempengaruhi kinerja aplikasi.

Sekarang mari kita tulis fungsi yang sama dalam mode ketat.

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

Kami akan mendapatkan kesalahan berikut.

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

Di sini, kompiler melempar kesalahan referensi. Dalam mode ketat, kompiler tidak memungkinkan kita untuk menggunakan variabel tanpa mendeklarasikannya. Sehingga kebocoran memori bisa dicegah. Selain itu, kami dapat menulis kode yang lebih optimal.