Son zamanlarda, JavaScript kodumun bir kısmını Crockford'un JSLint'i aracılığıyla çalıştırdım ve şu hatayı verdi:

1. satırdaki sorun 1: Eksik "kullanım katı" ifadesi eksik.

Biraz arama yaparak, bazı kişilerin "use strict";JavaScript kodlarına eklediğini fark ettim . İfadeyi ekledikten sonra hata görünmüyordu. Maalesef Google, bu dize ifadesinin arkasındaki geçmişin çoğunu açıklamadı. Kesinlikle JavaScript'in tarayıcı tarafından nasıl yorumlandığıyla ilgili bir şey olması gerekir, ancak etkinin ne olacağı hakkında hiçbir fikrim yok.

Öyleyse ne "use strict";hakkında, ne anlama geliyor ve hala alakalı mi?

Mevcut tarayıcılardan herhangi biri "use strict";dizeye yanıt veriyor mu veya ileride kullanılmak üzere mi?

Javascript Sıkı Modu hakkındaki bu makale ilginizi çekebilir: John Resig - ECMAScript 5 Sıkı Modu, JSON ve Daha Fazlası

Bazı ilginç bölümleri alıntılamak için:

Katı Mod, ECMAScript 5'te bir programı veya işlevi "katı" çalışma bağlamına yerleştirmenizi sağlayan yeni bir özelliktir. Bu katı bağlam belirli eylemlerin yapılmasını önler ve daha fazla istisna atar.

Ve:

Katı mod birkaç şekilde yardımcı olur:

• Bazı yaygın kodlama hatalarını yakalar ve istisnalar atar.
• Nispeten "güvenli olmayan" eylemler gerçekleştirildiğinde (global nesneye erişim gibi) hataları önler veya atar.
• Kafa karıştırıcı veya kötü düşünülmüş özellikleri devre dışı bırakır.

Ayrıca, tüm dosyaya "katı mod" uygulayabileceğinizi unutmayın ... Veya yalnızca belirli bir işlev için kullanabilirsiniz (John Resig'in makalesinden alıntı yaparak) :

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

Eski ve yeni kodu karıştırmanız gerekiyorsa ;-)

Yani, sanırım "use strict"Perl'de kullanabileceğiniz gibi (bu yüzden adı?) : Kırılmaya yol açabilecek daha fazla şeyi tespit ederek daha az hata yapmanıza yardımcı olur.

Sıkı mod artık tüm büyük tarayıcılar tarafından desteklenmektedir .

İçinde yerli ECMAScript modülleriyle (ile importve exportifadeleri) ve ES6 sınıfları , katı mod her zaman etkindir ve engelli olamaz.

ECMAScript 5'in yeni bir özelliği. John Resig bunun güzel bir özetini yazdı .

JavaScript dosyalarınıza (dosyanızın en üstüne veya bir işlevin içine) koyduğunuz bir dize şöyledir:

"use strict";

Kodunuza şimdi koymak, sadece bir dize olduğu için mevcut tarayıcılarda herhangi bir soruna neden olmamalıdır. Kodunuz pragmayı ihlal ederse, gelecekte kodunuzla ilgili sorunlara neden olabilir. Örneğin, şu anda ilk olarak foo = "bar"tanımlamadan sahipseniz foo, kodunuz başarısız olmaya başlayacaktır ... bence iyi bir şey.

İfadesi "use strict";JavaScript azaltılmış ve daha güvenli özellik kümesidir Sıkı modunu kullanmak için tarayıcı bildirir.

Özelliklerin listesi (ayrıntılı olmayan)

1. Global değişkenlere izin vermez. ( varDeğişken adlarındaki eksik bildirimleri ve yazım hatalarını yakalar )

2. Sessiz başarısız atamalar katı modda hata atar (atama NaN = 5;)

3. Silinemeyen özellikleri silme girişimleri atılacak ( delete Object.prototype)

4. Bir nesne değişmezindeki tüm özellik adlarının benzersiz ( var x = {x1: "1", x1: "2"}) olmasını gerektirir

5. İşlev parametre adları benzersiz olmalıdır ( function sum (x, x) {...})

6. Sekizlik sözdizimini yasaklar ( var x = 023;bazı geliştiriciler yanlış bir şekilde önceki sıfırın sayıyı değiştirmek için hiçbir şey yapmadığını varsayar.)

7. withAnahtar kelimeyi yasaklar

8. eval katı modda yeni değişkenler getirmez

9. Düz adları silmeyi yasaklar ( delete x;)

10. Atama adları veya bağlanma yasaklar evalve argumentsherhangi bir biçimde

11. Sıkı mod, argumentsnesnenin özelliklerini resmi parametrelerle diğer adlara takmaz . (yani function sum (a,b) { return arguments[0] + b;}bu çalışır çünkü arguments[0]bağlıdır avb.)

12. arguments.callee desteklenmiyor

[Ref: Katı mod , Mozilla Geliştirici Ağı ]

İnsanlar kullanmaktan endişe duyuyorsa use strict bu makaleyi incelemeye değer olabilir:

ECMAScript 5 Tarayıcılarda 'Katı mod' desteği. Ne anlama geliyor?
NovoGeek.com - Krishna'nın web günlüğü

