.: vb - grundlagen :.
 
abyter.de \\ workshops

In dieser Rubrik möchte ich für Anfänger Grundlagen der Visual Basic Programmierung behandeln, wie z.B. Variablen.

Variablen in Visual Basic

Sinn von Variablen
Es ist etwas umständlich, immer den vollen Objektnamen anzugeben (z.B. txtEingabe.Text oder noch schlimmer Data1.DataSource = "C:\db\db.mdb"), dies ist erforderlich, wenn man z.B. bei dem mit dem Inhalt eines Textfeldes rechnen will. Wie auch im richtigen Leben gibt es auch in Visual Basic eine Möglichkeit den Objekten sozusagen kürzere und besser zu merkende "Spitz"-Namen zu geben. Diese "Spitz"-Namen heißen Variablen.

Was sind Variablen genau
Wenn ich soeben von einem Spitznamen sprach, so ist dies eher bildlich gemeint. Denn eine Variable ist ein symbolischer Name für einen Speicherbereich im Hauptspeicher. In diesem Speicherbereich werden die der Variable zugewiesenen Daten gespeichert.
Ein Arbeitsspeicher besteht aus Registern, genau genommen müsste man als Programmierer nun die Speicheradresse angeben. Also eigentlich spricht man die Speicheradresse an, jedoch ist diese schwer einzusetzen. Wie kompliziert solche Speicheradresse sind zeigen manche kryptischen Fehlermeldung von Windows.
Darum gibt man dieser Speicheradresse einen Namen, den Variablennamen, ähnlich einer Domain für die IP-Adresse des Servers.

Variablen deklarieren
Bevor man jedoch die Variable verwenden kann, muss man Visual Basic sagen, dass es diese gibt und um welche Art von Variablen es sich handelt. Es gibt zwei Möglichkeiten, dies zu tun, das implizite und das explizite Deklarieren.
Das erste Verfahren bedeutet, dass Visual Basic die Variable automatisch deklariert (d.h. Visual Basic teilt sich selber mit, dass es die Variable gibt und welche Art von Variable es ist), wenn ihr etwas zugewiesen werden soll.
Das explizite Deklarieren bedeutet, dass man vor der Zuweisung von Werten auf die Variable, die Variable vereinbaren (also einbinden) muss; wie das funktioniert folgt gleich.

