Das Schlüsselwortthis bezieht sich auf den Kontext, in dem ein Stück Code, wie der Körper einer Funktion, ausgeführt werden soll. Es wird am häufigsten in Objektmethoden verwendet, wothis auf das Objekt verweist, an das die Methode angehängt ist, und es somit ermöglicht, dieselbe Methode auf verschiedenen Objekten wiederzuverwenden.

Der Wert vonthis in JavaScript hängt davon ab, wie eine Funktion aufgerufen wird (Laufzeit-Bindung), nicht wie sie definiert ist. Wenn eine reguläre Funktion als Methode eines Objekts aufgerufen wird (obj.method()), zeigtthis auf dieses Objekt. Wenn sie als eigenständige Funktion aufgerufen wird (nicht an ein Objekt gebunden:func()), verweistthis typischerweise auf dasglobale Objekt (im nicht-strikten Modus) oder istundefined (imstrikten Modus). Die MethodeFunction.prototype.bind() kann eine Funktion erstellen, derenthis-Bindung sich nicht ändert, und die MethodenFunction.prototype.apply() undFunction.prototype.call() können denthis-Wert für einen bestimmten Aufruf festlegen.

Arrow-Funktionen unterscheiden sich in ihrer Handhabung vonthis: Sie erbenthis vom übergeordneten Gültigkeitsbereich zum Zeitpunkt ihrer Definition. Dieses Verhalten macht Arrow-Funktionen besonders nützlich für Callbacks und zur Wahrung des Kontextes. Allerdings haben Arrow-Funktionen keine eigenethis-Bindung. Daher kann ihrthis-Wert nicht durchbind(),apply() odercall()-Methoden gesetzt werden und verweist in Objektmethoden auch nicht auf das aktuelle Objekt.

Probieren Sie es aus

const test = {  prop: 42,  func() {    return this.prop;  },};console.log(test.func());// Expected output: 42

Syntax

this

Wert

Im nicht-strikten Modus istthis immer eine Referenz auf ein Objekt. Im strikten Modus kann es jeden Wert haben. Weitere Informationen dazu, wie der Wert bestimmt wird, finden Sie in der nachfolgenden Beschreibung.

Beschreibung

Der Wert vonthis hängt davon ab, in welchem Kontext es erscheint: Funktion, Klasse oder global.

Funktionskontext

Innerhalb einer Funktion hängt der Wert vonthis davon ab, wie die Funktion aufgerufen wird. Betrachten Siethis als einen versteckten Parameter einer Funktion — genau wie die Parameter, die in der Funktionsdefinition deklariert sind, istthis eine Bindung, die die Sprache für Sie erstellt, wenn der Funktionskörper ausgewertet wird.

Für eine reguläre Funktion (keine Arrow-Funktion, gebundene Funktion usw.) ist der Wert vonthis das Objekt, auf dem die Funktion aufgerufen wird. Mit anderen Worten, wenn der Funktionsaufruf in der Formobj.f() ist, dann bezieht sichthis aufobj. Zum Beispiel:

function getThis() {  return this;}const obj1 = { name: "obj1" };const obj2 = { name: "obj2" };obj1.getThis = getThis;obj2.getThis = getThis;console.log(obj1.getThis()); // { name: 'obj1', getThis: [Function: getThis] }console.log(obj2.getThis()); // { name: 'obj2', getThis: [Function: getThis] }

Beachten Sie, wie die Funktion dieselbe ist, aber je nachdem, wie sie aufgerufen wird, der Wert vonthis unterschiedlich ist. Dies ist analog zu der Funktionsweise von Parametern.

Der Wert vonthis ist nicht das Objekt, das die Funktion als eigene Eigenschaft hat, sondern das Objekt, das verwendet wird, um die Funktion aufzurufen. Sie können dies beweisen, indem Sie eine Methode eines Objekts in derPrototypkette aufrufen.

const obj3 = {  __proto__: obj1,  name: "obj3",};console.log(obj3.getThis()); // { name: 'obj3' }

Der Wert vonthis ändert sich immer basierend darauf, wie eine Funktion aufgerufen wird, selbst wenn die Funktion bei der Erstellung an ein Objekt gebunden war:

const obj4 = {  name: "obj4",  getThis() {    return this;  },};const obj5 = { name: "obj5" };obj5.getThis = obj4.getThis;console.log(obj5.getThis()); // { name: 'obj5', getThis: [Function: getThis] }

