JavaScript - variabler Funktionsname?

Hallo!
Es klingt nach einer Kleinigkeit, aber ich habe keine Ahnung, wie es geht: Ich will in JavaScript eine Funktion aufrufen - Jedoch soll der Funktionsname variabel sein

Hmm, soweit ich weiß, geht das net!

Schade, das wäre in meinem Fall sehr praktisch
BTW: Gibt es in Javascript etwas, das dem Folgendem in PHP entspricht?

$test = 'hallo';
$name = 'test';
$var = $$name;
echo($var); // Gibt 'hallo' aus

schau dir mal eval an.

thx, hätte ich wohl auch selber finden können xD

JavaScript - variabler Funktionsname?

Hi
Vielleicht können wir dir einen anderen Lösungsvorschlag geben, wenn du uns sagst, was du machen willst bzw. was das bringen soll.
Lg Kudi

@kudi
eval() scheint ihm doch zu helfen.
für alle die zu faul sind:
eval("mach_was();");
führt die Funktion mach_was() aus. Generell: eval interpretiert den übergebenen String (Anführungszeichen sind nötig!) als Javascript-Code

Original von Fornax
Schade, das wäre in meinem Fall sehr praktisch
BTW: Gibt es in Javascript etwas, das dem Folgendem in PHP entspricht?

$test = 'hallo';
$name = 'test';
$var = $$name;
echo($var); // Gibt 'hallo' aus

Also Vars grundsätzlich erstmal so:

So setzt man Vars und überschreibt sie mit anderen.
Aber ich sehe gerade es geht um einen variablen Funktionsnamen *g*
Verstehe aber nicht ganz worauf Du hinaus willst?
Hier eval

wenn du dein Javascript per php ausgibts:

$name = $HTTP_POST_VARS[name];

echo "
function $name(){
// mach was
}
";
?>
allerdings muss dein Funktionsaufruf genauso gestaltet werden, also $name speichern

Du kannst zum Beispiel a) eine anonyme Funktion zur Hife nehmen oder b) einfach die Funktionsaufrufe umlenken.. letzteres geht aber nur Parameterlos.
Beispiel:

function func1(a, b, c){
alert("some shit"+a+b+c);
}

function func2(x, y) {
alert("holy shit"+x+y);
}

function foo() {
alert("foooo");
}

// case 1
meinefunktion = foo;
alert("jetzt fall 1");
meinefunktion();

// case 2
meinefunktion = function() {
func1(1,2,3);
func2(6,5);
}
alert("jetzt fall 2");
meinefunktion();

// case 3
meinefunktion = function(q,w,e,r,t) {
func1(q,w,e);
func2(r,t);
}
alert("jetzt fall 3");
meinefunktion(9,8,7,6,5);

omg, ich hatte es dank dem Untötbaren schon gefunden
einfach folgendes:
zu 1)

var function_name = 'my_function();';

eval(function_name);
zu 2)

var test = 'hallo';

var name = 'test';
alert('var ergebnis = ' + name + ';');
(Oder so, ich hab das letzte nicht ausprobiert, da ich es noch nicht brauchte)

Mich würde ja mal interessieren, wofür du die Variabilität des Funktionsnamen brauchst? Ich kenne den Code nicht, aber mit sowas kann man schnell in Teufels Küche kommen, wenn man Code-Strings zum Parsen an eval() übergibt. Nur so als kleinen, gutgemeinten Hinweis...
Lässt sich das Problem nicht mit einer Fallunterscheidung a la if/else lösen?

Es kann manchmal hilfreich sein.. aber wie gesagt, ich würde immer ohne eval arbeiten.. nur im äußersten Notfall. Was man da parst, kommt schließlich irgendwie von "aussen".. und ist damit potenziell unsicher.
Hier ist der eval-Inhalt zwar bekannt.. aber aus o.g. Gründen eigentlich unnötig.

Ich habe mich jetzt endlich an AJAX herangetraut. Je nach Anwendungszweck müssen die Daten anderst verarbeitet werden - und da es ja asynchron (omg, wie schreibt man das ) ist, wird die verarbeitende Funktion erst nach einer gewissen Zeit aufgerufen - in der Zeit könnte der Benutzer schon eine zweite Anforderung (für einen anderen Bereich) gesendet haben. Somit fällt eine globale Variable zum Eventhandling weg. Indem ich gleich beim Aufruf den Funktionsname übergebe, habe ich das Problem nicht.

Wie gesagt, anonyme Funktionen. Braucht man auch, wenn man richtige Objekte in JavaScript baut.

Original von knalli
Es kann manchmal hilfreich sein.. aber wie gesagt, ich würde immer ohne eval arbeiten.. nur im äußersten Notfall. Was man da parst, kommt schließlich irgendwie von "aussen".. und ist damit potenziell unsicher.
Hier ist der eval-Inhalt zwar bekannt.. aber aus o.g. Gründen eigentlich unnötig.

Eval ist doch nicht gefährlich, es kommt nur darauf an was ma ndamit macht.

