Kapitel 3: Funktionen

Funktionen und Prozeduren sind die grundlegenden Bausteine jedes Harbour-Programms. Sie erlauben es, Code in logische, wiederverwendbare und leicht wartbare Einheiten zu organisieren. In diesem Kapitel werden wir untersuchen, wie man Funktionen definiert und verwendet, den Unterschied zwischen ihnen und Prozeduren, wie man Parameter handhabt und einige der wichtigsten Hilfsfunktionen.

Prozeduren (`PROCEDURE`) vs. Funktionen (`FUNCTION`)

In Harbour werden sowohl PROCEDURE als auch FUNCTION verwendet, um Unterprogramme zu definieren. Obwohl sie sehr ähnlich sind, liegt der Hauptunterschied konzeptionell darin, ob sie einen Wert zurückgeben oder nicht.

**`FUNCTION`**: Eine Funktion ist ein Unterprogramm, das dazu entworfen ist, eine bestimmte Aufgabe auszuführen und **einen Wert** an den aufrufenden Code **zurückzugeben**. Der Wert wird mit der Anweisung `RETURN` zurückgegeben. Wenn kein Rückgabewert angegeben wird, gibt eine Funktion standardmäßig `NIL` zurück.


    // Definiere eine Funktion, die zwei Zahlen addiert und das Ergebnis zurückgibt
    FUNCTION Summe( n1, n2 )
       LOCAL nErgebnis
       nErgebnis := n1 + n2
    RETURN nErgebnis

    // Rufe die Funktion auf und speichere den zurückgegebenen Wert
    LOCAL nMeineSumme
    nMeineSumme := Summe( 5, 10 ) // nMeineSumme enthält 15
    ? nMeineSumme

**`PROCEDURE`**: Eine Prozedur ist ein Unterprogramm, das eine Reihe von Aktionen ausführt, aber **keinen expliziten Wert zurückgibt**. Ihr Zweck ist die Ausführung eines Prozesses, wie das Drucken auf den Bildschirm oder das Modifizieren einer Datenbank. In der Praxis ist eine Prozedur in Harbour einfach eine Funktion, die keine `RETURN`-Anweisung mit einem Wert hat. Intern gibt auch sie `NIL` zurück.


    // Definiere eine Prozedur, um einen Gruß anzuzeigen
    PROCEDURE Gruesse( cName )
       ? "Hallo, " + cName + "!"
    RETURN

    // Rufe die Prozedur auf
    Gruesse( "Welt" ) // Gibt "Hallo, Welt!" aus

**Wesentliche Erkenntnis:** Im modernen Harbour ist die Unterscheidung hauptsächlich semantisch. Du kannst FUNCTION für alles verwenden und einfach den `RETURN`-Wert weglassen, wenn er nicht benötigt wird. Die Verwendung von PROCEDURE kann jedoch die Absicht klären, dass ein Unterprogramm kein Ergebnis zurückgeben soll.

Parameter und Argumente

Parameter sind lokale Variablen, die die Werte (Argumente) empfangen, die an eine Funktion oder Prozedur übergeben werden.

**Deklaration**: Parameter werden in einer durch Kommata getrennten Liste in der Funktionsdefinition deklariert.
**Wertübergabe (Standard)**: Standardmäßig übergibt Harbour Argumente als Wert (by value). Das bedeutet, die Funktion erhält eine Kopie der Originaldaten. Wenn die Funktion den Parameter modifiziert, wird die ursprüngliche Variable nicht beeinflusst.
**Referenzübergabe**: Um die ursprüngliche Variable zu modifizieren, kannst du sie per Referenz übergeben, indem du den Operator `@` vor dem Variablennamen beim Aufruf der Funktion verwendest. Innerhalb der Funktion enthält der Parameter dann eine Referenz (Zeiger) auf die ursprüngliche Variable.


FUNCTION ModifiziereWert( nWertPerRef, nWertPerCopy )
   nWertPerRef += 100 // Modifiziert das Original
   nWertPerCopy      += 100 // Modifiziert nur die lokale Kopie
RETURN NIL

LOCAL nA := 10, nB := 10

? "Ursprüngliche Werte:", nA, nB // Gibt aus: 10, 10

ModifiziereWert( @nA, nB ) // nA wird per Referenz, nB per Wert übergeben

? "Modifizierte Werte:", nA, nB // Gibt aus: 110, 10

