A. Schreiber

---------------------------------------------------
ÜBERSICHT ZU EINIGEN SPRACHELEMENTEN VON JAVASCRIPT
---------------------------------------------------

Stand: 2007-03-15



I.Boolesche Vergleichsoperatoren
================================

  Gleich        ==
  Ungleich      !=
  
  Größer        >
  Größergleich  >=
  
  Kleiner       <
  Kleinergleich <=

-------------------------------

  Schreibweise (infix): a >= b
  
  Wert (Typ boolean):   true , false
  
  Auswertungskriterium: 
    bei Zahlen die natürliche Ordnung
    bei Strings die lexikografische Ordnung
    


II. Logik-Operatoren
====================
  
  UND           &&
  ODER          ||
  NICHT         !

-------------------------------

  Schreibweise:
    && und || infix:    op1 && op2, 
                        op1 || op2                       
    ! präfix:           !op
  
  Wert (Typ boolean):   true , false
  
  Auswertungskriterien: Gesetze der Aussagenlogik
    a && b true gdw a true und b true
    a || b false gdw a false und b false
    !a true gdw a false
    

III. if-else: Bedingte Ausführung von Anweisungen
=================================================

  Syntax (if-Anweisung):
  
  
  if (Bedingung)
    {
       Anweisungen
    }


  WICHTIG:
  Die Bedingung bei if MUSS in runden Klammern stehen!

---------------------------------------------

  Syntax (if-else-Anweisung):

      
  if (Bedingung)
    {
       Anweisungen 1
    }
  else
    {
       Anweisungen 2
    }      


IV. Fallunterscheidung mittels switch-case
==========================================

  Syntax:
  

  switch(arg)
  {
  case wert1:
    Anweisung 1
    break;
    
  case wert2:
    Anweisung 2
    break;
    
  ...
  
  default:
    Anweisung im Sonst-Fall
    break;
  }    
  


V. Das INPUT-Tag und einige (wichtige) Attribute
================================================

    <INPUT ...> : kein Abschluss-Tag!

    <INPUT TYPE = "text" ...> :
           TYPE = "button"
           TYPE = "reset"
               
           NAME = "---"     frei wählbarer Name
               
           SIZE = "---"     angezeigte Zeichenzahl
               
      MAXLENGTH = "---"     max. Zeichenzahl im Eingabefeld
          
          VALUE = "---"     Textvorbelegung bzw. Beschriftung
              
          READONLY          bewirkt im Eingabefeld "nur lesen"
              
              
Beispiel für den Zugriff auf eine Eingabe (TYPE="text", NAME="PLZfeld") innerhalb 
eines Formulars (NAME="Adressenformular"):

        document.Adressenformular.PLZfeld.value
        

VI. Dynamische Ablaufsteuerung
==============================

for-Schleife
------------

Eine for-Schleife wiederholt einen Anweisungsblock. Die Anzahl der wiederholten 
Durchläufe wird dabei durch eine Abbruch-Bedingung festgelegt.

SYNTAX:

        for ( initialausdruck; bedingung; änderung)
        {
          anweisungsfolge
        }

Die Änderungsvorschrift [änderung] wird grundsätzlich NACH einem Schleifendurchlauf 
ausgeführt.

Die Abbruchbedingung [bedingung] ist ein beliebiger boolescher Ausdruck und wird 
NACH jeder Ausführung der Änderungsvorschrift überprüft. Sie wird aber auch 
VOR dem Ersteintritt in die Schleife überprüft, d.h. bei unerfüllter [bedingung] 
wird die Schleife übersprungen. 

BEISPIEL:

        sum = 0;
        for ( var i=1; i<=10; i++ )
        {
          sum = sum + i
        }
          

Bemerkungen zum Beispiel:

In sum steht nach Austritt aus der Schleife die Summe der Zahlen 1 bis 10.
Die Änderungsanweisung i++ bewirkt dasselbe wie i = i+1 (erhöht die 
Laufvariable i somit um den Wert 1). 

Die Laufvariable i ist auch außerhalb des Schleifenrumpfs bekannt. 
Unmittelbar nach Austritt aus der Schleife hat i den Wert 11 
(da i zunächst erhöht und danach die Abbruchbedingung i<=10 überprüft wurde).


while-Schleife
--------------

Aufbau und Arbeitsprinzip der while-Schleife sind einfacher zu verstehen als bei 
der for-Schleife. Die Anweisungsfolge wird solange wiederholt durchlaufen, wie die 
Eintrittsbedingung erfüllt ist (d.h. den booleschen Wert true besitzt).

SYNTAX:

        while ( bedingung )
          {
            anweisungsfolge
          }
          
Die hier genannte Bedingung ist eine Eintrittbedingung; sie wird VOR Eintritt in die 
Schleife überprüft. Ist sie nicht erfüllt, so wird die Anweisungsfolge erst gar nicht 
ausgeführt ("abweisende Schleife").