Tarayıcı desteğinden bahsediyor, ancak daha da önemlisi bununla nasıl güvenli bir şekilde başa çıkılacağından bahsediyor:

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

Dikkatli bir kelime, tüm zor şarj programcıları: "use strict"mevcut koda başvurmak tehlikeli olabilir! Bu şey, 'daha iyi' yapmak için kodu tokatlayabileceğiniz, iyi hissettiren, mutlu yüzlü bir etiket değildir. İle"use strict" pragma, tarayıcı aniden varsayılan / gevşek JavaScript mutlu izin verdiğini bu noktada bir şey yapıyorsun sırf daha önce attı asla rastgele yerlerde istisnalar ama sıkı bir JavaScript tiksinen ATMAK olacak! Kodunuzda nadiren kullanılan çağrılarda gizlenen, ancak sonuçta çalışan müşterilerin kullandıkları üretim ortamında, yalnızca sonunda çalıştıklarında bir istisna atacak katılık ihlalleriniz olabilir!

Eğer dalma yapacaksanız, "use strict"kapsamlı birim testleri ve kesinlikle yapılandırılmış bir JSHint derleme görevinin yanı sıra modülünüzün karanlık bir köşesi olmadığına dair size güven verecek, Sıkı Modu açtım. Ya da, hey, başka bir seçenek: sadece "use strict"eski kodlarınızı eklemeyin , muhtemelen bu şekilde daha güvenlidir. KESİNLİKLE YAPMAYIN eklemek "use strict"üçüncü parti modüllerinde olduğu gibi, kendi yok herhangi modülleri veya bakımını.

Bence ölümcül kafesli bir hayvan olmasına rağmen, "use strict"iyi şeyler olabilir, ama bunu doğru yapmak zorundasın. Sıkı gitmek için en iyi zaman, projenizin greenfield olduğu ve sıfırdan başladığınız zamandır. JSHint/JSLintEkibinizin midesi olabildiğince sıkı kılan tüm uyarı ve seçeneklerle yapılandırın , iyi bir derleme / test / iddia sistemi gibi hileli bir şekilde alın Grunt+Karma+Chaive sadece SONRA tüm yeni modüllerinizi olarak işaretlemeye başlayın "use strict". Çok fazla hata ve uyarıyı iyileştirmeye hazır olun. JSHint/JSLintHerhangi bir ihlal oluşturursa, yapıyı FAIL olarak yapılandırarak herkesin yerçekimini anladığından emin olun .

Benim projem kabul ettiğimde bir yeşil alan projesi değildi "use strict". Sonuç olarak, "use strict"IDE'm kırmızı işaretlerle dolu çünkü modüllerin yarısında yok ve JSHint bundan şikayet ediyor. Gelecekte ne gibi yeniden düzenleme yapmam gerektiğine dair bir hatırlatma. Amacım, eksik "use strict"ifadelerimin tümü nedeniyle kırmızı işaret ücretsiz olmaktır , ancak bu yıllar sonra.

Kullanmak 'use strict';aniden kodunuzu daha iyi hale getirmez.

JavaScript katı mod bir özelliktir ECMAScript'e 5 . Sıkı modu, komut dosyanızın / işlevinizin üstünde bildirerek etkinleştirebilirsiniz.

'use strict';

Bir JavaScript motoru bu yönergeyi gördüğünde , kodu özel bir modda yorumlamaya başlar. Bu modda, potansiyel hatalar haline gelebilecek bazı kodlama uygulamaları tespit edildiğinde hatalar atılır (bu, katı modun arkasındaki nedendir).

Bu örneği düşünün:

var a = 365;
var b = 030;