Ich habe mich jetzt endlich an AJAX herangetraut.

Dann willkommen im Club.

wird die verarbeitende Funktion erst nach einer gewissen Zeit aufgerufen

Wieso denn das? Bei guter Verbindung schaffst du fast einen komplett neuen Request pro Sekunde.

Original von Klaus

wird die verarbeitende Funktion erst nach einer gewissen Zeit aufgerufen

Wieso denn das? Bei guter Verbindung schaffst du fast einen komplett neuen Request pro Sekunde.
"wieso denn das?" kannst du fragen, wenn du ein spiel nur für dich programmierst. wenn das spiel aber jeder und vor allem überall spielen können soll, muss man solche sachen berücksichtigen. du weisst nie, mit was der spieler unterwegs ist.

Original von Fornax
Ich habe mich jetzt endlich an AJAX herangetraut. Je nach Anwendungszweck müssen die Daten anderst verarbeitet werden - und da es ja asynchron (omg, wie schreibt man das ) ist, wird die verarbeitende Funktion erst nach einer gewissen Zeit aufgerufen - in der Zeit könnte der Benutzer schon eine zweite Anforderung (für einen anderen Bereich) gesendet haben. Somit fällt eine globale Variable zum Eventhandling weg. Indem ich gleich beim Aufruf den Funktionsname übergebe, habe ich das Problem nicht.

Das macht man in der Regel bereits beim starten einer AJAX Anfrage indem man eine Callbackfunktion für eben diesen Aufruf angibt. Weitere httprequests haben auch wieder ihre eigene Callback Funktion. Wozu hier noch ein weiteres Verfahren benötigt wird ist mir unklar.

Original von blum
[...]
"wieso denn das?" kannst du fragen, wenn du ein spiel nur für dich programmierst. wenn das spiel aber jeder und vor allem überall spielen können soll, muss man solche sachen berücksichtigen. du weisst nie, mit was der spieler unterwegs ist.

Erstens das - und zweitens kann es schon etwas dauern, bis die angeforterte Seite vom Apache geliefert ist.

Original von Flint

[...]
Das macht man in der Regel bereits beim starten einer AJAX Anfrage indem man eine Callbackfunktion für eben diesen Aufruf angibt.
Genau So mache ich es auch
Und hier mal für alle:

// AJAX

var req;
function loadXMLDoc(url, todo) {
req = false;
// branch for native XMLHttpRequest object
if(window.XMLHttpRequest) {
try {
req = new XMLHttpRequest();
} catch(e) {
req = false;
}
// branch for IE/Windows ActiveX version
} else if(window.ActiveXObject) {
try {
req = new ActiveXObject("Msxml2.XMLHTTP");
} catch(e) {
try {
req = new ActiveXObject("Microsoft.XMLHTTP");
} catch(e) {
req = false;
}
}
}

if(req) {
req.onreadystatechange = function (){
// only if req shows "loaded"
if (req.readyState == 4) {
// only if "OK"
if (req.status == 200) {
//alert(req.responseText);
eval(todo);
} else {
alert("There was a problem retrieving the XML data:\n" +
req.statusText);
}
}
};
req.open("GET", url, true);
req.send(null);
}
else{
alert('AJAX is not supported!');
}
}
// End
Und der Aufruf geht dann so:

function last_fm_reload(){
loadXMLDoc(url, 'last_fm_schreiben(req.responseText)');
}
(Das wird ausgefürt, wenn man wo drauf klickt)

in der Zeit könnte der Benutzer schon eine zweite Anforderung (für einen anderen Bereich) gesendet haben. Somit fällt eine globale Variable zum Eventhandling weg. Indem ich gleich beim Aufruf den Funktionsname übergebe, habe ich das Problem nicht.

Zwei Dinge: Soweit ich weiss, gibt es Probleme dabei, wenn man von einem Client aus zwei oder mehr AJAX-Requests an den Server schickt. Ich würde das auf jeden Fall verhindern, dass mehrere Requests gleichzeitig verschickt werden, alleine schon, wenn jemand mal aus Versehen mehrfach eine Aktion startet (z.B. Rohstoffe kaufen/verkaufen), das könnte dann ärgerlich werden.
Ausserdem funktioniert dein Script dann sowieso nicht, weil du die Variable "req" global definiert hast, diese wird dann bei jedem neuen Request neu mit dem XMLHTTPRequest-Objekt belegt und die alte Anfrage ist verloren...

hm, da hast du recht (in beiden Punkten). Darüber habe ich noch garnicht nachgedacht, danke .
Ich werd dann mal ne Lösung erarbeiten, ich denke, ich mache ein globales Array (oder ennnt sich das Objekt?). In das kommen die angeforderten Requests rein, und werden abgearbeitet. Mal gucken, wie's wird. Und wenns nichts wird, habe ich wenigstens wieder was dazugelernt.

Original von Störti

in der Zeit könnte der Benutzer schon eine zweite Anforderung (für einen anderen Bereich) gesendet haben. Somit fällt eine globale Variable zum Eventhandling weg. Indem ich gleich beim Aufruf den Funktionsname übergebe, habe ich das Problem nicht.

