Benutzer:Don P

Aus SELFHTML-Wiki
Wechseln zu: Navigation, Suche

Hinweis

  • Am 01.06.2014 wurden Links an die neue Wiki-Struktur angepasst.
  • Am 02.11.2014 wurden Links auf nicht mehr bestehende / mittlerweile gelöschte Seiten entfernt.--Matthias Scharwies (Diskussion) 05:54, 4. Nov. 2014 (CET)
  • am 21.04.2017 dito -- Matthias (Diskussion) 18:11, 21. Apr. 2017 (CEST) --


Zuweisungsoperator[Bearbeiten]

  • JavaScript 1.0
  • Leer
  • Leer
  • Leer
  • Leer
  • Leer
  • Leer

Verwenden Sie das Gleichheitszeichen = um einer Variablen einen Wert zuzuweisen.

für eine Zuweisung
var sinnDesLebens = 42;
Im Beispiel wird eine Variable namens sinnDesLebens definiert. Der Zuweisungsoperator = weist ihr den Wert 42 zu.

Vergleichsoperatoren[Bearbeiten]

  • JavaScript 1.0
  • Leer
  • Leer
  • Leer
  • Leer
  • Leer
  • Leer

Vergleichsoperatoren dienen zum Vergleichen zweier Werte. Solche Vergleiche werden vor allem für bedingte Anweisungen und Schleifen benutzt. Als Ergebnis liefern Vergleichsoperatoren immer einen sogenannten booleschen Wert (Wahrheitswert) vom Typ boolean, d.h. entweder true (wahr) oder false (falsch).

Sie können z.B. den Inhalt einer Variablen mit dem Inhalt einer anderen oder mit dem Ergebnis eines Ausdrucks vergleichen, indem Sie den gewünschten Vergleichgsoperator zwischen den beiden Operanden notieren:

für Vergleiche
var sinnDesLebens = 42, alter = 8;
if (sinnDesLebens == 42) alert("Richtig.");
if (sinnDesLebens != 42) alert("Falsch.");
if (sinnDesLebens > 42)  alert("Falsch.");
if (sinnDesLebens < 42)  alert("Falsch.");
if (alter >= 18)         alert("SIE duerfen das hier sehen.");
if (alter <= 17)         alert("SIE duerfen das hier NICHT sehen.");

Im Beispiel werden die Inhalte der Variablen sinnDesLebens und alter mit fixen numerischen Werten (42 etc.) verglichen. Informationen zur Funktionweise einer If-Abfrage finden Sie im Abschnitt über bedingte Anweisungen.

Notieren Sie für Vergleichsoperatoren das Gleichheitszeichen, das Ausrufezeichen, das Größerzeichen oder das Kleinerzeichen bzw. Kombinationen davon wie folgt:

Operator Bedeutung Ergebnis der Operation
== istgleich true, wenn die Werte gleich sind, sonst false.
 != ungleich true, wenn die Werte ungleich sind, sonst false.
> größer true, wenn der linke Wert größer als der rechte ist, sonst false.
>= größergleich true, wenn der linke Wert größer oder gleich dem rechten ist, sonst false.
< kleiner true, wenn der linke Wert kleiner als der rechte ist , sonst false.
<= kleinergleich true, wenn der linke Wert kleiner oder gleich dem rechten ist, sonst false.

Äpfel mit Birnen vergleichen[Bearbeiten]

Die genannten Vergleichsoperatoren führen ggf. vor dem eigentlichen Vergleich unmerklich eine Typumwandlung durch. Das bedeutet, dass zwei Werte auch dann sinnvoll verglichen werden können, wenn es sich um unterschiedliche Datentypen handelt. Die Anweisung
alert(42 == "42");
gibt z.B. "true" aus, obwohl hier eine Zahl (Typ number) mit einer Zeichenkette (Typ string) verglichen wird.
Beachten Sie:  
  • Bei Vergleichen zweier Werte vom Datentyp object ergibt der istgleich-Operator == nur dann true, wenn beide Operanden auf genau dasselbe Objekt verweisen.
  • Bei Vergleichen mit dem Wert NaN (Not a Number) liefert der ungleich-Operator != immer true, alle anderen immer false. Sogar der Vergleich NaN == NaN ergibt false, d.h. NaN ist nicht mit sich selbst gleich. Folgender Ausdruck ergibt jedoch true, wenn die Variable x den Wert NaN enthält, sonst false:
    (isNaN(x) && typeof x == "number")
    