Sayısal değişmezleri hizalama takıntılarında, geliştirici yanlışlıkla bbir sekizli değişmezle değişken başlattı . Katı olmayan mod bunu değeri olan sayısal bir değişmez olarak yorumlar 24(taban 10'da). Ancak, katı mod bir hata atar.

Katı modda kapsamlı olmayan bir uzmanlık listesi için bu cevaba bakınız .

Nerede kullanmalıyım 'use strict';?

• Benim içinde yeni bir JavaScript uygulaması: Kesinlikle! Sıkı mod, kodunuzla aptalca bir şey yaptığınızda bir ihbar olarak kullanılabilir.

• Benim içinde varolan JavaScript kodu: Muhtemelen hayır! Mevcut JavaScript kodunuzda katı modda yasaklanmış ifadeler varsa, uygulama kolayca kesilir. Sıkı mod istiyorsanız, mevcut kodunuzda hata ayıklamaya ve düzeltmeye hazır olmalısınız. Bu yüzden kullanmak 'use strict';aniden kodunuzu daha iyi hale getirmez .

Katı modu nasıl kullanırım?

1. 'use strict';Komut dosyanızın üstüne bir ifade ekleyin :

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

   Dosyadaki her şeyin myscript.jskatı modda yorumlanacağını unutmayın.

2. Veya 'use strict';işlev gövdesinin üstüne bir ifade ekleyin :

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

   Sözcüksel işlev kapsamındaki her şey doSomethingkatı modda yorumlanacaktır. Sözcüksel kapsam kelimesi burada önemlidir. Örneğin, katı kodunuz katı olmayan bir kitaplığın işlevini çağırırsa , yalnızca kodunuz katı modda yürütülür, çağrılan işlevde çalıştırılmaz. Daha iyi bir açıklama için bu cevaba bakınız .

Katı modda neler yasaklanmıştır?

Sıkı modda yasaklanmış birkaç şeyi açıklayan güzel bir makale buldum (bunun özel bir liste olmadığını unutmayın):

Dürbün

Tarihsel olarak, JavaScript işlevlerin nasıl kapsandığı konusunda kafası karışmıştı. Bazen statik olarak kapsamlandırılmış gibi görünürler, ancak bazı özellikler onları dinamik olarak kapsamlandırılmış gibi davranır. Bu kafa karıştırıcı, programları okumayı ve anlamayı zorlaştırıyor. Yanlış anlama hatalara neden olur. Aynı zamanda performans için de bir problemdir. Statik kapsam belirleme, değişken bağlamanın derleme zamanında gerçekleşmesine izin verecektir, ancak dinamik kapsam gereksinimi, bağlamanın çalışma zamanına ertelenmesi gerektiği anlamına gelir ve bu da önemli bir performans cezası ile birlikte gelir.

Katı mod, tüm değişken bağlamanın statik olarak yapılmasını gerektirir. Bu, daha önce dinamik bağlama gerektiren özelliklerin kaldırılması veya değiştirilmesi gerektiği anlamına gelir. Özellikle, with ifadesi ortadan kaldırılır ve eval işlevinin arayanın ortamına müdahale etme yeteneği ciddi şekilde kısıtlanır.

Katı kodun avantajlarından biri, YUI Kompresörü gibi araçların işlerken daha iyi bir iş yapabilmesidir.

Zımni Global Değişkenler

JavaScript genel değişkenleri ima etti. Bir değişkeni açıkça bildirmezseniz, genel bir değişken sizin için örtük olarak bildirilir. Bu, yeni başlayanlar için programlamayı kolaylaştırır, çünkü bazı temel temizlik işlerini ihmal edebilirler. Ancak daha büyük programların yönetimini çok daha zorlaştırır ve güvenilirliği önemli ölçüde azaltır. Bu nedenle katı modda, ima edilen global değişkenler artık yaratılmamaktadır. Tüm değişkenlerinizi açıkça beyan etmelisiniz.

Küresel Sızıntı

this Global nesneye bağlı olabilecek bazı durumlar vardır . Örneğin, newbir yapıcı işlevini çağırırken öneki sağlamayı unutursanız , yapıcı thisgenel nesneye beklenmedik bir şekilde bağlanır, bu nedenle yeni bir nesne başlatmak yerine bunun yerine global değişkenlerle sessizce müdahale eder. Bu durumlarda, katı mod bunun yerine bağlanacak thisve undefinedbu da yapıcı yerine bir istisna atmasına neden olacak ve hatanın daha erken tespit edilmesine izin verecektir.

Gürültülü Hata

JavaScript her zaman salt okunur özelliklere sahiptir, ancak ES5'in Object.createProperty işlevi bu özelliği gösterene kadar bunları kendiniz oluşturamazsınız . Salt okunur bir özelliğe değer atamayı denerseniz, sessizce başarısız olur. Atama, mülkün değerini değiştirmez, ancak programınız sanki olduğu gibi devam eder. Bu, programların tutarsız duruma geçmesine neden olabilecek bir bütünlük tehlikesidir. Katı modda, salt okunur bir özelliği değiştirmeye çalışmak bir istisna atar.

Sekizli

Sayıların sekizli (veya taban 8) temsili, kelime boyutları 3'ün katları olan makinelerde makine düzeyinde programlama yaparken son derece kullanışlıdır. 60 bitlik kelime boyutuna sahip CDC 6600 ana çerçevesi ile çalışırken sekizli gerekir. Sekizli okuyabilseydiniz, bir kelimeye 20 hane olarak bakabilirsiniz. İki basamak op kodunu temsil eder ve bir basamak 8 kayıttan birini tanımlar. Makine kodlarından yüksek seviyeli dillere yavaş geçiş sırasında, programlama dillerinde sekizli formlar sağlamanın yararlı olduğu düşünülmüştür.

C'de, oktalitenin son derece talihsiz bir temsili seçildi: Önde gelen sıfır. Yani C'de, 0100100 değil , 64 anlamına gelir ve 088 değil, bir hatadır. Ne yazık ki, bu anakronizm, sadece hatalar oluşturmak için kullanılan JavaScript dahil olmak üzere neredeyse tüm modern dillere kopyalanmıştır. Başka bir amacı yok. Yani katı modda, sekizli formlara artık izin verilmiyor.

Ve benzeri

Sözde dizi bağımsız değişkenleri ES5'te biraz daha diziye benzer hale gelir. Katı modda, calleeve caller özelliklerini kaybeder . Bu, argumentsçok fazla gizli bağlamdan vazgeçmeden güvenilmeyen kodunuza geçmenizi mümkün kılar . Ayrıca arguments işlevlerin özelliği elimine edilir.

Katı modda, işlev değişmezindeki yinelenen tuşlar bir sözdizimi hatası oluşturur. Bir işlevin aynı ada sahip iki parametresi olamaz. Bir işlev, parametrelerinden biriyle aynı ada sahip bir değişkene sahip olamaz. Bir fonksiyonun deletekendi değişkenleri olamaz . Denemesi deleteyapılandırılamayan özelliği artık bir istisna atar. İlkel değerler örtük olarak sarılmaz.

Gelecekteki JavaScript sürümleri için ayrılmış kelimeler

ECMAScript 5, ayrılmış kelimelerin bir listesini ekler. Bunları değişken veya bağımsız değişken olarak kullanırsanız katı mod bir hata atar. Ayrılmış kelimeler:

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

Daha fazla okuma

• Katı Mod - JavaScript | MDN
• Katı mod için tarayıcı desteği
• Katı moda geçme

Her geliştiricinin şimdi katı modu kullanmaya başlamasını şiddetle tavsiye ediyorum. Sıkı modun, kodunuzda olduğunu bile bilmediğimiz hatalardan bizi meşru bir şekilde korumamıza yardımcı olacak yeterli tarayıcı var.

Görünüşe göre, ilk aşamada daha önce hiç karşılaşmadığımız hatalar olacak. Tam faydayı elde etmek için, her şeyi yakaladığımızdan emin olmak için katı moda geçtikten sonra uygun testler yapmalıyız. Kesinlikle sadece use strictkodumuzu atmıyoruz ve hata olmadığını varsayıyoruz. Yani, daha iyi kod yazmak için bu inanılmaz kullanışlı dil özelliğini kullanmaya başlama zamanı geldi.

Örneğin,

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

JSLint , Douglas Crockford tarafından yazılmış bir hata ayıklayıcıdır. Komut dosyanızı yapıştırmanız yeterlidir; kodunuzda fark edilir sorunları ve hataları hızlı bir şekilde tarar.

Diğer cevapları tamamlayan biraz daha temelli bir cevap vermek istiyorum. En popüler cevabı düzenlemeyi umuyordum, ancak başarısız oldum. Olabildiğince kapsamlı ve eksiksiz yapmaya çalıştım.

Daha fazla bilgi için MDN belgelerine bakabilirsiniz .

"use strict" ECMAScript 5'te sunulan bir direktif.

Direktifler ifadelere benzer, ancak farklıdır.

• use strictanahtar kelimeler içermez: Yönerge, özel bir dize değişmezinden (tek veya çift tırnak işareti) oluşan basit bir ifade ifadesidir. ECMAScript 5'i uygulamayan JavaScript motorları, yalnızca yan etkisi olmayan bir ifade ifadesi görür. ECMAScript standartlarının gelecekteki versiyonlarının usegerçek bir anahtar kelime olarak sunulması beklenmektedir ; bu şekilde alıntılar kullanılmayacaktır.
• use strictyalnızca bir komut dosyasının veya bir işlevin başında kullanılabilir, yani her diğer (gerçek) ifadeden önce gelmelidir. Bir işlev komut dosyasındaki ilk komut olması gerekmez: dize değişmezlerinden oluşan diğer deyim ifadeleriyle (ve JavaScript uygulamaları bunları uygulamaya özel yönergeler olarak ele alabilir) gelebilir. İlk gerçek ifadeyi (kodda veya işlevde) izleyen dize değişmezleri ifadeleri basit ifade ifadeleridir. Tercümanlar bunları direktif olarak yorumlamamalıdır ve hiçbir etkisi yoktur.

use strictYönergesi (bir komut dosyası veya bir fonksiyonu olarak) şu kodu sıkı kod olduğunu gösterir. Bir komut dosyasının en üst düzeyindeki kod (işlevde olmayan kod), komut dosyası bir use strictyönerge içerdiğinde katı kod olarak kabul edilir . Bir işlevin içeriği, bir işlev katı bir kodda tanımlandığında veya işlev bir use strictyönerge içerdiğinde katı kod olarak kabul edilir . Bir eval()yönteme iletilen kod, katı bir koddan eval()çağrıldığında veya use strictyönerge içerdiğinde katı kod olarak kabul edilir .

ECMAScript 5'in katı modu, dilin ilgili açıklarını ortadan kaldıran ve daha sıkı hata kontrolü ve daha yüksek güvenlik özellikleri sunan, JavaScript dilinin sınırlı bir alt kümesidir. Aşağıda, katı mod ile normal mod (ilk üçü özellikle önemlidir) arasındaki farklar listelenmektedir:

• with-Statement işlevini katı modda kullanamazsınız .
• Katı modda tüm değişkenlerin bildirilmesi gerekir: değişken, işlev, işlev parametresi, catch-clause parametresi veya globalin özelliği olarak bildirilmemiş bir tanımlayıcıya bir değer Objectatarsanız, bir ReferenceError. Normal modda tanımlayıcı dolaylı olarak genel bir değişken olarak (genelin bir özelliği olarak Object) bildirilir
• Katı modda, anahtar kelime işlev olarak çağrılan işlevlerde (yöntem olarak değil) thisdeğere sahiptir undefined. (Normal modda thisdaima küresel olanı gösterir Object). Bu fark, bir uygulamanın katı modu destekleyip desteklemediğini test etmek için kullanılabilir:

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

• Ayrıca bir işlevle call()veya applykatı modda çağrıldığında this, tam olarak call()veya apply()çağrının ilk argümanının değeri olur . (Normal modda nullve undefinedküresel değiştirilir Objectdeğil, nesneleri nesnelerin içine dökme olan ve değerler).

• Katı modda TypeError, salt okunur özelliklere atamaya çalıştığınızda veya genişletilemeyen bir nesne için yeni özellikler tanımlamaya çalıştığınızda bir a alırsınız . (Normal modda her ikisi de hata mesajı vermeden başarısız olur.)

• Katı modda, kodu eval()iletirken arayanın kapsamındaki değişkenleri veya işlevleri bildiremez veya tanımlayamazsınız (normal modda yapabileceğiniz gibi). Bunun yerine, için yeni bir kapsam oluşturulur eval()ve değişkenler ve işlevler bu kapsam dahilindedir. Bu kapsam, eval()yürütme tamamlandıktan sonra yok edilir .
• Katı modda, bir işlevin arguments-object, o işleve iletilen değerlerin statik bir kopyasını içerir. Normal modda arguments-object bir şekilde "büyülü" davranışa sahiptir: Dizinin elemanları ve adlandırılmış işlev parametreleri aynı değere başvurur.
• Katı modda SyntaxError, deleteoperatörün ardından nitelikli olmayan bir tanımlayıcı (değişken, işlev veya işlev parametresi) geldiğinde bir süre alırsınız . Normal modda deleteifade hiçbir şey yapmaz ve değerlendirilir false.
• Katı modda, TypeErroryapılandırılamayan bir özelliği silmeye çalıştığınızda bir alırsınız . (Normal modda deneme başarısız olur ve deleteifade olarak değerlendirilir false).
• Katı modda, bir nesne hazır bilgisi için aynı ada sahip birkaç özellik tanımlamaya çalıştığınızda sözdizimsel bir hata olarak kabul edilir. (Normal modda hata yoktur.)
• Katı modda, bir işlev bildiriminde aynı ada sahip birden çok parametre olduğunda sözdizimsel bir hata olarak kabul edilir. (Normal modda hata yoktur.)
• Katı modda sekizli değişmezlere izin verilmez (bunlar ile başlayan değişmez değerlerdir 0x. (Normal modda bazı uygulamalar sekizlik değişmezlere izin verir.)
• Katı modda tanımlayıcılar evalve argumentsanahtar kelimeler gibi davranılır. Değerlerini değiştiremezsiniz, onlara değer atayamazsınız ve değişkenler, işlevler, işlev parametreleri veya catch bloğunun tanımlayıcıları için ad olarak kullanamazsınız.
• Katı modda, çağrı yığınını inceleme olanakları üzerinde daha fazla kısıtlama vardır. arguments.callerve katı modda a işlevine arguments.calleeneden olur TypeError. Ayrıca, katı moddaki işlevlerin bazı arayan ve bağımsız değişken özellikleri, TypeErrorbunları okumaya çalıştığınızda a'ya neden olur.

Benim görüşüm:

Katı modun amaçlarından biri, sorunların daha hızlı hata ayıklamasına izin vermektir. Web sayfanızın sessiz ve tuhaf davranışlarına neden olabilecek bazı yanlış şeyler meydana geldiğinde istisnalar oluşturarak geliştiricilere yardımcı olur. Kullandığımız anda use strict, kod geliştiricinin önceden düzeltmesine yardımcı olan hataları atar.

Kullandıktan sonra öğrendiğim birkaç önemli şey use strict:

Global Değişken Beyanını Önler:

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

Şimdi, bu kod nameoftreeküresel kapsamda yaratılabilir window.nameoftree. use strictKodu uyguladığımızda hata fırlatıyor.

Yakalanmayan ReferenceError: nameoftree tanımlanmamış

Sample

İfadeyi ortadan withkaldırır:

withifadeler uglify-js gibi araçlar kullanılarak küçültülemez . Ayrıca kullanımdan kaldırıldı ve gelecekteki JavaScript sürümlerinden kaldırıldı.

Sample

Kopyaları Önler:

Yinelenen mülkümüz olduğunda, bir istisna atar

Yakalanmamış SyntaxError: Katı modda nesne değişmezinde yinelenen veri özelliğine izin verilmiyor

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

Daha az şey var ama bunun hakkında daha fazla bilgi edinmem gerekiyor.

Geçen yıl piyasaya sürülen bir tarayıcı kullanıyorsanız, büyük olasılıkla JavaScript Sıkı modunu destekler. Sadece ECMAScript 5 geçerli standart haline gelmeden önceki eski tarayıcılar bunu desteklemiyor.

Komutun etrafındaki alıntılar, kodun hala eski tarayıcılarda da çalışmasını sağlar (ancak katı modda bir sözdizimi hatası oluşturan şeyler genellikle komut dosyasının bu eski tarayıcılarda algılanması zor bir şekilde arızalanmasına neden olur).

Eklerken "use strict";, aşağıdaki durumlarda bir atacağım SyntaxError betiğin önce:

• Gelecekteki ECMAScript sürümleri önünün açılması için (öngörü içinde yeni saklıdır anahtar kelimelerden birini kullanarak, ECMAScript'i 6 ): implements, interface, let, package, private, protected, public, static, ve yield.

• Bloklarda bildirim fonksiyonu

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

• Sekizlik sözdizimi

  var n = 023;

• this global nesnenin üzerine gelin.

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

• Bir nesne değişmezindeki özellik adı için iki kez aynı adı bildirme

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

  Bu artık ECMAScript 6'da geçerli değil ( hata 1041128 ).

• Aynı ada sahip iki işlev bağımsız değişkenini bildirme

  f(a, b, b){}

• Tanımlanmamış bir değişkene değer ayarlama

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

• kullanma deleteDeğişken adındadelete myVariable;

• Kullanılması evalveya argumentsdeğişken veya fonksiyon argümanı adı olarak

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

Kaynaklar:

• Katı moda geçme MDN'yi üzerinde

• Sıkı mod MDN'yi üzerinde

• JavaScript'in Sıkı Modu ve Neden Colin J. Ihrig'in blogunda kullanmalısınız (arşivlenmiş sürüm)

Katı mod, normal JavaScript semantiğinde birkaç değişiklik yapar:

• bazı JavaScript sessiz hatalarını hata atmalarını değiştirerek ortadan kaldırır.

• JavaScript motorlarının optimizasyon yapmasını zorlaştıran hataları düzeltir.

• ECMAScript'in gelecekteki sürümlerinde tanımlanması muhtemel bazı sözdizimini yasaklar.

daha fazla bilgi için vistit Sıkı Mod- Javascript

"Sıkı Kullan"; programcının JavaScript'in gevşek veya kötü özelliklerini kullanmayacağı bir sigortadır. Bu bir rehberdir, tıpkı bir cetvelin düz çizgiler yapmanıza yardımcı olacağı gibi. "Sıkı Kullan", "Düz kodlama" yapmanıza yardımcı olacaktır.

Çizgilerini düz yapmak için cetvelleri kullanmamayı tercih edenler genellikle bu sayfalarda başkalarının kodlarında hata ayıklamalarını ister.

İnan bana. Ek yük, kötü tasarlanmış koda göre önemsizdir. Birkaç yıldır üst düzey bir JavaScript geliştiricisi olan Doug Crockford'un burada çok ilginç bir yazısı var . Şahsen, iyi uygulamamı unutmadığımdan emin olmak için her zaman sitesine geri dönmeyi seviyorum.

Modern JavaScript uygulaması her zaman "Sıkı Kullan" ı çağrıştırmalıdır; Pragma. ECMA Grubunun "Katı" modunu isteğe bağlı yapmasının tek nedeni, daha az deneyimli kodlayıcıların JavaScript'e erişmesine izin vermek ve daha sonra yeni ve daha güvenli kodlama uygulamalarına uyum sağlamak için zaman vermektir.

Dahil use strictBu noktadan itibaren tüm hassas JavaScript dosyaları başında daha iyi bir JavaScript programcı olmak ve global olma ve işler sessizce değiştirmek rastgele değişkenler önlemek için küçük bir yoldur.

W3schools'tan alıntı :

"Katı kullanın" Direktifi

"Kullanım katı" yönergesi JavaScript 1.8.5'te (ECMAScript sürüm 5) yenidir.

Bu bir ifade değil, JavaScript'in önceki sürümleri tarafından yok sayılan gerçek bir ifade.

"Katı kullanın" amacı kodun "katı modda" yürütülmesi gerektiğini belirtmektir.

Katı modda, örneğin, bildirilmemiş değişkenleri kullanamazsınız.

Neden Sıkı Mod?

Katı mod "güvenli" JavaScript yazmayı kolaylaştırır.

Katı mod önceden kabul edilen "kötü sözdizimi" ni gerçek hatalara dönüştürür.

Örnek olarak, normal JavaScript'te, bir değişken adının yanlış yazılması yeni bir global değişken oluşturur. Katı modda, bu bir hata atar ve yanlışlıkla küresel bir değişken oluşturmayı imkansız hale getirir.

Normal JavaScript'te, geliştirici yazılamayan özelliklere değer atayan herhangi bir hata geri bildirimi almaz.

Katı modda, yazılamaz bir özelliğe, salt alıcı özelliğine, varolmayan bir özelliğe, varolmayan bir değişkene veya varolmayan bir nesneye yapılan atamalar hata verir.

Daha fazla bilgi için lütfen http://www.w3schools.com/js/js_strict.asp adresine bakın.

"use strict"JavaScript kodunu katı modda çalıştırır , bu da temel olarak her şeyin kullanımdan önce tanımlanması gerektiği anlamına gelir. Sıkı mod kullanmanın ana nedeni, tanımlanmamış yöntemlerin yanlışlıkla küresel kullanımından kaçınmaktır.

Ayrıca katı modda, işler daha hızlı çalışır, bazı uyarılar veya sessiz uyarılar ölümcül hatalar atar, her zaman daha temiz bir kod yapmak için kullanmak daha iyidir.

"use strict"ECMA5'te kullanılması yaygın olarak gereklidir, ECMA6'da varsayılan olarak JavaScript'in bir parçasıdır , bu nedenle ES6 kullanıyorsanız eklenmesi gerekmez.

MDN'den şu ifadelere ve örneklere bakın:

"Kullanım katı" Yönergesi
"Kullanım katı" yönergesi JavaScript 1.8.5'te (ECMAScript sürüm 5) yenidir. Bu bir ifade değil, JavaScript'in önceki sürümleri tarafından yok sayılan gerçek bir ifade. "Katı kullanın" amacı kodun "katı modda" yürütülmesi gerektiğini belirtmektir. Katı modda, örneğin, bildirilmemiş değişkenleri kullanamazsınız.

"Kullanım katı" kullanma örnekleri:
İşlevler için katı mod: Aynı şekilde, bir işlev için katı modu çağırmak için, tam ifade "katı kullanın"; (veya 'katı kullanın';) diğer ifadelerden önce işlevin gövdesinde.

1) fonksiyonlarda katı mod

 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) tüm komut dosyası katı modu

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

3) Yazılabilir olmayan bir küresel atama

