Frage zu eval()

[.nils.]

Hallo,

Verständnisfrage:

  
document.getElementsByTagName("p")[0].onclick=eval('function(){tue(this);};');  

Wird die zeitfressende Funktion eval() jedesmal neu bei Klick auf den Textabsatz ausgewertet, oder nur einmal und das Ergebnis wird zwischengespeichert?

Gruß, Nils

[derletztekick]

Hallo .nils.,

document.getElementsByTagName("p")[0].onclick=eval('function(){tue(this);};');

> Wird die zeitfressende Funktion eval() jedesmal neu bei Klick auf den Textabsatz ausgewertet...?  
  
Natürlich jedes Mal, wobei es bei Dir wohl nicht zwingend nötig zu sein scheint. Du könntest ja eine eigene Funktion an das Event heften, in der Du wiederum Deine tue() ansprichst:  
~~~javascript
  
obj.onclick = function() {  
  //mache etwas;  
}

Mit freundlichem Gruß
Micha

[globe]

n'abend,

Wird die zeitfressende Funktion eval() jedesmal neu bei Klick auf den Textabsatz ausgewertet...?
Natürlich jedes Mal [...]

bist du dir da sicher? Soweit ich das verstanden habe wird dem obj.onclick das Ergebnis der eval-Funktion angehängt. Für eine erneute Ausführung von eval() hätte man die Funktion schon ein eine closure packen müssen: obj.onclick = function(){ eval('...'); }

Dein Vorschlag mit der direkten Zuweisung einer Handler-Funktion macht natürlich mehr als Sinn und sollte vom OP in jedem Fall befolgt werden.

weiterhin schönen abend...

[derletztekick]

Hallo globe,

n'abend,

Wird die zeitfressende Funktion eval() jedesmal neu bei Klick auf den Textabsatz ausgewertet...?
Natürlich jedes Mal [...]

bist du dir da sicher?

Nein, ich habe es nur vermutet. Grund meiner Annahme ist, das sich Parameter innerhalb der Funktion ändern könnten. Da eval() auch nur eine Funktion ist, müsste sich der dort enthaltene String auch (dynamisch) ändern können, oder? Wie gesagt, ich vermute es nur und lass' mich da auch gern belehren, da ich selbst noch nie eval() benutzt habe.

weiterhin schönen abend...

In welcher Zeitzone lebst Du?

Mit freundlichem Gruß
Micha

[Struppi]

document.getElementsByTagName("p")[0].onclick=eval('function(){tue(this);};');

  
Das ist wieder mal ein Beispiel das eval in den seltensten Fällen sinnvoll eingesetzt wird.  
  
Struppi.

-- 
[Javascript ist toll](http://javascript.jstruebig.de/) (Perl auch!)

[.nils.]

Hallo, und guten Abend,

Das ist wieder mal ein Beispiel das eval in den seltensten Fällen sinnvoll eingesetzt wird.

Ich lese einen String ein, der Html-code enthält, parse diesen, und erzeuge als Rückgabewert ein Fragment aus Objekten, die dann in den DOM-Baum eingehängt werden können.
Dabei will ich Teile wie
'onmouseover=tuediesunddas("a", this, "b")'
in
(element).onmouseover=function(){tuediesunddas("a", this, "b");};
umwandeln (wie von molily empfohlen). Wie soll das sonst gehen, Struppi?

Gruß, Nils

[Struppi]

Dabei will ich Teile wie
'onmouseover=tuediesunddas("a", this, "b")'
in
(element).onmouseover=function(){tuediesunddas("a", this, "b");};
umwandeln (wie von molily empfohlen). Wie soll das sonst gehen, Struppi?

Das könnte eine Lösung sein und sehe ich durchaus als eine Möglichkeit der Nutzung von eval, ist aber trotzdem nicht nötig.

var str = 'tuediesunddas("a", this, "b")';
(element).onmouseover= new Funktion( '', str);

Struppi.

[.nils.]

Hallo,

var str = 'tuediesunddas("a", this, "b")';
(element).onmouseover= new Funktion( '', str);

Function, Tippfehler

Toll, Struppi! Da bin ich _überhaupt_ nicht draufgekommen. Hab mich immer gefragt, wozu ist das gut, dieses Function-objekt...

Du hasts echt drauf in javascript, ey ... :-)