**Optionale Parameter**: Harbour erlaubt es, eine Funktion mit weniger Argumenten aufzurufen als deklariert. Nicht empfangene Parameter enthalten `NIL`. Die Funktion `PCOUNT()` kann verwendet werden, um herauszufinden, wie viele Argumente tatsächlich übergeben wurden.


FUNCTION Nachricht( cText, cTitel )
   IF PCOUNT() < 2
      cTitel := "Hinweis" // Weist einen Standardwert zu, wenn kein Titel übergeben wurde
   ENDIF
   ? cTitel + ": " + cText
RETURN NIL

Nachricht( "Vorgang abgeschlossen." ) // Gibt aus: "Hinweis: Vorgang abgeschlossen."
Nachricht( "Schwerwiegender Fehler.", "Fehler" )  // Gibt aus: "Fehler: Schwerwiegender Fehler."

Ein-/Ausgabe-Funktionen (E/A)

E/A-Funktionen sind essentiell für die Interaktion mit dem Benutzer. Harbour bietet einen Satz einfacher Funktionen für die Handhabung der Konsole.

`? <ausdruck>`: Gibt einen oder mehrere Ausdrücke auf der Konsole aus, gefolgt von einem Zeilenumbruch.
`QOUT(<ausdruck>)` oder `?? <ausdruck>`: Gibt einen Ausdruck ohne abschließenden Zeilenumbruch aus.
`ACCEPT "<prompt>" TO <variable>`: Zeigt eine Nachricht an und wartet, bis der Benutzer eine Zeichenkette eingibt, die in der Variable gespeichert wird.
`INPUT "<prompt>" TO <variable>`: Ähnlich wie `ACCEPT`, wertet die Eingabe aber als Harbour-Ausdruck aus. Ist weniger sicher und wird nicht empfohlen.
`INKEY(0)`: Wartet, bis der Benutzer eine Taste drückt, und gibt ihren numerischen ASCII-Code zurück. Nützlich für Menüs oder Pausen.
`WAIT "<prompt>"`: Zeigt eine Nachricht an und pausiert die Ausführung, bis eine Taste gedrückt wird.


LOCAL cName

// Fragt den Benutzer nach dem Namen
ACCEPT "Bitte gib deinen Namen ein: " TO cName

// Begrüßt den Benutzer
? "Willkommen,", cName

// Wartet auf einen Tastendruck zum Beenden
WAIT "Drücke eine beliebige Taste, um fortzufahren..."

Hilfsfunktionen (`VALTYPE()`, `PROCNAME()`)

Harbour enthält einen umfangreichen Satz eingebauter Funktionen, die Informationen über den Programmzustand und die verarbeiteten Daten liefern.

**`VALTYPE( <ausdruck> )`**: Gibt eine Zeichenkette mit einem einzelnen Zeichen zurück, die den Datentyp des Ausdrucks angibt. Grundlegend für die Parameter- oder Variablenvalidierung.
`"C"`: Zeichenkette (Character)
`"N"`: Zahl (Numeric)
`"L"`: Logisch (Logical)
`"D"`: Datum (Date)
`"A"`: Array
`"H"`: Hash
`"B"`: Codeblock
`"O"`: Objekt (Object)
`"U"`: Undefiniert (`NIL`)

**`PROCNAME( [nEbene] )`**: Gibt den Namen der aktuellen Funktion oder Prozedur zurück. Wenn eine Ebene angegeben wird, kann der Aufrufstack inspiziert werden, um zu sehen, welche Funktion die aktuelle aufgerufen hat. Ein unschätzbares Werkzeug für die Fehlersuche und Protokollierung.


FUNCTION MeineRoutine( xParameter )
   LOCAL cDatentyp

   // Holt den Namen der aktuellen Funktion
   ? "Führe Funktion aus:", PROCNAME()

   // Validiert den Typ des Parameters
   cDatentyp := VALTYPE( xParameter )

   IF cDatentyp == "C"
      ? "Der Parameter ist eine Zeichenkette:", xParameter
   ELSEIF cDatentyp == "N"
      ? "Der Parameter ist eine Zahl:", xParameter
   ELSE
      ? "Der Parameter hat einen unerwarteten Typ:", cDatentyp
   ENDIF
RETURN NIL

// Beispielaufrufe
MeineRoutine( "Hallo" )
MeineRoutine( 123.45 )
MeineRoutine( .T. )