Grundsätzlich lassen sich alle Arten von Schleifen als while-Schleifen konstruieren. 
So lässt sich etwa das zur for-Schleife gegebene Beispiel folgendermaßen formulieren:

BEISPIEL:

        sum = 0;
        i = 1;
        while ( i<=10 )
          {
            sum = sum + i;
            i = i + 1;
          }
            
Der Schleifenzähler i muss vor der Schleife initialisiert werden.


Abbruch einer Schleife (for und while)
--------------------------------------

1. Unter Umständen will man eine Schleife verlassen (d.h. mit der ersten Anweisung 
fortfahren, die der Schleife folgt), wenn eine bestimmte Bedingung eintritt 
(welche innerhalb des Schleifenkörpers abgefragt wird). Die geschieht durch die 
Anweisung

        break
        
2. Will man lediglich den aktuellen Durchlauf der Schleife abbrechen und die 
Bearbeitung des Programms mit dem nächsten Schleifendurchlauf fortsetzen, so 
geschieht dies durch die Anweisung

        continue
        

Auf Beispiele wird hier verzichtet (man kann sie sich leicht selbst zurechtlegen). 
In den meisten Fällen lässt sich der Gebrauch von break und continue vermeiden.


VII. Das Objekt string
======================

String ist (anders als das Objekt Math) ein "allgemeines" Objekt, von dem einzelne 
Kopien mit Hilfe der Funktion String( ) erzeugt werden.

1. Direkte Wertzuweisung (definiert eine String-Variable)
        var text1 = "Hallo";

2. Verwendung eines sog. Konstruktors (erzeugt ein String-Objekt)
        var text2 = new String("Hallo");

Die Alternative 2 ist ratsam, wenn auf Zeichenketten aus verschiedenen 
window-Instanzen zugegriffen werden soll. 

Es besteht die Möglichkeit der Typkonversion: text2.toString() ist typgleich text1.

        
Eigenschaften
-------------

        length          Anzahl der Zeichen des Strings
        

Methoden (Auswahl)
------------------

Erscheinungsweise:

        big()                   groß darstellen
        small()                 klein darstellen
        
        sub()                   tiefstellen
        sup()                   hochstellen
        
        bold()                  fett darstellen
        italics()               kursiv darstellen
        fixed()                 in Schreibmaschinenschrift darstellen
        
        toLowerCase()           alle Zeichen kleinschreiben
        toUpperCase()           alle Zeichen großschreiben
        
        fontcolor()             Schriftfarbe erzeugen
        fontsize()              Schriftgröße erzeugen
        
Struktur/Operationen:

        charAt()                Zeichen an Position ermitteln
        indexOf()               Position eines Zeichens ermitteln
        lastIndexOf()           letzte Position eines Zeichens ermitteln
        
        concat()                Strings zusammenfügen (verketten)
        slice()                 Teil aus String extrahieren
        
        substr()                Teilstring ab Position ermitteln
        substring()             Teilstring ermitteln

        split()                 String in Teilstrings zerlegen
                                (wird bei Arrays behandelt)


VIII. Das Objekt Array
======================

Ein Array (bzw. Feld) ist vergleichbar einer Folge, einem Vektor (oder Tupel) 
im mathematischen Sinn. Es enthält eine Folge von Daten (Elementen).

Arrays werden über einen Konstruktor erzeugt, z.B.

        var Namenliste = new Array("Bodo","Lisa","Paul");

Das Element Namenliste[0] enthält "Bodo".
Das Element Namenliste[1] enthält "Lisa".
Das Element Namenliste[2] enthält "Paul".

Ein Array kann beliebige Daten aufnehmen. Die Elemente dürfen ihrerseits auch 
wieder Arrays sein.

Erzeugungsvarianten:
--------------------

        Namenliste = new Array(3);
        Namenliste[0] = "Bodo";
        Namenliste[1] = "Lisa";
        Namenliste[2] = "Paul";

Man kann es gänzlich vermeiden, die Anzahl der Elemente im Voraus festzulegen:

        Namenliste = new Array();
        Namenliste[0] = "Bodo";
        
        usw. 
        Weitere Elemente können nach Beliebigen hinzugefügt werden.
        
Eigenschaften:
--------------

        length          Anzahl der Elemente
        
Methoden:
---------      

        concat()        Arrays verketten
        
        reverse()       Elementreihenfolge umkehren
        sort()          Array sortieren
        
        pop()           letztes Element löschen
        push()          neue Elemente anhängen
        
        shift()         erstes Element entfernen
        
        slice()         Teil-Array extrahieren
        
        join()          in eine Zeichenkette umwandeln                                        


IX. Array als Datensatz und mehrdimensionale Arrays
===================================================

Beispiel:

        student = new Array();

        student[0] = "Meier"; // Nachname
        student[1] = "Peter"; // Vorname
        student[2] = "m";     // Geschlecht  
        student[3] = "Physik";// Studienfach
        student[4] = 1980;    // Geburtsjahr
        student[5] = 3;       // Semester  


