Vraag Wat doet "strict gebruiken" in JavaScript, en wat is de redenering erachter?


Onlangs heb ik een deel van mijn JavaScript-code via Crockford's gebruikt JSLint, en het gaf de volgende foutmelding:

Probleem bij regel 1-teken 1: ontbrekende instructie 'gebruik strikt'.

Na wat zoeken, realiseerde ik me dat sommige mensen eraan toevoegen "use strict"; in hun JavaScript-code. Nadat ik de instructie heb toegevoegd, is de fout niet meer weergegeven. Helaas heeft Google niet veel van de geschiedenis achter deze stringverklaring onthuld. Het moet zeker iets te maken hebben met hoe de JavaScript wordt geïnterpreteerd door de browser, maar ik heb geen idee wat het effect zou zijn.

Dus wat is "use strict"; alles over, wat houdt het in, en is het nog steeds relevant?

Reageer een van de huidige browsers op de "use strict"; string of is het voor toekomstig gebruik?


6702
2017-08-26 16:10


oorsprong


antwoorden:


Dit artikel over Javascript Strict-modus kan je interesseren: John Resig - ECMAScript 5 Strict-modus, JSON en meer

Om enkele interessante delen aan te halen:

Strict-modus is een nieuwe functie in ECMAScript 5 waarmee u een programma of een functie in een "strikte" werkomgeving kunt plaatsen. Deze strikte context voorkomt dat bepaalde acties worden ondernomen en werpt meer uitzonderingen op.

En:

Strikte modus helpt op een paar manieren:

  • Het betrapt een aantal veelvoorkomende codage-bloopers en werpt uitzonderingen op.
  • Het voorkomt fouten of gooit fouten wanneer relatief "onveilige" acties worden ondernomen (zoals het verkrijgen van toegang tot het globale object).
  • Het schakelt functies uit die verwarrend of slecht doordacht zijn.

Merk ook op dat je "strict mode" op het hele bestand kunt toepassen ... Of je kunt het alleen voor een specifieke functie gebruiken (nog steeds citerend uit het artikel van John Resig):

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

Wat handig kan zijn als je oude en nieuwe code moet mixen ;-)

Dus, ik denk dat het een beetje lijkt op het "use strict" je kunt gebruiken in Perl (Vandaar de naam?): het helpt u minder fouten te maken door meer dingen te detecteren die tot breuken kunnen leiden.

Momenteel is het dat ondersteund door alle belangrijke browsers  (balk IE 9 en lager).


4392
2017-08-26 16:15



Het is een nieuwe functie van ECMAScript 5. John Resig heeft het opgeschreven een mooie samenvatting ervan.

Het is gewoon een tekenreeks die u in uw JavaScript-bestanden plaatst (boven aan uw bestand of in een functie) die er zo uitziet:

"use strict";

Het nu in uw code plaatsen zou geen problemen met de huidige browsers moeten veroorzaken, want het is maar een string. Het kan in de toekomst problemen met uw code veroorzaken als uw code het pragma schendt. Bijvoorbeeld, als u op dit moment heeft foo = "bar" zonder te definiëren foo Ten eerste zal je code mislukken ... wat naar mijn mening een goede zaak is.


1101
2017-08-26 16:14



De verklaring "use strict"; instrueert de browser om de Strict-modus te gebruiken, wat een verminderde en veiligere functieset van JavaScript is.

Lijst met functies (niet-limitatief)

  1. Staat globale variabelen niet toe. (Vangsten ontbreken var declaraties en typfouten in variabele namen)

  2. Stille mislukte toewijzingen zullen fouten in de strikte modus werpen (toewijzen NaN = 5;)

  3. Pogingen om niet-verwijderbare eigenschappen te verwijderen zullen worden gegooid (delete Object.prototype)

  4. Vereist dat alle eigenschapsnamen in een letterlijk object uniek moeten zijn (var x = {x1: "1", x1: "2"})

  5. Functieparameternamen moeten uniek zijn (function sum (x, x) {...})

  6. Verbiedt octale syntaxis (var x = 023; sommige ontwikkelaars nemen verkeerd aan dat een voorgaande nul niets doet om het aantal te veranderen.)

  7. Verbiedt het with trefwoord

  8. eval in de strikte modus worden geen nieuwe variabelen geïntroduceerd

  9. Verbiedt het verwijderen van gewone namen (delete x;)

  10. Verbiedt binding of toewijzing van de namen eval en arguments in elke vorm

  11. Strikte modus heeft geen eigenschappen van de arguments object met de formele parameters. (dat wil zeggen in function sum (a,b) { return arguments[0] + b;} Dit werkt omdat arguments[0] is gebonden aan a enzovoort. )

  12. arguments.callee wordt niet ondersteund