JavaScript 1.2 Typgenaue Vergleiche[Bearbeiten]

Um bei Vergleichen auf einfache Art auch den Datentyp berücksichtigen zu können, wurden mit der JavaScript-Version 1.2 zwei typgenaue Vergleichsoperatoren eingeführt:

Operator Bedeutung Ergebnis der Operation
=== istgleich true, wenn beide Werte gleich und außerdem gleichen Typs sind, sonst false.
 !== ungleich true, wenn die Werte ungleich oder nicht gleichen Typs sind, sonst false.

Rechenoperatoren[Bearbeiten]

  • JavaScript 1.0
  • Leer
  • Leer
  • Leer
  • Leer
  • Leer
  • Leer

Numerische Berechnungen führen Sie Hilfe von Rechenoperatoren durch.

Notieren Sie zwischen den Operanden zum Addieren das Pluszeichen +, zum Subtrahieren das Minuszeichen -, zum Multiplizieren den Stern *, zum Dividieren den Schrägstrich / und für Modulo-Berechnungen das ProzentZeichen %.

Es gelten die üblichen Rechenregeln (Punkt- vor Strichrechnung etc.). Wie in der Mathematik üblich müssen Sie Klammern setzen, um eine andere Rangfolge der Operationen zu bestimmen.

für Berechnungen
var zwei = 1 + 1,
    nix           = 2 - 2,
    auchNix       = 81 / 3 - 27,
    wenigerAlsNix = 81 / (3 - 27),
    sinnDesLebens = 6 * 7,
    machtAuchSinn = 84 / 2,
    wiederNix     = 36 * 37 % 666;
Im Beispiel werden verschiedene Variablen definiert und jeweils ein Rechenergebnis zugewiesen.

Rechenoperationen mit Zuweisung[Bearbeiten]

Oft will man den Wert von Variablen nur umrechnen, d.h. das Rechenergebnis wieder in derselben Variablen speichern. Hierfür gibt es spezielle Rechenoperatoren, die außer der eigentlichen Rechnung auch die Neuzuweisung vornehmen, so dass Sie den Variablennamen nicht mehrfach notieren müssen. Wenn Sie z.B. 17 addieren wollen, können Sie statt ausführlich zahl = zahl + 17; einfach nur zahl += 17; schreiben.

Beispiel
var zahl = 0;
zahl += 3; zahl -= 2;
zahl *= 4; zahl /= 3;
zahl %= 5;
Im Beispiel wird eine Variable namens zahl definiert und ihr der Wert 0 zugewiesen. Dieser wird dann jeweils neu berechnet: Der Reihe nach wird 3 addiert, 2 subtrahiert, mit 4 multipiziert, durch 3 dividiert, eine Division mit Rest durch 5 berechnet.
Schreibweise Operation Neuer Wert
a += b Addition a + b
a -= b Subtraktion a - b
a *= b Multiplikation a * b
a /= b Division a / b
a %= b Division mit Rest a % b

Weil diese Rechenoperatoren eine Zuweisung an den linken Operanden durchführen, muss dort zwingend eine Variable stehen. Rechts können Sie beliebige fixe Werte, Variablen oder Ausdrücke notieren.

Inkrementoren und Dekrementoren[Bearbeiten]

Inkrementoren und Dekrementoren vergrößern bzw. verkleinern den Wert einer Variablen um genau 1. Sie finden vor allem in Schleifen Verwendung, bei denen ein Indexwert schrittweise hoch bzw. runtergezählt werden soll. Dabei ist der Wert, den ein Operator als Ergebnis der Operation zurückgibt, nicht immer identisch mit dem neu zugewiesenen Wert.

Beispiel
var zahl = 0;
zahl++; zahl--;
++zahl; --zahl;
Im Beispiel wird der Wert der Variablen zahl jeweils um 1 erhöht (++) oder verringert (--).

Diese Operatoren geben entweder den Wert der Variablen vor der Berechnung als Ergebnis zurück oder den neuen Wert nach der Berechnung, je nachdem, ob sie rechts oder links vom Operanden notiert werden:

  • Steht der Operator links vom Operanden, dann wird der neue Wert berechnet und als Ergebnis zurückgegeben.
  • Steht der Operator rechts vom Operanden, dann wird der alte Wert als Ergebnis zurückgegeben und erst dann der neue Wert berechnet.
Schreibweise Operation Ergebnis Neuer Wert
++a Inkrementierung a + 1 a + 1
--a Dekrementierung a - 1 a - 1
a++ Inkrementierung a a + 1
a-- Dekrementierung a a - 1