Gruß und danke, Nils

[globe]

n'abend,

ich verstehe jetzt erst, was du da eigentlich machen willst... toll, nicht?

Dabei will ich Teile wie
'onmouseover=tuediesunddas("a", this, "b")'
in
(element).onmouseover=function(){tuediesunddas("a", this, "b");};

und warum machst du dir das Leben dann so kompliziert?
Ich würde dir empfehlen dich "mal kurz" mit Organisation von Javascripten auseinanderzusetzen.

Wenn du dann über das Closures-Konzept gestolpert bist und dadurch anonyme Funktionen und ihre eigentliche Macht verstanden hast, erkennst du auch die Einfachheit des Folgenden:

element.onmouseover = function(){  
  tuediesunddas("a", this, "b");  
};

Wenn du dann noch weiter gehst und tuediesunddas() entsprechend ver-OOP-zifierst, kommst du zu dem schluss, dass this meist weggelassen werden kann, und "a" und "b" sich evtl. auch zu neuen Attributen des Elements eignen würden, etwa so:

element.alter = 55; /* irgendwelche werte */  
element.haarfarbe = 'lilablassblau'; /* irgendwelche werte */  
element.onclick = elemClickHandler; /* funktions-objekt direkt als handler zuweisen */  
  
/* handler, welcher dem objekt direkt zugewiesen werden muss */  
var elemClickHandler = function(){  
  alert( 'Haare: ' + this.haarfabre + ' Alter: ' + 55 );  
};

Schlussendlich ist das nur noch eine Frage deiner Architektur. Ich meine jedoch erkannt zu haben, dass du eval() hier für eine Sache nutzen möchtest, die der Nutzung eval()s gar nicht bedarf.

weiterhin schönen abend...

[.nils.]

Hallo,

Toll, dafür gibts ein fachlich hilfreich. Ich habe den Artikel tatsächlich schon ein paar mal gelesen und finde ihn sehr gut. Aber es scheint, das mir alle Feinheiten noch nicht aufgegangen sind. Muß sich wohl noch ein wenig setzen..

Ich kann also den Elementen des DOM-Baumes, body, form, h1, p, was auch immer, beliebig viele eigene Eigenschaften (also wohl auch z.B. weitere Objekte mit ihrerseits Eigenschaften?) zuordnen?
Ich könnte also quasi per javascript aus einem einfachem Html-Dokument eine Riesige -temporäre- Objektdatenbank erstellen...

Cool. Das ist es. Das ist der Schlüssel. Dann macht es auch mit dem "Funktionsaufruf" ohne() Sinn, weil ich ja keine Parameter brauche, mööönsch...
Pling! Aha-erlebnis...

_Vielen_ Dank, ich glaube, jetzt hab ichs kapiert. Geniales Konzept.

Gruß, Nils

[globe]

n'abend,

Ich kann also den Elementen des DOM-Baumes, body, form, h1, p, was auch immer, beliebig viele eigene Eigenschaften (also wohl auch z.B. weitere Objekte mit ihrerseits Eigenschaften?) zuordnen?
Ich könnte also quasi per javascript aus einem einfachem Html-Dokument eine Riesige -temporäre- Objektdatenbank erstellen...

Da gibts halt den großen Unterschied, der nennt sich DOM.
Die HTML und XHTML spezifikationen erlauben bei bestimmten Elementen nur bestimmte Attribute. Das ist in Ordnung so.
DOM hingegen arbeitet nicht auf Ebene von HTML. mittels des DOM kannst du Attribute an deine Elemente hängen, wie es dir beliebt.

Es ist übrigens keine Seltenheit, dass die "Nutzung von parametrisierten Funktionen" über Objekt-eigene Methoden und Objekt-eigene Attribute umgangen wird. In manchen Anwendungen macht das sehr viel Sinn (in anderen wiederum gar keinen...)