[Ref: Strikte modus, Mozilla Developer Network]


518
2017-11-24 21:22



Als mensen zich zorgen maken over het gebruik use strict het is de moeite waard om dit artikel te lezen:

ECMAScript 5 'Strict-modus' ondersteuning in browsers. Wat betekent dit?
NovoGeek.com - Krishna's weblog

Er wordt gesproken over browserondersteuning, maar wat nog belangrijker is hoe je er veilig mee om kunt gaan:

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

368
2017-07-15 23:25



Een woord van waarschuwing, alles wat je hard-charging programmeurs: solliciteren "use strict" bestaande code kan gevaarlijk zijn! Dit ding is niet een of andere feel-good, vrolijke sticker die je op de code kunt klikken om het 'beter' te maken. Met de "use strict" pragma, de browser zal opeens uitzonderingen op willekeurige plaatsen VERWIJDEREN die hij nog nooit eerder gooide, alleen omdat je op dat moment iets doet dat standaard / los JavaScript toestaat, maar strikt JavaScript verafschuwt! U kunt strictheidsoverschrijdingen hebben die zich verbergen in zelden gebruikte gesprekken in uw code die alleen een uitzondering zullen veroorzaken wanneer ze uiteindelijk worden uitgevoerd - bijvoorbeeld in de productieomgeving die uw betalende klanten gebruiken!

Als je een duik wilt nemen, is het een goed idee om je aan te melden "use strict" naast uitgebreide unit tests en een strikt geconfigureerde JSHint build taak die je enig vertrouwen geeft dat er geen duistere hoek van je module is die vreselijk zal ontploffen alleen omdat je de Strict-modus hebt ingeschakeld. Of, hé, hier is nog een andere optie: gewoon niet toevoegen "use strict" naar een van je oude code, het is waarschijnlijk veiliger op die manier, eerlijk gezegd. ZEKER NIET toevoegen "use strict" voor modules die u niet bezit of onderhoudt, zoals modules van derden.

Ik denk dat hoewel het een dodelijk gekooid dier is, "use strict" kan goed zijn, maar je moet het goed doen. De beste tijd om streng te werk te gaan, is wanneer uw project een groen veld is en u helemaal opnieuw begint. configureren JSHint/JSLint met alle waarschuwingen en opties aangezwengeld zo strak als je team kan maag, krijg een goede build / test / assert-systeem du jour getuigd zoals Grunt+Karma+Chai, en dan pas beginnen met het markeren van al uw nieuwe modules als "use strict". Wees voorbereid om vele niggly fouten en waarschuwingen te verhelpen. Zorg ervoor dat iedereen de zwaartekracht begrijpt door de build in FAIL if in te stellen JSHint/JSLintveroorzaakt elke overtreding.

Mijn project was geen greenfield-project toen ik het opnam "use strict". Als gevolg hiervan zit mijn IDE vol met rode cijfers omdat ik die niet heb "use strict" op de helft van mijn modules, en JSHint klaagt daarover. Het is een herinnering voor mij over wat refactoring ik in de toekomst zou moeten doen. Mijn doel is om gratis een rode markering te krijgen vanwege al mijn missen "use strict" uitspraken, maar dat is nu jaren geleden.


182
2018-03-03 07:37



Gebruik makend van 'use strict'; maakt je code niet opeens beter.

De JavaScript-strikte modus is een functie in ECMAScript 5. U kunt de strikte modus inschakelen door dit aan de bovenzijde van uw script / functie te declareren.

'use strict';

