Visual-Basic Schnellkurs

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

• Es können im Code Kommentare eingefügt werden die vom Compiler ignoriert werden. Alles nach einem '-Zeichen (Apostroph) wird als Kommentar betrachtet. Es können auch Codes auskommentiert werden um sie zu deaktivieren.
• Das Auskommentieren eines ganzen Blocks ist leider nicht möglich, der Editor bietet aber die Möglichkeit ein markierten Textblock auszukommentieren.

    ' 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.}

• Option Explicit Erzwingt das Variabeln explizit deklariert werden müssen. Auf diese Weise wird verhindert das zB. durch falsche Schreibweise unbemerkt neue Variablenamen deklariert werden und dies im Code überhaupt nicht auffällt. Das Fehlersuchen wird dann sehr schwer. Es ist zwar möglich die Daten-Typen teilweise auch mit Kürzeln anzugeben (&%!#@), tut man dies aber nicht werden sie automatisch als Variant behandelt, die viel zeitaufwendiger sind und auch mehr Speicher benutzen, und durch das wegfallen der Typenprüfung auch eine Fehlerquelle darstellen.
• Diese Anweisung wird im Code am besten ganz oben eingefügt und kann über eine Option im Editor automatisch in Projekte eingefügt werden.

'-------- 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 Namenskonvention unterläuft dies leider da der Daten-Typ als erstes eingegeben werden soll. Es spricht aber nichts gegen eine umgekehrte Schreibweise, falls man sich nicht an eine Vorgabe halten muß. ("StrReadTxt" ist besser als "txtStrRead")
• 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

• Um Informationen während der Entwicklungszeit auszugeben, kann über die Konsolen durch Debug.Print Text ausgegeben werden. Dieser Code wird nicht compiliert sondern nur während der Entwicklungszeit ausgeführt.
• Debug.Print funktioniert wie eine Auskommentieren, das heißt alles nach der Funktion wird bei der Compilierung ignoriert. Da VB leider keine Compiler-Konstante deklariert über welche es möglich ist festzustellen, ob das Programm in der Entwicklungszeit (Editor) oder in der Laufzeit (compiliert) ausgeführt wird, kann Debug.Print verwendet werden um dies im Programmlauf festzustellen.

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 beendet das Programm sofort.
• Die sofortige Beendung eines Programms hat aber auch Nachteile, da Initialisierte Klassen nicht auf Nothing gesetzt und damit aus dem Speicher gelöscht werden, verbleiben sie auch nach dem Programmende im Speicher. Und auch das Formular eines Programms ist eine Klasse, das beim abrupten beenden eines Programms im Speicher verbleibt. Programme sollten nie mit End beendet werden, es sollten zuerst mit Unload alle Formulare beendet werden und dann das Hauptformular beendet werden.

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.

• 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.

• Ganzzahlen können mit und ohne Vorzeichen interpretiert werden, das heißt mit negativen werden oder nur 0 und Positive Werte.

• Es ist möglich Ganzzahlen in verschiedenen Zahlensystemen zu schreiben. Unterstützt wird Dezimal (10) Hexadezimal (16) und Oktal (8).

    Var1 = 100     ' Dezimal
    Var1 = &H64    ' Hexadezimal
    Var1 = &O144   ' Oktal

• Fließpunktzahlen werden in der dieser Schreibweise geschrieben.
  {Mantisse}E[+-]{Exponent}

    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.
  • Er kann aufnehmen: Standard Daten-Typen, Array und Objekte
  • Er kann nicht aufnehmen: benutzerdefinierte Typen, Strings mit fester Länge
• 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.
  • Nothing wird im zusammehang mit Objekten verwendet und ist kein Untertyp sondern ein Inhalt. wenn also eine Variant-Variable als träger für ein Objekt dient, kann der Inhalt dieses Objekts Nothing sein, und zeigt an das ein Objekt-Varible noch keiner Instanz zugewiesen wurde.
  • Empty ist eine Variant-Variable dann, wenn nach der Deklaration noch kein Wert zugewiesen wurde, und somit noch Nichts enthalten ist, und auch noch kein Untertyp festgelegt wurde. Zurückgegeben wird Kontextabhängig 0 oder "" (Leer-String).
  • Null zeigt ann das der Variant-Variable absichtlich keine gültigen Daten enthält
  • Error ist noch die Möglichkeit ein bearbeitungsfehler (wie zB. ein überlaf) zu markieren, es bedeutet das die Daten zerstört wurden.

• Über die Funktion VarType() können die Untertypen über Konstanzern abgefragt werden, zurückgegeben wird eine Konstante. Dies funktioniert auch mit anderen Daten-Typen.

• Über Funktionen kann die Daten-Art ermitteln werden, ist True wenn der Inhalt der Daten-Art angehört.

• Es gibt drei Arten von Gültigkeitsbereichen, die bestimmen wo eine Deklaration gültig¦zugänglich¦sichtbar ist.

• 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

• Variabeln sind die einfachste Datenart in einem Programm und die meisten Standard Daten-Typen werden so wie sie sind von Prozessor unterstützt.
• Numerische Variabeln werden automatisch konvertiert, werden sie auf ein unterschiedlichen Typen übergeben, wird aber ein größerer Daten-Typ an ein kleineren übergeben, besteht immer die Potentielle Gefahr das ein Überlauf während der Laufzeit stattfinden kann, wenn zB. ein Long an ein Integer übergeben wird, oder sogar ein Double an ein Integer. Zudem macht die Konvertierung den Code langsamer. Normalerweise sollte man alle Werte die man in einem Code miteinander verwenden vom gleichen Daten-Typ sein. In 32Bit Systemen ist Long am schnellsten.

'-------- 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

• Alle Werte die in einem Programm als Wert oder "Text" eingegeben werden gelten als Konstanten. Es können aber auch Konstanten über das Schlüsselwort Const als Namen Deklariert werden. Dies hat den großen Vorteil das bestimmte Werte an verschiedenen stellen immer gleich lauten und über ein Name angegeben werden können. So können sie leicht geändert werden oder auch durch eine Variable ersetzt werden falls man im laufe der Programmierung feststellt das der Wert variabel sein sollte. Der Wert der die Konstante repräsentieren soll wird gleich bei der Deklaration angegeben.

'-------- 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.

• 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.
  </