|
|
Das ist ein möglichst kompakter Schnellkurs in Visual-Basic, wobei die wichtigsten Eigenschaften erklärt werden. Für eine Liste der verfügbaren Funktionen gibt es hier die Visual-Basic Funktionen.
Die in geschweiften Klammern {...Code...} beschreiben Texte sind nur Kommentare oder Platzhalter und nicht Code.
Die Vorteile liegen ganz klar das auf der Seite der Lesbarkeit, der einfachen Syntax und der leichten Erlernbarkeit der Sprache. Projekte und Codes in Visual-Basic sind grundsätzlich leichter zu verstehen als vergleichbare Codes in anderen Sprachen, wie zB. C++.
Die Syntax ist einfach übersichtlich und leicht zu lesen.
Die Sprache läßt sich mit wenig Aufwand erlernen.
Die Codes bleiben übersichtlicher und lesbarer als in anderen Programmiersprachen und sind deshalb auch leichter weiterzuentwickeln.
Die meisten Anwendungen lassen sich damit programmieren.
Ist auch für Hobbyprogrammierer interessant da kein Expertenwissen notwendig ist und schnell die ersten eigenen Programme geschrieben werden können.
Programme können mit weniger Zeitaufwand erstellt werden als teilweise in anderen Sprachen.
Der Editor ist übersichtlich, gut organisiert und enthält einen guten Dialogeditor, und auch das Compilern ist einfach.
Unterstützt Inline Debugging, welches es ermöglicht ein Programm bereits während dem Schreiben schritt für schritt auszuführen (interpretieren) und dabei die Werte und Reaktionen zu beobachten.
Auch wenn oft anderes behauptet wird können durchaus auch in VB professionelle Anwendungen entwickelt werden. Nur ab einer bestimmten Größe (da liegt es in der Regel an der Mangelhaften Umsetzung der Klassen-Eigenschaften) oder bei hohen Anforderungen an die Leistung oder sehr systemnahe Programmen (zB. Treiber) ist VB ungeeignet.
(Das oft gerne ins Feld gebrachte Argument Basic Sprachen führe oft zu unstrukturierten Spaghetti-Codes (durch die GoTo Funktion) ist ein Gerücht. Grundsätzlich ist jede Sprache in der Lage solche Codes zu generieren da jede vernünftige Sprache eine Sprung-Funktion kennt. Dies ist also ein Problem der Programmier und nicht der Sprache. Wahrscheinlich ist das Gerücht in der Zeit der aller ersten Basic Sprachen entstanden als den Programmiern noch die Erfahrung fehlte, und ist längst nicht mehr aktuell.)
VB führt standardmäßig eine Überlaufsprüfung, Indexbereichsprüfung und Stack-Überlaufsprüfung durch, was den Code zT. sicherer macht als zB. C. Überlaufsprüfung und Indexbereichsprüfung können optional für das ganze Projekt deaktiviert werden, leider aber nicht auf Modularer oder Prozeduraler Ebene.
(Sprachen wie C, die zB. keine Stack-Überlaufsprüfung durchführen sind auch gefährdet das passive Datenformate wie Bilder benutzt werden können um Codes auszuführen, wenn die Entsprechenden Programme dafür keine Vorsorge leisten. Auf diese Weise können auch Schadcodes in Systeme eingeschleust werden, und es sind bereits eine ganze Liste von Programmen bekannt die solche Fehler enthalten¦enthielten und dafür empfindlich waren. VB ist durch seine Stackprüfung dagegen grundsätzlich unempfindlich, bei einem Stack-Überlauf bricht ein Programm einfach mit einer Fehlermeldung ab.)
Die meisten Nachteile gehen auf kosten der Ausführungsgeschwindigkeit, weshalb zB. keine rechenintensiven Anwendungen wie 3D-Spiele oder Raytracing in Visual-Basic programmiert werden. Auch die mangelhafte Unterstützung von Klassen und Objekt orientiertem Programmieren verhindert das Visual-Basic für große komplexe Projekte verwendet wird. Oder auch da wo sehr System- oder Hardware-nahe Anwendungen geschrieben werden müssen (zB. Treiber, Betriebsystem) da kein Assembler unterstützt wird und auch keine Funktionen verfügbar sind.
Die Nachteile von Visual-Basic waren der Grund für das Eröffnen des Runtime-Basic Projekts und der Entwicklung einer Opensource Sprache die ähnlich leicht erlernbar und benutzbar sein soll wie Visual-Basic.
Unterstützt kein Unsigned Daten-Typen.
Unterstützt kein Inlining (Codes in Prozeduren werden direkt in die aufrufende Prozedur eingefügt und nicht über Call aufgerufen)
Unterstützt Klassen nur unvollständig, zB. keine Polymorphie oder Vererbung, keine echten Klassenmodule welche mehrere Klassen enthalten können.
Funktionen können nicht überladen werden (mehrere Funktionen und unterschiedliche Parameter mit dem gleichen Namen.)
Unterstützt keine Zeiger.
Unterstützt kein Inline Assembler.
Kann keine eigenständigen Programme compilieren die ohne Runtime DLL auskommen.
Der Codegenerator optimiert den Code an vielen Bereichen nicht gut (zB. wird nicht einmal X^2 durch X*X ersetzt).
Einige Optimierungen wie das Steuern der Prüfungen von Überlauf und Indexüberschreitung läßt sich nur für ein ganzes Projekt ein und ausschalten, und nicht auf modularer oder prozeduraler Ebene.
Die Sprache gehört einer Firma, ist kostenpflichtig, nicht opensource, und läuft nur auf einem Betriebssystem.
Der Sprachumfang ist klein und hat sich kaum weiterentwickelt, zudem wurde die Weiterentwicklung leider eingestellt und da es sich nicht um eine opensource Sprache handelt, kann sie auch nicht von freiwilligen weiterentwickelt werden.
Zeilen müssen nicht durch ein Zeichen (zB. In C ist es ";") voneinander getrennt werden. Jede Zeile gilt an ihrem Ende als abgeschlossen, wenn sie nicht mit einem "_ Zeichen Fortgesetzt wird."
Es ist möglich mehrere Codezeilen auf einer Zeile zu schreiben, sie müssen dann mit einem ":" Doppelpunkt voneinander getrennt werden.
Var1 = 1
Var2 = 2
Var1 = 1: Var2 = 2
Einige Zeilen können sehr lang werden, was oft nicht der Übersichtlichkeit dient. So ist es möglich eine Zeile zu trennen und auf der Nächsten Zeile fortzusetzen, das geht über ein " _" (unterstrich). Der Unterstrich darf nicht gleich nach einem Text oder Namen folgen, es muß zuvor mindestens ein Lehrzeichen stehen, sonst wird der Unterstrich als zum Code gehörend betrachtet.
If Var1 = 1 Or Var2 = 2 Or Var3 = 3 Or Var4 = 4 Then
End If
'...oder
If Var1 = 1 Or _
Var2 = 2 Or _
Var3 = 3 Or _
Var4 = 4 _
Then
End If
' Das ist ein Kommentar
' Var1 = 1 ' diese Zeile ist deaktiviert
Var1 = 1
Alle Deklarationen auf Modul-Ebene (Public¦Private) müssen vor dem Code, also vor der ersten Prozedur geschrieben werden.
In den Beispielen wird angegeben wo sich der Quelltext befindet.
'-------- Deklaration
'{... Diese Quelltexte befinden sich im Deklarationsteil des Moduls, also vor der ersten Prozedur.}
'-------- Code
'{... Diese Quelltexte befinden sich innerhalb einer Prozedur.}
'-------- Deklaration
Option Explicit
Namen sind in VB nicht casesensitiv, das heist de GroߦKlein-Schreibung spielt keine Rolle.
Namen sollten in CamelCase deklariert werden da dies die Lesbarkeit erhöht, das heißt das jedes Einzelwort in einem Name im ersten Buchstaben groß geschrieben wird. (zB. "StrRead" statt "strread")
Namen sollten ihren Zweck ausdrücken ("StrRead" ist besser als "StrR" oder "sr")
Namen sollten sinnvoll alphabetisch sortiert werden können, also ist es besser erst die höhere Zuordnung anzugeben und dann erst die spezifischen, ähnlich wie es bei Objekten durch den "."-Syntax gemacht wird ("Str.Read"). ("StrRead" ist besser als "ReadStr")
Die Namensvergaben ist ganz besonders bei Public (projektweit sichtbaren) Namen wichtig, erstens um am Namen zu erkennen worum es sich handelt, und zweitens um zu verhindern das Public Namen in verschiedenen Modulen sich durch Namensgleichheit gegenseitig überschneiden. Aber auch private und Lokale Namen sollten sinnvoll benannt werden damit ein Code auch nach dem Fertigstellen leicht verstanden werden kann. Einsilbige Namen wie "i j uu cs usw." sollte man vermieden (in Local Namen sind diese vielleicht noch tolerierbar wenn auch nicht sinnvoll, in Public Private aber nicht mehr).
Viele Strukturen funktionieren als Blöcke (If-Then, For-Next, Do-Loop, Sub Function), und solche Blöcke können verschachtelt werden (in welchem ein Block kompletter von einem anderen umschlossen ist), aber dürfen sich nicht überschneiden.
'-- Richtig
If ... Then
For ...
Next
End If
'-- Falsch
If ... Then
For ...
End If
Next
Debug.Print "Info", Var1, Var2
Debug.Print "Info", Var1, Var2: Var3 = True
'Var3 = 3 wird in einem compilierten Code nie ausgeführt.
Über Compiler-Konstanten können bestimmte Codeteile während der Entwicklung Ein- und Ausgeschaltet werden. Codes die in einem #If-Then Block stehen die deaktiviert sind, werden auch nicht in den ausführbaren Code compiliert. Man kann diese Compiler-Konstanten gut gebrauchen wenn man entweder große Blöcke deaktivieren will, oder wenn man Codes zum Debugging (Fehlersuchen) einfügen will, die man dann leicht ein- und ausschalten kann.
#If-Then Blöcke dürfen die Blockstruktur anderer Blöcke durchbrechen, es wird nur die eigene Struktur beachtet. Und dürfen im ganzen Modul verwendet werden auch außerhalb von Prozeduren.
Compiler-Konstanten können leider nicht Public deklariert werden sondern gelten immer nur Private.
'-------- Deklaration
#Const CompileDebugging = True
'-------- Code
#If CompileDebugging Then
'{... Code die ausgeführt und in das Programm compiliert werden wenn: CompileDebugging = True}
#Else
'{... Code die ausgeführt und in das Programm compiliert werden wenn: CompileDebugging = False}
#End If
#If 1 = 0 Then ' So kann man Codeblöcke schnell ein- und ausschalten.
'{... Code}
#End If
' Blockstruktur anderer Blöcke durchbrechen
#If CompileDebugging Then
Private Sub Test1(ByVal Par1 As Long, ByVal Par2 As Long)
#Else
Private Sub Test1(Optional ByRef Par1 As Long, Optional ByRef Par2 As Long)
#End If
'{... Code}
End Sub
End ' dies beendet das Programm sofort
' Code im Hauptformular
Unload Form2 ' Dies beendet zuerst ein zweites Formular
Unload Me ' und dann wird das Hauptformular beendet
Die Standard Daten-Typen sind die Basis jedes Programms und stellen das Format der Datenspeicherung dar, in welcher Werte abgelegt verwendet und verändert werden können.
Die Standard Daten-Typen werden fast alle auch direkt vom Prozessor unterstützt. Intern rechten man also mit Prozessor Registern, deshalb sind die Größen und Eigenschaften auch von der Hardware unterstützen Arithmetik abhängig.
Es gibt 3 Hauptarten der Standard Daten-Typen, numerisch ganzzahlig ( Integer), numerisch bruchzahlig ( Float) und Text ( String). Dazu kommen weitere spezielle Daten-Typen wie Boolean Currency usw. und auch solche mit polymorphen Eigenschaften wie Variant oder Object hinzu.
Je nach Daten-Typ können unterschiedliche Werte aufgenommen und berechnet werden. Bei einer Deklaration einer Variable Konstanten oder Parameter wird festgelegt welchen Daten-Typ sie abbilden und damit welche Werte sie aufnehmen können und wie diese berechnet werden.
Es werden leider nicht alle Daten-Typen unterstützt, zB. gibt es kein Unsigned (Ganzzahl ohne Vorzeichen) für Integer oder Long. Aber man kommt mit den vorhandenen schon recht weit.
Decimal ist ein Untertyp der nur über eine Variant-Variable in Vb6 erreichbar ist. es ist nicht möglich direkt zu deklarieren.
| Daten-Typ | PostFix | PräFix | Konv | vb-Name | Größe in Byte | Minimum | Maximum | Info |
| Byte | | byt | CByte | vbByte | 1 | 0 | 255 | Ganzzahl ohne Vorzeichen |
| - | | | | | 1 | -128 | 127 | Ganzzahl mit Vorzeichen |
| - | | | | | 2 | 0 | 65536 | Ganzzahl ohne Vorzeichen |
| Integer | % | int | CInt | vbInteger | 2 | -32'768 | 32'767 | Ganzzahl mit Vorzeichen |
| - | | | | | 4 | 0 | 4'294'967'295 | Ganzzahl ohne Vorzeichen |
| Long | & | lng | CLng | vbLong | 4 | -2'147'483'648 | 2'147'483'647 | Ganzzahl mit Vorzeichen |
| Single | ! | sng | CSng | vbSingle | 4 | -3.402823E+38
-1.401298E-45 | 3.402823E+38
1.401298E-45 | Gleitkommazahl |
| Double | # | dbl | CDbl | vbDouble | 8 | -1.79769313486232E+308
-4.94065645841247E-324 | 1.79769313486232E+308
4.94065645841247E-324 | Gleitkommazahl |
| | | | | | | | | |
| Boolean | | bln | CBool | vbBoolean | 2 | False (0) | True (-1) | Wahrheitswert |
| Currency | @ | | CCur | vbDecimal | 8 | -922'337'203'685'477.5808 | 922'337'203'685'477.5807 | Ganzzahl skaliert
kleinste Zahl ungleich Null ist +/-0.0000000000000000000000000001 |
| Decimal | | cur | CDec | vbCurrency | 14 | -79'228'162'514'264'337'593'543'950'335 | +79'228'162'514'264'337'593'543'950'335 | Gleitkommazahl |
| String (variable Länge) | $ | str | CStr | vbString | 10 +Länge | Länge: 0 | Länge: 2'147'483'647 | Zeichenkette Unicode |
| String (feste Länge) | $ | str | CStr | vbString | Länge | Länge: 1 | Länge: 65'536 | Zeichenkette Unicode |
| | | | | | | | | |
| Variant (mit Zahlen) | | vnt | CVar | vbVariant | 16 | | | Numerische Werte im Bereich des Datentyps Double |
| Variant (mit Zeichen) | | vnt | CVar | vbVariant | 22 +Länge | | | Wie bei String mit variabler Länge |
| Object | | obj | | vbObject | 4 | - | - | Beliebiger Verweis auf ein Objekt vom Typ Object |
| Date | | dtm | CDate | vbDate | 8 | 1. Januar 100 | Dezember 9999 | Zeit |
| Error | | err | CVErr | vbError | | - | - | |
| | | | | | | | | |
| Type | | udt | | vbUserDefinedType | Summe Elemente | - | - | Daten-Struktur Benutzerdefiniert |
| | | | | | | | | |
| (Datenfeld) | | | | vbArray | | Elemente: 0 | Elemente: 2'147'483'647 | Array, Datenfeld |
| (Datenzugriffsobjekt) | | | | vbDataObject | | | | Datenzugriffsobjekt |
| (Collection-Objekt) | | col | | | | - | - | Collection-Objekt |
| (nicht initialisiert) | | | | vbEmpty | - | - | - | nicht initialisiert Objekt |
| (ungültig) | | | | vbNull | - | - | - | keine gültigen Daten im Objekt |
Bei Fließpunkt Werten ist es wichtig zu beachten, das bei Operationen automatisch eine Rundung stattfindet (Alles <0.5 auf die nächst kleinere Ganzzahl, sonst auf die nächst größere), wenn diese an ein Ganzzahl übergeben werden. Ist dies unerwünscht können die Werte mit Fix() auf die nächst kleinere Ganzzahl gerundet werden.
Dim Var1 As Long
Var1 = 3 / 2 ' Resultat ist 2, da die Berechnung im Fließpunkt Format durchgeführt wird und das Resultat 1.5 automatisch aufgerundet wird.
Var1 = 1.5 ' Resultat ist 2, gleicher Grund wie oben.
Var1 = 3 \ 2 ' Resultat ist 1, hier wird die Berechnung in Ganzzahlen durchgeführt, und dabei werden die Bruchwerte einfach weggeschnitten.
'! Ganzzahl Divisionen sind viel schneller. Also sollte man besser "3 \ 2" statt "Fix(3 / 2)" verwenden.
| Typ | Beschreibung |
| Unsigned | Ohne Vorzeichen, nur 0 und positive Zahlen (zB. Byte -> 0 bis 255) |
| Signet | Mit Vorzeichen, also auch negative Zahlen (zB. Integer -> -32'768 bis 32'767) |
Var1 = 100 ' Dezimal
Var1 = &H64 ' Hexadezimal
Var1 = &O144 ' Oktal
Var1 = 1.23456789E+19
' ist gleich wie
Var1 = 1.23456789 * 10 ^ 19
Var1 = 12345678900000000000
Var1 = 1.23456789E-19
' ist gleich wie
Var1 = 1.23456789 * 10 ^ -19
Var1 = 0.000000000000000000123456789
Variant ist ein besonnter Daten-Typ weil er fast alle Informationen aufnehmen kann und dadurch eine flexible Datenspeicherung ermöglicht (er ist polymorph, vielgestaltig). Es ist aber durch den zusätzlichen Verarbeitungsaufwand auch langsamer und sollte deshalb nur eingesetzt werden wenn man diese Eigenschaft Braucht.
Wird eine Information an eine Variant Variable übergeben, Werden diese Daten abgelegt und die Variant-Variable verweist über ein Zeiger auf diese Daten. Gleichzeitig wird im auch eine Unter Daten-Typ festgelegt der auch enthält um welche Art von Daten es sich handelt, also um welchen Standard Daten-Typen, ob es sich um ein Array handelt oder das Objekt.
Ein Variant belegt mindestens 16 Bytes im Speicher und bei jedem Datenaustausch finden Typenprüfungen und wenn notwendig Konvertierungen statt.
Objektverweise in Variant-Variablen werden immer zur Laufzeit aufgelöst, da während de Compilierungszeit nicht festgelegt ist was die Variant-Variable aufnehmen wird.
Variant kann auch "Nichts" enthalten.
| Konstante | Wert | Beschreibung |
| vbEmpty | 0 | Nicht initialisiert (Voreinstellung), es wurde nichts übergeben, oder mit Nothing Zuweisung gelöscht |
| vbNull | 1 | Enthält keine gültigen Daten, wurde mit Null Zuweisung |
| vbError | 10 | Fehler, in einer Berechnung oder Verarbeitung ist ein Fehler aufgetreten, oder wurde mit CVErr() zugewiesen |
| | | |
| vbByte | 17 | Daten-Typ Byte |
| vbInteger | 2 | Daten-Typ Integer |
| vbLong | 3 | Daten-Typ Long |
| vbSingle | 4 | Daten-Typ Single |
| vbDouble | 5 | Daten-Typ Double |
| vbBoolean | 11 | Daten-Typ Boolean |
| vbCurrency | 6 | Daten-Typ Currency |
| vbString | 8 | Daten-Typ Typ String |
| | | |
| vbArray | 8192 | Datenfeld |
| vbObject | 9 | Objekt |
| vbVariant | 12 | Wert vom Typ Variant (angewendet nur bei Datenfeldern mit Variant-Werten) |
| vbDate | 7 | Daten-Typ Typ Date |
| vbDataObject | 13 | Datenzugriffs-Objekt |
| vbDecimal | 14 | Daten-Typ Typ Decimal (nur als Untertyp von Variant verwendbar) |
| vbUserDefinedType | 36 | Werte vom Typ Variant, die benutzerdefinierte Typen enthalten |
| Funktion | True wenn... |
| IsEmpty() | die Variable nicht initialisiert wurde. |
| IsNull() | die Variable keine gültigen Daten enthält. |
| IsError() | die Variable ein Fehlerwert enthält, also ein Fehler aufgetreten ist. |
| IsMissing() | in einer Prozedur ein Optionaler Parameter nicht übergeben wurde. |
| | |
| IsNumeric() | der gesamte Ausdruck als Zahl interpretiert werden kann, also auch ein String mit einem gültigen Zahlenwert. |
| IsArray() | die Variable ein Array ist. |
| IsObject() | es eine Objekt-Variable ist. |
| IsDate() | ein Ausdruck in ein Datum umgewandelt werden kann. |
| Schlüsselwort | Gültigkeitsbereichen |
| Public | Im gesamten Projekt |
| Private | Innerhalb eines Moduls oder Klasse |
| Local | Innerhalb einer Prozedur |
Variabeln werden innerhalb einer Prozedur immer als Lokal deklariert, sollen sie Private oder Public gültig sein, müssen sie alle vor der ersten Prozedur im Deklarationsbereich geschrieben werden. Nach einer Prozedur dürfen keine Deklarationen mehr geschrieben werden. In einer Prozedur können keine Namen Public¦Privare deklariert werden.
Lokal innerhalb einer Prozedur werden Variablen mit Dim deklariert. Ansonsten mit Private oder Public.
Lokal deklarierte Variabeln erhalten ihre Werte nur solange sich das Programm in der Prozedur befindet. Beim Verlassen der Prozedur gehen die Werte verloren. (Dies kann mit Static verhindert werden, siehe: Statische Werte: Static.)
Public sollten wirklich nur die Daten deklariert werden die auch tatsächlich im gesamten Projekt verwendet werden, damit es nicht zu Namensüberschneidungen kommt.
Lokal können Namen auch mit dem Postfix Zeichen deklariert werden, das am Ende des Namens geschrieben wird.
'-------- Deklaration
Private Var1 As Long ' nur im Modul gültig
Public Var2 As Single ' überall gültig
'-------- Code
Dim Var1 As Long ' nur in Prozedur gültig
Dim Var2& ' auch Long nur anders deklariert mit Postfix-Zeichen
'-------- Deklaration
Private Var1 As Long ' Deklaration mit Name Var1 und Daten-Typ Long (4-Byte Ganzzahl Signed)
Public Var2 As Single ' Deklaration mit Name Var2 und Daten-Typ Single (4-Byte Fließpunktzahl)
'-------- Code
Dim Var1 As Long ' Deklaration mit Name Var1 und Daten-Typ Long (4-Byte Signed)
Var1 = 1 ' die Variable enthält nun den Wert 1
'-------- Deklaration
Public Const Con1 As Long = 100
Private Const Con2 As String = "zwei"
'-------- Code
Const Con3 As Long = 300
Var1 = Con1 + Con3
' Wird interpretiert wie
' Var1 = 100 + 300
Es können mehrere Konstanten auch in einem Enum zusammengefaßt werden.
Die Werte können angegeben werden, werden sie weggelassen wird automatisch der Wert in jedem neuen Namen um 1 erhöht, beginnend bei 0.
Es ist erlaubt mehrere Namen mit dem gleichen Wert zu deklarieren.
Ein Enum kann auch als Parameter Daten-Typ in einer Prozedur deklariert werden.
Die Enum Daten-Typen können nicht mit As festgelegt werden.
Enum könne nicht in einer Prozedur deklariert werden.
'-------- Deklaration
Private Enum Aufzaelung
Name1 ' Name1 = 0
Name2 ' Name2 = 1
Name3 = 10 ' Name3 = 10
Name4 ' Name4 = 11
End Enum
String wird als Kette von Werten verstanden und verarbeitet.
String ist ein Standard Daten-Typ der Text aufnehmen kann, aber auch binäre Informationen enthalten kann.
Es stehen eine Reihe von Funktionen zur Verfügung um zB. die GroߦKlein-Schreibung zu ändern, Leerzeichen wegzuschneiden, Teile aus dem String zu kopieren oder ein String in einem anderen zu suchen.
Bei Übergabe von Text muß dieser immer mit "-Zeichen (Anführungszeichen) begonnen und abgeschlossen werden.
Ein leerer String wird mit zwei Anführungszeichen "" angegeben.
Will man ein "-Zeichen Anführungszeichen im Text beschrieben, tut man dies mit zwei Anführungszeichen "" im Text.
Strings können mit dem &-Zeichen verketten werden. Auch + wird als Verkettungszeichen akzeptiert, ist aber nicht ganz sauber, da so eine Verwechslung mit Zahlenmathematik auftreten kann.
Es ist bei der Deklaration eines Strings auch möglich eine feste Länge anzugeben. Dies bewirkt das diese feste Speichergröße deklariert wird und während der Laufzeit nicht geändert werden kann. Interessant ist dies vorallem im Zusammenhang mit Typen, da dann eine feste Größe deklariert wird und nicht nur ein Zeiger der auf eine Variable Größe verweist.
Dim Text1 As String ' Zeichenkette mit variabler Länge
Dim Text2 As String * 10 ' Zeichenkette mit fester Länge
Text1 = "Dies ist ein Text" 'entspringt: {Dies ist ein Text}
Text1 = "Dies ist " & "ein Text" 'entspringt: {Dies ist ein Text}
Text1 = "Dies ist " & 1 + 2 & " ein Text" 'entspringt: {Dies ist 3 ein Text}
Text1 = "Dies ""ist ein"" Text" 'entspringt: {Dies "ist ein" Text}
Text1 = """" & "Dies ist ein Text" & """" 'entspringt: {"Dies ist ein Text"}
'entspringt: { }, vor der ersten Zuweisung enthält Text2 10 Null-Werte
Text2 = "1" 'entspringt: {1 }, die restlichen Zeichen werden mit Lehrzeichen aufgefüllt
Text2 = "12345678901234567890" 'entspringt: {1234567890}, die Zeichen länger als die deklarierte Länge werden weggeschnitten.
Intern werden String automatisch zu Unicode konvertiert, nach Außen aber werden Strings immer als Ascii interpretiert. VB Konvertiert als immer Strings beim lesen von Ascii zu Unicode, und beim schreiben von Unicode zu Ascii.
Leider ist die Trennung dieser beiden String-Formate nicht sauber gelöst, da es nicht möglich ist ein Ascii- String zu deklarieren. Gleichzeitig aber beim Schreiben nach Außen immer eine Konvertierung durchgeführt wird. Dies kann auch zu Konflikten führen wenn dies nicht berücksichtigt wird und nicht die Formate übergeben werden wie sie erwartet werden, zB. auch im Zusammenhang mit API-Deklarationen.
| Typ | Beschreibung |
| Ascii | Das Standard Zeichenformat in welchem für jedes Zeichen 1 Byte reserviert wird. So ist es möglich 256 Symbole abzubilden, wobei die ersten 32 Steuerzeichen und keine Text-Symbole darstellen.
Die Symbole sind ein allgemein gültiger ISO-Standard.
Es existieren 2 Ascii Standards, das neu Windows Format welches unter VB verwendet wird, aber auch das alte DOS Format, welches noch Symbole enthielt für die grafische Abbildung von Rahmen mit Textsymbolen. |
| Unicode | Ist ein neues Standard Zeichenformat in welchem für jedes Zeichen 2 Byte reserviert werden. Es ist auf diese weise möglich mehrere Sprachen und Sonderzeichen abzubilden da jedes Zeichen 65536 Symbole abbilden kann.
Auch dies ist ein ISO-Standard, der permanent weiterentwickelt wird. Die ersten 256 Zeichen im Unicode sind identisch mit dem aus dem Ascii-Code (Windows). |
Daten-Typen können auch als Feld oder Array deklariert werden, sie können ein oder mehrdimensional deklariert werden und können so Listen oder Matrizen von Daten enthalten.
Wie bei normalen Variablen dürfen alle Daten-Typen deklariert werden. Ist eine Deklaration aber einmal erfolgt, kann der Daten-Typ bei einer Redimensionierung nicht mehr geändert werden.
Bei einer Dimensionierung eines Arrays werden alle Werte auf 0 initialisiert. Das gleichzeitige Festlegen von Werten bei der Dimensionierung ist leider nicht möglich.
Über Erase kann ein Array aus dem Speicher gelöscht und der reservierte Speicherbereich wieder freigegeben werden.
Wird nur ein Wert und kein Bereich deklariert, wird automatisch die Standarduntergrenze 0 verwendet. Diese kann über die Option "Option Base ?" geändert werden, erlaubt sind die Werte 0 und 1.
Felder können Statisch mit Dim oder Dynamisch mit ReDim deklariert werden. Statisch bedeutet das die Größe des Arrays während der Laufzeit nicht geändert werden kann, bei dynamischen Arrays kann die Größe während der Laufzeit geädert werden.
Wird ein Dynamisches Array ohne Angabe der Größe deklariert, und auf dieser zugegriffen bevor eine Dimensionierung durchgeführt wurde, wird ein Laufzeitfehler auftreten.
Die Größe Dynamische Arrays kann geändert werden, dabei gehen aber die enthaltenen Daten verloren. Um dies zu verhindern kann das Schlüsselwort Preserve verwendet werden.
Um die Größe eines Arrays zu ermitteln können die Funktionen LBound für Untergrenze und UBound für Obergrenze verwendet werden.
Es wird bei mehrdimensionalen Arrays leider keine Reimensionierung aller Dimensionen unterstützt, da dazu eine Umformung der Datenstruktur im speichern notwendig wäre. Durch die Struktur im Speicher ist nur die Redimensionierung der letzen Dimension möglich. Also sollte man zB. bei einem 2 dimensionalen Array in welchem die Zeilenanzahl redimensionierbar sein soll, die Zeilen auf der zweiten Dimension abgebildet werden Arr1(Spalten, Zeilen).
'-------- Deklaration
Option Base 0 ' Legt die Standarduntergrenze auf 0 fest
Private Arr1() As Long ' Legt ein dynamisches Array an, das noch keine Dimensionierung besitzt
Private Arr2(10) As Long ' Legt ein statisches 1-dimensionales Array an, das dimensioniert ist mit: 11 Feldern, von 0 bis 10.
Private Arr3(1 To 10) As Long ' Legt ein statisches 1-dimensionales Array an, das dimensioniert ist mit: 10 Feldern, von 1 bis 10.
Private Arr4(1 To 10, 1 To 20) As Long ' Legt ein statisches 2-dimensionales Array an, das dimensioniert ist mit: 10x20 Feldern, von 1 bis 10 und 1 bis 20.
'-------- Code
Dim Arr5(1 To 10) As Long ' Legt ein statisches 1-dimensionales Array an
ReDim Arr6() As Long ' Legt ein dynamisches 1-dimensionales Array an, das noch keine Dimensionierung besitzt
ReDim Arr7(1 To 10) As Long ' Legt ein dynamisches 1-dimensionales Array an
ReDim Arr8(-10 To 10) As Long ' Legt ein dynamisches 1-dimensionales Array an
ReDim Arr9(1 To 2, 1 to 100) As String ' Legt ein dynamisches 2-dimensionales Array an, wobei die erste Dimension 2 Spalten und die zweite 100 Zeilen enthält.
ReDim Arr1(1 To 10) ' das zuvor bereits deklarierte Arr1 wird jetzt erst Dimensioniert. Der Daten-Typ kann nun auch weggelassen werden da er <cls code>Long</cls> bleiben muß.
Arr1(1) = 100 ' Werte können nun in das Array geschrieben werden wie bei einer Variable auch.
Arr1(2) = 200
Arr9(2, 5) = "Text"
Redim Preserve Arr1(1 To 20) ' Ein dynamisches Array kann redimensioniert werden ohne die Enthaltenen werden zu löschen.
Debug.Print Arr1(1) ' der Wert 100 bleibt erhalten
Erase Arr1 ' Löscht den Speicher der von "Arr1" belegt wird, "Arr1" ist danach leer
Es können auch mehrere Daten-Typen zu einer Daten-Struktur zusammengefaßt werden, dies geschieht über das Schlüsselwort Type. Ist eine Daten-Struktur einmal Deklariert, kann man ihn genauso zum Deklarieren von Variabelname oder Parameter verwenden wie ein Standard Daten-Typen.
Daten-Strukturen stellt nur die Form zur Verfügung, um auch Speicher zu deklarieren muß über Dim eine Variable Deklariert werden wie bei den Normalen Daten-Typen auch.
Daten-Strukturen haben viele Vorteile, da man sie auch genauso durch eine Zuweisung als ganzes an ein anderen gleichnamigen Type kopieren kann oder auch mit allen enthaltenen Daten speichern kann. Hat man in einem Programm mehrere Variablen die zusammen gehören, sollte man sie über eine Daten-Struktur schon wegen der Übersichtlichkeit zusammenfassen.
Type können nur Private oder Public, also außerhalb einer Prozedur deklariert werden, innerhalb einer Prozedur wird eine Type Deklaration leider nicht zugelassen.
Die Größe einer Daten-Struktur kann über die Funktion Len nur dann ermittelt werden, wenn alle Daten mit einer festen Länge deklariert wurden. Ist ein zB. String mit variabler Länge oder ein Objekt enthalten, kann der Speicherbedarf des Typs nicht ermittelt werden.
Daten-Strukturen können auch andere Daten-Strukturen enthalten und so verschachtelt werden.
|