Excel aufmöbeln mit VBA - Fachbereich Mathematik und ...
Excel aufmöbeln mit VBA - Fachbereich Mathematik und ...
Excel aufmöbeln mit VBA - Fachbereich Mathematik und ...
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
<strong>Excel</strong> <strong>aufmöbeln</strong> <strong>mit</strong> <strong>VBA</strong><br />
Dietrich Baumgarten<br />
19. November 2008
Inhaltsverzeichnis<br />
1 Das Ausgangsproblem 9<br />
1.1 Die Hochschule <strong>und</strong> ihre Professoren . . . . . . . . . . . . . . . . . . . . 9<br />
1.1.1 Gr<strong>und</strong>gehalt <strong>und</strong> Zulagen . . . . . . . . . . . . . . . . . . . . . . 9<br />
1.1.2 <strong>Fachbereich</strong>e <strong>und</strong> Studiengänge . . . . . . . . . . . . . . . . . . . 10<br />
1.1.3 Module <strong>und</strong> Kurse . . . . . . . . . . . . . . . . . . . . . . . . . . 10<br />
1.1.4 Hörergeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11<br />
1.2 Steuern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12<br />
1.3 Wie kann <strong>Excel</strong> helfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12<br />
1.4 Quellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13<br />
2 Dateneingabe <strong>und</strong> Formatierung 14<br />
2.1 Die Fenster von <strong>Excel</strong> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14<br />
2.2 <strong>Excel</strong>-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16<br />
2.3 Eingaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17<br />
2.3.1 Der Dialog Autokorrektur . . . . . . . . . . . . . . . . . . . . . . 18<br />
2.3.2 Zahlen als Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18<br />
2.3.3 Eingabehilfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19<br />
2.4 Navigieren <strong>mit</strong> Maus <strong>und</strong> Tastatur . . . . . . . . . . . . . . . . . . . . . 19<br />
2.5 Markieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19<br />
2.5.1 Markieren über das Namensfeld . . . . . . . . . . . . . . . . . . . 19<br />
2.5.2 Markieren <strong>mit</strong> der Maus . . . . . . . . . . . . . . . . . . . . . . . 20<br />
2.5.3 Markieren über die Tastatur . . . . . . . . . . . . . . . . . . . . . 20<br />
2.6 Befehle an <strong>Excel</strong> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20<br />
2.6.1 Das Menüsystem . . . . . . . . . . . . . . . . . . . . . . . . . . . 21<br />
2.6.2 Der Dialog Anpassen . . . . . . . . . . . . . . . . . . . . . . . . . 22<br />
2.6.3 Tastaturkürzel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22<br />
2.6.4 Abbrechen <strong>und</strong> Rückgängigmachen von Befehlen . . . . . . . . . . 23<br />
2.6.5 Kontextmenüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23<br />
2.6.6 Symbolleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24<br />
2.6.7 Ansichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25<br />
2.6.8 Der Monsterdialog Optionen . . . . . . . . . . . . . . . . . . . . . 25<br />
2.7 Formatierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26<br />
2.7.1 Der Formatdialog . . . . . . . . . . . . . . . . . . . . . . . . . . . 26<br />
2.7.2 Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27<br />
2.7.3 Zeilen <strong>und</strong> Spalten . . . . . . . . . . . . . . . . . . . . . . . . . . 27<br />
2.7.4 Zeile <strong>und</strong> Spalten aus- <strong>und</strong> einblenden . . . . . . . . . . . . . . . 28<br />
3
Inhaltsverzeichnis<br />
2.8 Autovervollständigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29<br />
2.8.1 Das Ausfüllkästchen . . . . . . . . . . . . . . . . . . . . . . . . . 29<br />
2.8.2 Der Reihendialog . . . . . . . . . . . . . . . . . . . . . . . . . . . 29<br />
2.8.3 Benutzerdefinierte Listen . . . . . . . . . . . . . . . . . . . . . . . 30<br />
2.9 Zwischentest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30<br />
3 Formeln <strong>und</strong> Funktionen 32<br />
3.1 Formeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32<br />
3.1.1 Absolute, gemischte <strong>und</strong> relative Bezüge . . . . . . . . . . . . . . 33<br />
3.1.2 Die F4-Taste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33<br />
3.1.3 Namensfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34<br />
3.1.4 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34<br />
3.1.5 Formelüberwachung . . . . . . . . . . . . . . . . . . . . . . . . . . 34<br />
3.1.6 Matrix-Formeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35<br />
3.2 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36<br />
3.3 Wichtige Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37<br />
3.4 Datumsangaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38<br />
3.5 Datumsfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39<br />
3.6 Matrixfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40<br />
3.7 WENN-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41<br />
3.8 SUMMEWENN-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . 43<br />
3.9 SVERWEIS-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43<br />
3.10 Rang-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45<br />
3.11 <strong>Excel</strong>-Solver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46<br />
4 Organisation von Mappen <strong>und</strong> Tabellen 48<br />
4.1 Arbeitsmappen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48<br />
4.1.1 Ausblenden von Arbeitsblättern . . . . . . . . . . . . . . . . . . . 49<br />
4.1.2 Gleichzeitiges Markieren von Arbeitsblättern . . . . . . . . . . . . 49<br />
4.1.3 Weitere Befehle zur Verwaltung von Blättern . . . . . . . . . . . . 49<br />
4.1.4 Verschieben oder Kopieren von Blättern . . . . . . . . . . . . . . 49<br />
4.2 Neue Tabelle <strong>und</strong> neues Fenster . . . . . . . . . . . . . . . . . . . . . . . 50<br />
4.3 Verschieben, Kopieren <strong>und</strong> Ausschneiden . . . . . . . . . . . . . . . . . . 51<br />
4.4 Fensterteilung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51<br />
4.5 Formelbezüge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52<br />
4.6 Bezug auf andere Mappen . . . . . . . . . . . . . . . . . . . . . . . . . . 52<br />
4.7 Die Gehaltsabrechnung der EEE . . . . . . . . . . . . . . . . . . . . . . . 52<br />
4.7.1 Kopie der Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . 53<br />
4.7.2 Berechnung der SuF-Zulage . . . . . . . . . . . . . . . . . . . . . 53<br />
4.7.3 Berechnung der Familien-Zulage . . . . . . . . . . . . . . . . . . . 54<br />
4.7.4 Berechnung der Alters-Zulage . . . . . . . . . . . . . . . . . . . . 54<br />
4.7.5 Berechnung der Gebühren . . . . . . . . . . . . . . . . . . . . . . 54<br />
5 Listen 56<br />
4
Inhaltsverzeichnis<br />
5.1 Was sind Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56<br />
5.2 Das Menü Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58<br />
5.2.1 Sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58<br />
5.2.2 Eingabehilfe durch Auswahl . . . . . . . . . . . . . . . . . . . . . 59<br />
5.3 Filtern von Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59<br />
5.4 Der Befehl Maske. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59<br />
5.4.1 Kriterien zum Filtern . . . . . . . . . . . . . . . . . . . . . . . . . 59<br />
5.4.2 Platzhalterzeichen . . . . . . . . . . . . . . . . . . . . . . . . . . 60<br />
5.5 Der Befehl Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61<br />
5.5.1 Benutzerdefinierter Autofilter . . . . . . . . . . . . . . . . . . . . 62<br />
5.6 Spezialfilter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63<br />
5.7 Datenbank-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64<br />
5.7.1 Tabelle der Datenbank-Funktionen . . . . . . . . . . . . . . . . . 65<br />
6 Diagramme 67<br />
6.1 Vorrausetzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67<br />
6.2 Der Diagrammassistent . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68<br />
6.3 Säulendiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69<br />
6.4 Punktdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69<br />
6.5 Nachbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70<br />
6.6 Histogramme als Punktdiagramm . . . . . . . . . . . . . . . . . . . . . . 71<br />
6.6.1 Histogramm <strong>und</strong> Verteilungsfunktion . . . . . . . . . . . . . . . . 72<br />
6.7 Sek<strong>und</strong>ärachse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72<br />
7 Aufgaben 75<br />
8 Die Entwicklungsumgebung von Visual Basic 79<br />
8.1 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79<br />
8.2 Makroaufzeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79<br />
8.3 Der Visual Basic Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . 81<br />
8.3.1 Der Projekt-Explorer . . . . . . . . . . . . . . . . . . . . . . . . . 82<br />
8.3.2 Das Code-Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . 82<br />
8.3.3 Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83<br />
8.3.4 Sub-Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83<br />
8.3.5 Ausführen von Sub-Prozeduren . . . . . . . . . . . . . . . . . . . 83<br />
8.3.6 Laufzeitfehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84<br />
8.3.7 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85<br />
8.4 Formulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85<br />
8.4.1 Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . 85<br />
8.4.2 Erstellen von Formularen . . . . . . . . . . . . . . . . . . . . . . . 86<br />
8.4.3 Einfügen von Steuerelementen in ein Formular . . . . . . . . . . . 87<br />
8.4.4 Eigenschaften von Steuerelementen . . . . . . . . . . . . . . . . . 87<br />
8.4.5 Wichtige Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . 88<br />
8.4.6 Ereignisse von Steuerelementen . . . . . . . . . . . . . . . . . . . 88<br />
5
Inhaltsverzeichnis<br />
8.4.7 Ereignisse <strong>und</strong> Eigenschaften des Programms . . . . . . . . . . . . 89<br />
8.4.8 Die Tabellenereignisse . . . . . . . . . . . . . . . . . . . . . . . . 89<br />
8.4.9 Die Formulareignisse . . . . . . . . . . . . . . . . . . . . . . . . . 90<br />
8.4.10 Test des Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91<br />
8.5 Eigenschaften, Methoden <strong>und</strong> Ereignisse . . . . . . . . . . . . . . . . . . 91<br />
8.5.1 Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91<br />
8.5.2 Eigenschaften <strong>und</strong> Methoden . . . . . . . . . . . . . . . . . . . . 91<br />
8.5.3 Unterschied zwischen Ereignissen <strong>und</strong> Methoden . . . . . . . . . . 92<br />
8.5.4 Steuerelemente auf Tabellen . . . . . . . . . . . . . . . . . . . . . 93<br />
8.5.5 Listen- <strong>und</strong> Kombinationsfelder . . . . . . . . . . . . . . . . . . . 94<br />
8.5.6 Qualifizierte Bezeichner . . . . . . . . . . . . . . . . . . . . . . . . 95<br />
8.5.7 Die With-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . 96<br />
8.5.8 Das Formular DemoForm . . . . . . . . . . . . . . . . . . . . . . 96<br />
8.5.9 Der Code des Formulars DemoForm . . . . . . . . . . . . . . . . 97<br />
8.6 Meldungsfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97<br />
8.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99<br />
9 Die Sprachsyntax von Visual Basic 101<br />
9.1 Die Bausteine von <strong>VBA</strong> . . . . . . . . . . . . . . . . . . . . . . . . . . . 101<br />
9.1.1 Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102<br />
9.1.2 Initialisierung von Variablen . . . . . . . . . . . . . . . . . . . . . 104<br />
9.1.3 Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104<br />
9.1.4 Gültigkeit von Variablen <strong>und</strong> Prozeduren . . . . . . . . . . . . . . 105<br />
9.1.5 Option Explicit-Anweisung . . . . . . . . . . . . . . . . . . . . . . 105<br />
9.1.6 Ein weiteres Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . 106<br />
9.1.7 Gültigkeit von Prozeduren . . . . . . . . . . . . . . . . . . . . . . 108<br />
9.2 Format <strong>und</strong> Zeichenvorrat . . . . . . . . . . . . . . . . . . . . . . . . . . 108<br />
9.2.1 Format von Anweisungen . . . . . . . . . . . . . . . . . . . . . . . 108<br />
9.2.2 Zeichenvorrat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109<br />
9.2.3 Bezeichner (identifier) . . . . . . . . . . . . . . . . . . . . . . . . 109<br />
9.2.4 Schlüsselworte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109<br />
9.2.5 Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110<br />
9.3 Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110<br />
9.3.1 Basistypen für Zahlen . . . . . . . . . . . . . . . . . . . . . . . . 110<br />
9.3.2 Überlauf bei ganzen Zahlen . . . . . . . . . . . . . . . . . . . . . 111<br />
9.3.3 Der logische Datentyp . . . . . . . . . . . . . . . . . . . . . . . . 111<br />
9.3.4 Bedingte Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . 111<br />
9.3.5 Zeichenfolgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112<br />
9.3.6 Vordefinierte Zeichenfolgen . . . . . . . . . . . . . . . . . . . . . . 113<br />
9.3.7 Der Verkettungsoperator & für Zeichenfolgen . . . . . . . . . . . . 113<br />
9.3.8 Nützliche Stringfunktionen . . . . . . . . . . . . . . . . . . . . . . 114<br />
9.3.9 Wiederholungen einer Anweisung . . . . . . . . . . . . . . . . . . 116<br />
9.3.10 Datenfelder (Arrays) . . . . . . . . . . . . . . . . . . . . . . . . . 116<br />
9.3.11 Unter- <strong>und</strong> Obergrenzen eines Datenfelds . . . . . . . . . . . . . . 117<br />
6
Inhaltsverzeichnis<br />
9.3.12 Dynamische Datenfelder . . . . . . . . . . . . . . . . . . . . . . . 118<br />
9.3.13 Mehrdimensionale Datenfelder . . . . . . . . . . . . . . . . . . . . 119<br />
9.3.14 Der Datumstyp Date . . . . . . . . . . . . . . . . . . . . . . . . . 120<br />
9.3.15 Nützliche Datums-Funktionen . . . . . . . . . . . . . . . . . . . . 120<br />
9.3.16 Typumwandlungsfunktionen . . . . . . . . . . . . . . . . . . . . . 122<br />
9.3.17 Benutzerdefinierte Datentypen . . . . . . . . . . . . . . . . . . . . 123<br />
9.3.18 Der Datentyp Variant . . . . . . . . . . . . . . . . . . . . . . . . 124<br />
9.4 Operatoren, Ausdrücke <strong>und</strong> Anweisungen . . . . . . . . . . . . . . . . . . 124<br />
9.4.1 Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124<br />
9.4.2 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125<br />
9.4.3 Der Zuweisungsoperator . . . . . . . . . . . . . . . . . . . . . . . 125<br />
9.4.4 Der Modulooperator . . . . . . . . . . . . . . . . . . . . . . . . . 126<br />
9.4.5 Der Gregorianische Kalender . . . . . . . . . . . . . . . . . . . . . 126<br />
9.4.6 Logische Ausdrücke <strong>und</strong> Operatoren . . . . . . . . . . . . . . . . 127<br />
9.4.7 Vorrangregeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129<br />
9.5 Funktionen <strong>und</strong> Sub-Prozeduren . . . . . . . . . . . . . . . . . . . . . . . 130<br />
9.5.1 Einführendes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . 130<br />
9.5.2 Syntax von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . 131<br />
9.5.3 Verwendung von Funktionen in <strong>Excel</strong> . . . . . . . . . . . . . . . . 132<br />
9.5.4 Aufruf von Funktionen in <strong>VBA</strong> . . . . . . . . . . . . . . . . . . . 132<br />
9.5.5 Formale <strong>und</strong> aktuelle Parameter von Funktionen . . . . . . . . . . 133<br />
9.5.6 Parameterübergabe durch Referenz . . . . . . . . . . . . . . . . . 134<br />
9.5.7 Objekte als Parameter . . . . . . . . . . . . . . . . . . . . . . . . 135<br />
9.5.8 ByRef klappt nicht bei Strings . . . . . . . . . . . . . . . . . . . . 136<br />
9.5.9 Vektoren als Parameter . . . . . . . . . . . . . . . . . . . . . . . . 136<br />
9.6 Ablaufkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138<br />
9.6.1 Blöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138<br />
9.6.2 If. . . Else-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . 139<br />
9.6.3 Die Anweisung ElseIf . . . . . . . . . . . . . . . . . . . . . . . . . 140<br />
9.6.4 Auswahl <strong>mit</strong> Select Case . . . . . . . . . . . . . . . . . . . . . . 141<br />
9.6.5 Ein weiteres Beispiel: Jahreszeiten . . . . . . . . . . . . . . . . . . 143<br />
9.6.6 Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144<br />
9.6.7 for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145<br />
9.6.8 Beispiele <strong>mit</strong> Zeichenketten . . . . . . . . . . . . . . . . . . . . . 145<br />
9.6.9 Vektoren <strong>und</strong> Schleifen . . . . . . . . . . . . . . . . . . . . . . . . 146<br />
9.6.10 Der gregorianische Kalender . . . . . . . . . . . . . . . . . . . . . 147<br />
9.6.11 Verschachtelte Schleifen . . . . . . . . . . . . . . . . . . . . . . . 149<br />
9.6.12 Schleifen <strong>mit</strong> Wiederholungsbedingung am Ende . . . . . . . . . . 149<br />
9.6.13 Schleifen <strong>mit</strong> Abbruchbedingung am Ende . . . . . . . . . . . . . 150<br />
9.6.14 Die Quersumme einer Zahl . . . . . . . . . . . . . . . . . . . . . . 151<br />
9.6.15 Der größte gemeinsame Teiler einer Zahl . . . . . . . . . . . . . . 151<br />
9.6.16 Aufruf von Funktionen aus Funktionen . . . . . . . . . . . . . . . 152<br />
9.6.17 Wiederholungsbedingung am Anfang . . . . . . . . . . . . . . . . 153<br />
9.6.18 Die GoTo Sprunganweisung . . . . . . . . . . . . . . . . . . . . . 153<br />
7
Inhaltsverzeichnis<br />
8<br />
9.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
1 Das Ausgangsproblem<br />
Ich werde viele Teile anhand der Gehaltsberechnungen einer fiktiven Hochschule erläutern.<br />
Diese Hochschule werde ich zunächst vorstellen.<br />
1.1 Die Hochschule <strong>und</strong> ihre Professoren<br />
Die Emil-Erpel-Eliteuniversität in Entenhausen, kurz die EEE oder Triple E, hat zwei<br />
<strong>Fachbereich</strong>e <strong>mit</strong> drei Studiengängen. Jeder Studiengang hat zwei Semester <strong>und</strong> besteht<br />
aus Modulen. Der <strong>Fachbereich</strong> <strong>Mathematik</strong> <strong>und</strong> Datenverarbeitung (MaD) hat die Studiengänge<br />
<strong>Mathematik</strong> <strong>und</strong> Wirtschaftsinformatik, während der <strong>Fachbereich</strong> Sozial- <strong>und</strong><br />
Finanzwissenschaften (SuF) sich <strong>mit</strong> dem Studiengang Financial Engineering begnügt.<br />
Der Lehrbetrieb ruht auf den Schultern des in Abbildung 1.1 abgebildeten Kollegiums.<br />
1.1.1 Gr<strong>und</strong>gehalt <strong>und</strong> Zulagen<br />
Abbildung 1.1: Das Professorenkollegium<br />
Das Gehalt beruht auf zähen individuellen Verhandlungen <strong>mit</strong> dem Besitzer <strong>und</strong> Präsidenten<br />
der privaten Hochschule, Dagobert Duck.<br />
Zusätzlich gibt es familiäre Zuschläge, <strong>und</strong> zwar pro Gatte 100 e <strong>und</strong> pro Kind 200 e.<br />
Die Mitglieder des FBR SuF erhalten eine generelle Zulage von 150 e. Wer im Jahrzehnt<br />
vom 1.1.1960 bis zum 31.12.1969 geboren ist, erfreut sich an 100 e Alterszulage. Wer<br />
zwischen dem 1.1.1950 <strong>und</strong> dem 31.12.1959 geboren ist, erhält 200 e Alterszulage <strong>und</strong><br />
alle noch älteren Kollegen beziehen 300 e.<br />
Die dritte Komponente des Bruttogehalts ist das Hörergeld, das später beschrieben<br />
wird.<br />
9
1 Das Ausgangsproblem<br />
1.1.2 <strong>Fachbereich</strong>e <strong>und</strong> Studiengänge<br />
Die wichtigsten Teile der beiden <strong>Fachbereich</strong>e erklärt die folgende Tabelle:<br />
Kürzel <strong>Fachbereich</strong> Dekan Prodekan<br />
MaD <strong>Mathematik</strong> <strong>und</strong> Datenverarbeitung Trauerwein Schurigl<br />
SuF Sozial- <strong>und</strong> Finanzwissenschaften Grün Greulich<br />
Den Aufbau der drei Studiengänge entnehmen Sie bitte der folgenden Tabelle:<br />
Sem <strong>Mathematik</strong> Wirtschafts-<br />
Informatik<br />
Financial Engineering<br />
1 Analysis C Analysis<br />
1 C Financial Computing Economics<br />
2 Lineare Algebra Datenbanken Financial Computing<br />
2 Financial Computing Lineare Algebra C<br />
1.1.3 Module <strong>und</strong> Kurse<br />
Die Studiengänge sind modular aufgebaut. Für jedes Modul ist genau ein Professor der<br />
EEE zuständig, der für die Stoffauswahl, die Literatur <strong>und</strong> die Darstellung im Internet<br />
sorgt, der Modulverantwortliche. Die Beschreibung der Module befindet sich im Modulhandbuch.<br />
Natürlich dürfen aber auch andere Dozenten Kurse lesen, müssen sich aber<br />
dabei aber an die Vorgaben des Modulverantwortlichen halten. Die wichtigsten Angaben<br />
zu den Modulen sind in der Abbildung 1.2 zu finden: Die Abkürzung SWS steht<br />
Abbildung 1.2: Modulkatalog<br />
für Semesterwochenst<strong>und</strong>en. Jeder Student muss im Rahmen der Mittelorientierten<br />
Studiengebühren (MiSt) bei der Belegung eines Kurses die Gr<strong>und</strong>gebühr für eine SWS<br />
des Moduls multipliziert <strong>mit</strong> der Anzahl der SWS als Teilnahmegebühr bezahlen, etwa<br />
für C: 6 ∗ 80 = 480 e. Wie einträglich das ist, ergibt sich aus der Abbildung 1.3, in der<br />
alle 2004 angebotenen Kurse der EEE <strong>mit</strong> eingenommenen Gebühren aufgelistet sind:<br />
10
1.1.4 Hörergeld<br />
Abbildung 1.3: Kurse des Jahres 2005<br />
1.1 Die Hochschule <strong>und</strong> ihre Professoren<br />
Um den Professoren das neue Modell schmackhaft zu machen, erhöht sich nach Einführung<br />
von MiSt das Bruttomonatsgehalt um 1% der insgesamt innerhalb des Vorjahres<br />
verursachten Gebühren, wobei auf den nächsten durch 10 teilbaren Betrag abzur<strong>und</strong>en<br />
ist. Beim Dekan Trauerwein kommen daher ab Januar 2006 zum bisherigen Bruttogehalt<br />
noch einmal ungefähr 1% von 57 ∗ 80 ∗ 6 + 33 ∗ 70 ∗ 6 = 41220 e hinzu, denn seine<br />
beiden C-Kurse haben zusammen 57 Hörer, die Gebühr pro SWS beträgt 80 e <strong>und</strong> der<br />
St<strong>und</strong>enumfang sind 6 SWS. Die 33 Hörer des Kurses Datenbanken dürfen für jede der<br />
6 SWS 70 e berappen. Dadurch erhöht sich sein Monatsgehalt nach der Abr<strong>und</strong>ung auf<br />
die nächste durch 10 teilbare Zahl um 410 e. Trauerwein ist entzückt <strong>und</strong> verspricht<br />
im ersten Überschwang das gesamte Abrechnungswesen zunächst auf <strong>Excel</strong> <strong>und</strong> danach<br />
sogar auf Datenbanken umzustellen. Seine Sekretärin Elsa von Brabant fällt ihm dankbar<br />
um den Hals, denn bisher muss sie alle Gehälter mühsam von Hand ausrechnen. Die<br />
Frauenbeauftragte Fräulein Eisenbeiß wirft ein, wer soll’s denn machen, das kann doch<br />
keiner von uns. Trauerwein knurrt unwirsch zurück: dann müssen eben die Studenten<br />
11
1 Das Ausgangsproblem<br />
ran, wozu zahlen die schließlich Studiengebühren. Alle sind begeistert <strong>und</strong> lassen ihren<br />
Dekan hochleben.<br />
1.2 Steuern<br />
Natürlich ist auch das Finanzamt im Spiel. In Entenhausen gilt die Bierdeckelformel<br />
von Prof. Salavator Salbader: Aus dem Bruttomonatsgehalt wird durch Multiplikation<br />
<strong>mit</strong> 12 das Bruttojahresgehalt berechnet, davon wird für jedes Kind 2000 e abgezogen.<br />
Das ergibt das zu versteuernde Jahreseinkommen. Für die ersten 10000 e erfolgt kein<br />
Steuerabzug. Für den Überschuss über 10000 e ist zwischen 10000 e <strong>und</strong> 20000 e ein<br />
Steuersatz von 10% fällig. Bleibt immer noch was übrig, so wird der Betrag zwischen<br />
20000 e <strong>und</strong> 30000 e <strong>mit</strong> 20% besteuert <strong>und</strong> der dann noch verbleibende Rest <strong>mit</strong><br />
30%. Die Gesamtsteuer wird auf die größte durch 12 teilbare ganze Zahl verkleinert.<br />
Diese Zahl wird durch 12 geteilt <strong>und</strong> ergibt die monatlich fällige Steuer, die dann vom<br />
Bruttobetrag abgezogen wird <strong>und</strong> als Nettogehalt zur Auszahlung erfolgt.<br />
Die Sekretärin Elsa von Brabant muss Brutto- <strong>und</strong> Nettogehälter mühsam <strong>mit</strong> Papier<br />
<strong>und</strong> Bleistift berechnen <strong>und</strong> fragt sich: Mein lieber Schwan, geht das nicht auch elektronisch?<br />
Verfolgen wir Elsas Berechnungen am Beispiel des Dekans Trauerwein:<br />
Gr<strong>und</strong>gehalt: 6000 e<br />
Ehegattenzuschlag: 100 e<br />
Kindergeld: 2 · 200 = 400 e<br />
Alterspauschale: 200 e<br />
Hörergeld: 410 e<br />
Bruttogehalt: 7110 e<br />
Jahresgehalt: 12 · 7110 = 85320 e<br />
Abzug für 2 Kinder: 85320 − 2 · 2000 = 81320 e<br />
Zu versteuern: 10000 · 0 + 10000 · 0, 1 + 10000 · 0, 2 + 51320 · 0, 3 = 18396 e<br />
Abr<strong>und</strong>ung : 18396 (ist zufällig durch 12 teilbar)<br />
Steuerabzug pro Monat: 18396/12 = 1533 e<br />
Nettogehalt 7110 -1533 = 5577 e<br />
So verbringt die liebliche Elsa dem Stumpfsinn trotzend fröhlich singend ihre Tage,<br />
fest entschlossen nie mehr dumme Fragen zu stellen.<br />
1.3 Wie kann <strong>Excel</strong> helfen<br />
<strong>Excel</strong> ist ein so genanntes Tabellenkalkulationsprogramm, d.h. man kann da<strong>mit</strong> Daten in<br />
Tabellen erfassen, darstellen <strong>und</strong> dauerhaft speichern. Dieser Teil ist einfach zu lernen,<br />
wenn Sie <strong>mit</strong> Word umgehen können, wird Ihnen auch <strong>Excel</strong> keine Schwierigkeit machen.<br />
Die wichtigsten Angaben zur EEE habe ich schon als <strong>Excel</strong>-Tabellen präsentiert.<br />
Es handelt sich dabei um unterschiedliche Tabellen, die aber Teil einer einzigen Datei<br />
12
1.4 Quellen<br />
sind. <strong>Excel</strong>-Dateien heißen Arbeitmappen <strong>und</strong> haben die Erweiterung xls. Mit Ausnahme<br />
der Spalte Gesamtgebühr in Abbildung 1.3 wurden dabei nur Daten eingegeben, dieser<br />
mühselige Arbeitsgang steht am Anfang jeder Arbeit <strong>mit</strong> <strong>Excel</strong>.<br />
<strong>Excel</strong> kann aber auch kalkulieren, aus den Angaben der Modultabelle <strong>mit</strong> den Gebühren<br />
<strong>und</strong> der Hörerzahl habe ich über so genannte Formeln die Gesamtgebühren für<br />
jeden Kurs berechnet. Das erst macht <strong>Excel</strong> so wertvoll.<br />
Aber <strong>Excel</strong> kann noch mehr. Tabellen lassen sich grafisch darstellen, wobei <strong>Excel</strong><br />
unzählige Varianten anbietet, die man in einem eigenen Buch behandeln könnte.<br />
Mindestens genauso wichtig sind die Datenbankfähigkeiten von <strong>Excel</strong>. Die Frauenbeauftragte<br />
kann Durchschnittsgehälter von Frauen <strong>und</strong> Männer ausrechnen lassen <strong>und</strong> die<br />
skandalöse Unterbezahlung ihres Geschlechts <strong>mit</strong> flammenden Anklagen durch Zahlen<br />
untermauern. Weitere Auswertungen könnten die Belastungen der einzelnen Professoren<br />
durch den Vorlesungsbetrieb betreffen oder den Einnahmen der drei Studiengänge<br />
gelten.<br />
<strong>Excel</strong> arbeitet perfekt <strong>mit</strong> den anderen Produkten des Hauses Microsoft zusammen,<br />
man kann daher z.B. Serienbriefe <strong>mit</strong> Word schreiben oder Daten von Access beziehen<br />
oder dorthin senden. Obwohl <strong>Excel</strong> selbst kein Datenbankprogramm ist, versteht<br />
es trotzdem die Standardsprache SQL (Standard Query Language), was ein mächtiges<br />
Werkzeug zur Pflege, Darstellung <strong>und</strong> Auswertung von Daten ist.<br />
1.4 Quellen<br />
Die EEE habe ich mir ausgedacht. Die deutschen Namen des Kollegiums stammen von<br />
Frau Erika Fuchs, der begabten <strong>und</strong> vor kurzem hoch betagt verstorbenen Übersetzerin<br />
der Geschichten von Walt Disney. In Richard Wagners Oper Lohengrin ist Elsa von<br />
Brabant eine tragische Prinzessin, die sich aus weiblicher Neugier in ihrer Hochzeitsnacht<br />
aus dem warmen Ehebett direkt ins kalte Grab singt, schluchz.<br />
13
2 Dateneingabe <strong>und</strong> Formatierung<br />
In diesem Kapitel wird gezeigt, wie <strong>Excel</strong> aufgebaut ist <strong>und</strong> wie man Daten eingibt <strong>und</strong><br />
formatiert.<br />
2.1 Die Fenster von <strong>Excel</strong><br />
Abbildung 2.1: Das Anwendungsfenster<br />
<strong>Excel</strong> ist Teil des Office-Pakets, zu dem u.a. noch das Textverarbeitungsprogramm<br />
Word, das Datenbankprogramm Access sowie Powerpoint gehören. Es ist eine der sprudelnden<br />
Geldquellen von Microsoft <strong>und</strong> mehr oder weniger legal auf fast jedem PC der<br />
Erde installiert. Daher ist es relativ einfach <strong>Excel</strong>-Tabellen nach Word zu exportieren<br />
14
2.1 Die Fenster von <strong>Excel</strong><br />
oder umgekehrt Text von Word zu importieren. <strong>Excel</strong> ist ein Windows-Programm <strong>und</strong><br />
erscheint daher in einem Fenster, dem so genannten Anwendungsfenster. Es besteht von<br />
oben nach unten aus folgenden Bestandteilen:<br />
• Die Titelleiste. Diese hat ganz rechts das Symbol des Systemmenüs, gefolgt von<br />
der Bezeichnung Microsoft <strong>Excel</strong> <strong>und</strong> je nach Zustand des Fensters wird auch die<br />
gerade aktuelle Arbeitsmappe angezeigt. Den Zustand des Fensters beeinflussen die<br />
drei Symbole ganz rechts. Das Symbol - versetzt das Fenster auf die Task-Leiste,<br />
von wo es durch Anklicken wieder zum Vorschein gebracht werden kann. Das äußere<br />
x schließt das Fenster <strong>und</strong> da<strong>mit</strong> <strong>Excel</strong>. Über die Tastatur wird <strong>Excel</strong> durch<br />
Alt+ F4 geschlossen. Das <strong>mit</strong>tlere Symbol zeigt entweder ein Quadrat der zwei sich<br />
überlappende Quadrate. Wird wie in der Abbildung nur ein Quadrat angezeigt,<br />
hat das Fenster nicht seine Maximalgröße <strong>und</strong> kann an den Rändern <strong>mit</strong> der Maus<br />
vergrößert oder verkleinert werden. Klickt man das Quadrat an, erscheint <strong>Excel</strong><br />
im Vollbild <strong>und</strong> nimmt den ganzen Bildschirm ein. Das Symbol ändert sich dann<br />
auf die erwähnten zwei Quadrate. Durch erneutes Anklicken nimmt das Fenster<br />
wieder seine ursprüngliche Größe an. Die Umschaltung zwischen den beiden Darstellungsarten<br />
leistet auch ein Doppelklick in der Titelleiste.<br />
• Das Arbeitsmappenfenster. Dieses enthält die geöffneten Arbeitsmappen. Jede<br />
geöffnete Arbeitsmappe besitzt ein eigenes Fenster <strong>mit</strong> denselben Schaltflächen wie<br />
das Anwendungsfenster. Ist das Fenster einer Arbeitsmappe im Vollbild, verschwindet<br />
seine Titelleiste. Der Dateiname steht dann in der Titelleiste des Anwendungsfensters<br />
<strong>und</strong> die drei Fenstersymbole tauchen ganz rechts in der Titelleiste auf. Ist<br />
das Fenster der Arbeitsmappe wie oben abgebildet nicht im Vollbild, bekommt es<br />
eine eigene Titelleiste.<br />
• Die Menüleiste. Diese enthält mehrere Menüs, etwa das Menü Datei. Jedes Menü<br />
besteht aus einer Sammlung verwandter Befehle.<br />
• Die Symbolleisten. Der Raum unterhalb der Menüleiste ist für die so genannten<br />
Symbolleisten reserviert. Diese enthalten grafische Symbole für die wichtigsten<br />
Befehle von <strong>Excel</strong>. Führt man den Mauszeiger sanft über ein Symbol, erscheint<br />
nach kurzer Zeit eine Beschreibung des Befehls.<br />
• Die Bearbeitungsleiste. Diese ist spezifisch für <strong>Excel</strong>. Sie besteht aus dem Namensfeld<br />
<strong>und</strong> dem Eingabefeld. <strong>Excel</strong> unterteilt die Arbeitsblätter in Zellen,<br />
wobei jede Zelle einen eigenen Inhalt haben kann. In der obigen Abbildung ist die<br />
Zelle C8 aktiv, daher steht im Namensfeld C8. Der Inhalt der Zelle steht in der<br />
Zelle selbst <strong>und</strong> im Eingabefeld. Der scheinbare Unterschied zwischen 01.01.2000<br />
<strong>und</strong> 1.1.2000 rührt nur von der Formatierung der Zelle her.<br />
• Die Spaltenüberschriften. Jede Tabelle hat 256 Spalten, die alphabetisch zunächst<br />
von A bis Z verlaufen. Dann geht es <strong>mit</strong> AA bis AZ weiter <strong>und</strong> hört bei<br />
IV auf. Zwischen je zwei Spaltenüberschriften befindet sich eine Trennlinie. Führt<br />
man die Maus darauf, verändert der Mauszeiger seine Form in einen nach links<br />
15
2 Dateneingabe <strong>und</strong> Formatierung<br />
<strong>und</strong> rechts weisenden Doppelpfeil, um anzudeuten, dass die linke Spalte durch Ziehen<br />
<strong>mit</strong> der Maus in der Breite verändert werden kann. Ein Doppelklick auf der<br />
Trennlinie verändert die Breite der Spalte auf die optimale Breite, also die kleinste<br />
Breite, die gerade noch alle Inhalte der Spalte vollständig anzeigt.<br />
• Die Zeilenüberschriften. Jede Tabelle hat 65536 Zeilen, die am Zeilenanfang<br />
durchnummeriert sind. Über die Trennlinie lässt sich wie oben beschrieben sinngemäß<br />
die Höhe der oberen Zeile verändern.<br />
• Die Schaltfläche Alles Markieren. Diese befindet sich über den Zeilenüberschriften<br />
<strong>und</strong> links der Spaltenüberschriften. Klickt man sie an, wird die ganze Tabelle<br />
markiert. Das erreicht man auch über die Tastenkombination Strg + A .<br />
• Die Fensterleiste. Jede Arbeitsmappe besteht aus Tabellen, standardmäßig drei<br />
Stück, welche zunächst Tabelle1, Tabelle2 <strong>und</strong> Tabelle3 heißen. Die Tabellennamen<br />
erscheinen in Registern, wobei die aktuelle Tabelle hervorgehoben ist. In der obigen<br />
Abbildung ist das die Tabelle namens Anfang. Neben den Registern für die Arbeitsblätter<br />
befinden sich vier Pfeilsymbole zum Navigieren. Durch Anklicken des<br />
ersten Symbols wird die erste Arbeitsmappe ausgewählt, nach Klicken der letzten<br />
wird zur letzten Arbeitsmappe gesprungen, während die beiden <strong>mit</strong>tleren Symbole<br />
einen Wechsel nach links bzw. rechts erlauben. Klickt man auf eines Pfeilsymbole<br />
<strong>mit</strong> der rechten Maustaste, erscheinen alle Arbeitsblätter in einem Listenfeld <strong>und</strong><br />
man kann bequem eines davon auswählen. Durch Doppelklick auf einem Register<br />
kann der Name des Arbeitsblatts geändert werden.<br />
• Die horizontale <strong>und</strong> vertikale Bildlaufleisten. Da<strong>mit</strong> steuert man durch die aktuelle<br />
Tabelle, die meist größer ist, als der Bildschirmausschnitt. Die horizontale<br />
Bildlaufleiste ist direkt neben der Fensterleiste. Zwischen beiden befindet sich eine<br />
Trennlinie, die man <strong>mit</strong> der Maus wie oben für die Spaltenüberschriften beschrieben<br />
nach links <strong>und</strong> rechts ziehen kann.<br />
• Die Statusleiste. Ist meiner Meinung nach entbehrlich, zeigt meist überflüssige<br />
Informationen an. Kann über den Befehl Extras Optionen ausgeblendet werden.<br />
2.2 <strong>Excel</strong>-Objekte<br />
Soweit zum Äußeren von <strong>Excel</strong>. Nach innen verwaltet <strong>Excel</strong> Dateien, die so genannten<br />
Arbeitsmappen, englisch workbooks. Als tüchtiges Programm kann <strong>Excel</strong> mehrere Arbeitsmappen<br />
zur gleichen Zeit verwalten, davon rate ich Ihnen aber zunächst ab. Die<br />
Arbeitsmappen bestehen wiederum aus Arbeitsblättern, auf englisch worksheets. Die<br />
Blätter bestehen aus rechteckig angeordneten Zellen, die von oben nach unten zeilenweise<br />
durch Zahlen <strong>und</strong> von links nach rechts spaltenweise durch Buchstaben markiert sind.<br />
Die Zelle C7 steht also in der dritten Spalte der siebten Zeile. In der deutschen Literatur<br />
werden die Arbeitsblätter meistens Tabellen genannt, dem werde ich mich von jetzt ab<br />
16
2.3 Eingaben<br />
anschließen. Alle Zellen einer Zeile bilden ein Zeilenobjekt <strong>und</strong> haben als Schicksalsgemeinschaft<br />
dieselbe Zeilenhöhe, entsprechend haben die Zellen einer Spalte alle dieselbe<br />
Breite. Zeilen <strong>und</strong> Spalten sind Beispiele eines wichtigen Objekttyps, des so genannten<br />
Bereichs oder auf englisch range. Ein Bereich besteht aus einem Rechteck von Zellen,<br />
wobei zunächst die linke obere <strong>und</strong> dann die rechte untere Zelle angegeben wird, also<br />
etwa C7:F12. Die Zelle D8 gehört dazu, nicht aber D13.<br />
2.3 Eingaben<br />
<strong>Excel</strong> erlaubt die Eingabe von Text, Zahlen <strong>und</strong> Datumsangeben. Es gibt bei der Eingabe<br />
von Daten in eine Zelle drei Zustände:<br />
• Bereit. Eine Zelle ist ausgewählt, aber noch nicht zum Bearbeiten oder Eingeben.<br />
Dieser Zustand stellt sich durch Anklicken <strong>mit</strong> der Maus oder durch Navigation<br />
<strong>mit</strong> den Bewegungstasten der Tastatur ein.<br />
• Bearbeiten. Die Zelle ist ausgewählt <strong>und</strong> das Eingabefeld angeklickt. Die Bewegungstasten<br />
wirken nur innerhalb des Eingabefelds. Drückt man jetzt die Taste<br />
F2, ergibt sich der Zustand<br />
• Eingeben. Die Eingabe von normalen Zeichen bleibt gleich, aber über die Bewegungstasten<br />
wird die Zelle verlassen. Der eingegebene Inhalt wird für die Zelle<br />
übernommen. In diesen Zustand gelangt man auch, wenn man eine Zelle doppelt<br />
anklickt. Die Umschaltung in den Bearbeiten-Modus erfolgt durch F2.<br />
Im Modus Bearbeiten wird die Eingabe durch die Taste Eingabe beendet. <strong>Excel</strong> aktiviert<br />
dann die Zelle direkt darunter. Die Richtungstasten gelten innerhalb des Eingabefelds,<br />
während im Modus Eingeben zusätzlich zur Eingabe-Taste auch die Richtungstasten<br />
die Eingabe beenden <strong>und</strong> die entsprechenden Zelle aktiviert wird. Der jeweilige<br />
Zustand des Eingabefelds ist in der Statusleiste angezeigt. Bei den beiden letzten Zuständen<br />
erscheinen zwischen Namensfeld <strong>und</strong> EIngabefeld ein rotes Kreuz, ein grüner<br />
Haken <strong>und</strong> das Symbol fx. Der rote Haken löscht die neu erstellte Eingabe <strong>und</strong> stellt<br />
den alten Zustand wieder her, entspricht da<strong>mit</strong> der Esc-Taste. Über den grünen Haken<br />
wird dagegen die neue Eingabe übernommen. Auf das dritte Symbol komme ich später<br />
zurück.<br />
Falls der Inhalt einer Zelle nicht ganz in die Zelle passt, wird der Rest in den Nachbarzellen<br />
untergebracht, sofern diese leer sind. Ist das nicht der Fall, wird zwar nur der<br />
darstellbare Teil gezeigt, aber die Zelle behält den ganzen Inhalt. In der obigen Abbildung<br />
ist die Zelle D2 zu schmal für den Text »Wasser«, das »r« würde gerne in der<br />
Nachbarzelle unterschlüpfen, aber diese ist bereits belegt <strong>und</strong> daher erscheint es verkrüppelt.<br />
Wenn dagegen eine Zahl nicht genügend Platz in ihrer Zelle vorfindet, macht<br />
<strong>Excel</strong> das durch die hässlichen Lattenkreuze deutlich, in Abbildung 2.1 ist das in der<br />
Zelle E6 passiert.<br />
Ein Zeilenumbruch innerhalb einer Zelle wird durch Alt + Eingabe bewirkt. <strong>Excel</strong><br />
stellt dann die Zeilenhöhe entsprechend ein. Dies habe ich in der Zelle E2 gemacht.<br />
17
2 Dateneingabe <strong>und</strong> Formatierung<br />
2.3.1 Der Dialog Autokorrektur<br />
Dieser Dialog öffnet sich über die Befehlsfolge Extras|Autokorrektur-Optionen.<br />
Man kann Kürzel für vollständige oft verwendete Begriffe oder Symbole definieren. Falls<br />
jemand zufällig »Dietrich BAumgarten« heißt, wird er das oft zu schreiben haben <strong>und</strong><br />
freut sich, wenn das Kürzel »db« sich zum vollen Namen entfaltet. Die Autokorrektur<br />
ersetzt auch automatisch den zweiten Großbuchstaben am Anfang eines Wortes durch<br />
einen kleinen. Das kann lästig werden, daher kann die Autokorrektur durch Strg + Z<br />
rückgängig gemacht werden.<br />
Abbildung 2.2: Der Dialog Autokorrektur<br />
Jeder Eintrag gilt für alle Teile des Office-Pakets <strong>und</strong> kann wieder gelöscht werden.<br />
2.3.2 Zahlen als Text<br />
Eine der Stärken von <strong>Excel</strong> besteht darin, dass automatisch Zahlen erkannt werden. Es<br />
kann aber passieren, dass man Zahlen als Text interpretieren möchte, etwa Postleitzahlen<br />
wie 09873 oder Matrikelnummern. <strong>Excel</strong> versucht etwas übereifrig 09873 als Zahl zu<br />
verstehen <strong>und</strong> wandelt eigensinnig in 9873 um. Durch einen vorangestellten Apostroph<br />
»’« wird aus der vermeintlichen Zahl gewöhnlicher Text, man gibt also ’09873 statt 09873<br />
ein.<br />
18
2.3.3 Eingabehilfen<br />
2.4 Navigieren <strong>mit</strong> Maus <strong>und</strong> Tastatur<br />
Oft kommt es vor, dass sich die Einträge in einer Spalte wiederholen. Wenn Sie in einer<br />
Zelle die rechte Maustaste drücken, erscheint das Kontextmenü <strong>mit</strong> u.a. dem Befehl<br />
Auswahlliste. Wenn Sie diesen aufrufen, öffnet sich ein Listenfeld <strong>mit</strong> allen bisherigen<br />
Einträgen in der entsprechenden Spalte bis zur ersten leeren Zelle.<br />
2.4 Navigieren <strong>mit</strong> Maus <strong>und</strong> Tastatur<br />
Mit der Maus <strong>und</strong> den Laufleisten lässt sich am leichtesten durch ein Blatt navigieren. Es<br />
geht aber auch über die Tastatur. Die vier einfachen Pfeiltasten führen zum Wechsel der<br />
aktiven Zelle um eine Position nach links, rechts, oben oder unten. Die Bild-Hoch- bzw.<br />
Bild-Runtertasten verschieben den Bildschirmausschnitt um genau ein Bild nach oben<br />
oder unten. Die Bild-Hoch- bzw. Bild-Runtertasten bei gedrückter Alt-Taste verschieben<br />
den Bildschirmausschnitt um genau ein Bild nach links oder rechts. Die Bild-Hoch- bzw.<br />
Bild-Runtertasten bei gedrückter Strg-Taste führen zum Wechsel der aktuellen Tabelle.<br />
Die Taste Pos1 aktiviert die erste Zelle der aktuellen Zeile, während Strg+Pos1 einen<br />
Sprung zur ersten Zelle der Tabelle nach sich zieht. Die Taste End aktiviert die letzte<br />
jemals verwendete Zelle der Tabelle. Die Rück-Taste bei gedrückter Steuerungs-Taste<br />
rollt den Bildschirmausschnitt zur aktiven Zelle zurück.<br />
2.5 Markieren<br />
Viele Befehle richten sich an markierte Zellen. Eine einzelne Zelle wird durch anklicken<br />
<strong>mit</strong> der Maus oder über die Richtungstasten markiert. Größere Einheiten sind Rechtecke,<br />
die von links oben nach rechts unten verlaufen, etwa der Bereich B2 bis D6, wofür<br />
man kurz B2:D6 schreibt. Es können auch einzelne Zeilen oder Spalten sowie eine Folge<br />
zusammenhängender Zeilen oder Spalten markiert werden. Bei der Mehrfachauswahl<br />
können beliebig viele dieser Elementarbereiche ausgewählt werden. Die Markierung erfolgt<br />
über das Namensfeld, die Maus oder die Tastatur.<br />
In der Abbildung 2.1 ist der Bereich von Zelle C8 bis Zelle E9 markiert. Dies ist an<br />
der breiten Unrandung <strong>und</strong> dem grauen Hintergr<strong>und</strong> zu erkennen, wobei die ausgewählte<br />
Zelle C8 weiß bleibt.<br />
Man kann auch die ganze Tabelle auswählen. Dazu muss man entweder Strg + A<br />
eingeben oder die Schaltfläche zwischen den Zeilen- <strong>und</strong> Spaltenüberschriften anklicken.<br />
2.5.1 Markieren über das Namensfeld<br />
Am einfachsten geht die Markierung über das Namensfeld. In der folgenden Tabelle wird<br />
gezeigt wie:<br />
19
2 Dateneingabe <strong>und</strong> Formatierung<br />
Rechteck Folge von Zeilen Folge von Spalten Mehrfachauswahl<br />
C6:F8 3:8 C:E 3:8;B1:F5<br />
Rechteck von Zelle Zeilen 3 bis 8 Spalten C bis E Bereiche durch Se-<br />
C6 bis Zelle F8<br />
mikolon trennen<br />
Sie brauchen nur einen Ausdruck dieser Art in das Namensfeld zu schreiben <strong>und</strong> schon<br />
erscheint der entsprechende Bereich markiert.<br />
2.5.2 Markieren <strong>mit</strong> der Maus<br />
Die Markierung <strong>mit</strong> der Maus geschieht durch Ziehen <strong>mit</strong> gedrückter linker Maustaste<br />
von der linken oberen Zelle bis zur unteren rechten Zelle. Die markierten Zellen erscheinen<br />
bis auf die Anfangszelle <strong>mit</strong> dunklem Hintergr<strong>und</strong>. Möchte man einen weiteren<br />
Rechteckbereich markieren, muss die Steuerungstaste beim Ziehen gehalten werden.<br />
Sollen zusammenhängende Zeilen- oder Spaltenbereiche markiert werden, einfach den<br />
oberen Zeilen- bzw. den linken Spaltenkopf anwählen <strong>und</strong> dann nach unten bzw. rechts<br />
ziehen.<br />
2.5.3 Markieren über die Tastatur<br />
Die Markierung über die Tastatur geschieht über die Richtungstasten bei gedrückter<br />
Umschalt-Taste. Alternativ kann auch zuerst F8 gedrückt werden, danach wird<br />
der gewünschte Bereich durch die Richtungstasten markiert. Abschließend wieder F8<br />
drücken. Eine ganze Zeile wird über Umschalt + Leertaste , eine ganze Spalte über<br />
Strg + Leertaste markiert. Weitere Zeilen bzw. Spalten danach bei gedrückter Umschalttaste<br />
über die Richtungstasten markieren.<br />
Sollen mehrere Bereiche markiert werden, empfiehlt es sich, bei gedrückter Umschalt-<br />
Taste den ersten Bereich zu markieren, dann Umschalt + F8 zu drücken, zur ersten<br />
Zelle des zweiten Bereichs zu wechseln <strong>und</strong> diesen <strong>mit</strong> gedrückter Umschalt-Taste ebenfalls<br />
zu markieren. Zum Schluss dann wieder Umschalt + F8 drücken, um in den<br />
gewohnten Modus zurück zu gelangen. Jetzt können Befehle auf den markierten Bereich<br />
erfolgen, aber auf keinen Fall in eine Zelle klicken oder die Richtungstasten aktivieren,<br />
denn es gilt folgende Warnung:<br />
WWW Die Markierung wird aufgehoben, wenn die Richtungstasten oder die Maus<br />
eine neue Zelle auswählen.<br />
2.6 Befehle an <strong>Excel</strong><br />
<strong>Excel</strong>dateien entstehen durch Eingabe von Daten <strong>und</strong> deren Bearbeitung über Befehle.<br />
Die Befehle sind nach Themen innerhalb der Menüs gegliedert. Beim Laden von <strong>Excel</strong><br />
wird eine leere Arbeitsmappe <strong>mit</strong> dem schönen Namen Mappe1 erstellt. Sie erinnern<br />
sich an die Objekthierarchie. Danach bestehen Arbeitsmappen aus Tabellen (Arbeitsblättern)<br />
<strong>mit</strong> standardmäßig 256 Spalten <strong>und</strong> 65536 Zeilen. <strong>Excel</strong> erstellt drei Tabellen<br />
20
2.6 Befehle an <strong>Excel</strong><br />
<strong>mit</strong> den Namen Tabelle1, Tabelle2 <strong>und</strong> Tabelle3. Die Tabellennamen finden Sie ganz<br />
unten direkt über der Statusleiste in der Fensterleiste. Unsere ersten Aufgaben bestehen<br />
nun im Speichern der neuen Mappe <strong>und</strong> in der Änderung der Standardtabellennamen.<br />
Solche Aufgaben werden über Befehle an <strong>Excel</strong> erledigt. Dafür gibt es vier Möglichkeiten:<br />
• Über die Menüs der Menüleiste.<br />
• Über ein Tastaturkürzel wie Strg + S .<br />
• Über die Kontextmenüs.<br />
• Über ein Symbol der Symbolleisten.<br />
2.6.1 Das Menüsystem<br />
Abbildung 2.3: Das Menu Format<br />
Die Menüleiste besteht aus den Menüs Datei, Bearbeiten, usw. Jedes Menü öffnet<br />
sich durch Anklicken oder durch gleichzeitiges Drücken der Alt-Taste <strong>und</strong> des unterstrichenen<br />
Buchstabens, etwa Alt + t zum Öffnen des Menüs Format. Innerhalb des Menüs<br />
kann man die einzelnen Befehle <strong>mit</strong> der Maus anklicken oder über den unterstrichenen<br />
Buchstaben auswählen. Durch Drücken der Alt-Taste gelangt man in die Menüleiste<br />
<strong>und</strong> kann dann über die Bewegungstasten zu allen Menüpunkten kommen. Das ist aber<br />
nur bedingt empfehlenswert, etwa wenn die Maus streikt oder von der Katze gefressen<br />
wurde.<br />
Die Menüpunkte führen direkt Befehle aus, es sei denn sie enden <strong>mit</strong> drei Pünktchen.<br />
Dann öffnet sich ein Dialog zur weiteren Bearbeitung. Manche Menüpunkte enden auch<br />
<strong>mit</strong> einem Pfeil, dessen Anklicken vergabelt dann zu den endgültigen Befehlen. Schauen<br />
Sie sich bitte das Menü Format an. Der Befehl Zellen. . . führt zu einem Dialog, wie<br />
an den drei Pünktchen zu erkennen ist. Der Befehl Spalte führt wie abgebildet zu einer<br />
weiteren Auswahl von Befehlen. Wenn man die unterstrichenen Buchstaben auswendig<br />
kennt, kann man den Befehl Format|Spalten. . . durch Alt + t gefolgt von l über<br />
die Tastatur ausführen.<br />
21
2 Dateneingabe <strong>und</strong> Formatierung<br />
2.6.2 Der Dialog Anpassen<br />
Die Office-Programme bilden ein Gesamtkunstwerk <strong>und</strong> teilen sich den schönen Dialog<br />
Anpassen, der sich unter dem Menü Extras befindet. Darin kann man im Register<br />
Optionen steuern, wie sich die Befehle eines Menüs entfalten. Insbesondere kann die<br />
Option Nach kurzer Verzögerung vollständige Menüs anzeigen wählen. Dann werden die<br />
zuletzt verwendeten Befehle zuerst angezeigt <strong>und</strong> man muss auf die restlichen Befehle<br />
einen Augenblick warten. Ich finde das wenig hilfreich <strong>und</strong> habe diese Option abgewählt.<br />
Außerdem lassen sich noch Kindereien wie Menüanimation auswählen. Na ja, chacun à<br />
son goût, wie der Lateiner sagt. Ihre Entscheidung wird danach für alle Office-Programme<br />
gültig. Die beiden anderen Register sind für die individuelle Anpassung der Symbolleisten<br />
erstellt worden.<br />
2.6.3 Tastaturkürzel<br />
Abbildung 2.4: Der Dialog Anpassen<br />
Ich vermeide die Auswahl von Befehlen über Menüs, wo immer ich kann <strong>und</strong> bevorzuge<br />
die schnellen Tastaturkürzel, oft auch Shortcuts genannt. Der Befehl Speichern des<br />
Menüs Datei etwa lässt sich über Strg + S sofort auslösen. Das Ablegen eines markierten<br />
Teil in die Zwischenablage erledigt Strg + C, das Ausschneiden erfolgt über Strg + X<br />
<strong>und</strong> das Einfügen aus der Zwischenablage geht ratzfatz <strong>mit</strong> Strg + V. Das funktioniert<br />
in fast allen Windows-Programmen.<br />
Viele Befehle führen zu Dialogen. Auch hier kann man sich alternativ zur Maus <strong>mit</strong><br />
der Tastatur durch die Tabulator-Taste nach vorne bewegen. Steuerelemente <strong>mit</strong> unterstrichenen<br />
Buchstaben kann man bei gehaltener Alt-Taste über diesen Buchstaben<br />
22
2.6 Befehle an <strong>Excel</strong><br />
erreichen.<br />
Zur Übung speichern Sie nun bitte ihre Arbeitsmappe unter dem Namen ueb1.xls. Dies<br />
erfolgt über die Befehlsfolge Datei|Speichern unter. . . . Der neue Namen erscheint<br />
dann in der Titelleiste wie in Abbildung 2.9.<br />
2.6.4 Abbrechen <strong>und</strong> Rückgängigmachen von Befehlen<br />
Manchmal hat man einen Befehl vorschnell ausgeführt <strong>und</strong> ist <strong>mit</strong> dem Ergebnis unzufrieden.<br />
Dann kann diese Aktion durch Strg + Z oder über die Befehlsfolge Bearbeiten|Rückgängig<br />
widerrufen werden. Die eben beschriebene Notbremse sollten Sie<br />
sich gut merken. <strong>Excel</strong> macht bis zu 20 Aktionen rückgängig.<br />
Über die Taste Abbrechen kann ein laufender Befehl abgebrochen werden.<br />
2.6.5 Kontextmenüs<br />
Die Umständlichkeit des Menüsystems haben die Entwickler von Windows schon frühzeitig<br />
bemerkt <strong>und</strong> daher die Kontextmenüs eingeführt. Kontextmenüs sind objektbezogen<br />
<strong>und</strong> selektieren daher aus dem umfangreichen Menüsystem die passenden Befehle. Diese<br />
öffnen sich durch Drücken der rechten Maustaste über dem zu manipulierenden Objekt.<br />
TTT Man kann aber auch über die Tastatur zum Kontextmenü über die Tastenkombination<br />
Umschalt + F10 gelangen.<br />
Will man etwa an den Symbolleisten Veränderungen vornehmen, klickt man hier <strong>mit</strong><br />
der rechten Maustaste, aber natürlich nicht direkt auf einem Symbol, da dieses sich sonst<br />
angesprochen fühlt, sondern zwischen zwei Symbolen. Es öffnet sich dann eine Liste<br />
der vorhandenen Symbolleisten. Man wählt in der Regel mindestens die Symbolleisten<br />
Standard <strong>und</strong> Format. Sie erkennen am Haken die Auswahl.<br />
Probieren wir es <strong>mit</strong> der Fensterleiste, wo die vorhandenen Arbeitsblätter aufgeführt<br />
sind. Nach dem Klicken <strong>mit</strong> der rechten Maustaste auf ein Namensregister erscheinen<br />
im Kontextmenü Befehle zur Verwaltung von Tabellen wie Löschen, Kopieren oder<br />
Umbenennen. Wie Sie sehen, habe ich auf diese Weise in Abbildung 2.9 die Namen<br />
Anfang <strong>und</strong> Rohdaten für die ersten beiden Tabellen festgelegt. Machen Sie das dann<br />
bitte auch.<br />
Wenn man zu den drei vorhandenen Tabellen eine weitere benötigt, kann man über<br />
das Kontextmenü durch den Befehl Einfügen eine neue Tabelle erstellen lassen.<br />
TTT: Noch schneller lassen sich Tabellennamen durch Doppelklick <strong>mit</strong> der linken<br />
Maustaste im Register ändern. Der bisherige Namen erscheint hervorgehoben <strong>und</strong> kann<br />
editiert werden.<br />
Auch das Verschieben oder Kopieren einer Tabelle geht <strong>mit</strong> der Maus schneller als<br />
über das Kontextmenü. Man packt <strong>mit</strong> der linken Maustaste das Register der Tabelle<br />
<strong>und</strong> zieht es an die gewünschte neue Stelle. Hält man zusätzlich die Strg-Taste bleibt<br />
die bisherige Tabelle an ihrer alten Stelle <strong>und</strong> an der neuen Stelle entsteht eine Kopie.<br />
Auch Zeilen <strong>und</strong> Spalten haben Kontextmenüs. Schreiben Sie in die Zellen A1 <strong>und</strong> A2<br />
etwas Unsinniges, den Rest der beiden ersten Zeilen lassen Sie leer. Das Kontextmenü<br />
der Zeilen verwende ich, um die beiden ersten Zeilen zu löschen. Zunächst werden durch<br />
23
2 Dateneingabe <strong>und</strong> Formatierung<br />
Ziehen über die Zeilenköpfe die beiden ersten Zeilen markiert. Es gibt die Möglichkeit<br />
nur die Inhalte zu löschen oder die Zeilen vollständig auszulöschen. Dann rücken die<br />
anderen Zeilen nach <strong>und</strong> erhalten neue Zeilennummern. Die beiden Befehle lauten Inhalte<br />
löschen bzw. Zeilen löschen. Wählen Sie zunächst den ersten Befehl, so<br />
verschwinden die eingefügten Inhalte, aber die Zeilen bleiben verschont. Wählt man danach<br />
oder hätte sofort den zweiten Befehl gewählt, so verschwinden die Zeilen für immer<br />
<strong>und</strong> die restlichen Zeilen wandern nach oben.<br />
2.6.6 Symbolleisten<br />
<strong>Excel</strong> bietet eine Unzahl von Symbolleisten an, in Abbildung 2.1 habe ich über das<br />
Kontextmenü der Symbolleisten die Symbolleisten Standard <strong>und</strong> Format <strong>und</strong> in Abbildung<br />
2.9 lediglich die Symbolleiste Steuerelemente-Toolbox ausgewählt. Jede Symbolleiste<br />
kann über den Befehl Anpassen noch individuell gestaltet werden. Die Standardsymbolleiste<br />
enthält die klassischen Symbole für Speichern, Drucken, Seitenansicht <strong>und</strong> den<br />
sehr nützlichen Pinsel, auf den ich noch zu sprechen komme. Je nach Bildschirmgröße<br />
kann im Zoomfeld die Größe der Ansicht verändert werden.<br />
Symbolleisten sind durch eingekerbte Striche optisch in logische Einheiten untergliedert.<br />
An den hervorgehobenen Strichen erkennt man den Beginn einer Symbolleiste.<br />
Packt man einen solchen Strich, nimmt der Mauszeiger die Form eines Kreuzes <strong>mit</strong> vier<br />
Pfeilen an, zum Zeichen dafür, dass die Symbolleiste zum Verschieben bereit ist. Ich<br />
habe in Abbildung 2.1 die beiden erwähnten Symbolleisten untereinander geschoben.<br />
Man kann jede Symbolleiste aber auch an die senkrechten Ränder links <strong>und</strong> rechts oder<br />
sogar in das eigentliche Arbeitsblatt verschieben. Dann sieht die Symbolleiste wie ein<br />
gewöhnliches Fenster aus. Zieht man sie dann zurück nach oben, unten, rechts oder links,<br />
erscheint wieder der hervorgehobene Strich.<br />
Jede Symbolleiste endet <strong>mit</strong> einem Symbol, das einen nach unten gerichteten Pfeil<br />
zeigt. Klickt man diesen an, erscheinen alle Symbole der Leiste <strong>und</strong> man kann einzelne<br />
gezielt aus- oder einblenden. Dies ist gut in Abbildung 2.9 zu sehen. Wie zu erkennen<br />
ist, habe ich von der Symbolleiste Steuerelemente-Toolbox alle Symbole ausgewählt.<br />
Prägen Sie sich bitte an dieser Stelle schon mal gut das Symbol für den Entwurfsmodus<br />
ein. Es spielt innerhalb von Visual Basic <strong>und</strong> Access eine überragende Rolle<br />
In diesem Kapitel ist nicht nur dieses Symbol sondern auch die zugehörige Symbolleiste<br />
unnötig. Bringen Sie diese daher über das Kontextmenü wieder zum Verschwinden <strong>und</strong><br />
belassen es erst mal bei den Symbolleisten Standard <strong>und</strong> Format. Letztere wird im<br />
übernächsten Abschnitt erklärt.<br />
TTT Passt Ihnen die Anordnung der Symbole nicht, können Sie ein beliebiges Symbol<br />
bei gedrückter Alt-Taste an eine neue Stelle ziehen, auch außerhalb der eigenen<br />
Symbolleiste.<br />
Langt Ihnen das immer noch nicht, werden Sie vielleicht in dem folgendem Dialog<br />
fündig, der weitere Gestaltungsmöglichkeiten für das Menüsystem <strong>und</strong> die Steuerleisten<br />
bereitstellt.<br />
24
2.6.7 Ansichten<br />
2.6 Befehle an <strong>Excel</strong><br />
<strong>Excel</strong> bietet unzählige Möglichkeiten, die Ansicht des Fensters zu gestalten. Man kann<br />
die Gitterlinien ebenso ausblenden wie die Statusleiste oder die Laufleisten. Je nach<br />
Sehstärke kann auch die Bildschirmgröße des <strong>Excel</strong>-Fensters eingestellt werden. Dazu<br />
muss der Befehl Ansicht|Zoom. . . aufgerufen werden. Dann erscheint ein einfach zu<br />
bedienender Dialog zur Auswahl der Bildschirmgröße. Schneller geht die Zoomeinstellung<br />
natürlich über das entsprechende Symbol aus der Symbolleiste Standard, siehe dazu die<br />
Abbildung 2.1.<br />
2.6.8 Der Monsterdialog Optionen<br />
Dieser Dialog ist das Entsorgungslager für nicht einzuordnende Befehle. Er öffnet sich<br />
über den Befehl Optionen. . . des Menüs Extras. Mit jeder neuen Version kommen<br />
hier weitere Register hinzu. So sieht das Monster in meiner Office-Version aus:<br />
Abbildung 2.5: Der Dialog Optionen<br />
Generell behandelt dieser Dialog <strong>mit</strong> seinen unzähligen Registern die Erscheinung der<br />
Fenster. Leider weiß man nie, ob die Wahl nun für <strong>Excel</strong> als ganzes, oder für die aktuelle<br />
Arbeitsmappe oder gar nur für die aktuelle Tabelle gültig ist. Wählt man zum Beispiel die<br />
Option Gitternetzlinien ab, hat das nur Auswirkung auf das gerade aktuelle Arbeitsblatt.<br />
Entscheidet man sich gegen die Bearbeitungsleiste, verschwindet diese nicht nur in allen<br />
Arbeitsblättern der aktuellen Arbeitsmappe, sondern gleich in allen Arbeitsmappen.<br />
25
2 Dateneingabe <strong>und</strong> Formatierung<br />
Die Programmierer von Microsoft scheinen sich für den Monsterdialog selber etwas zu<br />
schämen, da er weder über ein Tastaturkürzel noch über ein Symbol zu erreichen ist.<br />
Andererseits ist er in fast allen Programmen des Hauses vorhanden.<br />
2.7 Formatierung<br />
Die Formatierung erfolgt am schnellsten über die Symbolleiste Format, die in Abbildung<br />
2.1 in der zweiten Reihe des Symbolleistenfensters gut zu sehen ist. Sie müssen zunächst<br />
einen Zellbereich markieren, dann können Sie die Schriftart, die Größe <strong>und</strong> Details wie<br />
Fettdruck oder kursiv auswählen. Die Ausrichtung kann links- oder rechtsbündig <strong>und</strong><br />
zentriert sein. Standardmäßig ist Text linksbündig <strong>und</strong> Zahlen sind rechtsbündig ausgerichtet.<br />
Sie können, etwa für Überschriften, mehrere Zellen verbinden. Der Hintergr<strong>und</strong><br />
kann <strong>mit</strong> dem Farbeimer eingefärbt <strong>und</strong> <strong>mit</strong> Hilfe des Symbols für Rahmen eingerahmt<br />
werden.<br />
Für Listen, das sind regelmäßige Rechteckbereiche, gibt es das Symbol Autoformat.<br />
Diese kann auch über die Befehlsfolge Format/AutoFormat. . . aktiviert werden. Ich<br />
habe da<strong>mit</strong> die Tabelle <strong>mit</strong> den Gewinnen formatiert. Die installierten Tabellenautoformate<br />
lassen sich noch nach eigenem Geschmack weiterverarbeiten.<br />
Sehr nützlich ist das Pinselsymbol, siehe Abbildung 2.1. Da<strong>mit</strong> lässt sich die Formatierung<br />
der gerade aktuellen Zelle auf einen beliebigen Bereich übertragen. Zuerst den<br />
Pinsel drücken <strong>und</strong> dann den gewünschten Bereich <strong>mit</strong> der gedrückter linker Maustaste<br />
überstreichen.<br />
2.7.1 Der Formatdialog<br />
26<br />
Abbildung 2.6: Der Dialog Zellen Formatieren
2.7 Formatierung<br />
Wenn das nicht langt, kann über die Befehlsfolge Format|Zellen. . . der in Abbildung<br />
2.6 zu sehende Dialog eingeblendet werden. Dieser Dialog erscheint auch sofort<br />
über den Shortcut Strg + 1.<br />
Der Dialog hat sechs Registerblätter für die vielfältigen Möglichkeiten der Formatierung.<br />
In der Abbildung ist das erste Blatt geöffnet, wo<strong>mit</strong> Zelleninhalte formatiert<br />
werden. Zunächst wird die Kategorie festgelegt <strong>und</strong> dann erfolgt der Feinschliff z.B.<br />
für die Anzahl der Nachkommastellen. In der Kategorie Währung kann das Währungssymbol<br />
wie $ oder e eingestellt werden, in der Kategorie Datum können Formate wie<br />
13.11.49 oder 13. November 1949 usw. ausgewählt werden.<br />
2.7.2 Löschen<br />
Den Inhalt einer Zelle kann man löschen, indem die Zelle zunächst ausgewählt wird.<br />
Der bisherige Inhalt erscheint in der Bearbeitungsleiste <strong>und</strong> kann jetzt gelöscht oder<br />
verändert werden.<br />
Das Löschen kann aber auch über Befehle erfolgen. Im Menü Bearbeiten gibt es zwei<br />
entsprechende Befehle. Zunächst muss aber eine Zelle oder ein Zellbereichs ausgewählt<br />
sein. <strong>Excel</strong> unterscheidet genau zwischen dem Inhalt einer Zelle <strong>und</strong> deren Formatierung.<br />
Beim Löschen über die Menüfolge Bearbeiten/Löschen wird entsprechend in einem<br />
Untermenü nachgefragt, ob der Inhalt, die Formatierung oder beides zu löschen sei.<br />
Bei dieser Vorgehensweise werden Inhalte, Formate, Formeln oder eben alles zusammen<br />
gelöscht, die betroffenen Zellen bleiben aber erhalten.<br />
Ist eine ganze Zeile oder Spalte markiert, können Sie diese auch ganz löschen, die<br />
anderen Zeilen bzw. Spalten rücken dann in den freien Raum. Die Befehlsfolge lautet<br />
Bearbeiten/Zellen löschen. . .<br />
Das Kontextmenü bietet die Befehle Inhalte löschen <strong>und</strong> Löschen an.<br />
2.7.3 Zeilen <strong>und</strong> Spalten<br />
Jedes Tabellenblatt hat genau 65 536 Zeilen <strong>und</strong> 256 Spalten. Daran ist nicht zu rütteln.<br />
Trotzdem kann man Zeilen <strong>und</strong> Spalten einfügen. <strong>Excel</strong> vernichtet dann einfach die letzte<br />
Zeile oder Spalte, sofern diese leer sind.<br />
Die Zeilen haben Zeilenüberschriften, die in in einer senkrechten Leiste durchnummeriert<br />
sind. Die Zeilenüberschriften sehen wie Schaltflächen aus <strong>und</strong> verhalten sich<br />
auch ähnlich. Durch Anklicken einer Zeilenüberschrift wird die ganze Zeile aktiviert.<br />
Klickt man die Zeilenüberschrift <strong>mit</strong> der rechten Maustaste an, erscheint das Kontextmenü.<br />
Darin befindet sich der Befehl Zeilenhöhe. . . Wählt man ihn aus, erscheint<br />
der Zeilenhöhedialog. Derselbe Dialog erscheint auch über die Menüfolge Format/Zeile/Höhe.<br />
. .<br />
Ändert man die Zahl im Eingabefeld des Dialogs, erscheint die Zeile vergrößert oder<br />
verkleinert. Doch was ist die Einheit? Pixel, Zoll oder cm? Alles falsch. Die Einheit<br />
ist Punkt, das ist die Standardeinheit für Grade von Schriften. Dieser Text wird beispielsweise<br />
in Garamond 12 Punkt geschrieben, <strong>Excel</strong> verwendet standardmäßig Arial<br />
10 Punkt. 72 Punkt ergeben einen Zoll, also ungefähr 2,56 cm. 12 Zoll machen einen<br />
27
2 Dateneingabe <strong>und</strong> Formatierung<br />
Abbildung 2.7: Der Zeilenhöhedialog<br />
Fuß aus, etwas mehr als 30 cm. Ein Yard besteht dann aus genau, finden Sie es selbst<br />
heraus. Glückliches Amerika, du hast es besser (Goethe).<br />
Die obige Zeilenhöhe ist gut an die Standardschriftart Arial 10 Punkt angepasst. Die<br />
Zeilenhöhe kann aber auch <strong>mit</strong> der Maus geändert werden. Ziehen Sie die Begrenzungslinie<br />
unterhalb der Zeilenüberschrift, bis die gewünschte Zeilenhöhe erreicht ist. Um die<br />
Zeilenhöhe an den Inhalt anzupassen, doppelklicken Sie auf die Begrenzungslinie unterhalb<br />
der Zeilenüberschrift.<br />
Um die Zeilenhöhe für mehrere Zeilen zu ändern, markieren Sie die entsprechenden Zeilen.<br />
Ziehen Sie dann die Begrenzungslinie unterhalb einer markierten Zeilenüberschrift<br />
an die gewünschte Position. Um die Höhe aller Zeilen im Tabellenblatt zu ändern, klicken<br />
Sie auf die Schaltfläche Alles Markieren. Ziehen Sie dann die Begrenzungslinie unterhalb<br />
einer beliebigen Zeilenüberschrift, bis die gewünschte Höhe erreicht ist.<br />
Das über die Zeilen Gesagte trifft sinngemäß auch auf die Spalten zu. Die Breite einer<br />
Spalte wird am rechten Rand der Überschrift verändert. Durch Doppelklicken auf diesen<br />
Rand wird die optimale Breite berechnet, d.h. die Breite wird so berechnet, dass alle<br />
Inhalte angezeigt werden können. Geht ein Inhalt absichtlich über mehrere leere Zellen,<br />
kann das unerwünscht sein.<br />
Die Breite einer Spalte kann über die Befehlsfolge Format/Spalte/Breite er<strong>mit</strong>telt<br />
werden. Die Einheit ist die Anzahl der Zeichen, die in einer bestimmten Schriftart in einer<br />
Zelle dargestellt werden können. Ein Wert von 11,75 erlaubt in der Standardschriftart<br />
Arial bei 10 Punkt etwa 12 sichtbare Zeichen. Ganz genau lässt es sich nicht sagen, da<br />
Arial eine Proportionalschriftart ist, bei der jedes Zeichen eine individuelle Breite hat,<br />
das schlanke i nimmt weniger Platz als das stattliche W.<br />
2.7.4 Zeile <strong>und</strong> Spalten aus- <strong>und</strong> einblenden<br />
Spalten <strong>und</strong> Zeilen können ausgeblendet werden. Das kann sinnvoll sein, wenn die Inhalte<br />
zwar für Kalkulationen benötigt werden, aber eine Anzeige nicht sinnvoll erscheint. So<br />
könnten bei einem Autoverkäufer hier Daten stehen wie etwa die Bonität des K<strong>und</strong>en,<br />
die der K<strong>und</strong>e zwar nicht sehen soll, die aber wichtig sind bei der Angebotskalkulation.<br />
Das Ausblenden ist sehr einfach. Durch Anklicken der Spalten- bzw. Zeilenüberschrift<br />
<strong>mit</strong> der rechten Maustaste erscheint im Kontextmenü der Befehl Ausblenden <strong>und</strong><br />
schon ist die Spalte oder Zeile weg. Über das Kontextmenü kann man auch leicht jede<br />
ausgeblendete Zeile oder Spalte wieder zum Vorschein bringen, außer der jeweils ersten.<br />
Ist die erste Zeile oder Spalte einer Tabelle ausgeblendet, geben Sie einfach im Na-<br />
28
2.8 Autovervollständigung<br />
mensfeld die Zelle A1 ein, <strong>und</strong> klicken Sie danach auf OK. Zeigen Sie im Menü Format<br />
auf Zeile bzw. Spalte, <strong>und</strong> klicken Sie dann auf Einblenden. Das klappt nicht nur<br />
für die erste Zeile oder Spalte, sondern für jede, nur muss natürlich statt A1 eine Zelle<br />
der entsprechenden Zeile oder Spalte eingegeben werden.<br />
2.8 Autovervollständigung<br />
2.8.1 Das Ausfüllkästchen<br />
In der Abbildung 2.1 ist der Bereich B8:D9 ausgewählt. Die aktuelle Zelle ist die linke<br />
obere, also B8. Sie erscheint weiß <strong>und</strong> ihr Inhalt steht im Eingabefeld, ihre Koordinaten<br />
im Namensfeld. In der Ecke unten links des markierten Bereichs erscheint ein kleines<br />
Kästchen, das so genannte Ausfüllkästchen. Durch Ziehen nach rechts oder unten erweitert<br />
sich nicht nur die Markierung, sondern in bestimmten Fällen auch der Inhalt der<br />
neu markierten Zellen. Wenn Sie auf das Ausfüllkästchen zeigen, nimmt der Mauszeiger<br />
die Form eines schwarzen Kreuzes an, nicht zu verwechseln <strong>mit</strong> den vier nach Norden,<br />
Süden, Osten <strong>und</strong> Westen zeigenden Pfeilen zum Verschieben einer Zelle. Sie müssen also<br />
das Ausfüllkästchen genau treffen. Danach die Maus <strong>mit</strong> gedrückter linker Maustaste<br />
solange wie erforderlich nach unten oder rechts ziehen <strong>und</strong> dann die Maustaste wieder<br />
los lassen.<br />
<strong>Excel</strong> erkennt die Gesetzmäßigkeit des Übergangs von Zeile 8 nach Zeile 9. In der Spalte<br />
C das genau ein Jahr spätere Datum, in der Spalte D kommen 20 Einheiten hinzu <strong>und</strong><br />
in der Spalte E wird von Abt. 1 zur Abt. 2 gesprungen. <strong>Excel</strong> vermutet lineare Trends<br />
<strong>und</strong> würde nach Ziehen am Ausfüllkästchen um zwei Zeilen nach unten die folgenden<br />
Einträge in den Zeilen 10 <strong>und</strong> 11 selbst vornehmen:<br />
1.1.2002 140 Abt. 3<br />
1.1.2003 160 Abt. 4<br />
Manchmal will man aber in einem Bereich einen konstanten Wert haben. Dann gibt<br />
man diesen Wert in die erste Zelle ein <strong>und</strong> zieht <strong>mit</strong> der linken Maustaste nach rechts<br />
bzw. unten <strong>und</strong> lässt dann los.<br />
2.8.2 Der Reihendialog<br />
Meist werden wie hier jeweils zwei Werte vorgegeben, da<strong>mit</strong> <strong>Excel</strong> den linearen Trend<br />
erkennt <strong>und</strong> folgen kann. Es gibt aber auch die Möglichkeit nur einen Wert anzugeben<br />
<strong>und</strong> dann am Ausfüllkästchen <strong>mit</strong> der rechten Maustaste zu ziehen. Der markierte<br />
Bereich bleibt zunächst leer, aber es erscheint ein Kontextmenü <strong>mit</strong> dem Menüpunkt<br />
Reihe. . . Wählt man diesen an, erscheint der Reihendialog von Abbildung 2.8. Dieser<br />
Dialog erscheint auch über die Menüfolge Bearbeiten/Ausfüllen/Reihe. . .. <strong>Excel</strong><br />
vermutet zunächst eine lineare Folge <strong>mit</strong> Inkrement von 1. Sie können hier jeden Wert<br />
einstellen. Bei linearen Folgen unterscheidet sich die Differenz benachbarter Zellen um<br />
29
2 Dateneingabe <strong>und</strong> Formatierung<br />
dieses Inkrement, bei geometrischen Folgen ist das Inkrement der Quotient der beiden<br />
Zellen.<br />
Abbildung 2.8: Der Reihendialog<br />
Die sicherlich bekannteste geometrische Folge ist die Zinseszinsformel Kn = K0(1+r) n ,<br />
wobei r der Zinssatz <strong>und</strong> K0 der Anfangsbetrag sind. Will man die Verzinsung eines<br />
Kapitals von 1000 Euro, das sich <strong>mit</strong> 3 Prozent jährlich verzinst über 10 Jahre verfolgen,<br />
gibt man 1000 in eine Zelle ein, zieht 9 Zeilen nach unten oder 9 Spalten nach rechts<br />
<strong>mit</strong> der rechten Maustaste, entscheidet sich dann für den Menüpunkt Reihe. . . des<br />
Kontextmenüs <strong>und</strong> gibt als Inkrement 1,03 an <strong>und</strong> wählt geometrisch als Typ.<br />
2.8.3 Benutzerdefinierte Listen<br />
<strong>Excel</strong> kennt viele Reihen, besonders Datenreihen wie Jan(uar), Feb(ruar), usw. oder<br />
Montag, Dienstag usw. Es erlaubt aber Reihen selbst zu erstellen, so genannte benutzerdefinierte<br />
Listen. Man schreibt einfach eine sinnvolle Reihe wie etwa Messer, Gabel,<br />
Schere, Licht in vier benachbarte Zellen <strong>und</strong> wählt dann die Menüfolge Extras/Optionen.<br />
. . <strong>und</strong> wählt in dem Monsterdialog das Register Benutzerdefinierte Listen. Der<br />
Zellbereich, wo sich die in der Tabelle erstellte Liste befindet, erscheint im Eingabefeld<br />
unten <strong>und</strong> kann durch die Schaltfläche Importieren zu den bekannten Listen hinzugefügt<br />
werden.<br />
Man kann aber auch in demselben Dialog im Eingabefeld Listeneinträge eine Liste<br />
eintragen, die nicht schon in der Tabelle steht. Nach Erstellung der Liste bitte die<br />
Schaltfläche Hinzufügen zu drücken. <strong>Excel</strong> erkennt danach benutzerdefinierte Listen <strong>und</strong><br />
die Vervollständigung erfolgt durch das Ausfüllkästchen. YYY Fehlt noch: Ausfüllen von<br />
Zellen innerhalb einer Zeile oder Spalte <strong>mit</strong> Daten Markieren Sie die zu kopierenden Zellen.<br />
Usw blah, was ist da<strong>mit</strong> bloß gemeint?<br />
2.9 Zwischentest<br />
Sie sollten sich jetzt vom Lesen entspannen <strong>und</strong> <strong>mit</strong> <strong>Excel</strong> eine Arbeitsmappe ueb1.xls<br />
anlegen. Die beiden ersten Tabellennamen sollen wie in Abbildung 2.9 Anfang <strong>und</strong> Rei-<br />
30
Abbildung 2.9: Autoausfüllen<br />
2.9 Zwischentest<br />
hen heißen. Die Tabelle Anfang soll wie in Abbildung 2.1 aussehen <strong>und</strong> die Tabelle Reihen<br />
soll Abbildung 2.9 gleichen, wobei die Reihen durch Autovervollständigung zu erzeugen<br />
sind. Durch geeignete Formatierung soll die Kapitalentwicklung <strong>mit</strong> Eurozeichen <strong>und</strong><br />
zwei Nachkommastellen erfolgen<br />
Die Tabelle links soll dann noch <strong>mit</strong> über den Befehl Autoausfüllen wie abgebildet<br />
formatiert werden.<br />
Die Zelle B1 soll den Namen dabier bekommen.<br />
Die rechte horizontale Bildlaufleiste soll wie abgebildet nicht erscheinen <strong>und</strong> die Symbolleiste<br />
Steuerelemente-Toolbox soll als einzige vorhanden sein.<br />
31
3 Formeln <strong>und</strong> Funktionen<br />
In diesem Kapitel wird gezeigt, wie man <strong>mit</strong> <strong>Excel</strong> Rechnungen durchführt. Dazu gibt<br />
es Formeln <strong>und</strong> eingebaute Funktionen.<br />
3.1 Formeln<br />
<strong>Excel</strong> ist ein Tabellenkalkulationsprogramm. In der Abbildung 3.1 sehen Sie eine Tabelle<br />
<strong>mit</strong> fiktiven Werten für die Anzahl monatlich verkaufter Bier- bzw. Wasserkisten eines<br />
Händlers in einem Jahr. Die Tabelle endet in der Zeile 13 für den Dezember. Der Absatz<br />
von Bier steigt monatlich um 100 Kästen , während der von Wasser um 100 Kästen<br />
abnimmt. Nun soll der Monatsumsatz berechnet werden. Dabei wird angenommen, dass<br />
jeder Kasten Bier <strong>mit</strong> 10 e <strong>und</strong> jeder Kasten Wasser <strong>mit</strong> 5 e zu Buche schlägt. Die<br />
Formel in Zelle D2 für den Monat Januar lautet daher<br />
= 10*B2 + 5*C2<br />
da in den Spalten B bzw. C die Anzahl der verkauften Kästen stehen. Diese Formel<br />
muss man nun in die Bearbeitungsleiste eingeben, nachdem die Zelle D2 aktiviert wurde.<br />
Da<strong>mit</strong> <strong>Excel</strong> die Eingabe als Formel erkennt, muss zunächst das Gleichheitszeichen<br />
getippt werden. Anstatt in der Formel C2 einzutippen, ist es auch erlaubt, die entspre-<br />
Abbildung 3.1: Eine Formel<br />
chende Zelle anzuklicken. Sie wird dann von einem gestrichelten Rahmen umgeben, bis<br />
man wieder in die Eingabeleiste klickt. Das ist für Anfänger gewöhnungsbedürftig, da der<br />
32
3.1 Formeln<br />
Eindruck erweckt wird, als wäre diese Zelle aktiviert. Das Ergebnis von 20000 erscheint<br />
in der Zelle D2, sobald die Eingabe <strong>mit</strong> der Eingabe-Taste beendet wird.<br />
WWW Klickt man aus Versehen während der Erstellung einer Formel eine Zelle an,<br />
erscheint diese <strong>mit</strong> ihren Koordinaten in der Formel.<br />
Das könnte man jetzt für die nächste Zeile wiederholen. Da aber die Formel nur für die<br />
Zeilennummer verändert wird, bietet <strong>Excel</strong> das schon beschriebene Ziehen an. Zunächst<br />
muss die Zelle D2 wieder aktiviert werden. Dann wird an ihrem Ziehpunkt die ganze<br />
Spalte bis zur Zeile 13 überstrichen. <strong>Excel</strong> füllt dann alle Zellen korrekt aus. Vergleichen<br />
Sie bitte Ihr Ergebnis <strong>mit</strong> der Abbildung 3.2, wo alle Ergebnisse kompakt zu sehen sind.<br />
Noch schneller als Ziehen funktioniert ein Doppelklick auf dem Ziehpunkt. Die Formel<br />
wird dann korrekt nach unten sinngemäß weitergeführt.<br />
3.1.1 Absolute, gemischte <strong>und</strong> relative Bezüge<br />
Im vorigen Beispiel wurde der Umsatz in Zelle D2 über die Formel =10*B2 + 5*C2<br />
berechnet. Durch Ziehen nach unten wird in der Zeile 3 die 2 durch 3 ersetzt usw. Das<br />
bewirkt der relative Bezug. Der Umsatz pro Kasten Bier beträgt 10 e <strong>und</strong> bleibt beim<br />
Ziehen unverändert. Das gleiche trifft auf die 5 e zu. Was aber wäre passiert, wenn wir<br />
die Umsätze pro Einheit nicht hart kodiert hätten, sondern weich <strong>und</strong> flexibel. Der Wert<br />
steht 10 in der Zelle I2 <strong>und</strong> 5 in der Zelle I3. Die Formel verändert sich dann auf =I2*B2<br />
+ I3*C2. Soweit so gut. Wird aber jetzt die Formel durch Ziehen auf die anderen Zeilen<br />
übertragen, werden nicht nur die erwünschten Ersetzungen von B2 nach B3 <strong>und</strong> von C2<br />
nach C3 durchgeführt, sondern auch die unerwünschten Fortsetzungen I2 nach I3 <strong>und</strong><br />
I3 nach I4.<br />
<strong>Excel</strong> bietet daher über die gemischten Bezüge die Möglichkeit, Werte unverändert zu<br />
lassen. Dafür muss vor der Zeilenkoordinate ein Dollarzeichen stehen I$2. Beim Ziehen<br />
nach unten bleibt die 2 erhalten <strong>und</strong> natürlich auch das I, beim Ziehen nach rechts<br />
verändert sich aber nach wie vor der Spaltenindex, daher die Bezeichnung gemischter<br />
Bezug. Der absolute Bezug verhindert Veränderung in jeder Richtung <strong>und</strong> erfolgt durch<br />
zwei $-Zeichen: $I$2. In unserem Fall lautet die korrekte Formel so<strong>mit</strong> =$I$2*B2 +<br />
$I$3*C2 oder =I$2*B2 + I$3*C2. Nach dem Ziehen wird daraus in der Zeile 3: $I$2*B3<br />
+ $I$3*C3 bzw. =I$2*B3 + I$3*C3.<br />
3.1.2 Die F4-Taste<br />
Das Wechseln zwischen relativen, absoluten <strong>und</strong> gemischten Bezügen über Einfügen <strong>und</strong><br />
Löschen des $-Zeichens ist lästig. Man kann über die F4-Taste alle möglichen Kombinationen<br />
von relativen <strong>und</strong> absoluten Bezüge nacheinander einstellen. Man markiert im<br />
Eingabefeld den Bezug, der geändert werden soll <strong>und</strong> drückt solange F4 bis die richtige<br />
Einstellung erscheint.<br />
33
3 Formeln <strong>und</strong> Funktionen<br />
3.1.3 Namensfelder<br />
Als nächstes soll nun der Gewinn berechnet werden. Pro Kasten Bier fällt ein Gewinn<br />
von einem Euro ab <strong>und</strong> bei einem Kasten Wasser werden 50 Cent erwirtschaftet. Die<br />
beiden Faktoren stehen in den Zellen H2 <strong>und</strong> H3. Natürlich könnte der Gewinn wie der<br />
Umsatz durch eine Mischung von relativen <strong>und</strong> absoluten Bezügen berechnet werden.<br />
Ich möchte aber von der Möglichkeit einzelnen Zellen oder Zellbereichen <strong>mit</strong> Namen zu<br />
geben Gebrauch machen. Die Zelle H2 soll gebier <strong>und</strong> die Zelle H3 gewasser heißen.<br />
Für die Namensgebung muss zunächst der entsprechende Zellbereich markiert werden,<br />
also eine einzelne Zelle, ein Rechteckbereich oder eine Mehrfachmarkierung. Dann trägt<br />
man im Namensfeld am linken Ende der Bearbeitungsleiste den gewünschten Namen ein<br />
<strong>und</strong> drückt die Eingabetaste.<br />
In Formeln darf man danach anstelle des benannten Zellbereichs dessen Namen verwenden.<br />
Ich habe daher in der Zelle E2 folgende Formel eingetragen:<br />
=gebier*B2 + gewasser*C2.<br />
Diese Formel lässt sich problemlos am Ausfüllkästchen durch Ziehen oder durch Doppelklick<br />
nach unten erweitern.<br />
Namen können auch wieder gelöscht werden, <strong>und</strong> zwar über die Befehlsfolge Einfügen|Namen|Definieren.<br />
. . , wobei in dem Dialog dann die Schaltfläche Löschen zu<br />
drücken ist.<br />
3.1.4 Operatoren<br />
In Formeln werden so genannte Operatoren eingesetzt, um die Elemente der Formel<br />
zu verbinden. Die arithmetischen Operatoren dienen der Addition (+), Subtraktion (-),<br />
Multiplikation (*), Division (/)<strong>und</strong> Potenzierung, wobei letztere durch das ˆ(Caretzeichen)<br />
erfolgt, wie in 4ˆ3.<br />
Die aritmetischen Operatoren verbinden Zahlen <strong>und</strong> haben Zahlen als Ergebnis. Das<br />
unterscheidet sie von den Vergleichsoperatoren, die zwar Zahlen vergleichen, aber die<br />
logischen Ergebnisse FALSCH oder WAHR liefern. Es gibt insgesamt sechs Vergleichsoperatoren,<br />
nämlich Abfragen auf Gleichheit (=), Ungleichheit (), Größer (>) <strong>und</strong><br />
Kleiner (=) <strong>und</strong> Kleiner-Gleich (
3.1 Formeln<br />
es in der Online-Hilfe, wobei ich <strong>mit</strong> dem Graviszeichen Probleme habe. Über die Befehlsfolge<br />
Extras|Formelüberwachung|Formelauswertung komme ich genauso<br />
zum Ziel.<br />
3.1.6 Matrix-Formeln<br />
Abbildung 3.2: Ergebnisse <strong>und</strong> Summe<br />
Der Inhaber möchte neben Umsatz <strong>und</strong> Gewinn auch über die Anzahl verkaufter Flaschen<br />
informiert werden. Jeder Kasten Bier hat 20 <strong>und</strong> jeder Kasten Wasser 12 Flaschen.<br />
Die monatlichen Gesamtzahlen sollen im Bereich F2:F13 erscheinen. Dieser Bereich bildet<br />
mathematisch einen Spaltenvektor, die Anzahl der Werte heißt Dimension, welche<br />
hier den Wert 12 hat. Die Werte eines Vektors heißen Komponenten. Mehrere Spaltenvektoren,<br />
die einen zusammenhängenden Bereich bilden, erzeugen eine Matrix. Eine<br />
Matrix ist also ein rechteckige Bereich, der aus m Zeilen <strong>und</strong> n Spalten besteht. Auch<br />
hier heißen die m ∗ n Werte der Matrix Komponenten. Ein Vektor ist so<strong>mit</strong> ebenfalls<br />
eine Matrix, nämlich der Sonderfall <strong>mit</strong> nur einer Spalte bzw. nur einer Zeile.<br />
Matrizen kann man <strong>mit</strong> einer Zahl multiplizieren, indem man jede Komponente einzeln<br />
<strong>mit</strong> dieser Zahl multipliziert. Zwei Matrizen <strong>mit</strong> übereinstimmender Zeilen- <strong>und</strong><br />
Spaltenzahl kann man addieren, indem ebenfalls komponentenweise addiert wird. Der<br />
Ergebnisvektor F2:F13 ergibt sich aus den Spaltenvektoren B2:B13 <strong>und</strong> C2:C13 durch<br />
den Ausdruck<br />
35
3 Formeln <strong>und</strong> Funktionen<br />
= K2*B2:B13 + K3*C2:C13,<br />
da K2 = 20 <strong>und</strong> K3 = 12 gilt. Diese Formel habe ich in die Zelle E2 geschrieben,<br />
wobei ich zuvor den gesamten Zielbereich F2:F13 markiert habe. Da<strong>mit</strong> <strong>Excel</strong> dies als<br />
Matrixformel erkennt, muss die Formeleingabe durch die Tastenkombination Strg + Umschalt<br />
+ Eingabe abgeschlossen werden. Dann <strong>und</strong> nur dann schließt <strong>Excel</strong> die Formel<br />
automatisch in geschweifte Klammern »{ }« ein.<br />
WWW Sie dürfen also die geschweiften Klammern nicht selbst schreiben!<br />
3.2 Funktionen<br />
Ich möchte nun die Einzelwerte zusammenfassen, also jeweils Summen bilden. Dazu<br />
aktiviere ich die Zelle B14, schreibe das Gleichheitszeichen, da<strong>mit</strong> <strong>Excel</strong> eine Formel<br />
erkennt <strong>und</strong> drücke dann das Funktionssymbol fx. <strong>Excel</strong> öffnet das Dialogfeld Funktion<br />
einfügen, das die vorhandenen Funktionen auflistet. Die Funktionen sind in Kategorien<br />
eingeteilt, eine davon heißt Zuletzt verwendet, wo alle zuletzt von mir verwendeten Funktionen<br />
aufgelistet sind. Dazu gehört auch die Funktion SUMME, die sich auch in ihrer<br />
eigentlichen Kategorie Math. & Trigonom. auftreiben ließe. Ich klicke doppelt auf dem<br />
Abbildung 3.3: Das Dialogfeld Funktion einfügen<br />
Eintrag SUMME. Dann öffnet sich ein weiterer Dialog, der mir eifrig bei den Argumenten<br />
helfen will. Dieses Dialogfeld kann Gedanken gelesen <strong>und</strong> hat bereits den Bereich<br />
B2:B13 als Argument eingesetzt. Das darf jetzt noch geändert werden, entweder durch<br />
direkte Eingabe oder indem der gewünschte Bereich im Arbeitsblatt <strong>mit</strong> der Maus überstrichen<br />
wird. Ich übernehme den Vorschlag aber <strong>und</strong> drücke die Taste OK. Die Summe<br />
des Bereichs B2:B13 erscheint dann prompt in der Zelle B14. Diese bleibt aktiviert <strong>und</strong><br />
36
Abbildung 3.4: Das Dialogfeld Funktionsargumente<br />
3.3 Wichtige Funktionen<br />
bietet Ihr Ziehkästchen an, das ich in der Zeile 14 nach rechts verschiebe bis zur Spalte<br />
F14, um auch die anderen Summen zu erhalten.<br />
Wenn Sie das nacharbeiten, sollten Sie zur Übung jetzt die Mittelwerte berechnen. Dazu<br />
werden alle 12 Monatswerte einer Spalte summiert <strong>und</strong> durch 12 geteilt. Die Werte<br />
sollen im Bereich B15:F15 erscheinen. Es gibt zwei Möglichkeiten. Entweder als Formel<br />
oder <strong>mit</strong> dem Funktionsassistenten. Die Formel für B15 ist sehr einfach<br />
= B14/12,<br />
Achten Sie wie immer bei Formeln auf das anfängliche Gleichheitszeichen!<br />
Bei der zweiten Methode wird wie beschrieben die Funktion MITTELWERT aufgerufen.<br />
Die angebotenen Funktionsargumente sind <strong>mit</strong> B2:B14 diesmal allerdings falsch,<br />
die 14 muss im Eingabefeld durch 13 ersetzt werden.<br />
Welchen Weg Sie auch einschlagen, das Ergebnis sollte 1550 sein. Nutzen Sie auch<br />
jetzt das Ziehkästchen der Zelle B15 <strong>und</strong> ziehen Sie bis F15 weiter. In den Zeilen 14 <strong>und</strong><br />
15 sollte dann folgendes stehen<br />
Summen 18600 17400 273000 e 27300 e 580800<br />
Mittelwert 1550 1450 22750 e 2.275 e 48400<br />
3.3 Wichtige Funktionen<br />
Die Funktion<br />
SUMME(Zahl1;Zahl2; ...) Summiert die Argumente. Beachten Sie, dass <strong>Excel</strong> die Argumente<br />
durch je ein Semikolon <strong>und</strong> nicht durch Komma trennt. Man kann die Funktion<br />
<strong>mit</strong> Werten wie =SUMME(1;2;3;4) aufrufen oder <strong>mit</strong> Bezügen wie =SUMME(A1:B4),<br />
37
3 Formeln <strong>und</strong> Funktionen<br />
wobei nur Zahlen berücksichtigt werden. Achten Sie unbedingt auf das anfängliche<br />
Gleichheitszeichen, denn sonst fasst <strong>Excel</strong> die Eingabe als Text auf <strong>und</strong> gibt diesen<br />
aus.<br />
Eng verwandt <strong>mit</strong> der Funktion SUMME ist die Funktion<br />
MITTELWERT(Zahl1;Zahl2; ...)<br />
welche den Mittelwert der Zahlen berechnet, also die Summe durch die Anzahl der<br />
Werte teilt.<br />
Diese Funktion gehört zur Gruppe der statistischen Funktionen, von denen ich noch<br />
VARIANZ(Zahl1;Zahl2; ...), VARIANZEN(Zahl1;Zahl2; ...), sowie STABW(Zahl1;Zahl2;<br />
...) <strong>und</strong> STABWN(Zahl1;Zahl2; ...) für die Varianz <strong>und</strong> die Standardabweichung einer<br />
Stichprobe bzw. einer Gr<strong>und</strong>gesamtheit.<br />
Die logischen Funktionen UND <strong>und</strong> ODER haben mindestens zwei Parameter. Die<br />
Funktion UND hat die Syntax<br />
UND(Logischer_Ausdruck1;Logischer_Ausdruck2; ...)<br />
<strong>und</strong> gibt WAHR zurück, wenn alle Argumente WAHR sind. Hat auch nur ein Parameter<br />
den Wert FALSCH, gibt diese Funktion den Wert FALSCH zurück.<br />
Die Funktion ODER <strong>mit</strong> der Syntax<br />
ODER(Logischer_Ausdruck1;Logischer_Ausdruck2; ...)<br />
ist da wesentlich großzügiger, denn sie gibt WAHR schon zurück, wenn mindestens ein<br />
Argument WAHR ist. Erst wenn alle Parameter den Wert FALSCH haben, gibt diese<br />
Funktion den Wert FALSCH zurück.<br />
3.4 Datumsangaben<br />
Das Datum wird intern als Zahl dargestellt. In der Hilfe heißt es dazu:<br />
»Microsoft <strong>Excel</strong> speichert Datumsangaben als fortlaufende Zahlen, so genannte serielle<br />
Werte. Standardmäßig hat der 1. Januar 1900 die Seriennummer 1 <strong>und</strong> der 1.<br />
Januar 2008 die Seriennummer 39448, da er genau 39.448 Tage nach dem 1. Januar<br />
1900 liegt. <strong>Excel</strong> speichert Uhrzeiten als Dezimalbrüche, da die Uhrzeit als Untermenge<br />
des Tages betrachtet wird. Weil Datums- <strong>und</strong> Uhrzeitangaben Werte sind, können sie<br />
addiert, subtrahiert <strong>und</strong> in anderen Berechnungen verwendet werden. Sie können eine<br />
Datumsangabe als fortlaufende Zahl <strong>und</strong> eine Uhrzeitangabe als Dezimalbruch anzeigen,<br />
indem Sie das Format der Zelle, die das Datum oder die Uhrzeit enthält, in das Format<br />
Standard ändern.«<br />
Gebe ich in eine Zelle etwa 0,5 ein <strong>und</strong> drücke dann Strg + 1 zum Öffnen des Formatdialogs,<br />
so kann ich als Format Uhrzeit wählen <strong>und</strong> in der Zelle steht dann 12:00:00.<br />
Möchte ich wissen, welcher Bruchteil des Tages bereits vergangen ist, wenn ich üblicher-<br />
38
3.5 Datumsfunktionen<br />
weise um 8:59 aufstehe, muss ich erst diese Uhrzeit in einer Zelle eingeben <strong>und</strong> dann das<br />
Format auf Zahl ändern <strong>und</strong> erhalte den betrüblichen Wert 0,37.<br />
Möchten Sie wissen, wieviel Tage Sie schon gelebt haben, müssen Sie in einer Zelle,<br />
sagen wir D1 Ihr Geburtsdatum z.B 19.1.1971 <strong>und</strong> in der Nachbarzelle D2 das heutige<br />
Datum, etwa 3.10.2008 schreiben. Steht dann in die Zelle D3 die Formel<br />
=D2-D1,<br />
ergibt sich der Wert 13772.<br />
Da man häufig gegenwärtige Datumsangaben benötigt, gibt es folgende Tastaturkürzel:<br />
Spezialdatum Eingaben<br />
Aktuelles Datum Markieren Sie eine Zelle, <strong>und</strong> drücken Sie STRG+:<br />
Aktuelle Uhrzeit Markieren Sie eine Zelle, <strong>und</strong> drücken Sie<br />
STRG+UMSCHALT+:<br />
Aktuelles Datum <strong>und</strong> Uhrzeit Markieren Sie eine Zelle, <strong>und</strong> drücken Sie<br />
STRG+: dann die UMSCHALTTASTE <strong>und</strong> dann<br />
STRG+UMSCHALT+:<br />
Quelle: Online-Hilfe.<br />
Das System <strong>mit</strong> den fortlaufenden Datumswerten wird im Jahr 9999 zusammenbrechen,<br />
trennen sich dann rechtzeitig von Aktien der Firma Microsoft, die im Strudel des<br />
»Jahr 10000« Fiaskos untergehen wird. Zur Vermeidung kurzfristigerer Schäden sollten<br />
Sie alle Jahre vierstellig eingeben, also 19.1.1977 statt 19.1.77.<br />
3.5 Datumsfunktionen<br />
<strong>Excel</strong> bietet eine Fülle von Funktionen im Zusammenhang <strong>mit</strong> Zeit <strong>und</strong> Datum. Einige<br />
habe ich in der folgenden Tabelle zuammengestellt.<br />
Funktion Beschreibung<br />
JETZT( ) Liefert die fortlaufende Zahl des aktuellen Datums <strong>und</strong><br />
der aktuellen Uhrzeit.<br />
HEUTE( ) Gibt die fortlaufende Zahl des heutigen Datums zurück.<br />
DATUM(Jahr;Monat;Tag) Gibt die fortlaufende Zahl zurück, die ein bestimmtes Datum<br />
darstellt.<br />
TAG(Zahl) Gibt den Tag eines Datums als fortlaufende Zahl zwischen<br />
1 <strong>und</strong> 31 zurück.<br />
MONAT(Zahl) Gibt den Monat eines Datums als fortlaufende Zahl zurück.<br />
JAHR(Zahl) Gibt das Jahr eines Datums als fortlaufende Zahl zwischen<br />
1900 <strong>und</strong> 9999 zurück.<br />
Wie diese Werte dann erscheinen, hängt von der eingestellten Zellenformat ab.<br />
39
3 Formeln <strong>und</strong> Funktionen<br />
Die Funktion<br />
TAGE360(Ausgangsdatum;Enddatum;WAHR)<br />
berechnet die Anzahl der zwischen zwei Tagesdaten liegenden Tage, wobei man das<br />
Jahr in 12 Monate zu je 30 Tagen einteilt. Jedes Ausgangs- <strong>und</strong> Enddatum, das auf den<br />
31. eines Monats fällt, wird zum 30. desselben Monats. Die Monatsenden im Februar<br />
bekommen aber nicht den Wert 30, aber der Februar selbst hat 30 Tage. Lässt man den<br />
Parameter WAHR weg, oder gibt stattdessen FALSCH ein, rechnet <strong>Excel</strong> nach einer<br />
amerikanischen Methode.<br />
3.6 Matrixfunktionen<br />
Für Matrizen stellt <strong>Excel</strong> für Vorgänge wie Multiplikation zweier Matrizen oder Finden<br />
der Inversen einer Matrix leistungsstarke Funktionen zur Verfügung. Die Matrix-<br />
Funktion MMULT <strong>mit</strong> der Syntax<br />
MMULT(A;B)<br />
gibt das Produkt der beiden Matrizen zurück. Die beiden Matrizen können als Zellbereiche<br />
wie C2:D6 oder als Matrix-Konstanten angegeben sein. Die Anzahl n der Spalten<br />
von A muss <strong>mit</strong> der Anzahl der Zeilen von B übereinstimmen. Ist A eine m ∗ n-Matrix<br />
<strong>und</strong> B eine n ∗ k-Matrix, so ist das Ergebnis eine m ∗ k-Matrix, d.h. die Ergebnismatrix<br />
hat dieselbe Anzahl von Zeilen wie A <strong>und</strong> dieselbe Anzahl von Spalten wie B. Da das<br />
Ergebnis eine Matrix ist, muss die Eingabe <strong>mit</strong> der Tastenkombination Strg + Umschalt<br />
+ Eingabe abgeschlossen werden.<br />
In der Abbildung 3.5 ist zu sehen, wie die Ergebnisse des Getränkehändlers <strong>mit</strong> nur<br />
einer Matrixformel berechnet werden können. Wenn Sie es nachvolziehen wollen, gehen<br />
Sie bitte wie folgt vor:<br />
40<br />
1. Markieren Sie den Bereich B2:C13 der Eingangswerte <strong>und</strong> geben im Namensfeld<br />
den Bezeichner E ein. Markieren Sie dann den Bereich D2:F13 <strong>und</strong> geben im<br />
Namensfeld den Bezeichner A ein. Als letztes soll der Bereich I2:K3 den Namen F<br />
erhalten.<br />
2. Markieren Sie dann den Bereich D2:F13 <strong>und</strong> geben im Eingabefeld die Formel<br />
MMULT(E;F)<br />
ein.<br />
3. Drücken Sie dann die Tastenkombination Strg + Umschalt + Eingabe. Die Matrixbereiche<br />
sollten dann wie in Abbildung 3.5 durch Begrenzungen zu erkennen<br />
sein.
Abbildung 3.5: Ergebnisse <strong>und</strong> Summe<br />
3.7 WENN-Funktion<br />
Neben der Multiplikation benötigt man die Inverse <strong>und</strong> die Transponierte einer Matrix.<br />
Die Funktion MINV <strong>mit</strong> der Syntax<br />
MINV(A)<br />
gibt die Inverse A −1 der Matrix A zurück. Dazu muss A quadratisch sein, d.h. die<br />
Anzahl der Zeilen <strong>und</strong> der Spalten sind gleich.<br />
Die Funktion MTRANS <strong>mit</strong> der Syntax<br />
MTRANS(A)<br />
gibt die Transponiertee B = A T der Matrix A zurück. Hat A m Zeilen <strong>und</strong> n Spalten,<br />
so hat die Transponierte n Zeilen <strong>und</strong> m Spalten <strong>und</strong> es gilt bi,j = aj,i.<br />
3.7 WENN-Funktion<br />
In der Abbildung 3.6 sind in der Spalte »Wert« die ver<strong>mit</strong>telten Objekte <strong>und</strong> in der<br />
Spalte daneben die erhaltenen Provisionen eines Maklerbüros zu sehen. Die Objekte sind<br />
in die Kategorien ETW (Eigentumswohnung), RH (Reihenhaus) <strong>und</strong> Mehrfamilienhaus<br />
(MFH) eingeteilt. Die Ver<strong>mit</strong>tlungsprovision für eine ETW beträgt 3%, für ein RH 5%<br />
<strong>und</strong> für ein MFH 10%.<br />
Das Maklerbüro bietet den Ver<strong>mit</strong>tlern für besonders schwierige Objekte eine Sonderprämie<br />
von 1000 Euro an. Diese Prämie wird fällig, wenn das Baujahr zwischen 1970<br />
<strong>und</strong> 1979 oder vor 1920 liegt. Hier gibt es nur zwei Fälle: Sonderprämie oder nicht.<br />
41
3 Formeln <strong>und</strong> Funktionen<br />
Deshalb wird eine Funktion benötigt, die abhängig von einem logischen Ausdruck je<br />
einen Wert zurückgibt. Diese Funktion benötigt drei Parameter. Der erste prüft, ob eine<br />
bestimmte logische Bedingung WAHR oder FALSCH ist. Der zweite Parameter ist der<br />
Wert, der zurückgegeben wird, wenn die logische Bedingung den Wert WAHR hat <strong>und</strong><br />
der dritte Parameter ist der zurückgegebene Wert, wenn die logische Bedingung den<br />
Wert FALSCH hat. Die Syntax der WENN-Funktion lautet also:<br />
WENN(LogischerAusdruck; WAHRWert; FALSCHWert)<br />
Jeder Parameter kann ein beliebiger Ausdruck sein, sofern er beim Aufruf der Funktion<br />
ausgewertet werden kann. Insbesondere können die beiden hinteren Parameter selbst<br />
wieder WENN-Funktionen sein wie in einem der folgenden Beispiele.<br />
Im Fall der Zweitprämie wird der logische Ausdruck sehr umfangreich <strong>und</strong> lautet<br />
=WENN(ODER(JAHR(C2)
=WENN(A2="ETW";0,03*B2;0)+WENN(A2="RH";0,05*B2;0)<br />
+WENN(A2="MFH";0,1*B2;0<br />
3.8 SUMMEWENN-Funktion<br />
3.8 SUMMEWENN-Funktion<br />
Betrachten Sie bitte in der Abbildung 3.6 die Zellen H2 bis H4, wo die Gesamtsummen<br />
der Erlöse <strong>und</strong> Prämien nach Kategorien aufgefächert sind. Erreicht wird dies <strong>mit</strong> einer<br />
speziellen Funktion, der SUMMEWENN-Funktion. Der Name soll andeuten, dass die<br />
Einträge einer Spalte nur dann addiert werden, wenn bestimmte Bedingungen erfüllt<br />
sind. Die Syntax dieser Funktion lautet:<br />
SUMMEWENN(AbfrageBereich;Kriterium;SummationsBereich)<br />
Dabei beschreiben die Argumente Abfragebereich <strong>und</strong> SummationsBereich Teile einer<br />
Liste, wovon das Argument SummationsBereich der Zellbereich ist, über den die Summation<br />
statt findet. Es werden aber nur diejenigen Zellen berücksichtigt, die dem Argument<br />
Kriterium entsprechen. Das Kriterium bezieht sich dabei immer auf den Parameter AbfrageBereich.<br />
Das Argument Kriterium ist also ein logischer Ausdruck, der für die Zellen<br />
des Bereichs AbfrageBereich ausgewertet wird. Nur wenn dieser Ausdruck den Wert<br />
WAHR ergibt, wird der Wert der entsprechenden Zelle in die Addition einbezogen.<br />
In unserem Beispiel sind die drei Kategorien ETW, RH <strong>und</strong> MFH vorhanden, die in<br />
der Spalte A vorkommen. Summiert wird über die Einträge in Spalte B für die Werte<br />
<strong>und</strong> in der Spalte C für die Provisionen. Für jede Kategorie soll der Gesamtwert der<br />
verkauften Objekte bestimmt werden. In der Zelle H2 steht so<strong>mit</strong> die Anweisung<br />
=SUMMEWENN($A$2:$A$6;$A2;B$2:B$6)<br />
oder<br />
=SUMMEWENN($A$2:$A$6;"ETW";B$2:B$6)<br />
Beide Ausdrücke sind gleichwertig, da der Wert der Zelle A2 gerade »ETW« ist.<br />
Nur wenn in der Spalte A des Bereichs $A$2:$A$6 »ETW« steht, wird der Wert der<br />
entsprechenden Zelle der Spalte B <strong>mit</strong> in die Summation einbezogen. Achten Sie bitte<br />
auf die Dollarzeichen, um die Bezüge bezüglich der Zeilen absolut zu machen.<br />
3.9 SVERWEIS-Funktion<br />
Betrachten Sie zunächst die Abbildung 3.7 für eine typische Anwendung dieser Funktion.<br />
Links steht die Liste der von der EEE für den Studienbetrieb vorgesehenen Module <strong>mit</strong><br />
43
3 Formeln <strong>und</strong> Funktionen<br />
Abbildung 3.7: Matrixfunktion: SVERWEIS<br />
ihrem Kürzel, der vollständigen Bezeichnung, der Anzahl der Semesterwochenst<strong>und</strong>en<br />
(SWS) <strong>und</strong> dem zu entrichtenden Hörergeld. Die Liste der angebotenen Kurse ist ab<br />
der Spalte F zu sehen. Von jedem Modul müssen mehrere Kurse angeboten werden. Es<br />
wäre daher schön, wenn nach Eintrag des Kürzels in der Kursliste die restlichen Einträge<br />
gleich <strong>mit</strong> erschienen. Dafür sorgt die SVERWEIS-Funktion. Sie hat vier Parameter <strong>und</strong><br />
die Syntax<br />
SVERWEIS(Suchkriterium;Liste;Spaltenindex;Sortiert)<br />
Der zweite Parameter ist der Bezug auf eine Liste, in meinem Beispiel auf die im Bereich<br />
A2:D6 befindliche Liste. Dieser Bezug darf auch ein Namen sein, den man dieser Liste<br />
gegeben hat, etwa »Matrix« oder »Liste«. Die Funktion überprüft, ob der Wert in der<br />
ersten Spalte der Liste dem Argument Suchkriterium entspricht <strong>und</strong> gibt dann den in<br />
der gleichen Zeile stehenden Wert aus der als drittem Argument angegebenen Spalte der<br />
Liste zurück. Der letzte Parameter Sortiert unterrichtet <strong>Excel</strong> darüber, ob die Werte der<br />
entscheidenden ersten Spalte sortiert sind oder nicht.<br />
Wenn der Ausdruck Sortiert den logischen Wert WAHR hat, müssen die Werte in<br />
der ersten Spalte der Liste in aufsteigender Reihenfolge angeordnet werden, d.h. bei<br />
Zahlen nach Wert etwa -2, -1, 0, 1, 2, usw. <strong>und</strong> bei Text in lexikalischer Ordnung. Bei<br />
Zeichenfolgen (Texten) wird nicht nach Groß- <strong>und</strong> Kleinbuchstaben unterschieden. Hat<br />
Sortiert den Wert WAHR, liegt aber keine Sortierung vor, »gibt« so schreibt die Online-<br />
Hilfe lakonisch »SVERWEIS möglicherweise! nicht den richtigen Wert zurück. Sie können<br />
die Werte in aufsteigender Reihenfolge anordnen, indem Sie den Befehl Sortieren aus<br />
dem Menü Daten verwenden <strong>und</strong> dann Aufsteigend wählen.«<br />
WWW Man darf den vierten Parameter weglassen, dann geht <strong>Excel</strong> aber von einer<br />
Sortierung aus! Bei nicht sortierten Daten muss man deshalb unbedingt den vierten<br />
Parameter als FALSCH angegeben, da man sonst nicht nur möglicherweise falsche Werte<br />
erhält.<br />
Weiter gibt die Online-Hilfe folgende nützliche Hinweise:<br />
44<br />
• Spaltenindex ist die Spaltennummer der Liste, aus der der entsprechende Wert<br />
zurückgegeben werden muss. Ein Spaltenindex von 1 gibt den Wert der ersten
3.10 Rang-Funktion<br />
Spalte der Liste zurück; ein Spaltenindex von 2 gibt den Wert der zweiten Spalte<br />
der Liste zurück usw. Wenn Spaltenindex kleiner 1 ist, gibt SVERWEIS den Fehler<br />
#WERT! zurück; wenn Spaltenindex größer als die Anzahl der Spalten der Liste<br />
ist, gibt SVERWEIS den Fehlerwert #BEZUG! zurück.<br />
• Der Parameter Sortiert ist ein logischer Wert, der angibt, ob SVERWEIS eine genaue<br />
oder eine ungefähre Entsprechung suchen soll. Wenn dieser Parameter WAHR<br />
ist oder weggelassen wird, wird eine ungefähre Entsprechung zurückgegeben, d.h es<br />
wird der größte Wert verwendet, der kleiner oder gleich Suchkriterium ist. Wenn<br />
Suchkriterium kleiner als der kleinste Wert in der ersten Spalte von Matrix ist,<br />
gibt SVERWEIS den Fehlerwert #NV zurück. Wenn der Parameter FALSCH ist,<br />
sucht SVERWEIS eine genaue Entsprechung. Wird keine Entsprechung gef<strong>und</strong>en,<br />
wird der Fehlerwert #NV zurückgegeben.<br />
Alles klar? Würde ich im Feld G2 =SVERWEIS($F2;$A$2:$D$6;6;FALSCH) eingeben,<br />
wäre #BEZUG! das Resultat, während auf =SVERWEIS($F2; $A$2:$D$6; 0; FALSCH)<br />
sogleich #WERT! folgte. Wenn ich beim Suchkriterium einen in der ersten Spalte nicht<br />
vorhandenen Wert eintippe, etwa =SVERWEIS(“fee“; $A$2:$D$6; SPALTE()-5; FALSCH),<br />
so wäre #NV die Folge. Hätte ich die erste Spalte aber zunächst sortiert <strong>und</strong> dann<br />
=SVERWEIS(“fee“; $A$2:$D$6; SPALTE()-5; WAHR) eingetippt, hätte sich <strong>Excel</strong> etwas<br />
mehr Mühe gegeben <strong>und</strong> mir »Economics« geliefert, da das Kürzel »eco« der größte<br />
Wert innerhalb der Kürzelspalte ist, der gerade noch kleiner als das Suchkriterium »fee«<br />
ist.<br />
Beachten Sie bitte meine Eingabe im Feld G2:<br />
=SVERWEIS($F2;$A$2:$D$6;SPALTE()-5;FALSCH)<br />
Ich habe den Listenbereich <strong>mit</strong> absoluten Bezügen angegeben, das Suchkriterium aber<br />
nur bezüglich der Spalte. Ebenso habe ich den Bezug auf die zweite Spalte der Liste<br />
nicht als Wert, d.h. 2, direkt, sondern über SPALTE() - 5 indirekt eingegeben. Die<br />
SPALTE-Funktion gibt von einer Zelle gerade den zugehörigen Spaltenindex zurück, bei<br />
der Spalte G so<strong>mit</strong> den Wert 7. Mit diesen Angaben kann ich am Ausfüllkästchen sowohl<br />
nach rechts als auch nach unten ziehen <strong>und</strong> erhalte immer den richtigen Eintrag.<br />
3.10 Rang-Funktion<br />
Bei der Vergabe von Rangzahlen wird der kleinsten Beobachtung der Rang 1 <strong>und</strong> der<br />
größten Beobachtung der Rang n, also der Stichprobenumfang gegeben. Kommen Beobachtungen<br />
mehrfach vor (so genannte Bindungen), wird jedem der <strong>mit</strong>tlere Rang zugeordnet.<br />
<strong>Excel</strong> kann Sortieren (Daten|Sortieren) <strong>und</strong> kennt auch Ränge, vergibt aber<br />
nicht das arithmetische Mittel, »sondern ordnet zwei gleichen Zahlen dieselbe Rangzahl<br />
zu. Zusätzlich wirkt sich das Vorhandensein zweier gleicher Zahlen auf die Ränge der<br />
nachfolgenden Zahlen aus. Ist die Zahl 10 zum Beispiel zweimal in einer Liste ganzer<br />
Zahlen vertreten <strong>und</strong> hat den Rang 5, dann hat die Zahl 11 den Rang 7 (keine Zahl hat<br />
45
3 Formeln <strong>und</strong> Funktionen<br />
den Rang 6).« Die <strong>Excel</strong>-Funktion heißt RANG <strong>und</strong> hat die Syntax<br />
RANG(Zahl;Bezug;Reihenfolge)<br />
Weiter heißt es in der Online-Hilfe dazu:<br />
Zahl ist die Zahl, deren Rangzahl Sie bestimmen möchten.<br />
Bezug ist eine Matrix <strong>mit</strong> Zahlen oder ein Bezug auf eine Liste von Zahlen. Nicht numerische<br />
Werte im Bezug werden ignoriert.<br />
Reihenfolge ist eine Zahl, die angibt, wie der Rang von Zahl bestimmt werden soll.<br />
Ist Reihenfolge <strong>mit</strong> 0 (Null) belegt oder nicht angegeben, bestimmt Microsoft <strong>Excel</strong><br />
den Rang von Zahl so, als wäre Bezug eine in absteigender Reihenfolge sortierte Liste.<br />
Ist Reihenfolge <strong>mit</strong> einem Wert ungleich 0 belegt, bestimmt Microsoft <strong>Excel</strong> den Rang<br />
von Zahl so, als wäre Bezug eine in aufsteigender Reihenfolge sortierte Liste.<br />
3.11 <strong>Excel</strong>-Solver<br />
Der Solver ist ein so genanntes Add-In, also ein zusätzliches benutzerdefiniertes Werkzeug,<br />
das in diesem Fall aber von Microsoft selber geliefert wird. Im Menü Extras gibt<br />
es den Befehl Add-Ins <strong>mit</strong> allen verfügbaren Add-Ins. Wenn das gewünschte Add-In<br />
nicht im Feld Verfügbare Add-Ins angezeigt wird, klicken Sie auf Durchsuchen, um das<br />
Add-In zu suchen. Wenn Sie das Add-In für den Solver richtig installiert haben, muss im<br />
Menü Extras der Befehl Solver dabei sein. Ist das nicht der Fall, muss das Features<br />
<strong>mit</strong>hilfe des Setup-Programms nachinstalliert werden. Der Solver maximiert oder minimiert<br />
eine Zielfunktion unter Nebenbedingungen. Betrachten Sie bitte folgendes Problem<br />
Max. G = − (x − 3) 2 − (y − 2) 2 + 5<br />
u. d. Nb. x + y ≥ 3<br />
x 2 + y 2 ≤ 9<br />
x, y ≥ 0<br />
Hier gibt es zwei unabhängige Variablen x <strong>und</strong> y <strong>und</strong> zwei Nebenbedingungen, wozu<br />
noch die Nebenbedingungen x, y ≥ 0 kommen. Für jede unabhängige Variable muss eine<br />
Zelle eingerichtet werden, dies seien A1 <strong>und</strong> B1. Die Werte sind zunächst beliebig, ich<br />
setze 4 <strong>und</strong> 5 ein, siehe Abbildung 3.8. Dann muss für die Zielfunktion <strong>und</strong> für jede<br />
Nebenbedingung eine Zelle eingerichtet werden. Ich nehme für die Zielfunktion die Zelle<br />
C1 <strong>und</strong> schreibe sie als Formel:<br />
= -((A1-3)ˆ2) - ((B1-2)ˆ2) + 5<br />
Das gleiche führe ich für die rechten Seiten der Nebenbedingungen durch. Die erste<br />
Nebenbedingung schreibe ich als Formel in die Zelle C4, <strong>und</strong> die zweite in die Zelle C5:<br />
46
= A1 + B1<br />
=A1ˆ2 + B1ˆ2<br />
3.11 <strong>Excel</strong>-Solver<br />
Nun rufe ich den Solverdialog auf, siehe Abbildung 3.8. Ich entscheide mich für die<br />
Art des Extremums, also Max oder Min. Im Feld Veränderbare Zellen werden die die<br />
Abbildung 3.8: Der Solverdialog<br />
Namen der veränderbaren Zellen eingetragen, hier als der Bereich A1:B1. Dann wird die<br />
Zielzelle angegeben, hier ist das die Zelle C1. Als letztes werden die Nebenbedingungen<br />
hinzugefügt. Dazu muss die entsprechende Schaltfläche gedrückt werden. Es erscheint<br />
ein kleiner Dialog, in dem eine Nebenbedingung eingetragen werden kann. Insgesamt<br />
sind vier Nebenbedingungen hinzuzufügen, die beiden eigentlichen Nebenbedingungen<br />
<strong>und</strong> die Nichtnegativitätsbedingungen, für die ich die unabhängigen Variablen A1 <strong>und</strong><br />
B1 selbst nehme.<br />
Um die Nebenbedingung zu übernehmen <strong>und</strong> eine weitere hinzuzufügen, klicken Sie<br />
auf Hinzufügen. Um die Nebenbedingung zu übernehmen <strong>und</strong> zum Dialogfeld Solver-<br />
Parameter zurückzukehren, klicken Sie auf OK. Die Nebenbedingungen können über die<br />
entsprechenden Schaltflächen gelöscht oder verändert werden.<br />
Im <strong>Excel</strong>-Tabellenblatt habe ich diesmal nicht die Werte, sondern die Formeln eingetragen.<br />
Die Umschaltung zwischen Werten <strong>und</strong> Formeln erfolgt über Strg+#.<br />
47
4 Organisation von Mappen <strong>und</strong><br />
Tabellen<br />
Jede Arbeitsmappe besteht aus Tabellen. Wie man Mappen <strong>und</strong> Tabellen organisiert,<br />
zeigt dieses kleine Kapitel<br />
4.1 Arbeitsmappen<br />
<strong>Excel</strong>-Dateien heißen Arbeitsmappen, die sich wiederum aus Arbeitsblättern oder Tabellen<br />
zusammensetzen. Diagramme können Teil des Arbeitsblattes sein, oder in einem<br />
eigenen Diagrammblatt erscheinen. Die Arbeitsblätter einer Arbeitsmappe sollten Daten<br />
enthalten, die logisch zusammengehören, wie etwa die Daten der Eliteuniversität<br />
EEE. Man darf Berechnungen durchführen, denen Daten aus mehreren Arbeitsblättern<br />
zugr<strong>und</strong>e liegen.<br />
Zuständig für die Organisation der Blätter einer Mappe ist die Blattregisterleiste, die<br />
sich am unteren Rand des Arbeitsmappenfensters befindet, vgl. Abbildung 4.1.<br />
Abbildung 4.1: Register<br />
Sie können zwischen Arbeitsblättern oder Diagrammblättern wechseln, indem Sie auf<br />
die Blattregister klicken. Das aktive Arbeitsblatt ist optisch hervorgehoben <strong>und</strong> da<strong>mit</strong><br />
leicht zu erkennen. Links neben der Blattregisterleiste befindet sich die Leiste <strong>mit</strong> den<br />
Schaltflächen für den Bildlauf der Registerkarten. Sowohl die Blattregisterleiste als auch<br />
diese Leiste haben ein eigenes Kontextmenü. Das Kontextmenü der Registerbildlaufleiste<br />
48
4.1 Arbeitsmappen<br />
erscheint durch Klicken der rechten Maustaste auf einem der Pfeile. Ich habe dieses<br />
Kontextmenü in Abbildung 4.1 aufgeklappt. Es zeigt alle Blätter der Arbeitsmappe.<br />
Die Registerblätter sind von der horizontalen Laufleiste durch den Trennungsbalken<br />
getrennt. Dieser lässt sich in beide Richtungen verschieben, wodurch sich die beiden<br />
Leisten vergrößern bzw. verkleinern. Das kann man ausnutzen, wenn eine Mappe sehr<br />
viele Blätter enthält.<br />
4.1.1 Ausblenden von Arbeitsblättern<br />
Sie können Arbeitsblätter ausblenden, um die Anzahl der Blätter auf dem Bildschirm<br />
zu reduzieren oder Arbeitsblätter <strong>mit</strong> vertrauliche Daten zu verbergen.<br />
Leider weiß ich nicht wie.<br />
4.1.2 Gleichzeitiges Markieren von Arbeitsblättern<br />
Normalerweise ist immer nur ein Arbeitsblatt ausgewählt. Mit den üblichen Windows-<br />
Techniken können Sie aber auch mehrere Arbeitsblätter gleichzeitig auswählen, etwa<br />
um sie gemeinsam zu löschen oder in allen ausgewählten Blättern dieselbe Eingabe zu<br />
erreichen.<br />
Bei Blättern, die in einer Reihe liegen, klicken Sie auf die Registerkarte des ersten<br />
Blattes, <strong>und</strong> klicken dann bei gehaltener Umschalt-Taste auf die Registerkarte des letzten<br />
Blattes. Sind die Blätter verstreut, halten Sie STRG gedrückt, <strong>und</strong> klicken dann auf die<br />
Registerkarten der Blätter, die Sie auswählen wollen. Alle Blätter gemeinsam wählen Sie<br />
am besten über das Kontextmenü der Blattregister aus. Die Aufhebung der gemeinsamen<br />
Markierung erfolgt ebenfalls über das Kontextmenü oder durch Anklicken eines nichtaktiven<br />
Arbeitsblatts.<br />
4.1.3 Weitere Befehle zur Verwaltung von Blättern<br />
Eine neue Tabelle kann man über das Kontextmenü der Blattregisterleiste oder über<br />
den Shortcut Umschalt + F11 erstellen. Wählt man den Umweg über das Menüsystem,<br />
ist aus dem Hauptmenü Einfügen der Befehl Tabellenblatt zu wählen. Die neue<br />
Tabelle erscheint in der Registerleiste un<strong>mit</strong>telbar vor dem gerade aktiven Blatt.<br />
Eine bestehende Tabelle löschen Sie ebenfalls bequem <strong>mit</strong> dem Kontextmenü. Zur<br />
Umbennung klicken Sie einfach den Namen der gewünschte Tabelle in der Registerleiste<br />
doppelt an, dann können Sie den neuen Namen über den alten schreiben.<br />
4.1.4 Verschieben oder Kopieren von Blättern<br />
Wenn Sie nur innerhalb einer Arbeitsmappe ein Blatt verschieben wollen, packen Sie das<br />
Registerblatt innerhalb der Registerblattleiste <strong>und</strong> ziehen <strong>mit</strong> der Maus das Register an<br />
die gewünschte neue Stelle. Soll das Blatt zusätzlich kopiert werden, müssen Sie beim<br />
Ziehen die Strg-Taste halten. Die Kopie erhält dann den alten Namen <strong>und</strong> zusätzlich in<br />
Klammern angefügt die Zahl 2. Danach können Sie die Kopie umbenennen.<br />
49
4 Organisation von Mappen <strong>und</strong> Tabellen<br />
Wollen Sie eine Tabelle einer Mappe in eine andere Mappe verschieben oder kopieren,<br />
müssen beide Mappen geöffnet sein. Sie können <strong>mit</strong> der gleich erklärten Fenstertechnik so<br />
wie in Abbildung 4.2 das Registerblatt von einer Registerleiste in die andere verschieben<br />
oder bei gedrückter Strg-Taste kopieren <strong>und</strong> verschieben.<br />
Sie können aber auch zunächst die gewünschten Blätter markieren <strong>und</strong> im Kontextmenü<br />
oder im Hauptmenü Bearbeiten den Befehl Blatt verschieben/kopieren<br />
wählen. Dann erscheint ein Dialogfeld <strong>mit</strong> allen geöffneten Arbeitsmappen. Wählen Sie<br />
die richtige aus <strong>und</strong> klicken dann im Feld Einfügen vor auf das Blatt, vor dem die<br />
verschobenen oder kopierten Blätter eingefügt werden sollen. Wenn die Blätter nicht<br />
verschoben, sondern kopiert werden sollen, aktivieren Sie das Kontrollkästchen Kopie<br />
erstellen.<br />
4.2 Neue Tabelle <strong>und</strong> neues Fenster<br />
Ein zweites Fenster für die aktuelle Mappe erhält man über die Befehlsfolge Fenster|Neues<br />
Fenster. In der folgenden Abbildung habe ich zwei Fenster für die Arbeitsmappe<br />
ueb1 erzeugt. Die beiden Fenster befinden sich innerhalb des Arbeitsmappenfensters<br />
von <strong>Excel</strong> <strong>und</strong> müssen <strong>mit</strong> den unter Windows üblichen Fenstertechniken platziert<br />
werden. Einfacher geht die Anordnung über die Befehlsfolge Fenster|Anordnen. . .<br />
<strong>Excel</strong> bietet die Möglichkeit, die Fenster überlappend, neben- oder übereinander anzuzeigen.<br />
Wählt man dann die Option Vertikal, erscheinen die Fenster nebeneinander.<br />
<strong>Excel</strong> hat in der Titelleiste an den Namen der Datei »:1« bzw. »:2« angehängt, da die<br />
Fenster dieselbe Datei anzeigen.<br />
Drückt man in der Titelleiste des aktiven Fensters auf das quadratische Symbol, erscheint<br />
dieses Fenster im Vollbild, nimmt also den gesamten Bereich des Arbeitsmappenfensters<br />
ein. Ein Fenster im Vollbild kann nicht durch die Maus verschoben oder<br />
verkleinert werden. Das Symbol hat sich in zwei überlappende Quadrate verwandelt.<br />
Drückt man dieses, kann das Fenster wieder manipuliert werden. Sobald ein Fenster ma-<br />
Abbildung 4.2: Zwei Fenster für eine Arbeitsmappe<br />
ximiert ist, verdeckt es automatisch alle anderen Fenster. Über die Tastenkombination<br />
Strg+Tab kann man bequem von Fenster zu Fenster springen.<br />
50
4.3 Verschieben, Kopieren <strong>und</strong> Ausschneiden<br />
Die hier beschriebenen Fenstertechniken gelten auch, wenn zwei oder mehr Arbeitsmappen<br />
geöffnet sind. Jede Arbeitsmappe kann dann in einem eigenen Fenster dargestellt<br />
werden.<br />
4.3 Verschieben, Kopieren <strong>und</strong> Ausschneiden<br />
Diese Aktionen sind in den meisten Windows-Programmen standardisiert. Zunächst<br />
muss der gewünschte Bereich markiert werden. Führt man die Maus an den schwarzen<br />
Rahmen, verändert sich der Mauszeiger zu einem Pfeilkreuz, das in alle vier Himmelsrichtungen<br />
zeigt. Jetzt kann man den Bereich verschieben. Ist der neue Bereich nicht<br />
leer, fragt <strong>Excel</strong> nach, ob die bisherigen Inhalte überschrieben werden sollen.<br />
Das Ausschneiden erfolgt entweder über Strg+X oder über die Befehlsfolge Bearbeiten|Ausschneiden.<br />
Der markierte Bereich wird von einem nervös machenden Laufband<br />
umgeben. Klickt man jetzt eine Zelle an <strong>und</strong> drückt die Eingabe-Taste, wird der<br />
ausgeschnittene Bereich hier eingefügt. Diese Vorgehensweise bietet sich an, wenn die<br />
Verschiebung über eine große Entfernung oder in eine andere Tabelle erfolgen soll.<br />
Genauso funktioniert das Kopieren, nur bleibt hier der ursprüngliche Bereich erhalten.<br />
Die Befehle sind Strg+C oder Bearbeiten|Kopieren.<br />
Hat man in einem Zellbereich Formeln <strong>und</strong> möchte nur deren Wert, aber nicht die<br />
Formel selbst kopieren, markiert man zunächst diesen Bereich, drückt Strg+C, wählt<br />
den Befehl Bearbeiten|Inhalte einfügen. . . wählt im Dialog die Option Werte.<br />
So muss man immer vorgehen, wenn man nur die Ergebnisse von Formeln, aber nicht<br />
die Bereiche <strong>mit</strong> kopieren will, aus denen die Formeln hervorgegangen sind. Mit der<br />
beschriebenen Methode können Sie Formeln auch durch die berechneten Werte ersetzen,<br />
in dem Sie auf den bestehenden Teil überschreiben. Das lässt sich dann aber nicht mehr<br />
rückgängig machen.<br />
4.4 Fensterteilung<br />
Anstelle eines weiteren Fensters kann auch das aktuelle Fenster in zwei Hälften geteilt<br />
werden.<br />
Die waagrechte Teilung erfolgt über den kleinen Balken direkt über dem oberen Pfeil<br />
der vertikalen Laufleiste. Sobald die Maus über diesem Balken liegt, verändert sich der<br />
Mauszeiger zu einem Doppelstrich <strong>mit</strong> zwei nach oben <strong>und</strong> unten gerichteten Pfeilen.<br />
Drückt man jetzt die Maus, erscheint ein dicker Querbalken, den man nur noch an die<br />
gewünschte Position zu schieben braucht. Jeder der beiden Bildschirmausschnitte zeigt<br />
dieselbe Tabelle, aber man kann unabhängig voneinander navigieren.<br />
Die senkrechte Teilung erfolgt über den kleinen Balken am rechten Rand der horizontalen<br />
Laufleiste. Sobald die Maus über diesem Balken liegt, verändert sich der Mauszeiger<br />
zu einem Doppelstrich <strong>mit</strong> zwei nach links <strong>und</strong> rechts weisenden Pfeilen. Drückt man<br />
jetzt die Maus, erscheint ein dicker Längsbalken, den man nur noch an die gewünschte<br />
Position zu schieben braucht.<br />
51
4 Organisation von Mappen <strong>und</strong> Tabellen<br />
Das Menü Fenster bietet noch eine weitere Variante der Teilung, nämlich das Fixieren<br />
einiger Zeilen. Diese bleiben beim Rollen des Bildschirms immer sichtbar. Das bietet<br />
sich etwa für Überschriften von Datenreihen <strong>mit</strong> vielen Zeilen an. Die Fixierung erfolgt<br />
durch Aktivierung derjenigen Zelle, die eine Zeile unterhalb <strong>und</strong> eine Spalte rechts des<br />
zu fixierenden Bereichs steht. Die Überschrift der Tabelle der Abbildung 4.3 steht im<br />
Bereich A1:G1, die Fixierung würde sich hier in der Zelle H2 anbieten. Dann wird der<br />
Befehl Fenster|Fenster fixieren aufgerufen. Die Fixierung lässt sich durch den<br />
Befehl Fenster|Fixierung aufheben wieder entfernen.<br />
4.5 Formelbezüge<br />
In einer Arbeitsmappe sind zusammengehörende Daten in verschiedenen Blättern verstreut.<br />
Berechnungen beziehen sich dann auf die Zellen in unterschiedlichen Tabellen.<br />
Daher muss bei Verwendung einer Zelle oder eines Bereichs aus einer anderen Tabelle,<br />
zunächst deren Namen gefolgt von einem Ausrufungszeichen »!« gestellt werden. Der<br />
Bezug Profs!G3 gilt also der Zelle G3 des Arbeitsblatts Profs.<br />
Das Kalkulieren <strong>mit</strong> unterschiedlichen Blättern einer Mappe werde ich jetzt am Beispiel<br />
der Gehaltsabrechnungen der EEE zeigen.<br />
4.6 Bezug auf andere Mappen<br />
Backslash= \ [ ] =INDEX(´ C:\aaaaa_wichtig<br />
4.7 Die Gehaltsabrechnung der EEE<br />
Ich gehe davon aus, dass eine Mappe namens eeedat.xls <strong>mit</strong> folgenden drei Tabellen angelegt<br />
ist. Die Tabellen Profs, Module <strong>und</strong> Kurse sollen so gestaltet sein, wie in den<br />
Abbildungen 1.1 bis 1.3 gezeigt, wobei die Spalte Gesamtgebühr der Tabelle Kurse nicht<br />
<strong>mit</strong> übernommen werden soll. Sie finden die Mappe unter<br />
WWW www.irgendwann-irgendwo.de<br />
Zusätzlich wird eine Tabelle namens Abrechnung so wie in der Abbildung 4.3 erstellt,<br />
natürlich nur <strong>mit</strong> den Überschriften, die Berechnungen soll ja <strong>Excel</strong> ausführen.<br />
Die drei Gr<strong>und</strong>tabellen Profs, Module <strong>und</strong> Kurse sind heilig <strong>und</strong> dürfen nur vom<br />
Dekan Trauerwein selbst bearbeitet werden. In der Praxis wären diese Tabellen Teil<br />
einer gut geschützten Datenbank. Um die Sache nicht zu kompliziert zu machen, bleibe<br />
ich bei einer Datei <strong>mit</strong> geschützten Ausgangsdaten.<br />
Um die Gesamtgebühren der Kurse zu er<strong>mit</strong>teln lege ich mir eine Kopie der Tabelle<br />
Kurse an. <strong>Excel</strong> gibt der Kopie den Namen Kurse(2), <strong>und</strong> da mir auch nichts besseres<br />
einfällt aber die Klammern missfallen, nenne ich die Kopie in Kurseneu um. Die Arbeits-<br />
52
Abbildung 4.3: Berechnung der Bruttogehälter<br />
4.7 Die Gehaltsabrechnung der EEE<br />
mappe hat so<strong>mit</strong> fünf Tabellen, <strong>und</strong> zwar Profs, Module <strong>und</strong> Kurse, sowie Kurseneu <strong>und</strong><br />
Abrechnung. Auf die drei ersten Tabellen habe ich wie erwähnt nur Lesezugriff.<br />
4.7.1 Kopie der Namen<br />
Der misstrauische Dekan Trauerwein hat die geschützten Dateien verborgen, <strong>und</strong> da ich<br />
nicht weiß, wie das aufzuheben ist, kann ich die erste Spalte <strong>mit</strong> den Namen nicht einfach<br />
kopieren. Ich verwende daher die INDEX-Funktion. Dies ist eine Matrixfunktion, wo<strong>mit</strong><br />
man direkt Zugriff auf die Elemente einer Matrix hat. Die Syntax dieser Funktion lautet:<br />
INDEX(M;Z;S)<br />
<strong>und</strong> sie gibt den Wert der Zelle zurück, der in der Zeile Z <strong>und</strong> Spalte S der Matrix M<br />
steht. Die Zeilen <strong>und</strong> Spalten werden dabei von 1 anfangend durchgezählt.<br />
So<strong>mit</strong> erhalte ich in der Zelle A2 den Namen des ersten Professors, also Bulletti durch<br />
folgenden Ausdruck:<br />
=INDEX(Profs!$A$2:$A$9;ZEILE()-1;1)<br />
Die Matrix M ist hier der Bereich Profs!$A$2:$A$9, denn die Namen stehen in der<br />
Tabelle Profs im Bereich $A$2:$A$9. Achten Sie unbedingt auf die absoluten Bezüge.<br />
Die Zeile <strong>mit</strong> dem Wert 1 habe ich nicht direkt so geschrieben, sondern als ZEILE()-1,<br />
denn die aktive Zelle ist A2 der Tabelle Abrechnung. Den obigen Ausdruck kann ich jetzt<br />
am Ausfüllkästchen nach unten ziehen.<br />
4.7.2 Berechnung der SuF-Zulage<br />
Die unterbezahlten Professoren des FBR SuF haben eine Zulage von 150 e erkämpft.<br />
Die Formel für die Zelle E2 lautet:<br />
53
4 Organisation von Mappen <strong>und</strong> Tabellen<br />
=WENN(Profs!G2="SuF";150;0)<br />
Auch hier muss auf die Tabelle Profs zugegriffen werden. Diese Formel kann problemlos<br />
nach unten gezogen werden.<br />
4.7.3 Berechnung der Familien-Zulage<br />
Diese Zulage setzt sich aus dem Kindergeld von 200 e <strong>und</strong> der Ehegattenzulage von 100<br />
e zusammen. In der Zelle D2 der Tabelle Abrechnung steht so<strong>mit</strong>:<br />
=WENN(Profs!E2="";0;$E$11)+Profs!F2*$E$12<br />
denn in der Zelle E11 steht die Ehegattenzulage <strong>und</strong> in der Zelle E12 das Kindergeld.<br />
Diese Bezüge müssen selbstverständlich absolut sein. Dann lässt sich auch diese Formel<br />
am Ausfüllkästchen nach unten ziehen.<br />
4.7.4 Berechnung der Alters-Zulage<br />
Dies überlasse ich Ihnen als Übung.<br />
4.7.5 Berechnung der Gebühren<br />
Ich berechne als letztes das Hörergeld, das sich aus den Gesamtgebühren ableitet. Ich<br />
beginne <strong>mit</strong> der Gesamtgebühr des ersten Kurses, der sich in der Zeile 2 der Tabelle<br />
Kurseneu befindet.<br />
Die Einnahme eines Kurses ist das Produkt dreier Faktoren, <strong>und</strong> zwar der Hörerzahl,<br />
der Gr<strong>und</strong>gebühr pro SWS <strong>und</strong> der Anzahl der SWS des zugr<strong>und</strong>liegenden Moduls.<br />
Die Hörerzahl steht in der Spalte F der Datei Kurseneu, die beiden anderen Angaben<br />
muss ich mir aus der Tabelle Module holen, <strong>und</strong> zwar passend zum Modul. Deshalb<br />
verwende ich die Funktion SVERWEIS, die passend zum Modul die richtigen Angaben<br />
über die Anzahl von SWS <strong>und</strong> die Gebühr pro SWS liefert. Dabei muss ich auf die<br />
Spalten 2 <strong>und</strong> 3 der Tabelle Module zugreifen. Da ich aus der Sicht der aktuellen Tabelle<br />
Kurseneu auf eine fremde Tabelle zugreife, muss ich dem Verweis den Namen der Tabelle<br />
gefolgt von einem Ausrufungszeichen voranstellen. In die Zelle G2 kommt so<strong>mit</strong> folgende<br />
Mammutformel:<br />
=SVERWEIS($A2;Module!$A$2:$C$7;2;FALSCH)<br />
*SVERWEIS($A2;Module!$A$2:$C$7;3;FALSCH)*F2<br />
Diese Formel kann ich am Ausfüllkästchen nach unten ziehen <strong>und</strong> erhalte alle Gesamtgebühren<br />
der einzelnen Kurse. Wenn Sie das nachvollziehen wollen, müssen Sie zu den<br />
Ergebnissen der Tabelle 1.3 kommen.<br />
Für das eigentliche Hörergeld muss ich zur Tabelle Abrechnung zurückkehren <strong>und</strong> die<br />
Gebühren auf die einzelnen Professoren <strong>mit</strong> Hilfe der SUMMEWENN-Funktiion umlegen.<br />
Da das Hörergeld 1% des Anteils des Professors an den Gesamtgebühren beträgt,<br />
muss in der Zelle F2 folgender Ausdruck stehen:<br />
54
4.7 Die Gehaltsabrechnung der EEE<br />
=GANZZAHL(SUMMEWENN(Kurseneu!$B$2:$B$25;A2;Kurseneu!$G$2:$G$25)/1000)*10<br />
55
5 Listen<br />
Listen sind rechteckige Bereiche einer <strong>Excel</strong>-Tabelle <strong>mit</strong> zusammengehörigen Daten. Die<br />
erste Zeile der Liste enthält Beschriftungen für jede Spalte. Die nachfolgenden Zeilen<br />
bestehen aus den eigentlichen Daten. Listen können sortiert, nach Kriterien gefiltert<br />
<strong>und</strong> <strong>mit</strong> Hilfe so genannter Datenbankfunktionen ausgewertet werden.<br />
5.1 Was sind Listen<br />
56<br />
Abbildung 5.1: Eine Tabelle<br />
Die Hilfe von <strong>Excel</strong> erklärt Listen als »eine Reihe von Tabellenzeilen, die zusammen-
5.1 Was sind Listen<br />
gehörende Daten enthalten, beispielsweise eine Rechnungsdatenbank oder eine Gruppe<br />
von K<strong>und</strong>ennamen <strong>und</strong> Telefonnummern. Die erste Zeile der Liste enthält Beschriftungen<br />
für die Spalten«. Eine Zeile wird Datensatz genannt, die Spalten werden als Felder<br />
bezeichnet. Im Zusammenhang von Datenbanken würde man Listen als Tabellen oder<br />
Tafeln bezeichnen. Da aber schon die Arbeitsblätter Tabellen genannt werden, heißen<br />
eben Tabellen hier Listen. Um die Verwirrung noch weiter zu steigern, werden Listen von<br />
der Hilfe manchmal auch als Datenbanken bezeichnet. Ein Datenbank ist aber streng<br />
genommen eine Sammlung zusammengehörender Tabellen (=Listen), wobei noch zusätzliche<br />
Forderungen gestellt werden, auf die ich hier nicht eingehen kann.<br />
Zur Erläuterung gebe ich in der Abbildung 5.1 die Liste der Professoren der Emil-<br />
Erpel-Eliteuniversität von Entenhausen (EEE) an. Die Liste besteht aus 8 Datensätzen<br />
<strong>und</strong> 8 Feldern, der erste Datensatz beschreibt die Merkmale von Prof. Bulletti, das dritte<br />
Feld gibt von jedem Datensatz das Geschlecht an.<br />
Die Daten in einer Zeile beziehen sich also auf eine Untersuchungseinheit, hier die Professoren,<br />
<strong>und</strong> die Daten einer Spalte sind die Ausprägungen eines gemeinsamen Merkmals,<br />
etwa des Namens oder des Geschlechts. Die Bezeichnungen der Merkmale bilden<br />
die erste Zeile. In der Statistik bezeichnet man eine solche Liste als Datenmatrix.<br />
Weiter wird in der Online-Hilfe empfohlen:<br />
• Legen Sie einen Abstand zwischen der Liste <strong>und</strong> den anderen Elementen fest.<br />
Lassen Sie zwischen der Liste <strong>und</strong> anderen Daten im Arbeitsblatt mindestens eine<br />
Spalte <strong>und</strong> eine Zeile leer. Auf diese Weise kann <strong>Excel</strong> die Liste leichter erkennen<br />
<strong>und</strong> markieren, wenn Sie Daten sortieren <strong>und</strong> filtern oder automatisch errechnete<br />
Teilergebnisse einfügen.<br />
• Erstellen Sie nur eine Liste pro Arbeitsblatt, da einige Listenverwaltungsfunktionen,<br />
z. B. das Filtern, nicht auf mehrere Listen gleichzeitig angewendet werden<br />
können.<br />
• Verwenden Sie formatierte Spaltenbeschriftungen. Erstellen Sie Spaltenbeschriftungen<br />
in der ersten Zeile einer Liste. <strong>Excel</strong> verwendet die Beschriftungen zur Berichterstellung<br />
<strong>und</strong> zum Auffinden <strong>und</strong> Strukturieren von Daten. Verwenden Sie<br />
für die Spaltenbeschriftung eine Schriftart, eine Ausrichtung, ein Format, einen<br />
Rahmen oder ein Format für die Groß-/Kleinschreibung, das sich von dem der<br />
Daten in der Liste unterscheidet. Formatieren Sie die Zellen als Text, bevor Sie die<br />
Spaltenbeschriftungen eingeben.<br />
• Wenn Sie die Beschriftungen von den Daten trennen möchten, verwenden Sie Zellrahmen,<br />
um Linien unterhalb der Beschriftungen einzufügen <strong>und</strong> keine Leerzeilen<br />
oder gestrichelten Linien.<br />
• Vermeiden Sie leere Zeilen <strong>und</strong> Spalten innerhalb der Liste, um <strong>Excel</strong> das Erkennen<br />
<strong>und</strong> Markieren der Liste zu erleichtern. Geben Sie keine Leerzeichen am Anfang<br />
oder am Ende eines Eintrags ein Zusätzliche Leerzeichen am Anfang <strong>und</strong> am Ende<br />
einer Zelle wirken sich nachteilig auf Sortier- <strong>und</strong> Suchvorgänge aus. Stattdessen<br />
können Sie dem Text in einer Zelle einen Einzug zuweisen.<br />
57
5 Listen<br />
• Wenn Sie neue Zeilen <strong>mit</strong> Daten am Ende einer Liste hinzufügen, werden von <strong>Excel</strong><br />
auf die neuen Zeilen konsistente Formatierungen <strong>und</strong> Formeln übertragen. Da<strong>mit</strong><br />
ein Format erweitert wird, müssen drei von fünf vorangegangenen Zellen dasselbe<br />
Format verwenden. Da<strong>mit</strong> eine Formel erweitert wird, müssen alle vorangegangenen<br />
Formeln konsistent sein.<br />
Wie Sie sehen war ich vorbildlich: Die Überschriften sind fett formatiert <strong>und</strong> durch<br />
Striche von den eigentlichen Daten getrennt. Es gibt keine Leerzeilen oder -Spalten<br />
innerhalb der Liste, die Liste selbst ist sauber von den anderen Inhalten des Arbeitsblatts<br />
durch Leerzeilen oder -Spalten getrennt, d.h. die ganze Zeile 10 <strong>und</strong> die nicht mehr<br />
abgebildete Spalte I bleiben frei.<br />
5.2 Das Menü Daten<br />
Tabellen werden von <strong>Excel</strong> also als Listen bezeichnet, das zugehörige Hauptmenü heißt<br />
entsprechend, eben nicht Listen sondern Daten. Das ist in sofern gerechtfertigt, da<br />
sich hinter den Befehlen verkappte Datenbankanweisungen wie Sortieren, Filtern (Auswählen)<br />
<strong>und</strong> Gruppieren verbergen. Ein besonders einfach zu verstehender Befehl dieses<br />
Menüs heißt Sortieren. . . . Den möchte ich näher erklären.<br />
5.2.1 Sortieren<br />
Abbildung 5.2: Der Dialog Sortieren<br />
Listen können nach jedem Feld, also nach jeder Spalte auf- oder absteigend sortiert<br />
werden. Falls die Sortierung über eine Spalte nicht genügt, kann über eine zweite, ggf.<br />
sogar über eine dritte Spalte sortiert werden. Bei der Professorenliste bietet sich die<br />
Sortierung über Namen <strong>und</strong> Vornamen an. Der abgebildete Dialog öffnet sich über die<br />
58
5.3 Filtern von Listen<br />
Befehlsfolge Daten Sortieren. . . Bei diesen Eingaben würde die Liste nach Namen<br />
sortiert <strong>und</strong> bei gleichem Namen noch zusätzlich nach Vornamen.<br />
5.2.2 Eingabehilfe durch Auswahl<br />
Oft kommt es vor, dass sich die Einträge in einer Spalte wiederholen. Wenn Sie in einer<br />
Zelle die rechte Maustaste drücken, erscheint das Kontextmenü <strong>mit</strong> u.a. dem Befehl Auswahlliste.<br />
. . Wenn Sie diesen aufrufen, öffnet sich ein Listenfeld <strong>mit</strong> allen bisherigen<br />
Einträgen in der entsprechenden Spalte bis zur ersten leeren Zelle.<br />
5.3 Filtern von Listen<br />
Zur Informationverdichtung werden Listen oft gefiltert, beispielsweise könnte die Frauenbeauftragte<br />
Fräulein Eisenbeiß einen Blick allein auf die weiblichen Professoren werfen<br />
wollen, ohne deshalb gleich alle Datensätze <strong>mit</strong> männlichen Professoren zu löschen. Eine<br />
gefilterte Liste blendet einfach alle Zeilen aus, die bestimmten Bedingungen nicht<br />
genügen. Der Vorgang selbst heißt Filtern, die Auswahlbedingungen Kriterien.<br />
Nicht überraschend stellt <strong>Excel</strong> einen spezialisierten Befehl namens Filter des Menüs<br />
Daten zur Verfügung. Ich möchte die Prinzipien des Filterns aber über den Umweg des<br />
Befehls Maske aus diesem Menü erklären.<br />
5.4 Der Befehl Maske. . .<br />
Dieser Befehl des Menüs Daten ist umfangreicher als der harmlose Befehl Sortieren,<br />
scheint aber zunächst nichts <strong>mit</strong> Filtern zu tun zu haben. <strong>Excel</strong> erstellt für Tabellen <strong>mit</strong><br />
Überschriften automatisch ein Eingabeformular, eine so genannte Maske. Dies wird über<br />
den Befehl Maske. . . des Menüs Daten erreicht. Der zugehörige Dialog, siehe Abbildung<br />
5.3, ist einfach zu verstehen <strong>und</strong> soll die Eingabe erleichtern. Über die Schaltfläche<br />
Kriterien ergibt sich aber auch die erste von vielen Möglichkeiten zum Filtern.<br />
Die Maske ist zunächst ohne Kriterien eingestellt <strong>und</strong> zeigt dann über die Schaltflächen<br />
Weitersuchen bzw. Vorherigen suchen alle Datensätze nacheinander, wobei man<br />
sich nach vorne <strong>und</strong> hinten bewegen kann, aber man kommt immer nur einen Schritt<br />
weiter. Über die gleichlautenden Schaltflächen kann man Datensätze löschen <strong>und</strong> neu<br />
erstellen. Aber Vorsicht:<br />
WWW Eine über die Maske erfolgte Löschung eines Datensatzes ist unwiderruflich<br />
<strong>und</strong> kann auch nicht mehr durch den Befehl Bearbeiten Rückgängig ungeschehen<br />
gemacht werden.<br />
5.4.1 Kriterien zum Filtern<br />
Die Schaltfläche Kriterien dient der Auswahl bestimmter Datensätze, die fest gesetzten<br />
Bedingungen, so genannten Kriterien genügen. Drückt man diese Schaltfläche,<br />
erscheint die Maske <strong>mit</strong> leeren Eingabefeldern. In jedem Eingabefeld kann man nun ein<br />
59
5 Listen<br />
Abbildung 5.3: Die Maske zur Liste<br />
Kriterium schreiben, etwa im ersten Eingabefeld für die Namen das Kriterium »>B«.<br />
Ein einzelnes Kriterium bezieht sich auf eine Spalte, also auf ein Merkmal. Man darf<br />
Kriterien für jede Spalte festlegen, die bei der abgebildeten Maske durch das logische<br />
»UND« verknüpft werden. Im Allgemeinen dürfen Kriterien aber auch durch das logische<br />
»ODER« verknüpft werden.<br />
Kriterien für numerische Felder sind leicht zu verstehen, so bedeutet in der Abbildung<br />
5.4 der Eintrag für das Feld Kinder, dass nur Datensätze angezeigt werden, wo im<br />
entsprechenden Feld der eingetragene Wert, hier also 0, auftritt. Man darf aber auch<br />
Vergleiche wie »> 0« oder »
Abbildung 5.4: Kriterien zur Maske<br />
5.5 Der Befehl Filter<br />
Bedeutung Gef<strong>und</strong>ene Zeichen<br />
? Ein beliebiges einzelnes Zeichen.<br />
Bsp.: Ma?er Erkennt »Maier« <strong>und</strong> »Mayer«, aber nicht »Meyer«<br />
* Eine beliebige Anzahl von Zeichen.<br />
Bsp.: M*er Erkennt »Maier« <strong>und</strong> »Mayer« sowie »Meyer«<br />
∼ (Tilde), gefolgt Fragezeichen, Sternchen oder Tilde.<br />
von ?, * oder ∼<br />
Bsp.: ∼∼M*er∼? Erkennt »∼Maier?«, »∼Müller?« usw.<br />
Die Eingabe »G?r*« im Feld Vorname des Kriteriendialogs lässt also nur Datensätze<br />
zu, deren Vorname <strong>mit</strong> »G« beginnt, gefolgt von einem beliebigen Buchstaben. Der dritte<br />
Buchstabe muss ein »r« sein, der Rest ist beliebig. Wenn Sie zurück in die Liste der<br />
Professoren blättern (Abbildung 5.1), werden Sie feststellen, dass nur zwei Datensätze,<br />
nämlich »Grün, Gero« <strong>und</strong> »Grünlich, Gerda« diesem Kriterium entsprechen.<br />
Filtern von Datensätzen ist so wichtig, dass im Menü Daten ein eigenständiger Befehl<br />
eingerichtet wurde, auf den ich jetzt eingehe.<br />
5.5 Der Befehl Filter<br />
Neben der Möglichkeit, die Liste über den Befehl Maske zu filtern, hat <strong>Excel</strong> im Menü<br />
Daten den Befehl Filter eingerichtet, der zu einem Untermenü <strong>mit</strong> den Einträgen<br />
Autofilter, Spezialfilter. . . <strong>und</strong> Alle anzeigen führt, wobei der letzte Befehl<br />
nur wirksam ist, wenn zuvor eine Filterung stattfand, die hier<strong>mit</strong> wieder aufgehoben<br />
wird.<br />
Beginnen wir <strong>mit</strong> dem Befehl Autofilter, der voraussetzt, dass eine Zelle innerhalb<br />
einer Liste ausgewählt ist, wobei die Liste die oben erwähnten Bedingungen erfüllen<br />
muss. Wählt man diesen Befehl aus, erscheint er <strong>mit</strong> einem Häkchen <strong>und</strong> <strong>Excel</strong> macht<br />
61
5 Listen<br />
aus den Spaltenüberschriften wie in Abbildung 5.1 gezeigt aufklappbare Listenfelder.<br />
Ich habe in dieser Abbildung das Listenfeld »Geschlecht« geöffnet. Darüber können die<br />
Datensätze auf einfache Weise gefiltert werden. Würde man den Eintrag »W« wählen,<br />
erschienen nur noch die weiblichen Professoren, die männlichen wären ausgeblendet, aber<br />
nicht gelöscht. Über den Eintrag »Alle« kämen sie sofort wieder zum Vorschein. In der<br />
Online-Hilfe heißt es dazu:<br />
»Im Gegensatz zur Sortierfunktion wird die Liste beim Filtern nicht neu angeordnet.<br />
Durch das Filtern werden vorübergehend Zeilen ausgeblendet, die nicht angezeigt werden<br />
sollen. Die ausgefilterten Einträge werden also nicht gelöscht! Wenn <strong>Excel</strong> Zeilen filtert,<br />
können Sie die Listenuntermenge bearbeiten, formatieren, als Diagramm darstellen <strong>und</strong><br />
drucken, ohne sie neu anzuordnen oder zu verschieben.«<br />
Sie können über den Unterbefehl Autofilter des Befehls Filter die Listenfelder<br />
für die Spaltenüberschriften wieder entfernen. Dann verschwindet auch das Häkchen an<br />
diesem Unterbefehl wieder. Zunächst möchte ich aber den Listeneintrag »Benutzerdefiniert.<br />
. . « erklären. Drückt man diesen, erscheint wie an den Pünktchen gut zu erkennen<br />
ist, ein Dialog, den Microsoft Benutzerdefinierter AutoFilter getauft hat.<br />
5.5.1 Benutzerdefinierter Autofilter<br />
Abbildung 5.5: Ein benutzerdefinierter Autofilter<br />
Das Merkmal »Geschlecht« <strong>mit</strong> seinen nur zwei Ausprägungen gibt für diesen Dialog<br />
nicht viel her, daher habe ich ihn über das Feld »Gehalt« ausgewählt, wie Sie an der<br />
ersten Zeile des Dialogs erkennen können. Man darf für dieses Feld zwei Kriterien aufstellen<br />
<strong>und</strong> durch UND oder ODER verbinden. Ich habe festgelegt, dass nur Datensätze<br />
erscheinen, wo das Gehalt mindestens 3800 e erreicht, aber unterhalb von 4000 e bleibt.<br />
Danach kann man zu einem anderen Feld gehen <strong>und</strong> auf die gleiche Weise einen Autofilter<br />
für dieses Feld festlegen. Es werden dann nur noch diejenigen Zeilen gezeigt, die<br />
beiden Autofiltern entsprechen, die Verknüpfung von Autofiltern verschiedener Spalten<br />
ist also nur über das logische UND möglich, während innerhalb einer Spalte die beiden<br />
Bedingungen durch UND oder ODER verb<strong>und</strong>en werden dürfen.<br />
Doch wie heißt es so schön in den Verkaufssendungen des Fernsehens: »Wait, you get<br />
more«, <strong>und</strong> zwar Spezialfilter, die beliebige Verknüpfungen von Kriterien ermöglichen.<br />
62
5.6 Spezialfilter<br />
Wenn Sie ein weiteres Mal zur Abbildung 5.1 zurückblättern, werden Sie fünf Spezialfilter<br />
erkennen.<br />
5.6 Spezialfilter<br />
Haben Sie diese gef<strong>und</strong>en? Die ersten drei stehen in den Zeilen 11 <strong>und</strong> 12, die nächsten<br />
beiden in den Zellen 14 bis 16. Spezialfilter bestehen in der oberen Zeile aus mindestens<br />
einer Spaltenbeschriftung der Liste. Direkt darunter oder eine Zeile weiter stehen die für<br />
die Spalte festgelegt Bedingungen. Der Spezialfilter im Bereich A14:B15 hat den Inhalt<br />
FBR Geschlecht<br />
MaD M<br />
<strong>und</strong> lässt nur die Datensätze übrig, in denen das Feld »FBR« den Wert »MaD« hat<br />
<strong>und</strong> das Feld »Geschlecht« den Wert »M« hat, d.h. die beiden Bedingungen werden<br />
durch das logische UND verknüpft. Übrig bleiben die Herrschaften Bulletti, Schurigl,<br />
Lobedanz <strong>und</strong> Trauerwein. Man darf auf diese Weise beliebig viele Spalten <strong>mit</strong> Bedingungen<br />
versehen, wobei auch bestimmte Spalten öfter auftreten dürfen, wie im zweiten<br />
Kriterium, das im Bereich D11:E12 steht<br />
GebDat GebDat<br />
>=1.1.1950 =1.1.1950
5 Listen<br />
D14:E16 <strong>und</strong> lautet<br />
FBR Kinder<br />
5.7 Datenbank-Funktionen<br />
Der erste Parameter ist die Liste, der zweite bezieht sich auf die Spalte <strong>mit</strong> der Überschrift<br />
»Gehalt« <strong>und</strong> der dritte verweist auf den Spezialfilter $A$11:$B$12. Der Verweis<br />
auf die Spalte wäre auch durch die Zahl 8 oder über den Verweis auf die Zelle $H$1 <strong>mit</strong><br />
der Überschrift geglückt. Achten Sie aber auf die doppelten Anführungszeichen, wenn<br />
Sie die Spaltenbeschriftung als Text eingeben, also "Gehalt"<strong>und</strong> nicht Gehalt. Da der<br />
Filter $A$11:$B$12 die folgenden Datensätze<br />
Name Gehalt<br />
Bulletti 4.600<br />
Schurigl 4.800<br />
Lobedanz 4.700<br />
Trauerwein 6.000<br />
auswählt, liefert die DBANZAHL-Funktion gerade deren Anzahl von Zeilen zurück, hier<br />
also 4. In der Tabelle habe ich nur die erste <strong>und</strong> die achte Spalte berücksichtigt, die<br />
anderen spielen bei diesem Beispiel keine Rolle, da die Datenbankfunktionen sich immer<br />
auf die ausgewählte Spalte, hier als Gehalt, beziehen.<br />
Die leicht zu verstehenden Funktionen DBMIN, DBMAX <strong>und</strong> DBSUMME geben so<strong>mit</strong><br />
die Werte 4600, 6000 <strong>und</strong> 20100 zurück. Sie finden diese Werte <strong>und</strong> die zugehörige<br />
Eingabe in der Abbildung 5.1. In der Spalte <strong>mit</strong> der Überschrift Anzahl habe ich für alle<br />
fünf besprochenen Spezialfilter die Funktion DBANZAHL eingesetzt.<br />
5.7.1 Tabelle der Datenbank-Funktionen<br />
Die Online-Hilfe liefert folgende Liste der Datenbank-Funktionen<br />
65
5 Listen<br />
Name Beschreibung<br />
DBANZAHL Gibt die Anzahl von Zellen zurück, die in einer Datenbank<br />
Zahlen enthalten<br />
DBANZAHL2 Gibt die Anzahl nicht leerer Zellen in einer Datenbank zurück<br />
DBAUSZUG Extrahiert einen einzelnen Datensatz aus einer Datenbank, der<br />
dem angegebenen Kriterium entspricht<br />
DBMAX Gibt den maximalen Wert einer Reihe von ausgewählten Datenbankeinträgen<br />
zurück<br />
DBMIN Gibt den minimalen Wert einer Reihe von ausgewählten Datenbankeinträgen<br />
zurück<br />
DBMITTELWERT Gibt den Mittelwert ausgewählter Datenbankeinträge zurück<br />
DBPRODUKT Multipliziert die Werte in einem bestimmten Datensatzfeld, die<br />
<strong>mit</strong> dem Kriterium in einer Datenbank übereinstimmen<br />
DBSTABW Schätzt die Standardabweichung auf Basis einer Stichprobe<br />
ausgewählter Datenbankeinträge<br />
DBSTABWN Berechnet die Standardabweichung auf Basis einer Gr<strong>und</strong>gesamtheit<br />
von ausgewählten Datenbankeinträgen<br />
DBSUMME Addiert die Zahlen aus der betreffenden Feldspalte derjenigen<br />
Datensätze in der Datenbank, die den angegebenen Kriterien<br />
entsprechen<br />
DBVARIANZ Schätzt die Varianz, ausgehend von einer Stichprobe aus bestimmten<br />
Datenbankeinträgen<br />
DBVARIANZEN Berechnet die Varianz, ausgehend von der Gr<strong>und</strong>gesamtheit<br />
PIVOTDATEN<br />
ZUORDNEN<br />
66<br />
aus bestimmten Datenbankeinträgen<br />
Gibt die in einer PivotTable gespeicherten Daten zurück
6 Diagramme<br />
6.1 Vorrausetzungen<br />
Abbildung 6.1: Ein Säulendiagramm<br />
Um ein Diagramm zu erstellen, müssen zuerst die Daten für das Diagramm im Arbeitsblatt<br />
in Form einer Liste eingegeben werden. Meistens stehen die Datenreihen in<br />
Spalten, jede Spalte hat eine Überschrift <strong>und</strong> es gibt mehr Datensätze als Datenreihen.<br />
Man darf es aber auch genau umgekehrt anordnen, also die Überschriften in einer Spalte<br />
<strong>und</strong> die Datenreihen in Zeilen. Ich gehe davon aus, dass die Datenreihen in Spalten stehen.<br />
Die Einträge der ersten Spalte werden von <strong>Excel</strong> als Rubriken bezeichnet <strong>und</strong> auf<br />
der horizontalen Achse, also der x-Achse aufgetragen, während erst die nächsten Spalten<br />
als Datenreihen aufgefasst werden. Die in einer Zeile stehenden Werte der Rubrik <strong>und</strong><br />
der zugehörigen Datenreihe bilden die Datenpunkte. Diese werden je nach Diagrammtyp<br />
unterschiedlich dargestellt. <strong>Excel</strong> fasst die erste Spalte immer als Rubriken auf, wenn<br />
wie in der Abbildung 6.1 hier keine Überschrift vorhanden ist.<br />
Die Tabelle zeigt die Entwicklung eines <strong>mit</strong> 8% Jahreszins angelegten Anfangskapitals<br />
von 5000 e, die Verzinsung erfolgt in der Spalte I <strong>mit</strong> Zinseszinsen <strong>und</strong> in der Spalte J<br />
<strong>mit</strong> einfacher Verzinsung. Diese Tabelle soll nun grafisch dargestellt werden. Diagramme<br />
basieren also immer auf Listen.<br />
67
6 Diagramme<br />
6.2 Der Diagrammassistent<br />
Zunächst müssen Sie also immer die Daten markieren, die im Diagramm dargestellt werden<br />
sollen, in unserem Beispiel der Bereich H1:J11. Dann <strong>und</strong> rufen Sie den Diagramm-<br />
Assistenten auf, der Sie beim Prozess der Diagramm- <strong>und</strong> Optionenauswahl unterstützt.<br />
Der Diagramm-Assistent hat ein Symbol in der Symbolleiste Standard. Schauen Sie bitte<br />
auf die Abbildung 2.1, dort ist das Symbol für die Erstellung von Grafiken ausgewiesen.<br />
Mit einiger Phantasie stellt das Symbol eine Grafik <strong>mit</strong> Balkendiagramm dar. Über das<br />
Menü geht es über die Folge Einfügen/Diagramm.Sie kommen aber auch über die Befehlsfolge<br />
Einfügen|Diagramm. . . zum Ziel. Der Diagramm-Assistent erstellt das Bild<br />
über vier Dialoge, die Ergebnisse lassen sich nach eigenem Geschmack nachbearbeiten.<br />
Im ersten Schritt trifft man die Auswahl für den Typ <strong>und</strong> Untertyp, siehe Abbildung 6.2.<br />
Der Dialog des zweiten Schritts zeigt nochmals die abzubildende Datenreihe. Sie können<br />
Abbildung 6.2: Erster Schritt<br />
die Angaben übernehmen oder ändern. Dieser Dialog ist nicht abgebildet.<br />
Der Dialog des dritten Schritts zeigt eine Vorschau auf das Ergebnis. Außerdem müssen<br />
Sie eine Fülle von Entscheidungen treffen: Sie erkennen einen Dialog <strong>mit</strong> sechs Registern.<br />
Im Register Titel wird die Überschrift <strong>und</strong> die Achsenbeschriftungen bestimmt. Die<br />
anderen Register kann man übergehen, ich entscheide mich im Register Legende, die<br />
Legende rechts neben das Diagramm zu setzen. Da wir nur zwei Datenreihen haben,<br />
68
Abbildung 6.3: Der Diagrammassistent, Schritt 3<br />
6.3 Säulendiagramm<br />
besteht die Legende auch nur aus zwei Teilen, exp. <strong>und</strong> Linear, also den Überschriften<br />
der Datenreihen.<br />
Im vierten <strong>und</strong> letzten Schritt müssen Sie entscheiden, ob das Diagramm in einem<br />
eigenen Blatt erscheint oder als Teil des Tabellenblatts ist, von dem die Daten stammen.<br />
auch dieser Dialog ist nicht abgebildet.<br />
6.3 Säulendiagramm<br />
Bei einen Säulendiagramm werden die Datenpunkte als Säulen dargestellt. Diese Entscheidung<br />
ist im ersten Schritt zu treffen. Hat man mehrere Datenreihen, wie etwa in der<br />
Abbildung 6.1, so werden die Datenpunkte <strong>mit</strong> einer gemeinsamen Rubrik nebeneinander<br />
als Säulen dargestellt.<br />
Die Spalten- <strong>und</strong> Zeilenüberschriften der Liste werden in der so genannten eingeblendet,<br />
falls man dieses Features im dritten Schritt im Register Legende auswählt. Im obigen<br />
Beispiel sind die Jahreszahlen 1999 bis 2010 die Rubriken, die erste Datenreihe ist das<br />
<strong>mit</strong> 8% bei Zinseszinsen verzinste Kapital <strong>und</strong> die zweite Datenreihe besteht aus dem<br />
Kapital bei einfacher Verzinsung. Die Datenpunkte sind als Säulen dargestellt.<br />
6.4 Punktdiagramm<br />
Man kann die Daten aber auch als Punktdiagramm darstellen, dafür muss im ersten<br />
Schritt des Diagrammassistenten der Eintrag Punkt(XY) gewählt werden. Dieser Diagrammtyp<br />
hat 5 Untertypen, man kann die Punkte einfach nur anzeigen lassen, oder<br />
69
6 Diagramme<br />
durch Linien verbinden. Bei der Verbindung <strong>mit</strong> Linien kann man von <strong>Excel</strong> eine Interpolation<br />
durchführen lassen, dann werden die Datenreihen als Kurve dargestellt. Verzichtet<br />
man darauf, verbindet <strong>Excel</strong> die Datenpunkte <strong>mit</strong> Geradenstücken. In beiden Fällen<br />
kann man sich die Datenpunkte ein- oder ausblenden lassen. Ich wähle den Untertyp<br />
Punkte <strong>mit</strong> interpolierten Linien.<br />
6.5 Nachbereitung<br />
Abbildung 6.4: Ein Punktdiagramm<br />
Nur selten ist das Ergebnis richtig schön. Zum Glück lässt es sich aber vielfältig nachbearbeiten.<br />
Das Diagramm besteht aus einzelnen Objekten wie Diagrammtitel, Diagrammfläche,<br />
Zeichenfläche, Legende, Rubrikenachse, Größenachse <strong>und</strong> natürlich den<br />
Datenreihen selbst. Die Objekte erkennt man, wenn man <strong>mit</strong> der Maus darüber streicht.<br />
Gut zu erkennen in Abbildung 6.1 ist das Objekt Zeichnungsfläche. Diese Beschriftung<br />
taucht auf, wenn Sie <strong>mit</strong> der Maus über dem Objekt liegen. Klicken Sie jetzt <strong>mit</strong> der<br />
linken Maustaste, wird das Objekt von einem Rahmen umgeben, der insgesamt acht<br />
Ziehpunkte hat. Da<strong>mit</strong> lässt <strong>mit</strong> der linken Maustaste die Größe des Objekts verändern.<br />
Klickt man <strong>mit</strong> der rechten Maustaste in ein Objekt, erscheint das Kontextmenü <strong>mit</strong><br />
einer großen Auswahl an Gestaltungsmöglichkeiten. Bei der Diagrammfläche etwa kann<br />
man die Ecken abr<strong>und</strong>en, den Hintergr<strong>und</strong> einfärben <strong>und</strong> Fülleffekte erzielen, also fließende<br />
farbliche Übergänge von hell nach dunkel. Die Farbe <strong>und</strong> das Muster der Säulen<br />
lassen sich ebenfalls sehr leicht über das Kontextmenü der Datenreihen verändern.<br />
In der Abbildung 6.4 erkennnen Sie das Kontextmenü der Datenreihe. Dieses Kontextmenü<br />
führt über den Befehl Diagrammtyp zurück zum Schritt 1 des Diagrammassistenten<br />
<strong>und</strong> über den Befehl Datenreihe formatieren zum dritten Schritt. Außerdem<br />
kann man die Datenquelle neu einstellen. Der zzugehörige Dialog ist gerade der zweite<br />
Schritt des Diagrammassistenten.<br />
70
6.6 Histogramme als Punktdiagramm<br />
Ich bearbeite fast immer die Achsen nach. Dazu überstreiche ich die horizontale oder<br />
die vertikale Achse <strong>mit</strong> der Maus bis das kleine Fenster <strong>mit</strong> dem Inhalt Größenachse (X)<br />
bzw Größenachse (Y) erscheint. Klickt man jetzt die rechte Maustaste, öffnet sich ein<br />
umfangreicher Dialog zum Einstellen der Achsenansicht, also Schriftgröße, Skalierung<br />
<strong>und</strong> Farben.<br />
Durch Markieren <strong>und</strong> anwählen können Sie nun auch noch den Titel, die Legenden<br />
<strong>und</strong> die Rubriken ändern.<br />
6.6 Histogramme als Punktdiagramm<br />
Abbildung 6.5: Histogramm <strong>und</strong> Verteilungsfunktion<br />
Beispiel: Histogramm zur Illustration klassierter kardinaler Daten.<br />
Quelle Dr. Manuel Frondel. Kann Statistik Spaß machen.<br />
Abbildung 6.5 informiert in Spalte A über die Körpergröße von 20 Personen durch eine<br />
so genannte Urliste. Zur Informationsverdichtung wird die Stichprobe stetiger Merkmale<br />
meistens in Klassen eingeteilt, untere <strong>und</strong> obere Grenzen sowie die Breiten der Klassen<br />
sehen Sie in den Spalten C, D <strong>und</strong> E. In der Spalte F stehen die absoluten Häufigkeiten<br />
hi. Diese ergeben sich aus der Urliste durch Abzählen. <strong>Excel</strong> bietet für die Auszählung<br />
eine Matrix-Funktion an, die HÄUFIGKEIT-Funktion.<br />
71
6 Diagramme<br />
Diese Funktion benötigt als ersten Parameter einen Bezug auf die Urliste, hier also<br />
$A$2:$A$21. Der zweite Parameter ist der Bezug auf die Obergrenzen der Klassen, in<br />
diesem Beispiel $D$2:$D$6. Da die Funktion eine Matrix-Funktion ist, wird zunächst<br />
der Ausgabebereich, hier also F2:F6 markiert <strong>und</strong> dann ins Eingabefeld<br />
=HÄUFIGKEIT($A$2:$A$21;$D$2:$D$6)<br />
geschrieben. Achten Sie auf die Eingabe als Matrix-Formel, also Strg + Umschalt +<br />
Eingabe drücken.<br />
Aus den absoluten Häufigkeiten folgen durch Division durch die Stichprobengröße n,<br />
hier also 20, die relativen Häufigkeiten fi = hi/n.<br />
6.6.1 Histogramm <strong>und</strong> Verteilungsfunktion<br />
Die Abbildung 6.5 zeigt ein so genanntes Histogramm, das die relative Häufigkeitsverteilung<br />
für das Merkmal Körpergröße wiedergibt <strong>und</strong> die zugehörige Verteilungsfunktion.<br />
Das Histogramm besteht aus Rechtecken, deren Breiten die Klassenbreiten ∆i <strong>und</strong> deren<br />
Flächeninhalte die relativen Häufigkeiten fi sind Also muss auf der Ordinate (der<br />
y-Achse) die sogenannte Dichte<br />
di = fi<br />
abgetragen werden. Die Fläche des i-ten Rechtecks, welche sich aus (Klassen-)Breite ∆i<br />
mal Höhe di ergibt, ist so<strong>mit</strong> immer identisch <strong>mit</strong> der relativen Häufigkeit fi für diese<br />
Klasse. Die Summe aller Rechtecke ist so<strong>mit</strong> 1.<br />
Hat man wie hier die Stichprobe durch k Klassen dargestellt, ergeben sich die so genannten<br />
kumulierten relativen Häufigkeiten Fi aus der Summe der relativen Häufigkeiten<br />
für die Klassen 1 bis i. So<strong>mit</strong> gilt<br />
F0 = f0<br />
∆i<br />
Fi = fi + Fi−1 i = 1 . . . k<br />
Da die Summe der relativen Häufigkeiten 1 ist, gilt so<strong>mit</strong> Fk = 1. Die kumulierte relative<br />
Häufigkeit Fi wird der oberen Grenze OGi der i-ten Klasse , <strong>und</strong> F0 der unteren Grenze<br />
UG1 der ersten Klasse zugeordnet. Diese k+1 Punkte (UG1, F0), (OG1, F1) bis (OGk, Fk)<br />
stellen die Eckpunkte des sogenannten Verteilungspolygons dar.<br />
Stellt man Histogramm <strong>und</strong> Verteilungsfunktion in einem gemeinsamen Diagramm<br />
dar, ist das Ergebnis bescheiden, da die Verteilungsfunktion viel geringere Werte als<br />
das Histogramm hat. Es wäre schön, wenn man eine zweiten Achse hinzufügen könnte.<br />
Daran haben auch die Entwickler von <strong>Excel</strong> gedacht.<br />
6.7 Sek<strong>und</strong>ärachse<br />
Wenn der Wertebereich der verschiedenen Datenreihen in einem 2D-Diagramm stark<br />
variiert oder das Diagramm unterschiedliche Datentypen enthält (z. B. Preis <strong>und</strong> An-<br />
72
6.7 Sek<strong>und</strong>ärachse<br />
zahl), können Sie eine oder mehrere Datenreihen auf einer sek<strong>und</strong>ären Größenachse (für<br />
den Wert Y) darstellen. Die Skalierung der Sek<strong>und</strong>ärachse entspricht den Werten der<br />
verb<strong>und</strong>enen Datenreihe.<br />
1. Klicken Sie auf die Datenreihe, die Sie auf einer sek<strong>und</strong>ären Größenachse darstellen<br />
möchten.<br />
2. Klicken Sie im Menü Format auf Markierte Datenreihen <strong>und</strong> dann auf die<br />
Registerkarte Achsen. Im Kontextmenü erscheint der Befehl Markierte Datenreihen<br />
ebenfalls, wenn eine Datenreihe ausgewählt ist.<br />
3. Klicken Sie auf Sek<strong>und</strong>ärachse.<br />
In Zelle B3 steht<br />
Abbildung 6.6: Primär- <strong>und</strong> Sek<strong>und</strong>ärachse<br />
=SVERWEIS(B1;Gehälter!A2:G9;6;FALSCH)<br />
73
6 Diagramme<br />
Ein- oder Ausblenden von Gitternetzlinien in einem Diagramm Klicken Sie auf das<br />
Diagramm, dem Sie Gitternetzlinien (Gitternetzlinien in Diagrammen: Linien, die Sie einem<br />
Diagramm hinzufügen können, um die Darstellung übersichtlicher zu gestalten <strong>und</strong><br />
die Auswertung von Daten zu erleichtern. Gitternetzlinien reichen von den Teilstrichen<br />
auf einer Achse über die Zeichnungsfläche.) hinzufügen möchten. Klicken Sie im Menü<br />
Diagramm auf Diagrammoptionen <strong>und</strong> dann auf die Registerkarte Gitternetzlinien. (Entspricht<br />
Schritt 3 des Assistenten) Aktivieren bzw. deaktivieren Sie die Kontrollkästchen<br />
für die einzublendenden oder auszublendenden Gitternetzlinien.<br />
74
7 Aufgaben<br />
Aufgabe 1. Erstellen Sie das abgebildete Arbeitsblatt. Dabei soll der Bierumsatz monatlich<br />
um 20% steigen, wobei immer auf die nächst kleinere Zahl abger<strong>und</strong>et wird. Den<br />
Verlauf der Limonade sollten Sie erkennen <strong>und</strong> sich dann noch den Zusammenhang <strong>mit</strong><br />
dem Gewinn überlegen. Die Gewinnspalte stellen Sie bitte als Matrixformel dar.<br />
Bei den Datums- <strong>und</strong> Zeitberechnungen soll der Anwender sein Geburtsdatum eingeben<br />
können <strong>und</strong> dann die Anzahl der gelebten Tage <strong>und</strong> sein Lebensalter erfahren.<br />
Weiter soll in der gezeigten Zelle immer die aktuelle Zeit erscheinen, wobei der Anwender<br />
allerdings die F9-Taste betätigen muss.<br />
Abbildung 7.1: Aufgabe 1<br />
Aufgabe 2. In einer psychologischen Untersuchung haben 20 Personen eine Denksportaufgabe<br />
zu lösen. Der Zeitaufwand wurde registriert <strong>und</strong> in folgende Klassen eingeteilt:<br />
Zeitaufwand in min 1-5 5-7 7-9 9-10 10-12 12-16<br />
Absolute Häufigkeit 4 4 3 3 2 4<br />
Zeichnen Sie das Histogramm <strong>und</strong> die Verteilungsfunktion. Bestimmen Sie den Median<br />
75
7 Aufgaben<br />
<strong>und</strong> die 25% bzw. 75%-Quantile. Alles soll natürlich <strong>Excel</strong> übernehmen.<br />
Aufgabe 3. Für die Einzelhandelsunternehmen (EHU) eines kleinen B<strong>und</strong>eslandes S<br />
sei folgende Übersicht betrachtet:<br />
Umsatz in Anzahl fi Fi Umsatz Umsatz<br />
1000 DM der EHU<br />
gesamt kumuliert<br />
[0, 10) 200<br />
[10, 50) 300 9000<br />
[50, 100) 250<br />
[100, 300) 250 1 78750 1<br />
Summen 1 78750<br />
Berechnen Sie die fehlenden Werte <strong>und</strong> zeichnen dann bitte die Lorenzkurve, also die<br />
Verbindung der Punkte ((0, 0), (Fi, Qi)). Welchen Anteil am Gesamtumsatz haben 25%<br />
bzw. 75% der EHU?<br />
Aufgabe 4. Es ist der optimale Standort für einen Flugplatz gesucht, von dem aus<br />
die sechs Flugplätze A bis F angeflogen werden. Optimal sei derjenige Standort, für den<br />
die Summe der täglich zurückzulegenden Flugkilometer minimal ist. Als Entfernung ist<br />
jeweils die Luftlinie anzunehmen. In der Abbildung 7.2 sind für jeden der Orte A bis F<br />
die Zahl der Füge zu dem neuen Flugplatz sowie die Ortskoordinaten (x, y) angegeben.<br />
Nicht geeignet für den Flugplatz sind ein durch die Bedingung x + y ≥ 250 definiertes<br />
Sumpfgebiet sowie ein See, dessen Fläche durch die Bedingung (x−100) 2 +x−100) 2 ≤ 400<br />
beschrieben ist. Fertigen Sie die Skizze wie abgebildet an.<br />
76<br />
Abbildung 7.2: Daten zur Aufgabe 4<br />
Qi
Aufgabe 5. Zu maximieren sei G = x + 3y u. d. Nb. x · y ≤ 4, x 2 · y ≤ 16, 2x − 2y ≤ 7,<br />
−2x + 2y ≤ −3. Außerdem sollen x, y ≥ 0 sein. Skizzieren Sie <strong>mit</strong> <strong>Excel</strong> die Nebenbedingungen<br />
<strong>und</strong> lassen Sie den Solver das Maximum finden. Das vom Solver in meinem<br />
Skript gelöste Problem hat die exakte Lösung x = 81/13 <strong>und</strong> y = 324/117. Wie<br />
kann man das einsehen?<br />
Aufgabe 6. Bei einer statistischen Untersuchung erreichten die Teilnehmer bei einem<br />
Intelligenztest folgende Werte: 15, 16, 14, 16, 14, 16, 18, 15, 14, 17, 16 <strong>und</strong> 15. Bei der<br />
Vergabe von Rangzahlen wird der kleinsten Beobachtung der Rang 1 <strong>und</strong> der größten<br />
Beobachtung der Rang n, also der Stichprobenumfang gegeben. Kommen Beobachtungen<br />
mehrfach vor (so genannte Bindungen), wird jedem der <strong>mit</strong>tlere Rang zugeordnet.<br />
Mehr zu Rangzahlen: Schuchmann, Sanns, Nichtparametrische Statistik <strong>mit</strong> Mathematica.<br />
Bestimmen Sie <strong>mit</strong> <strong>Excel</strong> die Rangzahlen der obigen Beobachtung. <strong>Excel</strong> kann<br />
Sortieren (Daten|Sortieren) <strong>und</strong> kennt auch Ränge, vergibt aber nicht das arithmetische<br />
Mittel, sondern blah, blah, finden Sie es selbst heraus. Welche Summe haben die<br />
korrekten Rangzahlen? Bestimmen Sie dann die Rangzahlen der Urliste von Abbildung<br />
7.5 des Skripts.<br />
Aufgabe 7. Gegeben seien die Matrizen L <strong>und</strong> R <strong>mit</strong> Berechnen Sie <strong>mit</strong> <strong>Excel</strong> die<br />
Matrizen wie im Bild <strong>und</strong> zusätzlich (A T ) −1 . Warum sind die Komponenten aller Matrizen<br />
ganzzahlig?<br />
Aufgabe 8. In meinem Ordner liegt die <strong>Excel</strong>datei eeedat.xls. Beenden Sie die Abrechnungen<br />
der Gehälter wie im Skript beschrieben. Berechnen Sie auch noch die Nettogehälter.<br />
Zunächst müssen Sie <strong>mit</strong> Hilfe der SVERWEIS-Funktion die Gesamtgebühren-Spalte<br />
77
7 Aufgaben<br />
berechnen. Er<strong>mit</strong>teln Sie <strong>mit</strong> einer Datenbankfunktion die Gesamtsumme an Gebühren,<br />
die im WS 2004 durch die Vorlesungen C <strong>und</strong> Financial Computing zusammen erzielt<br />
wurden <strong>und</strong> die Gesamtsumme an Gebühren, die im WS 2004 vom Studiengang M durch<br />
die Kurse in C eingenommen wurden. Stellen Sie dann noch das Bruttogehalt <strong>und</strong> das<br />
Hörergeld als Säulendiagramm dar. Die Prof. bilden die Rubriken. Richten Sie eine Sek<strong>und</strong>ärachse<br />
ein.<br />
Aufgabe 9. Bezogen auf die Gehaltsliste der EEE geben Sie die Filter für folgende<br />
Teillisten an <strong>und</strong> er<strong>mit</strong>teln die Ergebnisse.<br />
78<br />
1. Alle Professoren des FBR MaD, die mindestens ein Kind haben <strong>und</strong> deren Gr<strong>und</strong>gehalt<br />
4700 e übersteigt.<br />
2. Die Vereinigung aller nach dem 1.1.1950 geborenen Professoren des FBR SuF <strong>mit</strong><br />
den Professoren, die genau ein Kind haben.
8 Die Entwicklungsumgebung von<br />
Visual Basic<br />
<strong>VBA</strong> ist eine leistungsfähige Skriptsprache, die zur Erweiterung der Möglichkeiten der<br />
Microsoft-Office-Anwendungen wie <strong>Excel</strong>, Word oder Access entwickelt wurde. <strong>VBA</strong><br />
hat eine eigene Entwicklungsumgebung, die <strong>mit</strong> dem zugehörigen Wirtsprogramm zusammen<br />
ausgeliefert wird. <strong>VBA</strong> ist eine Skriptsprache, deren Anweisungen zeilenweise<br />
interpretiert werden. Deshalb ist <strong>VBA</strong> im Vergleich zu C oder Fortran sehr langsam, also<br />
nicht für aufwendige mathematische Algorithmen geeignet. <strong>VBA</strong> dient der Automatisierung<br />
von wiederholt durchzuführenden Aufgaben, kann aber auch die Fähigkeiten von<br />
Office-Programmen beträchtlich erweitern.<br />
8.1 Überblick<br />
<strong>VBA</strong> erfüllt vier Aufgaben<br />
• Makroaufzeichnen<br />
• Erstellen von Sub-Prozeduren<br />
• Erstellen von Formularen<br />
• Erstellen von Funktionen<br />
8.2 Makroaufzeichnen<br />
Eine der Fähigkeiten von <strong>VBA</strong> ist die Automatisierung von Routineaufgaben. Sorgen<br />
Sie bitte zunächst dafür, dass die Symbolleiste Visual Basic zu sehen ist. In der ersten<br />
Abbildung dieses Kapitels befindet sich diese Symbolleiste links oben. Über das entsprechende<br />
Symbol wird die Makroaufzeichnung gestartet. Sie können auch die Befehlsfolge<br />
Extras|Makros|Aufzeichnen. . . verwenden. Es öffnet sich der Dialog, der in der<br />
Abbildung links unten zu sehen ist. Sie müssen sich für einen Namen entscheiden, können<br />
aber auch den vorgeschlagenen Bezeichner übernehmen. <strong>Excel</strong> zählt die Makros<br />
dann einfach durch. Außerdem kann dem Makro wie zu sehen ist ein Tastaturkürzel<br />
zugewiesen werden.<br />
Die Symbolleiste rechts ist die Werkzeugleiste, in der alle Steuerelemente von <strong>VBA</strong><br />
versammelt sind. Darauf komme ich bei der Besprechung der Formulare zurück.<br />
79
8 Die Entwicklungsumgebung von Visual Basic<br />
Abbildung 8.1: Symbolleisten für <strong>VBA</strong><br />
Sobald Sie im Dialog Makro aufzeichnen auf OK drücken, verwandelt sich der Kreis<br />
des Symbols Aufzeichnen. . . in ein Quadrat, wo<strong>mit</strong> die Aufzeichnung wieder beendet<br />
werden kann. Zur Sicherheit erscheint auch noch das kleine Dialogfeld, das ich zwischen<br />
den Symbolleisten abgebildet habe, wo<strong>mit</strong> die Aufzeichnung über das Quadrat ebenfalls<br />
beendet werden kann. Aber dazu ist es noch zu früh, wir haben ja noch gar nicht<br />
begonnen.<br />
Ich hab folgende Aktionen durchgeführt, bevor ich die Aufzeichnung stoppte:<br />
1. In der noch unbearbeiteten Arbeitsmappe Mappe1 habe ich die dritte Tabelle<br />
markiert <strong>und</strong> über das Kontextmenü gelöscht.<br />
2. Dann habe ich die erste Tabelle markiert <strong>und</strong> in die Zelle A1 »Hallo!« eingegeben.<br />
3. Abschließend habe ich die neue Mappe unter dem Namen Makrotest im Verzeichnis<br />
C:\ gespeichert.<br />
<strong>Excel</strong> hat alles getreulich ausgeführt <strong>und</strong> der Makrorecorder hat den in der Abbildung<br />
8.2 zu sehenden Code aufgezeichnet. Der Code befindet sich innerhalb der Entwicklungsumgebung<br />
von Visual Basic. Wie Sie dorthin gelangen, zeige ich gleich.<br />
80
8.3 Der Visual Basic Editor<br />
8.3 Der Visual Basic Editor<br />
Wenn Sie alles nachgemacht haben, werden Sie sicher den Code suchen. Dazu müssen<br />
Sie den Visual Basic Editor öffnen. Dafür haben Sie drei Möglichkeiten:<br />
1. Über die Befehlsfolge Extras|Makros|Visual Basic Editor. . .<br />
2. Über die Tastenkombination Alt + F11<br />
3. Über das Symbol Visual Basic Editor der Symbolleiste.<br />
Visual Basic erscheint dann in der folgenden klassischen Dreiteilung: Links oben ist<br />
der Projekt-Explorer zu sehen, darunter das Eigenschaftsfenster <strong>und</strong> rechts von beiden<br />
das Arbeitsfenster zum Anzeigen von Code <strong>und</strong>/oder Formularen.<br />
Sollte das Eigenschaftsfenster nicht vorhanden sein, müssen Sie F4 drücken oder den<br />
entsprechenden Befehl des Menüs Ansicht wählen. Sollte der Projekt-Explorer nicht<br />
vorhanden sein, müssen Sie Strg + R drücken oder den entsprechenden Befehl des Menüs<br />
Ansicht wählen. Zwischen den drei Fenstern befinden sich Trennbalken, worüber Sie<br />
die Größen der einzelnen Fenster festlegen können.<br />
Abbildung 8.2: Der Visual Basic Editor<br />
Aus der Entwicklungsumgebeung von <strong>VBA</strong> gelangen Sie ebenfalls über die Tastenkombination<br />
Alt + F11 zurück nach <strong>Excel</strong> oder über den Befehl des Menüs Ansicht.<br />
81
8 Die Entwicklungsumgebung von Visual Basic<br />
8.3.1 Der Projekt-Explorer<br />
Der Projekt-Explorer zeigt wie der Windows-Explorer eine hierarchische Liste der Projekte<br />
<strong>und</strong> aller Elemente an, die in den jeweiligen Projekten enthalten sind. Die Elemente<br />
befinden sich im Listenfenster, das einen Überblick über die Arbeitsmappen, Tabellen,<br />
Module <strong>und</strong> Formulare des Projekts gibt. Zu jedem Listenelement kann Code geschrieben<br />
werden.<br />
Objektorientiert gesehen steht das Programm <strong>Excel</strong> an der Spitze der Hierarchie. <strong>Excel</strong><br />
verwaltet Arbeitsmappen, diese bestehen aus Tabellenblättern. Zu jedem Objekt<br />
kann man <strong>VBA</strong>-Code bereitstellen. Zusätzlich kann weiterer Code in so genannten Modulen<br />
abgelegt werden. Im Projekt-Explorer sind die Bestandteile aufgeführt, rechts<br />
daneben befindet sich das Code-Fenster zum Erstellen des Codes. Die Auswahl zum<br />
Bearbeiten erfolgt durch einfachen Doppelklick (kleiner Scherz) im Listenfenster des<br />
Projekt-Explorers.<br />
Oberhalb des Listenfensters befinden sich drei Symbole. Über das Symbol rechts können<br />
die Objektordner ein- bzw. ausgeblendet werden, während die darin enthaltenen<br />
Objekte weiterhin angezeigt werden.<br />
Das Symbol links aktiviert das Code-Fenster, während das Symbol in der Mitte das<br />
Objekt selbst zeigt. Das Code-Fenster öffnet sich auch über die Taste F7 <strong>und</strong> das Objekt<br />
selber wird angezeigt durch Umschalt + F7. Bei der Bearbeitung von Formularen kann<br />
man auf diese Weise zwischen der Erstellung des Formulars <strong>und</strong> der Erzeugung des<br />
Codes hin- <strong>und</strong> herschalten. Bei <strong>Excel</strong>-Objekten führt das <strong>mit</strong>tlere Symbol bzw. die<br />
Tastenkombination Umschalt + F7 zurück zum <strong>Excel</strong>-Fenster.<br />
In der Abbildung 8.2 ist das Listenelement Modul1 unter dem Ordner Module aktiviert.<br />
Module enthalten Visual Basic Code <strong>und</strong> deshalb existiert hierzu kein Objekt,<br />
das <strong>mit</strong>tlere Symbol ist deaktiviert. Im rechten Fenster, dem so genannten Code-Fenster<br />
befindet sich der vom Makrorecorder erzeugte Code.<br />
8.3.2 Das Code-Fenster<br />
Das Code-Fenster erscheint wie erwähnt bei Objekten durch Auswahl des Objekts im<br />
Listenfenster des Projekt-Explorers <strong>und</strong> Klicken des Symbols Code anzeigen. Man kann<br />
aber auch die Taste F7 drücken oder im Menü Ansicht den Befehl Code wählen.<br />
Im Code-Fenster wird der Visual Basic-Code erstellt <strong>und</strong> bearbeitet. Sie können so<br />
viele Code-Fenster öffnen wie Module vorhanden sind, sodass der Code auf einfache<br />
Weise in verschiedenen Formularen oder Modulen angezeigt <strong>und</strong> zwischen diesen kopiert<br />
<strong>und</strong> eingefügt werden kann. Über das Menü Fenster lassen sich die geöffneten Fenster<br />
anordnen. Sobald ein Fenster im Vollbild ist, überdeckt es alle übrigen Fenster.<br />
Über dem Code-Fenster können Sie zwei Dropdown-Listenfelder erkennen, das linke<br />
wird Objekt, das rechte Prozedur genannt. Bei Formularen sind die Objekte die<br />
Steuerelemente <strong>und</strong> die Prozeduren die zum ausgewählten Steuerelement vorhandenen<br />
Ereignisse. Die Prozeduren sind alphabetisch nach Namen sortiert. Durch Auswahl einer<br />
Prozedur wird der Cursor in deren erste Code-Zeile positioniert.<br />
Bei Formularen sind die Namen der Ereignisprozeduren nicht frei wählbar, sondern<br />
82
8.3 Der Visual Basic Editor<br />
setzen sich aus dem Namen des Steuerelements <strong>und</strong> dem Ereignis zusammen, etwa<br />
CommandButton1_Click()für die Ereignisprozedur Klicken einer Schaltfläche diesen<br />
Namens.<br />
Wenn bei Modulen (Allgemein) im Feld Objekt angezeigt wird, werden im Feld Prozedur<br />
alle Deklarationen <strong>und</strong> allgemeinen Prozeduren, die für dieses Formular erstellt<br />
wurden, aufgeführt.<br />
8.3.3 Module<br />
Der Makrorecorder hat den Code in einem so genannten Modul gespeichert. Der Code<br />
selber ist eine so genannte Sub-Prozedur. Sie dürfen weitere Sub-Prozeduren im bisherigen<br />
oder in neuen Modulen schreiben. Ein Modul sollte in der Regel Sub-Prozeduren<br />
eines bestimmten Aufgabenbereichs enthalten. Ein neues Modul wird vom Visual Basic<br />
Editor über die Befehlsfolge Einfügen|Modul angelegt. Das neue Modul enthält<br />
zunächst keine Sub-Prozeduren. Ich werde jetzt zeigen, wie eine solche erstellt wird.<br />
8.3.4 Sub-Prozeduren<br />
Ich gehe davon aus, dass Sie wie beschrieben ein neues Modul angelegt haben. Den<br />
vom Editor vorgeschlagenen Namen Modul2 können Sie übernehmen. Jede Sub-Prozedur<br />
beginnt <strong>mit</strong> der Anweisung Sub IrgendeinName(), worauf der Editor selbst das<br />
abschließende End Sub ergänzt. Zwischen diese beiden Anweisungen kommt dann der<br />
eigentliche Code. Ich möchte die gelöschte Tabelle Tabelle3 neu erstellen, verzichte aber<br />
auf den Recorder, sondern rate den Code:<br />
Sub NeuesBlatt()<br />
Sheets.Add<br />
ActiveSheet.Name = "Tabelle3"<br />
End Sub<br />
Zu Ihrer Erleichterung muss ich erwähnen, dass Sie <strong>mit</strong> Ihren bisherigen Vorkenntnissen<br />
diesen Code keineswegs raten können. Wenn Sie es nachvollziehen, sollte nach der Eingabe<br />
von Sheets. ein Listenfeld <strong>mit</strong> allen Methoden des Objekts Sheets erscheinen.<br />
Sie müssen dem Editor aber eine Chance geben <strong>und</strong> nach dem Punkt eine Pause einlegen.<br />
Mit etwas Englisch, Erfahrung <strong>und</strong> Phantasie werden Sie oft die passende Methode<br />
für Ihre Absicht finden.<br />
WWW Beachten Sie bitte, dass jede Sub-Anweisung ein leeres Klammernpaar nach<br />
dem Namen enthalten muss, also Sub NeuesBlatt() <strong>und</strong> nicht Sub NeuesBlatt.<br />
8.3.5 Ausführen von Sub-Prozeduren<br />
»Eine Sub-Prozedur ist eine Folge von Visual Basic-Anweisungen, die in den Anweisungen<br />
Sub <strong>und</strong> End Sub eingeschlossen sind <strong>und</strong> Aktionen ausführen, aber keinen Wert<br />
zurückgeben.« heißt es so schön in der Online-Hilfe.<br />
83
8 Die Entwicklungsumgebung von Visual Basic<br />
Eine Sub-Prozedur kann auf mehreren Wegen ausgeführt werden. Am einfachsten ist<br />
es, wenn der Cursor noch im Code der Sub-Prozedur ist. Dann genügt es, die F5-Taste<br />
zu drücken. Sie können aber auch den längeren Weg über die Befehlsfolge Ausführen|Sub/UserForm<br />
ausführen gehen.<br />
Auch in <strong>Excel</strong> können Sie Sub-Prozeduren aufrufen, <strong>und</strong> zwar über die Befehlsfolge<br />
Extra|Makro|Makros. . . oder die Tastenkombination Alt + F8. Dann erscheint<br />
eine Liste aller erstellten Makros, in unserem Fall also die beiden Makros Makro1<strong>und</strong><br />
NeuesBlatt.<br />
HHH Es werden nur Sub-Prozeduren aufgeführt, die keine Argumente haben.<br />
8.3.6 Laufzeitfehler<br />
Schon diese beiden einfachen Sub-Prozeduren habe ihre Tücken, man kann keine zweimal<br />
hintereinander ausführen! Denn die Sub-Prozedur Makro1 löscht die Tabelle Tabelle3<br />
<strong>und</strong> dann fehlt diese zum erneuten Löschen. Sie müssten also zuvor die Sub-<br />
Prozedur NeuesBlatt() aufrufen, wodurch die verschw<strong>und</strong>ene Tabelle wiederkommt.<br />
Aber auch NeuesBlatt() kann nicht zweimal hintereinander aufgerufen werden, da<br />
<strong>Excel</strong> nicht zwei Tabellen gleichen Namens duldet. Sollten Sie es aber trotzdem versuchen,<br />
wehrt sich der Interpreter <strong>mit</strong> der garstigen Fehlermeldung von Abbildung 8.3. Sie<br />
Abbildung 8.3: Eine Fehlermeldung<br />
können jetzt verzagt die Schaltfläche Beenden drücken oder sich über Debuggen mutig<br />
dem begangenen Fehler stellen.<br />
84<br />
Abbildung 8.4: Der Visual Basic Editor <strong>mit</strong> fehlerhafter Anweisung
8.4 Formulare<br />
Der Editor hat die beanstandete Anweisung gelb unterlegt. Das Menü Ausführen<br />
zeigt die verbliebenen Möglichkeiten. Sie können die Sub-Prozedur fortsetzen, was aber<br />
selten gelingt, oder beenden. Sie brauchen dabei nicht den Umweg über das Menüsystem<br />
gehen, sondern können auch direkt die entsprechenden Symbole verwenden. Wenn Sie<br />
sich für Beenden entscheiden, hebt der Editor die häßliche gelbe Untermalung wieder<br />
auf. Sie können die Fehler beheben <strong>und</strong> es erneut probieren. Zuvor aber müssen Sie die<br />
Tabelle Tabelle3 aber löschen oder umbenennen, sonst gibt’s wieder Ärger.<br />
8.3.7 Funktionen<br />
Funktionen spielen in <strong>Excel</strong> eine große Rolle. Zu den vorhandenen dürfen Sie jederzeit<br />
eigene Funktionen erstellen. Genau wie bei Sub-Prozeduren ist ein Modul nötig, um den<br />
Code aufzunehmen. Ich verwende dafür Modul2 <strong>und</strong> erstelle als Beispiel die folgende<br />
atemberaubende Funktion:<br />
Function Addieren(ByVal a as Long, ByVal b as Long)<br />
Addieren = a + b<br />
End Function<br />
Das Schlüsselwort Sub ist Function gewichen. Außerdem haben Funktionen i.a. Parameter,<br />
hier a <strong>und</strong> b, aus denen das Ergebnis gebildet wird. Das Ergebnis befindet<br />
sich immer in der Variablen, die den Namen der Funktion trägt.<br />
Die erstellte Funktion taucht in <strong>Excel</strong> beim Funktionsassistent unter der Kategorie<br />
benutzerdefiniert auf. Sie können aber auch direkt in eine Zelle =Addieren(12;13) eingeben<br />
<strong>und</strong> erhalten 25 als Ergebnis. Funktionen <strong>und</strong> Sub-Prozeduren werden später näher<br />
behandelt, hier soll es nur um das Editieren gehen.<br />
WWW In <strong>VBA</strong> müssen Sie die Parameter von Funktionen <strong>mit</strong> Kommas, in <strong>Excel</strong> aber<br />
<strong>mit</strong> Semikolons trennen.<br />
8.4 Formulare<br />
Formulare sind aus Anwendungsprogrammen, die unter Windows laufen, nicht mehr weg<br />
zu denken. Sie werden in verschiedenen Situationen von der Anwendung eingeblendet,<br />
um bestimmte Informationen vom vom Benutzer einzuholen. Formulare sind standardisiert<br />
<strong>und</strong> werden aus Steuerelementen aufgebaut. Die bekanntesten Steuerelemente sind<br />
Schaltflächen, sowei Text- <strong>und</strong> Eingabefelder. Fast genauso wichtig sind Listenfelder,<br />
Optionsfelder <strong>und</strong> Kontrollkästchen.<br />
8.4.1 Aufgabenstellung<br />
In der Abbildung 8.5 ist das Formular zu sehen, das erstellt werden soll. Es soll auftauchen,<br />
sobald die erste Tabelle aktiviert wird <strong>und</strong> wieder verschwinden, wenn eine<br />
andere Tabelle gezeigt wird. Das Textfeld soll beim Erscheinen des Formulars den Inhalt<br />
der Zelle A1 der ersten Tabelle anzeigen. Der Anwender kann im Textfeld diesen Inhalt<br />
85
8 Die Entwicklungsumgebung von Visual Basic<br />
verändern. Durch Drücken der Schaltfläche wird der neue Inhalt dann in der Zelle A1<br />
übernommen. Das ist keine sinnvolle Aufgabe für ein Formular, der eigentliche Zweck<br />
ist die Demonstration der gr<strong>und</strong>sätzlichen Vorgehensweise.<br />
8.4.2 Erstellen von Formularen<br />
Formulare sind komplizierter als Module. Microsoft bezeichnet sie als Userform oder<br />
Benutzerformular. Ich werde meistens bei der Bezeichnung Formular oder Dialogfeld<br />
bleiben.<br />
Wechseln Sie über Alt+F11 nach Visual Basic <strong>und</strong> stellen dort den Entwurfsmodus<br />
her. Jedem Formular ist in <strong>VBA</strong> ein UserForm-Objekt zugeordnet, das innerhalb der<br />
Entwicklungsumgebung von <strong>VBA</strong> durch die Befehlsfolge Einfügen|UserForm erzeugt<br />
wird.<br />
Dann öffnet sich das so genannte UserForm-Fenster <strong>mit</strong> dem noch jungfräulichen Formular<br />
<strong>und</strong> der Werkzeugsammlung (Toolbox), so wie in der Abbildung 8.5 zu erkennen.<br />
Allerdings ist dieses Formular bereits <strong>mit</strong> Steuerelementen besiedelt, wie das geht, wird<br />
gleich gezeigt. Die Toolbox ist frei verschiebbar <strong>und</strong> entspricht der Symbolleiste Werk-<br />
Abbildung 8.5: Der Visual Basic Editor<br />
zeugsammlung, die in Abbildung 8.1 rechts zu sehen ist. Dort finden Sie auch die Beschreibung<br />
der einzelnen Symbole, sofern Sie deren Bedeutung nicht ohnehin erkennen.<br />
Die Funktionen einiger Steuerelemente werde ich kurz beschreiben.<br />
86
8.4 Formulare<br />
Für einfache Ja/Nein-Entscheidungen sind die viereckigen Kontrollkästchen zuständig,<br />
durch Anklicken erscheint oder verschwindet ein Kreuz oder Häkchen. Listenfelder<br />
lassen aus mehreren Möglichkeiten ein Feld auswählen. Die Wahl aus einer Menge sich<br />
gegenseitig ausschließenden Optionen bietet auch eine Gruppe von Optionsfeldern, die<br />
im Gegensatz zu den Kontrollkästchen <strong>mit</strong> r<strong>und</strong>en Feldern erscheinen. Eingaben geschehen<br />
in einzeiligen <strong>und</strong> mehrzeiligen Textfeldern, die aber auch für Eingaben deaktiviert<br />
werden können <strong>und</strong> dann ausschließlich der Textausgabe dienen. Die meist grau dargestellten<br />
Schaltflächen lösen bestimmte Aktionen aus.<br />
8.4.3 Einfügen von Steuerelementen in ein Formular<br />
Um nun ein Steuerelement auf einem Formular abzulegen, muss in der Werkzeugsammlung<br />
das zugehörige Symbol angeklickt werden. Der Mauszeiger nimmt die Form eines<br />
Kreuzes an. An geeigneter Stelle wird dann im Formular ein Rahmen gezogen, worin<br />
dann das Steuerelement erscheint. Anschließend passen Sie Größe <strong>und</strong> Form des Steuerelements<br />
unter Verwendung eines seiner Ziehpunkte nach Ihren Wünschen an. Jedes<br />
Steuerelemnt hat acht Ziehpunkte. Diese erscheinen, sobald das Steuerelement aktiviert<br />
wird. In der Abbildung 8.5 ist das Formular selbst ausgewählt, von seinen acht Ziehpunkten<br />
sind nur fünf zu sehen, die drei rechten liegen unter der Toolbox. Ich habe auf<br />
diese Weise von links nach rechts dem Formular ein Bezeichnungsfeld, ein Textfeld <strong>und</strong><br />
eine Schaltfläche hinzugefügt. Die Feineinstellung des Erscheinungsbilds erfolgt in einem<br />
Fenster, dem Eigenschaftenfenster.<br />
8.4.4 Eigenschaften von Steuerelementen<br />
Ein Steuerelement ist ausgewählt, wenn es <strong>mit</strong> den Ziehpunkten <strong>und</strong> den gepunkteten<br />
Rahmen erscheint. Dann erscheinen die Eigenschaften des aktivierten Steuerelements im<br />
Eigenschaftenfenster. Sollte das nicht der Fall sein, müssen Sie die F4-Taste drücken. In<br />
der Abbildung 8.5 ist das Formular selbst ausgewählt. Eigenschaften bestimmen Aussehen<br />
wie Größe, Farbe, Font <strong>und</strong> Bildschirmposition sowie Zustände, wie aktiviert oder<br />
deaktiviert. Das Eigenschaftenfenster zeigt die gewählten Eigenschaften. Ganz oben steht<br />
das ausgewählte Steuerelement, in meinem Beispiel UserForm1. Über das Listenfeld<br />
können alle anderen Steuerelemente des aktiven Formulars angezeigt <strong>und</strong> ausgewählt<br />
werden.<br />
Die Eigenschaften werden entweder alphabetisch oder nach Kategorien angezeigt. Das<br />
lässt sich über die beiden Registerkarten steuern. Wenn Sie sich die Eigenschaften nach<br />
Kategorien anzeigen lassen, können Sie über Pluszeichen(+) <strong>und</strong> Minuszeichen(-) die<br />
Liste einer Kategorie ein- <strong>und</strong> ausblenden.<br />
Die Eigenschafteneinstellung wird durch Auswahl des Eigenschaftennamens rechts <strong>und</strong><br />
Eingabe oder Auswahl der neuen Einstellung links geändert.<br />
87
8 Die Entwicklungsumgebung von Visual Basic<br />
8.4.5 Wichtige Eigenschaften<br />
Die wichtigste Eigenschaft überhaupt ist die Eigenschaft Name. Über diese Eigenschaft<br />
wird das Steuerelement im Code identifiziert.<br />
Der Standardwert von Name besteht bei Objekten aus dem Klassennamen des Objekts,<br />
gefolgt von einer ganzen Zahl. Der Standardname für das erste Textfeld, Klassenname<br />
TextBox, das Sie auf einem Formular anlegen, ist z. B. TextBox1. Der Standardname<br />
für das zweite Textfeld-Steuerelement ist TextBox2. Genauso verhält es sich<br />
<strong>mit</strong> allen anderen Steuerelementen, Bezeichnungsfelder, deren Klassenname Label ist,<br />
haben z.B. die Standardnamen Label1, Label2 usw. Sie dürfen diese Namen zur Entwurfszeit<br />
ändern, aber nicht mehr zur Laufzeit. Das unterscheidet diese Eigenschaft von<br />
allen anderen Eigenschaften.<br />
Die Eigenschaft Name wird leicht <strong>mit</strong> der Eigenschaft Caption verwechselt, da<br />
auch diese Eigenschaft zunächst <strong>mit</strong> dem Klassenname des Objekts, gefolgt von einer<br />
ganzen Zahl, vorbesetzt wird. Die Eigenschaft Caption haben u.a. Schaltflächen, Bezeichnungsfelder<br />
<strong>und</strong> Formulare. Bei Schaltflächen <strong>und</strong> Bezeichnungsfeldern wird da<strong>mit</strong><br />
die Beschriftung festgelegt <strong>und</strong> bei Formularen der Fenstertitel. In der Abbildung 8.2 habe<br />
ich über diese Eigenschaft den Titel von UserForm1 in Testformular umgeändert.<br />
Auch die Beschriftungen der Schaltfläche <strong>und</strong> des Bezeichnungsfeldes habe ich so verändert.<br />
Die Namen habe ich dagegen übernommen, so<strong>mit</strong> heißen die drei Steuerelemente<br />
von links nach rechts Label, TextBox1 <strong>und</strong> CommandButton1 nach den englischen<br />
Klassennamen.<br />
Die dritte bedeutende Eigenschaft heißt Value. Diese gibt den Zustand oder Inhalt<br />
des Steuerelements an. Bei einem Textfeld ist dies der Text im Bearbeitungsbereich. Bei<br />
einem Kontrollkästchen <strong>und</strong> einem Optionsfeld hat Value den Wert -1 bzw. True, wenn<br />
das Element ausgewählt ist, <strong>und</strong> sonst den Wert 0 oder False.<br />
Über die Eigenschaften Top, Left, Width <strong>und</strong> Height können Sie die Steuerelemente<br />
pixelgenau auf dem Formular platzieren. Diese Eigenschaften bestimmen die<br />
obere linke Ecke sowie Breite <strong>und</strong> Höhe des Steuerelements. Die obere linke Ecke des<br />
Formulars selbst hat die Werte 0 für Left <strong>und</strong> Top.<br />
8.4.6 Ereignisse von Steuerelementen<br />
Ein Ereignis (engl. event) dient bei Formularen zur Steuerung des Programmablaufes.<br />
In <strong>VBA</strong> sind für jedes Steuerelement Ereignisse vorgesehen, die bestimmten Aktionen<br />
des Benutzers wie Klicken oder Drücken einer Taste entsprechen. Zu jedem Ereignis gibt<br />
es eine Ereignisbehandlungsroutine, die immer dann ausgeführt wird, wenn das Ereignis<br />
auftritt. Die beiden wichtigsten Ereignisse heißen in <strong>VBA</strong> Click <strong>und</strong> Change. Die zugeordnete<br />
Ereignisbehandlungsroutine setzt sich aus dem Namen des Steuerelements <strong>und</strong><br />
dem Ereignis zusammen. Dieser Bezeichner darf nicht verändert werden. Kein Programmierer<br />
kann die Art <strong>und</strong> die Reihenfolge der Ereignisse vorhersehen, er muss trotzdem<br />
für alle Fälle gewappnet sein. Die Kunst der ereignisorientierten Programmierung besteht<br />
darin, alle möglichen Ereignisse <strong>und</strong> Systemzustände vorherzusehen <strong>und</strong> immer<br />
die richtige Antwort aus dem Ärmel zu ziehen. Alle Programme <strong>mit</strong> grafischer Ober-<br />
88
8.4 Formulare<br />
fläche, speziell alle Windowsprogramme, sind ereignisorientiert, aber auch die meisten<br />
Steuerprogramme für technische Prozesse <strong>und</strong> Anlagen.<br />
Formulare gelten auch als Steuerelement. Das wichtigste Ereignis ist Initialize. Es tritt<br />
un<strong>mit</strong>telbar bevor das Formular erscheint ein. Daher wird in der zugehörigen Ereignisbehandlungsroutine<br />
das Formular <strong>mit</strong> sinnvollen werten vorbesetzt.<br />
8.4.7 Ereignisse <strong>und</strong> Eigenschaften des Programms<br />
Das Formular besteht aus vier Objekten, dem Formular selbst <strong>und</strong> den drei Steuerelementen.<br />
Von links nach rechts sind dies ein Bezeichnungsfeld, ein Textfeld <strong>und</strong> eine<br />
Schaltfläche.<br />
Ein Bezeichnungsfeld wird auf englisch Label genannt. Es zeigt in der Regel einen<br />
statischen Text, der andere Steuerelemente beschreibt, wie hier das Eingabefeld. Die<br />
Einstellung des Beschriftung erfolgt über die Caption-Eigenschaft. Bezeichnungsfelder<br />
lösen in der Regel keine Ereignisse aus.<br />
Ein Textfeld, englisch TextBox, dient der Eingabe des Benutzers, kann aber auch zur<br />
Ausgabe verwendet werden. Textfelder sind dynamisch. Ihre Standardeigenschaft ist die<br />
Value-Eigenschaft. Das Standardereignis für Textfelder ist das Change-Ereignis.<br />
Schaltflächen sind fast auf jedem Formular vorhanden. Ihr Standardereignis ist das<br />
Click-Ereignis, die wichtigste Eigenschaft ist Caption, um die Beschriftung festzulegen.<br />
Ich habe alle Namen übernommen, also UserForm1, Label1, TextBox1 <strong>und</strong> CommandButton1.<br />
Dann habe ich die Caption-Eigenschaft des Formulars, der Schaltfläche <strong>und</strong> des Bezeichnungsfelds<br />
verändert. Beim Formular entspricht Caption dem Titel, bei den beiden<br />
Steuerelementen der Beschriftung.<br />
Ich habe beim Formular die Eigenschaft ShowModal auf False gesetzt.<br />
Formulare erscheinen standardmäßig, d.h. beim Wert False für die Eigenschaft Show-<br />
Modal, als modale Pop-up-Fenster vor dem Hauptfenster der Anwendung, d. h. der<br />
Benutzer kann in den anderen Fenstern derselben Anwendung nicht weiterarbeiten, solange<br />
das Formular angezeigt wird. Hier möchte ich aber, dass der Anwender die Tabellen<br />
bearbeiten kann, auch wenn der der Dialog geöfnet ist.<br />
Schon diese einfache Programm benötigt vier Ereignisbehandlungsroutinen. Das Formular<br />
selbst kommt <strong>mit</strong> zwei aus, <strong>und</strong> zwar das Click-Ereignis der Schaltfläche <strong>und</strong> das<br />
Initialize-Ereignis des Formulars.<br />
Die Tabelle Tabelle1 sorgt für die beiden weiteren Ereignisse. Ja, Sie lesen richtig,<br />
auch Tabellen sind Auslöser von Ereignissen, <strong>und</strong> zwar Activate <strong>und</strong> Deactivate.<br />
8.4.8 Die Tabellenereignisse<br />
Ereignisse werden durch Ereignisbehandlungsroutinen beantwortet, also durch Code.<br />
Klicken Sie innerhalb des Projekt-Explorers doppelt auf den Eintrag Tabelle1. Es erscheint<br />
wieder das Code-Fenster, wählen Sie im linken Listenfeld den Eintrag Worksheet<br />
<strong>und</strong> rechts Activate. Dann erscheint im Code-Fenster eine Basisversion der zugehörigen<br />
89
8 Die Entwicklungsumgebung von Visual Basic<br />
Ereignisbehandlungsroutine. Ich musste nur eine einzige Anweisung hinzufügen, vgl. dazu<br />
Abbildung 8.6<br />
Abbildung 8.6: Das Code-Fenster der Tabelle1<br />
Das Ereignis Activate tritt immer ein, wenn die entsprechende Tabelle aktiviert wird.<br />
Dann soll über die Methode Show der Dialog erscheinen <strong>und</strong> sich durch die Methode Hide<br />
diskret zurückziehen, wenn die Tabelle Tabelle1 nicht mehr ausgewählt ist. Diese wird<br />
aufgerufen, wenn die Tabelle Tabelle1 nicht mehr aktiv ist, weil eine andere ausgewählt<br />
wurde. Das entsprechende Ereignis ist Deactivate. Der Code der beiden Ereignisbehandlungsroutinen<br />
ist ebenfalls in der Abbildung 8.6 zu sehen.<br />
Achten Sie jetzt noch einmal genau auf das Fenster des Projekt-Explorers. Die Tabelle<br />
Tabelle1 ist hervorgehoben <strong>und</strong> das Symbol für Code ganz links ist gedrückt. Im Codefenster<br />
sind im linken Listenfeld der Eintrag Worksheet <strong>und</strong> im rechten das Ereignis<br />
Activate ausgewählt. Der Wechsel zum Formular geschieht im Listenfeld des Projekt-<br />
Explorers durch Auswahl des Eintrags UserForm1. Dann wird zunächst das Formular<br />
erscheinen. Durch Drücken der F7-Taste oder des Symbols Code anzeigen im Projekt-<br />
Explorer öffnet sich das Code-Fenster für das Formular.<br />
TTT Der Arbeitsbereich für Code- <strong>und</strong> Userform ist ein so genanntes MDI-Fenster,<br />
in dem mehrere Fenster gleichzeitig geöffnet werden können, z.B. mehrere Code-Fenster,<br />
aber auch wie in Abbildung 8.5 sowohl das Code- als auch das Userform-Fenster eines<br />
Formulars. Sie erreichen dies durch die üblichen Windowstechnikem über den Menüpunkt<br />
Fenster.<br />
8.4.9 Die Formulareignisse<br />
Wenn Sie Vollbilder bevorzugen, erfolgt die Umschaltung zwischen Userform- <strong>und</strong> Code-<br />
Fenster über die beiden Symbole im Projekt-Explorer oder durch die Taste F7 für Code<br />
<strong>und</strong> Umschalt + F7 für die Userform.<br />
Auch im Codefenster eines Formulars befinden sich oben zwei Listenfelder, wobei links<br />
alle Steuerelemente des Formulars <strong>und</strong> das Formular selbst unter UserForm erscheint.<br />
90
8.5 Eigenschaften, Methoden <strong>und</strong> Ereignisse<br />
In dem Listenfeld rechts sind alle Ereignisse aufgeführt, worauf das links ausgewählte<br />
Steuerelement über Ereignusbehandlungsroutinen antworten kann, natürlich über Visual<br />
Basic Code. Bei Formularen reagiert man meistens nur auf das Ereignis Initialize, das<br />
eintritt, wenn das Formular neu erstellt wird <strong>und</strong> die Steuerelemente des Formulars in<br />
einen vernünftigen Ausgangszustand gebracht werden sollen.<br />
Mein Code ist in Abbildung 8.5 zu erkennen. Über die Eigenschaft Value erhält das<br />
Textfeld den Inhalt der Zelle A1 der Tabelle Tabelle1.<br />
Die Umkehrung erfolgt über das Click-Ereignis der Schaltfläche. Zunächst muss die<br />
Tabelle Tabelle1 aktiviert werden <strong>und</strong> danach erhält die Zelle A1 über die Eigenschaft<br />
Value als Wert den Inhalt des Textfeldes.<br />
8.4.10 Test des Codes<br />
Beenden Sie zunächst über das entsprechende Symbol den Entwurfsmodus <strong>und</strong> wechseln<br />
über Alt+ F11 zurück nach <strong>Excel</strong>. Jedesmal, wenn Sie die erste Tabelle auswählen,<br />
sollte das Formular erscheinen <strong>und</strong> wieder verschwinden, wenn eine andere Tabelle erscheint.<br />
Auch der Austausch der Werte zwischen dem Formular <strong>und</strong> der Zelle A1 sollte<br />
reibungslos klappen.<br />
8.5 Eigenschaften, Methoden <strong>und</strong> Ereignisse<br />
Nachdem Sie nun mnit der Entwicklungsumgebung von Visual Basic vertraut sind, möchte<br />
ich ein das Beispiel noch ein wenig ausbauen, um die Prinzipien der objekt- <strong>und</strong><br />
ereignisorientierten Programmierung zu erläutern.<br />
8.5.1 Objekte<br />
Steuerelemente sind Objekte, die über Eigenschaften, Ereignisse <strong>und</strong> Methoden verfügen.<br />
Weitere Objekte in <strong>VBA</strong> sind Programme wie <strong>Excel</strong>, Arbeitsmappen, Tabellen oder<br />
Grafiken. Nicht alle Objekte lösen Ereignisse aus, aber alle Objekte haben Eigenschaften<br />
<strong>und</strong> Methoden. Die Gesamtheit aller gleichartigen Objekte wird als Klasse bezeichnet.<br />
Die Schaltflächen bilden z.B. die Klasse CommandButton <strong>und</strong> die Textfelder die Klasse<br />
TextBox. Der Zustand <strong>und</strong> das Aussehen des Objekts wird durch seine Eigenschaften,<br />
die Aktivitäten des Objekts wird durch die Menge seiner Operationen beschrieben. Diese<br />
Operationen nennt man Methoden.<br />
8.5.2 Eigenschaften <strong>und</strong> Methoden<br />
Eigenschaft wie z.B. die Eigenschaft Caption werden durch Variablen realisiert. Der Wert<br />
der Eigenschaft kann während der Entwicklungszeit gesetzt werden <strong>und</strong> darf im Programm<br />
jederzeit verändert werden. Die Beschriftung der Schaltfläche namens CmdBtn<br />
wird durch folgende Anweisung geändert:<br />
CmdBtn.Caption = "Bitte, bitte drück mich!"<br />
91
8 Die Entwicklungsumgebung von Visual Basic<br />
Methoden sind Fähigkeiten <strong>und</strong> Aktionen, die von den Objekten ausgeführt werden. Einer<br />
Methode entspricht also immer eine Prozedur, also ausführbarer Code. Eine Schaltfläche<br />
kann sich auf dem Formular <strong>mit</strong> Hilfe der Methode Move bewegen, Ein Formular<br />
kann sich über die Methode Hide verbergen <strong>und</strong> ein Tabellenblatt löscht sich über die<br />
Methode Delete selbst aus. Jedes Objekt vefügt über eine klar abgegrenzte Zahl von Eigenschaften<br />
<strong>und</strong> Methoden, daher spricht man von objektorientierter Programmierung.<br />
Der Zugriff auf eine Eigenschaft oder eine Methode erfolgt lesend <strong>und</strong> schreibend durch<br />
den Namen des Objekts <strong>und</strong> den Namen der der Eigenschaft bzw. der Methode, wobei<br />
Objektname <strong>und</strong> Eigenschafts- bzw. Methodenname durch einen Punkt voneinander<br />
getrennt werden. Da Methoden Prozeduren sind, können sie Argumente haben, die in<br />
<strong>VBA</strong> ohne Klammern (!) durch Kommas getrennt aufgelistet werden. Beispiele:<br />
CmdBtn.Move CmdBtn.Left + 10, CmdBtn.Top + 20<br />
UserForm1.Hide<br />
Sheets("Tabelle3).Delete<br />
In der ersten Anweisung ist Move eine Methode <strong>und</strong> Left <strong>und</strong> Top sind sowohl Eigenschaften<br />
der Schaltfläche als auch Übergabeparameter an die Methode.<br />
Hinweis<br />
Der Code-Editor zeigt alle Eigenschaften <strong>und</strong> Methoden eines Steuerelements in einer<br />
Listbox, wenn man den Namen <strong>und</strong> den anschließenden Punkt wie CommandButton1.<br />
schreibt <strong>und</strong> dann kurz verharrt. Wenn Sie den Anfangsbuchstaben der gewünschten<br />
Eigenschaft oder Methode kennen <strong>und</strong> eingeben, springt die Listbox an diese Stelle. Sie<br />
können die gewünschte Eigenschaft/Methode markieren <strong>und</strong> deren Bezeichner durch<br />
Drücken der Tab-Taste in das Codefenster übernehmen.<br />
Der Code-Editor zeigt alle Eigenschaften <strong>und</strong> Methoden eines Steuerelements in einer<br />
Listbox, wenn man den Namen <strong>und</strong> den anschließenden Punkt wie CommandButton1.<br />
schreibt <strong>und</strong> dann kurz verharrt. Wenn Sie den Anfangsbuchstaben der gewünschten<br />
Eigenschaft oder Methode kennen <strong>und</strong> eingeben, springt die Listbox an diese Stelle.<br />
Sie können die gewünschte Eigenschaft/Methode markieren <strong>und</strong> deren Bezeichner durch<br />
Drücken der Tab-Taste in das Codefenster übernehmen.<br />
8.5.3 Unterschied zwischen Ereignissen <strong>und</strong> Methoden<br />
Ereignisse werden im Gegensatz von Methoden vom Benutzer ausgelöst, etwa Maustaste<br />
drücken oder loslassen oder Eingaben über die Tastatur. Ereignisse stehen immer <strong>mit</strong><br />
den Steuerelementen einer UserForm in Zusammenhang. Aber auch Arbeits- <strong>und</strong> Arbeitsblätter<br />
lösen Ereignisse aus, etwa das Aktivieren <strong>und</strong> Deaktivieren eines Blattes<br />
oder das Laden oder Speichern einer Mappe.<br />
Ereignisse werden vom Betriebssystem registriert <strong>und</strong> nach Auswertung an die zuständigen<br />
Programme zur Verarbeitung weitergeleitet. Daher muss das betroffene Programm,<br />
92
8.5 Eigenschaften, Methoden <strong>und</strong> Ereignisse<br />
das Ereignis <strong>mit</strong> einem Prozedur verknüpfen, dei so genannte Ereignisbehandlungsprozedur,<br />
auf englisch de event handler. Im Gegensatz zu den bereits von <strong>Excel</strong> programmierten<br />
Methoden müssen die Ereignisbehandlungsprozeduren selbst geschrieben werden.<br />
Diese sind bei Steuerelementen objektorientiert gesehen Methoden des Formulars <strong>und</strong><br />
nicht des Steuerelements, also gehört zwar das Ereignis zum Steuerelement, aber die<br />
Ereignisbehandlungsprozedur zum Formular.<br />
8.5.4 Steuerelemente auf Tabellen<br />
Sie können auch auf Tabellen Steuerelemente einfügen. Dazu muss die Symbolleiste Visual<br />
Basic geöffnet sein. Darauf befindet sich das Symbol für die Toolbox, worüber diese<br />
geöffnet wird. Sie können diese Symbolleiste auch durch den Befehl Ansicht| Symbolleisten<br />
<strong>und</strong> Klicken von Steuerelement-Toolbox erhalten. Sie können jetzt Steuerele-<br />
Abbildung 8.7: Tabelle <strong>mit</strong> Steuerelement<br />
mente genau wie bei Formularen auf die Tabelle ziehen. Sobald Sie das tun, ändert sich<br />
der Zustand des Symbols Entwurfsansicht von inaktiv zum aktiv. Die Steuerelemente<br />
werden in diesem Zustand bearbeitet, können aber nicht verwendet werden. Die Umschaltung<br />
erfolgt über dieses Symbol, dann sind die Steuerelemente zum Einsatz bereit.<br />
Das wichtige Symbol ist in der Abbildung 8.7 zu sehen. Es befindet sich sowohl auf der<br />
Werkzeugleiste als auch auf der Symbolleiste Visual Basic. Wenn Sie im Entwurfszustand<br />
sind <strong>und</strong> ein Steuerelement anklicken, erscheint es <strong>mit</strong> seinen acht Ziehpunkten.<br />
Wenn Sie nur die Beschriftung eines Steuerelements ändern wollen, klicken Sie bitte<br />
<strong>mit</strong> der rechten Maustaste auf das Steuerelement <strong>und</strong> wählen Steuerelement-<br />
Objekt| Bearbeiten.<br />
Wenn Sie andere Eigenschaften bearbeiten wollen, klicken Sie zunächst <strong>mit</strong> der rechten<br />
Maustaste auf das Steuerelement, <strong>und</strong> klicken dann im Kontextmenü auf Eigenschaften.<br />
Es öffnet sich das Eigenschaftenfenster <strong>mit</strong> der Liste der Eigenschaften. Die<br />
Beschriftung ändern Sie über die Eigenschaft Caption, den Namen legen Sie über die<br />
Eigenschaft Name fest. Ich habe auf der Tabelle der Abbildung 8.7 eine Schaltfläche<br />
eingefügt <strong>und</strong> ihr den Namen CmdBtn gegeben.<br />
93
8 Die Entwicklungsumgebung von Visual Basic<br />
Im Codefenster der Tabelle, in der Steuerelemente eingefügt wurden, tauchen diese<br />
in der linken Listbox Objekt auf. Betrachten Sie bitte noch einmal die Abbildung 8.6,<br />
wo das Codefenster der Tabelle Tabelle1 geöffnet ist. Der Code zun Click-Ereignis der<br />
Schaltfläche CmdBtn ist auch zu sehen. Es wird da<strong>mit</strong> eine Form namens Demoform über<br />
deren Show-Methode gezeigt. Um von Visual Basic wieder zu <strong>Excel</strong> zu wechseln, klicken<br />
Sie im Menü Datei auf Beenden oder geben Alt+F11 ein. In <strong>Excel</strong> müssen Sie den<br />
Entwurfsmodus beenden, indem Sie auf das mehrfach erwähnte Symbol Entwurfsmodus<br />
beenden drücken.<br />
8.5.5 Listen- <strong>und</strong> Kombinationsfelder<br />
Das neue Formular besteht aus einer Schaltfläche <strong>und</strong> einem Kombinationsfeld. Ich habe<br />
ein Kombinationsfeld ausgewählt, weil sich daran schön die Merkmale von Eigenschaften,<br />
Methoden <strong>und</strong> Ereignisse darstellen lassen.<br />
Kombinationsfelder sind leicht <strong>mit</strong> Listenfelder zu verwechseln. Die Symbole sind auf<br />
der Werkzeugleiste benachbart. Ein reines Listenfeld zeigt eine Liste von Werten an,<br />
aus der man einen oder mehrere Werte auswählen kann. Die Standardeigenschaft für<br />
das Listenfeld-Steuerelement ist die Value-Eigenschaft. Deren Inhalt ist der ausgewählte<br />
Wert, in Abbildung 8.7 hat Value den Wert Birne. Der Klassenname der Listenfelder ist<br />
ListBox.<br />
Ein Kombinationsfeld kombiniert die Merkmale eines Textfeldes <strong>und</strong> eines Listenfeldes.<br />
Der Benutzer kann entweder einen neuen Wert wie in ein Textfeld eingeben oder<br />
einen vorhandenen Wert wie bei einem Listenfeld auswählen. Der Klassenname der Kombinationsfelder<br />
ist ComboBox.<br />
Man kann Kombinationsfelder aber auch als reine Dropdown-Listenfelder verwenden,<br />
wenn man die Werte auf die in der Liste enthaltenen Einträge beschränken möchte. Dazu<br />
muss wie abgebildet die Style-Eigenschaft des Kombinationsfelds auf den Wert fmStyleDropDownList<br />
setzen. Dann öffnet sich das Kombinationsfeld über den Pfeil rechts.<br />
In einem Kombinationsfeld, das als Dropdownlistenfeld entworfen wird, kann kein Text<br />
abgelegt werden. Das Standardereignis für Listen- <strong>und</strong> Kombinationsfelder ist das Click-<br />
94<br />
Abbildung 8.8: Das Formular DemoForm
8.5 Eigenschaften, Methoden <strong>und</strong> Ereignisse<br />
Ereignis, genauso wichtig ist das Change-Ereignis, das von einem Wechsel innerhalb der<br />
Liste von Werten ausgelöst wird. Da<strong>mit</strong> wird automatisch auch die Value-Eigenschaft<br />
verändert. Es kommt dabei nicht darauf an, ob die Veränderung durch das Ausführen<br />
von Code oder durch eine Benutzeraktion über die Benutzeroberfläche ausgelöst wurde.<br />
Listen- <strong>und</strong> Kombinationsfelder haben einige sinnvolle Methoden zum Erstellen <strong>und</strong><br />
Bearbeiten der Liste von Werten. Die AddItem-Methode fügt der Liste ein Element<br />
hinzu. Der Prototyp lautet<br />
object_name.AddItem [ item [, varIndex]]<br />
wobei das Argument item der hinzuzufügende Wert ist <strong>und</strong> varIndex die Position innerhalb<br />
der Liste angibt. Fehlt dieses Argument, wird der neue Wert am Ende der Liste<br />
angefügt.<br />
Die Clear-Methode löscht bei einem Listen- oder Kombinationsfeld alle Werte.<br />
Die Eigenschaft ListCount gibt die Anzahl der Listenelemente im angegebenen Listenoder<br />
Kombinationsfeld zurück. Es handelt sich dabei um einen schreibgeschützten Long-<br />
Wert. Im Beispiel der Abbildung 8.7 hat ListCount den Wert 3.<br />
Die Eigenschaft ListIndex gibt die Indexnummer des aktuell markierten Elements in<br />
einem Listenfeld oder einem Kombinationsfeld zurück oder legt sie fest. Long-Wert <strong>mit</strong><br />
Lese-/Schreibzugriff. Dabei wird von 0 angefangen zu zählen, d.h. der oberste Eintrag<br />
hat den Wert 0, der unterste den Wert ListCount-1.<br />
8.5.6 Qualifizierte Bezeichner<br />
Aus objektorientierter Sicht ist ein Steuerelement, das einer Tabelle oder einem Formular<br />
hinzugefügt wurde, eine Eigenschaft dieser Tabelle oder dieses Formulars. Daher<br />
dürfen auch Schaltflächen denselben Bezeichner, etwa CommandButton1, haben, wenn<br />
sie auf unterschiedlichen Objekten platziert sind. In meinem Beispiel haben die Formulare<br />
UserForm1 <strong>und</strong> das in Abbildung 8.7 dargestellte DemoForm je eine Schaltfläche<br />
CommandButton1. Innerhalb des Codes von UserForm1 genügt es, den Bezeichner<br />
CommandButton1 zu verwenden, von außen, etwa im Code einer Tabelle, muss dem<br />
Bezeichner der Name des Formulars vorangestellt werden. Dies nennt man qualifizierte<br />
Bezeichner.<br />
Beispiel: Nach Aktivieren der Tabelle Tabelle2 sollen die Bezeichnunmgen der beiden<br />
Schaltflächen auf englisch erscheinen, also von »Verändern« auf »Change« <strong>und</strong> von<br />
»Verschieben« auf »Move« wechseln. Sinnvoller wäre es, eine solche Aktion durch eine<br />
Schaltfläche oder einen Menüpunkt zu veranlassen. Der Code lautet:<br />
Private Sub Worksheet_Activate()<br />
UserForm1.CommandButton1.Caption = "Change"<br />
DemoForm.CommandButton1.Caption = "Move"<br />
End Sub<br />
Dieser Code muss im Codefenster von Tabelle2 eingetragen werden. Wirksam wird der<br />
Code nur, wenn zunächst beide Formulare geschlossen werden <strong>und</strong> danach zu Tabelle2<br />
gewechselt wird, um deren Ereignis Activate auszulösen.<br />
95
8 Die Entwicklungsumgebung von Visual Basic<br />
8.5.7 Die With-Anweisung<br />
Objektorientierte Programmierung zieht also längliche Anweisungen nach sich, da immer<br />
der Namen des Objekts vor der Eigenschaft oder Methode stehen muss. Die With-<br />
Kontrollstruktur erleichtert dem Programmierer das Leben, <strong>und</strong> mir erleichtert die Online-<br />
Hilfe die nähere Erklärung:<br />
Mit der With-Anweisung können Sie eine Reihe von Anweisungen für ein bestimmtes<br />
Objekt ausführen, ohne den Namen des Objekts mehrmals angeben zu müssen. Wenn Sie<br />
zum Beispiel mehrere Eigenschaften eines bestimmten Objekts verändern möchten, sollten<br />
Sie die Zuweisungsanweisungen für die Eigenschaft in einer With-Kontrollstruktur<br />
unterbringen. Sie brauchen dann den Namen des Objekts nicht bei jeder einzelnen Zuweisung,<br />
sondern nur einmal zu Beginn der Kontrollstruktur anzugeben.<br />
Als Beispiel verwende ich die With-Anweisung im Initialize-Ereignis des Formulars<br />
DemoForm:<br />
Private Sub UserForm_Initialize()<br />
With ComboBox1<br />
.AddItem "Birne"<br />
.AddItem "Banane"<br />
.AddItem "Melone"<br />
.ListIndex = 0<br />
End With<br />
End Sub<br />
Das Kombinatiosfeld hat drei Werte. Da die Methode AddItem immer hinten anfügt,<br />
wenn keine Position bestimmt wird, steht »Birne« oben <strong>und</strong> »Melone« unten.<br />
8.5.8 Das Formular DemoForm<br />
Das neue Formular wird in folgenden Schritten erstellt:<br />
1. Wechsel zu Visual Basic durch Alt+F11.<br />
2. Befehl Einfügen|UserForm.<br />
3. Umbenennen des Namens von UserForm2 in DemoForm über die Name-Eigenschaft<br />
des Formulars.<br />
4. Ändern des Titels von UserForm2 in Eigenschaften, Methoden <strong>und</strong> Ereignisse über<br />
die Caption-Eigenschaft des Formulars.<br />
5. Einfügen des Kombinationsfelds. Setzen der Style-Eigenschaft auf den Wert fmStyleDropDownList.<br />
6. Einfügen der Schaltfläche. Änderung der Beschriftung von CommandButton1 in<br />
Verschieben über die Caption-Eigenschaft der Schaltfläche.<br />
Nun benötigen wir noch den Code der Ereignisse.<br />
96
8.5.9 Der Code des Formulars DemoForm<br />
8.6 Meldungsfelder<br />
Wechseln Sie nun über die Taste F7 oder über das Symbol im Projekt-Explorer in das<br />
Codefenster des Formulars. Erstellen Sie zunächst den Code zum Ereignis Initialize wie<br />
beschrieben. Wählen Sie dann im geöffneten Listenfeld Objekt wie in Abbildung 8.9<br />
das Kombinationsfeld <strong>und</strong> klicken im Listenfeld Prozedur rechts daneben das Ereignis<br />
Change. Jeder Wechsel der Auswahl ändert die Value-Eigenschaft des Kombinationsfelds<br />
Abbildung 8.9: Der Code zum Formular DemoForm<br />
<strong>und</strong> llöst das Change-Ereignis aus. Über ein Meldungsfenster wird die Auswahl angezeigt.<br />
Mehr zu Meldungsfenster im nächsten Abschnitt.<br />
Die Anzahl der Werte im Kombinationsfeld möchte ich ebenfalls über ein Meldungsfenster<br />
zeigen, <strong>und</strong> zwar beim Verlassen des Kombinationsfelds. Das löst das Exit-<br />
Ereignis aus. Sie brauchen dafür nur die Schaltfläche anzuklicken. Die Ereignisbehandlungsprozedur<br />
des Exit-Ereignis hat einen Parameter Cancel, dessen voreingestellter<br />
Wert False ist. Wenn die Ereignisbehandlungsprozedur diesen Wert auf True verändert,<br />
bleibt der Focus auf dem entsprechenden Steuerelement. Da<strong>mit</strong> sollten Sie vorsichtig<br />
sein, da sonst eventuell das ganze Formular nie zu schließen ist.<br />
Die Schaltfläche verschiebt das Kombinationsfeld um 20 Pixel nach rechts <strong>und</strong> um 10<br />
Pixel nach unten.<br />
8.6 Meldungsfelder<br />
Über die MsgBox-Funktion wird eine Meldung in einem Dialogfeld gezeigt. Der Dialog<br />
besteht aus verschiedenen Schaltflächen wie OK, Abbrechen usw. auf eine Schaltfläche<br />
klickt. Der Rückgabewert der Funktion zeigt an, auf welche Schaltfläche der Benutzer<br />
geklickt hat. Im einfachsten Fall erscheint nur eine Meldung <strong>und</strong> nur die Schaltfläche OK<br />
97
8 Die Entwicklungsumgebung von Visual Basic<br />
zum Schließen des Meldungsfensters. Die Anweisung lautet dann wie hier im Change-<br />
Ereignis des Kombinationsfelds<br />
MsgBox "Sie wählten eine " & ComboBox1.Value<br />
Das einzige Argument der Funktion ist eine Zeichenkette. Der Rückgabewert wird nicht<br />
ausgewertet, da der Dialog nur eine Schaltfläche hat. Zeichenketten können durch den<br />
Operator »&« verknüpft werden.<br />
Sie können den Dialog aber auch noch <strong>mit</strong> weiteren Schaltflächen <strong>und</strong> einem Titel<br />
ausstatten. Dann muss das zweite Argument Btns als Wert oder Summe von Werten<br />
aus der folgenden Tabelle gewählt werden. Das erste Argument ist die Meldung, das<br />
dritte der Titel des Meldungsfensters. Die Anweisung lautet<br />
Rueck = MsgBox( Meldung, Btns, Titel)<br />
WWW Achten Sie bitte auf dei Klammern, die nötig werden, sobald die Funktion einen<br />
Wert zurückgibt!<br />
Beispiel:<br />
Rueck = MsgBox( "Mein Häuslein brennt!", _<br />
VbOKCancel + VbExclamation, "Hilfe")<br />
Dieses Meldungsfenster hat die Schaltflächen OK <strong>und</strong> Abbrechen <strong>und</strong> erschreckt den Benutzer<br />
<strong>mit</strong> einem nervigen Ausrufezeichen. Die Tabelle zur Gestaltung der Schaltflächen<br />
<strong>und</strong> der Symbole entstammt der Online-Hilfe <strong>und</strong> ist nicht vollständig:<br />
Konstante Wert Beschreibung<br />
vbOKOnly 0 Nur die Schaltfläche OK anzeigen.<br />
VbOKCancel 1 Schaltflächen OK <strong>und</strong> Abbrechen anzeigen.<br />
VbAbortRetryIgnore 2 Schaltflächen Abbruch, Wiederholen <strong>und</strong> Ignorieren<br />
anzeigen.<br />
VbYesNoCancel 3 Schaltflächen Ja, Nein <strong>und</strong> Abbrechen anzeigen.<br />
VbYesNo 4 Schaltflächen Ja <strong>und</strong> Nein anzeigen.<br />
VbRetryCancel 5 Schaltflächen Wiederholen <strong>und</strong> Abbrechen anzeigen.<br />
VbCritical 16 Meldung <strong>mit</strong> Stop-Symbol anzeigen.<br />
VbQuestion 32 Meldung <strong>mit</strong> Fragezeichen-Symbol anzeigen.<br />
VbExclamation 48 Meldung <strong>mit</strong> Ausrufezeichen-Symbol anzeigen.<br />
VbInformation 64 Meldung <strong>mit</strong> Info-Symbol anzeigen.<br />
Der Rückgabeparameter kann ausgewertet werden. Je nach gedrückter Schaltfläche sind<br />
folgende Werte möglich:<br />
98
Konstante Wert Beschreibung<br />
vbOK 1 OK<br />
vbCancel 2 Abbrechen<br />
vbAbort 3 Abbruch<br />
vbRetry 4 Wiederholen<br />
vbIgnore 5 Ignorieren<br />
vbYes 6 Ja<br />
vbNo 7 Nein<br />
8.7 Aufgaben<br />
Die möglichen Rückgabewerte sind also vom zweiten Parameter der MsgBox-Funktion<br />
abhängig.<br />
Eine typische Anwendung der MsgBox-Funktion ist das Exit-Ereignis eines Steuerelements,<br />
z.B. der Schaltfläche CommandButton1 des Formulars DemoForm:<br />
Private Sub CommandButton1_Exit(ByVal Cancel _<br />
As MSForms.ReturnBoolean)<br />
Cancel = MsgBox("Soll ich wirklich den Focus abgeben?", _<br />
vbYesNo + vbQuestion)<br />
End Sub<br />
Dieses Meldungsfenstr hat zwei Schaltflächen, Ja <strong>und</strong> Nein sowie ein Fragezeichen. Der<br />
MsgBox-Funktion gibt ihren Wert an das Argument Cancel zurück, <strong>und</strong> abhängig davon<br />
verliert die Schaltfläche endgültig den Focus oder nicht.<br />
Die allgemeine Form der MsgBox-Funktion entnehmen Sie bitte der Online-Hilfe.<br />
8.7 Aufgaben<br />
Aufgabe 1. <strong>Excel</strong> erlaubt die Kopie eines Bereichs als Werte <strong>und</strong> als Format aber nicht<br />
beides zugleich. Zunächst muss der zu kopierende Bereich markiert <strong>und</strong> über Strg+C in<br />
die Zwischenablage gebracht werden, dann wird die Anfangszelle des Bereichs markiert,<br />
wo die Kopie eingefügt werden soll. Dann wird der Rest durch den Dialog erledigt, der<br />
sich nach der Befehlsfolge Bearbeiten|Inhalte einfügen. . . öffnet. Am Beispiel der<br />
Tabelle von Aufgabe 1, Seite 77, Abbildung 7.1 erstelle man ein Makro, das den Bereich<br />
A1:D13 in eine andere Tabelle <strong>mit</strong> Werten <strong>und</strong> Formaten, aber ohne Formeln kopiert.<br />
Auch die Breite der Spalten soll übertragen werden. Erstellen Sie danach ein Makro, das<br />
das Diagramm von Abbildung 7.1 erzeugt.<br />
Hinweis: Verwenden Sie den Makrorecorder zum Aufzeichnen von Aktionen.<br />
Aufgabe 2. Lassen Sie den Makrorecorder bei folgenden Aktionen <strong>mit</strong>laufen:<br />
1. Erzeugen einer neuen Arbeitsmappe.<br />
2. Löschen von Tabelle3.<br />
3. Umbenennen der beiden verbliebenen Tabellen in Blatt1 <strong>und</strong> Blatt2.<br />
4. Speichern der Arbeitsmappe unter dem Namen MeineMappe.xls.<br />
99
8 Die Entwicklungsumgebung von Visual Basic<br />
Schließen Sie daraus, welche Methoden jeweils gewirkt haben.<br />
Aufgabe 3. Erstellen Sie ein Formular namens BlattForm, das nur eine Listbox hat,<br />
deren Werte die Tabellen der Arbeitsmappe <strong>mit</strong> Ausnahme der ersten sind. Dieses Formular<br />
soll auftauchen, wenn die erste Tabelle erscheint <strong>und</strong> wieder verschwinden, wenn<br />
der Anwender zu einer anderen Tabelle wechselt. Das Formular soll nicht modal sein.<br />
Ein Doppelklick auf eine der aufgelisteten Tabellen der Listbox soll die entsprechende<br />
Tabelle löschen.<br />
Finden Sie über die Online-Hilfe heraus, was die Methode DisplayAlerts() tut <strong>und</strong><br />
verwenden Sie diese, um die lästige Nachfrage, ob wirklich gelöscht werden soll, zu unterdrücken.<br />
Aufgabe 4. Erstellen Sie ein Formular FilmForm, das Ihre Lieblingsfilme in einem Kombinationsfeld<br />
zeigt. Ein neuer Filmtitel wird in das Eingabefeld des Kombinationsfelds<br />
eingegeben <strong>und</strong> soll nach Drücken einer Schaltfläche <strong>mit</strong> der Beschriftung Hinzufügen zu<br />
den Werten des Kombinationsfelds hinzugefügt werden. Über eine weitere Schaltfläche<br />
sollen alle Filmtitel gelöscht werden. Ein einzelner Filmtitel soll durch Doppelklick auf<br />
seinem Eintrag gelöscht werden. Dieses Formular soll modal sein <strong>und</strong> nach Drücken einer<br />
Schaltfläche erscheinen, die sich auf der ersten Tabelle befindet.<br />
Aufgabe 5. Erstellen Sie ein Formular Meldungen, das aus zwei Kombinationsfeldern<br />
ohne Eingabemöglichkeit besteht. Das erste soll die Einträge Nur Ok, OK <strong>und</strong> Abbrechen<br />
sowie Ja <strong>und</strong> Nein haben. Das zweite soll die Einträge Ausrufungszeichen, Fragezeichen<br />
<strong>und</strong> Stopp haben. Dazu soll sich ein Textfeld <strong>und</strong> eine Schaltfläche gesellen. Drückt<br />
man die Schaltfläche, soll ein Meldungsfenster erscheinen, dessen Nachricht das Textfeld<br />
<strong>und</strong> dessen Schaltflächen <strong>und</strong> Aussehen die beiden Kombinationsfelder bestimmen.<br />
Diese Formular soll ebenfalls nach Drücken einer Schaltfläche auftauchen.<br />
100
9 Die Sprachsyntax von Visual<br />
Basic<br />
In diesem Kapitels werden Sie die Syntax von <strong>VBA</strong> lernen. Visual Basic ist eine typisierte<br />
Sprache, in der alle neuen Typen aus den Basistypen zusammengesetzt werden.<br />
Die Basistypen beschreiben Zahlen, Zeichen <strong>und</strong> den logischen Datentyp. Die Zahlen<br />
gliedern sich in Festpunkt- <strong>und</strong> Gleitpunktzahlen. Basistypen haben einen festgelegten<br />
Wertebereich <strong>und</strong> erlauben bestimmte arithmetische <strong>und</strong> bitweise Operationen. Ein Operator<br />
verknüpft ein oder zwei Operanden zu einem Ausdruck, dessen Wert sich aus den<br />
Werten der einzelnen Operanden ergibt. Es gibt arithmetische, logische sowie bitweise<br />
Operatoren <strong>und</strong> Vergleichsoperatoren. Unter den Operatoren gibt es wie beim Rechnen<br />
bestimmte Vorrangregeln, etwa Punktrechnung geht vor Strichrechnung <strong>und</strong> die Möglichkeit<br />
die Reihenfolge der Auswertung durch Klammern zu beeinflussen. Aus Operatoren<br />
<strong>und</strong> den Operanden werden Ausdrücke gebildet, etwa a + b. Jeder Ausdruck hat einen<br />
Wert <strong>und</strong> kann daher wiederum Teil eines anderen Ausdrucks sein <strong>und</strong> der Wert jedes<br />
Ausdrucks kann einer Variablen über den Zuweisungsoperator = zugewiesen werden. So<br />
ist der erwähnte Ausdruck a + b Teil des Ausdrucks d = c*(a + b). Durch das<br />
Zeilenende wird aus einem Ausdruck eine Anweisung.<br />
9.1 Die Bausteine von <strong>VBA</strong><br />
Die Gesamtheit aller Quellcodedateien <strong>und</strong> Formulare bezeichnet man als Projekt. Jedes<br />
<strong>VBA</strong>-Projekt darf beliebig viele Module haben, in denen der Quellcode enthalten ist. Jeder<br />
Modul soll dabei einen logisch abgeschlossenen Themenbereich des Gesamtprojekts<br />
abdecken. Module enthalten aufgezeichnete Makros oder selbst erstellten Programmcode.<br />
Erzeugt wird ein Modul über den Befehl EINFÜGEN|MODUL der Entwicklungsumgebung<br />
von <strong>VBA</strong>. Dadurch öffnet sich ein leeres Fenster des Editors. Bei der Aufzeichnung<br />
eines Makros legt die Entwicklungsumgebung selbst einen neuen Modul an. Module<br />
erhalten die Namen Modul1, Modul2 usw., können aber über das Eigenschaften-Fenster<br />
umbenannt werden. Module beginnen <strong>mit</strong> Deklarationen von Variablen <strong>und</strong> Konstanten,<br />
die für das gesamte Modul Gültigkeit haben sollen, gefolgt von Sub-Prozeduren <strong>und</strong><br />
Funktionen.<br />
Variable sind die Atome eines Programms. Sie beziehen sich auf einen festen Speicherplatz,<br />
wohin über den Namen Bezug genommen wird. Der Inhalt des zugehörigen<br />
Speicherplatzes kann sich während der Programmausführung ändern. Variablenbezeichner<br />
müssen bestimmte Bedingungen einhalten. Variablen haben einen Datentyp, der die<br />
Größe des zugehörigen Speicherplatzes regelt <strong>und</strong> werden explizit in einer so genannten<br />
101
9 Die Sprachsyntax von Visual Basic<br />
nicht ausführbaren Anweisung deklariert.<br />
Aus Variablen <strong>und</strong> Konstanten werden durch Operatoren wie + oder ∗ Ausdrücke<br />
gebildet. Über den Zuordnungsoperator = wird aus einem Ausdruck eine so genannte<br />
ausführbare Anweisung.<br />
Sub-Prozeduren sind selbständige Einheiten eines <strong>VBA</strong>-Programms. Sie beginnen<br />
<strong>mit</strong> dem Schlüsselwort Sub gefolgt vom Namen der Sub-Prozedur <strong>und</strong> <strong>und</strong> enden <strong>mit</strong><br />
End Sub. Beachten Sie die Klammern nach dem Namen, die auch dann nötig sind,<br />
wenn keine Argumente übergeben werden.<br />
Sub Prozedurname (Liste der Argumente)<br />
Anweisungen<br />
End Sub<br />
Eine selbst geschriebene Funktion hat fast dieselbe Syntax wie eine Sub-Prozedur.<br />
Der Unterschied liegt darin, dass ein Wert zurückgegeben wird <strong>und</strong> das Schlüsselwort<br />
Sub durch Function ersetzt wird. Die Syntax lautet:<br />
Function Funktionsname (Liste der Argumente) As Typ<br />
Anweisungen<br />
Funktionsname = Ausdruck<br />
End Function<br />
Als Oberbegriff für Sub-Prozedur <strong>und</strong> Funktion verwende ich den Begriff Prozedur.<br />
Eine Prozedur ist also entweder eine Sub-Prozedur oder eine Funktion.<br />
Prozeduren müssen nicht unbedingt Argumente haben, wenn das aber der Fall ist,<br />
müssen diese in derselben Reihenfolge aufgerufen werden wie in der Deklaration. Dabei<br />
werden die Argumente anders als in <strong>Excel</strong> durch Kommas <strong>und</strong> nicht durch Semikolons<br />
voneinander getrennt. Sehr drollig ist, dass beim Aufruf genau dann Argumentenklammern<br />
nötig sind, wenn der Rückgabewert einer Funktion auszuwerten ist, d.h. wenn der<br />
Term <strong>mit</strong> der Funktion rechts vom Gleichheitszeichen steht.<br />
9.1.1 Variablen<br />
Variablen stehen für Bezeichner, denen im Programm ein konstanter Speicherbereich<br />
für die Aufnahme von Werten zugewiesen wird. Der Name Variable rührt daher, dass<br />
sich diese Werte im Verlauf des Programms verändern. Die Größe des Speicherbereichs<br />
richtet sich nach dem Datentyp der Variablen. Der Datentyp einer Variablen wird über<br />
die gleich erklärten Schlüsselwort Public, Private <strong>und</strong> Dim festgelegt. Die folgende<br />
Anweisung deklariert beispielsweise eine Variable als Long:<br />
Dim i As Long<br />
Entscheidend für die Verfügbarkeit oder Gültigkeit einer Variablen ist, wo diese Anweisung<br />
innerhalb des Moduls steht. Visual Basic unterscheidet bei Code-Zeilen zwischen<br />
zwei Ebenen, der Modul- <strong>und</strong> der Prozedurebene.<br />
102<br />
• Die Prozedurebene beschreibt Anweisungen, die sich innerhalb einer Prozedur befinden.<br />
Deklarationen werden üblicherweise zuerst aufgeführt, gefolgt von Zuweisungen<br />
<strong>und</strong> anderem ausführbaren Code.
9.1 Die Bausteine von <strong>VBA</strong><br />
• Die Modulebene beschreibt den Code, der außerhalb einer Prozedur steht. Das sind<br />
Anweisungen <strong>und</strong> Deklarationen von Variablen <strong>mit</strong> Bedeutung für den gesamten<br />
Modul oder das ganze Projekt. Deklarationen von Variablen für die Modulebene<br />
müssen zuerst aufgelistet werden, danach folgen die Prozeduren.<br />
Innerhalb der Modulebene werden Variablen durch die Schlüsselworte Public oder<br />
Private deklariert. Die allgemeine Form lautet:<br />
[Public][Private] Variablenname [As Typ]<br />
wobei die Typangabe optional ist, d.h. entfallen kann, wovon ich aber abrate.<br />
Die Deklaration über Public wird auf Modulebene verwendet, um öffentliche Variablen<br />
zu deklarieren <strong>und</strong> den dafür erforderlichen Speicher zu reservieren. Auf Variablen,<br />
die <strong>mit</strong> der Public-Anweisung deklariert wurden, kann von allen Prozeduren in allen<br />
Modulen aus allen Anwendungen zugegriffen werden. Schreibt man allerdings die Anweisung<br />
Option Private Module<br />
in der Modulebene, sind die Variablen nur innerhalb des zugehörigen Projekts öffentlich.<br />
Variablen vom Typ Private stehen nur in dem Modul zur Verfügung, in dem sie deklariert<br />
wurden. Statt Private ist auch Dim erlaubt. Beide Anweisungen sind gleichwertig,<br />
ich bevorzuge wegen der besseren Lesbarkeit Private. Variablen, die da<strong>mit</strong><br />
auf Modulebene deklariert wurden, stehen allen Prozeduren innerhalb des Moduls zur<br />
Verfügung.<br />
Auf Prozedurebene werden Variablen durch das Schlüsselwort Dim deklariert, nicht<br />
erlaubt sind hier Private oder oder Public. Solche Variablen sind nur innerhalb der<br />
Prozedur gültig, in der sie definiert wurden. Variablen sollten innerhalb einer Prozedur<br />
immer ganz oben vor allen anderen Anweisungen deklariert werden. Die Deklaration von<br />
Variablen erfolgt wie im folgenden Beispielmodul, den ich Prozedur1 genannt habe <strong>und</strong><br />
der Teil der Arbeitsmappe MakroTest.xls ist.<br />
Option Explicit<br />
Private Const KurzPi = 3.14<br />
Public Const GebDatum = "19.1.1971"<br />
Public Const LangPi As Double = KurzPi + 0.00159<br />
Public w1 As Long<br />
Private w2 As Long<br />
Private s As String<br />
Sub Test()<br />
Dim a As Double<br />
a = 0.12<br />
w1 = 4<br />
MsgBox "a * w1 = " & a * w1<br />
103
9 Die Sprachsyntax von Visual Basic<br />
MsgBox "s = " & s & ", w2 = " & w2<br />
End Sub<br />
Sub PrivateTest()<br />
MsgBox "KurzPi = " & KurzPi<br />
End Sub<br />
Die beiden Variablen w1 <strong>und</strong> w2 werden im Deklarationsteil des Moduls, also auf Modulebene<br />
deklariert <strong>und</strong> sind daher zumindest in allen Prozeduren des Moduls verwendbar.<br />
Die Variable w2 ist durch Public sogar in allen Modulen des Projekts gültig. Die<br />
Variable a ist dagegen nur in der Prozedur Test() verfügbar.<br />
Versetzen wir uns in die Rolle des Compilers, so erkennen wir die Arbeitserleichterung<br />
durch die Typangaben. Zunächst werden je vier Byte für die Variablen w1 <strong>und</strong><br />
w2 reserviert. Dann werden acht Byte für die Variable a angelegt <strong>und</strong> <strong>mit</strong> dem Wert<br />
0.12 vorbesetzt. Die Typangaben informieren den Compiler also über die Größe des<br />
Speicherbereiches.<br />
Visual Basic ist anders als C oder Pascal keine streng typisierte Sprache, daher können<br />
Variablen auch ohne Typangabe deklariert werden, dann vergibt Visual Basic den<br />
Typ Variant, der stellvertretend für alle Typen steht. Sinnvoll ist das aber nicht. Die<br />
Schlüsselworte Dim, Private oder Public sind aber immer nötig.<br />
Im Gegensatz zu C unterscheidet Visual Basic nicht zwischen großen <strong>und</strong> kleinen Buchstaben!<br />
Sie dürfen deshalb nicht eine Variable Hans <strong>und</strong> eine andere hans nennen, der<br />
Interpreter nähme nur an, dass Sie von nun an Hans klein schreiben wollten.<br />
9.1.2 Initialisierung von Variablen<br />
Bei der Deklaration versucht Visual Basic den Variablen sinnvolle Anfangswerte zu geben.<br />
Numerische Variable erhalten der Wert 0, das trifft im obigen Beispiel auf die Variablen<br />
w1 <strong>und</strong> w2 zu. Zeichenfolgen vom Typ String werden <strong>mit</strong> der leeren Zeichenfolge<br />
""initialisiert. Die zweite MsgBox-Anweisung führt so<strong>mit</strong> zur Ausgabe »s =, w2 = 0«,<br />
denn beide Variablen wurden noch nicht verwendet <strong>und</strong> haben so<strong>mit</strong> noch die Werte nach<br />
der Initialisierung.<br />
9.1.3 Konstanten<br />
Konstanten sind wie Variablen benannte Elemente für feste, vordefinierte Werte von Zahlen<br />
oder Zeichenfolgen, die während der gesamten Programmausführung nicht geändert<br />
werden können. Eine Konstante kann durch andere Konstante über arithmetische oder<br />
logische Operatoren gebildet werden. Es gibt unzählige von Visual Basic vordefinierte<br />
Konstante. Jedes Projekt kann zusätzliche Konstanten <strong>mit</strong> der Const-Anweisung definieren.<br />
Durch die Verwendung von Konstanten anstelle der tatsächlichen Werte wird der<br />
Programmcode leichter lesbar. Außerdem muss der Wert einer Konstanten nur einmal<br />
geändert werden, wenn dies durch äußere Umstände nötig sein sollte.<br />
104
9.1 Die Bausteine von <strong>VBA</strong><br />
Die Deklaration von Konstanten muss auf Modulebene vor allen Prozeduren erfolgen!<br />
Vor dem Bezeichner muss das Schlüsselwort Const stehen <strong>und</strong> nach dem Typ muss die<br />
Wertzuweisung folgen. Davor darf <strong>mit</strong> Public oder Private die Gültigkeit festgelegt<br />
werden. Wenn diese fehlt, wird Public angenommen. Die allgemeine Form ist also<br />
[Public][Private] Const Bezeichner [As Typ] = Ausdruck<br />
Dabei sind alle Datentypen zulässig. Wird der Typ nicht angegeben, wird von Visual<br />
Basic ein zum Wert passender Typ er<strong>mit</strong>telt. Gültige Beispiele von Konstanten sind im<br />
obigen Modul zu sehen.<br />
Private Const KurzPi = 3.14<br />
Public Const GebDatum = "19.1.1971"<br />
Public Const LangPi As Double = KurzPi + 0.00159<br />
Nur die Konstante LangPi habe ich <strong>mit</strong> Typ deklariert, die Typen der beiden anderen<br />
Konstanten werden von Visual Basic selbst eingesetzt. Nach der Deklaration können die<br />
Konstanten GebDatum <strong>und</strong> LangPi in allen Prozeduren des Projekts <strong>und</strong> KurzPi in<br />
allen Prozeduren des Moduls benutzt werden, sofern sie typgerecht behandelt werden.<br />
Abschließend sei noch erwähnt, dass konstante Zeichenfolgen wie etwa "Hallo"als<br />
Literale bezeichnet werden.<br />
9.1.4 Gültigkeit von Variablen <strong>und</strong> Prozeduren<br />
Ich habe noch ein weiteres Modul geschrieben, das ich Prozedur2 nannte <strong>und</strong> das ebenfalls<br />
Teil der Arbeitsmappe MakroTest.xls ist. Es enthält nur eine Sub-Prozedur:<br />
Sub PublicTest()<br />
Test<br />
MsgBox "LangPi = " & LangPi & ", w1 = " & w1<br />
End Sub<br />
Diese Sub-Prozedur verwendet die globale Variable w2, die globale Konstante LangPi <strong>und</strong><br />
die globale Prozedur Test. Ungültig wären Zugriffe auf w1, KurzPi sowie die Prozedur<br />
SetzeWerte, deren Gültigkeit auf das Modul Prozedur1 beschränkt ist.<br />
9.1.5 Option Explicit-Anweisung<br />
Die Anweisung<br />
Option Explicit<br />
wird auf der Modulebene verwendet, um die explizite Deklaration aller Variablen in<br />
diesem Modul zu erzwingen. Wenn diese Anweisung vorhanden ist, muss sie im jeweiligen<br />
Modul vor jeder Prozedur stehen.<br />
Wenn Sie die Option Explicit-Anweisung in einem Modul verwenden, müssen alle Variablen<br />
explizit <strong>mit</strong> Dim, Private, Public, ReDim oder Static deklariert werden.<br />
105
9 Die Sprachsyntax von Visual Basic<br />
Wenn Sie einen nicht deklarierten Variablennamen verwenden, tritt zur Kompilierungszeit<br />
ein Fehler auf. Dadurch vermeidet man den versehentlichen Gebrauch von Variablen<br />
<strong>mit</strong> falsch geschriebenen Namen.<br />
Wenn Sie die Option Explicit-Anweisung nicht verwenden, erhalten alle nichtdeklarierten<br />
Variablen den Typ Variant, solange <strong>mit</strong> einer DefTyp-Anweisung kein anderer<br />
Standardtyp festgelegt wird.<br />
Die Anweisung Option Explicit wird automatisch in einen neu erstellten Modul<br />
eingefügt, wenn im Dialogfeld Optionen, das in der Entwicklungsumgebung von <strong>VBA</strong><br />
über den Befehl Extras|Optionen. . . erreichbar ist, auf der Registerkarte Editor die<br />
Option Variablendeklaration erforderlich aktiviert wird.<br />
Quelle: Online-Hilfe.<br />
9.1.6 Ein weiteres Beispiel<br />
Nach Obamas triumphalen Wahlsieg bricht in den USA wie von seinen Gegnern vorhergesagt<br />
der Sozialismus aus. Es gibt nur noch einheitliche Gehälter, <strong>und</strong> zwar ein<br />
Gr<strong>und</strong>gehalt zuzüglich einer Zulage pro Lebensjahr. Gr<strong>und</strong>gehalt <strong>und</strong> Lebensjahr werden<br />
je nach Wirtschaftslage festgesetzt, vorgesehen sind $ 1000 als Gr<strong>und</strong>gehalt <strong>und</strong> $<br />
50 als Zulage, sodass ein Mensch von 30 Jahren $ 2500 = 1000 + 30 · 50 verdient. Im<br />
Modul Obama1 der Arbeitsmappe MakroTest.xls wird das wie folgt geregelt:<br />
Option Explicit<br />
Public Gr<strong>und</strong>gehalt As Long<br />
Private Zulage As Long<br />
Private Sub SetzeDaten(ByVal Gg As Long, ByVal Zz As Long)<br />
Gr<strong>und</strong>gehalt = Gg : Zulage = Zz<br />
End Sub<br />
Function Gehalt(ByVal Alter As Long) As Long<br />
Gehalt = Gr<strong>und</strong>gehalt + Zulage * Alter<br />
End Function<br />
Sub GehaltsTest()<br />
Dim Al As Long<br />
Al = 30<br />
SetzeDaten 1000, 50<br />
Al = InputBox("Wie alt sind Sie?", "Alter eingeben", Al)<br />
MsgBox "Sie verdienen " & Gehalt(Al) & _<br />
" amerikanische Talerchen!" ’Fortsetzungszeichen!<br />
End Sub<br />
’Kommentarzeile: Nu is Schluss!<br />
106
9.1 Die Bausteine von <strong>VBA</strong><br />
Ich verwende hier die InputBox-Funktion zur Eingabe des Alters. »Die InputBox-<br />
Funktion zeigt eine Eingabeaufforderung in einem Dialogfeld an, wartet auf die Eingabe<br />
eines Textes oder auf das Klicken auf eine Schaltfläche <strong>und</strong> gibt einen Wert vom Typ<br />
String zurück, der den Inhalt des Textfeldes angibt.« heißt es etwas holprig in der<br />
Online-Hilfe. Die Funktion hat bis zu sieben Argumente, aber ich werde immer nur drei<br />
verwenden. Der erste ist die Meldung, der zweite der Titel des Dialogs <strong>und</strong> der dritte<br />
der Vorgabewert, den der Anwender im Textfeld ändern kann <strong>und</strong> soll. Wird auf dieses<br />
Argument verzichtet, erscheint das Textfeld am Anfang leer.<br />
Einige Bemerkungen.<br />
1. Die Sub-Prozedur GehaltsTest() kann über die F5-Taste ausgeführt werden.<br />
2. Die Anweisung Option Explicit erzwingt die explizite, also ausdrückliche Deklaration<br />
aller Variablen.<br />
3. Die Variablen Gr<strong>und</strong>gehalt <strong>und</strong> Zulage sind außerhalb der Prozeduren, d.h.<br />
auf Modulebene deklariert <strong>und</strong> dürfen da<strong>mit</strong> in jeder Prozedur des Moduls verwendet<br />
werden, die Variable Gr<strong>und</strong>gehalt sogar im ganzen Projekt.<br />
4. Das Schlüsselwort ByVal müssen Sie erst einmal hinnehmen. Es steht vor jedem<br />
Argument einer Sub-Prozedur oder Funktion, aber nur bei deren Deklaration, nicht<br />
beim Aufruf.<br />
5. Jede Zeile darf genau eine Anweisung haben, es sei denn die Anweisungen sind<br />
durch einen Doppelpunkt »:« voneinander getrennt wie hier<br />
Gr<strong>und</strong>gehalt = Gg : Zulage = Zz.<br />
6. Der Rückgabewert einer Funktion ist der letzte Wert derjenigen Variablen, die den<br />
Namen der Funktion trägt.<br />
7. Die Variable Al ist nur innerhalb der Sub-Prozedur GehaltsTest() gültig.<br />
8. Beachten Sie, dass ich den Rückgabewert der MsgBox-Funktion nicht verwende, sodass<br />
ich keine Argumentklammern setzen darf! Die Rückgabewerte der InputBox-<br />
Funktion sowie die Funktion Gehalt() werden dagegen benutzt <strong>und</strong> daher sind<br />
Argumentklammern erforderlich. Auf diesen Blödsinn muss auch ein krankes Hirn<br />
erst mal kommen.<br />
9. Wenn eine Anweisung zu lang für eine Zeile ist, verwendet man das Fortsetzungszeichen<br />
»_« <strong>und</strong> schreibt in der nächsten Zeile weiter. Das geschieht hier in der<br />
MsgBox-Anweisung.<br />
10. Kommentarzeilen werden in <strong>VBA</strong>-Programmen durch ein Hochkomma als erstes<br />
Zeichen der Zeile gekennzeichnet. Kommentare sind nur an den Leser des Programms<br />
gerichtet, der Interpreter geht über Kommentare kommentarlos hinweg.<br />
Manchmal werden problematische Anweisungen durch das vorangestellte Hochkomma<br />
inaktiviert, oder wie die Programmierer sagen, auskommentiert.<br />
107
9 Die Sprachsyntax von Visual Basic<br />
9.1.7 Gültigkeit von Prozeduren<br />
Prozeduren sind gr<strong>und</strong>sätzlich in allen Modulen des Projekts, ja sogar in allen Modulen<br />
aller Anwendungen verfügbar, dazu ist anders als bei Variablen das Schlüsselwort<br />
Public nicht nötig, dürfte aber zur besseren Lesbarkeit vor dem Schlüsselwort<br />
Sub stehen.<br />
Prozeduren können aber durch das vorangestellte Schlüsselwort Private auf die<br />
Verwendung innerhalb der Prozeduren des eigenen Moduls eingeschränkt werden. Ich<br />
habe dies <strong>mit</strong> der Prozedur SetzeDaten() getan.<br />
In einem weiteren Modul namens Obama2 habe ich die folgende Prozedur geschrieben:<br />
Option Explicit<br />
Sub Ausgabe()<br />
GehaltsTest<br />
MsgBox "Gr<strong>und</strong>gehalt = " & Gr<strong>und</strong>gehalt<br />
’Nicht erlaubt in einem anderen Modul<br />
’SetzeDaten<br />
’MsgBox "Zulage = " & Zulage<br />
End Sub<br />
Ich darf die Prozedur GehaltsTest <strong>und</strong> die Variable Gr<strong>und</strong>gehalt verwenden, da<br />
der Gültigkeitsbereich über das eigene Modul Obama1 hinausgeht. Die beiden auskommentierten<br />
Anweisungen wiese der Interpreter ab, da die Variable Zulage <strong>und</strong> die<br />
Prozedur SetzeDaten in ihrer Gültigkeit auf das Modul Obama1 beschränkt sind.<br />
9.2 Format <strong>und</strong> Zeichenvorrat<br />
Visual Basic Programme erfordern ein bestimmtes Format <strong>und</strong> beruhen auf Ziffern,<br />
lateinischen Zeichen <strong>und</strong> Sonderzeichen. Dazu kommen so genannte Schlüsselwörter.<br />
9.2.1 Format von Anweisungen<br />
Jede Anweisung muss in einer eigenen Zeile geschrieben werden. Wenn der Platz nicht<br />
langt, wird das Fortsetzungszeichen »_« benutzt.<br />
Die in eine Zeile gehörende Funktion wird dadurch in die nächste Zeile verlängert.<br />
Will man Platz sparen, darf man mehrere Anweisungen in eine Zeile schreiben, muss<br />
dann aber die einzelnen Anweisungen durch einen Doppelpunkt »:«trennen.<br />
Sie sollten Sie sich an folgende Prinzipien halten:<br />
108<br />
• Pro Anweisung eine Zeile.<br />
• Nach jedem Schlüsselwort wie Sub, Function oder If werden die nachfolgenden<br />
Anweisungen eingerückt.
9.2 Format <strong>und</strong> Zeichenvorrat<br />
• Die zugehörige schließende Anweisung steht in der gleichen Spalte wie die öffnende<br />
also Function <strong>und</strong> End Function oder If <strong>und</strong> End If .<br />
Lesen Sie bitte den Code des Moduls noch einmal durch. Sie werden erkennen, wie<br />
die obigen Prinzipien die Lesbarkeit begünstigen.<br />
9.2.2 Zeichenvorrat<br />
Der Zeichenvorrat umfasst drei Gruppen:<br />
• Lateinische Buchstaben: a . . . z <strong>und</strong> A . . . Z, aber keine Umlaute wie ä oder Ü<br />
• Arabische Ziffern: 0, 1,..., 9.<br />
• Sonderzeichen:<br />
; , . : ’ "<br />
+ - * / > <<br />
= ( ) ^<br />
9.2.3 Bezeichner (identifier)<br />
Bezeichner beginnen <strong>mit</strong> einem Buchstaben, gefolgt von weiteren Buchstaben oder Ziffern<br />
<strong>und</strong> sollten nicht länger als 20 Zeichen sein. Gültige Bezeichner sind so<strong>mit</strong> Xxx12,<br />
xXX12, Xxx12, <strong>und</strong> diese sind eigentlich alle gleich, da in Visual Basic nicht zwischen<br />
großen <strong>und</strong> kleinen Buchstaben unterschieden wird. Falsch sind dagegen _???,<br />
92X oder gar -X.<br />
Bezeichner stehen für<br />
• Variablen, z.B. Dim x As Long.<br />
• Namen von Funktionen <strong>und</strong> Sub-Prozeduren, z.B. Function Sum(). Bezeichner<br />
sollten nicht zu lang , aber aussagekräftig sein; sie dürfen nicht <strong>mit</strong> Schlüsselworten<br />
wie If übereinstimmen.<br />
Im Gegensatz zu C unterscheidet Visual Basic nicht zwischen großen <strong>und</strong> kleinen Buchstaben!<br />
Sie dürfen deshalb nicht eine Variable Hans <strong>und</strong> eine andere hans nennen, der<br />
Interpreter nähme nur an, dass Sie von nun an Hans klein schreiben wollten.<br />
9.2.4 Schlüsselworte<br />
Jede Programmiersprache hat reservierte Schlüsselworte, die vom Programmierer nicht<br />
als Bezeichner verwendet werden dürfen. Einige davon kennen Sie bereits, etwa If oder<br />
Else. In der folgenden Tabelle habe ich die wichtigsten Schlüsselworte aufgelistet.<br />
If Else Else If End False True Do Until Dim Public<br />
GoTo Function Sub For Next While Case Loop Private Global<br />
109
9 Die Sprachsyntax von Visual Basic<br />
9.2.5 Kommentare<br />
Kommentare beginnen <strong>mit</strong> einem Hochkomma ’<strong>und</strong> erstrecken sich bis ans Zeilenende.<br />
Man darf natürlich beliebig viele Kommentarzeilen hintereinander verwenden, muss dann<br />
aber jede Zeile für sich <strong>mit</strong> dem Hochkomma auskommentieren.<br />
9.3 Datentypen<br />
Abhängig vom Typ einer Variablen legt der Interpreter Speicherplatz an <strong>und</strong> erkennt<br />
unverträgliche Anweisungen. Die wichtigsten Basistypen von Visual Basic stehen für<br />
ganze Zahlen <strong>und</strong> Gleitkommazahlen sowie für Zeichenketten.<br />
9.3.1 Basistypen für Zahlen<br />
110<br />
• Den Datentyp Byte erwähne ich nur der Vollständigkeit halber. Variablen diesen<br />
Datentyps beanspruchen ein Byte Speicherplatz <strong>und</strong> haben einen Wertebereich von<br />
0 bis 255.<br />
• Variablen vom Datentyp Integer werden als 16-Bit-Zahlen (2 Bytes) in einem<br />
Bereich von -32.768 bis 32.767 gespeichert. Ich vermeide diesen Datentyp gr<strong>und</strong>sätzlich,<br />
da der Zahlenbereich zu klein ist <strong>und</strong> schon Ausdrücke wie nächsten Abschnitt<br />
zum Überlauf führen.<br />
• Variablen vom Datentyp Long (lange Ganzzahl) werden als 32-Bit-Zahlen (4 Bytes)<br />
<strong>mit</strong> Vorzeichen im Bereich von -2.147.483.648 bis 2.147.483.647 gespeichert.<br />
• Variablen vom Datentyp Single (Gleitkommazahl <strong>mit</strong> einfacher Genauigkeit)<br />
werden als 32-Bit-Gleitkommazahlen (4 Bytes) nach IEEE für negative Werte im<br />
Bereich von -3,402823E38 bis -1,401298E-45 <strong>und</strong> von 1,401298E-45 bis 3,402823E38<br />
für positive Werte gespeichert.<br />
• Variablen vom Datentyp Double (Gleitkommazahl <strong>mit</strong> doppelter Genauigkeit)<br />
werden als 64-Bit-Gleitkommazahlen (8 Bytes) nach IEEE für negative Werte im<br />
Bereich von -1,79769313486231E308 bis -4,94065645841247E-324 <strong>und</strong> für positive<br />
Werte von 4,94065645841247E-324 bis 1,79769313486232E308 gespeichert.<br />
• Der Datentyp Currency hat einen Wertebereich von -922.337.203.685.477,5808<br />
bis 922.337.203.685.477,5807. Das sind Festkommazahlen <strong>mit</strong> 15 Stellen vor <strong>und</strong> 4<br />
Stellen nach dem Komma. Auch dieser Datentyp benötigt acht Byte. Verwenden<br />
Sie diesen Datentyp für Berechnungen von Währungen <strong>und</strong> für Berechnungen <strong>mit</strong><br />
festgelegten Nachkommastellen, bei denen es besonders auf Genauigkeit ankommt.<br />
• Der Datentyp Decimal reicht bis zu ±79.228.162.514.264.337.593.543.950.335. Je<br />
größer der Absolutbetrag der Zahl ist, umso weniger Nachkommastellen gibt es. Im<br />
Bereich zwischen ±10 sind 27 Nachkommastellen möglich, <strong>mit</strong> jeder Zehnerpotenz
9.3 Datentypen<br />
muss eine Nachkommastelle geopfert werden. Die kleinsten Zahlen ungleich Null<br />
sind ±0, 0000000000000000000000000001 Dieser Datentyp benötigt 14 Byte.<br />
Quelle: Online-Hilfe.<br />
Vielleicht noch etwas Blah zu ganzen Zahlen, Gleitkomma- <strong>und</strong> Festkommazahlen (-<br />
>Numerik!). Alle numerischen Datentypen benutzen intern die Basis 2, der Typ Decimal<br />
sicher die Basis 10, warum sollte er sonst so heißen? Stimmt das? ->Studis raus kriegen<br />
lassen.<br />
9.3.2 Überlauf bei ganzen Zahlen<br />
Alle arithmetischen Rechnungen <strong>mit</strong> ganzen Zahlen werden von Computern nur dann<br />
korrekt ausgeführt, wenn das Ergebnis <strong>und</strong> alle Zwischenrechnungen immer im Wertebereich<br />
des verwendeten ganzzahligen Typs bleiben. Sobald eine arithmetische Operation<br />
zu einem Wert außerhalb dieses Bereiches führt, kommt es zu einem Überlauf genannten<br />
Fehler. Visual Basic bricht dann <strong>mit</strong> dieser Fehlermeldung ab.<br />
Sub Ueberlauf()<br />
Dim a As Integer, b As Integer<br />
a = 16000<br />
b = 17000<br />
MsgBox "a + b = " & a + b<br />
End Sub<br />
Lässt man diese Sub-Prozedur laufen, gibt es eine Fehlermeldung <strong>mit</strong> Programmabruch.<br />
Dies wäre durch Verwendung des Datentyps Long statt Integer leicht zuvermeiden<br />
gewesen.<br />
9.3.3 Der logische Datentyp<br />
Der logische Datentyp Boolean modelliert alle zweiwertigen Zustände wie an <strong>und</strong> aus<br />
oder ja <strong>und</strong> nein, <strong>und</strong> hat deshalb lediglich zwei Werte, nämlich True <strong>und</strong> False.<br />
Logische Variable entstehen meist aus arithmetischen Vergleichen, etwa<br />
Dim b As Boolean<br />
b = i > 2<br />
Dabei erhält b den Wert True, wenn die Variable i größer ist als 2.<br />
9.3.4 Bedingte Anweisungen<br />
Ganz eng <strong>mit</strong> dem logischen Datentyp ist die bedingte Anweisung verwandt, die ich<br />
deshalb in diesen Abschnitt einschiebe, wo sie eigentlich nicht hingehört. Die Syntax<br />
lautet:<br />
If (logischer Ausdruck) Then Anweisung<br />
111
9 Die Sprachsyntax von Visual Basic<br />
Dabei wird der logische Ausdruck zur besseren Lesbarkeit in Klammern gesetzt, was<br />
zwar in C++ aber nicht in Visual Basic erforderlich ist. Die nachfolgende Anweisung<br />
wird nur ausgeführt, wenn der Wert des logischen Ausdrucks True ist. Die meisten<br />
logischen Ausdrücke entstehen aus arithmetischen Vergleichen von zwei numerischen<br />
Ausdrücken. Eine solche Bedingung ist ein Ausdruck, der wie in der zweiwertigen Logik<br />
üblich nur True oder False sein kann. Ich habe mir folgende hirnerweichende Sub-<br />
Prozedur als Beispiel ausgedacht:<br />
Sub IfTest()<br />
Dim l As Long<br />
l = InputBox("Bitte Länge in cm eingeben!", "Titel", "")<br />
If (l > 200) Then MsgBox "Sie sind ein langer Lulatsch!"<br />
End Sub<br />
Die Meldung erscheint also nur, wenn die in Klammern stehende Bedingung wahr ist,<br />
also mindestens 201 eingegeben wird.<br />
9.3.5 Zeichenfolgen<br />
Eine Zeichenfolge besteht aus einer Folge von Zeichen. Konstante Zeichenfolgen werden<br />
in Anführungsstriche gesetzt, etwa "Hallo". Zum offiziellen Standard von Visual Basic<br />
gehört eine Klasse String für Zeichenketten. Der Name leitet sich von der englischen<br />
Bezeichnung für Zeichenketten ab. Es gibt zwei Arten von Zeichenfolgen: Zeichenfolgen<br />
variabler Länge <strong>und</strong> Zeichenfolgen fester Länge.<br />
• Zeichenfolgen variabler Länge können bis zu 2 Milliarden (oder 2 31 ) Zeichen enthalten.<br />
• Zeichenfolgen fester Länge können 1 bis etwa 64 KB (2 16 ) Zeichen enthalten. Die<br />
Codes für Zeichen vom Datentyp String liegen im Bereich von 0 bis 255 (einschließlich).<br />
Die ersten 128 Zeichen (0 bis 127) entsprechen den Buchstaben <strong>und</strong><br />
Symbolen auf einer US-amerikanischen Standardtastatur. Diese ersten 128 Zeichen<br />
stimmen <strong>mit</strong> den im ASCII-Zeichensatz definierten Zeichen überein. Die zweiten<br />
128 Zeichen (128 bis 255) sind Sonderzeichen, z.B. Buchstaben aus internationalen<br />
Alphabeten, Akzentzeichen, Währungssymbole <strong>und</strong> Symbole für mathematische<br />
Brüche.<br />
Quelle: Online-Hilfe.<br />
Standardmäßig haben Zeichenfolgen eine variable Länge. Sie können aber auch die<br />
Länge der Zeichenfolge festlegen, wie sehen Sie im folgenden Beispiel:<br />
Sub StringTest()<br />
Dim SVar As String<br />
Dim SFest As String * 5<br />
SVar = "Angela"<br />
SFest = "Angela"<br />
112
MsgBox "SVar = " & vbTab & SVar & vbNewLine & _<br />
"SFest = " & vbTab & SFest<br />
End Sub<br />
9.3 Datentypen<br />
Die Variable SVar ist variabel, während die Variable SFest die Länge 5 hat. Zeichenfolgen<br />
<strong>mit</strong> fester Länge können nur so viele Zeichen aufnehmen, wie es die Größe<br />
gestattet, daher wird das »a« beim Vornamen unserer engelsgleichen B<strong>und</strong>eskanzlerin<br />
abgeschnitten. Ist der Inhalt der Zeichenfolge zu kurz, werden die restlichen Zeichen <strong>mit</strong><br />
Leerzeichen belegt.<br />
Das Meldungsfenster gibt so<strong>mit</strong> folgenden Text aus:<br />
SVar = Angela<br />
SFest = Angel<br />
Den Zeilenumbruch <strong>und</strong> die Formatierung durch Tabulatoren erkläre ich gleich.<br />
9.3.6 Vordefinierte Zeichenfolgen<br />
Das Office-Paket stellt eine umfangreichen Vorrat an integrierten Konstanten zur Verfügung.<br />
Diese können Sie im Objektkatalog (noch nicht erklärt!) von <strong>VBA</strong> einzusehen.<br />
Der Präfix des Namens einer Konstanten deutet auf ihre Herkunft hin. Konstanten <strong>mit</strong><br />
dem Präfix »vb« stammen beispielsweise aus der Objekt-Library von <strong>VBA</strong>, solche <strong>mit</strong><br />
dem Präfix »xl« beziehen sich auf <strong>Excel</strong>. In der folgenden Tabelle sind einige wichtige<br />
Konstanten <strong>und</strong> ihre Bedeutung aufgelistet:<br />
Konstante Bedeutung<br />
vbCr Wagenrücklaufzeichen, bringt Cursor zurück an erste Stelle der Zeile.<br />
vbLF Neue Zeile Zeilenvorschubzeichen, verschiebt Cursor um eine Zeile nach<br />
unten.<br />
vbCrLf Kombination aus beiden.<br />
vbNewLine Plattformspezifisches Zeilenumbruchzeichen; je nachdem, welches für<br />
die aktuelle Plattform geeignet ist, also Windows, Mac oder DOS.<br />
vbTab Tabulator<br />
Blah<br />
9.3.7 Der Verkettungsoperator & für Zeichenfolgen<br />
Der Verkettungsoperator & verknüpft zwei Ausdrücke, wovon mindestens einer eine Zeichenfolge<br />
sein muss. Der andere Ausdruck kann alphanumerisch sein. Der rechte Ausdruck<br />
wird dabei an den linken angehängt. Für Leerzeichen müssen Sie dabei selbst<br />
sorgen.<br />
Sub TestEt()<br />
Dim s As String, t As String, j As Long<br />
s = "Hallo"<br />
t = " Welt im Jahr " ’Leerzeichen beachten!<br />
113
9 Die Sprachsyntax von Visual Basic<br />
j = 2008<br />
t = s & t & j & "!"<br />
MsgBox t<br />
End Sub<br />
Der String t hat jetzt den Wert "Hallo Welt im Jahr 2008!". Ich verwende<br />
diesen Operator gerne, um eine sehr lange Zeichenkette zu erzeugen, die nicht in eine<br />
Zeile passt:<br />
s = "Blah, blah, blah, blah, blah, blah, blah, blah, blah,"<br />
s = s & " Dacapo: blah"<br />
Der Verkettungsoperator wandelt numerische Ausdrücke bei Bedarf in Zeichenfolgen<br />
um:<br />
s = "Pi ist ungefähr " & 3.14<br />
Da<strong>mit</strong> trägt s den Text "Pi ist ungefähr 3.14".<br />
9.3.8 Nützliche Stringfunktionen<br />
Für Zeichenketten gibt es viele nützliche Funktionen. Einige davon möchte ich erwähnen.<br />
114<br />
• Die Funktion Len(s)gibt die Anzahl der Zeichen des Arguments s zurück.<br />
• Die Funktion LCase(s)liefert eine Zeichenfolge, in der jeder große Buchstabe von<br />
s durch einen kleinen ersetzt wird. Die anderen Zeichen bleiben unverändert.<br />
• Die Funktion UCase(s)liefert eine Zeichenfolge, in der umgekehrt jeder kleine<br />
Buchstabe von s durch einen großen ersetzt wird. Die anderen Zeichen bleiben<br />
unverändert.<br />
• Die Funktion Left(s, k), wobei s eine Zeichenfolge <strong>und</strong> k eine ganze Zahl<br />
sein müssen, liefert den Teilstring von s, der von den ersten k Zeichen gebildet<br />
wird.<br />
• Die Funktion Right(s, k), wobei s eine Zeichenfolge <strong>und</strong> k eine ganze Zahl<br />
sein müssen, liefert den Teilstring von s, der von den letzten k Zeichen gebildet<br />
wird.<br />
• Die Funktion Mid(s, i, k), wobei s eine Zeichenfolge <strong>und</strong> i sowie k ganze<br />
Zahlen sein müssen, liefert den Teilstring von s, der beim Zeichen i beginnt <strong>und</strong><br />
beim Zeichen (i + k - 1) endet, also von der Position i an genau k Zeichen<br />
umfasst.<br />
• Die Funktion InStr(pos, s, teilstr) sucht innerhalb der ganzen Zeichenfolge<br />
s die Zeichenfolge teilstr. Die Suche wird an der Position pos begonnen.<br />
Der Index des ersten Auftauchens wird zurückgegeben, also eine ganze Zahl. Ist<br />
die Zeichenfolge teilstr innerhalb der Zeichenfolge s nicht zu finden, wird die
9.3 Datentypen<br />
Zahl 0 zurückgegeben. Der erste Parameter darf fehlen werden, die Suche beginnt<br />
dann vom ersten Zeichen an.<br />
Der Ausdruck Mid(s, i, 1) liefert die Zeichenfolge, die aus dem Zeichen an der<br />
Stelle i besteht. Bitte beachten Sie, dass <strong>VBA</strong> nur den Typ String kennt, aber keinen<br />
eigenen Typ für ein einzelnes Zeichen.<br />
Auch hierzu eine Testprozedur. Am Beispiel der Zeichenfolge "Hallo Welt"werden<br />
die erwähnten Funktionen getestet. Danach wird in der europäisch geschriebenen Zahl<br />
"3,14"das Komma durch einen Punkt ersetzt.<br />
Sub StringFunctionTest()<br />
Dim s As String, anf As String, ende As String<br />
Dim <strong>mit</strong>te As String, Us As String, pi As String<br />
Dim ln As Long<br />
Dim i As Long, j As Long, r As Long<br />
s = "Hallo Welt"<br />
anf = Left(s, 1)<br />
ende = Right(s, 1)<br />
<strong>mit</strong>te = Mid(s, 7, 2)<br />
Us = UCase(s)<br />
ln = Len(s)<br />
MsgBox "s = " & s & ", Us = " & Us & ", ln = " & ln<br />
MsgBox "anf = " & anf & ", ende = " & ende _<br />
& ", <strong>mit</strong>te = " & <strong>mit</strong>te<br />
i = InStr(s, "Welt")<br />
j = InStr(3, s, "Welt")<br />
r = InStr(3, s, "Hallo")<br />
MsgBox "i = " & i & ", j = " & j & ", r = " & r<br />
pi = "3,14"<br />
i = InStr(pi, ",")<br />
If (i > 0) Then pi = Left(pi, i - 1) & _<br />
"." & Right(pi, Len(pi) - i)<br />
MsgBox "pi = " & pi<br />
End Sub<br />
Nach den Aufrufen der Zeichenfolgen-Funktionen haben anf, ende, <strong>mit</strong>te <strong>und</strong> ln die<br />
Werte "H", "t", "We"<strong>und</strong> 10. Die Zeichenfolge Us hat den Inhalt "HALLO WELT".<br />
Weiter haben die Variablen i <strong>und</strong> j den Wert 7 <strong>und</strong> r ist gleich 0. Die Zeichenfolge<br />
pi hat sich von "3,14"auf "3.14"verändert.<br />
Streng genommen liefern die erwähnten Funktionen nicht den Datentyp String,<br />
sondern den Datentyp Variant. Man kann die Rückgabe des Typs String erzwingen,<br />
115
9 Die Sprachsyntax von Visual Basic<br />
indem nach dem Funktionsnamen ein Dollarzeichen folgt, also z.B. Left$(s, k) statt<br />
Left(s, k). Das ist aber unnötig <strong>und</strong> tut auch keiner.<br />
9.3.9 Wiederholungen einer Anweisung<br />
Maanchmal kommt es vor, dass eine Anweisung nicht nur einmal, sondern mehrmals<br />
direkt hintereinander ausgeführt werden soll. Das trifft besonders oft im Zusammenhang<br />
<strong>mit</strong> Datenfeldern auf, die ich gleich besprechen möchte. Ein Klassiker ist die Summation<br />
der ganzen Zahlen zwischen 1 <strong>und</strong> n. Es gilt die Formel:<br />
Etwa<br />
n<br />
i = n ∗ (n + 1)/2.<br />
i=1<br />
n<br />
i = 100 ∗ (101)/2 = 5050.<br />
i=1<br />
Zur Überprüfung könnte man folgende Funktion verwenden:<br />
Function Sum(ByVal n As Long) As Long<br />
Dim i As Long<br />
Sum = 0<br />
For i = 1 To n<br />
Sum = Sum + i<br />
Next i<br />
End Function<br />
Hier wird die Anweisung Sum = Sum + i n-mal wiederholt.<br />
Die allgemeine Syntax der Wiederholung einer Anweisung lautet:<br />
Dim i As Long<br />
For i = Anfangswert To k = Endwert<br />
Anweisung<br />
Next i<br />
Die For-Anweisung wird sehr oft bei Datenfeldern <strong>und</strong> Zeichenketten eingesetzt.<br />
9.3.10 Datenfelder (Arrays)<br />
Alle Beispiele zu Datenfeldern befinden sich im Modul Felder der Arbeitsmappe Makrotest.xls.<br />
Ein eindimensionales Datenfeld enthält aufeinanderfolgende Elemente desselben Datentyps.<br />
Jedes Element eines Feldes wird durch eine eindeutige Index genannte Zahl<br />
identifiziert. Wenn bei einem Feldelement Änderungen vorgenommen werden, bleiben<br />
116
9.3 Datentypen<br />
die anderen Elemente davon unbeeinflusst. Die Indizes verlaufen dabei von einer Untergrenze<br />
low bis zu einer Obergrenze up. Die Angabe der Obergrenze ist erforderlich,<br />
die Untergrenze kann fehlen, dann erhält sie automatisch den Wert 0. Ein Datenfeld hat<br />
N = up-low+1 Elemente, wobei die natürliche Zahl N Dimension heißt. Ich verzichte<br />
gr<strong>und</strong>sätzlich auf die Untergrenze <strong>und</strong> lasse da<strong>mit</strong> alle Datenfelder immer beim Index 0<br />
beginnen. Da<strong>mit</strong> ist der Code leichter nach C oder C++ zu übertragen.<br />
Innerhalb einer Prozedur wird ein Datenfeld durch die Dim-Anweisung erzeugt, außerhalb<br />
durch Public oder Private anstelle von Dim .<br />
Public Tage(30) As Long<br />
Sub Feldtest()<br />
Dim i as Long<br />
Dim WoTage(6) As String<br />
for i = 0 to 30<br />
Tage(i) = i + 1<br />
Next i<br />
WoTage(0) = "Sonntag"<br />
WoTage(1) = "Montag"<br />
’usw.<br />
WoTage(6) = "Samstag"<br />
MsgBox "Die Woche beginnt am " & WoTage(0) & _<br />
", Monate enden spätestens am " & Tage(30) & "."<br />
End Sub<br />
Nach dieser Prozedur hat Tage(12) z.B. den Wert 13 <strong>und</strong> WoTage(5) den Wert<br />
»Freitag«.<br />
9.3.11 Unter- <strong>und</strong> Obergrenzen eines Datenfelds<br />
Visual Basic erlaubt die Angabe von Unter- <strong>und</strong> Obergrenze bei der Deklaration eines<br />
Datenfledes, etwa:<br />
Public ErstesDrittel(1 To 12) As Long<br />
Public ZweitesDrittel(13 To 24) As Long<br />
Public DrittesDrittel(24 To 36) As Long<br />
Das mag manchmal sinnvoll sein, entspricht aber nicht dem Stil der von C abgeleiteten<br />
Programmiersprachen wie C++, Java, PHP usw. Ich rate davon genauso ab, wie von<br />
der Anweisung<br />
Option Base 1<br />
117
9 Die Sprachsyntax von Visual Basic<br />
Diese Anweisung kann nur einmal pro Modul auftreten <strong>und</strong> muss vor allen Deklarationen<br />
von Datenfeldern stehen, die Dimensionen enthalten. Bei Datenfeldern dieses<br />
Moduls wird eine fehlende Untergrenze automatisch 1 gesetzt. Bei anderen Modulen<br />
ohne diese Anweisung bleibt die automatische Untergrenze bei 0. Die Funktionen<br />
LBo<strong>und</strong>(Datenfeld) <strong>und</strong> UBo<strong>und</strong>(Datenfeld) geben die Unter- bzw. Obergrenze<br />
des Arguments wieder. Das ist insbesondere bei dynamischen Datenfeldern, die ich<br />
gleich bespreche, vorteilhat.<br />
9.3.12 Dynamische Datenfelder<br />
Sie können ein Datenfeld auch <strong>mit</strong> einem leeren Klammernpaar deklarieren, die Dimension<br />
ist da<strong>mit</strong> zunächst unbestimmt. Danach können Sie <strong>mit</strong> der ReDim-Anweisung<br />
innerhalb einer Prozedur die Unter- <strong>und</strong> Obergrenze festlegen. Sie dürfen allerdings nicht<br />
den Typ des Datenfeldes verändern. Diesen Vorgang dürfen Sie beliebig oft wiederholen<br />
<strong>und</strong> da<strong>mit</strong> die Dimension des Datenfeldes dynamisch zur Laufzeit ändern. Nach jeder<br />
ReDim-Anweisung gehen die bisherigen Elemente des Datenfeldes verloren.<br />
Mit dem Schlüsselwort Preserve können Sie bei eindimensionalen Datenfeldern die<br />
Dimension ändern <strong>und</strong> die bisherigen Werte erhalten. Im folgenden Beispiel wird die<br />
Dimension eines dynamischen Datenfeldes vergrößert, ohne bereits bestehende Daten<br />
im Datenfeld zu löschen.<br />
Option Explicit<br />
Public Faecher() As String<br />
Sub DynArrayneu()<br />
Dim n As Long, i As Long<br />
n = InputBox("Anzahl Faecher: ", "Eingeben!", "")<br />
If (IsNumeric(n) And n > 0) Then ReDim Faecher(n - 1)<br />
For i = 0 To n - 1<br />
Faecher(i) = InputBox("Name des Fachs: ", "Eingeben!", "")<br />
Next i<br />
End Sub<br />
Sub DynArrayZu()<br />
Dim n As Long, i As Long, m As Long<br />
m = UBo<strong>und</strong>(Faecher)<br />
n = InputBox("Anzahl neuer Faecher: ", "Eingeben!", "")<br />
If (IsNumeric(n) And n > 0) Then _<br />
ReDim Preserve Faecher(UBo<strong>und</strong>(Faecher) + n)<br />
118<br />
MsgBox "Obere Grenze: " & UBo<strong>und</strong>(Faecher)<br />
For i = 1 To n<br />
Faecher(m + i) = InputBox("Name des Fachs: ", "", "")<br />
Next i
End Sub<br />
Sub Ausgabe()<br />
Dim i As Long, aus As String<br />
For i = 0 To UBo<strong>und</strong>(Faecher)<br />
aus = aus & Faecher(i) & vbNewLine<br />
Next i<br />
MsgBox aus<br />
End Sub<br />
Sub DynarrayTest()<br />
DynArrayneu<br />
Ausgabe<br />
DynArrayZu<br />
Ausgabe<br />
End Sub<br />
9.3.13 Mehrdimensionale Datenfelder<br />
9.3 Datentypen<br />
Mehrdimensionale Datenfelder werden wie eindimensionalen definiert, nur muss für jede<br />
Dimension Unter- <strong>und</strong> Obergrenze angegeben werden. Auch hier wird eine fehlende<br />
Untergrenze durch 0 ersetzt, es sei denn die Anweisung<br />
Option Base 1<br />
setzte die Untergrenze auf 1. Es laut Online-Hilfe sind maximal 60 Dimensionen möglich.<br />
Ein zweidimensionales Datenfeld von Werten des Typs Double werde etwa wie folgt<br />
deklariert:<br />
DIM Mat (4 TO 8, 9) As Double<br />
Da<strong>mit</strong> hat das Datenfeld (8 − 4 + 1) · 10 Elemente, <strong>und</strong> zwar von Mat(4, 0) bis<br />
Mat(8, 9). Der Speicherbedarf steigt bei mehrdimensionalen Feldern rapide an, da<br />
die einzelnen Dimensionen multipliziert werden.<br />
Zweidimensionale Datenfelder passen hervorragend zu rechteckigen Bereichen in Arbeitsblättern.<br />
Dazu ein kleines Beispiel:<br />
Sub Austausch()<br />
Dim Mat(2, 2) As Variant<br />
Mat(0, 0) = "A1"<br />
Mat(0, 2) = "C1"<br />
Mat(1, 0) = "A2"<br />
Mat(1, 1) = "B2"<br />
Mat(2, 0) = "A3"<br />
Mat(2, 2) = "C3"<br />
Worksheets("Tabelle2").Range("A1:C3").Value = Mat<br />
End Sub<br />
119
9 Die Sprachsyntax von Visual Basic<br />
Da<strong>mit</strong> wird in einigen der Zellen des Bereichs A1:C3 der Bezug der Zelle geschrieben.<br />
Alle nicht erwähnten Zellen werden <strong>mit</strong> Nullwerten, also ohne Inhalt, belegt, bereits vorhandene<br />
ältere Einträge werden gelöscht. Im obigen Beispiel erscheint in den 6 belegten<br />
Zellen der Inhalt, die drei fehlenden bleiben leer, egal, was vorher dort stand.<br />
9.3.14 Der Datumstyp Date<br />
Variablen vom Datentyp Date werden als 64-Bit-Gleitkommazahlen (8 Bytes) nach<br />
IEEE gespeichert <strong>und</strong> können ein Datum im Bereich vom 01. Januar 100 bis zum 31.<br />
Dezember 9999 <strong>und</strong> eine Uhrzeit im Bereich von 0:00:00 bis 23:59:59 speichern. Jeder<br />
gültige Wert eines Datums- oder Zeitliterals kann einer Variablen vom Datentyp<br />
Date zugewiesen werden. Ein Datumsliteral muss durch Rauten (#) eingeschlossen sein,<br />
zum Beispiel: #January 1, 1993# oder #1 Jan 93#. Ich hatte am meisten Glück<br />
<strong>mit</strong> der amerikanischen Kurzform #mm/tt/yy#, also z.B. für meinen Geburtstag am<br />
13.11.2008 durch #11/13/2008#. Es werden also Monat <strong>und</strong> Tag vertauscht <strong>und</strong> das<br />
Trennzeichen ist ein normaler Schrägstrich.<br />
Variablen vom Datentyp Date verwenden zur Darstellung des Datums das auf dem<br />
Computer eingestellte kurze Datumsformat. Zeitangaben werden <strong>mit</strong> dem auf dem Computer<br />
eingestellten Zeitformat (entweder 12- oder 24-St<strong>und</strong>en) dargestellt.<br />
Beim Umwandeln anderer numerischer Datentypen in Werte des Datentyps Date repräsentieren<br />
die Vorkommastellen das Datum <strong>und</strong> die Nachkommastellen die Uhrzeit.<br />
Mitternacht entspricht dem Wert 0, <strong>und</strong> Mittag entspricht den Nachkommawert 0,5.<br />
Negative ganze Zahlen repräsentieren ein Datum vor dem 30. Dezember 1899.<br />
9.3.15 Nützliche Datums-Funktionen<br />
Für den wichtigen Datentyp Date gibt es viele nützliche Funktionen. Ich werde hier<br />
eine Auswahl vorstellen. Weitere Funktionen finden Sie in der Online-Hilfe, woher ich<br />
auch in diesem Fall mein eigenes Wissen beziehe.<br />
120<br />
• Die Funktion Now gibt einen Wert vom Typ Date zurück, der das aktuelle Datum<br />
<strong>und</strong> die aktuelle Zeit aus den Einstellungen für das Systemdatum <strong>und</strong> die Systemzeit<br />
auf Ihrem Computer angibt. Man erhält das Systemdatum als 10-Zeichen lange<br />
Zeichenfolge der Form mm-tt-jjjj zurück, wobei mm (01-12) der Monat, tt (01-30)<br />
der Tag <strong>und</strong> jjjj das Jahr ist. Dies entspricht dem Datumsbereich vom 1. Januar<br />
1980 bis zum 31. Dezember 2099 des Gregorianischen Kalenders. Der Rückgabe<br />
kann als Variant ausgewertet werden.<br />
• Die Funktion IsDate(d) gibt einen Wert vom Typ Boolean zurück, der angibt,<br />
ob der Ausdruck d in ein Datum umgewandelt werden kann. Dies ist genau<br />
dann der Fall, wenn der Rückgabewert True ist. Da Ausdrücke vom Typ<br />
Date intern als Gleitkommazahlen dargestellt werden, gib die IsDate-Funktion<br />
für jeden numerischen Ausdruck den Wert True zurück. Die Zahl 0.5 z.B. entspricht<br />
dem Datumsliteral #12/30/1899 12:00#.
9.3 Datentypen<br />
• Die Funktion Day(d) gibt einen Wert zurück, der den Tag des Monats als ganze<br />
Zahl im Bereich von 1 bis 31 angibt.<br />
• Die Funktion Month(d) gibt einen Wert zurück, der den Monat als ganze Zahl<br />
im Bereich von 1 bis 12 angibt.<br />
• Die Funktion Year(d) gibt einen Wert zurück, der das Jahr als ganze Zahl angibt.<br />
• Die Funktion Hour(d) gibt einen Wert zurück, der die St<strong>und</strong>e als ganze Zahl im<br />
Bereich von 0 bis 23 angibt.<br />
• Die Funktion Minute(d) gibt einen Wert zurück, der die Minute als ganze Zahl<br />
im Bereich von 0 bis 59 angibt.<br />
• Die Funktion Second(d) gibt einen Wert zurück, der die Sek<strong>und</strong>e als ganze Zahl<br />
im Bereich von 0 bis 59 angibt.<br />
• Die Funktion Weekday(d) gibt einen Wert zurück, der den Wochentag als ganze<br />
Zahl angibt. Die Rückgabewerte verlaufen von 1 für Sonntag bis zu 7 für Samstag,<br />
da Wochen immer an einem Sonntag beginnen.<br />
• Die Funktion DateSerial(jahr,monat,tag) erzeugt einen Wert vom Typ<br />
Date, der dem angegebenen Jahres-, Monats- <strong>und</strong> Tageszahlen entspricht. Die<br />
Zeit wird dabei auf 0 Uhr gestellt, d.h. der Rückgabewert entspricht intern einer<br />
ganzen Zahl. So<strong>mit</strong> ist DateSerial(2008,12,24) der Weihnachtstag im Jahr<br />
2008.<br />
• Die Funktion TimeSerial(st<strong>und</strong>e,minute,sek<strong>und</strong>e) erzeugt einen Wert<br />
vom Typ Date, der der angegebenen Uhrzeit für eine bestimmte St<strong>und</strong>e, Minute<br />
<strong>und</strong> Sek<strong>und</strong>e entspricht.<br />
Sub DateTest()<br />
Dim Weihnacht As Date, diff As Long<br />
Dim Tage(1 To 7) As String<br />
Tage(1) = "Sonntag" : Tage(2) = "Montag"<br />
Tage(3) = "Dienstag" : Tage(4) = "Mittwoch"<br />
Tage(5) = "Donnerstag": Tage(6) = "Freitag"<br />
Tage(7) = "Samstag"<br />
Weihnacht = DateSerial(2008, 12, 24) + TimeSerial(18, 0, 0)<br />
’Oder: Weihnacht = #12/24/2008 6:00:00 PM#<br />
diff = DateSerial(2008, 12, 24) - Now + Time<br />
MsgBox "Now: " & Now & ", Time: " & Time & _<br />
121
9 Die Sprachsyntax von Visual Basic<br />
", Tag: " & Tage(Weekday(Now)) & "." & _<br />
vbNewLine & diff & "-mal werden wir noch wach, " _<br />
& "heißa dann ist Weihnachtstach!"<br />
MsgBox "0.5 entspricht: " & vbNewLine & _<br />
Day(0.5) & "." & Month(0.5) & "." & Year(0.5) & _<br />
", " & Hour(0.5) & ":" & Minute(0.5) & ":" & Second(0.5)<br />
End Sub<br />
9.3.16 Typumwandlungsfunktionen<br />
Die einfachste Art der Kommunikation <strong>mit</strong> dem Anwender eines Programms erfolgt über<br />
so genannte Inputboxen, das sind kleine Dialoge <strong>mit</strong> einer Frage <strong>und</strong> einem Antwortfeld.<br />
Darin kann der Anwender eine beliebige Eingabe machen, die Visual Basic natürlich als<br />
Zeichenkette deutet, auch wenn nur Ziffern eingegeben wurden. Die Anwenderin schreibt<br />
21 in ein Textfeld <strong>und</strong> meint die Zahl 21, das Textfeld jedoch vernimmt die Zeichenkette<br />
"21".<br />
Visual Basic verweigert alle arithmetischen Operationen <strong>mit</strong> als Strings verkleideten<br />
Zahlen. Die unentbehrlichen Helfer sind die Typumwandlungsfunktionen<br />
• CInt(Ausdruck)<br />
• CLng(Ausdruck)<br />
• CSng(Ausdruck)<br />
• CDbl(Ausdruck)<br />
• CDec(Ausdruck)<br />
• CCur(Ausdruck)<br />
• CDate(Ausdruck)<br />
welche das Argument Ausdruck in eine Zahl des jeweiligen Typs umwandeln, etwa<br />
CInt() in eine ganze Zahl <strong>und</strong> CDbl() in eine Gleitpunktzahl. Der Ausdruck muss<br />
dabei so sein, dass die Umwandlung gelingen kann.<br />
Im folgenden Beispiel soll über eine Inputbox ein Alter erfragt werden, der misstrauische<br />
Programmierer testet vor der Umwandlung <strong>mit</strong> Hilfe der Funktion IsNumeric(),<br />
ob die Eingabe wirklich als Zahl vorliegt <strong>und</strong> formt erst dann die Zeichenkette in eine<br />
Zahl vom Typ Long um:<br />
Dim i As Long, istr As String<br />
istr = InputBox("Alter", "Alter eingeben", 20)<br />
If (IsNumeric(istr)) Then i = CLng(istr);<br />
122<br />
Weitere Typumwandlungsfunktionen finden Sie in der Online-Hilfe.
9.3.17 Benutzerdefinierte Datentypen<br />
9.3 Datentypen<br />
Die Datentypen von Visual Basic sind die Bausteine für benutzerdefinierte Datentypen,<br />
worin logisch zusammengehörende Einzeltypen zu einem Informationsblock zusammengefasst<br />
werden. Die einzelnen Bestandteile dürfen dabei die Basistypen von Visual Basic<br />
als auch selbst wieder benutzerdefinierte Datentypen sein. Die Deklaration erfolgt über<br />
das Schlüsselwort Type. Wie bei gewöhnlichen Variablen kann der Geltungsbereich über<br />
Private <strong>und</strong> Public bestimmt werden.<br />
Persönliche Daten von Person gehören logisch zusammen <strong>und</strong> bieten sich als benutzerdefinierter<br />
Datentyp an, Der Typname darf frei gewählt werden, etwa Persdat. Der<br />
benutzerdefinierte Datentyp erlaubt die Deklaration von Variablen dieses Typs. Auf die<br />
EinzeleElemente wird wie auf Objekte über den Punktoperator zugegriffen. Die Eigenschaften<br />
erscheinen in einer Listbox <strong>und</strong> können über die Tabulatortaste in den Code<br />
übernommen werden.<br />
Das folgende Modul setzt voraus, dass eine Tabelle Profs vorhanden ist, wo die Daten<br />
der Professoren vorliegen. Name <strong>und</strong> Vorname des ersten Datensatzes werden dabei<br />
ausgelesen <strong>und</strong> in einem Meldungsfenster angezeigt:<br />
Option Explicit<br />
Public Type PersDat<br />
Nachame As String * 20<br />
Vorname As String * 20<br />
Geschlecht As String * 1<br />
GebDat As Date<br />
Gatte As String * 20<br />
Kinder As Integer<br />
FBR As String * 3<br />
Gehalt As Currency<br />
End Type<br />
Sub ZeigeProf()<br />
Dim Prof As PersDat<br />
Sheets("Profs").Activate<br />
Prof.Nachame = Range("A2").Value<br />
Prof.Vorname = Range("B2").Value<br />
MsgBox "Nachame: " & vbTab & Prof.Nachame & vbNewLine _<br />
& "Vorname: " & Prof.Vorname<br />
End Sub<br />
Nach der Zuweisung KopieProf = Prof erhalten alle Datenelemente von KopieProf die<br />
gleichen Werte wie die von Prof.<br />
123
9 Die Sprachsyntax von Visual Basic<br />
9.3.18 Der Datentyp Variant<br />
Der Datentyp Variant ist der Datentyp für alle Variablen, die nicht explizit als anderer<br />
Datentyp deklariert werden, etwa<br />
Dim IchBinVariant As Variant ’Explizit als Variant deklariert<br />
Dim IchAuch ’Variablen ohne Typangabe sind Variant<br />
Variant ist ein besonderer Datentyp, der beliebige Daten <strong>mit</strong> Ausnahme von String-<br />
Daten fester Länge <strong>und</strong> benutzerdefinierten Typen enthalten kann. Variablen vom Typ<br />
Variant passen sich geschmeidig jeder Wertzuweisung an. Wenn Sie zum Beispiel einem<br />
Variant einen Wert vom Datentyp Long zuweisen, interpretieren alle nachfolgenden<br />
Operationen den Variant als Datentyp Long. Wenn Sie jedoch <strong>mit</strong> einem<br />
Variant <strong>mit</strong> dem Typ Byte, Integer, Long oder Single eine arithmetische<br />
Operation ausführen <strong>und</strong> das Ergebnis den zulässigen Bereich für den ursprünglichen<br />
Datentyp überschreitet, wird das Ergebnis innerhalb des Variant automatisch zu<br />
dem nächstgrößeren Datentyp erweitert. Byte wird zu Integer , Integer wird zu<br />
Long, <strong>und</strong> Long bzw. Single werden zu Double umgewandelt. Werden die zulässigen<br />
Bereiche für den Datentyp Currency, Decimal oder Double in einer Variablen<br />
vom Typ Variant überschritten, so tritt ein Fehler auf.<br />
Quelle: Online-Hilfe.<br />
Trotz seiner Geschmeidigkeit sollten Sie diesen Datentyp nur in eng begründeten Ausnahmefällen<br />
verwenden. Die Gefahr besteht darin, dass über diesen Datentyp Operationen<br />
erfogen, die Sie gar nicht beabsichtigen, etwa dass Visual Basic Zeichenketten als<br />
Zahlen oder umgekehrt Zahlen als Zeichenketten auslegt.<br />
9.4 Operatoren, Ausdrücke <strong>und</strong> Anweisungen<br />
9.4.1 Ausdrücke<br />
Ein Ausdruck entsteht aus Konstanten, Variablen sowie anderen Ausdrücken <strong>und</strong> Operatoren<br />
<strong>und</strong> hat immer einen Wert <strong>und</strong> einen Typ. Je nach Typ des Ausdrucks <strong>und</strong> der Art<br />
der beteiligten Operatoren wird zwischen arithmetischen, logischen <strong>und</strong> Zeichenketten-<br />
Ausdrücken unterschieden. Durch das Zeilenende wird aus einem gültigen Ausdruck eine<br />
Anweisung. Gültige Ausdrücke sind:<br />
124<br />
Ausdruck Bemerkung Wert<br />
3 Eine Konstante ist ein Ausdruck 3<br />
x="Gerd" Eine Zuweisung ist ein Ausdruck "Gerd"<br />
3/4 ganzzahlige Division gibt es in Visual Basic<br />
nicht!<br />
0.75<br />
12/5 < 3 arithmetischer Vergleich True<br />
"Helle"
9.4.2 Operatoren<br />
9.4 Operatoren, Ausdrücke <strong>und</strong> Anweisungen<br />
Ein Operator wie etwa +, -, * oder / verknüpft ein, zwei oder mehrere Operanden zu<br />
einem Ausdruck, dessen Wert sich aus den Werten der einzelnen Operanden ergibt. In<br />
Visual Basic gibt es nur unäre (ein Operand) <strong>und</strong> binäre (zwei Operanden) Operatoren.<br />
Viele Operatoren sind mathematischer Natur <strong>und</strong> haben das in der <strong>Mathematik</strong><br />
übliche Symbol. Wie in der <strong>Mathematik</strong> gibt es eine Vorrangliste, die über die Reihenfolge<br />
der Auswertung entscheidet. Es gilt wie üblich die Priorität von Multiplikation <strong>und</strong><br />
Division über Addition <strong>und</strong> Subtraktion, Punktrechnung geht vor Strichrechnung. Die<br />
Auswertung wird durch Setzen von r<strong>und</strong>en Klammern bestimmt, da diese höchste Priorität<br />
haben. Es gibt neben den arithmetischen, auch noch logische sowie Zeichenketten-<br />
Operatoren. Alle arithmetischen Operatoren haben Zahlen als Operanden. Operatoren.<br />
Es gibt drei Arten von arithmetischen Operatoren:<br />
• Der unäre Vorzeichenoperator -.<br />
• Die aus der Algebra bekannten binären Operatoren für Zuweisung, Addition, Subtraktion,<br />
Multiplikation, Division <strong>und</strong> Rest =, +, -, *, /, Mod.<br />
Auf den Operator Mod komme ich später noch zurück. Er gibt den Rest bei ganzzahliger<br />
Division an, d.h. 17 Mod 4ist gleich 1. Der Zuweisungsoperator = unterscheidet sich<br />
in seinem Verhalten vom gewöhnlichen Gleichheitszeichen, daher gehe ich etwas näher<br />
auf ihn ein.<br />
9.4.3 Der Zuweisungsoperator<br />
Der Zuweisungsoperator ist das Gleichheitszeichen »=«. Selbst in diesem harmlosen<br />
Operator ist eine kleine Tücke für den Anfänger enthalten. Die Zuweisung<br />
a = b + 3 + 3*f;<br />
erfolgt wie in der <strong>Mathematik</strong>. Der Ausdruck auf der rechten Seite wird ausgewertet<br />
<strong>und</strong> der Wert wird der Variablen auf der linken Seite zugewiesen. Daher muss der Typ<br />
der Variablen auf der linken Seite <strong>mit</strong> dem Typ des Ausdrucks auf der rechten Seite<br />
übereinstimmen. Ist dies nicht der Fall, versucht der Interpreter den Wert des Ausdruckes<br />
auf der rechten Seite in den Typ der Variablen links umzuwandeln. Ist dies nicht möglich,<br />
so wird die Übersetzung <strong>mit</strong> einer Fehlermeldung abgebrochen.<br />
In fast allen Programmiersprachen sind aber auch Ausdrücke der Form<br />
a = 3*a + 2;<br />
erlaubt. In der Algebra wäre dies eine Gleichung für a <strong>mit</strong> der Lösung a = −1. In Visual<br />
Basic aber wird zunächst der Ausdruck auf der rechten Seite <strong>mit</strong> dem bisherigen Wert<br />
von a berechnet <strong>und</strong> das Ergebnis wird der Variablen a als neuer Wert zugewiesen. Sei<br />
etwa 3 der alte Wert von a, so wird a durch diese Anweisung 11.<br />
Wie alle Ausdrücke hat auch die Zuweisung ein Ergebnis, nämlich den zugewiesenen<br />
Wert, <strong>und</strong> dieser kann nun einer anderen Variablen zugewiesen werden, d.h., es sind<br />
125
9 Die Sprachsyntax von Visual Basic<br />
innerhalb einer Anweisung viele Zuweisungen möglich. Die Auswertung geschieht dabei<br />
von rechts nach links:<br />
a = b = c = 3*d + 1;<br />
Alle drei Variablen haben jetzt den Wert 3*d + 1.<br />
9.4.4 Der Modulooperator<br />
Ein Jahr hat bekanntlich etwas mehr als 365 Tage, in erster Näherung 365,25 Tage. Normale<br />
Kalenderjahre sind also um einen Vierteltag zu kurz! Daher legen die Schaltjahre<br />
alle vier Jahre einen Extratag zu, den 29.2., um in einem Schlag den verlorenen Tag<br />
wieder aufzuholen. Die Jahreszahlen dieser Jahre sind durch vier teilbar.<br />
Wie aber wird dies programmiert? Dazu werfen wir einen Blick zurück in die Gr<strong>und</strong>schule.<br />
Dort wird 17 geteilt durch 3 gleich 5 Rest 2. Bei ganzzahliger Division bleibt<br />
immer ein Rest, es sei denn, der Zähler ist durch den Nenner teilbar. Der Rest heißt<br />
vornehm Modulo, der entsprechende Operator Modulooperator. Der Modulooperator<br />
hat kein eigenes Zeichen, sondern man schreibt Mod. So<strong>mit</strong> ist 17 Mod 4 gleich 1,<br />
16 Mod 4 gleich 0 <strong>und</strong> 22 Mod 4 gleich 2.<br />
Folgende Bedingung überprüft also, ob die Jahreszahl j zu einem Schaltjahr gehört<br />
<strong>und</strong> gibt das Ergebnis in einem Meldungsfenster aus:<br />
If (j Mod 4 = 0) Then _<br />
MsgBox "Das Jahr " & j & "ist ein Schaltjahr."<br />
Ist die Bedingung j Mod 4 = 0 erfüllt, z.B. für 1996, so erscheint über die Funktion<br />
MsgBox() in einem Fenster der Text: Das Jahr 1996 ist ein Schaltjahr.<br />
9.4.5 Der Gregorianische Kalender<br />
Die Idee, alle vier Jahre ein Schaltjahr einzulegen, stammt von den Ägyptern. Julius<br />
Caesar eroberte Ägypten <strong>und</strong> Kleopatra <strong>und</strong> führte in Rom den ägyptischen Kalender<br />
ein <strong>und</strong> reservierte sich bei dieser Gelegenheit gleich noch seinen Geburtsmonat, den<br />
Juli. Der ganze Kalender <strong>mit</strong> 365 Tagen, verteilt auf 12 Monaten <strong>mit</strong> einem zusätzlichen<br />
Tag alle vier Jahre, heißt ebenfalls nach Caesars Vornamen Julianischer Kalender.<br />
Leider ist ein Jahr geringfügig kürzer als 365,25 Tage. Deshalb tut man auf lange<br />
Sicht zuviel des Guten, wenn man alle vier Jahre ein Schaltjahr einlegt. Das merkt man<br />
aber erst nach Jahrh<strong>und</strong>erten. In 400 Jahren hat man drei Tage zuviel angesammelt, der<br />
Frühling fängt schon am 18.3 <strong>und</strong> nicht am 21.3. an. Im 16. Jahrh<strong>und</strong>ert hatten sich dann<br />
bereits 10 überflüssige Tage eingeschlichen, die Sonne stand am 10.6 <strong>und</strong> nicht am 21.6.<br />
am höchsten. Papst Gregor setzte eine Kommission ein, die diesen Missstand beenden<br />
sollte. Zunächst wurden im im Oktober 1582 10 Tage ausgelassen. Dann wurden von<br />
jetzt an innerhalb von 400 Jahren drei Schaltjahre gestrichen, <strong>und</strong> zwar <strong>mit</strong> Ausnahme<br />
der durch 400 teilbaren Jahre alle Anfänge der Jahrh<strong>und</strong>erte, also z.B. die Jahre 1700,<br />
1800 <strong>und</strong> 1900. Alle durch 400 teilbaren Jahre bleiben Schaltjahre, etwa 1600, 2000 <strong>und</strong><br />
2400. Ein Jahr ist also genau dann Schaltjahr, wenn es durch 400 teilbar ist oder durch<br />
126
9.4 Operatoren, Ausdrücke <strong>und</strong> Anweisungen<br />
4 aber nicht durch 100. Schon in 3000 Jahren wird wieder eine Korrektur nötig sein,<br />
stellen Sie sich rechtzeitig darauf ein.<br />
Seit 1582 gilt in katholischen Ländern der neue, zu Ehren von Papst Gregor Gregorianisch<br />
genannte Kalender, obwohl die eigentliche Idee von einem Bayer stammt. Die<br />
deutschen Protestanten zogen nach kurzem Schmollen im frühen 18. Jahrh<strong>und</strong>ert nach,<br />
die Angelsachsen sogar erst 1752 <strong>und</strong> in Russland bedurfte es der Oktoberrevolution<br />
(eigentlich im November!) zum Anschluss an den Kalender des Westens. Die Griechen<br />
blieben kirchlich immer beim alten Julianischen Kalender <strong>und</strong> feiern so<strong>mit</strong> Ostern an<br />
einem anderen Termin als wir. Der 1.1.1582 war ein übrigens ein Freitag.<br />
Die komplizierten Zusammenhänge können wir noch nicht in Code fassen. Wir benötigen<br />
dazu die Verbindung von logischen Ausdrücken.<br />
9.4.6 Logische Ausdrücke <strong>und</strong> Operatoren<br />
Logische Ausdrücke entstehen durch Vergleiche, etwa a < b, was nur wahr oder falsch<br />
sein kann. Die folgenden sechs Vergleichsoperatoren vergleichen zwei Ausdrücke x <strong>und</strong><br />
y bezüglich ihrer Anordnung:<br />
Syntax Beschreibung Syntax Beschreibung<br />
x > y x größer als y x < y x kleiner als y<br />
x >= y x größer gleich y x 20 ) Then _<br />
MsgBox "Veronika, der Lenz ist da!"<br />
Zwei logische Ausdrücke können wie in der Umgangssprache durch UND sowie ODER<br />
verknüpft werden. Eine Bedingung, die durch zwei <strong>mit</strong> UND verb<strong>und</strong>ene Einzelbedingungen<br />
entsteht, ist genau dann erfüllt, wenn beide Bedingungen wahr sind. Die Verknüpfung<br />
<strong>mit</strong> ODER weicht von der Umgangssprache ab, wo oder häufig entweder, oder<br />
meint, wie in dem Vorhaben CDU oder FDP zu wählen. Anders ist die Bedeutung von<br />
oder in der Aussage, Milch gibt es bei Edeka oder Aldi. Es wird erwartet, Milch in mindestens<br />
einem Laden zu finden, möglicherweise auch in beiden. Genauso wird ODER<br />
in der Logik verstanden. Eine Bedingung, die aus zwei <strong>mit</strong> ODER verb<strong>und</strong>enen Be-<br />
127
9 Die Sprachsyntax von Visual Basic<br />
dingungen entsteht, ist genau dann zutreffend, wenn wenigstens eine Bedingung erfüllt<br />
ist.<br />
Neben UND sowie ODER gibt es noch drei weitere binäre logische Operatoren, die<br />
aber sehr selten benötigt werden. Werden zwei logische Ausdrücke X <strong>und</strong> Y durch das<br />
exklusive ODER verb<strong>und</strong>en, ist das Ergebnis genau dann True, wenn genau einer der<br />
beiden Operatoren True ist. Verknüpft man X <strong>und</strong> Y durch den Operator Eqv, der<br />
für äquivalent steht, so ist das Ergebnis nur True, wenn beide Operatoren denselben<br />
Wert haben. Der Implikationsoperator heißt Imp. Das Ergebnis X Imp Y ist immer<br />
True, außer wenn X den Wert True hat <strong>und</strong> dann Y = False ist.<br />
Die Verneinung oder Negation wird durch den unären Operator Not realisiert, der<br />
nur auf einen Ausdruck wirkt. Das Ergebnis ist das logische Gegenteil des Ausdrucks.<br />
Die sechs logischen binären Operatoren von Visual Basic sind in folgender Wahrheitstabelle<br />
zusammengefasst:<br />
Operator Bedeutung Ergebnis = True, wenn<br />
Not X Negation X = False<br />
X And Y Konjunktion X = True <strong>und</strong> Y = True<br />
X Or Y inklusives Oder mindestens ein Ausdruck = True<br />
X Xor Y exklusives Oder genau ein Ausdruck = True<br />
X Eqv Y Äquivalenz beide Ausdrücke gemeinsam = True oder False<br />
X Imp Y Implikation außer wenn X = True <strong>und</strong> Y = False<br />
Dabei bezeichnen X <strong>und</strong> Y die Operanden. Typische Beispiele sind:<br />
If(a = 3 And c 5) Then Anweisung;<br />
If(a < 6 Or x > 4) Then Anweisung;<br />
If(Not(a < 6 Or x > 4)) Then Anweisung;<br />
Manchmal muss geprüft werden, ob eine Variable x einen Wert innerhalb der Grenzen<br />
a <strong>und</strong> b hat. Dies geschieht korrekt wie folgt:<br />
If(x > a And x < b) Then Anweisung<br />
während die folgende verkürzte Form zwar gut gemeint, aber syntaktisch falsch ist:<br />
If(b > x > a) Then Anweisung;<br />
Mit Hilfe der logischen Operatoren sind wir jetzt auch in der Lage, die Schaltjahrbedingung<br />
richtig zu formulieren:<br />
If ((j Mod 400 = 0) Or (j Mod 4 = 0 And j Mod 100 0)) _<br />
Then MsgBox "Das Jahr " & j & "ist ein Schaltjahr."<br />
9.4.7 Vorrangregeln<br />
Wir wenden uns der Frage zu, in welcher Reihenfolge der Übersetzer Ausdrücke <strong>mit</strong><br />
mehreren Operatoren auswertet. Die Operatoren sind nach Priorität geordnet, so dass<br />
wie beim Rechnen der Ausdruck<br />
128
2*3 + 4*5<br />
9.5 Funktionen <strong>und</strong> Sub-Prozeduren<br />
den Wert 26 hat <strong>und</strong> nicht 50, was sich bei sturer Auswertung von rechts nach links ergibt.<br />
Auch die Kombination von arithmetischen <strong>und</strong> logischen Operationen funktioniert<br />
ohne Klammern. Denn<br />
a + b < c*d<br />
wird vom Übersetzer als<br />
(a + b) < (c*d)<br />
interpretiert. Dieses vernünftige Verhalten wird durch folgende Vorrangtabelle geregelt,<br />
wobei alle Operatoren innerhalb einer Zeile gleiche Priorität haben <strong>und</strong> die Priorität von<br />
oben nach unten abnimmt.<br />
Operator Beschreibung<br />
. oder ! Zugriff auf Methode oder Attribut<br />
( )<br />
Zugriff auf Vektorelement über Index<br />
( )<br />
Klammersetzen, Funktionsaufruf<br />
Not<br />
logische Verneinung<br />
* / Mod Multiplikation, Division, Modulo<br />
+ - Addition <strong>und</strong> Subtraktion<br />
< >= arithmetische Vergleiche<br />
= arithmetische Gleichheit <strong>und</strong> Ungleichheit<br />
And<br />
Or<br />
=<br />
logisches UND<br />
logisches ODER<br />
Zuweisung<br />
9.5 Funktionen <strong>und</strong> Sub-Prozeduren<br />
Funktionen enthalten Code, der an vielen Stellen des Programms benötigt, aber nur<br />
einmal geschrieben wird. Programme werden dadurch knapper <strong>und</strong> übersichtlicher. Ein<br />
einfacher Aufruf der Funktion setzt deren Code in Gang, etwa sin(3.14) eine komplizierte<br />
nummerische Prozedur zur Berechnung dieses Ausdrucks. Dieselbe Prozedur<br />
wird zur Berechnung von sin(2.1) nötig, nur tritt nun 2.1 an die Stelle von 3.14. Die<br />
Gr<strong>und</strong>idee besteht darin, ganz von den konkreten Werten abzuheben <strong>und</strong> einen generellen<br />
Stellvertreter etwa x einzusetzen, an dessen Stelle dann beim Funktionsaufruf die<br />
tatsächlichen Werte treten. Ein Funktionsaufruf ist ein Ausdruck, daher muss jede Funktion<br />
einen Typ haben. Wie sin(x) erlauben die meisten Funktionen die Übergabe von<br />
Parametern. Die übergebenen Parameter heißen aktuelle Parameter, doch deren Werte<br />
sind beim Schreiben der Funktion nicht bekannt, nur ihr Typ. Daher erlaubt der Rechner<br />
sin(3.14) <strong>und</strong> weist sin("Hans") ab. Stellvertretend für die aktuellen Parameter<br />
129
9 Die Sprachsyntax von Visual Basic<br />
stehen im Code einer Funktion die formalen Parameter, z.B. bei sin(x) der formale<br />
Parameter x für alle reellen Zahlen. Es gibt zwei Arten der Übergabe von aktuellen Parametern<br />
an Funktionen, <strong>und</strong> zwar die Übergabe als Original, was <strong>mit</strong> Referenzübergabe<br />
(call by reference) bezeichnet wird oder nur als Kopie, die sogenannte Wertübergabe (call<br />
by value). Im ersten Fall verfügt die Funktion über die Originale der aktuellen Parameter<br />
<strong>und</strong> kann deren Werte daher verändern, während im anderen Fall die Änderungen<br />
innerhalb der Funktion nach außen ohne Folgen bleiben, da nur <strong>mit</strong> Kopien gearbeitet<br />
wurde.<br />
9.5.1 Einführendes Beispiel<br />
Funktionen bilden die Basis von <strong>Excel</strong>. Es gibt für viele Probleme eine geeignete Funktion.<br />
Aber manchmal fehlt die richtige oder man muss endlose Klimmzüge machen. Der<br />
Ausweg sind selbst geschriebene Funktionen, wozu man aber die zum Office-Paket gehörende<br />
Programmiersprache <strong>VBA</strong> lernen muss. Wir werden an einem vereinfachten<br />
Problem zeigen, wie einfach es geht.<br />
Im glücklichen Staat Merkelien lohnen sich Arbeit <strong>und</strong> Kinderkriegen. Unabhängig von<br />
der Tätigkeit erhalten alle Menschen ein einheitliches Gehalt nach folgendem Prinzip.<br />
Bis zum Alter von 30 Jahren beträgt das Gr<strong>und</strong>gehalt 500 Merkel. Im Alter von 31 <strong>und</strong><br />
45 bekommt man 1000 Merkel <strong>und</strong> ab dann sogar 1500 Merkel. Pro Kind gibt es dazu<br />
eine Zulage von 300 Merkel.<br />
Die Steuer richtet sich nach der Größe des Haushalts, Ledige bezahlen 40% Steuer,<br />
Haushalte <strong>mit</strong> zwei Personen (unverheiratet <strong>und</strong> ein Kind oder verheiratet ohne Kinder)<br />
entrichten 30% Steuer <strong>und</strong> alle größeren Haushalte werden sogar nur <strong>mit</strong> 20% besteuert.<br />
Wir benötigen also zwei Funktionen Gehalt()<strong>und</strong> Steuer(), wobei die erste Funktion<br />
zwei Parameter hat <strong>und</strong> die andere sogar drei. Ich werfe Sie gleich ins Wasser <strong>und</strong><br />
gebe die Funktion Gehalt()sofort an:<br />
Function Gehalt(ByVal al As Long, ByVal k As Long) _<br />
As Long<br />
Dim Gr<strong>und</strong>gehalt as Long<br />
Gr<strong>und</strong>gehalt = 500<br />
If (al > 30 And al < 46) Then Gr<strong>und</strong>gehalt = 1000<br />
If (al >= 46) Then Gr<strong>und</strong>gehalt = 1500<br />
Gehalt = Gr<strong>und</strong>gehalt + k*300<br />
End Function<br />
Nach dem Aufruf werden die Anweisungen der Funktion ausgeführt. Funktionen werden<br />
gewissermaßen auf Vorrat geschrieben, der Code wird nur ausgeführt, wenn <strong>Excel</strong> oder<br />
eine andere Funktion die Funktion aufrufen, was beliebig oft erfolgen kann. Der Wert einer<br />
Funktion ist abhängig von den Werten der an die Funktion übergebenen Parameter.<br />
In der folgenden Tabelle sind die Werte der Funktion in Abhängigkeit einiger Werte der<br />
130
Parameter al <strong>und</strong> k angegeben:<br />
9.5 Funktionen <strong>und</strong> Sub-Prozeduren<br />
al 20 31 56<br />
k 1 3 4<br />
Gehalt(al, k) 500 + 300 = 800 1000 + 900 = 1900 1500 + 1200 = 2700<br />
9.5.2 Syntax von Funktionen<br />
Syntaktisch haben Funktionen die Gr<strong>und</strong>form:<br />
Function Name_der_Funktion(Parameterliste)<br />
Anweisungen<br />
End Function<br />
Funktionen haben einen Kopf, der aus dem Schlüsselwort Function, dem Namen <strong>und</strong><br />
der Parameterliste besteht. Das Ende wird durch das Schlüsselwort End Function<br />
angezeigt, dazwischen liegt der Rumpf, der aus den so genannten Anweisungen besteht.<br />
Sie dürfen niemals die r<strong>und</strong>en Klammern für die Parameterliste weglassen! Vor jedem<br />
Parameter steht das Schlüsselwort ByVal, nach jedem Parameter des Typ, wobei auf<br />
As zu achten ist. Funktionen kommen erst bei einem Aufruf ins Spiel.<br />
In jeder Funktion gibt es eine Variable, die aber nicht deklariert werden darf, <strong>und</strong><br />
zwar diejenige, welche den Namen der Funktion trägt. Ich werde diese Variable Funktionsvariable<br />
nennen In unserem Beispiel ist dies die Variable Gehalt, da die Funktion<br />
so heißt. Der Typ der Funktonsvariablen entspricht dem Typ der Funktion, hier also hat<br />
die Variable Gehalt den Typ Double.<br />
Jede Funktion gibt einen Wert zurück, <strong>und</strong> zwar denjenigen Wert, den die Funktionsvariable<br />
hat, wenn die letzte Anweisung der Funktion ausgeführt ist. Sei beispielsweise<br />
folgende Funktion gegeben, welche genau dann True zurückgibt, wenn das Jahr ein<br />
Schaltjahr ist:<br />
Function Schaltjahr(ByVal j As Long) As Boolean<br />
Schaltjahr = (j Mod 400 = 0) Or (j Mod 4 = 0 And j Mod 100 0)<br />
End Function<br />
Hier ist die Funktionsvariable Schaltjahr <strong>und</strong> die Funktion wird entweder die Zahl<br />
True oder False zurückgeben, abhängig davon ob der logische Ausdruck der Schaltjahrbedingung<br />
stimmt oder nicht.<br />
9.5.3 Verwendung von Funktionen in <strong>Excel</strong><br />
Jede selbst geschriebene Funktion kann in <strong>Excel</strong> verwendet werden. Sie tauchen in der<br />
Kategorie benutzerdefiniert auf.<br />
9.5.4 Aufruf von Funktionen in <strong>VBA</strong><br />
Funktionen werden auf Vorrat geschrieben <strong>und</strong> müssen erst durch einen Aufruf in Gang<br />
gesetzt werden. Der Rechner nimmt daher Funktionen zunächst nur zur Kenntnis, über-<br />
131
9 Die Sprachsyntax von Visual Basic<br />
prüft die syntaktische Korrektheit <strong>und</strong> unternimmt dann nichts weiter. Erst beim Aufruf<br />
kommt die Maschinerie in Bewegung.<br />
Folgende Aufrufe der Funktion Brutto()sind falsch:<br />
Dim s As Double<br />
s = Gehal(20, 3) ’falscher Namen, Gehal statt Gehalt<br />
s = Gehalt("Pi", 3.14) ’unsinnige Parametertypen<br />
s = Gehalt(20, 3, 12) ’zu viele Parameter<br />
Funktionen ohne rufende Prozeduren sind wie Fische ohne Fahrräder. Liefern wir<br />
schnell eine Sub-Prozedur nach, welche die Funktion Gehalt() zweimal aufruft, wobei<br />
die aktuellen Parameter einmal Variablen <strong>und</strong> dann Konstanten sind:<br />
Sub GehaltTest()<br />
Dim a As Long, k As Long<br />
a = 48: k = 3<br />
MsgBox "Alter: " & a & ", Kinder: " & k & ", _<br />
Gehalt: " & Gehalt(a, k)<br />
MsgBox "Alter: 35" & ", Kinder: 2" & ", _<br />
Gehalt: " & Gehalt(35, 2)<br />
End Sub<br />
Die Ausgabe lautet im ersten Fall: Alter: 48, Kinder: 3, Gehalt: 2400 <strong>und</strong> im zweiten:<br />
Alter: 35, Kinder: 2, Gehalt: 1600<br />
Die Implementation der Testroutine kann vor oder nach der Funktion stehen. Ich habe<br />
die Funktion insgesamt zweimal aufgerufen, immer <strong>mit</strong> anderen aktuellen Parametern.<br />
Ich werde jetzt näher beschreiben, was bei der Parameterübergabe geschieht.<br />
9.5.5 Formale <strong>und</strong> aktuelle Parameter von Funktionen<br />
Was aber geschieht eigentlich bei einem Aufruf wie<br />
s = Gehalt(20, 3)<br />
Im Prototyp der Funktion Gehalt(al, k)erscheinen al <strong>und</strong> k als so genannte formale<br />
Parameter. Die beim Aufruf eingesetzten Parameter heißen aktuelle Parameter.<br />
Viele Anfänger glauben beide Parameter seien identisch, aber das ist sehr falsch. Jede<br />
Variable oder Konstante, die den gleichen Typ wie der zugehörige formale Parameter<br />
hat, darf rein syntaktisch der entsprechende aktuelle Parameter werden, so wie jeder<br />
Deutsche das Recht hat B<strong>und</strong>eskanzler zu werden. In diesem Beispiel ist das Gr<strong>und</strong>gesetz<br />
die Funktion, B<strong>und</strong>eskanzler der formale Parameter <strong>und</strong> Angela Merkel der aktuelle<br />
Parameter.<br />
Beim Aufruf Gehalt(20, 3)wird der formale Parameter al <strong>mit</strong> dem Wert 20 initialisiert<br />
<strong>und</strong> der formale Parameter k <strong>mit</strong> 3. Der Funktionsrumpf startet anschließend<br />
<strong>mit</strong> diesen Startwerten für die formalen Parameter. Innerhalb der Funktion kann später<br />
aber der formale Parameter neue Werte annehmen. Es spielt deshalb keine Rolle, welche<br />
Bezeichner die formalen Parameter haben. Statt al <strong>und</strong> k hätte ich auch alter <strong>und</strong><br />
132
9.5 Funktionen <strong>und</strong> Sub-Prozeduren<br />
kinder verwenden können. Der Name von formalen Parametern ist Schall <strong>und</strong> Rauch,<br />
da sie nur eine Stellvertreterrolle für die aktuellen Parameter einnehmen.<br />
Viele Anfänger glauben dagegen, dass Funktionen nur <strong>mit</strong> aktuellen Parametern aufgerufen<br />
werden dürfen, die genauso heißen wie die formalen. Das ist natürlich falsch,<br />
da aktuelle <strong>und</strong> formale Parameter nur einmal in Kontakt treten, <strong>und</strong> zwar beim Aufruf.<br />
Die Funktion richtet ihre eigenen Speicherbereiche für die formalen Parameter ein<br />
<strong>und</strong> initialisiert diese <strong>mit</strong> den Werten der aktuellen Parameter. Danach trennen sich die<br />
Wege von aktuellen <strong>und</strong> formalen Parametern wieder. Deshalb kann eine Funktion auch<br />
niemals die Werte der aktuellen Parameter ändern.<br />
Die aktuellen Parameter werden also nicht als Originale übergeben, sondern nur deren<br />
Werte. Die Funktion legt für jeden formalen Parameter eine Variable an <strong>und</strong> initialisiert<br />
diese <strong>mit</strong> dem Wert des aktuellen Parameters. Deshalb ist eine Veränderung des formalen<br />
Parameters innerhalb der Funktion ohne Auswirkung auf den aktuellen, da dieser<br />
sich nicht selbst in die Funktion einbringt, sondern nur seinen Wert übergibt. Diese Art<br />
der Parameterübergabe heißt daher call by value oder Übergabe durch den Wert, anschaulicher<br />
wäre Übergabe als Kopie. Die Übergabe als Wert wird in Visual Basic durch<br />
das Schlüsselwort ByVal gekennzeichnet.<br />
9.5.6 Parameterübergabe durch Referenz<br />
Bisher haben wir Funktionen <strong>und</strong> Sub-Prozeduren die Parameter immer als Wert übergeben.<br />
Die Funktion legt für jeden aktuellen Parameter einen eigenen formalen Parameter<br />
an <strong>und</strong> initialisiert die formalen Paramter <strong>mit</strong> den Werten der aktuellen, lässt diese<br />
selbst aber unbehelligt. Daher können bei dieser Art der Paramterübergabe die Werte<br />
der aktuellen Parameter durch einen Funktionsaufruf auch nicht verändert werden.<br />
Visual Basic ermöglicht noch eine zweite Form der Parameterübergabe, wo beim Aufruf<br />
der aktuelle Parameter als Original an die Funktion übergeben wird. Diese zweite<br />
Form muss <strong>mit</strong> dem Zeichen ByRef vor dem formalen Parameter angezeigt werden.<br />
Bei formalen Parametern, die so markiert sind, tritt innerhalb der Funktion anstelle des<br />
formalen Parameters der aktuelle Parameter <strong>und</strong> kann daher von der Prozedur umgestaltet<br />
werden, da er sich im Jargon der Selbsterfahrungsgruppen gesprochen voll in die<br />
Prozedur einbringt. Dieses Verhalten wird auf englisch call by reference <strong>und</strong> im Deutschen<br />
Übergabe durch Referenz genannt, treffender wäre Übergabe als Original. Die<br />
Bezeichnungen drücken aus, dass der formale Parameter lediglich ein anderer Name,<br />
eben eine Referenz, für den aktuellen Parameter ist. Die Wertübergabe ist aufwendiger<br />
als die Referenzübergabe, da für die formalen Parameter Variablen angelegt <strong>und</strong> diese<br />
<strong>mit</strong> den Werten der aktuellen Parameter initialisiert werden müssen.<br />
Die folgende Sub-Prozedur vertauscht die Werte zweier Zahlen. Ihr müssen deshalb<br />
die Werte als Referenz übergeben werden.<br />
Sub Tausch(ByRef i As Long, ByRef j As Long)<br />
Dim h As Long<br />
h = j<br />
j = i<br />
133
9 Die Sprachsyntax von Visual Basic<br />
i = h<br />
End Sub<br />
Hätte ich die Sub-Prozedur Tausch()versehentlich <strong>mit</strong> Wertübergaben ausgestattet,<br />
so wären zwar die formalen Parameter innerhalb der Sub-Prozedur geändert worden,<br />
nicht aber die aktuellen Parameter. Ich nenne die falsche Version TauschtNicht():<br />
Sub TauschtNicht(ByVal i As Long, ByVal j As Long)<br />
Dim h As Long<br />
h = j<br />
j = i<br />
i = h<br />
End Sub<br />
Im folgenden Programmstück werden die Werte der Variablen a <strong>und</strong> b erfolgreich vertauscht,<br />
nicht aber von c <strong>und</strong> d:<br />
Sub TauschTest()<br />
Dim a As Long, b As Long, c As Long, d As Long<br />
a = 1: b = 2: c = 3: d = 4<br />
Tausch a, b<br />
TauschtNicht c, d<br />
MsgBox "a = " & a & ", b = " & b & ", c = " & c & ", d = " & d<br />
End Sub<br />
Die Ausgabe lautet dann<br />
a = 2, b = 1, c = 3, d = 4<br />
Nur aktuelle Parameter, die als Referenz, also als Original übergeben werden, können<br />
von einer Funktion oder Sub-Prozedur verändert werden. Ein Aufruf der Art<br />
Tausch 10, 20<br />
ist dagegen nicht erlaubt, da bei Konstanten die Werte unveränderlich sind <strong>und</strong> daher<br />
auch nicht vertauscht werden können.<br />
9.5.7 Objekte als Parameter<br />
Die Wertübergabe ist aufwendiger als die Referenzübergabe, da für die formalen Parameter<br />
Variablen angelegt <strong>und</strong> diese <strong>mit</strong> den Werten der aktuellen Parameter initialisiert<br />
werden müssen. Bei Parameter vom Typ Long oder Double ist das Anlegen einer<br />
Kopie kein Problem.<br />
Zusammengesetze Datentypen wie Datenfelder, Zeichenketten oder selbstdefinierte<br />
Typen bezeichnet man als Objektdatentypen, die Realisationen als Objekte. Als Ganzes<br />
bilden gleichartige Objekte eine so genannte Klasse. Streng genommen bilden natürlich<br />
auch die einfachen Datentypen eine Klasse, etwa die Klasse der ganzen Zahlen vom Typ<br />
Long. Man spricht aber erst dann von Objekten, wenn eine gewisse Komplexität dazu<br />
134
9.5 Funktionen <strong>und</strong> Sub-Prozeduren<br />
kommt, wie bei Zeichenketten oder Datenfeldern. Der erhöhte Speicherbedarf von Objekten<br />
verbietet daher die Übergabe als Kopie. Man übergibt deshalb Objekte immer<br />
als Referenz, auch wenn man die Werte der Argumente gar nicht ändern will.<br />
Ich halte mich also an folgende Regel:<br />
Objekte werden immer als Referenz, einfache Variablen fast immer als Wert übergeben,<br />
die einzige sinnvolle Ausnahme ist die schon beschriebene Sub-Prozedur Tausch.<br />
Ich zeige dies am Beispiel einer Zeichenkettenfunktion. Dabei werden die Funktionen<br />
Left, Right <strong>und</strong> InStr in der folgenden Funktion verwendet, die zu einer eine Zahl<br />
darstellenden Zeichenkette eine Zeichenkette liefert, wo das Dezimalkomma durch den<br />
Dezimalpunkt ersetzt wird:<br />
Function KommaZuPunkt(ByRef z As String)<br />
Dim i As Long<br />
KommaZuPunkt = z<br />
i = InStr(z, ",")<br />
If(i > 0) Then KommaZuPunkt = Left(z,i - 1) & "." _<br />
& Right(z, Len(z) - i)<br />
End Function<br />
Der formale Parameter z vom Typ String wird als Referenz übergeben, obwohl er<br />
innerhalb der Prozedur nicht verändert wird..<br />
Auch hierzu eine Testprozedur. Am Beispiel der Zeichenfolge "Hallo Welt"werden<br />
die erwähnten Funktionen getestet. Danach wird in der europäisch geschriebenen Zahl<br />
"3,14"das Komma durch einen Punkt ersetzt.<br />
Sub KommaTest()<br />
Dim pi As String<br />
pi = "3,14"<br />
MsgBox "Europäisches pi = " & pi<br />
pi = KommaZuPunkt(pi)<br />
MsgBox "Amerikanisches pi = " & pi<br />
End Sub<br />
9.5.8 ByRef klappt nicht bei Strings<br />
Die obige Funktion lässt die ursprüngliche Zeichenkette unverändert <strong>und</strong> liefert eine<br />
neue, wo das Komma durch einen Punkt ersetzt ist. Bei der folgenden Sub-Prozedur soll<br />
dagegen in der ursprüngliche Zeichenkette selbst der Dezimalpunkt durch ein Komma zu<br />
ersetzt werden. Das geht scheinbar ganz einfach wie folgt, klappt aber nicht <strong>und</strong> ich weiß<br />
noch nicht wieso. Muss an der internen Darstellung von Zeichenketten in Basic liegen,<br />
die anders als in C keine Null-terminierten Zeichenketten sind.<br />
Sub KommaWegGehtAberNicht(ByRef z As String)<br />
Dim i As Long<br />
i = InStr(z, ",")<br />
If(i > 0) Then z = Left(z,i - 1) & "." _<br />
135
9 Die Sprachsyntax von Visual Basic<br />
End Sub<br />
& Right(z, Len(z) - i)<br />
Sollte z verändern, tut es aber nicht! Tant pis.<br />
Kurz <strong>und</strong> gut: Man kann Zeichenketten innerhalb einer Prozedur zwar ändern, aber<br />
die Zeichenkette bleibt nach dem Aufruf trotzdem unverändert. Dagegen klappt die<br />
Rückgabe einer Zeichenkette als Funktionswert reibungslos.<br />
9.5.9 Vektoren als Parameter<br />
Vektoren sind ebenfalls Objekte <strong>und</strong> werden immer als Referenz übergeben, vor den<br />
formalen Parametern steht also immer ByRef, gefolgt vom Bezeichner <strong>mit</strong> offenen leeren<br />
Klammern. Beim Aufruf dürfen Sie aber keine Klammern setzen! Die Werte der Elemente<br />
des Vektors können innerhalb der Funktion geändert werden.<br />
Als Beispiel sei ein Selbstständiger betrachtet, der in bestimmten Monaten eines Jahres<br />
die Umsätze U(i) machte <strong>und</strong> jetzt den Monat <strong>mit</strong> dem größten Umsatz er<strong>mit</strong>teln<br />
möchte. Die Umsatzwerte stehen in einem Vektor U unbekannter Dimension. Die Unter<strong>und</strong><br />
Obergrenze des Vektors liefern die Funktionen LBo<strong>und</strong> <strong>und</strong> UBo<strong>und</strong>.<br />
Ich habe einen Modul VektorFunk eingerichtet, der wie üblich <strong>mit</strong> Option Explicit beginnt<br />
<strong>und</strong> einen dynamischen Vektor deklariert. Danach folgt die Funktion zur Bestimmung<br />
des maximalen Umsatzes. Zum Testen der Funktion habe ich eine kleine Sub-Prozedur<br />
geschrieben. Das vollständige Modul lautet:<br />
Option Explicit<br />
Private V() As Double<br />
Function UMax(ByRef U() As Double) As Double<br />
Dim i As Long, k As Long<br />
k = LBo<strong>und</strong>(U, 1)<br />
UMax = U(k)<br />
For i = k + 1 To UBo<strong>und</strong>(U, 1)<br />
If (U(i) > UMax) Then UMax = U(i)<br />
Next i<br />
End Function<br />
Sub TestVecFunction()<br />
Dim dm As Long, i As Long<br />
dm = InputBox("Dimension des Vektors:", "Eingeben!", "")<br />
ReDim V(dm - 1)<br />
136<br />
For i = 0 To dm - 1<br />
V(i) = InputBox("Wert der Komponente V(" & i & "):" _<br />
, "Eingeben!", "")
Next i<br />
MsgBox "Maximaler Umsatz:" & UMax(V)<br />
End Sub<br />
9.6 Ablaufkontrolle<br />
Die Bestimmung des maximalen Umsatzes besorgt eine bedingte Anweisung, die für alle<br />
Komponenten des Vektors wiederholt wird. Vor der Schleife müssen bestimmte Vorbereitungen<br />
getroffen werden. Bei der Suche nach dem Maximum wird der Wert UMax vor<br />
der Schleife initialisiert.<br />
Die Testprozedur erfragt zunächst die Dimension des Vektors <strong>und</strong> lässt sich danach<br />
die Werte eingeben. Die Dimension des dynamischen Vektors wird durch die Redim-<br />
Anweisung festgelegt.<br />
9.6 Ablaufkontrolle<br />
Die Anweisungen innerhalb eines Programmes werden hintereinander so ausgeführt wie<br />
sie im Quelltext stehen. In Visual Basic gibt es wie in allen höheren Programmiersprachen<br />
die Möglichkeit den Ablauf zu steuern. Dabei handelt es sich um Auswahl, Wiederholungen<br />
<strong>und</strong> Sprünge. Diese sogenannten Kontrollstrukturen verändern die sture<br />
sequentielle Reihenfolge der Verarbeitung <strong>und</strong> ermöglichen erst die Programmierung<br />
komplexer Probleme. Bei der If-Anweisung werden bestimmte Anweisungen nur unter<br />
Einhaltung einer Bedingung ausgeführt <strong>und</strong> das If . . . Else-Konstrukt sorgt für Alternativen.<br />
Mit Select Case wird die Auswahl aus einer Reihe von Optionen ermöglicht.<br />
Für die Wiederholung einer bestimmten Gruppe von Anweisungen gibt es ebenfalls eine<br />
Reihe von Sprachelementen. Bei der For-Anweisung steht die Anzahl der Wiederholungen<br />
von Anfang an fest, während die While-Anweisung die Wiederholung von einer<br />
Bedingung abhängig macht. Das dritte Steuerungselement sind die Sprünge. Dabei wird<br />
von einer Anweisung zu einer anderen gesprungen. Aus Funktionen <strong>und</strong> Sub-Prozeduren<br />
wird <strong>mit</strong> Exit Function bzw. Exit Sub zurück zu der Anweisung gesprungen, die<br />
un<strong>mit</strong>telbar auf den Aufruf folgt. Das Schmuddelkind unter den Sprüngen ist die Goto-<br />
Anweisung, die den Sprung zu einer <strong>mit</strong> einer Marke versehenen Anweisung erlaubt.<br />
9.6.1 Blöcke<br />
Mehrere Anweisungen können durch gleichartige Schlüsselworte zu einem Block zusammengefasst<br />
werden, wobei das schließende Schlüsselwort fast immer <strong>mit</strong> End anfängt.<br />
Funktionsrümpfe bilden etwa einen Block. Blöcke dürfen innerhalb eines anderen Blocks<br />
stehen.<br />
Die Notwendigkeit von Blöcken sei am Beispiel der bedingten Anweisung erläutert. Auf<br />
Drängen erboster Jungwähler wurden die Gehaltsvorschriften in Merkelien zugunsten der<br />
Jüngeren leicht verändert. Die drei Altersstufen <strong>mit</strong> den Gr<strong>und</strong>gehältern von 500, 1000<br />
<strong>und</strong> 1500 Merkel bleiben erhalten, aber das Kindergeld wurde altersabhängig auf 300,<br />
250 <strong>und</strong> 200 Merkel festgesetzt. So<strong>mit</strong> muss auf die die If-Bedingung ein ganzer Block<br />
folgen:<br />
137
9 Die Sprachsyntax von Visual Basic<br />
If (alter < 31) Then<br />
Gr<strong>und</strong>gehalt = 500<br />
kindergeld = 300<br />
End If<br />
Die Anweisungen innerhalb des Blocks werden nur ausgeführt, wenn der logische Ausdruck<br />
innerhalb der r<strong>und</strong>en Klammern den Wert True hat.<br />
Bitte achten Sie auf die allgemein übliche Schreibweise. Das E der End If-Anweisung<br />
steht in der gleichen Spalte wie das I von If. Die nachfolgenden Anweisungen werden<br />
zwei bis drei Spalten eingerückt. Soll auf die Bedingung nur eine Anweisung folgen, so<br />
steht diese in derselben Zeile wie die If-Bedingung. Sollen mehrere Anweisungen folgen,<br />
so muss man nach dem Then eine neue Zeile beginnen <strong>und</strong> abschließend für das<br />
End If sorgen.<br />
9.6.2 If. . . Else-Anweisung<br />
Die einseitige Alternative <strong>mit</strong> If-Bedingung führt die folgende Anweisung bzw. den Anweisungsblock<br />
aus, wenn die Bedingung wahr ist. Ist die Bedingung falsch, werden die<br />
Anweisungen übersprungen. Wie in der Umgangssprache gibt es aber auch die echte Alternative.<br />
Bestimmte Handlungen werden bei Erfüllung der Bedingung ausgeführt, sonst<br />
aber wird etwas anderes getan. Diese Form bietet auch die Syntax von Visual Basic an:<br />
If(Bedingung) Then<br />
Anweisung(en)<br />
Else<br />
Anweisung(en)<br />
End If<br />
Es dürfen auch mehrere If. . . Else-Blöcke ineinander verschachtelt sein. Wie bei der<br />
Klammersetzung gehört der erste Else-Teil zum letzten If-Teil <strong>und</strong> so setzt sich das<br />
von innen nach außen fort. Daher ist es besonders wichtig, durch die Einrückungen zusammengehörende<br />
Blöcke auch optisch deutlich zu machen. Ich rate Ihnen allerdings<br />
dringend, nicht mehr als drei If. . . Else-Blöcke zu verschachteln.<br />
Die neue Funktion für das Bruttogehalt hat folgende Gestalt:<br />
Function Brutto1(ByVal al As Long, ByVal k As Long) As Long<br />
138<br />
Dim Kindergeld as Long, Gr<strong>und</strong>gehalt As Long<br />
If (al < 31) Then<br />
Gr<strong>und</strong>gehalt = 500<br />
Kindergeld = 300<br />
Else<br />
If (al > 30 And al < 46) Then<br />
Gr<strong>und</strong>gehalt = 1000<br />
Kindergeld = 250
Else<br />
Gr<strong>und</strong>gehalt = 1500<br />
Kindergeld = 200<br />
End If<br />
End If<br />
Brutto1 = Gr<strong>und</strong>gehalt + k*Kindergeld<br />
End Function<br />
9.6 Ablaufkontrolle<br />
Im äußeren Else-Block befindet sich ein weiterer If. . . Else-Block. An den Einrückungen<br />
können Sie zusammengehörende Teile erkennen.<br />
Das Nettogehalt ergibt sich aus dem Bruttogehalt <strong>und</strong> der Anzahl der Mitglieder des<br />
Haushalts. Singles haben einen Steuersatz von 40%, Zweipersonenhaushalte zahlen 30%<br />
Steuern <strong>und</strong> die sonstigen Mehrpersonenhaushalte sogar nur 20%. Die entsprechende<br />
Funktion ergibt sich wie folgt:<br />
Function Netto1(ByVal Brutto As Long, _<br />
ByVal k As Long, ByVal verh As Boolean) As Double<br />
Dim anz As Long<br />
anz = k<br />
If (verh = True) Then anz = anz + 1<br />
If (anz = 0) Then<br />
Netto = Brutto * 0.6<br />
Else<br />
If (anz = 1) Then<br />
Netto = Brutto * 0.7<br />
Else<br />
Netto = Brutto * 0.8<br />
End If<br />
End IF<br />
End Function<br />
9.6.3 Die Anweisung ElseIf<br />
Zwischen If <strong>und</strong> Else können beliebig viele ElseIf Anweisungen stehen:<br />
If(Bedingung_1) Then<br />
Anweisung(en)<br />
ElseIf(Bedingung_2) Then<br />
Anweisung(en)<br />
’usw.<br />
Else<br />
139
9 Die Sprachsyntax von Visual Basic<br />
Anweisung(en)<br />
End If<br />
Es werden der Reihe nach alle If- <strong>und</strong> ElseIf-Bedingungen abgefragt. Bei Erfüllung der<br />
Bedingung wird der entsprechende Block bearbeitet <strong>und</strong> danach zur ersten Anweisung<br />
nach der Verzweigung gesprungen. Sollte keine Bedingung wahr sein, wird - falls vorhanden<br />
- der Else-Block ausgeführt. Schauen Sie sich für ein Beispiel bitte noch einmal<br />
den Funktionsrumpf der Funktion Brutto2() an:<br />
Function Brutto2(ByVal al As Long, ByVal k As Long) As Long<br />
Dim Kindergeld as Long, Gr<strong>und</strong>gehalt As Long<br />
If (al < 31) Then<br />
Gr<strong>und</strong>gehalt = 500<br />
Kindergeld = 300<br />
ElseIf (al > 30 And al < 46) Then<br />
Gr<strong>und</strong>gehalt = 1000<br />
Kindergeld = 250<br />
Else<br />
Gr<strong>und</strong>gehalt = 1500<br />
Kindergeld = 200<br />
End If<br />
Brutto1 = Gr<strong>und</strong>gehalt + k*kindergeld<br />
End Function<br />
Auch die noch Funktion Netto2() beruht auf If- <strong>und</strong> ElseIf-Abfragen:<br />
Function Netto2(ByVal Brutto As Long, _<br />
ByVal k As Long, ByVal verh As Boolean) As Double<br />
Dim anz As Long<br />
anz = k<br />
If (verh = True) Then anz = anz + 1<br />
If (anz = 0) Then<br />
Netto2 = Brutto * 0.6<br />
ElseIf (anz = 1) Then<br />
Netto2 = Brutto * 0.7<br />
Else<br />
Netto2 = Brutto * 0.8<br />
End If<br />
End Function<br />
140
9.6.4 Auswahl <strong>mit</strong> Select Case<br />
9.6 Ablaufkontrolle<br />
Diese Struktur erlaubt die Auswahl aus mehreren Optionen. Dabei wird in zunächst ein<br />
Ausdruck ausgewertet <strong>und</strong> zu dem Block gesprungen, wo auf das Schlüsselwort Case<br />
dessen Wert folgt. Die allgemeine Form der Auswahl <strong>mit</strong> Select Case lautet:<br />
Select Case(Ausdruck)<br />
Case Auswahlliste1<br />
Anweisung(en)<br />
Case Auswahlliste1<br />
Anweisung(en)<br />
’usw.<br />
Case Else<br />
Anweisung(en)<br />
End Select<br />
Der Ausdruck in der Select-Anweisung wird ausgewertet <strong>und</strong> <strong>mit</strong> den Auswahllisten<br />
verglichen. Die Case Else-Marke wird angesprungen, wenn keine der Auswahllisten den<br />
Wert des Ausdruckes enthält. Diese Marke darf weggelassen werden, so dass dann eventuell<br />
keine Anweisung innerhalb des Select-Blockes ausgeführt wird. Merken Sie sich<br />
also:<br />
• Die Einrückungen.<br />
• Case Else kann weggelassen werden.<br />
Ich gebe zur Illustration die Funktionen für die Brutto- <strong>und</strong> Nettogehälter nun unter<br />
Verwendung der Select-Anweisung an <strong>und</strong> beginne <strong>mit</strong> der Funktion Brutto3():<br />
Function Brutto3(ByVal al As Long, ByVal k As Long) As Long<br />
Dim Kindergeld as Long, Gr<strong>und</strong>gehalt As Long<br />
Select Case al<br />
Case 0 To 30<br />
Gr<strong>und</strong>gehalt = 500<br />
Kindergeld = 300<br />
Case 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45<br />
Gr<strong>und</strong>gehalt = 1000<br />
Kindergeld = 250<br />
Case Else<br />
Gr<strong>und</strong>gehalt = 1500<br />
Kindergeld = 200<br />
End Select<br />
Brutto3 = Gr<strong>und</strong>gehalt + k*kindergeld<br />
End Function<br />
141
9 Die Sprachsyntax von Visual Basic<br />
Hier wäre es natürlich kürzer gewesen case 31 To 40 zu schreiben.<br />
Die Funktion für das Nettogehalt lautet entsprechend:<br />
Function Netto3(ByVal Brutto As Double, _<br />
ByVal k As Long, ByVal verh As Long) As Double<br />
Dim anz As Long ’ anz: Anzahl der Familien<strong>mit</strong>glieder<br />
anz = kinder<br />
If (verh 0) Then anz = anz + 1<br />
Select Case anz<br />
Case 0<br />
Netto3 = Brutto * 0.6<br />
Case 1<br />
Netto3 = Brutto * 0.7<br />
Case Else<br />
Netto3 = Brutto * 0.8<br />
End Select<br />
End Function<br />
9.6.5 Ein weiteres Beispiel: Jahreszeiten<br />
Die folgende Funktion bestimmt zu einem Datum die Jahreszeit. Dabei werden die logischen<br />
Operatoren innerhalb von If- <strong>und</strong> ElseIf-Bedingungen verwendet. Die Funktion<br />
hat zwei Parameter, <strong>und</strong> zwar für den Tag <strong>und</strong> den Monat:<br />
Function Jahreszeit(ByVal tag As Long, _<br />
ByVal mon As Long) As String<br />
142<br />
If (mon = 1 Or mon = 2 Or (mon = 3 And tag < 21) _<br />
Or (mon = 12 And tag > 20)) Then _<br />
Jahreszeit = "Winter"<br />
ElseIf (mon = 4 Or mon = 5 Or (mon = 3 And tag > 20) _<br />
Or (mon = 6 And tag < 21)) Then _<br />
Jahreszeit = "Lenz"<br />
ElseIf (mon = 7 Or mon = 8 Or (mon = 9 And tag < 21) _<br />
Or (mon = 6 And tag > 20)) Then _<br />
Jahreszeit = "Sommer"<br />
Else<br />
End If<br />
Jahreszeit = "Herbst"
End Function<br />
9.6 Ablaufkontrolle<br />
Ich habe hier wieder das Fortsetzungszeichen _ verwendet, da die Deklaration nicht<br />
in eine Zeile passt. Der Winter verläuft vom 21.12 bis zum 20.3. Dies wird durch die<br />
Anweisung<br />
If (mon = 1 Or mon = 2 Or (mon = 3 And tag < 21) _<br />
Or (mon = 12 And tag > 20)) Then _<br />
Jahreszeit = "Winter"<br />
programmiert. Zur besseren Lesbarkeit habe ich Klammern gesetzt.<br />
Es gibt aber auch die Möglichkeit, die Select-Anweisung zu verwenden. Diese Funktion<br />
liefert das gleiche Ergebnis <strong>mit</strong> anderem Code. Ich habe deshalb einen anderen Namen<br />
gewählt, nämlich Season:<br />
Function Season(ByVal tag As Long, _<br />
ByVal mon As Long) As String<br />
Select Case mon<br />
Case 1, 2, 3<br />
Season = "Winter"<br />
If (mon = 3 And tag > 20) Then Season = "Frühling"<br />
Case 4, 5, 6<br />
Season = "Frühling"<br />
If (mon = 6 And tag > 20) Then Season = "Sommer"<br />
Case 7, 8, 9<br />
Season = "Sommer"<br />
If (mon = 9 And tag > 20) Then Season = "Herbst"<br />
Case Else<br />
Season = "Herbst"<br />
If (mon = 12 And tag > 20) Then Season = "Winter"<br />
End Select<br />
End Function<br />
Man darf also die Select- <strong>und</strong> die If-Anweisung mischen.<br />
9.6.6 Schleifen<br />
Die Select-Anweisung bezieht sich auf die Auswahl unter mehreren Möglichkeiten. Sehr<br />
oft müssen eine oder mehrere Anweisungen wiederholt werden. Man spricht dann von<br />
143
9 Die Sprachsyntax von Visual Basic<br />
einer Schleife. Ein typisches Beispiel ist, wenn alle Zeichen eines Strings einzeln untersucht<br />
werden. Bei jeder Schleife wird ein zusammenhängender Teil des Programms<br />
solange wiederholt, wie eine bestimmte Bedingung wahr ist. Es gibt Schleifen <strong>mit</strong>:<br />
• einer festen Anzahl von Wiederholungen<br />
• Abfrage der Wiederholungsbedingung am Anfang<br />
• Abfrage der Wiederholungsbedingung am Ende<br />
9.6.7 for-Schleife<br />
Ich beginne <strong>mit</strong> den Schleifen, die eine feste Zahl von Wiederholungen haben. Ein Klassiker<br />
ist die Summation der ganzen Zahlen zwischen 1 <strong>und</strong> n. Es gilt die Formel:<br />
Etwa<br />
n<br />
i = n · (n + 1)/2.<br />
i=1<br />
n<br />
i = 100 · 101/2 = 5050.<br />
i=1<br />
Möchte man diese Formel überprüfen, könnte man folgende Funktion verwenden:<br />
Function Sum(ByVal n As Long) As Long<br />
Dim i As Long<br />
Sum = 0<br />
For i = 1 To n<br />
Sum = Sum + i<br />
Next i<br />
End Function<br />
Die allgemeine Syntax der For-Schleife lautet:<br />
Dim i As Long<br />
For i = Anfangswert To k = Endwert<br />
Anweisung(en)<br />
Next i<br />
Die For-Anweisung wird sehr oft bei Vektoren <strong>und</strong> Zeichenketten eingesetzt.<br />
9.6.8 Beispiele <strong>mit</strong> Zeichenketten<br />
Passend zur Rechtschreibreform <strong>und</strong> als Gruß an die Schweiz, wo schon vor Jahren das<br />
ß ausgerottet wurde, werde ich jetzt ein Programm vorstellen, wo diesem possierlichen<br />
Buchstaben der Garaus gemacht wird. Der Code ist nicht sehr schwer. Die nützliche<br />
144
9.6 Ablaufkontrolle<br />
Suchfunktion InStr() findet die Position des ersten »ß«. Die Zeichenkette wird an<br />
dieser Position aufgespaltet in einen Teil vor dem »ß« <strong>und</strong> den Teil nach dem »ß«. Die<br />
Teile werden dann neu zusammengesetzt, wobei in der Mitte »ss« eingefügt wird. Dieser<br />
Vorgang wird solange wiederholt, bis kein »ß« mehr vorhanden ist. Die Suchfunktion<br />
InStr() gibt dann den negativen Wert 0 zurück. Die einzelnen Zeichen der Zeichenfolge<br />
werden über eine For-Schleife durchlaufen:<br />
Function KillSz(ByRef s As String) As String<br />
Dim i As Long<br />
KillSz = ""<br />
For i = 1 To Len(s)<br />
If Mid(s, i, 1) = "" & Chr(223) Then<br />
KillSz = KillSz & "ss"<br />
Else<br />
KillSz = KillSz & Mid(s, i, 1)<br />
End If<br />
Next i<br />
End Function<br />
Der bereinigte String ist zunächst leer. Abhängig davon, ob in der deutschen Version das<br />
Zeichen an der Position <strong>mit</strong> dem Index i ein »ß« steht, wird dem bereinigten String<br />
entweder ein »ss« oder das ursprüngliche Zeichen angehängt.<br />
ganz ähnlich ist die folgende Funktion, die den schönen deutschen Umlauten wie »Ä«<br />
oder »ä« an den Kragen geht:<br />
Function WegMitUmlauten(ByRef S As String) As String<br />
Dim i As Long<br />
For i = 1 To Len(S)<br />
Select Case Mid(S, i, 1)<br />
Case "Ä": WegMitUmlauten = WegMitUmlauten & "Ae"<br />
Case "ä": WegMitUmlauten = WegMitUmlauten & "ae"<br />
Case "Ö": WegMitUmlauten = WegMitUmlauten & "Oe"<br />
Case "ö": WegMitUmlauten = WegMitUmlauten & "oe"<br />
Case "Ü": WegMitUmlauten = WegMitUmlauten & "Ue"<br />
Case "ü": WegMitUmlauten = WegMitUmlauten & "ue"<br />
Case Else: WegMitUmlauten = WegMitUmlauten & Mid(S, i, 1)<br />
End Select<br />
Next i<br />
End Function<br />
9.6.9 Vektoren <strong>und</strong> Schleifen<br />
Man benötigt oft die laufende Nummer eines Datums, z.B. 40 für den 9.2. <strong>und</strong> 365 bzw.<br />
366 für den 31.12. Ich werde jetzt eine Funktion schreiben, wo der Anwender Jahr, Monat<br />
<strong>und</strong> Tag eingibt <strong>und</strong> als Antwort die laufende Nummer des Datums erscheint:<br />
145
9 Die Sprachsyntax von Visual Basic<br />
Function LaufendeNr(ByVal j As Long, ByVal m As Long, _<br />
ByVal t As Long) As Long<br />
Dim MTage(12) As Long, s As Long, i As Long<br />
For i = 1 To 7<br />
MTage(i) = 30 + i Mod 2<br />
Next i<br />
For i = 8 To 12<br />
MTage(i) = 31 - i Mod 2<br />
Next i<br />
MTage(2) = 28<br />
If (j Mod 400 = 0 Or (j Mod 4 = 0 And j Mod 100 0)) Then _<br />
MTage(2) = 29<br />
End If<br />
s = 0<br />
For i = 1 To m - 1 Step 1<br />
s = s + MTage(i)<br />
Next i<br />
LaufendeNr = s + t<br />
End Function<br />
In einem Vektor <strong>mit</strong> 12 Elementen halte ich die Tage eines Monats fest. Im Februar<br />
hängt dies davon ab, ob das Jahr j ein Schaltjahr ist. Bis zum Juli haben immer ungerade<br />
Monate 31 Tage, ab August dann die geraden Monate 8, 10 <strong>und</strong> 12. Die Monate<br />
<strong>mit</strong> 30 Tagen erreiche ich über den Modulooperator. Die laufende Nummer ergibt sich<br />
als Summe der Tage bis zum Vormonat m - 1 <strong>und</strong> der Tage t innerhalb des Monats.<br />
Bei Schleifen, die eine Summation durchführen, muss man immer vor dem Schleifenbeginn<br />
die Summationsvariable 0 setzen!<br />
9.6.10 Der Gregorianische Kalender<br />
Seit 1582 gilt in katholischen Ländern der Gregorianischen Kalender, der von Papst<br />
Gregor eingeführt wurde. Die Protestanten zogen nach kurzem Schmollen im frühen<br />
18. Jahrh<strong>und</strong>ert nach <strong>und</strong> in Russland bedurfte es der Oktoberrevolution (eigentlich im<br />
November!) zum Anschluss an den Kalender des Westens. Der 1.1.1582 war ein Freitag.<br />
Seit diesem Datum ist jedes Jahr ein Schaltjahr, wenn seine Jahreszahl durch 400 teilbar<br />
ist. Die restlichen Jahre sind Schaltjahre, wenn die Jahreszahl durch vier teilbar ist, aber<br />
146
9.6 Ablaufkontrolle<br />
nicht durch 100. Verzwickt! Wahrscheinlich haben die Protestanten zwei Jahrh<strong>und</strong>erte<br />
gebraucht, um das zu verstehen. Auf diese geniale Idee kam übrigens ein Bayer, erst<br />
in 3000 Jahren wird eine Korrektur nötig sein, bis dahin wird noch manche Weißwurst<br />
dran glauben müssen.<br />
Wir wollen nun ein Programm schreiben, wo<strong>mit</strong> für jeden Tag seit dem 1.1.1582 der<br />
Wochentag bestimmt werden kann. Dazu muss zunächst berechnet werden, der wie vielte<br />
Tag seit dem 1.1.1582 der entsprechende Tag ist. Zum Testen, habe ich in einer<br />
sechlaflosen Nacht nachgezählt: Mein 50. Geburtstag am Samstag, dem 13.11.1999, war<br />
der 152623. Tag seit dem 1.1.1582. Schneller wäre ich <strong>mit</strong> dieser Funktion am Ziel gewesen:<br />
Function TageSeitGregor(ByVal j As Long, ByVal m As Long, _<br />
ByVal t As Long) As Long<br />
Dim i As Long, s As Long<br />
TageSeitGregor = LaufendeNr(j, m, t)<br />
For i = 1582 To j - 1<br />
s = s + 365<br />
If(i Mod 400 = 0 Or (i Mod 4 = 0 And i Mod 100 0)) Then<br />
TageSeitGregor = TageSeitGregor + 1<br />
End If<br />
Next i<br />
End Function<br />
Die laufenden Tage innerhalb eines Jahres j können wir bereits <strong>mit</strong> der Funktion<br />
LaufendeNr() bestimmen. Die Anzahl der Tage bis zum letzten Tag des Vorjahres<br />
wird durch die anschließende Schleife er<strong>mit</strong>telt. Dabei werden alle Jahre i zwischen<br />
1582 <strong>und</strong> j - 1 durchlaufen <strong>und</strong> die Summationsvariable TageSeitGregor für gewöhnliche<br />
Jahre um 365 <strong>und</strong> für Schaltjahre um 366 erhöht.<br />
Über die Funktion TageSeitGregor(j, m, t) lässt sich der Wochentag bestimmen.<br />
Der 1.1.1582 war ein Freitag, daher ist ein beliebiger Tag genau dann auch ein<br />
Sonntag, wenn (TageSeitGregor(j, m, t) + 4) Mod 7 den Wert 0 hat. Hat<br />
dieser Ausdruck dagegen den Wert 1, so handelt es sich um einen Montag, usw.<br />
Die Funktion WTage(j, m, t) verwendet TageSeitGregor(j, m, t) wie folgt:<br />
Function WTag(ByVal j As Long, ByVal m As Long, _<br />
ByVal t As Long) As String<br />
Select Case (TageSeitGregor(j, m, t) + 4) Mod 7<br />
Case 0: WTag = "Sonntag"<br />
Case 1: WTag = "Montag"<br />
Case 2: WTag = "Dienstag"<br />
Case 3: WTag = "Mittwoch"<br />
Case 4: WTag = "Donnerstag"<br />
Case 5: WTag = "Freitag"<br />
147
9 Die Sprachsyntax von Visual Basic<br />
Case Else: WTag = "Samstag"<br />
End Select<br />
End Function<br />
Da zu jedem Case nur eine Anweisung gehört, habe ich diese direkt nach dem Case<br />
geschrieben. Da aber eigentlich eine neue Zeile nötig wäre, habe ich den Doppelpunkt<br />
verwendet, der einem Zeilenvorschub entspricht.<br />
9.6.11 Verschachtelte Schleifen<br />
Manchmal müssen auch Schleifen verschachtelt werden. Im folgenden Beispiel soll in den<br />
Zeilen 1,2,. . . i,. . . n einer mehrzeiligen Zeichenkette jeweils 2i − 1 Sternchen in Dreiecksform<br />
*<br />
***<br />
*****<br />
*******<br />
’usw<br />
ausgegeben werden. Dafür benötige ich zwei verschachtelte Schleifen. Die äußere Schleife<br />
gibt n Zeilen aus, die innere Schleife sorgt für die 2i − 1 Sternchen in der Zeile i. Der<br />
Zeilenumbruch wird <strong>mit</strong> der Visual Basic Konstanten vbNewLine bewirkt.<br />
Function HalbTanne(ByVal n As Long) As String<br />
Dim i, j As Long<br />
Tanne = ""<br />
For i = 1 To n<br />
For j = 1 To 2 * i - 1<br />
HalbTanne = HalbTanne & "*"<br />
Next j<br />
HalbTanne = HalbTanne & vbNewLine<br />
Next i<br />
End Function<br />
Ich teste diese Funktion <strong>mit</strong> der folgenden Sub-Prozedur:<br />
Sub TestHalbTanne()<br />
Dim i As Long<br />
i = InputBox("Bitte Anzahl der Zeilen eingeben: ", "", "12")<br />
MsgBox HalbTanne(i)<br />
End Sub<br />
148
9.6.12 Schleifen <strong>mit</strong> Wiederholungsbedingung am Ende<br />
XXX: Mehr blah<br />
Ich beginne <strong>mit</strong> der Do . . . While-Schleife, deren Syntax wie folgt lautet:<br />
Do<br />
Anweisung(en)<br />
Loop While(Wiederholungsbedingung)<br />
nächste Anweisung<br />
9.6 Ablaufkontrolle<br />
Der Block zwischen Do <strong>und</strong> Loop While heißt Schleifenkörper, dessen Anweisungen<br />
werden mindestens einmal ausgeführt. Solange die Wiederholungsbedingung wahr<br />
ist, wird der Schleifenkörper immer wieder von oben an durchlaufen. Die Anweisungen<br />
innerhalb des Schleifenkörpers müssen demnach irgendwann zur Nichterfüllung der<br />
Wiederholungsbedingung führen, da sonst die Schleife unendlich oft wiederholt würde.<br />
Sobald die Wiederholungsbedingung zum ersten Mal nicht erfüllt ist, wird das Programm<br />
<strong>mit</strong> der nächsten Anweisung fortgesetzt. Bitte beachten Sie also:<br />
• Die Einrückungen nach der Do-Anweisung.<br />
• Die Wiederholungsbedingung steht in r<strong>und</strong>en Klammern.<br />
• Die Schleife wird solange wiederholt, wie die Wiederholungsbedingung wahr ist.<br />
• Eine so genannte Idiotenschleife entsteht, wenn die Wiederholungsbedingung immer<br />
wahr bleibt.<br />
Diese Schleife wird gerne bei Eingaben verwendet:<br />
Dim Jahr As Long<br />
Do<br />
Jahr = CInt(InputBox("Bitte Geburtsjahr eingeben: ","1978"))<br />
Loop While (1900 > Jahr Or Jahr > 1990)<br />
Der Anwender hat den Abbruch selbst in der Hand, sobald das Eingabejahr zwischen<br />
1900 <strong>und</strong> 1990 liegt, wird die Schleife verlassen.<br />
Die Funktion InputBox(Text, Anfangswert) öffnet einen Standarddialog, wo<br />
der erste Parameter als Erläuterung <strong>und</strong> der zweite in einem Textfeld erscheint. Der<br />
Inhalt des Textfelds kann vom Anwender geändert werden <strong>und</strong> wird nach dem Drücken<br />
der OK-Taste als Wert der Funktion zurückgegeben.<br />
9.6.13 Schleifen <strong>mit</strong> Abbruchbedingung am Ende<br />
Diese Schleifen verwendet eine Abbruchbedingung am Ende. Das Schlüsselwort While muss<br />
dem Schlüsselwort Until weichen<br />
Do<br />
Anweisung(en)<br />
Loop Until(Abbruchbedingung))<br />
149
9 Die Sprachsyntax von Visual Basic<br />
Die Do. . . Loop-While Schleife wird solange wiederholt, wie eine bestimmte Wiederholungsbedingung<br />
wahr ist, während diese abbricht, wenn eine Abbruchbedingung wahr<br />
wird. Daher ist die Abbruchbedingung gerade die logische Verneinung der Wiederholungsbedingung.<br />
Die oben erwähnte Schleife kann entsprechend umformuliert werden:<br />
Dim Jahr As Long<br />
Do<br />
Jahr = CInt(InputBox("Bitte Geburtsjahr eingeben: ","1978"))<br />
Loop Until (1900
9.6.15 Der größte gemeinsame Teiler einer Zahl<br />
9.6 Ablaufkontrolle<br />
Die folgende Funktion berechnet den größten gemeinsamen Teiler von a <strong>und</strong> b <strong>und</strong> gibt<br />
-1 zurück, wenn a oder b nicht positiv sind. Der Algorithmus geht auf Euklid zurück.<br />
Die jeweils größere Zahl wird durch die kleinere geteilt. Ist dies ohne Rest möglich, ist<br />
die kleinere Zahl der größte gemeinsame Teiler. Sonst wird die bisher größere Zahl durch<br />
den Rest ersetzt <strong>und</strong> das Verfahren fortgesetzt. Soll etwa der größte gemeinsame Teiler<br />
von 88 <strong>und</strong> 24 bestimmt werden, wird zunächst 88 Mod 24, also 16 berechnet. Danach<br />
übernimmt 16 die Rolle von 88. So<strong>mit</strong> wird jetzt 24 Mod 16 berechnet, was 8 ergibt. Es<br />
bleiben 16 <strong>und</strong> 8 im Rennen. Da 16 Mod 8 den Wert 0 hat, ist 8 der größte gemeinsame<br />
Teiler von 88 <strong>und</strong> 24. Hier müssen innerhalb der Schleife fortwährend die Werte der<br />
Variablen i <strong>und</strong> j getauscht werden. Dies übernimmt die bereits beschriebene Sub-<br />
Prozedur Tausch().<br />
Function Ggt(ByVal i As Long, ByVal j As Long) _<br />
As Long<br />
If (i < 1 Or j < 1) Then Ggt = -1<br />
If j > i Then Tausch i, j<br />
Do<br />
i = i Mod j<br />
Tausch i, j<br />
Loop While (j > 0)<br />
’oder Loop Until (j = 0)<br />
Ggt = i<br />
End Function<br />
9.6.16 Aufruf von Funktionen aus Funktionen<br />
Funktionen wurden bisher immer nur von <strong>Excel</strong> aus aufgerufen. Selbstverständlich können<br />
aber auch Funktionen andere Funktionen aufrufen. Das kleinste gemeinsame Vielfache<br />
Kgv zweier Zahlen a <strong>und</strong> b ist die kleinste Zahl, die beide Zahlen als Teiler hat.<br />
So ist etwa für 45 <strong>und</strong> 30 die Zahl 90 das kleinste gemeinsame Vielfache. Das kleinste<br />
gemeinsame Vielfache Kgv zweier Zahlen a <strong>und</strong> b ist eng <strong>mit</strong> dem größten gemeinsamen<br />
Teiler Ggt verwandt:<br />
Kgv = a*b/Ggt<br />
Das kommt daher, dass das kleinste gemeinsame Vielfache aus allen Primfaktoren besteht,<br />
die in wenigstens einer Zahl vorkommen <strong>und</strong> der größte gemeinsame Teiler sich<br />
aus allen Primfaktoren zusammensetzt, die in beiden Zahlen vorhanden sind. Im Beispiel<br />
ist<br />
151
9 Die Sprachsyntax von Visual Basic<br />
45 = 3*3*5, 30 = 2*3*5, Ggt = 3*5, Kgv = 2*3*3*5<br />
So<strong>mit</strong> ist der Code der Funktion für die Berechnung des kleinsten gemeinsamen Vielfachen<br />
ganz einfach:<br />
Function Kgv(ByVal i As Long, ByVal j As Long) As Long<br />
Kgv = i * j / Ggt(i, j)<br />
End Function<br />
9.6.17 Wiederholungsbedingung am Anfang<br />
Manche Schleifen sollen unter bestimmten Umständen gar nicht durchlaufen werden. Die<br />
Wiederholungsbedingung wird dann an den Anfang der zu wiederholenden Anweisungen<br />
gesetzt. Die allgemeine Form lautet:<br />
Do While (Wiederholungsbedingung)<br />
Anweisung(en)<br />
Loop<br />
Ist die Wiederholungsbedingung schon am Anfang nicht erfüllt, wird der Schleifenkörper<br />
überhaupt nicht durchlaufen. Eine Do . . . Loop While-Schleife wird dagegen immer mindestens<br />
einmal ausgeführt, weil die Wiederholungsbedingung erst zum Schluss überprüft<br />
wird.<br />
Als Beispiel sei eine andere Funktion zur Ausrottung des Buchstabens »ß« geschrieben,<br />
in der <strong>mit</strong> einer Do-While-Schleife gearbeitet wird:<br />
Function KillSz2(ByRef s As String) As String<br />
Dim i As Long, sz As String, r As String<br />
sz = "" & Chr(223)<br />
KillSz = s<br />
i = InStr(KillSz, sz)<br />
Do While (i > 0)<br />
r = Right$(KillSzWhile, Len(KillSzWhile) - i)<br />
KillSz = Left$(KillSz,i - 1,) & "ss" & r<br />
i = InStr(i + 1, KillSz, sz)<br />
Loop<br />
End Function<br />
Der bereinigte String ist zunächst leer. Abhängig davon, ob in der deutschen Version das<br />
Zeichen an der Position <strong>mit</strong> dem Index i ein »ß« steht, wird dem bereinigten String<br />
entweder ein »ss« oder das ursprüngliche Zeichen angehängt.<br />
9.6.18 Die GoTo Sprunganweisung<br />
Die Anweisung GoTo ist das Schmuddelkind unter den Anweisungen. Man sollte sie nur<br />
in Notfällen verwenden, um bei fehlerhaftem Programmverlauf zu einer Fehlermeldung<br />
zu springen. XXX Raus aus Schleifen Diese Anweisung beendet aber einen laufenden<br />
152
9.7 Aufgaben<br />
Schleifendurchlauf vorzeitig <strong>und</strong> springt aus der Schleife zu einer Marke. XXX: Exit<br />
Function, Exit Sub usw. XXX: On error goto<br />
9.7 Aufgaben<br />
Aufgabe 1. Schreiben Sie eine Funktion, deren Parameter Jahr, Monat <strong>und</strong> Tag sind.<br />
Die Funktion überprüft, ob die Eingabe sinnvoll oder wie etwa der 31.11. falsch ist <strong>und</strong><br />
gibt entsprechend True oder False zurück. Verwenden Sie Select Case. Schreiben<br />
Sie dann eine zweite Version unter Verwendung von If <strong>und</strong> ElseIf .<br />
Aufgabe 2. Man benötigt oft die laufende Nummer eines Datums, z.B. 40 für den 9.2.<br />
<strong>und</strong> 365 oder 366 für den 31.12., da Schaltjahre zu berücksichtigen sind. Man schreibe<br />
eine weitere Funktion LaufendeNr2, die das liefert. Verwenden Sie Select Case.<br />
Aufgabe 3. Man schreibe eine Funktion, die eine Zeichenfolge <strong>mit</strong> N Zeilen aus Sternchen<br />
in gleichschenkliger Dreiecksform erzeugt:<br />
*<br />
***<br />
*****<br />
*******<br />
*********<br />
Hier ist das Argument N = 5. Dieses N soll aber beliebig sein können.<br />
Aufgabe 4. Entwickeln Sie eine Funktion, deren Argument eine Zeichenfolge ist, zu<br />
der die Anzahl der Vokale ausgegeben wird.<br />
Aufgabe 5. Schreiben Sie eine Funktion, deren Argumente ein Vektor von Zahlen <strong>und</strong><br />
eine Variable Auf vom Typ Boolean sind. Hat Auf den Wert True, so soll der Vektor<br />
aufsteigend, sonst absteigend sortiert werden.<br />
Aufgabe 6. Schreiben Sie Funktionen MyHour(d) <strong>und</strong> MyMinute(d), die zu einer<br />
Zahl zwischen 0 <strong>und</strong> 1 die St<strong>und</strong>e <strong>und</strong> Minute liefern, wobei MyHour(0) = 0 <strong>und</strong><br />
MyMinute(0) = 0 sowie MyHour(1) = 24 <strong>und</strong> MyMinute(1) = 0 sind.<br />
Aufgabe 7. Schreiben Sie Funktionen MyYear(d) <strong>und</strong> MyMonth(d) <strong>und</strong> MyDay(d),<br />
die zu einer ganzen Zahl jahr, Monat <strong>und</strong> Tag liefern, wobei der Wert 1 dem 1.1.1582<br />
entspricht. Wenn ich mich nicht verrechnet habe, muss als Probe für d = 152623 sich<br />
das Datum 13.11.1999 ergeben.<br />
Aufgabe 8. Erstellen Sie von den Aufgaben 1, 2 sowie 5 bis 7 die entsprechenden<br />
C-Funktionen.<br />
153
9 Die Sprachsyntax von Visual Basic<br />
Alle Aufgaben nur <strong>mit</strong> Bord<strong>mit</strong>teln von Basic selbst lösen, also ohne Verwendung<br />
eingebauter Funktionen wie Month(), Sort() usw.! Ziehen Sie diese<br />
Funktionen aber zum Vergleich <strong>und</strong> als Probe heran, wobei aber zu bedenken<br />
ist, dass bei den eingebauten Datumsfunktionen die Zahl 1 dem 30.12.1899<br />
entspricht.<br />
154
Index<br />
Überlauf, 113<br />
Select Case, 143<br />
Alles Markieren, 17<br />
Anweisung, 126<br />
Anwendungsfenster, 16<br />
Arbeitsblatt, 17<br />
Arbeitsfenster, 83<br />
Arbeitsmappe, 17<br />
Arbeitsmappenfenster, 16<br />
Ausdruck, 126<br />
Ausfüllkästchen, 30<br />
Bearbeitungsleiste, 16<br />
bedingte Anweisung, 113<br />
Befehl, 21<br />
benutzerdefinierte Listen, 31<br />
Bezeichner, 111<br />
Bezeichnungsfeld, 91<br />
Bildlaufleiste, 17<br />
Block, 140<br />
Boolean, 113<br />
ByRef, 136<br />
ByVal, 134, 136<br />
Case, 143<br />
CDbl(), 124<br />
CInt(), 124<br />
Code-Fenster, 84<br />
Datenbank-Funktionen, 65<br />
Datenfeld, 118<br />
Dimension, 119<br />
Elemente, 118<br />
Datenmatrix, 58<br />
Datenpunkte, 69<br />
Datenreihe, 69<br />
Diagramm, 69<br />
Diagrammlegende, 71<br />
Dim, 105, 106<br />
Do, 152<br />
Eigenschaftsfenster, 83<br />
Eingabefeld, 16<br />
Else, 141<br />
ElseIf, 142<br />
End Function, 134<br />
Ereignis, 90<br />
Ereignisbehandlungsroutine, 90<br />
False, 113<br />
Fensterleiste, 17<br />
Filter, 60<br />
Kriterium, 60<br />
For, 118, 147<br />
Formeln<br />
absoluter Bezug, 34<br />
gemischter Bezug, 34<br />
relativer Bezug, 34<br />
Formulare, 87<br />
Function, 134<br />
Funktion, 133<br />
aktuelle Parameter, 135<br />
call by reference, 136<br />
call by value, 136<br />
formale Parameter, 135<br />
Funktionen, 87<br />
GoTo, 155<br />
HÄUFIGKEIT-Funktion, 73<br />
If, 113<br />
155
Index<br />
InputBox-Funktion, 109<br />
IsNumeric(), 124<br />
Klasse, 93<br />
Kommentare, 112<br />
Konstante, 106<br />
Kontextmenü, 24<br />
Label, 91<br />
Laufzeitfehler, 86<br />
Liste<br />
Datensatz, 58<br />
Feld, 58<br />
Listen, 57<br />
Literale, 107<br />
Loop While, 152<br />
Makroaufzeichnen, 81<br />
Markieren, 20<br />
Maske, 60<br />
Menüleiste, 16<br />
Modul, 84, 85<br />
Modulebene, 105<br />
Modulooperator, 128<br />
Namensfeld, 16<br />
NICHT-Operator, 130<br />
Objekt, 137<br />
ODER-Funktion, 43<br />
ODER-Operator, 130<br />
Operand, 127<br />
Operator, 127<br />
arithmetisch, 127<br />
binär, 127<br />
für Zeichenketten, 127<br />
logisch, 127<br />
unär, 127<br />
Operatoren<br />
arithmetische, 35<br />
Platzhalterzeichen, 61<br />
Priorität<br />
von Operatoren, 131<br />
Private, 105<br />
Projekt-Explorer, 83, 84<br />
156<br />
Prozedurebene, 104<br />
Public, 105<br />
Punkt, 28<br />
Punktdiagramm, 71<br />
range, 18<br />
Reihendialog, 30<br />
Rubriken, 69<br />
Säulendiagramm, 71<br />
Schlüsselwort, 111<br />
Schleife, 146<br />
Schleifenkörper, 152<br />
Shortcut, 23<br />
SPALTE-Funktion, 46<br />
Spaltenüberschrift, 16<br />
Spezialfilter, 63<br />
Statusleiste, 17<br />
Steuerelemente, 88, 89<br />
Listenfeld, 89<br />
Optionsfeld, 89<br />
Schaltfläche, 89<br />
Steuerelemente1Textfeld, 89<br />
String, 114<br />
Sub-Prozedur, 85<br />
SUMMEWENN-Funktion, 44<br />
SVERWEIS-Funktion, 45<br />
Symbolleiste, 16, 25<br />
Tabelle, 17<br />
Tastaturkürzel, 23<br />
TextBox, 91<br />
Textfeld, 91<br />
Titelleiste, 16<br />
True, 113<br />
UND-Funktion, 43<br />
UND-Operator, 130<br />
Variable, 104<br />
Visual Basic Editor, 83<br />
WENN-Funktion, 43<br />
Werkzeugsammlung, 88<br />
workbook, 17<br />
worksheet, 17
Zeichenfolge, 114<br />
Zeilenüberschrift, 17, 28<br />
Zuweisungsoperator, 127<br />
Index<br />
157