Will man die Daten zu mehreren Studenten darstellen (abspeichern), so benötigt man 
dazu einen Array, dessen Elemente Arrays vom Typ "student" (s.o.) sind, 
sog. mehrdimensionale Arrays:

Beispiel:

        studatei = new Array();
  
        studatei[0] = new Array();
        studatei[0][0] = "Meier";
        studatei[0][1] = "Peter";
        studatei[0][2] = "m";
        studatei[0][3] = "Physik";
        studatei[0][4] = 1980;
        studatei[0][5] = 3;      

        studatei[1] = new Array();
        studatei[1][0] = ... usw.


X. Funktionen
=============

a) Aufbau einer Funktion (in JS)
--------------------------------


SYNTAX:

        function fktname( [p_1] [,p_2] [... p_N] )
        {
          anweisungen
        }
        

Bemerkungen:

1. function ist ein in JS reserviertes Wort; ihm folgt der Funktionsname mit 
angehängtem Klammerpaar (). Groß/Kleinschreibung wird unterschieden (und ist daher 
zu beachten).

2. Innerhalb der Klammern können (müssen aber nicht) eine oder mehrere Variablen 
stehen, sog. Parameter (durch Komma getrennt).

3. Der nachfolgende Block (sog. Rumpf oder Funktionskörper) { ... } enthält die 
Anweisungen, welche abgearbeitet werden, wenn die Funktion aufgerufen wird. Ein 
Funktionsaufruf erfolgt durch die Anweisung: fktname(...);

4. Soll die Funktion einen Wert [ergebnis] zurückgeben (an das aufrufende Programm), 
so geschieht dies innerhalb ihres Rumpfes durch die Anweisung:

        return ergebnis

5. Funktionen sind nicht schachtelbar, d.h. im Rumpf einer Funktion können keine 
weiteren (Unter-)Funktionen definiert werden.


b) Lokale und globale Variable
------------------------------

Eine Variable, die außerhalb einer Funktion deklariert wurde, ist "überall" bekannt 
(global gültig); insbesondere kann ihr innerhalb und außerhalb des Funktionsrumpfes 
ein Wert zugewiesen werden.

BEISPIEL:
       
        var a = 5;
        
        ...
                
        function Dummy(x)
        // Tut nichts! Oder doch?
        {
          a = x;
          return a
        }
        
In diesem Fall wird a durch den in Dummy zugewiesenen Wert überschrieben 
(sog. Seiteneffekt).

Wird eine Variable innerhalb einer Funktion deklariert, so ist sie auch nur innerhalb 
des Rumpfs dieser Funktion gültig (und außerhalb unbekannt): sog. lokale Variable. 
In diesem Fall MUSS 'var' vor die Variable geschrieben werden.

BEISPIEL:

        var a = 5;
        
        function Dummy2(x)
        // Tut wirklich nichts!
        {
          var a = x;
          return a
        }
        
Die Variable a innerhalb von Dummy2 ist außerhalb des Rumpfs nicht gültig. 
Nichtsdestoweniger ist eine (andere) Variable a global definiert und hat den Wert 5. 
Es entsteht somit nicht einmal ein Namenskonflikt zwischen gleichbenannten globalen 
und lokalen Variablen!


c) Parameterübergabe
--------------------

1. "call by value"

Wird eine Variable x einer Funktion als Parameter übergeben, so wird nur ihr Wert 
übernommen ("call by value"). Die Funktion legt eine Kopie der Variablen an. 
Änderung des Parameters im Funktionsrumpf hat keine Auswirkung auf die Variable x.

BEISPIEL:

        var x = 7;

        function vorgaenger(m)
        {
          m = m-1;
          return m
        }
                     
        y = vorgaenger(x)
        

In y steht nun der Wert 6. Die Variable x hat ihren ursprünglichen Wert 7 behalten.
        

2. "call by reference"

Wird ein Objekt als Parameter übergeben, so übernimmt die Funktion NICHT den Wert, 
sondern lediglich eine Referenz auf das Objekt ("call by reference"). 
Die Funktion arbeitet dann mit dem Original (anstatt mit einer Kopie). 

Das hat eine erhebliche Konsequenz:

------------------------------------------------
ÄNDERUNGEN INNERHALB DER FUNKTION WIRKEN SICH 
AUCH AUF DAS OBJEKT AUSSERHALB DER FUNKTION AUS!
------------------------------------------------

BEISPIEL:

        var x = new Array(1,2,3);

        function verdoppeln(a)
        {
          a[0] = 2*a[0];
          a[1] = 2*a[1];
          a[2] = 2*a[2];          
        }
        
        verdoppeln(x);
        

Nun ist x gleich dem Array mit den Elementen 2,4,6.

Bemerkung: 
Werden Objekte auf diese Weise verändert, so ist eine Rückgabe (mittels return) 
nicht erforderlich.


------------------------------------------------------
                                    ENDE DER ÜBERSICHT
------------------------------------------------------