Ano ang ginagawa ng "paggamit ng mahigpit" sa JavaScript, at ano ang mga dahilan para dito?

Inilunsad ko kamakailan ang aking JavaScript code sa pamamagitan ng Crockford JSLint , at nagbigay ito ng sumusunod na error:

Problema sa linya 1 karakter 1: Nawawa>

Habang gumagawa ng i>"use strict"; sa iyong javascript code. Sa sandaling idinagdag ko ang expression, ang error ay tumigil na lumitaw. Sa kasamaang palad, hindi ibinunyag ng Google ang karamihan sa kasaysayan ng linya ng operator na ito. Siyempre, ito ay dapat na may kaugnayan sa paraan ng interpretasyon ng JavaScript sa pamamagitan ng browser, ngunit hindi ko alam kung ano ang epekto.

Kaya, ano ang "use strict"; ay ang lahat ng bagay tungkol sa kung ano ang nagpapahiwatig na ito, at ito ay may kaugnayan pa rin?

Ang anumang kasalukuyang browser ay tumugon sa "use strict"; string o ito para sa hinaharap na paggamit?

6989
26 авг. itinakda ni Mark Rogers 26 aug. 2009-08-26 19:10 '09 sa 19:10 2009-08-26 19:10
@ 30 sagot

Ang artikulong ito sa Javascript Strict Mode ay maaaring maging interesado sa iyo: John Resig - ECMAScript 5 Mahigpit na Mode, JSON, at higit pa

Upang sipiin ang i>

Ang mahigpit na mode ay isang bagong tampok sa ECMAScript 5 na nagbibigay-daan sa iyo upang maglagay ng isang programa o pag-andar sa isang "mahigpit" na konteksto sa pagtatrabaho. Ang mahigpit na konteksto na ito ay pumipigil sa i>

Gayundin:

Ang mahigpit na mode ay tumutulong sa maraming paraan:

  • Siya ay nakakakuha ng i>
  • Pinipigilan o nililikha ang mga error kapag ang mga aksyon na "hindi ligtas" ay kinukuha (halimbawa, ang pagkakaroon ng access sa isang pandaigdigang bagay).
  • Hindi pinapagana ang mga tampok na nakakalito o hindi naisip.

Tandaan din na maaari mong ilapat ang "mahigpit na mode" sa buong file ... O maaari mo itong gamitin para lamang sa isang partikular na function (pa rin na sumipi sa artikulo ni John Resig):

 // Non-strict code... (function(){ "use strict"; // Define your library strictly... })(); // Non-strict code... 

Ano ang maaaring maging kapaki-pakinabang kung kai>

Kaya ipagpalagay ko na ito ay medyo tulad ng "use strict" maaari mong gamitin sa Perl (kaya ang pangalan?): Ito ay tumutulong sa iyo na gumawa ng mas kaunting mga pagkakamali sa pamamagitan ng paghahanap ng higit pang mga bagay na maaaring humantong sa breakdowns.

Sa kasalukuyan, sinusuportahan ito ng lahat ng mga pangunahing browser (IE 9 panel at sa ibaba).

4587
26 авг. ang sagot ay ibinigay ng Pascal MARTIN 26 aug. 2009-08-26 19:15 '09 sa 19:15 2009-08-26 19:15

Ito ay isang bagong tampok ng ECMAScript 5. Si John Resig ay sumulat ng magandang buod .

Ito ay isang linya lamang na inilagay mo sa iyong mga file na JavaScript (alinman sa itaas ng iyong file, o sa loob ng isang function), na ganito ang hitsura nito:

border=0
 "use strict"; 

Ang pagpapagana ng code na ito ay hindi na dapat maging sanhi ng mga problema sa kasalukuyang mga browser, dahil ito ay isang string lamang. Ito ay maaaring maging sanhi ng mga problema sa iyong code sa hinaharap kung ang iyong code break isang pragma. Halimbawa, kung kasalukuyan kang may foo = "bar" wa>foo , ang iyong code ay mag-crash ... kung saan, sa palagay ko, ay mabuti.

1152
26 авг. ang sagot ay ibinigay seth 26 aug. 2009-08-26 19:14 '09 at 7:14 PM 2009-08-26 19:14

Ang pahayag na "use strict"; Tinuturuan ng browser na gumamit ng Mahigpit na mode, na isang pinababang at mas ligtas na hanay ng mga pag-andar ng JavaScript.