Cool. Das ist es. Das ist der Schlüssel. Dann macht es auch mit dem "Funktionsaufruf" ohne() Sinn, weil ich ja keine Parameter brauche, mööönsch...

Sehr lustig wird das übrigens, wenn du Elemente als Attribute anderer Elemente registrierst. Je nach Anwendung bloatet man dadurch zwar ein wenig, spart sich aber häufige "Lookups" irgendwelcher Elemente im DOM-Baum. Es ist schliesslich schnurz, ob du einen String, Integer, ein Element deiner Seite oder eine Funktion als Attribut an irgendein Objekt hängst.

weiterhin schönen abend...

[.nils.]

Hallo,

Sehr lustig wird das übrigens, wenn du Elemente als Attribute anderer Elemente registrierst. Je nach Anwendung bloatet man dadurch zwar ein wenig, spart sich aber häufige "Lookups" irgendwelcher Elemente im DOM-Baum. Es ist schliesslich schnurz, ob du einen String, Integer, ein Element deiner Seite oder eine Funktion als Attribut an irgendein Objekt hängst.

In meiner Schachapplikation kann ich das gut gebrauchen in der Notation: Zu welchen/von welchen Stellungen führt/kommt der Zug, kam die Stellung schon vor und wo (Zugwiederholung), etc.

bloatet? Vermutlich: verbraucht Anfangs mehr Zeit ?!

Gruß, Nils

[globe]

n'abend,

bloatet? Vermutlich: verbraucht Anfangs mehr Zeit ?!

eher mehr Speicher, als Zeit. Du kaufst dir Zeitersparnis (entfallen von Lookups im DOM-Baum) mittels weiterer Referenzen (Speicherbelegung).

weiterhin schönen abend...

[Steffen Weber]

Tag,

Verständnisfrage:

document.getElementsByTagName("p")[0].onclick=eval('function(){tue(this);};');

> Wird die zeitfressende Funktion eval() jedesmal neu bei Klick auf den Textabsatz ausgewertet, oder nur einmal und das Ergebnis wird zwischengespeichert?  
  
Die Function "eval" wird in diesem Beispiel definitv nur einmal ausgeführt. Es wird da aber nix zwischengespeichert. Du weist ja nicht das "eval" dem onlick zu, sondern den \_Returnwert\_ von "eval".  
  
Grüße,  
Steffen.

[.nils.]

Hallo,

Die Function "eval" wird in diesem Beispiel definitv nur einmal ausgeführt. (...)

Natürlich jedes Mal(...)

bist du dir da sicher? (...)

Nein, ich habe es nur vermutet.(...)

Könnt ihr euch bitte einigen? Sonst erkenne ich euch den Expertenstatus ab und den Labertaschenstatus an... :-D

Gruß, Nils

[globe]

n'abend,

Könnt ihr euch bitte einigen?

Einigkeit und Recht und Freiheit?

Sonst erkenne ich euch den Expertenstatus ab und den Labertaschenstatus an... :-D

Wäre mir nicht bewusst einen derartigen Status anerkannt bekommen zu haben, noch diesen gewünscht zu haben. ;)

in deinem Beispiel:

document.getElementsByTagName("p")[0].onclick = eval('function(){tue(this);};');

wird eval() nur ein mal ausgeführt. Dem onclick-handler wird das Ergebnis (der Return-Wert) des eval()-uierten Strings zugewiesen.

Ein kleiner Test um dein Vorhaben etwas genauer unter die Lupe zu nehmen zeigte aber, dass eval() hier kein Funktions-Objekt zurück gibt. Siehe:

<html>  
<head>  
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">  
<title>New document</title>  
<script type="text/javascript">

window.onload = function()  
{  
 var h = document.getElementById( 'klicker' );  
 h.onclick = eval('function(){ alert("eval-fkt-executed") }; alert("eval executed")');  
 alert( 'alerting eval: ' + h.onclick );  
}

</script>  
</head>  
<body>  
<h1 id="klicker">klick mich</h1>  
</body>  
</html>