Zwei Dinge: Soweit ich weiss, gibt es Probleme dabei, wenn man von einem Client aus zwei oder mehr AJAX-Requests an den Server schickt. Ich würde das auf jeden Fall verhindern, dass mehrere Requests gleichzeitig verschickt werden, alleine schon, wenn jemand mal aus Versehen mehrfach eine Aktion startet (z.B. Rohstoffe kaufen/verkaufen), das könnte dann ärgerlich werden.
[...]
Genau richtig. Anstatt alle Anfragen in eine Schleife zu packen solltest du neue Anfragen erstmal blocken. Eine gute Idee ist es eine Grafik o.ä. anzuzeigen, die einen Ladezustand signalisiert. Damit dies nicht ewig dauern kann auch ein Timeout nützlich sein.

Daran habe ich auch gedacht:
laden ...
(Sieht auf schwarzem Hintergrund besser aus)

Anfangs habe ich auch ein Array gehabt, in dem dann die Request-Objekte lagen, dann habe ich mir gedacht, scheiss drauf, und kontrolliere jetzt immer, ob schon ein Request aktiv ist und auf die Antwort vom Server wartet. Wenn das so ist, werden alle neuen Anfragen ignoriert, ob man also 10x auf einen Link klickt oder nur einmal ist völlig egal, die letzten 9 Klicks sind komplett ohne Funktion (sie werden auch nicht auf eine Warteliste gesetzt).
Das macht das Ganze wesentlich unkomplizierter und vor allem bleiben die bisherigen Requests auch nicht alle im Speicher. Wenn du die Requests nämlich immer hinten an ein Array dran hängst, dann hast du nach einer Weile einen grossen Haufen von Requests, die fertig und unbenutzt im Speicher liegen (und ab 100-200 Requests ist der Speicherverbrauch zwar noch nicht sehr gross, aber trotzem unnötig viel).

loadXMLDoc(url, 'last_fm_schreiben(req.responseText)');

Das ist doch wohl ein schlechter Scherz.. entweder XML oder nicht.. aber so ein Pseudo ist Nonsense!
In JS ist alles ein Objekt.. also sowohl das Arrayaobjekt (zB kann man ja neue prototypes in das Objekt Array anlegen um zB allen Array weitere Funktionen zu geben) als auch zB die "Funktion".

Der Witz an AJAX ist ja gerade das der Benutzer nicht auf immer auf alle Ergebnisse warten muß ^^
Wenn ihr nur eine Anfrage zulassen wollt und in der Wartezeit eingaben blockiert werden solltet ihr evtl nicht asyncron arbeiten. Man kann einen httprequest auch syncron ausführen, d.h. es wird gewartet bis die Antwort da ist.

nur bei synchroner abarbeitung hast du das problem: was passiert bei nem timeout? was passiert bei ner anfrage, die nciht wie gewünscht abläuft? so serverfehler wie 501, 404, 403 etc. pp.

Original von Drezil
nur bei synchroner abarbeitung hast du das problem: was passiert bei nem timeout? was passiert bei ner anfrage, die nciht wie gewünscht abläuft? so serverfehler wie 501, 404, 403 etc. pp.

Und was machst du mit deinen asynchronen Calls die in solche Fehler laufen ?
Es geht ja hier um die Idee einen httprequest asyncron aufzurufen und dann selbst was zu basteln was weitere Anfragen unterbindet, also das ganze dann wieder zu synchronisieren. Sehe nicht wie durch einen synchronen Call hier ein aufwendigeres Fehlerhandling erforderlich wird, ganz im Gegenteil sparst du dir noch das zusätzliche Fehlerhandling in einer selbstgestrickten synchronisation.
Im Allgemeinen wird dir so oder so nicht viel über bleiben als den httprequest Status zu prüfen oder halt ein Framework benutzen was dir da den größten Teil schon abnimmt.

Bei einem synchronen Call kannst du allerdings nicht den Status auslesen und evtl. anzeigen, du kannst nicht auf Timeouts reagieren und erhälst das Ergebnis später. Stattdessen wird das ganze Script blockiert. Das kann zwar manchmal von Nutzen sein, ist aber in der Regel nicht erforderlich. Ein Framework wäre in der Tat nicht schlecht. Also kennt jemand eine gutes?

Original von Flint
Und was machst du mit deinen asynchronen Calls die in solche Fehler laufen ?

Bei asynchonen läuft der rest des scriptes wenigstens weiter.
Man stelle sich mal vor, der Spieler muss erst 30 sec warten (weil voher kein timeout kommt), bis ein teil der seite aufgebaut ist.
Da ist es besser während der ladezeit überhaupt was anzuzeigen - auch wenn es nur ein loading ist..

...was aber auch wieder kein Alltagsrezept ist. Von Feature-zu-Feature unterschiedlich.
Ein Vollblende-Ladeschirm bei einer LiveSuggest-Anwendung würde mich zumindestens in den Wahnsinn bringen..