Die speziellen Operationen mit Zuweisung sind stets durch normale Rechenoperatoren und separate Zuweisungen ersetzbar. Kurzschreibweisen, Inkrementoren und Dekrementoren finden sich allem bei Anweisungen, Schleifen und in komplexen Ausdrücken, weil sich damit der Code übersichtlicher gestalten lässt und man Variablen sozusagen im Vorbeigehen neu belegen kann, z.B. im Zuge eines Vergleichs:

var jahre = 17, geburtstag = true;

if(geburtstag) 
  if(++jahre === 18) 
    alert("Gralutiere! Sie sind jetzt volljährig!")

Der Modulo-Operator[Bearbeiten]

Für Modulo-Berechnungen existiert ein Modulo-Operator, der als Prozentzeichen % notiert wird. Er liefert den verbleibenden Rest bei der Division zweier Zahlen.

5 % 3 ergibt 2, weil 5 nicht ganzzahlig durch 3 teilbar ist: „3 passt 1 mal in 5 und es bleibt ein Rest von 2“ als Ergebnis. 6 % 3 ergibt dagegen 0, weil 6 duch 3 restlos teilbar ist.

Beispiel
var jahr = 2100, // Anno Domini
    tage = 365;                // normales Jahr
if (jahr % 4 == 0) ++tage;     // Schaltjahr
if (jahr % 100 == 0)           // Säkularjahr
  if (jahr % 400 != 0) --tage; // kein Schaltjahr
alert(tage); // Tage anzeigen
Im Beispiel werden zwei Variable namens jahr und tage definiert und ihnen die Zahlen 2100 bzw. 365 zugewiesen. Mit Hilfe des Modulo-Operators % und des Vergleichsoperators == wird in bedingten Anweisungen nach den Schaltregeln des gregorianischen Kalenders geprüft, ob die Jahreszahl restlos durch 4, durch 100 und ggf. durch 400 teilbar ist. Mit Hilfe der Rechenoperatoren ++ bzw. -- wird der Inhalt der Variablen tage ggf. um einen Schalttag vergrößert bzw. verkleinert. Zur Kontrolle wird die Anzahl der Tage ausgegeben.
Beachten Sie: Im Unterschied zu manchen anderen Programmiersprachen wie Ruby, Python und Perl verwendet JavaScript die sogenannte „symmetrische Variante“ des Modulo-Algorithmus, die für negative Operanden andere Ergebnisse liefert als die „mathematische Variante“. Für JavaScript gilt:
  • a%m hat stets dasselbe Vorzeichen wie a
  • (-a)%m === -(a%m), aber im Allgemeinen (a+k*m)%m !== a%m (mit k ε N).

Die Ergebnis des Ausdrucks a % m entspricht dem Rückgabewert folgender JavaScript-Funktion mod(a, m):

function mod(a, m) {

   if( m == 0                        || 
       isNaN(m)                      || 
       isNaN(a)                      || 
       a == Number.POSITIVE_INFINITY || 
       a == Number.NEGATIVE_INFINITY ) return Number.NaN;

   if( m == Number.POSITIVE_INFINITY || 
       m == Number.NEGATIVE_INFINITY ) return a;

   var float = a / m;

   if( float == 0 ) return 0;
   if( float  > 0 ) return a - m * Math.floor(float);
   if( float  < 0 ) return a - m * Math.ceil (float);
}

Logische Operatoren[Bearbeiten]

  • JavaScript 1.0
  • Leer
  • Leer
  • Leer
  • Leer
  • Leer
  • Leer

Allgemeines zu logischen Operatoren[Bearbeiten]

Mit den logischen Operatoren werden logische Verknüpfungen formuliert, z.B. für Abbruchbedingungen von Schleifen, bedingte Anweisungen bzw. Verzweigungen im Programmfluss. Beim Verknüpfen von booleschen Operanden (true/false) entsprechen die Ergebnisse denen der booleschen Alegbra.

Im Unterschied zu den meisten anderen Programmiersprachen können die logischen Operatoren in JavaScript aber nicht nur boolesche Operanden verknüpfen, sondern z.B. auch Werte anderen Datentyps (z.B. number, string, object), wobei dann auch die Ergebnisse der binären und ternären Operationen nicht mehr zwingend boolesche Werte sind. Dabei werden die Operanden zunächst intern zu booleschen Werten umgeandelt und logisch verknüft. Je nach Resultat der Umwandlung/Verknüpfung wird dann der eine oder andere Operand unverändert als Ergebnis zurückgegeben.