weiterhin schönen abend...

[.nils.]

Hallo,

Wäre mir nicht bewusst einen derartigen Status anerkannt bekommen zu haben, noch diesen gewünscht zu haben. ;)

Oh, wie bescheiden :-)

in deinem Beispiel:

document.getElementsByTagName("p")[0].onclick = eval('function(){tue(this);};');

wird eval() nur ein mal ausgeführt. Dem onclick-handler wird das Ergebnis (der Return-Wert) des eval()-uierten Strings zugewiesen.

Ich glaube selbst auch, das es sich so verhält, bin mir aber nicht sicher.

Ein kleiner Test um dein Vorhaben etwas genauer unter die Lupe zu nehmen zeigte aber, dass eval() hier kein Funktions-Objekt zurück gibt. Siehe:

<html>

<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<title>New document</title>
<script type="text/javascript">

>   
> ~~~javascript

window.onload = function()  

> {  
>  var h = document.getElementById( 'klicker' );  
>  h.onclick = eval('function(){ alert("eval-fkt-executed") }; alert("eval executed")');  
>  alert( 'alerting eval: ' + h.onclick );  
> }

</script>

</head>
<body>
<h1 id="klicker">klick mich</h1>
</body>
</html>

  
aber:  
~~~html
  
<html><head>  
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">  
<title>New document</title>  
  
<script type="text/javascript">  

~~~~~~javascript
  
window.onload = function()  
{  
 var h = document.getElementById( 'klicker' );  
 h.onclick = eval('function(){ alert("eval-fkt-executed") };');  
 alert( 'alerting eval: ' + h.onclick );  
}  

~~~~~~html
  
</script>  
  
</head><body>  
<h1 id="klicker">klick mich</h1>  
</body></html>  

ohne die zweite Zeile im eval()-Ausdruck funktioniert es und gibt den Quellcode der Funktion wieder.

(Was das mit ner referenz auf eine Funktion zu tun hat ist mir eher schleierhaft. Dachte immer, Referenzen wären irgendwelche Zahlenreihenfolgen, mit denen nur der Computer was anfangen kann und die auf Objekte verweisen...)

weiterhin schönen abend...

dito und
Gruß, Nils

[globe]

n'abend,

Ich glaube selbst auch, das es sich so verhält, bin mir aber nicht sicher.

Du glaubst richtig.

(Was das mit ner referenz auf eine Funktion zu tun hat ist mir eher schleierhaft. Dachte immer, Referenzen wären irgendwelche Zahlenreihenfolgen, mit denen nur der Computer was anfangen kann und die auf Objekte verweisen...)

In Javascript ist _alles_ ein Objekt. Es gibt nur Objekte. Keine Primitives (oder sonstige Halblebigkeiten). Und was deine Variablen sind ist klar: nichts anderes als eine Referenz auf ein Objekt.

function xyz(){ alert('foo'); };  
var abc = xyz;  
abc();

sowie

var obj = new Object();  
obj.info = function(){ alert( this.variable ); };  
obj.variable = "hallo welt";  
  
var abc = obj;  
abc.info();  
  
obj.variable = "wir werden alle sterben";  
abc.info();

sollten das Verhalten (der Referenzen) verdeutlichen.

weiterhin schönen abend...

[.nils.]

Hallo,

Schöne Beispiele, aber ich hatte was anderes gemeint, nämlich diese Ausdrucksweise:

  
// abc() ist eine Funktion.  
(element).onclick = abc;             //geht  
(element).onclick = abc();           //geht nicht  
(element).onclick = abc(p1, p2, p3); //geht nicht  

ich dachte ich hätte irgendwo (auf Struppis Seite?) gelesen, ohne die Klammern, wäre es eine Referenz auf den Funktionsinhalt, nicht auf den eigentlichen Rückgabewert der Funktion. Das checke ich noch nicht so recht.
Wieso ist das im Javascript-code so komisch geregelt, im Html-Quelltext geht es aber?

Gruß, Nils

[molily]

Hallo,