'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 hakkında daha fazla bilgi edinebilirsiniz .

ECMAScript komitesinde olan bazı insanlar tarafından iyi bir konuşma var: JavaScript'teki Değişiklikler, Bölüm 1: ECMAScript 5 " , "use strict"anahtarın artımlı kullanımının JavaScript uygulayıcılarının her bir web sitesini aniden kırmadan JavaScript'in birçok tehlikeli özelliğini temizlemesine nasıl izin verdiği hakkında dünyada.

Tabii ki bu yanlışlıkların çoğunun ne olduğu ve ne olduğu hakkında ECMAScript 5'in bunları nasıl düzelttiği de anlatılıyor.

Karşılaştırılacak küçük örnekler:

Sıkı olmayan mod:

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

Sıkı mod:

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

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

Sıkı olmayan mod:

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

Not use stricttanıtıldı ECMAscript 5 ve o zamandan beri tutuldu.

ES6 ve ES7'de katı modu tetikleme koşulları şunlardır :

• Genel kod, Sıkı Kullanım Direktifi içeren bir Direktif Prologuyla başlarsa katı mod kodudur (bkz. 14.1.1).
• Modül kodu her zaman katı mod kodudur.
• ClassDeclaration veya ClassExpression öğelerinin tüm bölümleri katı mod kodudur.
• Eval kodu, Use Strict Directive içeren bir Directive Prologue ile başlarsa veya eval'e yapılan çağrı, katı mod kodunda bulunan doğrudan bir eval (bkz. 12.3.4.1) ise katı mod kodudur.
• İlişkili FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition veya ArrowFunction , katı mod kodunda varsa veya işlevin [[ECMAScriptCode]] iç yuvasının değerini üreten kod bir Directive Prologue ile başlıyorsa, işlev kodu katı mod kodudur. Sıkı Kullan Direktifi içeren.
• Son işlev, işlendiğinde Sıkı Kullanım Yönergesi içeren bir Yönerge Prolog ile başlayan bir FunctionBody ise, yerleşik Function ve Generator yapıcılarına bağımsız değişkenler olarak sağlanan işlev kodu katı mod kodudur .