Der NOT-Operator[Bearbeiten]

Der unäre NOT-Operator wird als Ausrufezeichen ! vor dem Operanden notiert. Das Ergebnis ist immer ein boolescher Wert, d.h. true oder false, und entspricht dem Gegenteil des booleschen Wertes des Operanden.

Beispiel
var falsch = false; if (!falsch) alert("Weil's nicht falsch ist, ist es wahr.");
Im Beispiel wird die Variable namens falsch deklariert und ihr der booleschen Wert false zugewiesen. In einer bedingten Anweisung wird dann geprüft, ob ihr Gegenteil (!false) wahr ist, und eine entsprechende Meldung ausgegeben.

Da der NOT-Operator immer einen booleschen Wert als Ergebnis liefert, eignet er sich auch zur expliziten Umwandlung eines beliebigen Datentyps zu einem entsprechenden booleschen Wert, indem man einfach eine doppelte Verneinung notiert:

Beispiel
alert( !!"" );
Die Anweisung gibt false aus, weil die leere Zeichenkette "" intern false ergibt, so dass auch die doppelte NOT-Operation als Ergebnis false liefert. Die Anweisung alert(""); gibt dagegen die leere Zeichenkette selbst aus.





(To be continued...)[Bearbeiten]






Beispiel:

<script type="text/javascript"> var PLZ = 81000; var x = 20, y = 8; var name = "";

if (PLZ >= 80000 && PLZ <= 82000)

 alert("Sie wohnen wohl in Muenchen oder Umgebung!");

if (x > 100 || y == 0)

 break;

if (!name)

 alert("Sie haben vergessen, einen Namen einzugeben!");

</script>

Erläuterung:

Mit dem logischen Operator && verknüpfen Sie zwei oder mehrere Bedingungen durch "und", d.h. beide bzw. alle Bedingungen müssen erfüllt sein, damit die gesamte Bedingung erfüllt ist. Mit dem logischen Operator || verknüpfen Sie zwei oder mehrere Bedingungen inklusiv durch "oder", d.h. es genügt, wenn eine der Bedingungen erfüllt ist, damit die gesamte Bedingung erfüllt ist. Der logische Operator ! (engl. not) prüft, ob ein Ausdruck unwahr ist. Der Ausdruck if (!name) trifft zu, wenn name gleich null, 0, ein Leerstring oder undefiniert ist.

nach obennach unten JavaScript 1.0Netscape 2.0MS IE 3.0Opera 5.12Mozilla Firefox 1Konqueror 3.1Safari 1.0 Bit-Operatoren

Bit-Operatoren sind nur etwas für Profis. Um Bit-Operatoren richtig einzusetzen, müssen Sie viel von computer-internen Speichervorgängen verstehen. Deshalb werden die Bit-Operatoren hier nur kurz erwähnt.

>> verschiebt Bits nach rechts << verschiebt Bits nach links & definiert in einer Bitmaske eine Und-Bedingung | definiert in einer Bitmaske eine inklusive Oder-Bedingung ^ definiert in einer Bitmaske eine exklusive Oder-Bedingung ~ bitweiser Nicht-Operator, tauscht alle Nullen in Einsen und umgekehrt

nach obennach unten JavaScript 1.0Netscape 2.0MS IE 3.0Opera 5.12Mozilla Firefox 1Konqueror 3.1Safari 1.0 Operator zur Zeichenkettenverknüpfung

Mit einem einfachen Pluszeichen + können Sie eine Zeichenkette an eine andere anhängen. Beispiel:

<script type="text/javascript"> var Vorname = "Stefan "; var Zuname = "Muenz"; var Name = Vorname + Zuname + ", der Autor dieses Dokuments"; </script>

Erläuterung:

Sie können sowohl Zeichenkettenvariablen als auch direkte Zeichenkettenangaben mit + aneinanderhängen.

nach obennach unten JavaScript 1.0Netscape 2.0MS IE 3.0Opera 5.12Mozilla Firefox 1Konqueror 3.1Safari 1.0 Operatorenrangfolge

