Nützliche Funktionen und Prozeduren in Delphi

In diesem Artikel werde ich einige nützliche und wissenswerte Funktionen der Programmiersprache Delphi tabellarisch auflisten.

Sie sind nach verschiedenen Themengebieten der Programmierung geordnet.

Falls Fragen zur Verwendung der Funktionen aufkommen, so ist es besonders hilfreich die Hilfe per Tastendruck auf F1 aufzurufen. Dort werden alle Parameter und die Funktionsweise erläutert. Alternativ kann auch gerne im Internet gesucht werden.

Arithmetische Routinen

Mit den Funktionen dieser Gruppe lassen sich die verschiedensten Integer- und Gleitkommaberechnungen und andere arithmetische oder erweiterte mathematische Operationen durchführen.

Funktion	Bedeutung
`ABS`	Absolutwert des Arguments.
`ARCTAN`	Arcustangens des Arguments.
`COS`	Kosinus des Arguments. Das Argument muss dabei im Bogenmaß übergeben werden.
`EXP`	Exponentialwert des Arguments.
`FRAC`	Nicht ganzzahliger Anteil des Arguments.
`INT`	Ganzzahliger Anteil des Arguments.
`LN`	Natürlicher Logarithmus des Arguments.
`PI`	Wert der Konstanten Pi.
`RANDOM`	Liefert eine Zufallszahl zurück.
`RANDOMIZE`	Initialisiert den Zufallsgenerator.
`ROUND`	Das Real-Argument wird auf einen ganzzahligen Wert gerundet.
`SIN`	Sinus des Arguments.
`SQR`	Quadrat des Arguments.
`SQRT`	Quadratwurzel des Arguments.
`TRUNC`	Wandelt einen Real-Wert in einen Integer-Wert um, indem die Nachkommastellen verworfen werden.

Behandlung von Ordinalwerten

Eine Reihe von Routinen hilft uns beim Umgang mit Ordinalwerten – also mit aufzählbaren Typen wie Integer-, Zeichen, oder auch Aufzählungstypen.

Funktion	Bedeutung
`DEC`	Vermindert eine Variable um einen bestimmten Wert.
`INC`	Erhöht eine Variable um einen bestimmten Wert.
`ODD`	Prüft, ob das Argument eine ungerade Zahl ist.
`PRED`	Liefert den Vorgänger des Arguments.
`SUCC`	Liefert den Nachfolger des Arguments
`CHR`	Wandelt eine Ordinalzahl in das dazugehörige Zeichen um.
`HIGH`	Ergibt den höchsten Wert im Bereich des Arguments.
`LOW`	Ergibt den niedrigsten Wert im Bereich des Arguments
`ORD`	Wandelt einen ordinalen Typ in die dazugehörige Ordinalzahl um.

Routinen für die Umwandlung von Fließkommawerten

Mit Routinen für die Typkonvertierung kann ein Typ in einen anderen konvertiert werden. Es noch einige weitere, die sich speziell mit Fließkommawerten beschäftigen, nämlich:

Funktion	Bedeutung
`FloatToDecimal`	Wandelt einen Real-Wert in einen Verbundtyp um, der zur weiteren Formatierung geeignet ist.
`FloatToStrF`	Wandelt einen Real-Wert in eines von mehreren vordefinierten Zahlenformaten um.
`FloatToStr`	Wandelt einen Real-Wert in eine Zeichenfolge um.
`FloatToText`	Ähnlich wie FloatToStr, aber das Ergebnis wird in einem Puffer abgelegt.
`FormatFloat`	Formatiert den übergebenen Real-Wert analog zum ebenfalls übergebenen Formatierungsstring.
`StrToFloat`	Wandelt eine Zeichenfolge in einen Real-Wert um, falls möglich.
`TextToFloat`	Wandelt einen null-terminierten String in einen Real-Wert um.

Routinen für die String-Bearbeitung

Eine ganze Reihe von Routinen stehen zur Stringverwaltung zur Verfügung. Zum einen gibt es Routinen, die es ermöglichen, Strings zu formatieren, zum anderen erleichtern sie das Arbeiten mit nullterminierten Strings.

Die “traditionellen” Routinen zur Bearbeitung von Strings sind:

Funktion	Bedeutung
`CONCAT`	Verbindet mehrere Strings
`COPY`	Kopiert einen Teil aus einem String
`DELETE`	Löscht einen Teil innerhalb eines Strings
`INSERT`	Fügt einen String in einen anderen ein
`LENGTH`	Ermittelt die Anzahl der Zeichen in einem String
`POS`	Sucht einen String in einem anderen und gibt die Position des ersten Zeichens der Fundstelle zurück
`LOWERCASE`	Konvertiert alle Zeichen in einem String in Kleinbuchstaben
`UPPERCASE`	Konvertiert alle Zeichen in einem String in Großbuchstaben
`TRIM`	Entfernt Leerzeichen in einem String, die am Anfang oder Ende stehen
`TRIMLEFT`	Entfernt alle Leerzeichen am Anfang des Strings
`TRIMRIGHT`	Entfernt alle Leerzeichen am Ende des Strings
`VAL`	Wandelt einen String in eine Zahl um, falls möglich

Es existieren außerdem folgende Funktionen, um Strings in Zahlen und umgekehrt zu wandeln:

Funktion	Bedeutung
`IntToHex`	Wandelt einen Integer in einen String um, wobei das Zahlenformat im Hexadezimalsystem benutzt wird.
`IntToStr`	Wandelt einen Integer in einen String um.
`StrToInt`	Versucht, eine Zeichenfolge in einen Integerwert umzuwandeln.
`StrToIntDef`	Wandelt eine Zeichenfolge in eine Ganzzahl um. Lässt sich aus der Zeichenfolge kein Integer-Wert konstruieren, wird stattdessen ein Standardwert zurückgegeben.

