copyright 1999 - 2014 by heinz prelle - hannover  - lenbachstraße 42 - www.visual-basic5.de | impressum
2. Einleitung:
Beim Programmieren erlebt man es recht häufig, daß man auf ein Teilproblem stößt, für das man sich irgendwann schon einmal in dieser oder ähnlicher Form ein Stück Programm überlegt hatte. Es ist absolut keine Schande, wenn man dann dieses Programm wieder hervorkramt und den betreffenden Teil für sein neues Programm, eventuell entsprechend angepaßt, übernimmt. 'Angewandte Intelligenz' könnte man das nennen. Besonders angenehm wird es, wenn dieses Programm schon ausgetestet war!

Die Sprache BASIC unterstützt sogar diesen zielorientierten Arbeitsstil, indem sie eine ganze Reihe von Programmen zur Verfügung stellt, in denen häufig auftretende Programmieraufgaben schon fix und fertig gelöst sind und deshalb vom Programmierer einfach übernommen werden können. In der Hauptsache sind dies Programme, die, ähnlich dem Taschenrechner, gewisse mathematische Standardaufgaben erfüllen, z.B. das Berechnen einer Quadratwurzel, oder die Aufgaben erledigen, die in der Programmiersprache BASIC sehr schwierig lösbar sind. Keines dieser Programme, die man auch Standardfunktionen oder eingebaute oder vorgefertigte Funktionen nennt, ist in der Sprache BASIC geschrieben. Diese Programme sind in der sogenannten Maschinensprache geschrieben, einer Sprache, die die speziellen Besonderheiten des elektronischen Aufbaus Ihres Computers berücksichtigt, ihm sozusagen auf den Leib maßgeschneidert ist und deshalb von den besonderen Stärken Ihres Computers Gebrauch machen kann. Mit den Befehlen dieser Maschinensprache kann man Programme schreiben, die, gemessen an dem, was sie tun, schneller sind und weniger Speicherplatz benötigen als Programme, die in VB geschrieben sind.
Wo liegt dann der Vorteil von BASIC?, werden Sie fragen. Nun, das Programmieren von BASIC ist wesentlich leichter zu erlernen.
Zeichenkettenfunktionen:
1. Die Funktion LEN(...)
Oft kommt es vor, daß man im Verlauf eines Programms die Anzahl der Zeichenkette wissen muß. Diese liefert die Funktion LEN (LEN sind die ersten drei Buchstaben des englischen Wortes length, deutsch: Länge). Sie wird folgendermaßen benutzt: Ist A$ die Textvariable, deren Wert die Zeichenkette ist, dann erhält man die Anzahl der Zeichen (oder die ' Länge' von A$) z.B. durch die Zuweisung

N = LEN(A$)

Man erkennt aus dem Beispiel:

1. Die Textvariable, deren Länge man benötigt, steht in Klammern eingeschlossen hinter LEN.
2. Alles, was zwischen diesen Klammern steht, wird auch das 'Argument' der Funktion LEN genannt. Das gilt übrigens für alle der hier zu besprechenden Funktionen.
3. Solch eine Funktion wird wie eine Variable verwendet. Ist das Argument angegeben, dann hat sie einen ganz bestimmten Wert, den man dann z.B. einer anderen Variablen(die wir hier N genannt haben) zuweisen kann. Aber auch in anderen Anweisungstypen kann eine Funktion auftreten, z.B. in

Print LEN(A$)

Mit dem Wert dieser Funktion kann man auch Ausdrücke bilden, z.B.:

M = 2 * LEN(A$)-1

4. Im Argument der Funktion benutzten wir bisher immer nur eine Variable. Man kann hier aber auch eine Textkonstante direkt hineinschreiben, z.B.

K = LEN("14. MAI 2000")

K erhält dann den Wert 12. Die Leerzeichen zwischen . und M und I und 2 werden natürlich mitgezählt. Das Argument kann sogar ein Ausdruck sein, soweit es bei Textvariablen überhaupt sinnvoll ist, einen solchen zu bilden.

Beispiel:

A$ = "KINDER"
B$ = "GARTEN"
N = LEN(A$ + B$)


Das Ergebnis der Verkettung A$ + B$ ist KINDERGARTEN, damit hat N nach Ausführung den Wert 12.


2. Die Funktion LEFT$(...)


















 
 
Mit Hilfe der nächsten drei zu besprechenden Funktionen LEFT$(...), RIGHT$(...) und MID(...) können aus Zeichenketten Zeichenketten beliebige Teilketten herausgenommen werden. Man kann sich schon hier einprägen, daß diejenigen Funktionen, deren Werte aus Zeichen bestehen, im Namen als letztes Zeichen ein $ haben. Das werden wir gleich genauer sehen. Beginnen wir mit der Funktion LEFT$(...). Angenommen, wir wollen von einer Zeichenkette, sagen wir KINDERGARTEN, die ersten 4 Zeichen, beginnend am linken Ende, einer anderen Variablen zuweisen. Dies ermöglicht die Funktion LEFT$(...).