Geliştiricilerin kullanması gereken temel nedenler "use strict":

1. Küresel variables.Using ilanından yanlışlıkla engeller "use strict()"emin değişkenler ile deklare olduğunu yapacaktır varkullanılmadan önce. Örneğin:

   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. Not: "use strict"Yönerge yalnızca bir komut dosyasının veya işlevin başında tanınır.

3. Dize "arguments"değişken olarak kullanılamaz:

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

4. Anahtar kelimelerin değişken olarak kullanımını kısıtlar. Bunları kullanmaya çalışmak hatalar verecektir.

Kısacası kodunuzu daha az hataya eğilimli hale getirecek ve sırayla iyi kod yazmanızı sağlayacaktır.

Bununla ilgili daha fazla bilgi edinmek için buraya başvurabilirsiniz .

"katı kullanın"; ECMA'nın JavaScript'i biraz daha sağlam hale getirme çabasıdır. JS'ye en azından biraz "katı" olma girişiminde bulunur (diğer diller 90'lardan beri katı kurallar uygular). Aslında JavaScript geliştiricilerini bir tür kodlama en iyi uygulamalarını izlemeye "zorlar". Yine de JavaScript çok kırılgandır. Yazılan değişkenler, yazılan yöntemler vb. Gibi bir şey yoktur. JavaScript geliştiricilerine Java veya ActionScript3 gibi daha sağlam bir dil öğrenmelerini ve JavaScript kodunuzda aynı en iyi uygulamaları uygulamalarını şiddetle tavsiye ederim, daha iyi çalışacak ve daha kolay olacak ayıklama.