Wanneer een JavaScript-engine dit ziet richtlijn, het zal de code gaan interpreteren in een speciale modus. In deze modus worden fouten gegenereerd wanneer bepaalde codeermethoden die mogelijk potentiële bugs zouden kunnen zijn worden gedetecteerd (wat de redenering achter de strikte modus is).

Beschouw dit voorbeeld:

var a = 365;
var b = 030;

In hun obsessie om de numerieke literals op een rij te zetten, heeft de ontwikkelaar per ongeluk een variabele geïnitialiseerd b met een octaal letterlijke. Niet-strikte modus zal dit interpreteren als een numerieke letterlijke waarde 24 (in basis 10). Een strikte modus zal echter een fout veroorzaken.

Zie voor een niet-uitputtende lijst met specialiteiten in de strikte modus dit antwoord.


Waar moet ik gebruiken 'use strict';?

  • In mijn nieuwe JavaScript-toepassing: Absoluut! De strikte modus kan als een klokkenluider worden gebruikt wanneer u iets stoms doet met uw code.

  • In mijn bestaand JavaScript code: Waarschijnlijk niet! Als uw bestaande JavaScript-code instructies bevat die verboden zijn in de strikte modus, breekt de toepassing gewoon. Als u een strikte modus wilt, moet u voorbereid zijn om uw bestaande code te debuggen en te corrigeren. Dit is waarom gebruik makend van 'use strict'; maakt je code niet opeens beter.


Hoe gebruik ik de strikte modus?

  1. Plaats een 'use strict'; verklaring bovenop je script:

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

    Merk op dat alles in het bestand myscript.js zal in strikte modus worden geïnterpreteerd.

  2. Of voeg een in 'use strict'; verklaring bovenop uw functie-instantie:

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

    Alles in de lexicale reikwijdte van functie doSomething zal in strikte modus worden geïnterpreteerd. Het woord lexicale reikwijdte is hier belangrijk. Zien dit antwoord voor een betere uitleg.


Welke dingen zijn verboden in strikte modus?

ik heb gevonden leuk artikel een beschrijving van verschillende dingen die verboden zijn in strikte modus (merk op dat dit geen exclusieve lijst is):

strekking

JavaScript is van oudsher verward over de manier waarop functies werken   zijn scoped. Soms lijken ze statisch te zijn afgebakend, maar sommige   functies zorgen ervoor dat ze zich gedragen alsof ze dynamisch zijn afgebakend. Dit is   verwarrend, waardoor programma's moeilijk te lezen en te begrijpen zijn.   Misverstand veroorzaakt fouten. Het is ook een probleem voor de prestaties.   Statische scoping zou een variabele binding mogelijk maken bij het compileren   tijd, maar de eis voor dynamisch bereik betekent dat de binding moet zijn   uitgesteld tot runtime, wat gepaard gaat met een aanzienlijke prestatie   boete.

Strict-modus vereist dat alle variabele binding statisch wordt gedaan.   Dat betekent dat de functies die eerder dynamische binding vereisten   moet worden geëlimineerd of gewijzigd. In het bijzonder is de met-instructie   geëlimineerd, en het vermogen van de eval-functie om te knoeien met de   omgeving van zijn beller is ernstig beperkt.

Een van de voordelen van strikte code is dat tools zoals YUI-compressor   kan het beter doen tijdens het verwerken ervan.

Impliciete globale variabelen

JavaScript heeft globale variabelen geïmpliceerd. Als   je geeft niet expliciet een variabele aan, een globale variabele is dat wel   impliciet voor u verklaard. Dit maakt programmeren eenvoudiger   beginners omdat ze een deel van hun elementaire huishouding kunnen verwaarlozen   klusjes. Maar het maakt het beheer van grotere programma's veel meer   moeilijk en het degradeert de betrouwbaarheid aanzienlijk. Dus strikt   modus, impliciete globale variabelen worden niet langer aangemaakt. Je zou moeten   expliciet alle variabelen declareren.

Wereldwijde lekkage

Er zijn een aantal situaties die kunnen leiden this   gebonden zijn aan het globale object. Bijvoorbeeld als u het vergeet   lever de new voorvoegsel bij het aanroepen van een constructorfunctie, de   constructeur this zal onverwachts gebonden zijn aan het globale object, dus   in plaats van een nieuw object te initialiseren, zal het in plaats daarvan stil zijn   knoeien met globale variabelen. In deze situaties zal de strikte modus   in plaats daarvan binden this naar undefined, wat de constructor zal doen   werp in plaats daarvan een uitzondering, waardoor de fout veel wordt gedetecteerd   eerder.

