JavaScript
Strikte modus

Syntaxis

• 'gebruik streng';
• "gebruik streng";
• `gebruik strikt`;

Opmerkingen

Voor hele scripts

De strikte modus kan op hele scripts worden toegepast door de instructie "use strict"; vóór andere verklaringen.

"use strict";
// strict mode now applies for the rest of the script

De strikte modus is alleen ingeschakeld in scripts waarin u "use strict" definieert. U kunt scripts combineren met en zonder strikte modus, omdat de strikte status niet wordt gedeeld tussen verschillende scripts.

Voor functies

De strikte modus kan ook worden toegepast op afzonderlijke functies door het "use strict"; verklaring aan het begin van de functieverklaring.

function strict() {
   "use strict";
   // strict mode now applies to the rest of this function
   var innerFunction = function () {
     // strict mode also applies here
   };
}

function notStrict() {
  // but not here
}

De strikte modus is ook van toepassing op alle interne scoped-functies.

Wijzigingen in globale eigenschappen

In een niet-strikte modus, wordt een variabele automatisch toegewezen in het globale bereik wanneer een variabele wordt toegewezen zonder te worden geïnitialiseerd met het var , const of het let sleutelwoord:

a = 12;
console.log(a); // 12

In de strikte modus geeft elke toegang tot een niet-aangegeven variabele een referentiefout:

"use strict";
a = 12; // ReferenceError: a is not defined
console.log(a);

Dit is handig omdat JavaScript een aantal mogelijke gebeurtenissen heeft die soms onverwacht zijn. In de niet-strikte modus leiden deze gebeurtenissen er vaak toe dat ontwikkelaars denken dat het bugs of onverwacht gedrag zijn, dus door de strikte modus in te schakelen, dwingen alle fouten die worden gegooid om precies te weten wat er wordt gedaan.

"use strict";
                       // Assuming a global variable mistypedVariable exists
mistypedVaraible = 17; // this line throws a ReferenceError due to the 
                       // misspelling of variable

Deze code in de strikte modus geeft een mogelijk scenario weer: het genereert een referentiefout die verwijst naar het regelnummer van de opdracht, waardoor de ontwikkelaar het mistype in de naam van de variabele onmiddellijk kan detecteren.

In de niet-strikte modus wordt, naast het feit dat er geen fout wordt gegenereerd en de toewijzing met succes wordt gemaakt, de mistypedVaraible automatisch in de globale scope als een globale variabele gedeclareerd. Dit houdt in dat de ontwikkelaar deze specifieke opdracht handmatig in de code moet opzoeken.

Bovendien kan de ontwikkelaar door het declareren van variabelen niet per ongeluk globale variabelen binnen functies declareren. In niet-strikte modus:

function foo() { 
   a = "bar"; // variable is automatically declared in the global scope
}
foo();
console.log(a); // >> bar

In de strikte modus is het noodzakelijk om de variabele expliciet te declareren:

function strict_scope() { 
   "use strict";
   var a = "bar"; // variable is local
}
strict_scope();
console.log(a); // >> "ReferenceError: a is not defined"

De variabele kan ook buiten en na een functie worden gedeclareerd, waardoor deze bijvoorbeeld in het globale bereik kan worden gebruikt:

function strict_scope() { 
   "use strict";
   a = "bar"; // variable is global
}
var a;
strict_scope();
console.log(a); // >> bar

Wijzigingen in eigenschappen

De strikte modus voorkomt ook dat u onherstelbare eigenschappen verwijdert.

"use strict";
delete Object.prototype; // throws a TypeError

De bovenstaande verklaring zou gewoon worden genegeerd als u de strikte modus niet gebruikt, maar nu weet u waarom deze niet wordt uitgevoerd zoals verwacht.

Het voorkomt ook dat u een niet-uitbreidbare eigenschap uitbreidt.

var myObject = {name: "My Name"}
Object.preventExtensions(myObject);

function setAge() {
    myObject.age = 25;   // No errors
}

function setAge() {
    "use strict";
    myObject.age = 25;  // TypeError: can't define property "age": Object is not extensible
}

Gedrag van de lijst met argumenten van een functie

arguments object gedraagt zich anders in de strikte en niet-strikte modus. In de niet-strikte modus weerspiegelt het argument de wijzigingen in de waarde van de aanwezige parameters, maar in de strikte modus worden wijzigingen in de waarde van de parameter niet weerspiegeld in het argument .

function add(a, b){
    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 5,10
}

add(1, 2);

Voor de bovenstaande code wordt het object arguments gewijzigd wanneer we de waarde van de parameters wijzigen. Voor de strikte modus wordt hetzelfde echter niet weerspiegeld.

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 1,2
}

Het is vermeldenswaard dat, als een van de parameters niet is undefined , en we proberen de waarde van de parameter in zowel de strikte modus als de niet-strikte modus te wijzigen, het arguments object ongewijzigd blijft.

Strikte modus

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // undefined,undefined 
                                             // 1,undefined
    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // undefined,undefined
                                             // 1, undefined
}
add();
// undefined,undefined 
// undefined,undefined

add(1)
// 1, undefined
// 1, undefined

Niet-strikte modus

function add(a,b) {

    console.log(arguments[0],arguments[1]);

    a = 5, b = 10;

    console.log(arguments[0],arguments[1]);
}
add();
// undefined,undefined 
// undefined,undefined

add(1);
// 1, undefined
// 5, undefined

Dubbele parameters

In de strikte modus kunt u geen dubbele namen van functieparameters gebruiken.

function foo(bar, bar) {}  // No error. bar is set to the final argument when called

"use strict";
function foo(bar, bar) {}; // SyntaxError: duplicate formal argument bar

Functiebereik in strikte modus

In de strikte modus zijn functies die in een lokaal blok zijn gedeclareerd buiten het blok ontoegankelijk.

"use strict";
{
  f(); // 'hi'
  function f() {console.log('hi');}
}
f(); // ReferenceError: f is not defined

Qua bereik hebben functieverklaringen in de strikte modus dezelfde binding als let of const .

Niet-eenvoudige parameterlijsten

function a(x = 5) {
  "use strict";
}

is ongeldige JavaScript en genereert een SyntaxError omdat u de instructie "use strict" niet kunt gebruiken in een functie met een niet-eenvoudige parameterlijst zoals hierboven - standaardtoewijzing x = 5

Niet-eenvoudige parameters omvatten -

• Standaard toewijzing

function a(x = 1) {
  "use strict";
}

• destructurering

function a({ x }) {
  "use strict";
}

• Rust params

function a(...args) {
  "use strict";
}