// abc() ist eine Funktion.
(element).onclick = abc;             //geht
(element).onclick = abc();           //geht nicht
(element).onclick = abc(p1, p2, p3); //geht nicht

>   
> ich dachte ich hätte irgendwo (auf Struppis Seite?) gelesen, ohne die Klammern, wäre es eine Referenz auf den Funktionsinhalt, nicht auf den eigentlichen Rückgabewert der Funktion. Das checke ich noch nicht so recht.  
  
Ich verstehe deine Frage nicht recht. Dass »abc()« die Funktion ausführt (sog. Call-Operator), während die reine Nennung von »abc« nur dazu führt, dass in diesem Ausdruck das Funktionsobjekt eingesetzt wird, wurde ja schon erklärt.  
  
Funktionen sind wie gesagt Objekte, Objekte liegen im Speicher. Um auf sie später zugreien zu können, speichert man sie unter (erst einmal) einem Namen. Ein Objekt kann aber auch unter mehreren Namen gespeichert werden, das hat globes Beispiel ja gezeigt. Und wenn ein Objekt unter einem weiteren Namen (d.h. in einer »Variablen« oder in einer Objekteigenschaft) gespeichert wird, wird nur ein weiterer Alias, eben eine Referenz erzeugt. All diese Namen zeigen auf dasselbe Objekt.  
  
Wenn man schreibt  
element.onclick = abc;  
dann wird in der Eigenschaft onclick keine Kopie (kein Klon, keine Verdoppelung) des Funktionsobjekts gespeichert, sondern nur eine Referenz. Beide Namen verweisen auf dieselbe Speicherstelle, auf dasselbe Objekt.  
  

> Wieso ist das im Javascript-code so komisch geregelt, im Html-Quelltext geht es aber?  
  
Wie meinst du das?  
  
Mathias

[.nils.]

Hallo,

Ich verstehe deine Frage nicht recht. Dass »abc()« die Funktion ausführt (sog. Call-Operator), während die reine Nennung von »abc« nur dazu führt, dass in diesem Ausdruck das Funktionsobjekt eingesetzt wird, wurde ja schon erklärt.

also, ich habe es mal getestet.
Wenn ich eine funktion abc() habe und dann alert(abc) ausführe, kriege ich den Code der Funktion augegeben. Wenn ich andere Objekte ausgebe, bekomme ich meist "[Object]" geliefert. Liege ich da richtig, das es sich beim Ausgeben des Funktionscodes um den Prototyp/(sozusagen eine "Klasse") handelt und sonst um eine Objektinstanz? Diese Frage wäre mir sehr wichtig, weißt Du eine Antwort?

Funktionen sind wie gesagt Objekte, Objekte liegen im Speicher. Um auf sie später zugreien zu können, speichert man sie unter (erst einmal) einem Namen. Ein Objekt kann aber auch unter mehreren Namen gespeichert werden, das hat globes Beispiel ja gezeigt. Und wenn ein Objekt unter einem weiteren Namen (d.h. in einer »Variablen« oder in einer Objekteigenschaft) gespeichert wird, wird nur ein weiterer Alias, eben eine Referenz erzeugt. All diese Namen zeigen auf dasselbe Objekt.

Das ist mir glasklar.

Wenn man schreibt
element.onclick = abc;
dann wird in der Eigenschaft onclick keine Kopie (kein Klon, keine Verdoppelung) des Funktionsobjekts gespeichert, sondern nur eine Referenz. Beide Namen verweisen auf dieselbe Speicherstelle, auf dasselbe Objekt.

Glasklar.

Also ist ein Methodenaufruf kein "atomares" Element der Programmlogik (wenn man mal von den einzelnen Buchstaben absieht) sondern er besteht aus einer Variable (in diesem Fall "abc") die ein (prototypisches?) Funktionsobjekt (genauer eine Referenz auf ein Funktionsobjekt) enthält.
Außerdem einem nachgeordneten Operator "()", der bewerkstelligt, das das Funktionsobjekt/(der Quellcode), auf das die vorangestellte Variable zeigt, ausgeführt wird.

