Wat is de strikte modus van JavaScript?

JavaScript is een vergevingsgezinde taal. Een deel van de syntaxis is optioneel en de taal herstelt fouten met meer gratie dan vele andere. Maar dit vasthouden heeft een nadeel: het kan gemakkelijker zijn om bugs te introduceren en inconsistente code is moeilijker te lezen.

Als je meer discipline wilt oefenen, is er gelukkig een eenvoudige manier om dat te doen: de strikte modus. De strikte modus is een manier om JavaScript te vragen om slagvaardiger te reageren wanneer het problemen in uw code tegenkomt.

Wat is een strikte modus?

Verschillende talen gebruiken het concept van een strikte modus: een modus die code strenger evalueert en uitvoert. U bent misschien bekend met het strikte HTML-doctype, dat bepaalde elementen en attributen afkeurt.

Perl, een andere geïnterpreteerde scripttaal, heeft al lang zijn eigen strikte modus. Deze modus verbiedt bepaalde soorten onveilige uitingen.

Hoe gebruik ik de strikte modus in JavaScript?

Plaats in een script een "use strict" -instructie bovenaan, vóór andere verklaringen:

// dit hele script zal in de strikte modus zijn
'gebruik strikt';

Houd er rekening mee dat u er een opmerking voor kunt plaatsen, maar geen uitspraken. U kunt de strikte modus inschakelen in een JavaScript-bestand of aan het begin van een scriptblok in een HTML-bestand. U kunt de strikte modus ook per functie inschakelen:

functie strikt() {
// Syntaxis voor strikte modus op functieniveau
'gebruik strikt';
return "Deze functie is strikt";
}

functie los() {
return "Deze functie is NIET strikt";
}

Nadat u de strikte modus heeft ingeschakeld, moet u uw code testen. Als u met internet werkt, opent u a JavaScript-console, zodat u eventuele nieuwe fouten kunt identificeren.

Wat doet de strikte modus van JavaScript?

Kortom, de strikte modus zal bepaalde soorten problematische code minder vergevingsgezind zijn. In plaats van problemen te negeren en door te gaan met de uitvoering, zullen bepaalde fouten het script stoppen. Dit is vaak veiliger dan doorgaan in ongewenste omstandigheden.

Voorkomt onbedoelde globals

Het beste voorbeeld waartegen de strikte modus beschermt, is het maken van onbedoelde globale variabelen. Bij normale uitvoering is deze code:

mijnVar = 17;

Het zal een eigenschap maken met de naam myVar op het globale object, ervan uitgaande dat u myVar nog niet eerder hebt gedeclareerd. In een webbrowser is het globale object meestal venster:

console.log (window.myVar);
>> 17

Als u echter een "use strict" -instructie opneemt, ziet u een fout in de console, zoiets als:

Uncaught ReferenceError: myVar is niet gedefinieerd

De reden dat dit zo handig is, is dat het een veelvoorkomend geval van typefout oppikt. Het is gemakkelijk om de naam van een variabele verkeerd te typen, en veel talen zouden ons op een dergelijke fout oppikken.

Maar JavaScript neemt standaard de reikwijdte van het globale object over en gaat verder alsof er niets aan de hand is. Sommige code kan opzettelijk afhankelijk zijn van dat gedrag, iets waar u zich bewust van moet zijn wanneer u besluit de strikte modus te gebruiken.

Zie ook: Hoe u uw code schoon kunt houden met objectinkapseling

Maakt mislukking expliciet

Bepaald gedrag in JavaScript mislukt, maar het doet dit geruisloos. U bent misschien niet op de hoogte van dergelijke fouten, tenzij u er specifiek op controleert. NaN is bijvoorbeeld een speciale eigenschap van het globale object dat een ongeldig getal vertegenwoordigt. Deze eigenschap is alleen-lezen, maar u kunt nog steeds proberen ernaar te schrijven:

NaN = 2;
>> 2

Maar ook al lijkt het alsof die opdracht geslaagd is, is dat niet het geval:

NaN
>> NaN

In de strikte modus krijgt u een daadwerkelijke foutmelding die u vertelt dat u niet kunt toewijzen aan NaN. Deze code gebruikt een functie waarmee u de strikte modus in de console kunt demonstreren:

javascript
function badNaN() { "gebruik strikt"; raam. NaN = 2; }
>> ongedefinieerd
slechtNan()
>> Uncaught TypeError: Kan niet toewijzen aan alleen-lezen eigenschap 'NaN' van object '#'
bij badNaN (:1:46)
bij :1:1

Dit is een klassiek voorbeeld dat aantoont dat, hoewel onwetendheid gelukzaligheid kan zijn, het soms beter is om te weten of er iets misgaat.

Waarschuwt voor dubbele parameters

Het laatste voorbeeld gaat over een weinig bekende functie van JavaScript. Het zal u misschien verbazen te horen dat parameternamen niet uniek hoeven te zijn:

functie dupeParam (a, a, c) { console.log (a); }
>> ongedefinieerd
dupeParam (2, 4, 8)
>> 4

Merk op dat JavaScript de laatste waarde toewijst aan een dubbele parameter. Dit gedrag is niet bijzonder nuttig. Het zou zelfs nuttiger zijn als JavaScript ons zou vertellen dat het een fout is, en dat is precies wat de strikte modus doet:

function dupeParam (a, a, c) { "gebruik strikt"; }
<< Uncaught SyntaxError: Dubbele parameternaam niet toegestaan ​​in deze context

Gebruik de strikte modus voor extra codevertrouwen

Goede praktijken en middelen om ze te handhaven gaan hand in hand. In sommige contexten, zoals een professionele programmeerrol, wil je zoveel mogelijk discipline uitoefenen. Zelfs als je gewoon aan een hobby-open-sourceproject werkt, kan de beheerder er de voorkeur aan geven om standaard de strikte modus te gebruiken.

Uiteindelijk is het aan jou, maar het is handig om te weten dat er een helpende hand beschikbaar is. Als programmeur moet u altijd op zoek zijn naar best practices en wat u kunt doen om deze af te dwingen.

10 basisprogrammeerprincipes die elke programmeur moet kennen

Uw code moet duidelijk en gemakkelijk te onderhouden zijn. Hier zijn verschillende andere programmeerprincipes om je te helpen je act op te ruimen.

Lees volgende

Over de auteur