JavaScript “katı” modu ECMAScript 5'te tanıtıldı.

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

"use strict";JS dosyanızın en üstüne yazmak katı sözdizimi kontrolünü açar. Bizim için aşağıdaki görevleri yapar:

1. bildirilmemiş bir değişkene atamaya çalışırsanız bir hata gösterir

2. anahtar JS sistem kitaplıklarının üzerine yazmanızı engeller

3. güvensiz veya hataya açık bazı dil özelliklerini yasaklar

use strictbireysel fonksiyonların içinde de çalışır. Kodunuza dahil etmek her zaman daha iyi bir uygulamadır use strict.

Tarayıcı uyumluluğu sorunu: "Kullanım" yönergeleri geriye dönük olarak uyumludur. Onları desteklemeyen tarayıcılar, daha fazla referans verilmeyen bir dize hazır bilgisi görür. Böylece, üzerinden geçip devam edecekler.

use strictkodunuzu daha güvenli hale getirmenin bir yoludur, çünkü beklediğiniz gibi çalışmayabilecek tehlikeli özellikleri kullanamazsınız. Ve daha önce yazıldığı gibi, kodu daha katı hale getirir.

Sıkı Kullan, yaygın ve tekrarlanan hataları farklı şekilde işlenecek şekilde göstermek için kullanılır ve java komut dosyasının çalışma şeklini değiştirir, bu değişiklikler şunlardır:

• Kazara küreselleri önler

• Kopya yok

• İle ortadan kaldırır

• Bu zorlamayı ortadan kaldırır

• Daha güvenli eval ()

• Değişmez hatalar

ayrıntılar için bu makaleyi de okuyabilirsiniz

Normalde, JavaScript katı kurallara uymaz, bu nedenle hata olasılığı artar. Kullandıktan sonra "use strict"JavaScript kodu, sonlandırıcıların kullanımı, başlatma öncesi bildirim vb.Gibi diğer programlama dillerinde olduğu gibi katı kurallara uymalıdır.

Eğer "use strict"kullanılırsa, kod dolayısıyla hataları ve belirsizlikler şansını düşürür kurallar sıkı bir set takip ederek yazılmalıdır.

"katı kullanın"; JavaScript kodunun "katı modda" yürütülmesi gerektiğini tanımlar.

• ECMAScript sürüm 5'te "katı kullanım" direktifi yeniydi.
• Bu bir ifade değil, JavaScript'in önceki sürümleri tarafından yok sayılan gerçek bir ifade.
• "Katı kullanın" amacı kodun "katı modda" yürütülmesi gerektiğini belirtmektir.
• Katı modda, örneğin, bildirilmemiş değişkenleri kullanamazsınız.

Internet Explorer 9 ve sonraki sürümler dışında tüm modern tarayıcılar "katı kullanımı" destekler .