Ehrlich gesagt (wenn das stimmt), finde ich das so elementar wichtig, das ich es mir in Selfhtml gewünscht hätte. Ich habe bisher immer zwischen Eigenschaften und Methoden unterschieden. Wenn es so ist, dann gibt es nur Eigenschaften. Und der Methodenaufruf ist nur eine spezielle, auf eine Eigenschaft angewandte Operation.

Wieso ist das im Javascript-code so komisch geregelt, im Html-Quelltext geht es aber?

Wie meinst du das?

Im Html-Quelltext:

  
<body onload="tuedies(parameterA, parameterB, parameterC)">... <!-- Das geht, direkter Methodenaufruf -->  

Im Javascript-Code:

  
window.onload=tuedies(parameterA, parameterB, parameterC);.../* Das geht nicht, warum? Warum kann man nicht auch hier direkt eine Funktion aufrufen? */  
window.onload=tuedies;.../* Das geht wiederum */  

Das meine ich. Ist mir aber mittlerweile nicht mehr so wichtig, weil ich wenigstens verstehen beginne, was es ist. Dann ist das Warum nicht so wichtig (Obwohl es seltsam ist).

p.s.
@Selfhtml:
"Beachten Sie, dass hier nur der Funktionsname stehen darf, kein Funktionsaufruf mit runden Klammern dahinter."

Das befriedigt mich _ganz und gar_ nicht. ;-)

Gruß, Nils

[globe]

n'abend,

<body onload="tuedies(parameterA, parameterB, parameterC)">... <!-- Das geht, direkter Methodenaufruf -->

du solltest dir klar machen, dass der inhalt des handlers, den du im HTML angegeben hast, "in einer anonymen Funktion gekapselt wird".

Sprich dein HTML von oben in Javascript übersetzt sieht dann etwa so aus:

body.onload = function(){  
  tuedies( parameterA, parameterB, parameterC);  
};

window.onload=tuedies(parameterA, parameterB, parameterC);.../* Das geht nicht, warum? Warum kann man nicht auch hier direkt eine Funktion aufrufen? */

Das *KANN NICHT* den gewünschten Effekt haben. window.onload wird hier _das Ergebnis_ des Funktions_aufrufs_ von tuedies übergeben. NICHT die Funktion selbst.

window.onload = function(){  
  tuedies( parameterA, parameterB, parameterC);  
};

stellt sicher, dass deine Funktion tuedies() mit den gewünschten Parametern aufgerufen wird.

window.onload=tuedies;.../* Das geht wiederum */

Das hingegen funktioniert (nur ohne Parameter), weil du dem onload-Handler hier ein Funktions-Objekt zuweist. Analog zum Obigen hätte man auch folgendes notieren können:

window.onload = function(){  
  tuedies();  
};

Das befriedigt mich _ganz und gar_ nicht. ;-)

Das befriedigt dich nur noch nicht, weil du noch nicht verstanden hast, dass sich dein Problem in Nichts auflöst, sobald du "anonyme Funktionen" verstanden hast.

weiterhin schönen abend...

[molily]

Hallo,

Wenn ich eine funktion abc() habe und dann alert(abc) ausführe, kriege ich den Code der Funktion augegeben. Wenn ich andere Objekte ausgebe, bekomme ich meist "[Object]" geliefert. Liege ich da richtig, das es sich beim Ausgeben des Funktionscodes um den Prototyp/(sozusagen eine "Klasse") handelt und sonst um eine Objektinstanz? Diese Frage wäre mir sehr wichtig, weißt Du eine Antwort?

Die Frage verstehe ich nicht. Weder noch, würde ich antworten.

Beim »Ausgeben« wird ein Objekt zuerst über die Methode toString() in einen String umgewandelt. Funktionsobjekte werden eben so in einen String umgewandelt: »function ([Parameter]) { [Funktionskörper] }« (Also syntaktisch wieder eine Function-Expression.) Das ist eine Sonderregel für Funktionsobjekte - andere Objekte haben eigene toString-Methoden. »[object Object]« kommt z.B. bei ganz allgemeinen Objekten heraus.