A$ = "KINDERGARTEN"
B$ = LEFT$(A$,4)

Nach Ausführung der Zeile B$ hat B$ den Wert KIND. Allgemein hat LEFT$(...) den folgenden Aufbau:
LEFT$(Zeichenkette(Variable oder Konstante oder Ausdruck),(Anzahl der auszuwählenden Zeichen von links gezählt)

Die LEFT$(...)-Funktion hat also 2 Argumente.
A$ hat auch nach der Ausführung der Zeile B$ immer noch den Wert KINDERGARTEN, die ersten vier Zeichen werden nach B$ kopiert.

Hier noch ein anderes Beispiel:

PRINT LEFT$("KARL MEIER",1)

Druckt den 1. Buchstaben von links, also K, aus.


3. Die Funktion RIGHT$(...)

Ganz ähnlich wie LEFT$(...) arbeitet auch die Funktion RIGHT$(...).


Sie liefert eine gewisse Anzahl von Zeichen, diesmal aber vom rechten Ende der Zeichenkette. (Das englische Wort right heißt 'rechts'.)

PRINT RIGHT$("KARL MEIER",1)

Bewirkt Auswahl eines Buchstabens, beginnend am rechten Ende, also Ausgabe von R.

A$ = "KINDERGARTEN"
B$ = RIGHT$(A$,6)

Weist B$ den Wert GARTEN zu.


4. Die Funktion MID$(...)

Wenn wir Teile von Zeichenketten an beliebiger Stelle auswählen wollen, dann ist uns mit RIGHT$(...) und LEFT$(...) noch nicht geholfen, denn die hiermit ausgewählten Teile beginnen ja immer am rechten bzw. am linken Ende. Mit der Funktion MID$(...) wird es jedoch möglich, beliebige Teilketten auszuwählen. Diese Funktion gibt es in zwei Formen:

a) MID$(...) mit 2 Argumenten
Beispiel:

A$ = "KINDERGARTEN" B$ = MID$(A$,7)

Hier bewirkt MID$(...), daß ab Position 7 der Zeichenkette alle Zeichen bis zum Ende der Kette der Variablen B$ zugewiesen werden. B$ erhält damit den Wert GARTEN.

b) MID$(...) mit 3 Argumenten
Beispiel:
A$ = "KINDERGARTEN"
B$ = MID$(A$,7,3)


Das letzte Argument(hier 3) besagt, daß ab der Position 7 eine Kette der Länge 3 ausgewählt werden soll. Nach Ausführung von Zeile B$ hat B$ den Wert GAR. (MID steht für das englische Wort middle und bedeutet 'Mitte')

Interessant und wichtig ist die Tatsache, daß eine Funktion in passenden Fällen ein Argument einer anderen Funktion sein kann.

Beispiel:

A$ = "KINDERGARTEN"
N = LEN(MID$(A$,7))


Argument von LEN(...) ist hier, ganz wie es sein soll, eine Zeichenkette, denn der Wert von MID$(A$,7) ist ja eine solche. MID$(A$,7) ist die Teilkette von A$, die sich von der 7. Position von A$ bis zum rechten Ende von A$ erstreckt. Diese Teilkette lautet GARTEN. Die Länge dieser Zeichenkette ist 6 Zeichen, also erhält N den numerischen Wert 6.


5. Die Funktionen VAL(...) und STR$(...)

Diese beiden Funktionen sind gewissermaßen Umkehrungen voneinander. Die Wirkung von VAL(...) ist folgende: Das Argument von VAL(...) muß eine Zeichenkette sein, aber eine solche Zeichenkette, die, würde man sie als Zahlenwert auffassen, auch einen Sinn ergäbe.

Beispiel:

X$ = "123"

Wäre ein erlaubtes Argument von VAL(...). Ebenso

X$ = "0.014"

Nicht aber

X$ = "DC10"

Die Funktion VAL(...) wandelt dann eine solche Zeichenkette in einen numerischen Wert um:

X = VAL("123")

Macht aus den aneinandergesetzten Zeichen "1", "2", "3" die Zahl 123(einhundertdreiundzwanzig) und weist sie der Variablen X zu. Oder aus der Zeichenkette "0.014" wird vermittels VAL(...) der Zahlenwert 0.014:

X = VAL("0.014")

VAL kommt aus dem englischen Wort value, das heißt 'Zahlenwert'.