Listahan ng mga function (hindi kumpleto)

  1. Hindi pinapayagan ang mga pandaigdigang variable. (Tinatanggal ang mga nawawa>var at mga typo sa mga variable na pangalan)

  2. Ang mga tahimik na nabigong mga gawain ay magiging sanhi ng isang error sa mahigpit na mode (pagtatalaga NaN = 5; )

  3. Ang mga pagtatangka upang alisin ang mga katangian ng may kasalanan ay magsasanhi ( delete Object.prototype )

  4. Kinakai>var x = {x1: "1", x1: "2"} )

  5. Ang mga pangalan ng parameter ng function ay dapat na natatangi ( function sum (x, x) {...} )

  6. Forbids - octal syntax ( var x = 023; i>

  7. Pagbabawal with keyword

  8. eval sa mahigpit na mode ay hindi nagpapakilala ng mga bagong variable

  9. Huwag paganahin ang simpleng pagtanggal ng pangalan ( delete x; )

  10. Hindi pagpapagana ng umiiral o pagbibigay ng pangalan ng eval at mga arguments sa anumang anyo

  11. Ang mahigpit na mode ay hindi sumusuporta sa mga katangian ng arguments may mga pormal na parameter. (hal. sa function sum (a,b) { return arguments[0] + b;} Gumagana ito dahil ang mga arguments[0] ay nauugnay sa a , atbp.)

  12. Hindi sinusuportahan ang arguments.callee

[Link: Strict Mode , Mozilla Developer Network]

567
25 нояб. ang sagot ay ibinigay ng gprasant Nobyembre 25. 2014-11-25 00:22 '14 sa 0:22 2014-11-25 00:22

Kung ang mga tao ay nag-aalala tungkol sa use strict posible na tingnan ang artikulong ito:

Ang suporta ng Strict Mode ECMAScript 5 sa mga browser. Ano ang ibig sabihin nito?
NovoGeek.com - Blog ni Krishna

Ito ay nagsasalita tungkol sa suporta sa browser, ngunit mas mahalaga, kung paano panghawakan ito:

 function isStrictMode(){ return !this; }  function isStrictMode(){ "use strict"; return !this; }  
385
16 июля '12 в 2:25 2012-07-16 02:25 Sagot ay ibinigay ni Jamie Hutber Hulyo 16, '12 sa 2:25 ng umaga 2012-07-16 02:25

Ang isang salita ng pag-iingat, anumang bagay na iyong programa na may matigas na singilin: ang paglalapat ng "use strict" sa umiiral na code ay maaaring mapanganib! Ang bagay na ito ay hindi isang uri ng magandang, maligaya na sticker na maaari mong pat sa code upang gawin itong "mas mahusay." Sa "use strict" tama ang "use strict" pragmas, ang browser ay big>

Kung pupunta ka sa isang mapagpasyang hakbang, inirerekumenda namin ang paggamit ng "use strict" kasama ang mga komprehensibong yunit ng pagsubok at ang mahigpit na isinaayos na JShint na bumuo ng gawain, na magbibigay sa iyo ng tiwala na wa>"use strict" sa alinman sa iyong mga hindi napapanahong mga code, marahil ito ay mas ligtas, tapat. Tiyak Hindi idagdag ang "use strict" para sa anumang mga module na hindi mo pagmamay-ari o suporta, tulad ng mga third-party na module.

Sa tingin ko na kahit na ito ay isang nakamamatay na tiyan sa isang hawla, "use strict" ay maaaring maging mabuti, ngunit kai>JSHint/JSLint sa lahat ng mga babala at mga pagpipilian na nakatiklop nang JSHint/JSLint hangga't ang iyong koponan ay maaring magising, makakuha ng isang mahusay na build / test / apruba system na maaaring i-configure tulad ng Grunt+Karma+Chai , at tanging ITO ay markahan ang lahat ng iyong bagong modules bi>"use strict" . Maging handa upang pagalingin ang maraming mga pagkakamali at mga babala. Tiyaking naiintindihan ng lahat ang gravity sa pamamagitan ng pagtatakda ng pagpupulong upang JSHint/JSLint kung ang JSHint/JSLint nagdudulot ng anumang mga iregularidad.

Ang aking proyekto ay hindi isang bagong proyekto kapag pinagtibay ko ang "use strict" . Bi>"use strict" sa kalahati ng aking mga module, at ang JSHint ay nagrereklamo tungkol dito. Ito ay isang paalala sa akin kung anong refactoring ang dapat kong gawin sa hinaharap. Ang aking layunin ay maging isang red mark para sa libre dahil sa lahat ng aking nawawa>"use strict" pahayag, ngunit ito ay para sa maraming taon.

193
03 марта '14 в 10:37 2014-03-03 10:37 Ang sagot ay ibinigay ng DWoldrich noong Marso 03 '14 sa 10:37 2014-03-03 10:37

Gamitin ang 'use strict'; ay hindi ginagawang mas mahusay ang iyong code.

Ang mode na Strict JavaScript ay isang function sa ECMAScript 5 . Maaari mong paganahin ang mahigpit na mode sa pamamagitan ng pagdeklara nito sa tuktok ng iyong script / function.

 'use strict'; 

Kapag nakikita ng engine ng JavaScript ang direktiba na ito, magsisimula itong bigyang-kahulugan ang code sa isang espesyal na mode. Sa mode na ito, ang mga error ay magaganap kapag natukoy ang i>

Isaa>

 var a = 365; var b = 030; 

Sa kanyang kinahuhumalingan upang bumuo ng mga numerical literals, ang developer ay inadvertently na-initialize ang variable b ikawalo literal. Ang isang di-mahigpit na mode ay magpapakahulugan na ito bi>24 (sa base 10). Gayunpaman, ang mahigpit na mode ay magdudulot ng error.

Para sa isang hindi kumpletong listahan ng mga specialties sa mahigpit na mode, tingnan ang sagot na ito .


Saan ko dapat gamitin ang 'use strict'; ?

  • Sa aking bagong javascript app: Ganap na! Ang mahigpit na mode ay maaaring gamitin bi>

  • Sa aking umiiral na javascript code: Marahil hindi! Kung ang iyong umiiral na code ng JavaScript ay naglalaman ng mga tagubilin na ipinagbabawal sa mahigpit na mode, ang application ay simpleng masira. Kung kai>'use strict'; ay hindi ginagawang mas mahusay ang iyong code.


Paano gamitin ang mahigpit na mode?

  1. Ipasok ang 'use strict'; sa itaas ng iyong script:

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

    Pakitandaan na ang lahat ng nasa myscript.js ay ipapaliwanag sa mahigpit na mode.

  2. O i-paste ang 'use strict'; Ang pahayag sa itaas ng mga function ng iyong katawan:

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

    Lahat ng bagay sa leksikal na saklaw ng doSomething function ay mabibigyang-kahulugan sa mahigpit na mode. Ang leksiko na lugar ng salita ay mahalaga dito. Tingnan ang sagot na ito para sa isang mas mahusay na paliwanag.


Ano ang mga bagay na mahigpit na ipinagbabawal?

Nakakita ako ng magandang artikulo na naglalarawan ng maraming bagay na mahigpit na ipinagbabawal (tandaan na hindi ito isang eksklusibong listahan):

Dami

Kasaysayan, ang JavaScript ay nalito tungkol sa kung paano ang mga function ay sakop. Minsan tila sila ay nakuha sa istatistika, ngunit ang i>

Ang mahigpit na mode ay nangangai>

Isa sa mga pakinabang ng mahigpit na code ay ang mga kasangkapan tulad ng YUI Compressor ay maaaring gumawa ng mas mahusay na trabaho sa pagproseso nito.

Naipapatupad na mga variable ng globo

Ang JavaScript ay nagpapahiwatig ng mga variable ng globo. Kung hindi ka malinaw na nagpapahayag ng isang variable, isang pandaigdigang variable ay ipinahayag para sa iyo. Pinadadali nito ang programming para sa mga newbies, dahil maaari ni>

Global leaks

Mayroong i>this na maiugnay sa isang pandaigdigang bagay. Halimbawa, kung nakalimutan mong magbigay ng new prefix kapag tumawag ka ng isang function na tagapagbuo, ang tagapagbuo na ito ay nauugnay nang hindi inaasahan sa isang pandaigdigang bagay, kaya sa halip na magsimula ng isang bagong bagay, sa halip, ito ay tahimik na magkakasama sa mga pandaigdigang variable. Sa mga sitwasyong ito, ang halip na mahigpit na mode ay nagbubuklod na this undefined , na nagiging sanhi ng tagapagbuo upang itapon ang isang pagbubukod sa halip, na nagpapahintulot nito upang makita ang error na mas maaga.

Maingay na pagkakamali

Ang JavaScript ay laging may mga read-only na katangian, ngunit hindi mo maaaring likhain ang mga ito hanggang sa ang function na Object.createProperty ay bukas sa Object.createProperty para sa function na Object.createProperty . Kung sinubukan mong magtalaga ng isang halaga sa isang read-only na ari-arian, ito ay mabibigo. Ang pagtatalaga ay hindi magbabago sa halaga ng ari-arian, ngunit ang iyong programa ay kumilos na parang ito. Ito ay isang panganib ng integridad, na maaaring humantong sa paglipat ng mga programa sa isang hindi pantay na estado. Sa mahigpit na mode, ang pagtatangkang baguhin ang read-only na ari-arian ay magdudulot ng eksepsiyon.

octal

Ang 8-bit na representasyon ng mga numero ay lubhang kapaki-pakinabang kapag gumaganap machine programming sa machine na ang laki ng salita ay isang maramihang ng 3. Kapag nagtatrabaho sa CDC 6600 kompyuter ng karaniwang sukat, pagkakaroon ng isang salita laki ng 60 bits, kai>

Sa C, ang napakasamang ideya ng pagkaantala ay pinili: ang nangungunang zero. Kaya sa C 0100 nangangahulugan 0100 64, hindi 100, at 08 ay isang error, hindi 8. Kahit na higit pa, sa kasamaang palad, ang anachronism na ito ay kinopya sa halos lahat ng mga modernong wika, kabi>

Et cetera

Ang mga pseudo array na argumento ay nagiging kaunti pa katulad ng arrays sa ES5. Sa mahigpit na mode, nawawala ang mga katangian ng callee at caller . Pinapayagan ka nitong ipasa ang iyong mga arguments mapagkakatiwalaang code, nang hindi nag-iiwan ng maraming kumpidensyal na konteksto. Bi>arguments aari ng mga function ay hindi kasama.

Sa mahigpit na mode, ang mga duplicate na key sa isang function na literal ay nagbibigay ng error sa syntax. Ang hindi maaaring gumana ay may dalawang mga parameter na may parehong pangalan. Ang hindi maaaring function ay may isang variable na may parehong pangalan bi>delete function ay may sariling mga variable. Ang pagtatangkang delete non-configure na ari-arian ngayon ay nagtatapon ng eksepsiyon. Ang mga primitive na halaga ay hindi talaga nakabalot.


Nakareserbang mga salita para sa mga bersyon sa hinaharap ng javascript

Nagdagdag ang ECMAScript 5 ng isang listahan ng mga reserved word. Kung gagamitin mo ang mga ito bi>

implements , interface , let , package , private , protected , public , static , at yield


Karagdagang pagbabasa

144
29 янв. sagot na ibinigay ng sampathsris Jan 29 2016-01-29 14:35 '16 sa 14:35 2016-01-29 14:35

Mahigpit kong inirerekumenda na ang lahat ng mga developer ay nagsisimula gamit ang mahigpit na mode. May sapat na mga browser na sumusuporta dito na ang mahigpit na mode ay legal na makakatulong sa pag-save sa amin mula sa mga pagkakamali na hindi namin nalalaman ay nasa iyong code.

Tila, sa unang yugto magkakaroon ng mga pagkakamali na hindi pa natin nakatagpo. Upang makuha ang buong benepisyo, kai>use strict sa aming code at naniniwala na wa>

Halimbawa

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

JSLint ay isang debugger na isinulat ni Douglas Crockford. I-paste >

128
05 июля '13 в 22:38 2013-07-05 22:38 ang sagot ay ibinigay sa Pank noong Hulyo 05 '13 sa 10:38 2013-07-05 22:38

Gusto kong mag-alok ng isang bahagyang higit pang substantiated na sagot na kumpleto sa iba pang mga sagot. Ako ay umaasa na i-edit ang pinaka-popular na sagot, ngunit hindi ko magagawa. Sinubukan kong gawin itong kumpleto at kumpleto hangga't maaari.

Para sa karagdagang impormasyon, maaari kang sumangguni sa dokumentasyon ng MDN .

"use strict" direktiba ay ipinasok sa ECMAScript 5.

Ang mga direktiba ay tulad ng mga pahayag, ngunit naiiba.

  • use strict ay hindi naglalaman ng mga keyword: ang isang direktiba ay isang simpleng pahayag ng expression na binubuo ng isang espesyal na literal na string (sa solong o double quotes). Ang mga engine ng JavaScript na hindi nagpapatupad ng ECMAScript 5 ay nakikita lamang ang expression na wa>use bi>
  • use strict maaari lamang gamitin sa simula ng isang script o function, i.e. dapat na mauna ang anumang iba pang (tunay na) pahayag. Hindi ito dapat ang unang pagtuturo sa isang function na script: maaari itong mauna sa iba pang mga ekspresyon ng operator na binubuo ng mga literal na string (at ang mga pagpapatupad ng JavaScript ay maaaring matingnan bi>

use strict direktiba ay nagpapahiwatig na ang sumusunod na code (sa isang script o function) ay isang mahigpit na code. Ang code sa pinakamataas na antas ng script (code na wala sa function) ay itinuturing na isang mahigpit na code kapag ang script ay naglalaman ng use strict direktiba. Ang nilalaman ng isang function ay itinuturing na mahigpit na code kapag ang function mismo ay tinukoy sa mahigpit na code o kapag ang function ay naglalaman ng use strict direktiba. Ang code na ipinasa sa eval() paraan ay itinuturing na isang mahigpit na code kapag ang eval() ay tinatawag mula sa isang string code o naglalaman ng use strict direktiba.

Ang mahigpit na mode ng ECMAScript 5 ay isang limitadong subset ng wika ng JavaScript, na nag-aalis ng nararapat na mga bahid ng wika at nagbibigay ng mas mahigpit na pagsusuri ng error at mas mataas na seguridad. Ang mga sumusunod ay ang mga pagkakaiba sa pagitan ng mahigpit na mode at normal na mode (kung saan ang unang tatlong ay partikular na mahalaga):

  • Hindi mo magagamit ito with -statement sa mahigpit na mode.
  • Sa mahigpit na mode, dapat na ideklara ang lahat ng mga variable: kung magtalaga ka ng isang halaga sa isang identifier na hindi ipinahayag bi>Object , makakakuha ka ng ReferenceError . Sa normal na mode, ang isang identifier ay ipinahayag nang kataon bi>Object )
  • Sa mahigpit na mode, ang this ay may halaga na hindi undefined function na tinawag bi>this всегда указывает на глобальный Object ). Это различие можно использовать для проверки, поддерживает ли реализация строгий режим:
 var hasStrictMode = (function() { "use strict"; return this===undefined }()); 
  • Также, когда функция вызывается с call() или apply в строгом режиме, this точно значение первого аргумента call() или apply() . (В нормальном режиме null и undefined заменяются глобальным Object а значения, которые не являются объектами, преобразуются в объекты.)

  • В строгом режиме вы получите TypeError , когда вы пытаетесь назначить свойства readonly или определить новые свойства для не растяжимого объекта. (В обычном режиме оба просто обходятся без сообщения об ошибке.)

  • В строгом режиме при передаче кода в eval() вы не можете объявлять или определять переменные или функции в области вызывающего (как это можно сделать в обычном режиме). Вместо этого для eval() создается новая область, и переменные и функции находятся в пределах этой области. Эта область уничтожается после того, как eval() завершает выполнение.
  • В строгом режиме аргумент-объект функции содержит статическую копию значений, которые передаются этой функции. В нормальном режиме аргумент-объект имеет несколько "магическое" поведение: элементы массива и именованные функциональные параметры ссылаются на одно и то же значение.
  • В строгом режиме вы получите SyntaxError когда за оператором delete следует неквалифицированный идентификатор (переменная, функция или параметр функции). В нормальном режиме выражение delete ничего не сделает и будет оценено как false .
  • В строгом режиме вы получите TypeError при попытке удалить неконфигурируемое свойство. (В обычном режиме попытка просто терпит неудачу, а выражение delete - false ).
  • В строгом режиме это считается синтаксической ошибкой при попытке определить несколько свойств с тем же именем для литерала объекта. (В нормальном режиме ошибки нет.)
  • В строгом режиме это считается синтаксической ошибкой, когда объявление функции имеет несколько параметров с тем же именем. (В нормальном режиме ошибки нет.)
  • В строгом режиме не допускаются восьмеричные литералы (это литералы, начинающиеся с 0x . (В нормальном режиме некоторые реализации позволяют делать восьмеричные литералы).
  • В строгом режиме идентификаторы eval и arguments обрабатываются как ключевые слова. Вы не можете изменить их значение, не можете присвоить им значение, и вы не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch.
  • В строгом режиме больше ограничений на возможности проверки стека вызовов. arguments.caller и arguments.callee вызывают TypeError в функции в строгом режиме. Кроме того, некоторые свойства caller- и аргументы функций в строгом режиме вызывают TypeError при попытке их прочитать.
88
ответ дан Ely 15 мая '15 в 9:58 2015-05-15 09:58