Mit Prototypen und Instanzen hat das erstmal nichts zu tun (wobei natürlich die Methode toString des Function-Prototyps die des Über-Prototyps Object überschreibt.)

Also ist ein Methodenaufruf kein "atomares" Element der Programmlogik (wenn man mal von den einzelnen Buchstaben absieht)

Richtig.

sondern er besteht aus einer Variable (in diesem Fall "abc") die ein (prototypisches?) Funktionsobjekt (genauer eine Referenz auf ein Funktionsobjekt) enthält.

Ja, ein Funktionsaufruf ist auch nur ein Ausdruck: ein Identifier wird mit einem Call-Operator zusammengebracht. Daraus folgt, dass man den Identifier auch ohne diesen Operator benutzen kann, um auf das Funktionsobjekt zugreifen zu können.

Wie du hier wieder auf Prototypen kommst, verstehe ich nicht.

Außerdem einem nachgeordneten Operator "()", der bewerkstelligt, das das Funktionsobjekt/(der Quellcode), auf das die vorangestellte Variable zeigt, ausgeführt wird.

Genau.

Ich habe bisher immer zwischen Eigenschaften und Methoden unterschieden. Wenn es so ist, dann gibt es nur Eigenschaften.

Das ist korrekt. Funktionen/Methoden sind Eigenschaften wie alle anderen auch, sie haben nur einen bestimmten Typ.

"Beachten Sie, dass hier nur der Funktionsname stehen darf, kein Funktionsaufruf mit runden Klammern dahinter."

Das befriedigt mich _ganz und gar_ nicht. ;-)

Die Sicht, dass Funktionen auch nur Objekte wie alle anderen auch sind, ist in SELFHTML nicht beachtet, das stimmt.

Mathias

[molily]

Hallo,

In Javascript ist _alles_ ein Objekt. Es gibt nur Objekte. Keine Primitives (oder sonstige Halblebigkeiten).

Nein! Natürlich gibt es Primitives in JavaScript (ECMAScript). Wenn ich Number-, String- oder Boolean-Literale notiere, erzeuge ich Primitives. Die werden allerdings (nur für den Kontext der jeweiligen Expression) automatisch in Objekte umgewandelt, sofern es der Kontext erfordert.

Also, nicht alle Variablen sind Objekte. Die Unterscheidung zwischen Objekten und Primitives in JavaScript ist sogar sehr wichtig:

• Objekte haben eine »eigene Identität«, sie sind nur mit sich selbst identisch (Identitätsoperator ===) und auch nur mit sich selbst gleich (Vergleichsoperator ==).
• Primitives haben keine »eigene Identität«, sie sind mit anderen Primitives gleichen Wertes gleich (==) und bei gleichem (Primitive-)Typ auch identisch (===).

(Wenn ich das jetzt richtig in Erinnerung habe.)

Aus der »Identität« folgt:

• Objekte werden immer referenziert. (Beim Speichern eines Objektes wird nur der Zeiger auf eine Speicherstelle unter einem Namen abgelegt. Speichert man das Objekt unter einem anderen Namen, zeigen beide Namen auf dieselbe Speicherstelle.)
• Primitives werden immer kopiert.

Was dein Beispiel angeht, so lässt sich das auch zeigen:

var obj = new Object();  
obj.info = function(){ alert( this.variable ); };  
obj.variable = "hallo welt";

obj.variable ist hier ein Primitive, kein Objekt:

var neueVar = obj.variable;  
neueVar = "neuer Wert";  
obj.info(); // bleibt »hallo welt«

Bei der Zuweisung wurde hier also kopiert, nicht referenziert. Denn ein String-Literal erzeugt immer ein Primitive. String-Objekte kann man hingegen z.B. so erzeugen: new String("bla"). Wenn man die kopieren will, wird eine Referenz angelegt.

Mathias

[globe]

n'abend,

na wenigstens braucht man nicht so dumm sterben, wie man geboren wurde.
Danke für die Erläuterung.

weiterhin schönen abend...