Noisy Failure

JavaScript heeft altijd alleen-lezen-eigenschappen gehad, maar jij   kon ze niet zelf maken tot de ES5's Object.createProperty   functie die mogelijkheid wordt blootgelegd. Als u probeert een waarde toe te wijzen   naar een alleen-lezen-eigenschap, zou het stil uitvallen. De opdracht zou   verander de waarde van de eigenschap niet, maar uw programma zou verdergaan zoals   hoewel het had. Dit is een integriteitsrisico dat programma's kan veroorzaken   in een inconsistente staat terechtkomen. In strikte modus probeert u een   alleen-lezen eigenschap zal een uitzondering opleveren.

Octaal

De octale (of basis 8) representatie van getallen was extreem   handig bij programmering op machineniveau op machines waarvan het woord   maten waren een veelvoud van 3. U had octaal nodig bij het werken met de CDC   6600 mainframe, dat een woordgrootte van 60 bits had. Als je kon lezen   octaal, je zou een woord kunnen zien als 20 cijfers. Twee cijfers vertegenwoordigd   de op-code, en één cijfer identificeerde een van de 8 registers. Tijdens de   trage overgang van machinecodes naar talen op hoog niveau, dat was het   gedacht nuttig te zijn om octale vormen in programmeertalen te verstrekken.

In C was een uiterst ongelukkige representatie van octalness   geselecteerd: Leading zero. Dus in C, 0100 betekent 64, niet 100, en 08 is een   fout, niet 8. Nog jammer genoeg is dit anachronisme geweest   gekopieerd naar bijna alle moderne talen, inclusief JavaScript, waar   het wordt alleen gebruikt om fouten te maken. Het heeft geen ander doel. Dus in   strikte modus, octale vormen zijn niet langer toegestaan.

Et cetera

De argumenten pseudo-array wordt een beetje meer   array-achtig in ES5. In strikte modus verliest het zijn callee en caller   eigenschappen. Dit maakt het mogelijk om je te passeren arguments te onbetrouwbaar   code zonder veel vertrouwelijke context op te geven. Ook de    arguments eigenschap van functies is geëlimineerd.

In strikte modus produceren dubbele sleutels in een letterlijke functie a   syntax error. Een functie kan niet twee parameters met dezelfde naam hebben.   Een functie kan geen variabele hebben met dezelfde naam als een van zijn   parameters. Een functie kan dat niet delete zijn eigen variabelen. Een poging om    delete een niet-configureerbare eigenschap werpt nu een uitzondering. Primitief   waarden worden niet impliciet ingepakt.


Gereserveerde woorden voor toekomstige JavaScript-versies

ECMAScript 5 voegt een lijst met gereserveerde woorden toe. Als je ze gebruikt als variabelen of argumenten, zal een strikte modus een fout veroorzaken. De gereserveerde woorden zijn:

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


Verder lezen


131
2018-01-29 11:35



Ik adviseer elke ontwikkelaar ten sterkste om nu de strikte modus te gaan gebruiken. Er zijn voldoende browsers die het ondersteunen, dat een strikte modus legitiem kan helpen ons te redden van fouten waarvan we niet eens wisten dat ze in jouw code zaten.

Blijkbaar zullen er in het beginstadium fouten zijn die we nog nooit zijn tegengekomen. Om het volledige voordeel te krijgen, moeten we goed testen nadat we naar de strikte modus zijn overgegaan om te zorgen dat we alles hebben gevangen. Absoluut niet alleen gooien use strict in onze code en neem aan dat er geen fouten zijn. Dus de churn is dat het tijd is om deze ongelooflijk nuttige taalfunctie te gaan gebruiken om betere code te schrijven.

Bijvoorbeeld,

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

JSLint is een debugger geschreven door Douglas Crockford. Plak gewoon je script in en het zal snel zoeken naar merkbare problemen en fouten in je code.


122
2017-07-05 19:38