Unter den Operatoren von JavaScript gibt es eine festgelegte Rangordnung. Wenn Sie komplexe Rechenoperationen durchführen oder mehrere Bedingungen miteinander verknüpfen, gilt bei der internen Auflösung solcher komplexen Ausdrücke die folgende Rangordnung:

  1. Rangstufe: , (Aneinanderreihung)
  2. Rangstufe: = += -= <<= >>= &= ^= |=
  3. Rangstufe: ?: (Seite Entweder-Oder-Bedingung)
  4. Rangstufe: ||
  5. Rangstufe: &&
  6. Rangstufe: |
  7. Rangstufe: ^
  8. Rangstufe: &
  9. Rangstufe: == === != !==
 10. Rangstufe: < <= > >=
 11. Rangstufe: << >> >>>
 12. Rangstufe: + -
 13. Rangstufe: * / %
 14. Rangstufe: ! ~ - ++ --
 15. Rangstufe: () [] . (Klammerung und Vektoren)

Mit Hilfe von Klammern, die absichtlich die unterste Rangstufe in der Prioritätshierarchie darstellen, können Sie die Rangfolge bei den Operatoren beeinflussen und Ausdrücke so bewerten, wie Sie es wünschen. Beispiel:

<script type="text/javascript"> var OffizielleStatistik = 3.29 * 3 + 4.71; var MeineStatistik = 3.29 * (3 + 4.71); </script>

Erläuterung:

Das Beispiel zeigt, wie Sie durch Setzen von Klammern das Ergebnis einer Rechenoperation beeinflussen können.

nach obennach unten JavaScript 1.1Netscape 3.0MS IE 3.0Opera 5.12Mozilla Firefox 1Konqueror 3.1Safari 1.0 Operator zur Typenbestimmung

Methoden Seite vordefinierter Objekte sind an feste Variablentypen gebunden. Bevor Sie diese verwenden können, sollten Sie im Zweifelsfall den Typ der Variable prüfen. Mit dem Operator typeof steht Ihnen ein Werkzeug zur Typenüberprüfung zur Verfügung. Beispiel:

<script type="text/javascript"> var Zahl = 2505; alert(typeof Zahl); </script>

Erläuterung:

Der Operator typeof wertet den nachfolgenden Operanden hinsichtlich seines Typs aus. Der Rückgabewert dieses Operators ist ein String, den Sie abfragen können. Mögliche Rückgabewerte sind: boolean (Ja/Nein-Variable), string (Zeichenkettenvariable), number (numerische Variable), function (Funktion), object (Objekt), undefined (unbestimmter Typ). Anweisungen müssen in Klammern eingeschlossen werden, z.B. typeof(Zahl=Zahl+2).

nach obennach unten JavaScript 1.1Netscape 3.0MS IE 4.0Opera 5.12Mozilla Firefox 1Konqueror 3.1Safari 1.0 void-Operator

Der Operator void wird dann verwendet, wenn eine Anweisung ausgeführt werden soll, aber keine Rückgabewerte erzeugt werden dürfen. Das ist z.B. dann der Fall, wenn Sie so genannte "Bookmarklets" erzeugen möchten. Beispiel:

<script type="text/javascript"> var Zahl = 2505; void Zahl++; </script>

Erläuterung:

Der Operator void führt die nach ihm notierte Anweisung aus. Der Operator ersetzt dabei die Rückgabewerte der Anweisung stets durch undefined. Sie können auch eine Anweisung wie z.B. Zahl=Zahl+2 als Operand angeben. In diesem Fall schließen Sie die Anweisung in Klammern ein, also void(Zahl=Zahl+2).

nach obennach unten JavaScript 1.2Netscape 4.0MS IE 4.0Opera 5.12Mozilla Firefox 1Konqueror 3.1Safari 1.0 Operator zum Löschen von Objekten

Nicht mehr benötigte Objekte bzw. Objekteigenschaften werden mit dem Operator delete gelöscht. Sie können jedoch keine vordefinierten Objekte und Objekteigenschaften löschen. Der Operator gibt im Erfolgsfall den Wert true und bei Misserfolg den Wert false zurück. Beispiel:

<script type="text/javascript"> SinnDesLebens = 42; delete SinnDesLebens; alert(typeof SinnDesLebens); </script>

Erläuterung:

Im Beispiel wird der Variablen SinnDesLebens der Wert 42 zugewiesen. Anschließend wird diese Variable mit delete wieder gelöscht. Mit Hilfe des Operators typeof wird überprüft, ob das Löschen der Variablen erfolgreich ist. Beachten Sie:

In Netscape bis einschließlich Version 6 können nur Variablen und Objekte gelöscht werden, die nicht mit dem Schlüsselwort var deklariert wurden.

Auf vordefinierte Objekte oder Objekteigenschaften wie z.B. Math.PI können Sie diesen Operator nicht anwenden.