nicht angemeldet
JürgenB
Gunnar Bittersmann
molily
Gunnar Bittersmann
Struppi
Gunnar Bittersmann
Struppi
Der Martin
Struppi
hallo allerseits :)
ich möchte ein kleines quiz mit javascript schreiben aber es kommt immer die fehlermeldung "objekt erwartet (zeile 19 zeichen 1)" ... ich bin noch ein blutiger anfänger also verzeiht mir falls ganz arg grobe fehler drin sind ;). ich hoffe ihr könnt mir helfen!
function quiz()
{
x=-1
punkte=0
antwort= new Array("antwort1", "antwort2", "antwort3", "antwort4");
quest= new Array("frage1", "frage2", "frage3", "frage4");
do
{
x++;
answer=promt("quest[x]","")
if(answer==antwort[x])
{punkte++};
}
while (x<5);
if(punkte==0)
{alert("sehr schlecht")}
if(punkte==1)
{alert("schlecht")}
if(punkte==2)
{alert("ganz oke")}
if(punkte==3)
{alert("gut")}
if(punkte==4)
{alert("sehr gut")}
}
//-->
</script>
<noscript></noscript>
mfg sven :)
function quiz() {
x=-1
punkte=0
antwort= new Array("antwort1", "antwort2", "antwort3", "antwort4");
quest= new Array("frage1", "frage2", "frage3", "frage4");
Du hast also antwort[0] bis antwort[3]
do {
x++;
answer=promt("quest[x]","")
if(answer==antwort[x])
{punkte++};
}
while (x<5);
verlangst aber hier antwort[4]
mfg Beat
Hallo sven,
x=-1
do
{
x++;
answer=promt("quest[x]","")
if(answer==antwort[x])
{punkte++};
}
while (x<5);
x läuft von 0 bis 4, der maximale Index ist aber 3. Javascript zählt Arrayelemente von 0 bis Länge-1. Du solltest dir übrigens mal die for_Schleife ansehen. Im Zusammenhang mit Arrays eine ganz tolle Sache:
for(var x=0;x<antwort.length;x++) {
...
}
Gruß, Jürgen
Hallo,
ok, dann nehmen wir das ding mal auseinander ...
»» function quiz()
> {
> x=-1
warum machst du hier -1? Hast du eine Begründung dafür?
Eigentlich alles in Programmiersprachen fängt mit der 0 an. So auch deine zwei arrays.
»» punkte=0
> antwort= new Array("antwort1", "antwort2", "antwort3", "antwort4");
> quest= new Array("frage1", "frage2", "frage3", "frage4");
Hier definierst du zwei Arrays mit jeweils 4 Elementen.
> do
> {
> x++;
> answer=promt("quest[x]","")
> if(answer==antwort[x])
> {punkte++};
> }
> while (x<5);
Wenn du hier mal Computer spielst wird rauskommen:
do
{
x++; //x=0
answer=promt("quest[x]",""); //quest[0]
if(answer==antwort[x]); //antwort[0]
{
punkte++; // = 1
}
}
while (x<5); // 0 kleiner gleich 5 --> true --> nächster durchlauf.
Wenn wir das immer weiter machen, sind wir hier:
do
{
x++; //x=4
answer=promt("quest[x]",""); //quest[4]
if(answer==antwort[x]); //antwort[4]
{
punkte++;
}
}
while (x<5); // 4 kleiner 5 --> true --> nächster durchlauf.
Schon hier forderst du im Array ein 5tes Element, wo aber nur 4 gegeben sind. Die Zählung von Arrays beginnt aber ab 0. Also 0, 1, 2, 3. Mehr gibst du nicht vor.
Im Nächsten durchlauf hast du das gleiche Problem mit der 5.
//-->
Kommentare sind in der heutigen Welt nicht mehr nötig.
Zu deinem Codingstyle:
Achte auf richtige Einrückung. umso Besser wirst du später Fehler finden und beheben können.
Jede Verschachtelung und jeder Befehl müssen eingerückt werden.
Desweiteren bietet JavaScript zwar die Möglichkeit, die Semikolons am Ende eines Befehles wegzulassen, aber setze sie trotzdem. Sowas ist unsauber.
MfG. Christoph Ludwig
@@sven:
if(punkte==0)
{alert("sehr schlecht")}
if(punkte==1)
{alert("schlecht")}
if(punkte==2)
{alert("ganz oke")}
if(punkte==3)
{alert("gut")}
if(punkte==4)
{alert("sehr gut")}
Was zur Performanz: Wenn eine Bedingung erfüllt ist, müssen die nachfolgenden doch gar nicht mehr ausgewertet werden. Das sähe also so aus:
if (punkte == 0)
{
alert("sehr schlecht")
}
else if (punkte == 1)
{
alert("schlecht")
}
else if (punkte == 2)
{
alert("ganz oke")
}
else if (punkte == 3)
{
alert("gut")
}
else if (punkte == 4)
{
alert("sehr gut")
}
Wohlgemerkt sähe. Denn für mehrfache Abfragen derselben Variablen gibt es sie http://de.selfhtml.org/javascript/sprache/bedingt.htm#switch@title=switch-Anweisung:
switch (punkte)
{
case 0: alert("sehr schlecht"); break;
case 1: alert("schlecht"); break;
case 2: alert("ganz oke"); break;
case 3: alert("gut"); break;
case 4: alert("sehr gut"); break;
}
//-->
HTML-Auskommentierung hat in JavaScript-Code nichts zu suchen. Weg damit!
Live long and prosper,
Gunnar
switch (punkte)
{
case 0: alert("sehr schlecht"); break;
case 1: alert("schlecht"); break;
case 2: alert("ganz oke"); break;
case 3: alert("gut"); break;
case 4: alert("sehr gut"); break;
}
Wieso denn so umständlich? Bei case 4 muss der JS-Interpreter immer noch fünf Vergleiche machen. Besser direkt in einem Array nachschlagen:
var bewertungen = ["sehr schlecht", "schlecht", "ganz oke", "gut", "sehr gut"];
alert( bewertungen[punkte] );
Mathias
--
[JavaScript-Erweiterung für das SELFHTML-Forum](http://forum.de.selfhtml.org/js/doku/)
@@molily:
Besser direkt in einem Array nachschlagen:
Ja, da hätte ich auch gleich drauf kommen können. ;-)
Live long and prosper,
Gunnar
Tach,
Besser direkt in einem Array nachschlagen:
Ja, da hätte ich auch gleich drauf kommen können. ;-)
Ingrid muß man ihre fünf Minuten schon zugestehen ;-)
mfg
Woodfighter
ah das ist ne gute idee :) ... vielen dank
Wieso denn so umständlich? Bei case 4 muss der JS-Interpreter immer noch fünf Vergleiche machen. Besser direkt in einem Array nachschlagen:
Das besser ist ein Trugschluß (dem ich auch schon unterlag), die Implemetierung der Hashes scheint nicht sonderlich schnell zu sein, der Vergleich mit einem integer ist auf jeden Fall schneler, als die Suche nach einem String (dem key des Objektes).
<script type="text/javascript" src="[link:http://javascript.jstruebig.de/javascript/368/@title=benchmark.js]"></script>
<script type="text/javascript">
function rand (min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
var test = {
'case': function() {
var punkte = rand(0, 4);
var x;
switch (punkte)
{
case 0: x = "sehr schlecht"; break;
case 1: x = "schlecht"; break;
case 2: x = "ganz oke"; break;
case 3: x = "gut"; break;
case 4: x = "sehr gut"; break;
}
},
'object': function() {
var bewertungen = ["sehr schlecht", "schlecht", "ganz oke", "gut", "sehr gut"];
var punkte = rand(0, 4);
var x = bewertungen[punkte];
}
};
Benchmark(50000, test, function(t) {alert(t);});
Ergibt bei mir (FF 3/2.6GHz):
JS Benchmark. Anzahl der Durchläufe: 50.000 ----------------------------------------
case:...............109ms = 458.715/sekunde......................... object:.............305ms = 163.934/sekunde.........................
Struppi.
Das besser ist ein Trugschluß (dem ich auch schon unterlag), die Implemetierung der Hashes scheint nicht sonderlich schnell zu sein, der Vergleich mit einem integer ist auf jeden Fall schneler, als die Suche nach einem String (dem key des Objektes).
Wobei mir auffällt, es ist ja nicht mal ein Objekt. Also auch ein Array ist nicht sonderlich performant.
Struppi.
die Implemetierung der Hashes scheint nicht sonderlich schnell zu sein, der Vergleich mit einem integer ist auf jeden Fall schneler, als die Suche nach einem String (dem key des Objektes).
Ich weiß nicht, ob man hier wirklich switch versus Property Accessor Operator misst. Kommentiere switch und bewertungen[punkte] mal aus, da bekommst du fast gleiche Resultate.
Firefox 3:
case:...............4154m = 722.195/sekunde.........................
object:.............9097m = 329.779/sekunde.........................
Ohne switch und Property Accessor:
case:...............4214m = 711.912/sekunde.........................
object:.............8865m = 338.409/sekunde.........................
Firefox 3.1 Beta 3 (TraceMonkey):
case:...............3714m = 807.754/sekunde.........................
object:.............6354m = 472.143/sekunde.........................
Ohne switch und Property Accessor:
case:...............3460m = 867.052/sekunde.........................
object:.............6039m = 496.770/sekunde.........................
Chrome (V8):
object:.............974ms = 3.080.082/sekunde.......................
case:...............1034m = 2.901.353/sekunde.......................
Ohne switch und Property Accessor:
object:.............932ms = 3.218.884/sekunde.......................
case:...............1001m = 2.997.002/sekunde.......................
Safari 4 (Squirrelfish Extreme):
case:...............7260m = 413.223/sekunde.........................
object:.............7970m = 376.411/sekunde.........................
Ohne switch und Property Accessor:
case:...............6951m = 431.592/sekunde.........................
object:.............7710m = 389.105/sekunde.........................
Ich vermute, man misst damit das Erzeugen von Objekten beim Variable Object über Objekt-Literale. 99% der Zeit gehen beim case-Testfall wohl für rand() drauf. case selbst fällt dann überhaupt nicht ins Gewicht. Beim object-Testfall kommt noch das teure Objektliteral hinzu, während der Property Accessor wieder nicht ins Gewicht fällt, nehme ich an.
V8 hat offenbar eine extrem schnelle Implementierung von Math (ich musste 3 Millionen Tests wählen, um überhaupt einen Unterschied zu sehen) und optimiert offenbar auch das Erzeugen immer desselben Objektes weg.
Mathias
@@Gunnar Bittersmann:
switch (punkte)
{
case 0: alert("sehr schlecht"); break;
case 1: alert("schlecht"); break;
case 2: alert("ganz oke"); break;
case 3: alert("gut"); break;
case 4: alert("sehr gut"); break;
}
BTW, in dem Falle bietet es sich auch an, 'punkte' als Index eines Arrays zu nutzen. Dann entfällt if bzw. switch:
~~~javascript
var ausgabe = new Array("sehr schlecht", "schlecht", "ganz oke", "gut", "sehr gut");
alert(ausgabe[punkte]);
Live long and prosper,
Gunnar
PS: Soll es wirlich „oke“ heißen? Oder „okay“?
vielen dank für die antworten !!
das war ein flüchtigkeitsfehler und eigentlich müsste das problem ja dann behoben sein wenn ich am ende while(x<4); schreibe, oder? ... da kommt aber immernoch die gleiche meldung. und x lege ich mit -1 fest weil am anfang der schleife ja x++ steht und frage1 (also im array objekt 0) auch gefragt werden soll isgt der anfangswert von x -1.
und auch noch danke für den tip mit elseif ich habs mir zu herzen genommen :)
mfg sven
das war ein flüchtigkeitsfehler und eigentlich müsste das problem ja dann behoben sein wenn ich am ende while(x<4); schreibe, oder? ... da kommt aber immernoch die gleiche meldung. und x lege ich mit -1 fest weil am anfang der schleife ja x++ steht und frage1 (also im array objekt 0) auch gefragt werden soll isgt der anfangswert von x -1.
Warum durchläufst du ein Array nicht wie es alle anderen machen?
var array = [.....];
for(var i = 0; i < array.length; i++) {
tu_was_mit(array[i]);
}
Dann brauchst du keine unnötigen Rechenschritte mehr.
Struppi.
Hallo,
Warum durchläufst du ein Array nicht wie es alle anderen machen?
var array = [.....];
for(var i = 0; i < array.length; i++) {
tu_was_mit(array[i]);
}
Vielleicht, gerade \*weil\* alle anderen es so machen?
So geht's mir jedenfalls. Ich hinterfrage immer alles und suche neue Wege, die manchmal eleganter und/oder schneller sind, als da wären:
~~~javascript
var array = [.....];
for(var i = 0; array[i]; i++) {
tu_was_mit(array[i]);
}
(bricht aber ab, sobald array[i]==false gilt)
oder:
var array = [.....];
for(var i = 0; i in array; i++) {
tu_was_mit(array[i]);
}
(bricht auch ab, sobald array[i]==false gilt)
oder gar – als Krönung – einzeilig:
var array = [.....];
for(var i = 0; array[i]; tu_was_mit(array[i++]));
(bricht auch ab, sobald array[i]==false gilt)
All diese Varianten würden für das genannte Quiz funktionieren, wobei mir natürlich die letzte am besten gefällt :-)
Gruß, Don P
for(var i = 0; array[i]; i++) {
tu_was_mit(array[i]);
}
(bricht aber ab, sobald array[i]==false gilt)
Könnte man mit typeof array[i] != "undefined" verhindern, allerdings denke ich nicht, dass das schneller ist als i < length.
for(var i = 0; i in array; i++) {
(bricht auch ab, sobald array[i]==false gilt)
Nein, bricht nicht ab.
oder gar – als Krönung
array.forEach(function (elem) { ... }) ;)
Mathias
Hallo,
»» for(var i = 0; i in array; i++) {
»» (bricht auch ab, sobald array[i]==false gilt)Nein, bricht nicht ab.
Stimmt, nicht wirklich wenn array[i]==false, aber wenn ein Array-Element gar nicht befüllt ist, dann schon:
var a = new Array(3); // Array mit 3 Elementen
for (var i=0; i in a; alert(i++)); // gibt nichts aus
aber:
var a = new Array(3); // Array mit 3 Elementen
a[0]='wert1'; // Erstes Element befüllen
for (var i=0; i in a; alert(i++)); // gibt nur 0 aus
und:
var a = new Array(3); // Array mit 3 Elementen
a[0]='wert1'; // 1. Element befüllen
a[2]='wert3'; // 3. Element befüllen
for (var i=0; i in a; alert(i++)); // gibt ebenfalls nur 0 aus
Beim fehlenden 2. Array-Element bricht die Schleife ab, hier dagegen nicht:
var a = new Array(3); // Array mit 3 Elementen
a[0]='wert1'; // 1. Element befüllen
a[2]='wert3'; // 3. Element befüllen
for (var i=0; i<a.length; alert(i++)); // gibt 0,1 und 2 aus
Und hier auch nicht:
var a = new Array(3); // Array mit 3 Elementen
for (var i=0; i<a.length; alert(i++)); // gibt 0,1 und 2 aus
»» oder gar – als Krönung
array.forEach(function (elem) { ... }) ;)
Klar, falls Array.forEach implementiert ist.
forEach arbeitet auch nur mit den befüllten Array-Elementen:
var a = new Array(3); // Array mit 3 Elementen
a.forEach( function(e,i,a){alert(i++)} ); // gibt nichts aus
Gruß, Don P
forEach arbeitet auch nur mit den befüllten Array-Elementen:
var a = new Array(3); // Array mit 3 Elementen
a.forEach( function(e,i,a){alert(i++)} ); // gibt nichts aus
Ja, da es auch mit in arbeitet
<https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference:Objects:Array:forEach>
Struppi.
Hallo,
Ja, da es auch mit in arbeitet
https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference:Objects:Array:forEach
Genau. Der dortige Algorithmus("exactly the one used in Firefox and SpiderMonkey") gibt mir allerdings ein Rätsel auf:
if (!Array.prototype.forEach)
{
Array.prototype.forEach = function(fun /*, thisp*/)
{
var len = this.length >>> 0; // hä???
if (typeof fun != "function")
throw new TypeError();
var thisp = arguments[1];
for (var i = 0; i < len; i++)
{
if (i in this)
fun.call(thisp, this[i], i, this);
}
};
}
Anscheinend soll mit var len = this.length >>> 0; die len-Variable durch einen (fingierten) rechts-shift um 0 Bits numerisch gemacht werden. Aber array.length ist doch ohnehin immer numerisch...
Kann mir auch nicht denken, dass das für den Fall vorgesehen ist, dass die length-Eigenschaft gar nicht definiert ist, denn ein Array hat sie ja immer, und da die Funktion eine Methode von Array-Objekten ist, ist length also immer definiert und eben immer bereits numerisch.
Außerdem habe ich mal irgendwo gelesen oder gehört, dass bitweise Operatoren in JavaScript performancemäßig teuer sind, weil numerische Werte immer float-Typen sind und daher für bitweise Operationen zweimal umgeformt werden müssen. Die Zeile hätte ich daher so geschrieben: var len = +this.length;, wenn das denn überhaupt nötig ist, wie gesagt.
Ein Test hat übrigens ergeben, dass die Variante n>>>0 im IE6 schneller ist, im FF3 aber die Variante +n.
Gruß, Don P
Hallo,
Anscheinend soll mit
var len = this.length >>> 0;die len-Variable durch einen (fingierten) rechts-shift um 0 Bits numerisch gemacht werden. Aber array.length ist doch ohnehin immer numerisch...
Ich rate mal rum: $Zahl >>> 0 hat laut ECMAScript-Standed den Nebeneffekt, dass $Zahl von 64 Bit double precision floating point in 32 Bit unsigned integer umgewandelt wird. Ich gehe davon aus, dass derjenige ein paar Rechenzyklen vermeiden will. Auf der anderen Hand ist das eher dämlich, weil Array.length in Spidermonkey eh schon uint32 ist. Hat jemand noch eine Idee?
Tim
Warum durchläufst du ein Array nicht wie es alle anderen machen?
Vielleicht, gerade *weil* alle anderen es so machen?
So geht's mir jedenfalls. Ich hinterfrage immer alles und suche neue Wege, die manchmal eleganter und/oder schneller sind
Allgemein würde ich festhalten:
Darauf gibts keine eindeutige Antwort. Wie man einen Array am besten durchläuft, hängt ganz vom Inhalt des Arrays ab und davon, warum man den Array durchläuft. Und zudem hat man es in JavaScript nicht bloß mit Arrays zu tun, sondern mit NodeLists, NamedNodeMaps, HTMLCollections, arguments-Objekten usw. Die erfordern jeweils speziellere Techniken je nach Anwendungszweck. Dann gibts die besagten Helfermethoden, die aber nicht in allen Engines zu Verfügung stehen.
Mathias
Wie man einen Array am besten durchläuft, hängt ganz vom Inhalt des Arrays ab und davon, warum man den Array durchläuft.
Und bei manchen Engines wie SpiderMonkey hat man nochmal ganz eigene Methoden:
http://www.melez.com/mykzilla/2009/04/syntaxes-for-iterating-arrays-in.html
Mathias
Hi,
Und bei manchen Engines wie SpiderMonkey hat man nochmal ganz eigene Methoden
http://www.melez.com/mykzilla/2009/04/syntaxes-for-iterating-arrays-in.html
Was es nicht alles gibt...
Ich persönlich mag die Iterationen mit for(var i ... i++) nicht sonderlich und vermeide sie wo immer möglich.
Um z.B. nur mal Array-Elemente abzuholen, die man im Array nicht weiter braucht, kann man doch viel schöner sowas schreiben:
while(array.length) { tu_was_mit( array.shift() }
bzw. umgekehrt:
while(array.length) { tu_was_mit( array.pop() }
Auf folgende nützliche Funktion zum endlos-Durchlaufen eines Arrays bin ich besonders stolz:
array.rotate = function (step) { /* rotiert die Array-Elemente schrittweise, © Don P ;-) */
step = (step||0) % (this.length||1);
if (step > 0) while (step--) this.unshift(this.pop());
else if (step < 0) while (step++) this.push(this.shift());
};
Statt einen Zähler i zu deklarieren, mit dem man durchläuft um ihn dann dann am Ende wieder auf 0 zu setzen, werden einfach die Array-Elemente selbst rotiert, und man greift konstant z.B. auf array[0] zu, um das nächste Element abzuholen (nach array.rotate(1);).
Gruß, Don P
Hallo,
Das Ganze könnte dann z.B. so funktionieren:
function quiz() {
var frage = ["frage1", "frage2", "frage3", "frage4"],
antwort = ["antwort1", "antwort2", "antwort3", "antwort4"],
note = ["sehr schlecht", "schlecht", "ganz ok", "gut", "sehr gut"],
richtige = 0;
for(var i = -1; frage[++i]; richtige += (antwort[i] == prompt(frage[i],"")));
alert(note[richtige]);
}
Gruß, Don P
[latex]Mae govannen![/latex]
function quiz() {
var frage = ["frage1", "frage2", "frage3", "frage4"],
antwort = ["antwort1", "antwort2", "antwort3", "antwort4"],
note = ["sehr schlecht", "schlecht", "ganz ok", "gut", "sehr gut"],
richtige = 0;for(var i = -1; frage[++i]; richtige += (antwort[i] == prompt(frage[i],"")));
alert(note[richtige]);
}
Mir fehlt generell die Bindung der Fragen und Antworten zueinander (Zwei Arrays, nur verbunden über den Array-Index, was bei größeren Arrays etwas fehlerträchtig sein kann, z.B. wenn man einen Satz zwischendrin einfügen möchte).
Ich würde es eher so machen:
var richtige = 0, i;
var daten = [
{frage: "frage1", antwort: "antwort1"},
{frage: "frage2", antwort: "antwort2"},
{frage: "frage3", antwort: "antwort3"},
{frage: "frage4", antwort: "antwort4"}
];
for (i = 0; daten[i]; i++) {
richtige += +(daten[i]['antwort'] == prompt(daten[i]['frage'],''));
//richtige += +(daten[i].antwort == prompt(daten[i].frage,'')); // alternativ
}
alert(richtige);
oder so:
var richtige = 0, i;
var daten = [
["frage1", "antwort1"],
["frage2", "antwort2"],
["frage3", "antwort3"],
["frage4", "antwort4"]
];
for (i = 0; daten[i]; i++) {
richtige += +(daten[i][1] == prompt(daten[i][0],''));
}
alert(richtige);
Cü,
Kai
Hai Kai,
Zwei Arrays, nur verbunden über den Array-Index, was bei größeren Arrays etwas fehlerträchtig sein kann, z.B. wenn man einen Satz zwischendrin einfügen möchte.
Ich würde es eher so machen:
[...]
oder so:
var richtige = 0, i;
var daten = [
["frage1", "antwort1"],
["frage2", "antwort2"],
["frage3", "antwort3"],
["frage4", "antwort4"]
];for (i = 0; daten[i]; i++) {
richtige += +(daten[i][1] == prompt(daten[i][0],''));
}
alert(richtige);
Ja, so würde ich es für größere Datenmengen auch machen. Das hat auch den Vorteil, dass man das daten-Array leicht umstellen kann, z.B. mit einem Zufallsalgorithmus.
Auch der Vergleich mit dem prompt ist ja so nicht wirklich zu gebrauchen. Wen man z.B. die frage2 mit "Antwort2" beantwortet statt mit "antwort2", das ist das schon falsch... ziemlich kleinlich, würde ich sagen.
Leider sind arrays recht langsam, vor allem im IE. Ich wollte mal testweise ein Array mit 1 Million leerer Objekte füllen. FF oder Opera machen das glaub' in ein paar hundert Millisekunden, bei IE war die Zeit nicht messbar, weil der nach einer Weile meint, das Script habe vielleicht einen Fehler und dann fragt er, ob man vielleicht abbrechen will... Nö, ich wollte eigentlich nur das Array befüllt haben, aber wenn er das nicht packt, dann doch lieber abbrechen, Browser schließen und seine Existenz möglichst vergessen oder mindestens alle Gedanken an ihn schnell verdrängen ;-)
Gruß, Don P
Hallo,
answer=promt("quest[x]","")
steht das wirklich so in deinem Code? Oder ist das ein Abschreibfehler?
Ich würde dem prompt mal das dringend nötigte zweite 'p' spendieren.
Davon abgesehen wäre es schön, wenn du uns verraten hättest, wo genau die Zeile 19 in deinem Codeausschnitt ist; außerdem kann ich mich den übrigen Teilnehmern anschließen: Der JS-Code ist sehr umständlich, angemessene Einrückungen würden ihn *wesentlich* besser lesbar machen, und vom Weglassen des Semikolons am Zeilenende kann ich auch nur abraten - es verschleiert mögliche Fehler nur allzu leicht.
Der Wortlaut deiner Fehlermeldung lässt mich übrigens vermuten, dass du den IE zum Testen verwendest - und das ist keine gute Idee. Seine Fehlermeldungen sind sehr kryptisch, die Angabe der Position oft falsch. Firefox und Opera sind da in ihrer Fehlerkonsole wesentlich gesprächiger und hilfreicher.
if(answer==antwort[x])
{punkte++};
}
while (x<5);
Zusammen mit der Initialisierung von x auf -1 hätte man diese do-while-Schleife auch viel einfacher und übersichtlicher als for-Schleife formulieren können:
for (x=0; x<5; x++)
{
}
{alert("ganz oke")}
"oke" sieht sehr merkwürdig aus ...
<noscript></noscript>
Wenn du keinen Ersatzinhalt bieten willst, lass doch auch das noscript-Element gleich weg.
So long,
Martin
omg...nur weil ich das "p" bei prompt vergessen hatte -.-
wie peinlich ^^ ... vielen vielen dank jetzt tut alles :)
die fehlermeldung kahm übrigens in der vorschau von phaase 5 wenn ichs mit opera geöffnet habe dann kam garnix...naja egal jetzt funktioniert ja alles...vielen dank nochmal an alle :) mfg sven
die fehlermeldung kahm übrigens in der vorschau von phaase 5 wenn ichs mit opera geöffnet habe dann kam garnix...
Das ist falsch, auch Opera hat eine Fehlerkonsole.
Struppi.