Funktionen

Einleitung

Funktionen sind vordefinierte Programmbefehle.
Einige Funktionen hast du bereits kennen gelernt. input(), output(), prompt() und alert() sind alles vordefinierte Funktionen.
Du kannst solche Funktionen auch selbst programmieren, um deinen Programmcode übersichtlicher und verständlicher zu gestalten.

In diesem Kapitel lernst du, wie das geht und worauf du speziell achten musst.
Du lernst auch weitere vordefinierte Funktionen kennen, die dir die Arbeit erleichtern...

Nach diesem Kapitel hast du alle Grundlagen beisammen, um auch grössere, eigene Programme zu schreiben.

Inhalt:
Einfache Funktionen
Funktionen mit Parametern
Funktionen mit Rückgabewerten
Gültigkeitsbereich von Variablen
Vordefinierte Funktionen

Funktionen definieren und aufrufen

Eine Funktion kannst du dir als ein kleines Unterprogramm vorstellen, dass innerhalb des Hauptprogramms läuft.

Eine Funktion muss irgendwo definiert sein, damit sie aufgerufen werden kann. Viele Funktionen sind schon vordefiniert, andere muss der Programmierer selber definieren.
Die Funktion alert() ist zum Beispiel vordefiniert, die Funktion output() hingegen wurde extra für das CodeLab definiert.

Jedesmal, wenn ein Programm bei einer Zeile mit einem output() angelangt, führt es den Code aus, der in der Funktion output() definiert ist. (Du kannst den Code unter "weitere Informationen" studieren).
Stell dir vor, du müsstest jedesmal diesen langen Codeblock schreiben, um Daten auszugeben.

Dank der Funktion ist das Programm kürzer und einfacher zu lesen. Und hat man einen Fehler gemacht, muss man den nur einmal korrigieren.

Einfache Funktionen selber definieren

Eine eigene Funktion kannst du so definieren:

function funktionsname() //Deklaration { //Funktionskörper }

Die Funktion kann vor oder nach dem eigentlichen Programm definiert werden.
Es können beliebig viele Funktionen geschrieben werden. Jeder Funktionsname muss aber einmalig sein! Definierte Funktionen können dann wie bestehende Befehle aufgerufen werden.
Um diese Funktion dann aufzurufen, musst du einfach funktionsname(); schreiben.

Beispiel:

getName(); output('Hallo '+name); function getName() { output('Bitte gib deinen Namen ein:'); name=prompt(); }

Für Funktionsnamen gelten die selben Regeln wie für Variablennamen:

Sie dürfen keine Leerzeichen enthalten
Sie dürfen nur aus Buchstaben und Ziffern bestehen - das erste Zeichen muss ein Buchstabe sein
Einziges erlaubtes Sonderzeichen ist der Unterstrich (Umlaute sind verboten!)

Siehe auch Tipps_7 zu Funktionsnamen.

Der Befehl input() darf in Funktionen nicht vorkommen!

Funktionen mit Parametern

Manchmal ist es nötig, der Funktion bestimmte Daten zu übergeben. Diese können in den Klammern nach dem Funktionsnamen angegeben werden:

function meineFunktion(bar) { //Anweisungen verwenden die Variable bar }

Um eine Funktion mit Parametern aufzurufen, müssen diese Parameter beim Aufruf mit einem Wert gefüllt werden.
Beispiel:

getName('Bitte Name eingeben:'); output('Hallo '+name); function getName(text) { name=prompt(text); }

Es können auch mehrere Parameter übergeben werden. Dies werden durch Kommas getrennt.
Beispiel:

getName('Bitte Name eingeben:','Name'); output('Hallo '+name); function getName(text,def) { name=prompt(text,def); }

Funktionen mit Rückgabewerten

Manchmal ist es nötig, dass eine Funktion einen Wert zurückgibt. Zum Beispiel das Resultat einer Berechnung oder eine Meldung, ob alles funktioniert hat. In der Funktionsdefinition muss man dazu das Schlüsselwort return verwenden.

Beispiel:

name=getName('Bitte Name eingeben:'); output('Hallo '+name); function getName(text) { n=prompt(text); return n; }

Tritt in einer Funktion das Schlüsselwort return auf, wird die Funktion automatisch beendet

Gültigkeitsbereich von Variablen

Bei grösseren Programmen mit mehreren Funktionen und vielen Variablen besteht schnell die Gefahr, dass versehentlich schon verwendete Variablennamen verwendet werden.

Bei folgendem Programm, welches das kleine 1x1 ausgeben soll, gibt es ein ernstes Problem:

//Hauptprogramm for(i=1; i<=10; i++) { z=reihe(i); output(z); } function reihe(n) { r=''; for(i=1; i<=10; i++) { r=r+String(i*n)+', '; } return r; }

Die Variable i hat nach dem ersten Aufruf der Funktion reihe() den Wert 10. Die Schleife des Hauptprogramms wird also nur einmal durchlaufen.

Das Problem liegt darin, dass die Variable i eine globale Variable ist. Das heisst ihr Wert kann von allen Programmteilen geändert werden.
Eine Lösung besteht darin, die Variable i in der Funktion reihe() anders zu benennen. Dies ist aber nicht so klug, denn der neue Variablenname könnte zu neuen Fehlern führen...

Um solche Fehler zu verhindern, kann man die Variablen lokal definieren. Lokale Variablen sind nur in der Funktion "sichtbar" in der sie definiert wurden.
Variablen sind lokal, wenn vor ihrer ersten Definition das Codewort var steht:

//Hauptprogramm for(i=1; i<=10; i++) { z=reihe(i); output(z); } function reihe(n) { var r=''; var i; for(i=1; i<=10; i++) { r=r+String(i*n)+', '; } return r; }

Vordefinierte Funktionen

In jeder Programmiersprache gibt es vordefinierte Funktionen. Einige Funktionen können einfach so verwendet werden, andere stehen erst zur Verfügung, wenn eine bestimmte Funktionsbibliothek in das Programm eingebunden wird.
Die Gesammtheit aller vordefinierter Funktionen nennt man API (Applications Programmer Interface). Je grösser das API ist, desto komplexere Programme kann man schreiben, desto länger geht es aber, bis man die Sprache kennt...

Auch in JavaScript gibt es viele vordefinierte Funktionen. Auf dieser Seite sind die wichtigsten Funktionen aufgelistet und erklärt.

Allgemeine Funktionen

Name	Kurzbeschreibung	Beispiel
alert()	Zeigt ein Informations-Dialogfenster an.	`alert('Hallo Welt!');`
`void alert(string Textmedlung)` Die Funktion alert() erwartet einen String-Parameter. Dieser Text wird in einem Dialogfenster ausgegeben. Das Programm wird angehalten, bis der Benutzer 'OK' drückt.
confirm()	Zeigt ein Frage-Dialogfenster an.	`halt=confirm('Beenden?');`
`bool confirm(string Textmeldung)` Die Funktion confirm() erwartet als Parameter eine Ja/Nein-Frage. Liefert true oder false zurück.
prompt()	Zeigt ein Eingabe-Dialogfenster an.	`eingabe=prompt('Name:','');`
`string prompt(string Textmeldung, string Feldvorbelegung)` Die Funktion prompt() zeigt ein Dialogfenster mit einer Eingabeaufforderung, einem Eingabefeld und einem OK- und Abbrechen-Button an. Erwartet zwei Parameter: Textmeldung = Text, der angibt, was einzugeben ist. Feldvorbelegung = Text, der im Eingabefeld steht. Soll das Feld leer sein, muss man eine leere Zeichenkette "" übergeben.

Math-Funktionen

Im Math-Objekt werden verschieden Konstanten und Funktionen für mathematische Berechnungen zusammengefasst. Um auf diese Konstanten oder Funktion zuzugreifen, muss man vor dem Aufruf Math. schreiben:

//Allgemein: //x=Math.Konstante; //x=Math.Funktion(); pi=Math.PI; wurzel3=Math.sqrt(3);

Name	Kurzbeschreibung	Beispiel
Math.PI	Konstante π	`pi=Math.PI;`
`number Math.PI`
Math.abs()	Positiver Wert einer Zahl	`z=Math.abs(-2)`
`number Math.abs(number)` Erwartet als Parameter eine Zahl und berechnet den absoluten (positiven) Wert dieser Zahl.
Math.ceil()	Rundet eine Zahl auf	`z=Math.ceil(-3.456)`
`number Math.ceil(number)` Erwartet als Parameter eine Zahl und rundet diese Zahl auf die nächsthöhere Ganzzahl auf.
Math.floor()	Rundet eine Zahl ab	`z=Math.floor(-3.456)`
`number Math.floor(number)` Erwartet als Parameter eine Zahl und rundet diese Zahl auf die nächstniedrigere Ganzzahl ab.
Math.pow()	Berechnet die Potenz einer Zahl	`z=Math.pow(2,8)`
`number Math.pow(number Basis, number Exponent)` Erwartet zwei Zahlen als Parameter. Die erste Zahl ist die Basis, die zweite der Exponent. Gibt Basis hoch Exponent zurück.
Math.random()	Zufallszahl zwischen 0 und 1	`z=Math.random()`
`number Math.random()` Gibt eine Bruchzahl zwischen 0 und 1 zurück, z.B. . Erwartet keine Parameter.
Math.round()	Rundet eine Zahl auf oder ab.	`z=Math.round(3.589)`
`number Math.round(number)` Erwartet eine Zahl als Parameter. Rundet diese Zahl abhängig von der ersten Stelle nach dem Komma auf oder ab.
Math.sqrt()	Quadratwurzel	`z=Math.sqrt(2)`
`number Math.sqrt(number)` Erwartet eine Zahl als Parameter. Berechnet die Quadratwurzel dieser Zahl.

String-Funktionen

Im String-Objekt werden verschieden Konstanten und Funktionen für die Behandlung von Zeichenketten (Strings) zusammengefasst. Um auf diese Konstanten oder Funktion zuzugreifen, muss man sie mit eine Punkt getrennt hinter eine Zeichenkette schreiben:

//Allgemein: //x=String.Konstante; //x=String.Funktion(); laenge='Hallo Welt'.length; GROSS='Hallo Welt'.toUpperCase();

Name	Kurzbeschreibung	Beispiel
length	Anzahl Zeichen	`laenge='Hallo Welt'.length;`
`number String.length` Diese Eigenschaft speichert die Anzahl der Zeichen in einer Zeichenkette. Auch die Leerzeichen zählen!
charAt()	Zeichen an Position	`zeichen='Hallo Welt'.charAt(7);`
`string String.charAt(number)` Erwartet als Parameter eine Zahl. Liefert das Zeichen der Zeichenkette an der entsprechenden Position.
indexOf()	Erste Position einer Zeichenkette	`zeichen='Hallo Welt'.indexOf('Welt');`
`number String.indexOf(string)` Erwartet eine Zeichenkette als Parameter. Sucht nach dieser Zeichenkette und gibt an, an welcher Stelle die Zeichenkette als erstes gefunden wurde.
lastIndexOf()	Letze Position einer Zeichenkette	`zeichen='Hallo Welt'.lastIndexOf('Welt');`
`number String.lastIndexOf(string)` Erwartet eine Zeichenkette als Parameter. Sucht nach dieser Zeichenkette und gibt an, an welcher Stelle die Zeichenkette als letztes gefunden wurde.
slice()	Extrahiert Zeichenkette	`zeichen='Hallo Welt'.slice(0,4);`
`string String.slice(number Anfang, number Ende)` Erwartet zwei Parameter: den Anfang und das Ende der zu extrahierenden Zeichenkette. Es wird bei 0 zu zählen begonnen. Wenn man den zweiten Parameter weglässt, wird bis zum Ende extrahiert.
substr()	Extrahiert Zeichenkette	`zeichen='Hallo Welt'.substr(0,4);`
`string String.substr(number Anfang, number Länge)` Erwartet zwei Parameter: den Anfang und die Länge der zu extrahierenden Zeichenkette. Es wird bei 0 zu zählen begonnen. Wenn man den zweiten Parameter weglässt, wird bis zum Ende extrahiert.
toLowerCase()	In Kleinbuchstaben umwandeln	`zeichen='Hallo Welt'.toLowerCase();`
`string String.toLowerCase()` Wandelt eine Zeichenkette in Kleinbuchstaben um. Erwartet keine Parameter.
toLowerCase()	In Grossbuchstaben umwandeln	`zeichen='Hallo Welt'.toUpperCase();`
`string String.toUpperCase()` Wandelt eine Zeichenkette in Grossbuchstaben um. Erwartet keine Parameter.