JavaScript Strict Mode ("use strict")

Was ist "use strict"?

JavaScript wurde 1995 so entworfen, dass es bei fehlerhaftem Code niemals abstürzt — Fehler wurden still ignoriert, um Webseiten am Laufen zu halten. Dieses nachsichtige Verhalten verbirgt Bugs. Der Strict Mode ist eine optionale Variante der Sprache, die in ECMAScript 5 (2009) eingeführt wurde. Sie wandelt viele dieser stillen Fehler in deutliche Fehlermeldungen um und entfernt einige verwirrende veraltete Funktionen.

Aktiviert wird er mit einer literalen String-Direktive:

"use strict";

Diese Seite erklärt, wo die Direktive platziert wird, was sie genau verändert und warum moderner Code (Module und Klassen) bereits ohne eigenes Zutun im Strict Mode läuft.

Strict Mode aktivieren

Die Direktive muss die allererste Anweisung sein — ein einfacher String, vor jedem anderen Code. Falls etwas davor steht (selbst ein einzelner Ausdruck), wird sie als gewöhnlicher String behandelt und ignoriert, ohne jede Warnung.

Ganzes Skript oder Modul

"use strict"; an den Anfang der Datei stellen, um alles darunter zu erfassen:

"use strict";

// Every statement in this file now runs in strict mode.
function doStuff() {
  // strict here too
}

Eine einzelne Funktion

Der Strict Mode lässt sich auf eine einzelne Funktion beschränken, indem die Direktive an den Anfang des Funktionsrumpfs gesetzt wird. Der Rest der Datei bleibt im sogenannten Sloppy-Modus (ohne Strict Mode). Das ist nützlich, wenn man Strict-Verhalten schrittweise in eine große Legacy-Datei einführen möchte.

function strictFn() {
  "use strict";
  return arguments; // strict behavior, just inside here
}

function sloppyFn() {
  return arguments; // legacy behavior
}

Den Strict Mode lässt sich nicht wieder abschalten, sobald er in einem Scope aktiv ist. Die Direktive wirkt nur in eine Richtung.

Was der Strict Mode tatsächlich verändert

Die Unterschiede sind zahlenmäßig gering, aber sie decken echte Bugs auf. Hier sind die am häufigsten anzutreffenden.

Zuweisung an nicht deklarierte Variablen wirft einen Fehler

Im Sloppy-Modus erstellt x = 10 ohne var/let/const still eine globale Variable — eine klassische Quelle von Lecks und Tippfehlern. Der Strict Mode verweigert das:

"use strict";
undeclaredVariable = 10; // ReferenceError: undeclaredVariable is not defined

Siehe das globale Objekt und Variable Scope für eine Erklärung, warum versehentliche globale Variablen so schädlich sind.

Fehlerhafte Zuweisungen werfen statt still zu scheitern

Das Schreiben in eine schreibgeschützte Eigenschaft, eine Getter-only-Eigenschaft oder ein nicht erweiterbares object schlägt im Sloppy-Modus still fehl. Der Strict Mode wirft einen TypeError, sodass man es sofort bemerkt:

"use strict";
const obj = {};
Object.defineProperty(obj, "x", { value: 1, writable: false });
obj.x = 2; // TypeError: Cannot assign to read only property 'x'

this ist undefined bei gewöhnlichen Funktionsaufrufen

Ruft man eine normale Funktion direkt auf (nicht als Methode), setzt der Sloppy-Modus this auf das globale object. Der Strict Mode lässt es undefined, was Fehler sichtbar macht, wenn eine Methode von ihrem object getrennt wird:

"use strict";
function whoAmI() {
  return this;
}
console.log(whoAmI()); // undefined  (in sloppy mode this would be the global object)

Doppelte Parameternamen sind verboten

"use strict";
function add(a, a) { // SyntaxError: Duplicate parameter name not allowed in this context
  return a + a;
}

Weitere Einschränkungen

• delete auf eine Variable, eine Funktion oder ein Funktionsargument ist ein SyntaxError.
• Oktale Literale wie 010 sind nicht erlaubt (stattdessen 0o10 verwenden).
• eval und arguments können weder überschrieben noch als Variablennamen verwendet werden.
• Reservierte Wörter wie implements, interface, private, public dürfen nicht als Bezeichner genutzt werden.

Module und Klassen sind immer im Strict Mode

Oft muss "use strict"; gar nicht geschrieben werden, weil zwei der häufigsten modernen Kontexte automatisch im Strict Mode laufen:

• ES-Module. Jede als Modul geladene Datei (<script type="module">, eine per import eingebundene Datei oder eine .mjs-Datei) läuft im Strict Mode. Die Direktive ist dort überflüssig.
• Klassenrümpfe. Sämtlicher Code innerhalb einer class { ... }-Deklaration oder -Expression ist strict, unabhängig von der umgebenden Datei.

class Counter {
  // This method is strict even with no directive anywhere in the file.
  bump() {
    return this; // undefined if called detached, like any strict function
  }
}

Da moderner Code heute überwiegend in diesen Kontexten geschrieben wird, läuft er de facto bereits im Strict Mode. Die "use strict";-Direktive ist hauptsächlich für klassische, nicht-modulare <script>-Dateien und ältere Codebasen relevant.

Wann sollte man ihn verwenden?

• Neue Nicht-Modul-Skripte: "use strict"; an den Anfang setzen. Es ist kostenlose Absicherung gegen versehentliche globale Variablen und stille Fehler.
• Module und Klassen: nichts zu tun — der Strict Mode ist bereits aktiv.
• Legacy-Dateien: schrittweise einführen, Funktion für Funktion, und anschließend testen. Das Umstellen einer ganzen Sloppy-Datei auf Strict kann Code ans Licht bringen, der heimlich auf versehentliche globale Variablen oder sloppy this angewiesen war. Siehe das alte "var" für verwandtes Legacy-Verhalten, das sich gleichzeitig bereinigen lässt.

Zusammenfassung

Der Strict Mode ist ein strengerer, sichererer Dialekt von JavaScript, der mit der "use strict";-Direktive am Anfang eines Skripts oder einer Funktion aktiviert wird. Er verhindert implizite globale Variablen, wirft bei fehlerhaften Zuweisungen einen Fehler, setzt this bei gewöhnlichen Aufrufen auf undefined und verbietet doppelte Parameter sowie einige veraltete Syntaxformen. ES-Module und Klassenrümpfe aktivieren ihn automatisch, sodass der Hauptgrund, ihn manuell zu schreiben, klassische Skriptdateien und älterer Code sind.

Übungen