Wenn der Wert, auf dem die Methode aufgerufen wird, ein primitiver Wert ist, wirdthis ebenfalls ein primitiver Wert sein — aber nur, wenn die Funktion im strikten Modus ist.

function getThisStrict() {  "use strict"; // Enter strict mode  return this;}// Only for demonstration — you should not mutate built-in prototypesNumber.prototype.getThisStrict = getThisStrict;console.log(typeof (1).getThisStrict()); // "number"

Wenn die Funktion ohne Bezug auf irgendetwas aufgerufen wird, istthisundefined — aber nur, wenn die Funktion im strikten Modus ist.

console.log(typeof getThisStrict()); // "undefined"

Im nicht-strikten Modus sorgt ein spezieller Prozess namensthis-Substitution dafür, dass der Wert vonthis immer ein Objekt ist. Das bedeutet:

• Wenn eine Funktion mitthis aufgerufen wird, das aufundefined odernull gesetzt ist, wirdthis mitglobalThis ersetzt.
• Wenn die Funktion mitthis aufgerufen wird, das auf einen primitiven Wert gesetzt ist, wirdthis mit dem entsprechenden Wrapper-Objekt des primitiven Wertes ersetzt.

function getThis() {  return this;}// Only for demonstration — you should not mutate built-in prototypesNumber.prototype.getThis = getThis;console.log(typeof (1).getThis()); // "object"console.log(getThis() === globalThis); // true

In typischen Funktionsaufrufen wirdthis implizit wie ein Parameter durch das Präfix der Funktion übergeben (der Teil vor dem Punkt). Sie können den Wert vonthis auch explizit mit den MethodenFunction.prototype.call(),Function.prototype.apply() oderReflect.apply() festlegen. MitFunction.prototype.bind() können Sie eine neue Funktion mit einem bestimmten Wert vonthis erstellen, der sich unabhängig davon, wie die Funktion aufgerufen wird, nicht ändert. Bei der Verwendung dieser Methoden gelten die oben genannten Regeln zurthis-Substitution weiterhin, wenn die Funktion nicht im strikten Modus ist.

Callbacks

Wenn eine Funktion als Callback übergeben wird, hängt der Wert vonthis davon ab, wie der Callback aufgerufen wird, was vom Implementor der API bestimmt wird. Callbacks werdentypischerweise mit einemthis-Wert vonundefined aufgerufen (direktes Aufrufen ohne Anknüpfung an ein Objekt), was bedeutet, dass der Wert vonthis das globale Objekt ist (globalThis), wenn die Funktion nicht im strikten Modus ist. Dies ist der Fall beiiterativen Array-Methoden, demPromise()-Konstruktor usw.

function logThis() {  "use strict";  console.log(this);}[1, 2, 3].forEach(logThis); // undefined, undefined, undefined

Einige APIs erlauben es Ihnen, einenthis-Wert für die Aufrufe des Callbacks festzulegen. Zum Beispiel akzeptieren alle iterativen Array-Methoden und verwandte wieSet.prototype.forEach() einen optionalenthisArg-Parameter.

[1, 2, 3].forEach(logThis, { name: "obj" });// { name: 'obj' }, { name: 'obj' }, { name: 'obj' }

Gelegentlich wird ein Callback mit einemthis-Wert aufgerufen, der nichtundefined ist. Zum Beispiel werden derreviver-Parameter vonJSON.parse() und derreplacer-Parameter vonJSON.stringify() beide mitthis auf das Objekt gesetzt, zu dem die zu parsende/zu serialisierende Eigenschaft gehört.

Arrow-Funktionen

InArrow-Funktionen behältthis den Wert des umgebenden lexikalischen Kontextes bei. Mit anderen Worten, beim Auswerten des Körpers einer Arrow-Funktion erstellt die Sprache keine neuethis-Bindung.

Zum Beispiel ist in globalem Codethis immerglobalThis, unabhängig vom Striktheitsgrad, aufgrund derglobalen Kontexte-Bindung:

const globalObject = this;const foo = () => this;console.log(foo() === globalObject); // true

Arrow-Funktionen erstellen eineClosure über denthis-Wert ihres umgebenden Gültigkeitsbereichs, was bedeutet, dass Arrow-Funktionen sich verhalten, als wären sie "automatisch gebunden" — egal wie sie aufgerufen werden,this ist an das gebunden, was es war, als die Funktion erstellt wurde (im obigen Beispiel das globale Objekt). Dasselbe gilt für Arrow-Funktionen, die innerhalb anderer Funktionen erstellt werden: Ihrthis bleibt das des umgebenden lexikalischen Kontextes.Siehe Beispiel unten.

Darüber hinaus wird beim Aufrufen von Arrow-Funktionen mitcall(),bind() oderapply() derthisArg-Parameter ignoriert. Sie können jedoch weiterhin andere Argumente mit diesen Methoden übergeben.

const obj = { name: "obj" };// Attempt to set this using callconsole.log(foo.call(obj) === globalObject); // true// Attempt to set this using bindconst boundFoo = foo.bind(obj);console.log(boundFoo() === globalObject); // true

Konstruktoren

Wenn eine Funktion als Konstruktor verwendet wird (mit dem Schlüsselwortnew), istthis an das neue Objekt gebunden, das erstellt wird, unabhängig von dem Objekt, auf dem die Konstruktorfunktion aufgerufen wird. Der Wert vonthis wird der Wert desnew-Ausdrucks, es sei denn, der Konstruktor gibt einen anderen nicht-primitiven Wert zurück.

function C() {  this.a = 37;}let o = new C();console.log(o.a); // 37function C2() {  this.a = 37;  return { a: 38 };}o = new C2();console.log(o.a); // 38

Im zweiten Beispiel (C2) wird das neue Objekt, an dasthis gebunden war, verworfen, weil ein Objekt während der Erstellung zurückgegeben wurde. (Dies macht die Anweisungthis.a = 37; im Wesentlichen zu totem Code. Es ist nicht genau tot, weil es ausgeführt wird, aber es kann ohne äußere Effekte eliminiert werden.)

super

Wenn eine Funktion in der Formsuper.method() aufgerufen wird, istthis innerhalb dermethod-Funktion der gleiche Wert wie derthis-Wert um densuper.method()-Aufruf, und ist im Allgemeinen nicht gleich dem Objekt, auf dassuper verweist. Dies liegt daran, dasssuper.method kein Objektmitgliedszugriff wie die oben genannten ist — es ist eine spezielle Syntax mit anderen Bindungsregeln. Für Beispiele siehe diesuper-Referenz.

Klassenkontext

EineKlasse kann in zwei Kontexte unterteilt werden: statisch und instanziiert.Konstruktoren, Methoden und Initialisierer für Instanzfelder (öffentlich oderprivat) gehören zum Instanzkontext.Statische Methoden, Initialisierer für statische Felder undstatische Initialisierungsblöcke gehören zum statischen Kontext. Derthis-Wert ist in jedem Kontext unterschiedlich.

Konstruktormethoden werden immer mitnew aufgerufen, sodass ihr Verhalten dem vonFunktionskonstruktoren entspricht: Derthis-Wert ist die neue Instanz, die erstellt wird. Klassenmethoden verhalten sich wie Methoden in Objektliteralen — derthis-Wert ist das Objekt, auf dem die Methode aufgerufen wurde. Wenn die Methode nicht an ein anderes Objekt übertragen wird, istthis im Allgemeinen eine Instanz der Klasse.

Statische Methoden sind keine Eigenschaften vonthis. Sie sind Eigenschaften der Klasse selbst. Daher werden sie im Allgemeinen auf der Klasse aufgerufen, undthis ist der Wert der Klasse (oder einer Unterklasse). Statische Initialisierungsblöcke werden ebenfalls mitthis auf die aktuelle Klasse gesetzt ausgewertet.

Initialisierer für Felder werden ebenfalls im Kontext der Klasse ausgewertet. Instanzfelder werden mitthis auf die Instanz gesetzt, die erstellt wird, ausgewertet. Statische Felder werden mitthis auf die aktuelle Klasse gesetzt ausgewertet. Deshalb sind Arrow-Funktionen in Feldinitialisierernan die Instanz für Instanzfelder und an die Klasse für statische Felder gebunden.

class C {  instanceField = this;  static staticField = this;}const c = new C();console.log(c.instanceField === c); // trueconsole.log(C.staticField === C); // true

Abgeleitete Klassenkonstruktoren

Im Gegensatz zu Basisklassenkonstruktoren haben abgeleitete Konstruktoren keine initialethis-Bindung. Der Aufruf vonsuper() erstellt einethis-Bindung innerhalb des Konstruktors und hat im Wesentlichen die Wirkung, die folgende Codezeile auszuwerten, wobeiBase die Basisklasse ist:

this = new Base();

Abgeleitete Klassen dürfen nicht vor dem Aufruf vonsuper() zurückkehren, es sei denn, der Konstruktor gibt ein Objekt zurück (sodass derthis-Wert überschrieben wird) oder die Klasse hat keinen Konstruktor.

class Base {}class Good extends Base {}class AlsoGood extends Base {  constructor() {    return { a: 5 };  }}class Bad extends Base {  constructor() {}}new Good();new AlsoGood();new Bad(); // ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor

Globaler Kontext

Im globalen Ausführungskontext (außerhalb von Funktionen oder Klassen; kann inBlöcken oderArrow-Funktionen definiert im globalen Gültigkeitsbereich liegen) hängt derthis-Wert davon ab, in welchem Ausführungskontext das Skript ausgeführt wird. Wie beiCallbacks wird derthis-Wert von der Laufzeitumgebung (dem Aufrufer) bestimmt.

Auf der obersten Ebene eines Skripts bezieht sichthis aufglobalThis, unabhängig davon, ob im strikten Modus oder nicht. Dies ist im Allgemeinen dasselbe wie das globale Objekt — wenn der Quelltext beispielsweise in einem HTML-<script>-Element eingeschlossen und als Skript ausgeführt wird, istthis === window.

// In web browsers, the window object is also the global object:console.log(this === window); // truethis.b = "MDN";console.log(window.b); // "MDN"console.log(b); // "MDN"

Wenn die Quelle alsModul geladen wird (für HTML bedeutet dies das Hinzufügen vontype="module" zum<script>-Tag), istthis immerundefined auf der obersten Ebene.

Wenn der Quellcode miteval() ausgeführt wird, istthis dasselbe wie der umgebende Kontext fürdirektes eval, oderglobalThis (als ob es in einem separaten globalen Skript ausgeführt wird) für indirektes eval.

function test() {  // Direct eval  console.log(eval("this") === this);  // Indirect eval, non-strict  console.log(eval?.("this") === globalThis);  // Indirect eval, strict  console.log(eval?.("'use strict'; this") === globalThis);}test.call({ name: "obj" }); // Logs 3 "true"

Beachten Sie, dass ein Teil des Quellcodes, obwohl er wie der globale Bereich aussieht, tatsächlich in eine Funktion eingeschlossen ist, wenn er ausgeführt wird. Beispielsweise werden Node.js CommonJS-Module in eine Funktion eingeschlossen und mit demthis-Wertmodule.exports ausgeführt.Ereignishandlerattribute werden mitthis auf das Element gesetzt, an das sie angehängt sind.

Objektliterale erstellen keinenthis-Gültigkeitsbereich — nur innerhalb des Objekts definierte Funktionen (Methoden) tun das. Die Verwendung vonthis in einem Objektliteral erbt den Wert vom umgebenden Gültigkeitsbereich.

const obj = {  a: this,};console.log(obj.a === window); // true

Beispiele

this in Funktionskontexten

Der Wert desthis-Parameters hängt davon ab, wie die Funktion aufgerufen wird, nicht davon, wie sie definiert ist.

// An object can be passed as the first argument to 'call'// or 'apply' and 'this' will be bound to it.const obj = { a: "Custom" };// Variables declared with var become properties of 'globalThis'.var a = "Global";function whatsThis() {  return this.a; // 'this' depends on how the function is called}whatsThis(); // 'Global'; the 'this' parameter defaults to 'globalThis' in non–strict modeobj.whatsThis = whatsThis;obj.whatsThis(); // 'Custom'; the 'this' parameter is bound to obj

Mitcall() undapply() können Sie den Wert vonthis übergeben, als ob es ein expliziter Parameter wäre.

function add(c, d) {  return this.a + this.b + c + d;}const o = { a: 1, b: 3 };// The first argument is bound to the implicit 'this' parameter; the remaining// arguments are bound to the named parameters.add.call(o, 5, 7); // 16// The first argument is bound to the implicit 'this' parameter; the second// argument is an array whose members are bound to the named parameters.add.apply(o, [10, 20]); // 34

this und Objektumwandlung

Im nicht-strikten Modus, wenn eine Funktion mit einemthis-Wert aufgerufen wird, der kein Objekt ist, wird derthis-Wert mit einem Objekt ersetzt.null undundefined werden zuglobalThis. Primitive wie7 oder'foo' werden zu einem Objekt unter Verwendung des zugehörigen Konstruktors konvertiert, sodass die primitive Zahl7 zu einerNumber-Wrapper-Klasse und der String'foo' zu einerString-Wrapper-Klasse werden.

function bar() {  console.log(Object.prototype.toString.call(this));}bar.call(7); // [object Number]bar.call("foo"); // [object String]bar.call(undefined); // [object Window]

Die bind()-Methode

Der Aufruf vonf.bind(someObject) erstellt eine neue Funktion mit dem gleichen Körper und Gültigkeitsbereich wief, aber der Wert vonthis ist dauerhaft an das erste Argument vonbind gebunden, unabhängig davon, wie die Funktion aufgerufen wird.

function f() {  return this.a;}const g = f.bind({ a: "azerty" });console.log(g()); // azertyconst h = g.bind({ a: "yoo" }); // bind only works once!console.log(h()); // azertyconst o = { a: 37, f, g, h };console.log(o.a, o.f(), o.g(), o.h()); // 37 37 azerty azerty

this in Arrow-Funktionen

Arrow-Funktionen erstellen Closures über denthis-Wert des umgebenden Ausführungskontextes. Im folgenden Beispiel erstellen wirobj mit einer MethodegetThisGetter, die eine Funktion zurückgibt, die den Wert vonthis zurückgibt. Die zurückgegebene Funktion wird als Arrow-Funktion erstellt, sodass ihrthis dauerhaft an dasthis ihrer umgebenden Funktion gebunden ist. Der Wert vonthis innerhalbgetThisGetter kann im Aufruf festgelegt werden, was wiederum den Rückgabewert der zurückgegebenen Funktion festlegt. Wir nehmen an, dassgetThisGetter eine nicht-strikte Funktion ist, was bedeutet, dass sie in einem nicht-strikten Skript enthalten ist und nicht weiter in einer Klasse oder strikten Funktion verschachtelt ist.

const obj = {  getThisGetter() {    const getter = () => this;    return getter;  },};

Wir könnengetThisGetter als Methode vonobj aufrufen, wasthis anobj innerhalb seines Körpers bindet. Die zurückgegebene Funktion wird einer Variablenfn zugewiesen. Wenn wir nunfn aufrufen, bleibt der Wert vonthis der, der durch den Aufruf vongetThisGetter festgelegt wurde, alsoobj. Wäre die zurückgegebene Funktion keine Arrow-Funktion gewesen, würden solche Aufrufe dazu führen, dass derthis-WertglobalThis wäre, weilgetThisGetter nicht-strikt ist.

const fn = obj.getThisGetter();console.log(fn() === obj); // true

Aber seien Sie vorsichtig, wenn Sie die Methode vonobj ohne sie aufzurufen lösen, dagetThisGetter noch eine Methode mit einem variierendenthis-Wert ist. Der Aufruf vonfn2()() im folgenden Beispiel gibtglobalThis zurück, weil es demthis vonfn2() folgt, welchesglobalThis ist, da es ohne Verbindung zu einem Objekt aufgerufen wird.

const fn2 = obj.getThisGetter;console.log(fn2()() === globalThis); // true in non-strict mode

Dieses Verhalten ist sehr nützlich beim Definieren von Callbacks. Normalerweise erstellt jeder Funktionsausdruck seine eigenethis-Bindung, die denthis-Wert des oberen Bereichs überschattet. Jetzt können Sie Funktionen als Arrow-Funktionen definieren, wenn Ihnen derthis-Wert egal ist, undthis-Bindungen nur dort erstellen, wo Sie es tun (z.B. in Klassenmethoden). SieheBeispiel mitsetTimeout().

this mit einem Getter oder Setter

this in Gettern und Settern basiert darauf, auf welchem Objekt die Eigenschaft aufgerufen wird, nicht auf welchem Objekt die Eigenschaft definiert ist. Eine Funktion, die als Getter oder Setter verwendet wird, hat ihrthis an das Objekt gebunden, von dem die Eigenschaft gesetzt oder abgerufen wird.

function sum() {  return this.a + this.b + this.c;}const o = {  a: 1,  b: 2,  c: 3,  get average() {    return (this.a + this.b + this.c) / 3;  },};Object.defineProperty(o, "sum", {  get: sum,  enumerable: true,  configurable: true,});console.log(o.average, o.sum); // 2 6

this in DOM-Ereignishandlern

Wenn eine Funktion als Ereignishandler verwendet wird, ist ihrthis-Parameter an das DOM-Element gebunden, auf dem der Listener platziert ist (einige Browser halten sich nicht an diese Konvention bei Listeners, die dynamisch mit anderen Methoden alsaddEventListener() hinzugefügt werden).

// When called as a listener, turns the related element bluefunction bluify(e) {  // Always true  console.log(this === e.currentTarget);  // true when currentTarget and target are the same object  console.log(this === e.target);  this.style.backgroundColor = "#A5D9F3";}// Get a list of every element in the documentconst elements = document.getElementsByTagName("*");// Add bluify as a click listener so when the// element is clicked on, it turns bluefor (const element of elements) {  element.addEventListener("click", bluify);}

this in Inline-Ereignishandlern

Wenn der Code von einem Inline-Ereignishandler-Attribut aufgerufen wird, istthis an das DOM-Element gebunden, auf dem der Listener platziert ist:

<button>Show this</button>

Die obige Benachrichtigung zeigtbutton. Beachten Sie jedoch, dass nur der äußere Gültigkeitsbereich auf diese Weise seinthis gebunden hat:

<button>  Show inner this</button>

In diesem Fall ist derthis-Parameter der inneren Funktion anglobalThis gebunden (d.h. das Standardobjekt im nicht-strikten Modus, bei demthis im Aufruf nicht übergeben wird).

Gebundene Methoden in Klassen

Wie bei regulären Funktionen hängt derthis-Wert innerhalb von Methoden davon ab, wie sie aufgerufen werden. Manchmal ist es nützlich, dieses Verhalten zu überschreiben, sodassthis innerhalb von Klassen immer auf die Klasseninstanz verweist. Um dies zu erreichen, binden Sie die Klassenmethoden im Konstruktor:

class Car {  constructor() {    // Bind sayBye but not sayHi to show the difference    this.sayBye = this.sayBye.bind(this);  }  sayHi() {    console.log(`Hello from ${this.name}`);  }  sayBye() {    console.log(`Bye from ${this.name}`);  }  get name() {    return "Ferrari";  }}class Bird {  get name() {    return "Tweety";  }}const car = new Car();const bird = new Bird();// The value of 'this' in methods depends on their callercar.sayHi(); // Hello from Ferraribird.sayHi = car.sayHi;bird.sayHi(); // Hello from Tweety// For bound methods, 'this' doesn't depend on the callerbird.sayBye = car.sayBye;bird.sayBye(); // Bye from Ferrari

const carSayHi = car.sayHi;carSayHi(); // TypeError, weil die 'sayHi'-Methode versucht, 'this.name' zuzugreifen, aber 'this' ist im strikten Modus undefiniert.

Beachten Sie jedoch, dass automatisch gebundene Methoden dasselbe Problem haben wiedie Verwendung von Arrow-Funktionen für Klassenmethoden: Jede Instanz der Klasse wird ihre eigene Kopie der Methode haben, was den Speicherverbrauch erhöht. Verwenden Sie dies nur, wenn es absolut notwendig ist. Sie können auch die Implementierung vonIntl.NumberFormat.prototype.format() nachahmen: Definieren Sie die Eigenschaft als Getter, der eine gebundene Funktion zurückgibt, wenn sie aufgerufen wird, und speichern Sie sie, sodass die Funktion nur einmal und nur bei Bedarf erstellt wird.

this in with-Anweisungen

Obwohlwith-Anweisungen veraltet und im strikten Modus nicht verfügbar sind, bilden sie weiterhin eine Ausnahme von den normalenthis-Bindungsregeln. Wenn eine Funktion innerhalb einerwith-Anweisung aufgerufen wird und diese Funktion eine Eigenschaft des Gültigkeitsbereich-Objekts ist, wird derthis-Wert an das Gültigkeitsbereich-Objekt gebunden, als ob dasobj.-Präfix existiert.

const obj = {  foo() {    return this;  },};with (obj) {  console.log(foo() === obj); // true}

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Strikter Modus
• globalThis