JavaScript
Strikter Modus

Syntax

• 'streng verwenden';
• "streng verwenden";
• "use strict";

Bemerkungen

Für ganze Skripte

Der strikte Modus kann auf ganze Skripts angewendet werden, indem die Anweisung "use strict"; vor allen anderen Aussagen.

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

Der strikte Modus ist nur in Skripts aktiviert, in denen Sie "use strict" . Sie können Skripts mit und ohne strikten Modus kombinieren, da der strikte Status nicht von verschiedenen Skripts gemeinsam genutzt wird.

Für Funktionen

Der strikte Modus kann auch auf einzelne Funktionen angewendet werden, indem das "use strict"; vorangestellt wird "use strict"; Anweisung am Anfang der Funktionsdeklaration.

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
}

Der strikte Modus gilt auch für alle Funktionen des inneren Bereichs.

Änderungen an globalen Eigenschaften

Wenn eine Variable ohne strengen Modus zugewiesen wird, ohne mit dem Schlüsselwort var , const oder let initialisiert zu werden, wird sie automatisch im globalen Bereich deklariert:

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

Im strikten Modus wird jedoch bei jedem Zugriff auf eine nicht deklarierte Variable ein Referenzfehler ausgegeben:

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

Dies ist hilfreich, da in JavaScript eine Reihe möglicher Ereignisse vorhanden sind, die manchmal unerwartet sind. Im Nicht-strikten Modus führen diese Ereignisse häufig dazu, dass Entwickler glauben, dass es sich um Fehler oder unerwartetes Verhalten handelt. Wenn also der strikte Modus aktiviert wird, erzwingt jeder Fehler, der ausgelöst wird, genau, was getan wird.

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

Dieser Code im strikten Modus zeigt ein mögliches Szenario an: Er gibt einen Referenzfehler aus, der auf die Zeilennummer der Zuweisung verweist, sodass der Entwickler den Fehlertyp im Namen der Variablen sofort erkennen kann.

Im Non-Strict-Modus wird neben der Tatsache, dass kein Fehler ausgelöst wird und die Zuweisung erfolgreich durchgeführt wurde, das mistypedVaraible im globalen Bereich automatisch als globale Variable deklariert. Dies bedeutet, dass der Entwickler diese spezifische Zuweisung im Code manuell nachschlagen muss.

Darüber hinaus kann der Entwickler durch das Erzwingen der Deklaration von Variablen nicht versehentlich globale Variablen in Funktionen deklarieren. Im nicht-strikten Modus:

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

Im strikten Modus muss die Variable explizit deklariert werden:

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

Die Variable kann auch außerhalb und nach einer Funktion deklariert werden, um sie beispielsweise im globalen Gültigkeitsbereich verwenden zu können:

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

Änderungen an den Eigenschaften

Der strikte Modus verhindert auch das Löschen nicht wiederherstellbarer Eigenschaften.

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

Die obige Anweisung würde einfach ignoriert, wenn Sie nicht den strikten Modus verwenden. Jetzt wissen Sie, warum sie nicht wie erwartet ausgeführt wird.

Es verhindert auch, dass Sie eine nicht erweiterbare Eigenschaft erweitern.

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
}

Verhalten der Argumentliste einer Funktion

arguments Objekt verhalten sich im strengen und nicht strengen Modus unterschiedlich. Im nicht-strengen Modus spiegelt das argument die Änderungen im Wert der vorhandenen Parameter wider. Im strengen Modus werden jedoch Änderungen des Parameterwerts nicht im argument angezeigt.

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

Für den obigen Code wird das arguments geändert, wenn wir den Wert der Parameter ändern. Für den strikten Modus wird dasselbe jedoch nicht angezeigt.

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
}

Wenn einer der Parameter undefined ist und wir versuchen, den Parameterwert sowohl im strikten Modus als auch im nicht strengen Modus zu ändern, bleibt das arguments unverändert.

Strikter 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

Nicht strikter 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

Doppelte Parameter

Im strengen Modus können Sie keine doppelten Funktionsparameternamen verwenden.

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

Funktionsumfang im strikten Modus

Im strengen Modus sind Funktionen, die in einem lokalen Block deklariert sind, außerhalb des Blocks nicht zugänglich.

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

Funktionsumfang Deklarationen von Funktionen im strengen Modus haben dieselbe Bindungsart wie let oder const .

Nicht einfache Parameterlisten

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

ist ein ungültiges JavaScript und wirft einen SyntaxError weil Sie die Direktive "use strict" in einer Funktion mit einer Liste nicht einfacher Parameter wie der obigen nicht verwenden können - Standardzuweisung x = 5

Nicht einfache Parameter umfassen -

• Standardzuweisung

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

• Zerstörung

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

• Restparams

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