Hallo Klaus > Innerhalb vom Body von seite1.html > > ~~~HTML > <object id="test" type="text/html" data="seite2.html"></object> > ~~~ > > Habe ich jetzt die Möglichkeit von einer Javascript-Funktion von seite2.html aus eine Javascript-Funktion von seite1.html aufzurufen? Nicht direkt, da [der *Nested Browsing Context*{: @en}](https://www.w3.org/TR/html52/browsers.html#sec-nested-browsing-contexts) den `object` hier repräsentiert einen eigenen globalen Sichtbarkeitsbereich für Bezeichner erzeugt. Sprich, es werden nicht automatisch die Namensbindungen aus dem umgebenden Kontext "geerbt". Da Funktionsdeklarationen und gewöhnliche Variablendeklarationen im globalen *Scope*{: @en} von Skripten jedoch zu Eigenschaften auf dem jeweiligen `window`-Objekt verarbeitet werden, kannst du Funktionen über das `window`-Objekt des umgebenden Kontextes referenzieren. ~~~JavaScript // Im globalen Scope von seite1.html function foo() { console.log('foo'); } // Oder als Variablendeklaration: var foo = function() { console.log('foo') }; ~~~ Hast du wie oben eine Funktion auf seite1.html deklariert, kannst du von seite2.html aus über die [Eigenschaft `window.parent`](https://developer.mozilla.org/en-US/docs/Web/API/Window/parent) auf das `window`-Objekt des Kontextes von seite1.html zugreifen und die gewünschte Funktion als Methode dieses Objektes aufrufen: ~~~JavaScript // Auf seite2.html in irgendeinem Scope window.parent.foo(); ~~~ Variablen und Konstanten die mit den Schlüsselwörtern `let` und `const` deklariert werden, können hingegen nicht auf diese Weise referenziert werden, da diese Deklarationen nicht dazu führen, dass entsprechende Eigenschaften auf `window` definiert werden. Allgemein würde ich von einem Konstrukt wie diesem hier, mit dokumentübergreifenden Referenzen, aber abraten. – Da wird es höchstwahrscheinlich eine bessere Lösung geben. Viele Grüße, Orlok -- „Dance like it hurts. Make love like you need money. Work when people are watching.“ — Dogbert

Hallo Klaus > Innerhalb vom Body von seite1.html > > ~~~HTML > <object id="test" type="text/html" data="seite2.html"></object> > > ~~~ > > Habe ich jetzt die Möglichkeit von einer Javascript-Funktion von seite2.html aus eine Javascript-Funktion von seite1.html aufzurufen? Nicht direkt, da [der *Nested Browsing Context*{: @en}](https://www.w3.org/TR/html52/browsers.html#sec-nested-browsing-contexts) den `object` hier repräsentiert einen eigenen globalen Sichtbarkeitsbereich für Bezeichner erzeugt. Sprich, es werden nicht automatisch die Namensbindungen aus dem umgebenden Kontext "geerbt". Da Funktionsdeklarationen und gewöhnliche Variablendeklarationen im globalen *Scope*{: @en} von Skripten jedoch zu Eigenschaften auf dem jeweiligen `window`-Objekt verarbeitet werden, kannst du Funktionen über das `window`-Objekt des umgebenden Kontextes referenzieren. ~~~JavaScript // Im globalen Scope von seite1.html function foo() { console.log('foo'); } // oder var foo = function() { console.log('foo'); }; ~~~ Dann mit der [Eigenschaft `window.parent`](https://developer.mozilla.org/en-US/docs/Web/API/Window/parent): ~~~JavaScript // Auf der seite2.html window.parent.foo(); ~~~ Variablen und Konstanten die mit den Schlüsselwörtern `let` und `const` deklariert werden, können hingegen nicht auf diese Weise referenziert werden, da diese Deklarationen nicht dazu führen, dass entsprechende Eigenschaften auf `window` definiert werden. Allgemein würde ich von einem Konstrukt wie diesem hier, mit dokumentübergreifenden Referenzen, aber abraten. – Da wird es höchstwahrscheinlich eine bessere Lösung geben. Viele Grüße, Orlok -- „Dance like it hurts. Make love like you need money. Work when people are watching.“ — Dogbert

Hallo Klaus > Innerhalb vom Body von seite1.html > > ~~~HTML > <object id="test" type="text/html" data="seite2.html"></object> > > ~~~ > > Habe ich jetzt die Möglichkeit von einer Javascript-Funktion von seite2.html aus eine Javascript-Funktion von seite1.html aufzurufen? Nicht direkt, da [der *Nested Browsing Context*{: @en}](https://www.w3.org/TR/html52/browsers.html#sec-nested-browsing-contexts) den `object` hier repräsentiert einen eigenen globalen Sichtbarkeitsbereich für Bezeichner erzeugt. Sprich, es werden nicht automatisch die Namensbindungen aus dem umgebenden Kontext "geerbt". Da Funktionsdeklarationen und gewöhnliche Variablendeklarationen im globalen *Scope*{: @en} von Skripten jedoch zu Eigenschaften auf dem jeweiligen `window`-Objekt verarbeitet werden, kannst du Funktionen über das `window`-Objekt des umgebenden Kontextes referenzieren. ~~~JavaScript // Im globalen Scope von seite1.html function foo() { console.log('foo'); } // oder var foo = function() { console.log('foo'); }; ~~~ Dann mit der [Eigenschaft `window.parent`](https://developer.mozilla.org/en-US/docs/Web/API/Window/parent): ~~~JavaScript // Auf der seite2.html window.parent.foo(); ~~~ Variablen und Konstanten die mit den Schlüsselwörtern `let` und `const` deklariert werden, können hingegen nicht auf diese Weise referenziert werden, da diese Deklarationen nicht dazu führen, dass entsprechende Eigenschaften auf auf `window` definiert werden. Allgemein würde ich von einem Konstrukt wie diesem hier, mit dokumentübergreifenden Referenzen, aber abraten. – Da wird es höchstwahrscheinlich eine bessere Lösung geben. Viele Grüße, Orlok -- „Dance like it hurts. Make love like you need money. Work when people are watching.“ — Dogbert

Hallo Klaus > Innerhalb vom Body von seite1.html > > ~~~HTML > <object id="test" type="text/html" data="seite2.html"></object> > > ~~~ > > Habe ich jetzt die Möglichkeit von einer Javascript-Funktion von seite2.html aus eine Javascript-Funktion von seite1.html aufzurufen? Nicht direkt, da der *Nested Browsing Context*{: @en} den `object` hier repräsentiert einen eigenen globalen Sichtbarkeitsbereich für Bezeichner erzeugt. Sprich, es werden nicht automatisch die Namensbindungen aus dem umgebenden Kontext "geerbt". Da Funktionsdeklarationen und gewöhnliche Variablendeklarationen im globalen *Scope*{: @en} von Skripten jedoch zu Eigenschaften auf dem jeweiligen `window`-Objekt verarbeitet werden, kannst du Funktionen über das `window`-Objekt des umgebenden Kontextes referenzieren. ~~~JavaScript // Im globalen Scope von seite1.html function foo() { console.log('foo'); } // oder var foo = function() { console.log('foo'); }; ~~~ Dann mit der [Eigenschaft `window.parent`](https://developer.mozilla.org/en-US/docs/Web/API/Window/parent): ~~~JavaScript // Auf der seite2.html window.parent.foo(); ~~~ Variablen und Konstanten die mit `let` und `const` deklariert werden können hingegen nicht auf diese Weise referenziert werden, da diese Deklarationen nicht dazu führen, dass Eigenschaften auf dem globalen Objekt (`window`) definiert werden. Allgemein würde ich von einem Konstrukt wie diesem hier mit dokumentübergreifenden Referenzen aber abraten. Da wird es höchstwahrscheinlich eine bessere Lösung geben. Viele Grüße, Orlok -- „Dance like it hurts. Make love like you need money. Work when people are watching.“ — Dogbert

Hallo Klaus > Innerhalb vom Body von seite1.html > > ~~~HTML > <object id="test" type="text/html" data="seite2.html"></object> > > ~~~ > > Habe ich jetzt die Möglichkeit von einer Javascript-Funktion von seite2.html aus eine Javascript-Funktion von seite1.html aufzurufen? Nicht direkt, da der *Nested Browsing Context*{: @en} den `object` hier repräsentiert einen eigenen globalen Sichtbarkeitsbereich für Bezeichner erzeugt. Sprich, es werden nicht automatisch die Namensbindungen aus dem umgebenden Kontext "geerbt". Da Funktionsdeklarationen und gewöhnliche Variablendeklarationen im globalen *Scope*{: @en} von Skripten jedoch zu Eigenschaften auf dem jeweiligen `window`-Objekt verarbeitet werden, kannst du Funktionen über das `window`-Objekt des umgebenden Kontextes referenzieren. ~~~JavaScript // Im globalen Scope von seite1.html function foo() { console.log('foo'); } // oder var foo = function() { console.log('foo'); }; ~~~ Dann mit der Eigenschaft `window.parent`: ~~~JavaScript // Auf der seite2.html window.parent.foo(); ~~~ Variablen und Konstanten die mit `let` und `const` deklariert werden können hingegen nicht auf diese Weise referenziert werden, da diese Deklarationen nicht dazu führen, dass Eigenschaften auf dem globalen Objekt (`window`) definiert werden. Allgemein würde ich von einem Konstrukt wie diesem hier mit dokumentübergreifenden Referenzen aber abraten. Da wird es höchstwahrscheinlich eine bessere Lösung geben. Viele Grüße, Orlok -- „Dance like it hurts. Make love like you need money. Work when people are watching.“ — Dogbert

Hallo Klaus > Innerhalb vom Body von seite1.html > > ~~~HTML > <object id="test" type="text/html" data="seite2.html"></object> > > ~~~ > > Habe ich jetzt die Möglichkeit von einer Javascript-Funktion von seite2.html aus eine Javascript-Funktion von seite1.html aufzurufen? Nicht direkt, da der *Nested Browsing Context*{: @en} den `object` hier repräsentiert einen eigenen globalen Sichtbarkeitsbereich für Bezeichner erzeugt. Sprich, es werden nicht automatisch die Namensbindungen aus dem umgebenden Kontext "geerbt". Da Funktionsdeklarationen und gewöhnliche Variablendeklarationen im globalen *Scope*{: @en} von Skripten jedoch zu Eigenschaften auf dem jeweiligen `window`-Objekt verarbeitet werden, kannst du Funktionen über das `window`-Objekt des umgebenden Kontextes referenzieren. ~~~JavaScript // Im globalen Scope von seite1.html function foo() { console.log('foo'); } // oder var foo = function() { console.log('foo'); }; ~~~ Dann mit der Eigenschaft `window.parent`: ~~~JavaScript // Im globalen Scope von seite2.html window.parent.foo(); ~~~ Variablen und Konstanten die mit `let` und `const` deklariert werden können hingegen nicht auf diese Weise referenziert werden, da diese Deklarationen nicht dazu führen, dass Eigenschaften auf dem globalen Objekt (`window`) definiert werden. Allgemein würde ich von einem Konstrukt wie diesem hier mit dokumentübergreifenden Referenzen aber abraten. Da wird es höchstwahrscheinlich eine bessere Lösung geben. Viele Grüße, Orlok -- „Dance like it hurts. Make love like you need money. Work when people are watching.“ — Dogbert