Ik zou graag een iets meer gefundeerd antwoord willen bieden dat de andere antwoorden aanvult. Ik hoopte het meest populaire antwoord te kunnen bewerken, maar is mislukt. Ik heb geprobeerd het zo volledig en volledig mogelijk te maken.

U kunt verwijzen naar de MDN-documentatie voor meer informatie.

"use strict" een richtlijn geïntroduceerd in ECMAScript 5.

Richtlijnen zijn vergelijkbaar met verklaringen, maar toch verschillend.

  • use strict bevat geen sleutelwoorden: de richtlijn is een eenvoudige uitdrukkingsverklaring, die bestaat uit een speciale letterlijke tekenreeks (in enkele of dubbele aanhalingstekens). JavaScript-engines die ECMAScript 5 niet implementeren, zien alleen een uitdrukkingsverklaring zonder bijwerkingen. Er wordt verwacht dat toekomstige versies van ECMAScript-normen worden geïntroduceerd use als een echt sleutelwoord; de offertes zouden daardoor achterhaald zijn.
  • use strict kan alleen worden gebruikt aan het begin van een script of van een functie, d.w.z. het moet aan elke andere (echte) instructie voorafgaan. Het hoeft niet de eerste instructie te zijn in een script van functie: het kan worden voorafgegaan door andere uitdrukkingen van uitdrukkingen die bestaan ​​uit letterlijke tekenreeksen (en door JavaScript-implementaties kunnen ze als implementatiespecifieke richtlijnen worden behandeld). String literals-instructies, die een eerste echte instructie volgen (in een script of functie) zijn eenvoudige uitdrukkingsinstructies. Tolken mogen ze niet interpreteren als richtlijnen en hebben geen effect.

De use strictrichtlijn geeft aan dat de volgende code (in een script of een functie) een strikte code is. De code op het hoogste niveau van een script (code die niet in een functie voorkomt) wordt als een strikte code beschouwd als het script een bevat use strict richtlijn. De inhoud van een functie wordt als een strikte code beschouwd als de functie zelf is gedefinieerd in een strikte code of als de functie a bevat use strict richtlijn. Code die wordt doorgegeven aan een eval() methode wordt als een strikte code beschouwd wanneer eval() werd aangeroepen vanuit een strikte code of bevat de use strict richtlijn zelf.

De strikte modus van ECMAScript 5 is een beperkte subset van de JavaScript-taal, die relevante tekortkomingen van de taal elimineert en beschikt over strengere foutcontroles en een hogere beveiliging. Hieronder worden de verschillen weergegeven tussen de strikte modus en de normale modus (waarvan de eerste drie bijzonder belangrijk zijn):

  • U kunt de. Niet gebruiken with-statement in strikte modus.
  • In strikte modus moeten alle variabelen worden gedeclareerd: als u een waarde toewijst aan een identifier die niet als variabele is gedeclareerd, functie, functieparameter, catch-clause parameter of eigenschap van de globale Object, dan krijg je een ReferenceError. In de normale modus wordt de identifier impliciet gedeclareerd als een globale variabele (als een eigenschap van de globale Object)
  • In strikte modus het sleutelwoord this heeft de waarde undefined in functies die werden aangeroepen als functies (niet als methoden). (In de normale modus this wijst altijd naar het globale Object). Dit verschil kan worden gebruikt om te testen of een implementatie de strikte modus ondersteunt:
var hasStrictMode = (function() { "use strict"; return this===undefined }());
  • Ook wanneer een functie wordt aangeroepen call() of apply in strikte modus dan this is precies de waarde van het eerste argument van de call()of apply() aanroeping. (In de normale modus null en undefined worden vervangen door de globale Object en waarden, die geen objecten zijn, worden in objecten gegoten.)

  • In strikte modus krijg je een TypeError, wanneer u probeert om alleen-lezen eigenschappen toe te wijzen of om nieuwe eigenschappen te definiëren voor een niet-uitbreidbaar object. (In de normale modus mislukken beide eenvoudig zonder foutmelding.)

  • In strikte modus, bij het doorgeven van code aan eval(), u kunt geen variabelen of functies in het bereik van de beller declareren of definiëren (zoals u dat in de normale modus kunt doen). In plaats daarvan wordt een nieuwe scope gemaakt voor eval() en de variabelen en functies vallen binnen die scope. Die scope wordt vernietigd na eval() beëindigt de uitvoering.
  • In strikte modus bevat het argumenten-object van een functie een statische kopie van de waarden die aan die functie worden doorgegeven. In de normale modus heeft het argumenten-object een enigszins "magisch" gedrag: de elementen van de array en de genoemde functieparameters verwijzen beide naar dezelfde waarde.
  • In strikte modus krijg je een SyntaxError wanneer de delete operator wordt gevolgd door een niet-gekwalificeerde ID (een variabele, functie of functieparameter). In de normale modus de delete expressie zou niets doen en wordt geëvalueerd false.
  • In strikte modus krijg je een TypeError wanneer u een niet-configureerbare eigenschap probeert te verwijderen. (In de normale modus mislukt de poging eenvoudig en de deleteexpressie wordt geëvalueerd naar false).
  • In strikte modus wordt dit beschouwd als een syntactische fout wanneer u probeert verschillende eigenschappen met dezelfde naam voor een letterlijk object te definiëren. (In de normale modus is er geen fout.)
  • In strikte modus wordt dit beschouwd als een syntactische fout wanneer een functieverklaring meerdere parameters met dezelfde naam heeft. (In de normale modus is er geen fout.)
  • In strikte modus zijn octale literalen niet toegestaan ​​(dit zijn letterlijke woorden die beginnen met 0x. (In de normale modus staan ​​sommige implementaties octale literalen toe.)
  • In strikte modus de ID's eval en arguments worden behandeld als zoekwoorden. U kunt hun waarde niet wijzigen, kunt er geen waarde aan toewijzen en u kunt ze niet gebruiken als namen voor variabelen, functies, functieparameters of identificaties van een catch-blok.
  • In strikte modus zijn er meer beperkingen op de mogelijkheden om de oproepstack te onderzoeken. arguments.caller en arguments.callee oorzaak a TypeError in een functie in de strikte modus. Verder veroorzaken sommige beller- en argumenteigenschappen van functies in de strikte modus een TypeError wanneer je ze probeert te lezen.

81
2018-05-15 06:58



Mijn twee cent:

Een van de doelen van de strikte modus is om snellere foutopsporing van problemen mogelijk te maken. Het helpt de ontwikkelaars door een uitzondering te maken wanneer bepaalde verkeerde dingen optreden die stille en vreemde gedragingen van uw webpagina kunnen veroorzaken. Het moment dat we gebruiken use strict, de code zal fouten weggooien die de ontwikkelaar helpt om hem van tevoren te repareren.

Weinig belangrijke dingen die ik heb geleerd na gebruik use strict :

Voorkomt wereldwijde variabele verklaring:

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

Nu maakt deze code aan nameoftree in wereldwijde reikwijdte die toegankelijk is via window.nameoftree. Wanneer we implementeren use strict de code zou fouten veroorzaken.

Uncaught ReferenceError: nameoftree is niet gedefinieerd

Monster

elimineert with uitspraak :

with statements kunnen niet worden verkleind met behulp van tools zoals verlelijken-js. Ze zijn ook verouderd en verwijderd uit toekomstige JavaScript-versies.

Monster

Voorkomt duplicaten:

Wanneer we dubbele eigenschappen hebben, wordt er een uitzondering gegenereerd

Uncaught SyntaxError: dubbele eigenschap data in letterlijk object niet   toegestaan ​​in strikte modus

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

Er zijn er weinig meer, maar ik moet daar meer kennis over verzamelen.


73
2018-03-10 03:31



Als je een browser gebruikt die in het afgelopen jaar is uitgebracht, ondersteunt dit waarschijnlijk de JavaScript Strict-modus. Alleen oudere browsers voordat ECMAScript 5 de huidige standaard werd, ondersteunen dit niet.

De aanhalingstekens rond de opdracht zorgen ervoor dat de code ook nog in oudere browsers werkt (hoewel de dingen die een syntaxisfout genereren in de strikte modus er meestal toe zullen leiden dat het script op sommige moeilijk te detecteren manieren defect raakt in die oudere browsers).


54
2018-03-27 12:18