Des Weiteren können folgende Ausdrücke genutzt werden, um Strings zu formatieren:

Funktion	Bedeutung
`Format`	Formatiert eine Reihe von Argumenten und liefert das Ergebnis als String zurück.
`FmtStr`	Formatiert eine Reihe von Argumenten; das Ergebnis wird im Argument Result zurückgegeben.
`FormatBuf`	Formatiert eine Reihe von Argumenten.
`StrFmt`	Formatiert eine Reihe von Argumenten; das Ergebnis ist ein null-terminierter String.
`StrLFmt`	Formatiert eine Reihe von Argumenten; das Ergebnis enthält einen Zeiger auf den Zielpuffer.

Routinen für Datum/Uhrzeit

Delphi hat etliche Routinen zu bieten, mit denen wir bequem mit Datum und Uhrzeit arbeiten können. Das sind die folgenden:

Funktion	Bedeutung
`Date`	Liefert das aktuelle Datum im TDateTime-Format zurück.
`DateTimeToStr`	Wandelt das TDateTime-Format in einen String um.
`DateTimeToString`	Wandelt das TDateTime-Format in einen String um, berücksichtigt dabei aber die Formatierungsinformationen, die als Argument übergeben wurden.
`DateToStr`	Wandelt einen Datumsformat-Wert in einen String um.
`DayOfWeek`	Liefert den aktuellen Wochentag zurück.
`DecodeDate`	Dekodiert das angegebene Datum.
`DecodeTime`	Dekodiert die angegebene Uhrzeit.
`EncodeDate`	Wandelt die einzeln übergebenen Werte in das Datums-/Zeit- Format um..
`FormatDateTime`	Wandelt ein TDateTime-Format in einen String um, berücksichtigt dabei die übergebenen Formatinformationen.
`Now`	Liefert das aktuelle Datum und die Uhrzeit.
`StrToDate`	Wandelt eine Zeichenkette in das Datumsformat um.
`StrToDateTime`	Wandelt eine Zeichenkette in das TDateTime-Format um.
`StrToTime`	Wandelt eine Zeichenkette in das Zeitformat um.
`Time`	Liefert die aktuelle Uhrzeit zurück.
`TimeToStr`	Wandelt das Zeitformat in eine Zeichenkette um.

Nützliche Dialoge

Delphi stellt einige vordefinierte Dialoge zur Verfügung, um eine Meldung anzuzeigen oder vom Anwender einen Wert zu erfragen:

Funktion	Bedeutung
`InputBox`	Stellt eine Dialogbox dar, in der der Benutzer etwas eingeben kann.
`InputQuery`	Wie InputBox, aber die Funktion liefert TRUE oder FALSE zurück, je nachdem, ob der Benutzer den Schalter »OK« oder »Abbruch« angeklickt hat.
`MessageDlg`	Zeigt ein Meldungsfenster an, wobei der Text, ein Hinweis-Symbol und die Buttons innerhalb des Fensters festgelegt werden können.
`MessageDlgPos`	Wie MessageDlg, aber zusätzlich kann noch die Position des Meldungsfensters angegeben werden.
`ShowMessage`	Zeigt eine einfache Dialogbox mit der Meldung an.
`ShowMessagePos`	Wie ShowMessagePos, aber zusätzlich kann die Position des Meldungsfensters angegeben werden.

Die Funktion ShowMessage ist eine praktische »Abkürzung«, um mal schnell
eine Meldung auszugeben. Ein Aufruf wie

ShowMessage('Dies ist ein Test!');

erzeugt ein kleines modales Dialogfenster, das der Anwender erst mit “OK” bestätigen muss, bevor er weiterarbeiten kann.

Was ist ein “modales Dialogfenster”?
Ein “modaler” Dialog ist ein Dialog, der erst geschlossen werden muss, bevor man mit anderen Formularen des Programms weiterarbeiten kann. Dies dient dazu, den Anwender zu zwingen, eine Meldung zur Kenntnis zu nehmen, oder eine Eingabe zu erfragen, die für die weitere Arbeit unbedingt notwendig ist.

Andere nützliche Routinen

Funktion	Bedeutung
`Exclude`	Ausschließen eines Elements aus einer Menge.
`FillChar`	Füllt einen Speicherbereich mit einem Byte-Wert.
`Hi`	Liefert das höherwertige Byte des Arguments zurück.
`Lo`	Liefert das niederwertige Byte des Arguments zurück.
`Move`	Kopiert eine Anzahl von Bytes von einem Speicherbereich in einen anderen.
`ParamCount`	Liefert die Anzahl der Kommandozeilen-Parameter.
`ParamStr`	Liefert einen Kommandozeilen-Parameter.
`SizeOf`	Liefert die Anzahl Bytes, die eine Variable belegt oder die eine Variable vom angegebenen Typ benötigen würde.
`Swap`	Vertauscht das niederwertige und das höherwertige Byte des Arguments.
`UpCase`	Wandelt ein einzelnes Zeichen in Großbuchstaben um.
`AllocMem`	Reserviert einen Speicherbereich auf dem Heap, wobei jedes Byte im reservierten Bereich auf Null gesetzt wird.
`FreeMem`	Freigabe eines mit AllocMem reservierten Speicherbereichs.
`Beep`	Gibt einen Warnton aus.

Damit war es das mit meiner Übersicht über die notwendigsten Funktionen Delphis.

Ihr müsst sie keineswegs auswendig wissen – dafür ist diese Sammlung da. Ebenso müsst Ihr nicht alle sofort verstehen. Das kommt nach und nach und vor allem auch dann, wenn Ihr sie braucht…