Umkehrende Wirkung hat die Funktion STR$(...). Wie schon das Zeichen $ in ihrem Namen zeigt, ist ihr Wert immer eine Zeichenkette. Ihr Argument ist jedoch immer numerisch. STR$(...) wandelt einen Zahlenwert (z.B. 1.27) in eine Zeichenkette um, die die gleichen Zeichen enthält:

X$ = STR$(1.27)
PRINT X$


Liefert die Zeichenkette 1.27.


6. Die Funktionen ASC(...) und CHR$(...)

Auch diese beiden Funktionen sind eine Art Umkehrung voneinander. Sie werden sich sicher daran erinnern, daß jedes Zeichen, das man über die Tastatur eingibt, sei es nun ein Buchstabe, eine Ziffer oder ein Sonderzeichen, im Computer als eine Zahl gespeichert wird. Der Computer benutzt einen bestimmten Code, den ASCII-Code nämlich, zu dieser Umwandlung. Der Buchstabe A z.B. wird in eine 65 verwandelt und so gespeichert. Dieser Vorgang erfolgt automatisch ohne Zutun des Programmierers. In manchen Fällen ist es aber recht nützlich, solche Umwandlungen auch in einem VB Programm vornehmen zu können. Natürlich nicht zum Zweck der Speicherung, die erfolgt ja, wie gesagt, automatisch, sondern für andere, teils recht knifflige Anwendungen.

ASC(...)

Die Funktion ASC(...) wandelt ein Zeichen, das das Argument der Funktion bildet, in den entsprechenden Zahlenwert gemäß dem ASCII-Code um.
Beispiel:

Print ASC("A")

Bewirkt die Ausgabe der Zahl 65, des ASCII-Codes des Buchstaben A also.

Print ASC("7")

Behandelt 7 als Zeichen und liefert den ASCII-Code für dieses Zeichen, nämlich die Zahl 55. Der Name ASC der Funktion soll daran erinnern, daß sie eine Umwandlung in den ASCII-Code vornimmt.

Beispiel:
A$ = "NEIN"
PRINT ASC(A$)


Was geschieht hier? Da die Funktion ASC(...) immer nur ein Zeichen in den ASCII-Code umwandeln kann, nimmt sie bei Textvariablen, deren Wert aus mehr als einem Zeichen besteht, stets das erste Zeichen links und wandelt es um.

Mit dem folgenden kleinen Programm könnten wir einen beliebigen Text eingeben, Zeichen für Zeichen in den ASCII-Code umwandeln und diesen wieder ausgeben:

A$ = "KINDERGARTEN"
FOR I = 1 TO LEN(A$)
Z$ = MID$(A$,I,1)
PRINT Z$,ASC(Z$)
Next I


Die zeichenweise Umwandlung erfolgt in einer FOR-Schleife. Dazu müssen wir wissen, wie viele Zeichen umgewandelt werden sollen, d.h. wie lang der eingegebene Text A$ ist. Entsprechend oft wird die Schleife durchlaufen. Die Anzahl der Zeichen gibt uns die Funktion LEN(A$). Dieser Wert dient uns als obere Grenze der Laufvariablen der FOR- Schleife. In Zeile Z$ isolieren wir mit Hilfe der Funktion MID$(...) ein Zeichen nach dem anderen, bei jedem Durchlaufen der Schleife das weiter rechts stehende. Dieses Zeichen weisen wir vorläufig erst einmal der Variablen Z$ zu. Das zweite Argument der Funktion MID$(...) ist die Laufvariable I der FOR - Schleife. Diese nimmt nacheinander die Werte 1,2,3 usw. bis zum Wert LEN(A$) an. Entsprechend wird der Hilfsvariablen Z$ nacheinander das 1.,2.,3. usw. Zeichen von A$ zugewiesen. In der Zeile PRINT erfolgt die Ausgabe dieses Zeichens und des zugehörigen ASCII-Werts nebeneinander in der Zeile.

CHR$(...)

Nun fehlt uns nur noch die Erklärung der Funktion CHR$(...). Wie bereits gesagt, ist CHR$(...) eine Art Umkehrung der Funktion ASC.
CHR$(...) liefert für einen ASCII-Code das zugehörige Zeichen.

Beispiel:
PRINT CHR$(65)

Bewirkt die Ausgabe des Buchstabens A. (Die Bezeichnung CHR ist vom englischen Wort character abgeleitet, das die Bedeutung von Schriftzeichen hat.)

Das Argument von CHR$(...) muß ganzzahlig sein, nicht negativ und darf nicht größer als 255 sein.
 
 
 
 
Zeichenkettenfunktionen
1. Funktionen:
[LEN] [LEFT$] [RIGHT$] [MID$] [VAL] [STR$] [ASC] CHR$