dezavantaj

Bir geliştirici katı modda olan bir kitaplık kullandıysa ancak geliştirici normal modda çalışmaya alışıksa, kitaplıkta beklendiği gibi çalışmayan bazı eylemler çağırabilir.

Daha da kötüsü, geliştirici normal modda olduğundan, ek hataların atılmasının avantajları yoktur, bu nedenle hata sessizce başarısız olabilir.

Ayrıca, yukarıda listelendiği gibi, katı mod belirli şeyleri yapmanızı engeller.

İnsanlar genellikle bu şeyleri ilk etapta kullanmamanız gerektiğini düşünür, ancak bazı geliştiriciler kısıtlamayı sevmez ve dilin tüm özelliklerini kullanmak ister.

• Temel örnek ve referans için:

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

Sıkı mod, bellek sızıntılarını önleyebilir.

Lütfen katı olmayan modda yazılmış aşağıdaki işlevi kontrol edin:

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

Bu işlevde, işlevin nameiçinde adlandırılan bir değişken kullanıyoruz . Dahili olarak, derleyici ilk önce söz konusu işlev kapsamında o adla bildirilen herhangi bir değişken olup olmadığını kontrol eder. Derleyici böyle bir değişken olmadığını anladığından, dış kapsamı kontrol edecektir. Bizim durumumuzda, küresel kapsamdır. Derleyici yine, küresel alanda o adla bildirilen bir değişkenin olmadığını, bu nedenle küresel alanda bizim için böyle bir değişken yarattığını anladı. Kavramsal olarak, bu değişken küresel kapsamda oluşturulacak ve tüm uygulamada mevcut olacaktır.

Başka bir senaryo, örneğin, değişkenin bir alt işlevde bildirilmesidir. Bu durumda, derleyici bu değişkenin dış kapsamdaki geçerliliğini, yani üst işlevi kontrol eder. Ancak o zaman küresel alanı kontrol edecek ve orada bizim için bir değişken yaratacaktır. Bu, ilave kontroller yapılması gerektiği anlamına gelir. Bu uygulamanın performansını etkileyecektir.

Şimdi aynı işlevi katı modda yazalım.

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

Aşağıdaki hatayı alırız.

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

Burada, derleyici referans hatasını atar. Katı modda, derleyici değişkeni bildirmeden kullanmamıza izin vermez. Böylece bellek sızıntıları önlenebilir. Ayrıca, daha optimize edilmiş kod yazabiliriz.