Warum sollte man explizit deklarieren
Jetzt wird man sich fragen, warum man denn nicht immer die erste Methode verwendet, Visual Basic macht doch alles für einen und man braucht nichts zu tun. Doch dies hat einen großen Nachteil, denn Visual Basic wählt den denkbar schlechtesten Datentypen (Der Datentyp bestimmt die Art und Größe der Variable, die im Hauptspeicher (Stack) reserviert wird) Variant, dieser Datentyp ist ein Allzweck-Datentyp der sowohl Zahlen als auch Zeichenfolgen (Wörter) aufnehmen kann und dies hat seinen Preis (er beansprucht 16 Byte (für Zahlen) oder 22 Byte + 1 Byte pro Zeichen (für Zeichenfolgen) (zum Vergleich:  Integer 2 Byte (für Zahlen) String 1 Byte pro Zeichen (für Zeichenfolgen)). Also, das implizierte deklarieren geht zwar schneller und ist bequemer, aber man sollte dem Hauptspeicher des Benutzers zu liebe, die Variablen "von Hand" explizit deklarieren.

Wie deklariert man explizit?
Das explizite Deklarieren funktioniert so: DIM Variablenname AS Datentyp.
DIM steht für Dimensionierung, also heißt die Deklaration übersetzt dimensioniere die Variable Variablenname als Datentyp. Zum Variablenname ist noch etwas zur Konvention (Gesetz zur Namensgebung) zu sagen: Man kann entweder m (steht für Memory (Speicher)) als Präfix voranstellen um zu zeigen, das es sich um eine Variable handelt, oder man kann den Datentyp als Präfix verwenden (z.B. int für Integer oder strg für String).
Hier eine Tabelle mit Datentypen

Namensgebung bei Variablen
Jeder Variablenname muss mit einem Buchstaben beginnen, der Name darf höchstens 256 Zeichen lang sein (Es ist jedoch nicht sinnvoll lange Namen zu verwenden), er darf keine Sonderzeichen (wie .,;!$%&#) und Leerzeichen enthalten, er darf nur einmal im Gültigkeitsbereich vorkommen und nicht ein von Visual Basic reserviertes Schlüsselwort sein und wie schon erwähnt sollte man zur besseren Identifizierung einen Präfix (entweder aus m oder aus drei Buchstaben des Datentypen) voranstellen.

Wertezuweisung
Nachdem die Variable festgelegt ist, kann man ihr Werte des Datentyps zuweisen. Das geht z.B. so: mVariN = txtVariable.Text, die Anweisung liest man so: Der Variable VariN wir der Inhalt des Textfeldes txtVariable zugewiesen. Also: Man liest Wertezuweisungen immer von rechts nach links.

Sonderfall Textfeld
Zum Thema Textfeld und Rechnen: Leider liefert das Steuerelement Textfeld als Rückgabewert eine Zeichenfolge, wenn man diese einfach einer "Zahlen"-Variable zuweist, bekommt man die Fehlermeldung "Typenunverträglichkeit", also muss man den Inhalt vorher in einen "Zahlen"-Datentypen konvertieren, dies geht mit dem Voranstellen vom Schlüsselwort Val. Das funktioniert so: mVariZahl = Val(txtVariable.Text). Also gar nicht so schwer!
Wenn man das Ergebnis der Rechnung dann wieder zurück in einem Textfeld ausgeben will, muss man auch den ganzen Weg wieder rückwärts gehen, dies geht mit dem Voranstellen des Schlüsselwortes Str. Das funktioniert so: txtVariable2.Text = Str(mVariZahl).

Arrays
Arrays stellen eine Sonderform der Variablen dar, es handelt sich um Datenfelder. Es werden also mehrere gleichartige Variablen mit dem gleichen Namen auf einmal definiert. Alle Elemente innerhalb des Datenfeldes haben den gleichen Datentyp und die Anzahl der Datenelemente muss schon bei der Definition angegeben werden.
Die Definierung funktioniert folgendermaßen:
Dim strMitarbeiter (1 to 5) as String

Der erste Teil (bis zur Klammer) gleicht der gewöhnlichen Variablendefinition, in der Klammer steht dann, wie groß das Datenfeld sein soll (d.h. wie viele gleichartige Variablen erstellt werden sollen). Der Schluss ist wieder normal.
Zugewiesen wird wie folgt:
strMitarbeiter(2) = “Müller“

In der Klammer steht der Index, die ist die Nummer der reservierten Variablen. Die Zuweisung ist also bis auf die Angabe des Indexes identisch mit der gewöhnlichen Variablenzuweisung.
Auch der Aufruf der Array-Variable ist einfach:
Print strMitarbeiter(4)

Wieder muss nur der Index zusätzlich angegeben werden.

Ein- und Ausgabefunktionen in Visual Basic

Wozu braucht man Ein- und Ausgabefunktionen?
Um Eingaben vom Benutzer annehmen zu können, braucht man eine Eingabemöglichkeit. Natürlich kann man für diesen Zweck auch einfach ein Textfeld auf dem Formular aufziehen, doch dies hat den Nachteil, dass das Steuerelement immer sichtbar ist, bzw. ein neues Formular dafür angelegt werden muss. Außerdem muss man die Inhalte des Textfeldes konvertieren, wenn man ihn einer "Zahl"-Variable zuweisen will.
Ähnlich sieht es auch mit der Ausgabe aus. Es ist viel zu umständlich für jede Meldung eine neue Form anzulegen.

InBox-Funktion für die Eingabe
Für die Eingabe gibt es eine Eingabefunktion in Visual Basic, diese heißt InputBox. Wie bei allen Funktionen können der InputBox-Funktion Argumente(Parameter) zugewiesen werden, z.B. für den Inhaltstext.
Eine InputBox-Funktion wird folgendermaßen verwendet:
Variable = InputBox(Beschriftung, Titel, Standardinhalt des Dialogs)

Die Funktion wird also direkt einer Variable zugewiesen, die Beschriftung bestimmt, was für ein Text über dem Eingabefeld steht, der Titel legt die Überschrift des Dialogfeldes fest und der Standardinhalt legt fest, was standardmäßig schon in dem Feld als Vorgabe steht.

InputBox

MsgBox-Funktion für die Ausgabe
Die Ausgabe funktioniert sehr ähnlich, hier heißt die Funktion MsgBox. Eine solche Funktion wir folgendermaßen verwendet:
MsgBox(Beschriftung, Button-Art, Titel, Name der Hilfe-Datei zu diesem Dialog)

Die Funktion kann also direkt aufgerufen werden, die Beschriftung legt fest, was die Meldung besagen soll, die Button-Art legt fest, ob es sich z.B um eine Fehlermeldung handelt, der Titel legt die Überschrift des Dialogs fest, wenn es sich um eine Fehlermeldung handeln soll, kann man auch noch den Namen der Hilfedatei angeben, die das Problem näher beschreibt und vielleicht auch Lösungsvorschläge bietet.

MessageBox

Auswahlstrukturen in Visual Basic

Was sind Auswahlstrukturen
Mit einer Auswahlstruktur kann die Reihenfolge gesteuert werden, in der Anweisungen ausgeführt werden. So kann man die Ausführung von Anweisungen an Bedingungen knüpfen. Wenn etwas passiert, dann tue dies. Ähnlich wird die Auswahlstruktur auch geschrieben, sie wird so verwendet:
If Bedingung Then
Anweisung
End If

Also wie schon oben erwähnt, heißt dies ins Deutsche übersetzt: Wenn die Bedingung wahr ist, dann tue dies und beende die Auswahlstruktur danach. Das End If darf nichts vergessen werden, da sonst eine Fehlermeldung erscheint.
Für Bedingung wird ein bedingter Ausdruck (wie z.B. Text1.Text = "") eingesetzt, wenn diese Bedingung wahr ist, dann wird das ausgeführt, was in der Anweisung steht (z.B. MsgBox(„Textfeld ist leer“)).

Auswahlstruktur mit If...Then
Das obige ist eine einseitige Auswahlstruktur, nun gibt es noch eine zweiseitige Auswahlstruktur. Hier wird für den Fall, dass die erste Bedingung nicht wahr ist, eine alternative Anweisung ausgeführt. An die obige Anweisung wird dann noch Else hinzugefügt, dies funktioniert so:
If Bedingung Then
Anweisung1
Else
Anweisung2
End If

Um das obige Beispiel mit dem leeren Textfeld aufzugreifen, könnte nun die Anweisung2 MsgBox("Textfeld ist voll") heißen.

Auswahlstruktur mit Select Case
Wenn sie sehr viele Anweisungen haben ist es sehr umständlich immer die nur wenig abgeänderte Bedingung immer ganz ausschreiben zu müssen. Für solche Fälle bietet Visual Basic die Select Case-Struktur an. Hier wird in der erste Zeile festgelegt, worauf sich die folgenden Bedingungen beziehen sollen, die Struktur wird folgendermaßen verwendet:
Select Case Variable
Case Wert1
Anweisung1
Case Wert2
Anweisung2
End Select

Die Variable kann auch ein Eigenschaftswert, wie z.B. List1.ListIndex sein. Wenn der Wert nach dem Case mit dem Variablenwert übereinstimmt, also, z.B. der 2. Listenpunkt ausgewählt wurde, dann wird die Anweisung ausgeführt (Kleiner Hinweis am Rande: Das Listenfeld fängt mit 0 an zu zählen, so dass der erste Case-Fall 0 heißt). Auch hier ist es wichtig die Struktur mit End Select abzuschließen um eine Fehlermeldung zu vermeiden.

Schleifen

Wozu Schleifen?
Mit Schleifen kann man einfach und schnell Anweisungen mehrmals ausführen. Dabei kann man entweder eine Anzahl der Ausführungen festlegen oder die Ausführungszahl an einer Bedingung festmachen. So kann man das Programm anweisen die Anweisungen solange auszuführen, wie eine Bedingung erfüllt wird.

For-Schleifen
Mit For-Schleifen kann man das Programm anweisen, die Anweisung eine bestimmte Anzahl zu wiederholen. Deshalb kann man sie auch als bedingte Wiederholungsschleife bezeichnen.
Eine For-Schleife ist wie folgt aufgebaut:
For i = 1 To 10
Anweisung
Next i

In dem sogenannten Schleifenkopf (For...) steht die Bedingung die Schleife 10mal auszuführen (1 bis 10). Der erste Wert stellt hierbei den Anfangswert dar und der Wert nach dem to den Endwert. Beim Endwert wird begonnen und auf die Zählervariable i immer 1 aufgeschlagen, bis die Variable den Endwert erreicht hat. Im sogenannten Schleifenkörper steht die Anweisung die bei der Ausführung wiederholt werden soll. Im Schleifenfuss schließlich wird die Schleife abgeschlossen mit der Schlüsselphrase Next i.

Andere Zählmuster von For-Schleifen
Wenn man ein anderes Zählmuster als 1,2,3 verwenden will, kann man einen anderen Startwert definieren, dazu wird statt der 1 To ... z.B. 3 To ... geschrieben. Man kann auch die Zählschritte beeinflussen. Dies funktioniert mit dem Schlüsselwort Step. Eine Anweisung mit Step sieht dann folgendermaßen aus:
For i = 5 to 25 Step 5
Print i
Next i

Bei dieser Anweisung wird von 5 ab in fünfer Schritten bis 25 gezählt (also 5,10,15,20,25), dies geht auch mit Dezimalzahlen. Bei Dezimalzahlen aber darauf achten, dass man statt dem trennenden Komma eine Punkt verwendet (also NICHT 0,5 SONDERN 0.5).

Exit For
Mit Exit For kann man die Schleife vorzeitig beenden um auf ein Ereignis zu reagieren. z.B. so:
For i = 1 To 3
Pass = InputBox("Geben Sie Ihr Passwort ein, oder Ende zum Beenden")
If Pass = "Ende" Then
Exit For
Next i

Die Schleife wird 3 mal wiederholt oder vorzeitig beendet, wenn das korrekte Passwort eingegeben wird.

Schleifen mit Do While Loop
Mit Do While Loop-Schleifen kann man bei der Anzahl der Wiederholungen der Anweisungen auf Bedingen reagieren. Eine Do While-Schleife wird solange ausgeführt, solange die Bedingung erfüllt ist.
Die Do While Loop Schleife ist folgendermaßen aufgebaut:
Do While Bedingung
Anweisung
Loop

Wie bei der For-Schleife steht die Bedingung im Schleifenkopf, die Anweisung im Schleifenkörper (ist aber jeder Schleifenart so) und Loop schließt die Schleife ab.

Achtung bei Do While Schleifen
Do-Schleifen können bei falscher Schleifenbedingung Endlosschleifen werden, das heißt, die Bedingung kann nie erfüllt werden und die Schleife wird dann unendlich oft ausgeführt. Im schlimmsten Falle kann dies zum Absturz eines Computers führen (So arbeiten auch Hacker die einen Computer lahm legen wollen. Sie schreiben eine Endlosschleife die den Computer zum Absturz bringt). Deshalb sollte man entweder auf eine sinnvolle Schleifengestaltung achten oder eine Austrittsbedingung einbauen (z.B. eine Zahl die die Schleife beendet).

Schleifen mit Do Loop Until
Eine Do Loop Until-Schleife wird solange ausgeführt, bis ein Ereignis eintritt, das die Schleife beendet. Die Do... Loop Until-Schleife ist folgendermaßen aufgebaut:
Do
Anweisung
Loop Until Bedingung

Auf den ersten Blick ist schon zu erkennen, dass sich diese Schleifenart grundlegend von den vorherigen Arten unterscheidet. Sie ist eine geschlossene Schleife, da die Bedingung im Schleifenfuss steht. Deshalb wird diese Schleife mindestens einmal ausgeführt.
Auch bei dieser Schleife ist auf eine erfüllbare Bedingung zu achten, da ansonsten wie bei der Do While Loop-Schleife eine Endlosschleife erzeugt wird.

Funktionen

Warum Funktionen?
Man stellt sich natürlich die Frage warum man Funktionen einsetzen soll, wo doch schon andere Mittel bekannt sind und diese (vermeintlich) einfacher und besser sind. Doch Funktionen haben Vorteile gegenüber der normalen Schreibweise von Anweisungen.
Sie verringern den Programmieraufwand in dem Programm, da man vorgefertigte Funktionen verwenden kann und sich so nicht mit der komplizierten Herleitung und Programmierung des Problems beschäftigen muss. Außerdem werden Fehlerquellen vermindert, da man die Anweisungen nur noch einmal schreiben muss und so den gewöhnlichen Quelltext vom logischen trennen kann. Natürlich wird der Quelltext auch durch den Einsatz von Funktionen übersichtlicher.

Wie funktionieren Funktionen
Funktionen sind kleine Unterprogramme, die separat vom Quelltext abgehoben geschrieben werden. Man kann in Visual Basic integrierte Funktionen verwenden, dann muss man die Funktionen mit ihrem Namen aufrufen und ihnen in der Regel ein Argument übergeben. Das sieht dann zum Beispiel so aus:
Sqr(Zahl)

Mit der Funktion Sqr lässt sich die Quadratwurzel von einer Zahl ausrechnen, die Zahl wird dann in Klammern hinter den Funktionsnamen geschrieben und so an die Funktion übergeben. Die Berechnen den Wert und übergibt diesen wieder zurück an die Funktion, die genauso lautet wie der Funktionsname.

Eigene Funktionen schreiben
Natürlich kann man auch eigene Funktionen schreiben. Das sieht dann so aus:
Public Function Euro(DM as Currency) as Currency
Euro = DM / 1,9558
End Function

Hier lautet der Name der Funktion Euro. Die benutzerdefinierten Funktionen werden nicht in eine Prozedur (Private Sub ... End Sub) geschrieben, sondern vor, bzw. hinter die Prozeduren der Knöpfe und anderen Objekte.
Jede Funktion beginnt mit den Schlüsselwörtern Public Function. Mit Public legt man fest, dass die Funktion im ganzen Programm Gültigkeit hat. In der Klammer stehen die Attributwerte des Attributs, das an die Funktion übergeben werden soll. Das Attribut ist eine Angabe, die die Funktion zu ihrer Berechnung von außerhalb benötigt um ihre Berechnungen durchführen zu können. In unserem Beispiel fordert die Funktion einen Wert für DM von außen an. Jede Funktion hat einen Rückgabewert, als das Ergebnis, das die Berechnung ergibt, dass an die Stelle zurückgegeben wird, wo es angefordert wird. Den Datentyp für diesen Datentyp gibt man nach der Klammer an. Man kann zwar die Attributsliste weglassen, den Datentyp des Rückgabewerts muss man jedoch immer angeben. Beendet wird die Funktion mit den Schlüsselwörtern End Function.
Daraus ergibt sich folgende allgemeine Definition:
Public Function Funktionsname (Attribut as Datentyp) as Datentyp
Anweisung
End Function

Aufgerufen wird die Funktion, in dem der Funktionsname mit der Übergabe des/der Attribute angegeben wird (z.B. Betrag = Euro(2)).

Prozeduren

Was sind Prozeduren?
Prozeduren unterscheiden sich von Funktionen nur dadurch, dass dem Namen einer Prozedur kein Rückgabewert zugeordnet ist. Sie sind also Funktionen ganz ähnlich; das schließt auch die Gründe ein, warum man Prozeduren einsetzen sollte. Jedoch werden Prozeduren vorwiegend dazu verwendet Benutzereingaben zu verarbeiten, Informationen anzuzeigen oder auszudrucken. Sie können aber auch mehrere Eigenschaften in Abhängigkeit von einer Bedingung verändern.
Der große Unterschied ist der Rückgabewert. Während Funktionen nur einen Rückgabewert haben, können Prozeduren beliebig viele haben.

Syntax von Prozeduren
Prozeduren sind folgendermaßen aufgebaut:
Sub Prozedurname(Parameter)
Prozeduranweisungen
End Sub

Jetzt wird jedem ein Licht auf gehen der sich die Struktur der Prozedur ansieht: Das sieht doch so aus, wie der automatisch von Visual Basic generierte Rahmen für den Quelltext von Steuerelement. GENAU! Bei dem von Visual Basic generierten Rahmen handelt es sich um Ereignisprozeduren der Steuerelemente.
Nun gehe ich noch mal genauer auf die Struktur der Prozedur ein. Die Parameter sind optional, d.h. man kann die Prozedur auch ohne Parameter programmieren.

Übergabemöglichkeiten
Man der Prozedur auf verschiedene Weisen Werte übergeben, entweder als Referenz oder als Wert. Bei der Übergabe als Referenz wird der Prozedur eine Variable übergeben, die die Prozedur verändern kann. Bei der Übergabe als Wert, also z.B. ein Name in Anführungszeichen, wird der Wert als Konstante behandelt und kann somit folglich nicht verändert werden.

Prozeduren aufrufen
Mit folgendem Befehl wir die Prozedur aufgerufen:
Prozedurname(Parameter)

Im Falle des Weglassens der Parameter wird die Prozedur also nur durch die Angabe des Namens aufgerufen.

Related Workshops: Allgemeines \\ Visual Basic Einführung \\ Die Programmierumgebung \\ Programmieren mit VB \\ Datenbankprogrammierung \\ Datenbanktheorie \\ Datenbankprogrammierung 2 \\ EmbeddedSQL \\ Steuerelemente \\ Api-Funktionen

Workshop als PDF

<Zurück

© by www.abyter.de (Martin Monshausen)