Notes Domino 5. Einführung in die LotusScript-Programmierung

Notes/Domino 5

EDITION Lotus Domino.Solutions – Domino 5 richtig einsetzen Klaus Fochler / Jörg Ungermann / Benedikt Wahl Notes/Domino effektiv nutzen – Groupware in Fallstudien Ulrich Hasenkamp / Oliver Reiss / Thomas Jenne / Matthias Goeken Lotus Notes und Domino im Einsatz – Anwendungen und Lösungen Michael Herkens / Petra Kienle Lotus Notes 5 und Domino – Arbeiten im Team, arbeiten im Web Michael Frerking / Monika Jaszkowski / Klaus-Dieter Kolm Anwendungsentwicklung unter Lotus Notes/Domino 5 Matthias Knäpper / Primoz Perc / Volker Perplies Notes/Domino 5 – Einführung in die LotusScript-Programmiersprache Thomas Muhs / Börries Klatt Lotus Domino.doc – Unternehmensweites Dokumentenmanagement Artur Rueb / Mario Kuhl

Thomas Muhs Boerries Klatt

Notes/Domino 5 Einführung in die LotusScript-Programmierung

Bitte beachten Sie: Der originalen Printversion liegt eine CD-ROM bei. In der vorliegenden elektronischen Version ist die Lieferung einer CD-ROM nicht enthalten. Alle Hinweise und alle Verweise auf die CD-ROM sind ungültig.

ADDISON-WESLEY An imprint of Pearson Education München • Boston • San Francisco • Harlow, England Don Mills, Ontario • Sydney • Mexico City Madrid • Amsterdam

Die Deutsche Bibliothek – CIP-Einheitsaufnahme Ein Titeldatensatz für diese Publikation ist bei der Deutschen Bibliothek erhältlich

Die Informationen in diesem Produkt werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für Verbesserungsvorschläge und Hinweise auf Fehler sind Verlag und Herausgeber dankbar. Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zulässig. Fast alle Hardware- und Softwarebezeichnungen, die in diesem Buch erwähnt werden, sind gleichzeitig auch eingetragene Warenzeichen oder sollten als solche betrachtet werden. Umwelthinweis: Dieses Produkt wurde auf chlorfrei gebleichtem Papier gedruckt. Die Einschrumpffolie – zum Schutz vor Verschmutzung – ist aus umweltverträglichem und recyclingfähigem PE-Material. 10 9 8 7 6 5 4 3 2 1 03 02 01 00 ISBN 3-8273-1653-7 © 2000 by Addison-Wesley Verlag, ein Imprint der Pearson Education Deutschland GmbH Martin-Kollar-Straße 10–12, D-81829 München/Germany Alle Rechte vorbehalten Einbandgestaltung: Lektorat: Herstellung: Satz: Druck und Verarbeitung: Printed in Germany

Barbara Thoben, Köln Rolf Pakendorf, [email protected] Anja Zygalakis, [email protected] mediaService, Siegen Schoder Druck, Gersthofen

Inhaltsverzeichnis Ei n l e i t un g . .. .... ... ..... .. .... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 25 S at zk o n v e n t io n e n . ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 27 1

Das A n we n d u n gs be is p i e l .. .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 29 1.1 Der Start: Ein erster Aufbau der Anwendung Kontaktmanagement ...........30 1.1.1 Datenbank »Adressen« .............................................................30 1.1.2 Datenbank »Konfiguration« ......................................................35 1.1.3 Datenbank »Kontakte« .............................................................37 1.2 Wie geht es weiter? ..................................................................................39

2

En t w i ckl u n gs u m ge b un g (ID E) . .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 41 2.1 Verständnisvoraussetzungen.....................................................................41 2.2 Lernziel ....................................................................................................41 2.3 Die IDE.....................................................................................................41 2.4 Navigator.................................................................................................42 2.5 Objektstruktur und Referenz.....................................................................43 2.6 Programmierbereich.................................................................................44 2.6.1 Editor .......................................................................................44 2.6.2 Zeilenumbrüche .......................................................................46 2.6.3 Tabulator..................................................................................46 2.6.4 Kommentare ............................................................................46 2.6.5 Hintereinanderhängen von Befehlen.........................................46 2.6.6 Kompilieren und Kompilierfehler ..............................................47 2.7 Debugger.................................................................................................47 2.7.1 Start des Debuggers .................................................................47 2.7.2 Haltepunkte..............................................................................49 2.7.3 Aufrufe verfolgen ......................................................................50 2.7.4 Weitere Navigationsmöglichkeiten............................................51 2.7.5 Variablenwerte verfolgen und manipulieren..............................51 2.8 Probleme .................................................................................................52 2.9 Fragen......................................................................................................53

3

G r u n dl e ge n d e D at e n t yp e n .. ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 55 3.1 Verständnisvoraussetzungen.....................................................................55 3.2 Lernziel ....................................................................................................55 3.3 Allgemeines zur impliziten und expliziten Deklaration von Variablen ........55 3.4 Numerische Datentypen ..........................................................................56 3.4.1 Der Datentyp Integer................................................................56 3.4.2 Der Datentyp Long...................................................................57 3.4.3 Der Datentyp Single .................................................................58

6

Inhaltsverzeichnis

3.5 3.6 4

3.4.4 Der Datentyp Double ...............................................................59 3.4.5 Der Datentyp Currency.............................................................60 3.4.6 Numerischer Typenwandel .......................................................61 3.4.7 Zusammenfassung numerischer Datentypen ............................61 Der Datentyp Variant ...............................................................................61 Fragen......................................................................................................63

D e r D at e n t yp S t r in g .. .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 65 4.1 Verständnisvoraussetzungen.....................................................................65 4.2 Lernziel ....................................................................................................65 4.3 Vorbemerkung .........................................................................................65 4.4 Implizite und explizite Deklaration............................................................65 4.5 Dynamische und statische Zeichenkette ...................................................66 4.6 Initialisierung von Zeichenketten ..............................................................66 4.7 Verwendung von statischen Zeichenketten ..............................................66 4.8 Funktionen und Anweisungen für Zeichenketten ......................................67 4.8.1 Die Funktionen Len, LenB, LenBP und LenC..............................67 4.8.2 Die Funktionen Left und Right ..................................................67 4.8.3 Die Funktion Mid......................................................................68 4.8.4 Die Operationen RSet und LSet.................................................69 4.8.5 Die Funktionen LTrim, RTrim und Trim .....................................69 4.8.6 Die Funktionen LCase und UCase .............................................69 4.8.7 Die Funktion Str........................................................................70 4.8.8 Die Funktionen StrCompare und StrComp................................70 4.8.9 Die Funktion StrConv ...............................................................71 4.8.10 StrLeft, StrLeftBack, StrRight und StrRightBack..........................71 4.8.11 Die Funktion String...................................................................73 4.8.12 Die Funktionen InStr, InstrB, InstrBP und InstrC ........................73 4.8.13 Die Anweisung Option Compare ..............................................73 4.8.14 Die Funktion Space...................................................................73 4.8.15 Die Funktion Val .......................................................................74 4.8.16 Die Funktion Asc.......................................................................74 4.8.17 Die Funktion Chr ......................................................................74 4.8.18 Die Funktion UChr....................................................................74 4.8.19 Die Funktion Uni.......................................................................75 4.8.20 Die Funktion UString ................................................................75 4.9 Operatoren für das Handling von Zeichenketten ......................................75 4.9.1 Konkatenationsoperatoren........................................................75 4.9.2 Vergleichsoperatoren ................................................................75 4.10 Übergabe von Zeichenketten als Parameter..............................................76 4.10.1 Übergabe per Referenz .............................................................76 4.10.2 Übergabe per Wert ...................................................................76 4.11 Verwendung von konstanten Zeichenketten.............................................76

Inhaltsverzeichnis

7

4.12 Grenzen beim Datentyp String.................................................................77 4.13 Besondere Unterschiede zwischen statischen und dynamischen Zeichenketten.....................................................................77 4.13.1 Unterschiede bei der Wertzuweisung ........................................77 4.13.2 Unterschiede bei der Längenermittlung ....................................78 4.14 Fragen......................................................................................................78 5

Zeit5.1 5.2 5.3

u n d D at u m s we r t e ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 79 Verständnisvoraussetzungen.....................................................................79 Lernziel ....................................................................................................79 Einleitung.................................................................................................79 5.3.1 Umwandlung der Einzelwerte Jahr, Monat, Tag in Datumswert ...................................................................80 5.3.2 Umwandlung von Strings in Datumswerte................................81 5.3.3 Umwandlung von Stunden, Minuten, Sekunden in Zeitwert .....81 5.3.4 Umwandlung von Strings in Zeitwerte......................................81 5.3.5 Überprüfung, ob ein Ausdruck ein Datum darstellt ...................82 5.4 Das aktuelle Datum ermitteln und setzen .................................................82 5.4.1 Aktuelles Datum ermitteln ........................................................82 5.4.2 Aktuelles Datum setzen.............................................................82 5.5 Die aktuelle Uhrzeit ermitteln und setzen .................................................83 5.5.1 Aktuelle Uhrzeit ermitteln .........................................................83 5.5.2 Aktuelle Uhrzeit setzen..............................................................83 5.6 Die Funktionen Now, Today und Timer....................................................83 5.6.1 Die Funktion Now ....................................................................83 5.6.2 Die Funktion Today ..................................................................83 5.6.3 Die Funktion Timer ...................................................................84 5.7 Ermitteln von Tag, Monat, Jahr, Wochentag.............................................84 5.7.1 Die Funktion Year .....................................................................84 5.7.2 Die Funktion Month .................................................................84 5.7.3 Die Funktion Day......................................................................85 5.7.4 Die Funktion Weekday ..............................................................85 5.8 Ermitteln von Stunden, Minuten und Sekunden .......................................85 5.8.1 Die Funktion Hour ....................................................................85 5.8.2 Die Funktion Minute.................................................................86 5.8.3 Die Funktion Second ................................................................86 5.9 Wichtige Bemerkung zum Abschluss ........................................................86 5.10 Fragen zu dem Kapitel .............................................................................87

6

A rr rra ay . .. .... ... ..... .. .... ... ..... .. .... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 89 6.1 Verständnisvoraussetzungen.....................................................................89 6.2 Lernziel ....................................................................................................89 6.3 Einleitung.................................................................................................89 6.4 Statische und dynamische Arrays..............................................................90

8

Inhaltsverzeichnis

6.5 6.6 6.7 6.8 6.9

6.10 6.11 6.12 6.13 6.14 6.15 6.16 6.17

Deklaration ..............................................................................................90 6.5.1 Größenveränderung eines dynamischen Arrays.........................90 Zugriff auf Elemente.................................................................................91 Löschen von Elementen ...........................................................................91 Zugriff auf die Indizes...............................................................................92 ArrayAppend und ArrayReplace ................................................................92 6.9.1 ArrayAppend ............................................................................92 6.9.2 ArrayReplace.............................................................................93 Suchen eines Wertes in einem Array .........................................................93 Standarduntergrenze der Indexbereiche...................................................94 6.11.1 Überprüfung auf Arrayreferenz .................................................95 Keine Zuweisungen ..................................................................................95 Verbesserung des Laufzeitverhaltens.........................................................95 Laufzeitverhalten bei dynamischen Arrays ................................................97 Doch eine Zuweisung von zwei Arrays .....................................................97 Problematische Fehler ..............................................................................97 6.16.1 Wichtige Bemerkungen ............................................................97 Fragen zu dem Kapitel .............................................................................98

7

D e r D at e n t yp L i st .. ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... 99 7.1 Verständnisvoraussetzungen.....................................................................99 7.2 Lernziel ....................................................................................................99 7.3 Einleitung.................................................................................................99 7.4 Die Deklaration ........................................................................................99 7.5 Zugriff auf die Elemente .........................................................................100 7.5.1 Wert-Zuweisung bei einem Listen-Element .............................101 7.5.2 Wert-Auslesen bei einem Listen-Element .................................101 7.6 Datentypen der Listen-Elemente.............................................................102 7.7 LotusScript-Befehle für Listen..................................................................103 7.7.1 Löschen aller oder einzelner Elemente einer Liste mit Erase .....103 7.7.2 Die ForAll-Schleife...................................................................103 7.7.3 Die Überprüfung mit IsList ......................................................104 7.7.4 Die Überprüfung der Existenz eines Elementes mit IsElement ..104 7.7.5 Die Anweisung ListTag............................................................104 7.8 Fragen....................................................................................................105

8

P r og r amm mmv v e rz we i g un g ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 07 8.1 Verständnisvoraussetzungen...................................................................107 8.2 Lernziel ..................................................................................................107 8.3 Sprungmarken .......................................................................................107 8.4 Die If-Anweisung ....................................................................................108 8.4.1 If ... Goto-Anweisung..............................................................108 8.4.2 If ... Then ... Else-Anweisung ...................................................108 8.4.3 If ... Then ... ElseIf-Anweisung .................................................109

Inhaltsverzeichnis

9

8.5 8.6

Die Select Case-Anweisung ....................................................................109 Programmschleifen ................................................................................110 8.6.1 Die For ... Next-Anweisung.....................................................110 8.7 Die Do-Schleife ......................................................................................111 8.7.1 Kopfgesteuerte Do ... While-Schleife .......................................111 8.7.2 Fußgesteuerte Do ... While-Schleife ........................................111 8.7.3 Kopfgesteuerte Do ... Until-Schleife ........................................112 8.7.4 Fußgesteuerte Do ... Until-Schleife..........................................112 8.7.5 Die While-Schleife...................................................................112 8.7.6 Do ... Loop-Schleife ................................................................113 8.8 Die ForAll-Anweisung .............................................................................114 8.9 Programmsprung GoTo .........................................................................114 8.9.1 Der GoTo-Sprung ...................................................................114 8.9.2 On ... GoTo-Sprung................................................................115 8.10 GoSub-Anweisungen..............................................................................115 8.10.1 GoSub-Sprung........................................................................115 8.10.2 On ... GoSub-Sprung ..............................................................116 8.11 Exit-Anweisung ......................................................................................116 8.11.1 Exit Sub/Exit Function/Exit Property........................................116 8.11.2 Exit Do, Exit For, Exit Forall .....................................................117 8.12 Fragen....................................................................................................117 9

F e h le r b e h an d lu n g . ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 19 9.1 Verständnisvoraussetzungen...................................................................119 9.2 Lernziel ..................................................................................................119 9.3 Einleitung...............................................................................................119 9.3.1 Einige Tipps zur Fehlerbehandlung .........................................125 9.4 Fragen....................................................................................................127

10 De r P r o t o k o ll m e ch a n i sm u s .. ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 29 10.1 Verständnisvoraussetzungen...................................................................129 10.2 Lernziel ..................................................................................................129 10.3 Einleitung...............................................................................................129 10.4 Allgemeine Implementierung .................................................................131 10.5 Die Protokollmedien...............................................................................132 10.5.1 Protokollieren in einer Datenbank ...........................................132 10.5.2 Protokollierung in einer Textdatei ...........................................133 10.5.3 Protokollierung durch Mails ....................................................134 10.5.4 Protokollierung ins AgentLog..................................................134 10.6 Die verschiedenen Arten der Protokollmeldungen ..................................135 10.6.1 Meldungen.............................................................................135 10.6.2 Fehlermeldungen ...................................................................135 10.7 Fragen....................................................................................................135

10

Inhaltsverzeichnis

11 Di e A g e n t -P r og r amm mmii e ru n g ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 37 11.1 Verständnisvoraussetzungen...................................................................137 11.2 Lernziel ..................................................................................................137 11.3 Funktionen zum Synchronisieren von Agents .........................................137 11.3.1 Die Funktion CreateLock.........................................................138 11.3.2 Die Funktion DestroyLock .......................................................138 11.3.3 Die Funktion CodeLock...........................................................138 11.3.4 Die Funktion CodeUnLock ......................................................138 11.4 Die Anweisung Sleep und ihre Verwendung ...........................................139 11.5 Der Kontext bei Webagents ...................................................................139 11.5.1 Einige Beispiele für CGI-Variablen ...........................................140 11.6 Die RunOnServer-Anweisung..................................................................141 11.7 Einige wichtige Einschränkungen ...........................................................141 11.7.1 Verwendung von Frontend-Klassen.........................................141 11.7.2 Zugriff von Serveragenten auf andere Server ..........................141 11.8 Fragen....................................................................................................142 12 A u fr u f e x t e r n e r P r og r amm mme e ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 43 12.1 Verständnisvoraussetzungen...................................................................143 12.2 Lernziel ..................................................................................................143 12.3 Ausführen von externen Programmen ....................................................143 12.4 Einbinden von externen Anwendungen in eigene LotusScript-Dateien ...143 12.5 Lizenzrechtliche Probleme bei der Verwendung von externen Anwendungen.........................................................................144 12.5.1 Sicherheits-Probleme bei der Verwendung von externen Anwendungen .........................................................144 12.5.2 Administrative Probleme bei der Verwendung von externen Programmen............................................................144 12.5.3 Kompatibilitätsprobleme bei der Verwendung von externen Programmen............................................................144 12.6 Wann der Einsatz von externen Anwendungen sinnvoll ist .....................145 12.7 Art der externen Anwendungen .............................................................145 12.7.1 Dynamische Bibliotheken........................................................145 12.7.2 Verwendung von dynamischen Bibliotheken...........................145 12.7.3 ActiveX-Elemente ...................................................................145 12.7.4 LSX-Klassen ............................................................................146 12.8 Fragen....................................................................................................146 13 Di e V e rw e n d un g v o n O L E .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 47 13.1 Verständnisvoraussetzungen...................................................................147 13.2 Lernziel ..................................................................................................147 13.3 Was ist OLE?...........................................................................................147 13.4 Der Unterschied von Embedded- und Linking-Objects ...........................147 13.5 Erstellung eines Datei-Anhangs...............................................................147

Inhaltsverzeichnis

13.6 13.7 13.8 13.9 13.10 13.11 13.12 13.13 13.14 13.15

11

Erstellen eines eingebetteten bzw. verknüpften Objektes........................148 Zugriff auf einen Datei-Anhang ..............................................................149 Zugriff auf ein eingefügtes oder ein eingebettetes Objekt.......................150 Zugriff auf alle Objekte eines Items oder des ganzen Dokuments ...........150 13.9.1 Die Eigenschaften eines eingebetteten Objektes .....................151 Bearbeiten eines eingebetteten oder verknüpften Objektes ....................151 Entfernen eines eingebetteten oder verknüpften Objekts bzw. eines Datei-Anhangs...............................................................................152 Extrahieren eines Datei-Anhangs ............................................................152 Weitere Möglichkeiten ...........................................................................153 Wichtige Bemerkungen ..........................................................................153 Fragen....................................................................................................153

14 D e r U m ga n g m i t Da t e ie n . .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 55 14.1 Verständnisvoraussetzungen...................................................................155 14.2 Lernziel ..................................................................................................155 14.3 Einleitung...............................................................................................155 14.3.1 Der Dateityp...........................................................................156 14.4 Die sequentielle Datei.............................................................................156 14.4.1 Was ist eine sequentielle Datei? ..............................................156 14.4.2 Das Öffnen einer sequentiellen Datei ......................................156 14.4.3 Schreiben in eine sequentielle Datei........................................157 14.4.4 Lesen aus einer sequentiellen Datei.........................................157 14.4.5 Positionieren des Dateizeigers bei einer sequentiellen Datei ....157 14.4.6 Ermitteln der aktuellen Position des Dateizeigers in einer sequentiellen Datei ........................................................158 14.4.7 Ermitteln des Dateiendes ........................................................158 14.4.8 Das Schließen einer sequentiellen Datei ..................................159 14.4.9 Die Dateinummer ...................................................................159 14.5 Die Random-Datei..................................................................................159 14.5.1 Was ist eine Random-Datei?....................................................159 14.5.2 Die Deklaration der Datenstruktur mit der Type-Anweisung....159 14.5.3 Das Öffnen einer Random-Datei .............................................160 14.5.4 Das Schreiben in eine Random-Datei ......................................160 14.5.5 Das Lesen aus einer Random-Datei .........................................161 14.5.6 Das Schließen einer Random-Datei .........................................161 14.5.7 Das Positionieren des Dateizeigers in einer Random-Datei.......161 14.6 Die Binärdatei ........................................................................................162 14.6.1 Das Öffnen einer Binärdatei ....................................................162 14.6.2 Das Schreiben in eine Binärdatei .............................................162 14.6.3 Das Lesen aus einer Binärdatei ................................................162 14.6.4 Das Schließen einer Binärdatei ................................................162 14.6.5 Das Positionieren eines Dateizeigers in einer Binärdatei...........162

12

Inhaltsverzeichnis

14.7 Locking-Mechanismen ...........................................................................163 14.7.1 Dateilocking ...........................................................................163 14.8 Die Loc-Funktion ....................................................................................165 14.9 Die Lof-Funktion.....................................................................................166 14.10 FileAttr-Funktion....................................................................................166 14.11 Funktion für nicht geöffnete Dateien .....................................................167 14.11.1 Die FileLen-Funktion ...............................................................167 14.11.2 Die FileCopy-Anweisung .........................................................167 14.11.3 Die Dir-Anweisung..................................................................167 14.11.4 ChDir .....................................................................................168 14.11.5 CurDir ....................................................................................168 14.11.6 CurDrive.................................................................................168 14.11.7 Die Anweisung Kill..................................................................168 14.11.8 Die Anweisung Name .............................................................168 14.11.9 Die Anweisung SetFileAttr.......................................................169 14.11.10 Die Anweisung GetFileAttr ......................................................169 14.12 Fragen....................................................................................................169 15 Be n ut ze r i n t e r akt i o n .. .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 71 15.1 Print .......................................................................................................171 15.2 MessageBox ...........................................................................................171 15.3 InputBox ................................................................................................172 15.4 DialogBox ..............................................................................................172 15.5 Picklist ....................................................................................................173 15.6 Fragen....................................................................................................176 16 Mo d u le un d S i ch t ba rk e it e n . ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 77 16.1 Verständnisvoraussetzungen...................................................................177 16.2 Lernziel ..................................................................................................177 16.3 Der Begriff des Moduls ...........................................................................177 16.4 Zugang zu Modulen und deren Aufbau..................................................178 16.5 Wichtige Bemerkungen ..........................................................................185 16.6 Fragen....................................................................................................186 17 O bj e kt o r i e n t ie r t e P r o g ra m mi e r u n g un t e r L o t u sS c ri p t .. ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...1 1 87 17.1 Verständnisvoraussetzungen...................................................................187 17.2 Lernziel ..................................................................................................187 17.3 Motivation .............................................................................................187 17.4 Was ist OOP? .........................................................................................188 17.5 OOP am Beispiel ....................................................................................189 17.6 Funktionale Analyse................................................................................190 17.7 Objektorientierte Analyse .......................................................................192 17.8 Kerngedanken der Funktionalen und der Objektorientierten Programmierung.......................................................193 17.9 Objekte in LotusScript »bauen« ..............................................................193

Inhaltsverzeichnis

13

17.10 Eigenschaften und Methoden.................................................................195 17.11 Abfrage von Eigenschaften .....................................................................196 17.12 Zuweisen von Eigenschaften ..................................................................196 17.12.1 Explizites Setzen von Eigenschaften ........................................196 17.12.2 Implizites Setzen von Eigenschaften........................................197 17.13 Vererbung ..............................................................................................200 17.14 Zustandsvariablen ..................................................................................205 17.15 Methodenvererbung ..............................................................................205 17.16 Properties...............................................................................................207 17.17 Klassenvariablen .....................................................................................209 17.18 New-Methoden mit unterschiedlichen Parameterlisten in derselben Ableitungshierarchie...............................................................211 17.19 Benutzerdefinierte Containerklassen .......................................................213 17.20 Ein Rasenmäher in Aktion .......................................................................217 17.21 Virtuelle Funktionen und Mächtigkeit von LotusScript contra C++ u. a. ..219 17.22 Polymorphismus.....................................................................................220 17.22.1 Variantvariablen für Pseudopolymorphismus...........................222 17.23 Datenstrukturen unter LotusScript ..........................................................223 17.24 Praktisches Beispiel für Objekte aus dem Kontaktmanagement ...............225 17.25 Fragen....................................................................................................228 18 D o m i n o -Kl ass sse e n . .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...2 2 31 18.1 Überblick................................................................................................231 18.2 Notes-Objekte instanziieren....................................................................233 18.2.1 Weg: Einstieg über NotesUIWorkspace ...................................234 18.2.2 Weg: Einstieg über NotesSession ............................................235 18.3 Einige häufige Problemstellungen und ihre Lösung(en) ..........................237 18.3.1 Bearbeite das gerade geöffnete und aktivierte Dokument .......237 18.3.2 Starte einen Agenten ..............................................................237 18.3.3 Erzeuge ein neues Dokument .................................................237 18.3.4 Kopiere Dokumente................................................................237 18.3.5 Versende ein Dokument .........................................................238 18.3.6 Finde bestimmte Dokumente..................................................238 18.3.7 Ergreife alle in einer Ansicht markierten Dokumente ...............239 18.3.8 Öffne eine Datenbank.............................................................239 18.3.9 Finde eine geöffnete Datenbank .............................................239 18.4 Containerklassen: NotesDbDirectory, NotesDocumentCollection, NotesView..............................................................................................240 18.4.1 Erste Methode: GetFirstXXX/GetNextXXX-Kombination .........240 18.4.2 Zweite Methode: GetNthXXX.................................................242 18.5 Neue Funktionalitäten unter Domino R5 ................................................242 18.6 Spezielle Betrachtungen .........................................................................243 18.7 Weitere Klassen, LSX ..............................................................................243

14

Inhaltsverzeichnis

19 A u f D at e n b an ke n u n d Do ku m e n t e zu gr e i f e n u n d s ie be ar b e i te n ... ..... .. .... ... ...2 2 45 19.1 Verständnisvoraussetzungen...................................................................245 19.2 Lernziel ..................................................................................................245 19.3 Datenbanken .........................................................................................245 19.3.1 Allgemeines zum Datenbankzugriff.........................................245 19.3.2 Neue Datenbanken erzeugen .................................................246 19.3.3 Zugriff auf vorhandene Datenbanken .....................................248 19.3.4 Löschen von Datenbanken......................................................251 19.3.5 Programmieren von Datenbanken ..........................................251 19.4 Dokumente finden und darauf zugreifen ................................................256 19.4.1 Zusammenhang zwischen den Klassen NotesDatabase, NotesView und NotesDocumentCollection .............................256 19.4.2 Suchmöglichkeiten in NotesDocumentCollection ...................256 19.4.3 Suchmöglichkeiten in NotesView ............................................262 19.4.4 Suchmöglichkeiten in NotesDatabase .....................................267 19.5 Mit Dokumenten arbeiten ......................................................................269 19.5.1 Neue Dokumente erzeugen ....................................................272 19.5.2 Dokumente speichern.............................................................272 19.5.3 Dokument mit Inhalt füllen.....................................................272 19.5.4 Dokument mit Maske verbinden.............................................273 19.5.5 Items anzeigen .......................................................................273 19.5.6 Extended Syntax.....................................................................273 19.5.7 Beispiele und weitere Syntaxangaben .....................................274 20 P r of il ild do ku m e n t e . .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...2 2 81 20.1 Verständnisvoraussetzungen...................................................................281 20.2 Lernziel ..................................................................................................281 20.3 Was ist ein Profildokument? ...................................................................281 20.3.1 Wie die zwei unterschiedlichen Arten von Profildokumenten erzeugt werden ......................................................................281 20.4 Das Arbeiten mit Profildokumenten ........................................................282 20.4.1 Erstellen bzw. Öffnen eines Datenbankprofils..........................282 20.4.2 Löschen eines Profildokuments ...............................................283 20.5 Die Verwendung von GetProfileDocCollection........................................284 20.6 Die Benutzerprofildokumente.................................................................284 20.6.1 Erstellen bzw. Öffnen eines Benutzerprofildokuments .............284 20.7 Fragen....................................................................................................285

Inhaltsverzeichnis

21 L ot u s 21.1 21.2 21.3

21.4

21.5

21.6 21.7

15

N o t e s -S ic h e r h e it . ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...2 2 87 Verständnisvoraussetzungen...................................................................287 Lernziel ..................................................................................................287 Zugriffsschutz.........................................................................................287 21.3.1 NotesACL ...............................................................................287 21.3.2 NotesACLEntry .......................................................................289 21.3.3 Zugriffslevel ............................................................................290 21.3.4 Zusammenspiel verschiedener Einträge...................................290 Zugriffsschutz auf Dokumentenebene ....................................................291 21.4.1 Autorenfelder .........................................................................291 21.4.2 Leserfelder ..............................................................................291 21.4.3 Mehrere Autoren- und Leserfelder ..........................................292 21.4.4 Beispiele .................................................................................292 21.4.5 Funktionen (Rollen) ................................................................293 21.4.6 Zusammenfassung..................................................................293 21.4.7 Wichtige Bemerkungen ..........................................................294 Verschlüsselungsmechanismen ...............................................................294 21.5.1 Geheimer Schlüssel.................................................................294 21.5.2 Public-Private-Schlüsselpaar ....................................................294 21.5.3 Verschlüsselung mit LotusScript ..............................................295 Elektronische Unterschriften ...................................................................297 Fragen....................................................................................................297

22 O D B C- Sc hn hniitt ttss t e l le ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...2 2 99 22.1 Verständnisvoraussetzungen...................................................................299 22.2 Lernziel ..................................................................................................299 22.3 Was ist ODBC? .......................................................................................299 22.4 ODBC in Lotus-Notes/Domino ...............................................................300 22.5 Einsatzgebiete ........................................................................................300 22.6 Die LS:DO-Klassen..................................................................................301 22.6.1 ODBCConnection...................................................................301 22.6.2 ODBCQuery ...........................................................................309 22.6.3 ODBCResultSet .......................................................................311 22.7 Der praktische Einsatz von LS:DO ...........................................................323 22.8 Fehler.....................................................................................................323 22.9 Fragen....................................................................................................324 23 Ku r zr e f e r e n z d e r N o te s / D o mi n o -K l ass sse e n . ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...3 3 25 23.1 Zum Gebrauch dieser Referenz...............................................................325 23.2 Button....................................................................................................326 23.3 Field .......................................................................................................326 23.4 Navigator...............................................................................................326 23.5 NotesACL...............................................................................................327 23.6 NotesACLEntry .......................................................................................328

16

Inhaltsverzeichnis

23.7 23.8 23.9 23.10 23.11 23.12 23.13 23.14 23.15 23.16 23.17 23.18 23.19 23.20 23.21 23.22 23.23 23.24 23.25 23.26 23.27 23.28 23.29 23.30 23.31 23.32 23.33 23.34 23.35 23.36 23.37 23.38 23.39 23.40 23.41 23.42

NotesAgent............................................................................................330 NotesDatabase.......................................................................................332 NotesDateRange ....................................................................................336 NotesDateTime .....................................................................................337 NotesDbDirectory .................................................................................339 NotesDocument....................................................................................339 NotesDocumentCollection ....................................................................343 NotesEmbeddedObject .........................................................................345 NotesForm ............................................................................................346 NotesInternational ................................................................................347 NotesItem .............................................................................................348 NotesLog ..............................................................................................350 NotesName...........................................................................................351 NotesNewsletter ...................................................................................353 NotesOutline.........................................................................................354 NotesOutlineEntry.................................................................................355 NotesRegistration ..................................................................................357 NotesReplication ...................................................................................358 NotesRichTextItem................................................................................359 NotesRichTextParagraphStyle................................................................361 NotesRichTextStyle ...............................................................................361 NotesRichTextTab .................................................................................362 NotesSession .........................................................................................363 NotesTimer ...........................................................................................365 NotesUIDatabase ..................................................................................365 NotesUIDocument ................................................................................366 NotesUIView .........................................................................................370 NotesUIWorkspace ................................................................................371 NotesView.............................................................................................373 NotesViewColumn ................................................................................377 NotesViewEntry.....................................................................................379 NotesViewEntryCollection .....................................................................380 NotesViewNavigator .............................................................................381 ODBCConnection .................................................................................383 ODBCQuery ..........................................................................................384 ODBCResultSet .....................................................................................385

Inhaltsverzeichnis

17

24 Di e B e f e h l s- Re f e r e n z . .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...3 3 89 24.1 Aufbau der Referenz ...............................................................................389 24.2 Typumwandlung....................................................................................389 24.3 Verdeckte Typumwandlung ...................................................................390 24.3.1 Das automatische Casting ......................................................390 24.3.2 Beispiele für automatisches Casting ........................................390 24.4 Befehlsgruppen ......................................................................................391 24.4.1 Konvertierung.........................................................................391 24.4.2 Typenprüfung ........................................................................391 24.4.3 Datumsfunktionen I ................................................................391 24.4.4 Mathematische Funktionen ....................................................392 24.4.5 Zufallszahlen...........................................................................392 24.4.6 Zeichenkette I.........................................................................392 24.4.7 Zeichenketten II......................................................................393 24.4.8 Zeichenketten III.....................................................................393 24.4.9 Schleifen.................................................................................393 24.4.10 Rundung ................................................................................394 24.4.11 Datumsfunktionen II ...............................................................394 24.4.12 Array ......................................................................................394 24.4.13 Threadhandling und Locking ..................................................394 24.4.14 Dateien...................................................................................395 24.4.15 Standardtypen-Deklaration .....................................................395 24.4.16 Operatoren.............................................................................395 24.5 Die Befehle.............................................................................................396 24.5.1 Abs .........................................................................................396 24.5.2 Acos .......................................................................................396 24.5.3 ActivateApp ............................................................................397 24.5.4 And ........................................................................................398 24.5.5 ArrayAppend ..........................................................................399 24.5.6 ArrayGetIndex ........................................................................401 24.5.7 ArrayReplace...........................................................................402 24.5.8 Asc .........................................................................................403 24.5.9 ASin........................................................................................404 24.5.10 ATn ........................................................................................405 24.5.11 ATn2 ......................................................................................406 24.5.12 Beep .......................................................................................407 24.5.13 Bin..........................................................................................408 24.5.14 Call.........................................................................................408 24.5.15 CCur ......................................................................................410 24.5.16 CDat.......................................................................................411 24.5.17 CDbl.......................................................................................412 24.5.18 ChDir .....................................................................................413

18

Inhaltsverzeichnis

24.5.19 24.5.20 24.5.21 24.5.22 24.5.23 24.5.24 24.5.25 24.5.26 24.5.27 24.5.28 24.5.29 24.5.30 24.5.31 24.5.32 24.5.33 24.5.34 24.5.35 24.5.36 24.5.37 24.5.38 24.5.39 24.5.40 24.5.41 24.5.42 24.5.43 24.5.44 24.5.45 24.5.46 24.5.47 24.5.48 24.5.49 24.5.50 24.5.51 24.5.52 24.5.53 24.5.54 24.5.55 24.5.56 24.5.57 24.5.58 24.5.59 24.5.60

ChDrive ..................................................................................414 Chr.........................................................................................415 CInt ........................................................................................416 Class.......................................................................................416 CLng ......................................................................................418 Close ......................................................................................419 CodeLock ...............................................................................420 CodeLockCheck......................................................................421 CodeUnlock............................................................................422 Const .....................................................................................423 Command ..............................................................................424 Cos.........................................................................................425 CreateLock .............................................................................425 CreateObject ..........................................................................426 CSng ......................................................................................428 CStr........................................................................................428 CurDir ....................................................................................429 CurDrive.................................................................................430 CVar .......................................................................................431 CVdate ...................................................................................432 Date .......................................................................................432 DateNumber ..........................................................................432 DateSerial ...............................................................................434 DataType................................................................................434 DateValue...............................................................................435 Day ........................................................................................436 Declare (external C) C ............................................................437 Declare forward ......................................................................439 DefCur ...................................................................................440 DefDbl....................................................................................441 DefInt .....................................................................................442 DefLng ...................................................................................443 DefSng ...................................................................................444 DefStr .....................................................................................445 DefVar ....................................................................................446 Delete.....................................................................................447 DestroyLock............................................................................448 Dim ........................................................................................449 Dir ..........................................................................................450 Do ..........................................................................................452 DoEvents ................................................................................453 End.........................................................................................453

Inhaltsverzeichnis

24.5.61 24.5.62 24.5.63 24.5.64 24.5.65 24.5.66 24.5.67 24.5.68 24.5.69 24.5.70 24.5.71 24.5.72 24.5.73 24.5.74 24.5.75 24.5.76 24.5.77 24.5.78 24.5.79 24.5.80 24.5.81 24.5.82 24.5.83 24.5.84 24.5.85 24.5.86 24.5.87 24.5.88 24.5.89 24.5.90 24.5.91 24.5.92 24.5.93 24.5.94 24.5.95 24.5.96 24.5.97 24.5.98 24.5.99 24.5.100 24.5.101 24.5.102

19

Environ ...................................................................................454 Erase.......................................................................................455 Erl...........................................................................................456 Err-Funktion............................................................................457 Err Statement .........................................................................458 Error-Funktion ........................................................................458 Error Statement ......................................................................459 Eof..........................................................................................460 Exp .........................................................................................461 Exit .........................................................................................462 Evaluate..................................................................................463 Execute ..................................................................................463 FileAttr....................................................................................464 FileCopy .................................................................................466 FileDateTime ..........................................................................467 FileLen ....................................................................................467 Fix ..........................................................................................468 Fraction ..................................................................................469 FreeFile ...................................................................................470 For..........................................................................................471 ForAll......................................................................................472 Format ...................................................................................473 FullTrim ..................................................................................474 Function .................................................................................475 Get .........................................................................................476 GetAttr ...................................................................................477 GetFileAttr ..............................................................................478 GetObject...............................................................................479 GetThreadInfo ........................................................................480 GoSub ....................................................................................481 GoTo ......................................................................................482 Hex ........................................................................................483 Hour.......................................................................................483 If...Goto..................................................................................484 If...Then...Else .........................................................................485 If...Then...ElseIf .......................................................................486 IMEStatus ...............................................................................488 IMESetMode...........................................................................489 InputBox ................................................................................490 Input# ....................................................................................491 Input ......................................................................................492 InputB ....................................................................................493

20

Inhaltsverzeichnis

24.5.103 24.5.104 24.5.105 24.5.106 24.5.107 24.5.108 24.5.109 24.5.110 24.5.111 24.5.112 24.5.113 24.5.114 24.5.115 24.5.116 24.5.117 24.5.118 24.5.119 24.5.120 24.5.121 24.5.122 24.5.123 24.5.124 24.5.125 24.5.126 24.5.127 24.5.128 24.5.129 24.5.130 24.5.131 24.5.132 24.5.133 24.5.134 24.5.135 24.5.136 24.5.137 24.5.138 24.5.139 24.5.140 24.5.141 24.5.142 24.5.143 24.5.144

InputBP ..................................................................................493 InStr .......................................................................................493 InStrB .....................................................................................494 InStrBP ...................................................................................495 InStrC .....................................................................................495 Int ..........................................................................................495 IsA ..........................................................................................496 IsArray ....................................................................................497 IsDate .....................................................................................498 IsDefined ................................................................................498 IsElement................................................................................499 IsEmpty ..................................................................................500 IsList .......................................................................................501 IsNull......................................................................................502 IsNumeric ...............................................................................502 IsObject ..................................................................................503 IsScalar ...................................................................................504 IsUnknown .............................................................................505 Kill ..........................................................................................506 LBound...................................................................................506 LCase......................................................................................507 Left.........................................................................................508 LeftB.......................................................................................509 LeftBP .....................................................................................509 LeftC ......................................................................................510 Len .........................................................................................510 LenBP .....................................................................................511 LenB .......................................................................................511 LenC.......................................................................................512 Let..........................................................................................512 ListTag....................................................................................512 Loc .........................................................................................513 Lock .......................................................................................514 Lof..........................................................................................515 Log.........................................................................................516 LSet ........................................................................................517 LTrim......................................................................................518 Like ........................................................................................518 Line Input# .............................................................................519 MessageBox ...........................................................................520 Mid-Funktion..........................................................................522 Mid Statement .......................................................................523

Inhaltsverzeichnis

24.5.145 24.5.146 24.5.147 24.5.148 24.5.149 24.5.150 24.5.151 24.5.152 24.5.153 24.5.154 24.5.155 24.5.156 24.5.157 24.5.158 24.5.159 24.5.160 24.5.161 24.5.162 24.5.163 24.5.164 24.5.165 24.5.166 24.5.167 24.5.168 24.5.169 24.5.170 24.5.171 24.5.172 24.5.173 24.5.174 24.5.175 24.5.176 24.5.177 24.5.178 24.5.179 24.5.180 24.5.181 24.5.182 24.5.183 24.5.184 24.5.185 24.5.186

21

MidB ......................................................................................524 MidBP ....................................................................................524 MidC ......................................................................................524 Minute ...................................................................................524 MkDir .....................................................................................525 Month ....................................................................................526 Mod .......................................................................................527 MsgBox ..................................................................................528 Name .....................................................................................528 Not.........................................................................................529 Now .......................................................................................530 Oct.........................................................................................530 On Error .................................................................................531 On...GoSub ............................................................................532 On...GoTo ..............................................................................533 On Event ................................................................................534 Option Base............................................................................535 Option Compare ....................................................................536 Option Declare .......................................................................537 Option Public .........................................................................537 Open......................................................................................538 Or ..........................................................................................540 Print .......................................................................................540 Print# .....................................................................................541 Property Get / Property Set.....................................................542 Put .........................................................................................543 Randomize .............................................................................544 ReDim ....................................................................................545 Rem........................................................................................546 Reset ......................................................................................546 Resume ..................................................................................547 Return ....................................................................................548 Right ......................................................................................548 RightBP ..................................................................................549 RightB ....................................................................................549 RightC ....................................................................................550 Round ....................................................................................550 RmDir.....................................................................................551 Rnd ........................................................................................551 RSet........................................................................................552 RTrim .....................................................................................553 Run ........................................................................................553

22

Inhaltsverzeichnis

24.5.187 24.5.188 24.5.189 24.5.190 24.5.191 24.5.192 24.5.193 24.5.194 24.5.195 24.5.196 24.5.197 24.5.198 24.5.199 24.5.200 24.5.201 24.5.202 24.5.203 24.5.204 24.5.205 24.5.206 24.5.207 24.5.208 24.5.209 24.5.210 24.5.211 24.5.212 24.5.213 24.5.214 24.5.215 24.5.216 24.5.217 24.5.218 24.5.219 24.5.220 24.5.221 24.5.222 24.5.223 24.5.224 24.5.225 24.5.226 24.5.227 24.5.228

Second ...................................................................................554 Seek-Funktion .........................................................................554 Seek-Anweisung .....................................................................555 Select Case .............................................................................556 SendKey .................................................................................558 SetAttr ....................................................................................558 SetFileAttr...............................................................................558 Sgn.........................................................................................559 Shell .......................................................................................560 Sin..........................................................................................562 Sleep ......................................................................................562 Space .....................................................................................563 Spc .........................................................................................564 Sqr .........................................................................................564 Stop .......................................................................................565 Str .........................................................................................566 StrLeft.....................................................................................566 StrLeftBack .............................................................................567 StrRight ..................................................................................568 StrRightBack ...........................................................................569 StrCompare ............................................................................570 StrComp.................................................................................571 StrConv ..................................................................................571 String-Funktion.......................................................................571 Sub.........................................................................................572 Tab.........................................................................................573 Tan.........................................................................................574 Time-Anweisung.....................................................................575 Time-Funktion ........................................................................575 TimeNumber ..........................................................................576 Timer......................................................................................576 TimeValue ..............................................................................577 Today .....................................................................................578 Trim .......................................................................................578 Type .......................................................................................579 TypeName..............................................................................580 UBound ..................................................................................581 UCase.....................................................................................582 UChr ......................................................................................582 Uni .........................................................................................583 UnLock ...................................................................................584 Use .........................................................................................585

Inhaltsverzeichnis

23

24.5.229 UseLSX ...................................................................................586 24.5.230 UString ...................................................................................586 24.5.231 Val..........................................................................................587 24.5.232 VarType ..................................................................................588 24.5.233 Weekday ................................................................................588 24.5.234 While......................................................................................589 24.5.235 Width# ...................................................................................590 24.5.236 Write# ....................................................................................591 24.5.237 With .......................................................................................591 24.5.238 Xor .........................................................................................592 24.5.239 Year ........................................................................................593 24.5.240 Yield .......................................................................................594 24.5.241 %If .........................................................................................595 24.5.242 %Include ................................................................................596 24.5.243 %Rem ....................................................................................597 24.6 Datentypen ............................................................................................598 24.6.1 Numerische Datentypen .........................................................598 24.6.2 Alphanumerische Datentypen.................................................598 24.6.3 Sonstige Datentypen ..............................................................598 24.6.4 Prefix der Zahlensysteme ........................................................599 24.7 Konstanten.............................................................................................599 24.8 Includedateien .......................................................................................599 25 D i e A n w e n d un g au s d e m Ka pi t e l 17 .. ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...6 6 01 S ti c h wo r t ve r z e ic hn hniis . .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ..... .. .... ... ...6 6 07

25

Einleitung Wir möchten wir Ihnen an dieser Stelle kurz vermitteln, womit Sie in diesem Buch rechnen können. Lotus Notes/Domino wird fälschlicherweise oft für ein E-Mailsystem gehalten. Mailen kann dieses System zwar auch, doch ist Lotus Notes/Domino viel mehr: Datenbank, Workgroup-Software, Web-Server usw. Es ist gut geeignet, die täglichen Kommunikationsprozesse in den Unternehmen zu unterstützen, zu vereinfachen und zu beschleunigen. Lotus Notes hat durch seine Flexibilität und Anwenderfreundlichkeit eine starke Position an der Spitze des Groupwaremarktes erreicht. Um dieses große Potential ausschöpfen zu können, stehen mehrere Programmiermöglichkeiten zur Verfügung, beginnend mit der Notes-Formelsprache über LotusScript, JavaScript, Java, bis hin zur C- und C++-API. Trotz all dieser Möglichkeiten ist LotusScript nach wie vor die Sprache, in der Lotus Notes/Domino-Datenbanken programmiert werden. Sie ist einfach zu erlernen und birgt aufgrund des mächtigen Domino-Klassenkonzeptes starke Möglichkeiten. Daher wird sich jeder Notes-Entwickler mit ihr auseinandersetzen. Dieses Buch wurde geschrieben, damit Sie gleich von Anfang an den größten Nutzen aus LotusScript haben können. Es zeigt sowohl die grundlegenden Möglichkeiten als auch die »hohe Kunst« der objektorientierten Programmierung mit den unter LotusScript zugegebenermassen etwas eingeschränkten Möglichkeiten auf. Die Beschäftigung mit der objektorientierten Programmierung (OOP) wird für einen fortgeschrittenen Notes-Entwickler kaum ausbleiben, da ein Großteil der wirklich interessanten Datenbankmanipulationen über die von Lotus zur Verfügung gestellten Domino-Klassen (also objektorientierte Programmiermöglichkeiten) erfolgt. Diesem Thema ist ein umfangreicher Teil des Buches gewidmet. Es wird sehr anschaulich und mit viel praktischem Hintergrund dargelegt. Im Zusammenhang mit den grundlegenden Möglichkeiten der Scriptsprache erhalten Sie eine umfangreiche und durchdachte Referenz. Die einzelnen Sprachmerkmale wurden intensiv ausgetestet, um Ihnen auf engem Raum so viel Informationen wie möglich zu bieten, z.B. auch über häufig anzutreffende implizite Typumwandlungen und andere Merkmale, die sonst nur selten (wenn überhaupt) erläutert werden. Sie erhalten somit auch manche Information, die von Lotus nicht dokumentiert ist. Um die Arbeit mit den Domino-Klassen zu erleichtern, wurde eine Kurzreferenz eingefügt, die sämtliche zur Zeit dokumentierten Domino-Klassen umfasst. Sie dient dazu, sich möglichst schnell einen Überblick über den Aufbau und das Potential der Domino-Klassen zu verschaffen und sie sofort effektiv zu nutzen. Zahlreiche praxisorientierte Beispiele tun ihr übriges, um den Leser zu unterstützen.

26

Einleitung

Das Buch ist so aufgebaut, dass es sowohl dem Einsteiger (der schon ein wenig allgemeine Programmiererfahrung besitzen sollte), als auch dem fortgeschrittenen Notes-Entwickler viele Vorteile bringt. Während sich Einsteiger eher mit den grundlegenden Erläuterungen und den zahlreichen Beispielen beschäftigen werden, wird der bereits Fortgeschrittene gerne auf die nicht alltäglichen Praxishinweise zurückkommen, die ihm helfen, manche Stolperfalle von vornherein zu meiden. Auch wird er immer wieder gerne auf die Referenzen zurückgreifen, die ihn bei der täglichen Arbeit noch lange wirkungsvoll unterstützen werden. Der Code der in diesem Buch mittels der Beispiele entwickelten (rudimentären) Kontaktverwaltung ist neben anderen sehr nützlichen Notes-Tools auch auf der beiligenden CD zu finden.

27

Satzkonventionen Menüaufrufe

Datei | Datenbank | Öffnen...

Bedeutung: Im Hauptmenü den Punkt Datei, in dessen Untermenü den Eintrag Datenbank und dann den Button Öffnen... anklicken.

Buttonaufrufe: Button Durchsuchen... Bedeutung: den Button Durchsuchen... anklicken

Anführungszeichen im Text: »Text«

Syntax:

Set notesItem = notesDocument.AppendItemValue( _ itemName$ As String, value As Variant )

Bedeutung: Die fett gedruckten Wörter sind Schlüsselwörter und in Notes definierte Funktionen und Klassen nebst deren Eigenschaften und Methoden. Domino-Objekte werden in kursiv-normal angegeben. Auch Parameter und benutzerdefinierte Namen werden so geschrieben. Codebeispiele: AppendItemValue(Byval Itemname As String, Newvalue) _ As NotesItem

Fest definierte Werte und Konstanten: TRUE, FALSE, EMPTY, ACCESS_LEVEL_MANAGER usw.

Auslassungen: ...

Syntaxdiagramme und Merksätze: Syntax, Merksatz

Typenbezeichnungen: Wo möglich, durch die Kürzel der impliziten Variablen-Deklaration ($, &, #, %, ...), z. B. name$

1 1

Das Anwendungsbeispiel

Beim Schreiben des Buches stellte sich die Herausforderung, eine möglichst präzise und praxisnahe Einführung in die LotusScript-Programmierung zu bieten. Gleichzeitig sollte dem LotusScript-Einsteiger ein möglichst direkter und schneller Zugang zu den Möglichkeiten der Applikationssprache verschafft werden. Ohne zu versäumen, ihn auf zahlreiche Fallen und Tücken aufmerksam zu machen, die ihm im Alltag häufig begegnen werden. Zur Unterstützung dieses Ziels werden im mittleren Teil des Buches Komponenten einer praxisbezogenen Notes-Anwendung aufgebaut, die ein Kontaktmanagement unterstützt. Sie besteht aus drei Datenbanken, wie sie in der Praxis immer wieder vorkommen werden. Eine Stammdaten-Datenbank (Adressen), eine Konfigurations-Datenbank (mit der einstellbare Daten für die Gesamtanwendung verwaltet werden) und eine Anwendungsdatenbank (Kontakte). Gleichzeitig ist das Werk bewusst über weite Teile wie eine Referenz aufgebaut. Dadurch soll es Ihnen auch über die Einführung hinaus lange Zeit wertvolle Dienste als Nachschlagewerk leisten können. Die Beispielanwendung »Kontaktmanagement« wird insbesondere in den Kapiteln 15 »Benutzerinteraktion«, 19 »Auf Datenbanken und Dokumente zugreifen und sie bearbeiten« und 22 »ODBC-Schnittstelle« betrachtet und programmiert. Für das Kapitel 17 »Objektorientierte Programmierung unter LotusScript« wurde ein ganz anderer Rahmen gewählt, da sich diese Form der Programmierung mit dem gewählten Rasenmäher-Beispiel besser und umfangreicher veranschaulichen liess. Ansonsten wurde Wert darauf gelegt, dass die Möglichkeit besteht, einzelne Kapitel für sich zu studieren, ohne den vorherigen Fortlauf des Beispiels genau zu kennen. Dadurch, dass das Beispiel einfach und doch umfassend ist, wird dies gewährleistet. Den größten Nutzen werden Sie als Leser haben, wenn Sie die Beispiele mit aufbauen und das Zusammenspiel der einzelnen Komponenten und Schritte mitverfolgen. Wenn Ihnen die Zeit zum Mitprogrammieren fehlt, dann können Sie den Code natürlich auch von der beiliegenden CD verwenden.

30

Das Anwendungsbeispiel

1.1 Der Start: Ein erster Aufbau der Anwendung Kontaktmanagement 1.1.1 Datenbank »Adressen« Zunächst erzeugen wir eine neue leere Datenbank. Sie erhält den Namen adressen.nsf und den Titel »Adressen«. Der Einfachheit halber arbeiten wir zunächst lokal im Notes-Datenverzeichnis:

Abbildung 1.1: Erzeugung der neuen Datenbanken für das Kontaktmanagement

Dann erstellen wir zwei Masken, mit der die Adressdaten aufgenommen werden können. Dazu klicken Sie auf den Button »Neue Maske«. Es erscheint (wie in Abbildung 1.2 zu sehen) eine neue, leere Maske.

Der Start: Ein erster Aufbau der Anwendung Kontaktmanagement

31

Abbildung 1.2: Neue, leere Maske für die Adressen

Diese Maske versehen wir mit mehreren Feldern, die zur Aufnahme der Daten dienen. Die Felder erhalten entsprechende Label. Die Abgrenzung der Feldlabel nehmen wir über (mindestens zwei) Tabulatoren vor. Der zweite Tabulator dient dazu, dass wir eventuell Buttons zwischen Label und Feld setzen können, die ebenfalls per Tabulator ausgerichtet werden. Falls zur korrekten Ausrichtung erforderlich, nehmen Sie noch einen dritten Tabulator. Anschließend geben Sie der Maske den Namen »Firma« und speichern sie über Datei | Speichern ab.

32

Das Anwendungsbeispiel

Abbildung 1.3: Maske für Firmenadresse

Bevor wir die Personen-Maske zusammenstellen, benötigen wir noch eine Ansicht, mit der wir auf die Firmen zugreifen können. Da wir diese Ansicht nur für programmatischen Zugriff benötigen, wird sie sehr einfach gestaltet. Sie hat nur eine Spalte, die mit der verwendeten Spaltenformel überschrieben wird: Name + " " + Name2. Dies hat den Vorteil, dass wir später sofort sehen, welchen Inhalt die Spalte hat. Die Zusammensetzung der Formel aus beiden Namensteilen garantiert uns den eindeutigen Zugriff. Die Spalte sollte aufsteigend sortiert sein.

Der Start: Ein erster Aufbau der Anwendung Kontaktmanagement

33

Abbildung 1.4: Die Ansicht für Firmen-Dokumente

Für die Selektion verwenden Sie die Formel SELECT Form = "Firma". Die Ansicht wird unter dem Namen »(Firmen)« abgespeichert. Die Klammern sorgen dafür, dass die Ansicht vom Benutzer normalerweise nicht zu sehen ist (»versteckte Ansicht«). Ganz analog erzeugen Sie eine Ansicht für den schnellen Zugriff auf die PersonenDokumente, wie in Abbildung 1.5 gezeigt.

34

Das Anwendungsbeispiel

Abbildung 1.5: Die Ansicht für Personen-Dokumente

Jetzt müssen wir aber noch eine Maske für die Personen-Dokumente aufbauen. Dabei gehen wir analog zur Firmen-Maske vor. Das Ergebnis sehen Sie in der Abbildung 1.6. Das Feld Firma ist vom Typ »Berechnet beim Anlegen«. Der Hotspot-Button links daneben dient zur Auswahl und Zuordnung einer Firma. Er wird später eine Pickliste öffnen, die dem Benutzer hilft, das Personen-Dokument mit einer Firma zu verknüpfen. Näheres dazu finden Sie in Kapitel 15 »Benutzerinteraktion«. Als Nächstes erstellen wir die Konfigurations-Datenbank. Sie erhält eine Maske für Konfigurations-Dokumente und eine Ansicht, über die die einzelnen Konfigurationswerte gesucht werden können.

Der Start: Ein erster Aufbau der Anwendung Kontaktmanagement

35

Abbildung 1.6: Personen-Maske

1.1.2 Datenbank »Konfiguration« Die Datenbank nennen wir konfiguration.nsf (Titel Konfiguration) und die Maske »Konfiguration«. Der Aufbau der Maske wird in Abbildung 1.7 gezeigt. Die Felder sind bearbeitbar. Das Feld Werte sollte Mehrfachwerte aufnehmen können, als Trennzeichen haben wir die Zeilenumschaltung gewählt (sowohl für die Anzeige als auch für die Eingabe). Die Art des Trenners ist natürlich Geschmacksache, Sie können hier auch ein anderes Zeichen verwenden. Um die Beschreibung der Werte abzusetzen, haben wir eine kleinere Schrift und die Farbe Grau eingesetzt. Die Ansicht hat den Namen »Konfigurationen« und weist eine sortierte Spalte für den Namen der Konfigurationen auf. Die nächsten beiden Spalten sind unsortiert und nehmen die Werte und die Beschreibung auf. Mehrfachwerte sollten durch ein Trennzeichen getrennt angezeigt werden. Wir wählen das Komma.

36

Das Anwendungsbeispiel

Abbildung 1.7: Konfigurations-Maske

Abbildung 1.8: Maximale Ansichtszeilen pro Eintrag wählen

Es werden vorsichtshalber, mit der Option »Zeilenhöhe anpassen«, sechs Textzeilen pro Zeile eingestellt. Dadurch können auch längere Bemerkungen in der Ansicht gelesen werden, ohne dass unnötig Platz verschenkt wird. Geben Sie probeweise schon mal einen Wert ein, der später noch gebraucht werden kann:

Der Start: Ein erster Aufbau der Anwendung Kontaktmanagement

37

Abbildung 1.9: Konfigurations-Dokumente füllen

Die Ansicht sollte dann so ausschauen, wie in Abbildung 1.10 gezeigt.

Abbildung 1.10: Konfigurations-Ansicht

1.1.3 Datenbank »Kontakte« Jetzt brauchen wir nur noch die Anwendungs-Datenbank. Wir nennen Sie kontakte.nsf mit dem Titel Kontaktmanagement. Wir erzeugen eine Maske für die Kontakte. Sie enthält zweckmäßigerweise zwei Felder vom Typ Dialogliste (bearbeitbar): Kontaktart (Telefon, Besuch, ...) und NächsteAktion (Angebot, ...). Das Feld für den Zeitpunkt können Sie mit der Formel @Now vorbelegen. Wenn es bearbeitbar ist, kann der Benutzer bei Bedarf den genauen Zeitpunkt eintragen. Das Feld ist vom Typ Zeit/Datum.

38

Das Anwendungsbeispiel

Abbildung 1.11: Maske »Kontakt«

Fürs Erste erzeugen wir eine Ansicht, in der alle Daten zu sehen sind, sortiert nach Datum, Zeit und Kontaktperson. Die Spaltenformel fürs Datum lautet @Date(Zeitpunkt) und die für die Zeit @Time(Zeitpunkt). Die Auswahlformel lautet SELECT Form = "Kontakt". Abbildung 1.12 zeigt, wie die Dokumente in der Ansicht angezeigt werden.

Abbildung 1.12: Ansicht »Kontakte«

Wie geht es weiter?

39

1.2 Wie geht es weiter? Mit dieser Grundlage sind Sie jetzt gut ausgerüstet, den kommenden Beispielen zu folgen. Doch zunächst werden Sie über mehrere Kapitel hinweg mit den »Basics« versorgt. Insbesondere ab dem Kapitel »Benutzerinteraktion« werden wir dann auf die soeben aufgebaute Beispielanwendung zurückkommen. Und im Kapitel »Auf Datenbanken und Dokumente zugreifen und sie bearbeiten« werden Sie feststellen, wie nützlich und unverzichtbar die Domino-Klassen sind, um solche Anwendungen aufzubauen. Schließlich wird Ihnen das Kontaktmanagement noch einmal im Kapitel »ODBC-Schnittstelle« über den Weg laufen, wo wir den Zugriff auf eine relationale Datenbank (in diesem Falle Access) vorstellen. Und nun: Viel Spaß mit LotusScript und guten Erfolg!

2 2

Entwicklungsumgebung (IDE)

2.1 Verständnisvoraussetzungen In diesem Kapitel werden keine besonderen Voraussetzungen erwartet.

2.2 Lernziel Sie werden in diesem Kapitel mit der IDE von Notes/Domino bekannt gemacht, insbesondere mit den für einen LotusScript-Entwickler wichtigen Details. Sie sind anschließend in der Lage, mit der IDE schnell und einfach LotusScript-Programme zu entwerfen, wobei Sie vollen Gebrauch von den zahlreichen Unterstützungsfunktionen machen können. Außerdem werden wir den übersichtlichen und einfach zu bedienenden Script-Debugger erläutern.

2.3 Die IDE Gegenüber früheren Versionen wartet die Domino-IDE mit einer ganzen Reihe von interessanten Verbesserungen auf: eine baumartige Anzeige der Modulstruktur, die Markierung der mit Code versehenen Modulabschnitte und -eventhandler, eine größere Übersicht bei den Domino-Objekten, eine bessere Referenz usw.

Abbildung 2.1: Domino-IDE

42

Entwicklungsumgebung (IDE)

Abbildung 2.1 zeigt die Domino-IDE, wie sie sich bei der Programmierung einer LotusScript-Bibliothek präsentiert (je nachdem, welches Gestaltungselement gerade bearbeitet wird, kann das Aussehen leicht variieren). Sie teilt sich in drei Bereiche auf: links der Navigator durch die Gestaltungselemente der Datenbank, in der Mitte die Anzeige der Objektstruktur mit der Referenz und rechts das Programmierfenster. Wir werden diese Bereiche genauer untersuchen.

2.4 Navigator Im Navigator des Designers werden die Gestaltungselemente einer Datenbank in die Gruppen Gliederungen, Rahmengruppen, Seiten, Masken, Ansichten, Ordner, Navigatoren, Agenten und Ressourcen aufgegliedert. Die Gruppe Ressourcen selbst lässt sich durch einen Klick öffnen und auch schließen. Sie ist unterteilt in Bilder, Applets, Teilmasken, Gemeinsame Felder, ScriptBibliotheken und Andere. Um diese Elemente des Navigators sichtbar zu machen, muss die zu bearbeitende Datenbank allerdings erst geöffnet werden. Dies geschieht über die Menüeinträge Datei | Datenbank | Öffnen... Es öffnet sich die in Abbildung 2.2 gezeigte Dialogbox.

Abbildung 2.2: Dialogbox zum Suchen einer zu öffnenden Datenbank

In der Kombobox »Server« wählen Sie aus, auf welcher Maschine die Datenbank liegt, und im Listenfeld ermitteln Sie die dort befindlichen Datenbanken. Sie können auch das gesamte Filesystem des lokalen Rechners über den Button Durchsuchen... nach der gewünschten Datenbank durchlaufen. Nach Auswahl der Datenbank und Klicken auf den Button Öffnen wird diese geöffnet und ein Lesezeichen auf dem Navigator abgelegt. Sollten die vorher beschriebenen Gruppierungen der Gestaltungselemente nicht zu sehen sein, klicken Sie einmal auf den angezeigten Datenbanktitel, um die Liste zu öffnen. Umgekehrt kann die Liste durch einen solchen Klick wieder geschlossen werden.

Objektstruktur und Referenz

43

Im Navigator werden auch die Lesezeichen für weitere geöffnete Datenbanken abgelegt und angezeigt.

2.5 Objektstruktur und Referenz In der Mitte des IDE-Fensters werden die Objektstruktur und eine kontextsensitive Referenz angezeigt. Die Objektstrukturanzeige bietet einen Überblick über alle Abschnitte, die in dem Modul bzw. einem Gestaltungselement definiert sind. So werden z. B. bei einer Maske die Abschnitte »(Options)«, »(Declarations)«, »Initialize«, »Terminate« und die Eventhandler angezeigt. Darüber hinaus werden auch Aktionen, Buttons und alle weiteren Objekte aufgeführt. Dies ist eine wesentliche Verbesserung gegenüber den Vorgängerversionen, denn jetzt müssen Sie die einzelnen Objekte nicht mehr mühsam über eine Kombobox suchen, sondern können sehr effektiv navigieren. Zusätzlich erkennen Sie an den abgedunkelten Symbolen, in welchen Abschnitten sich benutzerdefinierter Code befindet. Wenn Sie eines der Symbole anklicken, wird der Inhalt des betreffenden Abschnitts im rechten Bereich, dem Programmierfenster, angezeigt. Die Referenz bietet einen kontextsensitiven Überblick über die Möglichkeiten, die die jeweilige Sprache und der jeweilige Kontext anbieten. Der Kontext wird von einer Einstellung im Programmierfenster bestimmt, das im nächsten Abschnitt genauer besprochen wird. Zwischen der Anzeige der Objektstruktur und der Referenz wird durch Anklicken der Reiter hin- und hergeschaltet. Ein Beispiel für die Referenzanzeige liefert die folgende Abbildung 2.3.

Abbildung 2.3: Kontextsensitive Referenz

44

Entwicklungsumgebung (IDE)

Im oberen Bereich der Anzeige sehen Sie eine Kombobox, mit der verschiedene Teile der Referenz ausgewählt werden können. Es können Bereiche zur LotusScript-Sprache, zu Domino-spezifischen Erweiterungen (Klassen, Konstanten usw.) und OLE-Klassen geöffnet werden. Wenn zusätzliche LSX-Module eingebunden werden, können auch diese hier eingesehen werden. Wir haben in Abbildung 2.3 den Bereich Domino-Klassen geöffnet. Im Listenfeld werden die Klassen mit ihren Eigenschaften (Properties), Methoden (Methods) und Ereignissen (Events) präsentiert. Durch das Listenfeld kann wie durch eine kategorisierte Notes-Ansicht hindurch navigiert werden. Auf unterster Ebene wird die Syntax der Elemente dargestellt. Diese stellt zugleich ein Codestück dar. Durch Ausführen eines Doppelklicks auf das Codestück oder durch Anklicken des Einfügen-Buttons wird es in das Programmierfenster übernommen. Der übernommene Text wird an die Stelle positioniert, an der der Cursor momentan steht. Es gibt zwei Arten der Codestückübernahme: Volltext oder Hauptbezeichner. Der Volltextmodus wird durch das Optionsfeld Volltext einfügen ausgewählt. Volltext bedeutet, dass die ganze angezeigte Zeile übertragen wird. In Abbildung 2.3 würde dies bei Auswahl der Dokument-Methode AppendItemValue bedeuten, dass folgender Text übernommen wird: AppendItemValue(Byval Itemname As String, Newvalue) As NotesItem

Im anderen Modus wird lediglich der folgende Teil übertragen: AppendItemValue

Der Hilfe-Button öffnet die Designerhilfe.

2.6 Programmierbereich 2.6.1 Editor Je nachdem welches Objekt programmiert wird, können unterschiedliche Sprachen verwendet werden, z. B. LotusScript oder Java. Die jeweiligen Möglichkeiten erfährt man über die Dropdown-Liste »Starten« im oberen Teil des Fensters. Teilweise erkennt man die Programmiermöglichkeiten auch über den vorher erwähnten Mittelteil, die Objektstruktur. Hier wird durch die Verwendung verschiedener Symbole angezeigt, welches Sprachmittel verwendet werden kann. Für LotusScript und Java wird eine Schriftrolle angezeigt, für JavaScript eine Kugel, für die Formelsprache eine Raute und für Notes-Systembefehle (Einfache Aktionen) ein Quadrat oder Würfel. Wenn für ein zu programmierendes Element mehrere Programmiermöglichkeiten bestehen, so wird nach dem Speichern und Wiederöffnen das Symbol angezeigt, das der ausgewählten Programmiersprache entspricht.

Programmierbereich

45

Der Editor ist in der Lage, die Syntax schon während der Eingabe zu überprüfen. Erkannte syntaktische Elemente werden mit verschiedenen Farben dargestellt. Dabei sind Schlüsselworte im Allgemeinen blau, Kommentare grün, Konstanten rosa und als fehlerhaft erkannte Teile rot. Es ist auch möglich, die Farbgebung dem eigenen Geschmack anzupassen. Dazu klicken Sie mit der rechten Maustaste in das Programmierfenster. Es öffnet sich die zugehörige Eigenschaftenbox, wie in Abbildung 2.4 gezeigt.

Abbildung 2.4: Eigenschaftenbox zur Anpassung des IDE-Editors

Wie Sie rechts in der Box sehen, können Sie die Farbe für die einzelnen syntaktischen Komponenten auswählen. Auch der verwendete Schrifttyp kann bestimmt werden. Die Einstellungen können ebenfalls für die Formelsprache und für Einfache Aktionen vorgenommen werden. Wenn Sie den zweiten Reiter wählen, können Sie noch zwei Einstellungen zur Formatierung vornehmen.

Abbildung 2.5: Zweiter Reiter der Eigenschaftenbox des IDE-Editors zur Einstellung der Formatierung von Programmcode

Es klang bei der Besprechung der Eigenschaftenbox schon durch: Seit Notes/ Domino R5 wird auch die Struktur von Formelprogrammen analog dem Erscheinungsbild von LotusScript farblich gekennzeichnet. Dies gehört zwar nicht zum Thema dieses Buches, mag aber doch für den einen oder anderen interessant sein.

46

Entwicklungsumgebung (IDE)

2.6.2 Zeilenumbrüche Zeilenumbrüche werden durch einen Unterstrich (_) erzeugt. Diese dürfen nicht innerhalb von Schlüsselworten oder von Strings und anderen Werten angeordnet werden. Ein Unterstrich zum Erzeugen eines solchen Umbruchs muss immer am Ende der vorhergehenden Zeile stehen und durch mindestens ein Leerzeichen von dem letzten Zeichen der Zeile getrennt sein. Es können mehrere Zeilenumbrüche hintereinander erfolgen. MessageBox _ "Dies ist ein extra langer Text, der deshalb in der Folgezeile steht."

2.6.3 Tabulator Im Gegensatz zu früheren Versionen können Sie unter der Version R5 auch die Tabulatortaste zum Erzeugen von Leerräumen verwenden.

2.6.4 Kommentare Kommentare können auf drei verschiedene Arten eingefügt werden: mit dem Hochkomma, der REM- und der %REM...%ENDREM-Anweisung. Mit den ersten beiden Möglichkeiten können nur einzeilige, mit der dritten auch mehrzeilige Kommentare geschrieben werden. 'Dies ist ein Kommentar (mit Hochkomma eingeleitet) REM Dies ist auch ein Kommentar, REM wobei dies die zweite Zeile ist, die ein neues REM benötigt %REM Dies ist auch ein Kommentar, wobei dies die zweite Zeile ist, die KEIN neues REM benötigt %ENDREM

2.6.5 Hintereinanderhängen von Befehlen Mehrere in eine Zeile geschriebene Befehle und Anweisungen werden durch Doppelpunkte (:) getrennt. Diese Technik ist aufgrund der Übersichtlichkeit nur in Ausnahmefällen zu empfehlen. If nZahl = 1 Then nZahl = 2 : Exit Sub

In diesem Fall werden, wenn die Bedingung nZahl = 1 erfüllt ist, zwei Anweisungen ausgeführt. Als erstes wird der Variablen »nZahl« ein neuer Wert zugewiesen (2) und anschließend wird die Prozedur, in der sich dieser Code befindet, mit »Exit Sub« verlassen.

Debugger

47

2.6.6 Kompilieren und Kompilierfehler Bei jedem Speichern wird Code, der neu eingegeben oder verändert wurde, automatisch kompiliert und auf Kompilierfehler untersucht. Treten solche auf, so werden sie in der unteren Zeile mit der Bezeichnung »Fehler« angezeigt. Wenn es sich um mehrere Fehler handelt, können Sie die Zeile als Kombo-Box öffnen und einen beliebigen Fehler per Mausklick auswählen. Der Cursor des ScriptEditors springt dann genau zu der Zeile, in der der Fehler aufgetreten ist. Wenn Sie an der betreffenden Zeile eine Änderung vornehmen, wird die dazugehörige Fehlermeldung aus der Kombo-Box entfernt. Beim nächsten Abspeichern des Codes wird dann wieder versucht, den veränderten Code zu kompilieren. Code, der nicht kompiliert werden kann, wird auch nicht abgespeichert.

2.7 Debugger Der Debugger in der Domino-IDE hat sich schon in den vergangenen Versionen durch einfache Handhabung und gute Übersicht ausgezeichnet. Mit ihm können komfortabel Laufzeitfehler erkannt und verfolgt werden. Er verfügt über die Möglichkeit, sofort aus dem geschriebenen Code heraus gestartet zu werden. Sie können schrittweise durch den Code gehen oder bestimmte Teile überspringen. Auch Haltepunkte sind möglich, und zwar sowohl solche, die nur für einen einzelnen Aufruf gelten, als auch solche, die fest im Code verankert werden. Während des Durchlaufs hat man zu jeder Zeit einen guten Überblick über sämtliche Variablen, die im jeweiligen Gültigkeitsbereich liegen, und deren Inhalt. Auch kann ihr Wert jederzeit während des Laufs durch Eingabe verändert werden. Was an diesem gelungenen Werkzeug hauptsächlich fehlt, sind bedingte Haltepunkte. Na ja, vielleicht kommt ja auch dieses Feature in nicht allzu ferner Zeit? (Allerdings lassen sich bedingte Haltepunkte durch »harte« Codierung im Programmtext einbinden. Wie dies funktioniert, zeigen wir Ihnen in Kapitel 2.7.2 »Haltepunkte«, Abschnitt »Programmierte Haltepunkte«.)

2.7.1 Start des Debuggers Im Unterschied zu vielen anderen Programmier-Umgebungen wird ein DebugDurchlauf des Programms genauso gestartet wie der normale Ablauf. Allerdings wird der Domino-Client zunächst in den »Debug-Modus« geschaltet: Datei | Extras | Debug LotusScript. Wird jetzt das Programm wie üblich gestartet (Klick auf den Button, der das Script enthält, oder auch Start des Agenten, Öffnen des Dokuments, dessen PostOpen-Event programmiert wurde usw.), dann wird es nach dem Aufruf automatisch in der ersten ausführbaren Zeile stehen bleiben. Der durchlaufene Code wird im oberen weißen Fenster angezeigt. Die nächste ausführbare Zeile ist durch einen kleinen Pfeil auf der linken Seite markiert. Mit vier Schaltflächen kann der Weiterlauf beeinflusst werden.

48

Entwicklungsumgebung (IDE)

Abbildung 2.6: Der Debugger in Aktion

Die Funktionen der Schaltflächen können auch über Menüeinträge aufgerufen werden:

Abbildung 2.7: Menüfunktionen zum Steuern des Debuggers

Debugger

49

F o rt f a h r e n Die Schaltfläche Fortfahren lässt das Script ohne weiteren Halt bis zum nächsten Haltepunkt oder, wenn keiner mehr vorhanden ist, zu Ende laufen. S ch r itt a us f ü h r e n Die Schaltfläche Schritt ausführen reagiert genauso, wie Sie es aufgrund der Bezeichnung erwarten würden: sie führt den nächsten ausführbaren Schritt aus. Wenn zwischen der vorher eingenommenen Cursorposition und der nächsten ausführbaren Zeile nicht ausführbare Zeilen liegen, werden diese übersprungen. Mit Schritt ausführen können Sie auch in aufgerufene Funktionen hineinspringen. S ch r itt ü b e rs p r in g e n Die Schaltfläche Schritt überspringen arbeitet ähnlich wie Schritt ausführen, aber sie springt nicht in Funktionsaufrufe hinein. Dies ist nützlich, um den Code schneller zu durchlaufen und entweder bereits getestete Funktionen zu übergehen oder die Stelle, an der ein Fehler auftritt, schneller zu finden. S ch r itt b ee een nden Wird die Schaltfläche Schritt beenden gewählt, so wird die gerade durchlaufene Funktion oder Prozedur ohne Halt berechnet und zur nächsthöheren Ebene zurückgesprungen. Dort bleibt der Debugger wieder stehen. Wenn es keine höhere Ebene mehr gibt, dann wird auf diese Weise das Programm zu Ende ausgeführt, als wäre der Button Fortfahren angeklickt worden. D e b ug ge r S t o p pe n Mit dem Button Stop wird der Debuglauf abgebrochen. Vor dem endgültigen Abbruch wird zur Sicherheit noch einmal nachgefragt, ob Sie es wirklich ernst meinen.

2. 7.2 H al tep u nkte N ic h tp r o gr amm mmii e r t e H al t e p un kt e Sie können während des Debuglaufs auf jede Zeile mit ausführbarem Code wie folgt einen (nichtprogrammierten) Haltepunkt setzen: entweder die Zeile doppelt anklicken, oder den Cursor (blauer Balken) auf die Zeile setzen und F9 drücken oder im Menü den Punkt Debug | Breakpoint festlegen/löschen. Nichtprogrammierte Haltepunkte bleiben nur während eines Debuglaufs gültig. Sie müssen bei jedem neuen Lauf neu gesetzt werden. Während eines Durchlaufs können Sie zu einzelnen Haltepunkten springen, indem Sie im unteren weißen Fenster den Reiter Breakpoints auswählen und in der Liste der Haltepunkte den gewünschten Punkt anklicken.

50

Entwicklungsumgebung (IDE)

In diesem Abschnitt besprechen wir nur solche nichtprogrammierten Haltepunkte. Programmierte Haltepunkte werden im folgenden Abschnitt abgehandelt. Haltepunkte können aktiviert und deaktiviert werden. Dies geschieht z. B. über das Menü Debug | Breakpoint aktivieren bzw. Debug | Breakpoint deaktivieren. Eine andere Möglichkeit, Haltepunkte zu aktivieren oder zu deaktivieren, ist der Doppelklick auf die Zeile, die den Haltepunkt enthält. Bei mehreren hintereinander ausgeführten Doppelklicks durchwandert eine Zeile bezüglich ihres Haltepunkts drei Zustände in folgender Reihenfolge: aktiviert, deaktiviert, nicht gesetzt (bzw. gelöscht) und (bei weiterem Klicken) wieder von vorne. Auch deaktivierte Haltepunkte werden angesprungen, wenn man sie in dieser Liste auswählt. Wahlweise können über das Menü auch sämtliche Haltepunkte auf einmal aktiviert oder deaktiviert werden. Zum Löschen eines Haltepunktes wählen Sie entweder den Menüpunkt Debug | Breakpoint löschen, oder Sie führen wie oben besprochen auf der betreffenden Zeile ein oder zwei Doppelklicks aus, bis er verschwunden ist. P r og r amm mmii e rt e H al t e pu n kt e Programmierte Haltepunkte werden durch die einfache Script-Anweisung Stop definiert. Sie können damit unbedingte Haltepunkte setzen, indem Sie sie in die entsprechende Zeile schreiben. Entgegen unserer früheren Behauptung können mit Hilfe der Stop-Anweisung in LotusScript auch bedingte Haltepunkte gesetzt werden, allerdings müssen sie bei der Programmierung hart codiert werden. Dazu kombinieren Sie die Stop-Anweisung mit Bedingungsausdrücken. Ein Haltepunkt, der nur dann zum Stoppen führen soll, wenn eine Variable mit Name IsOpen den Wert FALSE aufweist, sieht beispielsweise so aus: If Not IsOpen Then Stop

Die programmierten Haltepunkte führen wie die nicht programmierten nur im Debug-Modus zum Anhalten des Programmlaufs. Im normalen Ablauf sind sie ohne Wirkung.

2. 7.3 A ufr ufe v er fo lg e n In der Mitte zwischen den beiden weißen Bereichen befindet sich eine DropdownListe (»Aufrufe«), die Auskunft über die Position in der Aufrufschachtelung gibt. Der oberste Eintrag gibt den letzten Aufruf, also die momentan tiefste Schachtelungsebene, wieder. Sie können die Ansicht einer bestimmten Aufrufebene anzeigen lassen, indem Sie aus der Dropdownliste einen Eintrag auswählen.

Debugger

51

2.7.4 Weitere Navigationsmöglichkeiten Während eines Debuglaufs möchten Sie manchmal schnell an eine spezielle Stelle im Code gelangen. Dies kann beispielsweise bei der Schachtelung mehrerer Bibliotheken recht schwierig werden. Um ein bestimmtes Modul bzw. Objekt anzusteuern, wählen Sie dieses in der linken Dropdown-Liste oben im Debuggerfenster aus (»Objekt«). Das im Codebereich angezeigte Script wechselt dann auf diesen ausgewählten Eintrag. Innerhalb von Modulen können Sie verschiedene Abschnitte oder Funktionen auswählen, indem Sie die Dropdown-Liste (Ereignis) rechts oben nutzen. Dann wird genau in diesen Abschnitt gesprungen. Diese Navigation dient nur der Information oder dem Setzen und Manipulieren von Haltepunkten. Sie beeinflusst nicht den Ablauf des Debuggings.

2.7.5 Variablenwerte verfolgen und manipulieren V a r i a b le n w e r t e a n se h e n Unterhalb der Aufruf-Liste befindet sich der zweite größere weiße Bereich. Er hat drei Reiter. Der linke Reiter steht wie bereits besprochen für eine Liste der gesetzten Haltepunkte. In diesem Abschnitt ist der mittlere Reiter unser Thema. Er listet die im jeweiligen Gültigkeitsbereich zu »sehenden« Variablen und Konstanten auf. Die Liste ist sehr übersichtlich. In der linken Spalte sehen Sie die Namen der Variablen. Wenn vor einem Namen ein kleines grünes Dreieck erscheint, dann besteht die Variable aus mehreren Elementen. Dies trifft zu bei zusammengesetzten Typen und Objektvariablen, die instanziierte Objekte referenzieren. In der mittleren Spalte werden die Werte angezeigt. Bei zusammengesetzten Typen und Objektvariablen, die instanziierte Objekte referenzieren, wird für jedes Element der entsprechende Wert angezeigt. In Höhe des Namens für die Typ- oder Objektvariable werden zudem in einer eckigen Klammer die Werte der einzelnen Elemente aufgezählt (durch Kommas getrennt). M a n i p u l a t io n d e r V a r ia b l e n w e r te Sie können die Werte der im Debugger angezeigten Variablen für die Dauer des verbleibenden Programmlaufs verändern. Dies kann sehr praktisch sein, beispielsweise um festzustellen, wie sich der weitere Ablauf gestaltet, wenn eine Variable einen bestimmten Wert aufweist. Dies interessiert insbesondere dann, wenn eine Variable an einer bestimmten Stelle einen unerwarteten Wert aufweist, Sie aber vor einer Korrektur des Programms zunächst einmal feststellen wollen, wie sich der weitere Ablauf gestalten würde, wenn der Wert derjenige wäre, den Sie erwartet haben. Um den Wert einer Variablen oder deren Elemente zu verändern, klicken Sie den Namen an. Dann erscheint der Wert in der unten befindlichen Zeile »Neuer Wert«. Sie können jetzt durch Anklicken den Cursor dort hinsetzen und den Wert verändern. Damit er in den Programmlauf übernommen wird, wählen Sie das rechts

52

Entwicklungsumgebung (IDE)

befindliche grüne Häkchen. Zum Rückgängigmachen wählen Sie das rote Kreuzchen. Anschließend können Sie den Debuglauf fortsetzen.

Abbildung 2.8: Sicht auf die Variablen und deren Inhalte

Wenn die Variable einen Text mit Zeilenumbrüchen enthält, dann können Sie in der Zeile »Neuer Wert« zwischen den einzelnen Zeilen navigieren. Noch ein Hinweis: Werte können nur in skalaren Variablen bzw. bei zusammengesetzten Variablen in deren skalaren Elementen bearbeitet werden.

2.8 Probleme So genial der Debugger auch aufgebaut ist, so hat er doch eine recht gravierende Schwachstelle, die einen Programmierer manchmal ziemlich verzweifeln lassen kann: Es kommt im Debug-Modus wesentlich häufiger zu einem harten Absturz als im normalen Ablauf. Bei diesem Absturz wird ein rotes Fenster geöffnet, das im Allgemeinen darauf hinweist, dass ein Objekthandle ungültig ist. Dies ist eine Fehlermeldung, mit der Sie normalerweise nicht viel anfangen werden, außer dass Sie sich darüber ärgern.

Fragen

53

Es lohnt sich in einem solchen Fall, einmal zu testen, ob das Programm ohne den Debug-Modus lauffähig ist. Manchmal hilft es, den fehlerproduzierenden Script-Code per Copy-and-Paste in ein anderes neues Gestaltungselement umzustellen. Den Autoren begegnete einmal eine Teilmaske, die bei einer API-Programmierung ähnliche Abstürze verursachte. Durch Neuerstellen der Maske konnte das Problem behoben werden. Die wesentliche Erkenntnis ist, dass das rote Fenster auf irgendwelche internen Inkonsistenzen hinweist, die mit normalen Methoden kaum zu finden sind. Hier hilft nur, mit solchen unkonventionellen Mitteln wie den beschriebenen auf halbwegs systematische Art die Fehlerquelle einzukreisen und zu eliminieren. Selbst wenn eine solche Fehlersuche manchmal ergebnislos zu sein scheint: Es gibt mit entsprechender Ausdauer immer eine Lösung. Also nicht verzagen und weitermachen. Manchmal hilft auch ein Blick in Foren, die sich mit Lotus-Programmierung befassen, z. B. die Foren von Iris unter www.notes.net (das Iris-Team ist das eigentliche Entwicklerteam von Notes).

2.9 Fragen 1. Wie ist die IDE des Domino-Designers aufgebaut? 2. Wie wird der Debugger gestartet? 3. Wie können Sie einen unbedingten Haltepunkt setzen? 4. Wie setzt man bedingte Haltepunkte? 5. Wie können Sie zu einem bestimmten Haltepunkt springen? 6. Wo werden Variablenwerte verfolgt? 7. Können Sie den Inhalt von Variablen während eines Debuglaufs beeinflussen? 8. Wie können Sie den Code einer bestimmten Aufrufebene einsehen? 9. Wie können Sie den Code einer bestimmten Funktion anzeigen? 10. Welchen Vorteil hat der Stop-Befehl gegenüber anderen Arten von Haltepunkten? 11. Welchen Nachteil hat der Stop-Befehl?

3 3

Grundlegende Datentypen

3.1 Verständnisvoraussetzungen Das Lesen dieses Kapitels erfordert keine besonderen Voraussetzungen.

3.2 Lernziel Das Kapitel macht den Leser mit den grundlegenden Datentypen in LotusScript vertraut. Außerdem wird das allgemeine Vorgehen bei der impliziten und expliziten Deklaration von Variablen erläutert. Der Datentyp String wird im Detail in Kapitel 4 »Der Datentyp String« besprochen.

3.3 Allgemeines zur impliziten und expliziten Deklaration von Variablen Variablen sollten im Normalfall vor ihrer Verwendung deklariert werden. Dies geschieht in LotusScript über die Verwendung der Anweisung Dim. Dabei wird über die Klausel »As Datentyp« oder über ein Suffix (z. B. $, % usw.) der Datentyp der Variablen festgelegt: Dim Text As String Dim Text$ Dim Text

Wie Sie sehen, kann man auf die Angabe des Datentyps auch ganz verzichten. Dann wird bei der Deklaration defaultmäßig der Datentyp Variant angenommen, es sei denn, Sie haben über eine Def...-Anweisung (z. B. DefStr, DefInt usw.) einen anderen Datentyp voreingestellt: DefStr T Dim Text

Hier wurde die Variable Text als Datentyp String angelegt, im oberen Beispiel dagegen als Datentyp Variant. Man kann die Deklaration auch implizit durchführen, d. h. ohne ausdrückliche Anweisung. Dies geschieht, indem eine Variable einfach verwendet wird, z. B.

56

Grundlegende Datentypen

durch eine Wertzuweisung. Für die Angabe des Datentyps gilt dasselbe wie bei der expliziten Deklaration: Zahl = 1234 Zahl% = 1234 DefInt Z Zahl = 1234

Die erste implizite Deklaration legt eine Variable vom Typ Variant an, die zweite und die dritte eine vom Typ Integer. Allerdings zeugt es von besserem Programmierstil, wenn Sie Variablen immer explizit deklarieren. Dies hilft Ihnen vor allem, manchen Laufzeitfehler schneller zu finden. Ansonsten kann es beispielsweise passieren, dass Sie eine Variable verwenden, der nie ein Wert zugewiesen wird. Oder es werden im Falle einer Umbenennung verschiedene Vorkommen einer Variablen vergessen, die dann »in der Luft hängen«. Am besten Sie erzwingen die explizite Deklaration durch Angabe von »Option Declare« im Modulabschnitt »(Options)«.

3.4 Numerische Datentypen 3.4.1 Der Datentyp Integer Der Datentyp Integer wird verwendet, um ganzzahlige Werte von –32.768 bis 32.767 aufzunehmen. Dazu belegt er 2 Byte im Speicher. Eine Deklaration kann mit der Dim ... As Integer-Anweisung oder durch das Suffix % erfolgen. Außerdem kann über die Anweisung DefInt Integer als Defaulttyp für Variablen-Deklarationen festgelegt werden. Dim Wert1 As Integer Diese Anweisung deklariert die Variable Wert1 als Integer-Variable. Wert2% = 123

Hier wird die Variable durch das Typensuffix % als Integervariable deklariert. Defint W-Z Wert3 = 100

Die Variable Wert3 hat hier den Datentyp Integer, weil die Anweisung Defint den Datentyp Integer für alle Variablen mit den Anfangsbuchstaben W bis Z festlegt. Mit Integerwerten können alle mathematischen Operationen ausgeführt werden. Bei einer Wertzuweisung einer Zahl mit Nachkommastellen wird die Zahl entsprechend gerundet.

Numerische Datentypen

57

Dim Wert As Integer Wert = 2.5 MessageBox Wert

Ausgegeben wird der Wert 2. F e h le r q u e ll e n Es gibt zwei häufige Fehlermeldungen bei der Verwendung von Integervariablen: Overflow- sowie Type Mismatch-Fehler. Der Overflow-Fehler Beim Speichern des Programms meldet der Compiler den

Fehler Overflow, wenn versucht wird, einer Integer-Variable einen Wert zuzuweisen, welcher nicht in ihrem Wertebereich liegt. Das heißt ein Wert kleiner als – 32.768 oder größer als 32.767. Dieser Fehler kann auch zur Laufzeit auftreten, wenn eine solche unzulässige Zuweisung versucht wird. Wert% = 40000

Diese Wertzuweisung erzeugt einen Overflow-Fehler. Der Type Mismatch-Fehler Dieser Fehler deutet auf den Versuch hin, einer Integer-

variablen einen Wert mit einem fremden Datentyp wie z. B. einer Zeichenkette zuzuweisen. Auch dieser Fehler kann während der Kompilierung und während der Laufzeit auftreten. Wert% = "Hallo" Diese Wertzuweisung erzeugt einen Type Mismatch-Fehler.

3. 4.2 D e r D ate nty p L o ng Long ist ein weiterer ganzzahliger Datentyp. Long belegt 4 Byte und kann dadurch ganzzahlige Werte von –2.147.483.648 bis 2.147.483.647 beinhalten. Sein Suffix bei der impliziten Deklaration ist das &-Zeichen. Dim Wert As Long

Diese Anweisung deklariert die Variable Wert1 als Variable vom Typ Long. Wert2& = 100 Die Variable Wert2 wird durch das Suffixzeichen als Longvariable deklariert. DefLng W-Z Wert3 = 100

Die Variable Wert3 hat hier den Datentyp Long, weil die Anweisung DefLng den Datentyp Long für alle Variablen mit den Anfangsbuchstaben W bis Z festlegt. Auch bei dem Datentyp Long werden Werte mit Nachkommastellen bei einer Zuweisung gerundet.

58

Grundlegende Datentypen

F e h le r q u e ll e n Die Fehlerquellen sind die gleichen wie beim Datentyp Integer: Overflow- sowie Type Mismatch-Fehler. Der Overflow-Fehler Wird das Programm gespeichert, meldet der Compiler den

Fehler Overflow, wenn versucht wird, einer Long-Variablen einen Wert außerhalb des Long-Wertebereichs zuzuweisen. Dieser liegt zwischen -2.147.483.647 und 2.147.483.648. Dieser Fehler kann auch während des Programmlaufs auftreten, wenn eine unzulässige Zuweisung versucht wird. Wert& = -3000000000000

Diese Wertzuweisung erzeugt einen Overflow-Fehler. Der Type Mismatch-Fehler Dieser Fehler tritt auf, wenn versucht wird, einer Long-

Variablen einen fremden Datentyp wie beispielsweise eine Zeichenkette zuzuweisen. Auch dieser Fehler kann während der Kompilierung und während der Laufzeit auftauchen. Wert& = "Hallo"

Diese Wertzuweisung erzeugt einen Type Mismatch-Fehler.

3. 4.3 D e r D ate nty p S ing l e Single ist der kleinste nicht ganzzahlige Datentyp in LotusScript. Single belegt 4 Byte im Speicher. Der Wertebereich Single liegt zwischen –3,402823E+38 und 3,402823E+38. Für die implizite Deklaration mit einem Suffixzeichen wird bei dem Datentyp Single das !-Symbol verwendet. Dim Wert1 As Single Deklariert die Variable Wert1 als Single-Datentyp. Wert2! = 100 Deklariert die Variable Wert2 als Single-Datentyp und weist ihr den Wert 100 zu. DefSng W Legt für alle Variablen mit dem Anfangsbuchstaben W den Standarddatentyp Single fest.

F e h le r q u e ll e n Overflow und Type Mismatch. Der Overflow-Fehler Bei der Speicherung des Programms meldet der Compiler

einen Overflow, wenn versucht wird, einer Single-Variablen Werte außerhalb des Single-Wertebereichs zuzuweisen. Dieser liegt zwischen -3.402823E+38 und 3,402823E+38. Dieser Fehler kann auch während des Programmlaufs auftreten, wenn eine unzulässige Zuweisung versucht wird. Wert! = -3000000000000^40

Diese Wertzuweisung erzeugt einen Overflow-Fehler.

Numerische Datentypen

59

Der Type Mismatch-Fehler Dieser Fehler tritt auf, wenn versucht wird, einer Sin-

gle-Variablen einen fremden Datentyp wie beispielsweise eine Zeichenkette zuzuweisen. Dieser Fehler kann während der Kompilierung und während der Laufzeit auftauchen. Wert! = "Hallo"

Diese Wertzuweisung erzeugt einen Type Mismatch-Fehler.

3.4.4 Der Datentyp Double Der Datentyp Double ist der größte nicht ganzzahlige Datentyp in LotusScript. Er belegt 8 Byte im Speicher. Der Wertebereich umfasst –1,77975931348623158E+308 bis 1,77975931348623158E+308. Sein Suffixzeichen ist das #-Symbol. Dim Wert1 As Double

Diese Anweisung deklariert die Variable Wert1 als Double-Variable. Wert2! = 100

Auch die Variable Wert2 wird durch das Suffixzeichen als Double-Variable deklariert. DefDbl W-Z Wert3 = 100

Die Variable Wert3 hat hier den Datentyp Double, weil die Anweisung DefDbl diesen Datentyp für alle Variablen mit den Anfangsbuchstaben W bis Z festlegt. F e h le r q u e ll e n Auch hier treten häufig die Fehlermeldungen Overflow sowie Type Mismatch auf. Der Overflow-Fehler Bei der Speicherung des Programms meldet der Compiler

den Fehler Overflow, wenn versucht wird, einer Double-Variablen einen Wert außerhalb des Double-Wertebereichs zuzuweisen. Dieser liegt zwischen -1,77975931348623158E+308 und 1,77975931348623158E+308. Der OverflowFehler kann auch während des Programmlaufs auftreten, wenn eine unzulässige Zuweisung versucht wird. Da der Datentyp Double den größten Wertebereich hat und somit die größten und kleinsten Zahlen speichern kann, muss sich der Entwickler bei Auftreten dieser Meldung vermutlich einige Gedanken über seine Variablenstruktur machen. Die Frage lautet dann: Wie kann man die gewünschten großen Zahlen anders darstellen? Wert# = -3000000000000^308

Diese Wertzuweisung erzeugt einen Overflow-Fehler.

60

Grundlegende Datentypen

Der Type Mismatch-Fehler Dieser Fehler tritt auf, wenn versucht wird, einer

Double-Variablen einen fremden Datentyp wie beispielsweise eine Zeichenkette zuzuweisen. Dieser Fehler kann wieder während der Kompilierung oder auch zur Laufzeit auftreten. Beispiel: Wert# = "Hallo"

Diese Wertzuweisung erzeugt einen Type Mismatch-Fehler.

3.4.5 Der Datentyp Currency Der Datentyp Currency hat einen speziellen Wertebereich: er umfasst die Zahlen von -922.337.203.685.477,5807 bis 922.337.203.685.477,5807, und zwar jeweils alle Zahlen mit 4 Nachkommastellen. Sein Suffix ist das Zeichen @. Eine Variable dieses Datentyps belegt 8 Byte. Dim Wert1 As Currency

Diese Anweisung deklariert die Variable Wert1 als Currency-Variable. Wert2@ = 100

Auch die Variable Wert2 wird durch das Suffixzeichen als Currency-Variable deklariert. DefCur W-Z Wert3 = 100

Die Variable Wert3 hat hier den Datentyp Currency, weil die Anweisung DefCur den Datentyp Currency für alle Variablen mit den Anfangsbuchstaben W bis Z festlegt. F e h le r q u e ll e n Die zwei häufigsten Fehlermeldungen bei der Verwendung lauten: Overflow- oder auch Type Mismatch-Fehler. Der Overflow-Fehler Bei der Speicherung des Programms meldet der Compiler

einen Overflow, wenn versucht wird, einer Currency-Variablen einen Wert außerhalb des Currency-Wertebereichs zuzuweisen. Das heißt, einen Wert kleiner als -922.337.203.685.477,5807 oder größer als 922.337.203.685.477,5807. Dieser Fehler kann auch während des Programmlaufs auftreten, wenn eine unzulässige Zuweisung versucht wird. Wert@ = -3000000000000000000000000

Diese Wertzuweisung erzeugt einen Overflow-Fehler.

Der Datentyp Variant

61

Der Type Mismatch-Fehler Dieser Fehler tritt auf, wenn versucht wird, einer Cur-

rency-Variablen einen fremden Datentyp wie beispielsweise eine Zeichenkette zuzuweisen. Er kann während der Kompilierung und während der Laufzeit auftauchen. Wert@ = "Hallo"

Diese Wertzuweisung erzeugt einen Type Mismatch-Fehler.

3.4.6 Numerischer Typenwandel Jeder numerische Datentyp kann jedem anderen numerischen Datentyp zugewiesen werden. Wenn ein Wert mit Nachkommastellen einer Variable mit einem Datentyp ohne Nachkommastellen zugewiesen wird, werden die Nachkommastellen vorher gerundet. Wert% = 10.5 Messagebox Wert%

'Liefert 10

3.4.7 Zusammenfassung numerischer Datentypen Datentyp Integer Long Single Double Currency

Speichergröße 2 Byte 4 Byte 4 Byte 8 Byte 8 Byte

Nachkomma Nein Nein Ja Ja Ja

Min -32.768 2.147,483.648 3,402823E+38 -1,7976931348623158+308 -922.337.203.685.477,5807

Max 32.767 2.147,483.647 3,402823E+38 1,7976931348623158+308 922.337.203.685.477,5807

3.5 Der Datentyp Variant Der Datentyp Variant belegt 16 Byte im Speicher und kann jeden anderen Datentyp außer benutzerdefinierten Typen aufnehmen. Trotz der erwähnten Einschränkung kann einem Variant jedes Objekt, also auch jedes benutzerdefinierte Objekt, zugewiesen werden. Jede Variable, die ohne eine Typangabe deklariert wird, hat den Datentyp Variant. (Ausnahme: Variablen, die aufgrund einer DefType-Anweisung einen anderen Default-Typ haben.) Bei der Initialisierung wird die Variable mit dem Wert EMPTY versehen. Dim WertA As Variant Dim WertB

Beide Variablen werden als Variant-Variablen deklariert und mit dem Wert EMPTY initialisiert. Der Wert einer Variant-Variablen wird im Speicher auf 8 Byte ausgerichtet.

62

Grundlegende Datentypen

Z u we i s u n g vo n W e r t e n a us V a r i a n t va r ia b l e n a n a n d e re D a t e n t y p e n Variant-Variablen können zwar im Rahmen ihrer Möglichkeiten alle Werte aus anderen Variablen aufnehmen, aber anders herum ist eine Zuweisung nicht immer möglich. Dies hängt davon ab, ob die Zielvariable einen Datentyp aufweist, der zu dem zu übergebenden Wert »passt«. Dim WertA As Integer Dim WertB As String Dim WertC As Variant WertA = 100 WertB = "Hallo" WertC = WertA MsgBox WertC WertC = WertB MsgBox WertC

Die Variable WertA wird als Integer deklariert und mit dem Wert 100 belegt. Variable WertB ist vom Typ STRING und bekommt die Zeichenkette »Hallo« zugewiesen. Nach der ersten Zuweisung an die Variable WertC wird die Zahl 100 ausgegeben. Die zweite Ausgabe nach der zweiten Zuweisung gibt die Zeichenkette »Hallo« aus. Außerdem kann eine Variant-Variable den Wert NULL oder EMPTY annehmen. Der Wert EMPTY wird bei numerischen Operationen zu 0 gewandelt. Bei Stringoperationen wird der Wert zu einem Leerstring ("") gewandelt.

X

X

Um den Datentyp des aktuell gespeicherten Wertes in einer Variant-Variablen zu ermitteln, können die beiden Funktionen DataType und TypeName eingesetzt werden. Die Funktion DataType liefert einen numerischen Wert zurück. Syntax der DataType-Funktion: DataType ( expression ) TypeName gibt eine Zeichenkette mit dem Datentyp des Ausdrucks zurück. Syntax der TypeName-Funktion: TypeName ( expression ) Dim Kette As String Dim Zahl As Integer Dim Element As Variant Kette = Element 'Kette beinhaltet danach eine leere 'Zeichenkette Zahl = Element 'Die Variable Zahl beinhaltet nach der 'Zuweisung den Wert 0 Element = Kette MessageBox DataType(Element) 'Liefert eine 8 zurück Element = Zahl MessageBox TypeName(Element) 'Liefert den Wert "INTEGER" zurück

Fragen

63

3.6 Fragen 1. Was verstehen Sie unter einer impliziten und unter einer expliziten Deklaration von Variablen? 2. Wie werden unter LotusScript implizite und explizite Deklarationen von Variablen durchgeführt? 3. Welche Deklarations-Art sollte im Sinne von Programmlesbarkeit und Fehlervermeidung verwendet werden? Wie können Sie diese Art erzwingen? 4. Wie wird bei der Deklaration der Datentyp einer Variablen angegeben? 5. Wann wird der Datentyp gemäß der Voreinstellung verwendet? 6. Wie kann der Datentyp durch Voreinstellung festgelegt werden? 7. Welche numerischen Datentypen unter LotusScript kennen Sie? 8. Was ist ein Variant? 9. Welche Fehler treten häufig beim Gebrauch von Variablen auf?

4 4

Der Datentyp String

4.1 Verständnisvoraussetzungen In diesem Kapitel werden die allgemeinen Kenntnisse zur Variablen-Deklaration in LotusScript vorausgesetzt, wie sie in Kapitel 3.3 »Allgemeines zur impliziten und expliziten Deklaration von Variablen« erläutert wurden.

4.2 Lernziel Das Kapitel zeigt den Umgang mit Zeichenketten unter LotusScript auf.

4.3 Vorbemerkung Für das Verarbeiten von Zeichenketten wird in LotusScript der Datentyp String benutzt. Intern wird in LotusScript der Zeichencode im so genannten UNICODEFormat gespeichert. Dies bedeutet, dass für jedes Zeichen der Zeichenkette jeweils 2 Byte Speicherplatz belegt werden. Bei der Verwendung der Systemoption wird die Zeichenkette in das plattformabhängige Systemformat umgewandelt. Die Zeichenkette belegt pro Zeichen 2 Byte Speicherplatz.

4.4 Implizite und explizite Deklaration Die explizite Deklaration einer Variable als String erfolgt mit der Dim-Anweisung durch Angabe des Datentyps String oder durch das Suffix $. Sie können das Suffix $ auch ohne die Dim-Anweisung zur Festlegung des Datentyps bei einer impliziten Variablen-Deklaration verwenden. Die implizite Deklaration können Sie mit der DefStr-Anweisung für eine Gruppe von Variablen auf den Datentyp String voreinstellen. Die explizite Deklaration einer Variable vom Datentyp String erfolgt entweder mit Dim ... As String oder mit Dim in Verbindung mit dem Suffix $. Die implizite Deklaration kann durch DefStr auf den Typ String voreingestellt werden und erfolgt ansonsten durch Verwendung des Suffix $(ohne Dim). Weitere Einzelheiten zur impliziten und expliziten Variablen-Deklaration siehe Kapitel 3.3, »Allgemeines zur impliziten und expliziten Deklaration von Variablen«.

66

Der Datentyp String

4.5 Dynamische und statische Zeichenkette LotusScript kennt zwei Arten von Zeichenketten. Die statische Zeichenkette hat eine feste Anzahl von Zeichen. Die dynamische Zeichenkette besteht aus einer variablen Anzahl von Zeichen. Dynamische Zeichenketten können eine variable Anzahl von Zeichen aufnehmen, statische Zeichenketten dagegen bestehen aus einer festen Anzahl von Zeichen. Die Art der Zeichenkette wird durch ihre Deklaration bestimmt. Implizit deklarierte Variablen vom Datentyp String sind immer dynamische Zeichenketten. Statische Zeichenketten werden bei der expliziten Deklaration mit Dim durch die Angabe der Länge festgelegt. Implizit deklarierte Zeichenketten sind immer dynamische Zeichenketten.

Syntax Dim: { Dim | Static | Public | Private } variableName As String [ * length ] Dim ZeichenketteA As String Dim ZeichenketteB As String * 10 ZeichenketteC$ = "Hallo"

'dynamische Zeichenkette 'statische Zeichenkette 'dynamische Zeichenkette

Defstr Z ZeichenketteD = "Hallo"

'dynamische Zeichenkette

4.6 Initialisierung von Zeichenketten Alle Variablen vom Datentyp String werden bei ihrer Deklaration automatisch initialisiert. Dabei wird einer dynamischen Zeichenkette der Wert Leerstring ("") zugewiesen. Eine statische Zeichenkette wird bei der Deklaration mit der der angegebenen Länge entsprechenden Anzahl von Leerzeichen aufgefüllt.

4.7 Verwendung von statischen Zeichenketten Statische Zeichenketten mit fester Länge werden häufig bei Übergabepunkten zu C-Routinen oder bei I/O-Operationen (Eingabe-/Ausgabeoperationen) verwendet.

Funktionen und Anweisungen für Zeichenketten

67

4.8 Funktionen und Anweisungen für Zeichenketten 4.8.1

Die Funktionen Len, LenB, LenBP und LenC

Die Funktion Len Mit der Funktion Len wird die Länge einer Zeichenkette ermittelt. Bei einer dynamischen Zeichenkette ist dies die Anzahl der Zeichen des aktuellen Wertes. Bei einer statischen Zeichenkette gibt Len die Länge zurück, die bei der Deklaration angegeben wurde. Syntax Len: Len ( text$ ) Dim Kette1 As String * 10 Dim Kette2 As String Kette1 = "Hallo" Kette2 = "Welt" Print Len(Kette1) Print Len(Kette2)

'Liefert 10 'Liefert 4

Die Funktion LenB Diese Funktion liefert die Größe des Speicherbereiches zurück, welchen die Zeichenkette einnimmt. Angabe in Bytes. Die Funktion LenBP Mit dieser Funktion erhält man die Größe des Speicherbereiches, welcher benötigt wird, um die Zeichenkette im plattformabhängigen Format zu speichern. Angabe in Bytes. Die Funktion LenC Die Funktion LenC wird bei spaltenorientierten Sprachen verwendet, wie z. B. Thailändisch. Sie gibt die Länge einer Zeichenspalte in Anzahl der Zeichen zurück.

4.8.2

Die Funktionen Left und Right

Die Funktion Left liefert den linken und die Funktion Right den rechten Teil eines Strings. Den Funktionen wird der Quellstring und die gewünschte Anzahl der Stellen übergeben. Bei der Rückgabe ist zwischen einem dynamischen und einem statischen Quellstring zu unterscheiden. Für die Auswertung eines statischen Strings ist zu beachten, dass er am Ende mit den Füllzeichen bis zur deklarierten Länge aufgefüllt ist. Sollte die Länge des übergebenen Quellstrings kleiner als die gewünschte Anzahl der Stellen sein, wird der gesamte Quellstring zurückgegeben. Die Funktionen LeftB, LeftBP und LeftC arbeiten analog. Die Unterschiede liegen in der Inter-

68

Der Datentyp String

pretation der Längenangaben. Sie werden analog zu den Spielarten der Len-Funktion in Unicode-Bytes, Bytes im plattformabhängigen Codesystem und Zeichenanzahl der Spalte gemessen. Syntax Left: Left[$] ( text$, length ) Syntax Right: Right[$] ( text$, length ) Dim Kette1 As String * 10 Dim Kette2 As String Kette1 = "Hello" Kette2 = "Welt" Msgbox Right$(Kette1, 6) Msgbox Right$(Kette2, 2) Msgbox Left$(Kette1, 6) Msgbox Left$(Kette2, 2)

4.8.3

'Liefert 'Liefert 'Liefert 'Liefert

'o' lt Hello We

Die Funktion Mid

Die Funktion Mid liefert einen Teilstring aus einer Zeichenkette zurück. Hierfür wird die Zeichenkette, die Startposition und die gewünschte Länge übergeben. Sollte der gewünschte Teilstring teilweise außerhalb der Ausgangszeichenkette liegen, werden wie bei Left und Right die Zeichen des Quellstrings zurückgegeben, die innerhalb des Bereichs liegen, der für den Teilstring angegeben wurde. Dies bedeutet einfacher ausgedrückt: Es wird einfach das zurückgegeben, was verfügbar ist und innerhalb des gewünschten Bereichs liegt. Auch bei dieser Funktion existieren Varianten bezüglich der Längenangaben in Form von MidB, MidBP, MidC. Nähere Angaben dazu finden Sie bei der Beschreibung der Len-Funktion in Abschnitt 4.8.1. Syntax Mid: Mid[$] ( text$, begin [, length ] ) Dim Kette1 As String * 10 Dim Kette2 As String Kette1 = "Hallo" Kette2 = "Welt" Msgbox Mid$(Kette1, 5, 2) Msgbox Mid$(Kette2, 3, 2)

'liefert "o " 'liefert "lt"

Funktionen und Anweisungen für Zeichenketten

4.8.4

69

Die Operationen RSet und LSet

Die Schlüsselworte RSet und LSet dienen bei Zuweisungen an statische Strings dazu, die Zeichenkette entweder links- oder rechtsbündig auszurichten. Syntax RSet und LSet: RSet variable = text$ LSet variable = text$ Dim Kette As String * 10 RSet Kette = "Hallo" Msgbox "-" + Kette + "-"

4.8.5

'liefert "-

Hallo-"

Die Funktionen LTrim, RTrim und Trim

Die Funktion LTrim entfernt führende Leerzeichen aus einem String. Am Ende abschließende Leerzeichen werden durch RTrim entfernt. Bei dem Aufruf von Trim werden sowohl führende als auch alle abschließenden Leerzeichen entfernt. Syntax LTrim, RTrim, Trim: LTrim ( text$ ) RTrim ( text$ ) Trim ( text$ ) Dim Kette As String Kette = " Hallo Msgbox LTrim(Kette) Msgbox RTrim(Kette) Msgbox Trim(Kette)

4.8.6

" 'liefert "Hallo " 'liefert " Hallo" 'liefert "Hallo"

Die Funktionen LCase und UCase

Die Funktion LCase wandelt alle Großbuchstaben einer Zeichenkette zu Kleinbuchstaben um. Umgekehrt wandelt die Funktion UCase alle Kleinbuchstaben in Großbuchstaben um. Syntax LCase und UCase: LCase[$] ( text$ ) RCase[$] ( text$ ) Print LCase("Hallo") Print UCase("Hallo")

'liefert hallo 'liefert HALLO

70

Der Datentyp String

4.8.7

Die Funktion Str

Die Funktion Str wandelt einen Ausdruck in eine Zeichenkette um. Syntax Str: Str[$] ( numericValue ) Print Str(100)

4.8.8

'liefert "100"

Die Funktionen StrCompare und StrComp

StrCompare und StrComp repräsentieren dieselbe Funktion. Sie vergleicht zwei Zeichenketten und liefert das Ergebnis als numerischen Wert zurück. Dabei ist es möglich, die Vergleichsmethode auszuwählen. Syntax StrCompare und StrComp: StrCompare ( text1$, text2$ [, comparisonMethod ] ) StrComp ( text1$, text2$ [, comparisonMethod ] ) Dabei sind folgende Vergleichsmethoden möglich: Wert

Groß-/Kleinschreibung

Pitch

0

relevant

relevant

1

nicht relevant

relevant

4

relevant

nicht relevant

5

nicht relevant

nicht relevant

Als Ergebnis können folgende Werte zurückgeliefert werden: Mindestens eine der übergebenen Zeichenketten ist NULL

NULL

Zeichenkette1 ist kleiner Zeichenkette2

-1

Zeichenkette1 ist gleich Zeichenkette2

0

Zeichenkette1 ist größer Zeichenkette2

1

Print Print Print Print

StrCompare("A", "b", 0) StrCompare("A", "a", 1) StrCompare("A", "A", 0) StrCompare(NULL, "A", 0)

'liefert 'liefert 'liefert 'liefert

–1 0 0 NULL

Funktionen und Anweisungen für Zeichenketten

4.8.9

71

Die Funktion StrConv

Diese Funktion wandelt eine Zeichenkette in verschiedene Zeichensätze um. Dabei werden der Quellstring und das bzw. die gewünschten Formate angegeben. Syntax StrConv: StrConv ( text$ , convertType ) Dabei gibt es folgende Konvertierungstypen: Wert

Typ der Konvertierung

1

Großbuchstaben

2

Kleinbuchstaben

3

Erster Buchstabe groß, Rest klein

4

Einzelbyte zu Zweibyte

8

Zweibyte zu Einzelbyte

16

Hiragana zu Katakana

32

Katakana zu Hiragana

Print StrConv("abc", 3)

'liefert "Abc"

4.8.10 StrLeft, StrLeftBack, StrRight und StrRightBack D i e F u n k t io n St r L e f t Die Funktion StrLeft sucht einen Teilstring in einem gegebenen Quellstring, beginnend von links. Wenn der Teilstring im Quellstring gefunden wird, werden alle Zeichen aus dem Quellstring ausgegeben, welche links von dem Teilstring stehen. Außerdem kann eine Anzahl bestimmt werden, welche beschreibt, wie häufig die Zeichenkette gefunden werden muss, damit eine Ausgabe erfolgt. Ein Flag bestimmt die Vergleichsmethode analog zur Funktion StrCompare (siehe dort). Syntax StrLeft: StrLeft ( text1$, text2$ [, flag% [, count ]] ) Print StrLeft("Eins Zwei Eins Drei", "Zwei") 'liefert "Eins " Print StrLeft("Eins Zwei Eins Drei", "Eins", 0, 2) 'liefert "Eins Zwei "

D i e F u n k t io n St r R ig h t Die Funktion StrRight sucht einen Teilstring in einem gegebenen Quellstring, beginnend von links. Wenn der Teilstring im Quellstring gefunden wird, werden alle Zeichen aus dem Quellstring ausgegeben, welche rechts von dem Teilstring stehen. Außerdem kann eine Anzahl bestimmt werden, welche beschreibt, wie häufig

72

Der Datentyp String

die Zeichenkette gefunden werden muss, damit eine Ausgabe erfolgt. Ein Flag bestimmt die Vergleichsmethode analog zur Funktion StrCompare (siehe dort). Syntax StrRight: StrRight ( text1$, text2$ [, flag% [, count ]] ) Print StrRight("Eins Zwei Eins Drei", "Zwei") 'liefert " Eins Drei" Print StrRight("Eins Zwei Eins Drei", "Eins", 0, 2) 'liefert " Drei"

D i e F u n k t io n St r L e f tB a c k Die Funktion StrLeftBack sucht einen Teilstring in einem gegebenen Quellstring, beginnend von rechts. Wenn der Teilstring im Quellstring gefunden wird, werden alle Zeichen aus dem Quellstring ausgegeben, welche links von dem Teilstring stehen. Außerdem kann eine Anzahl bestimmt werden, welche beschreibt, wie häufig die Zeichenkette gefunden werden muss, damit eine Ausgabe erfolgt. Der Flag bestimmt die Vergleichsmethode analog zur Funktion StrCompare (siehe dort). Syntax StrLeftBack: StrLeftBack ( text1$, text2$ [, flag% [, count ]] ) Print StrLeftBack("Eins Zwei Eins Drei", "Zwei") 'liefert "Eins " Print StrLeftBack("Eins Zwei Eins Drei", "Eins", 0, 2) 'liefert ""

D i e F u n k t io n St r R ig h t Ba c k Die Funktion StrRightBack sucht einen Teilstring in einem gegebenen Quellstring von rechts beginnend. Wenn der Teilstring im Quellstring gefunden wird, werden alle Zeichen aus dem Quellstring ausgegeben, welche rechts von dem Teilstring stehen. Außerdem kann eine Anzahl bestimmt werden, welche beschreibt, wie häufig die Zeichenkette gefunden werden muss, damit eine Ausgabe erfolgt. Das Flag bestimmt die Vergleichsmethode analog zur Funktion StrCompare (siehe dort). Syntax StrRightBack: StrRightBack ( text1$, text2$ [, flag% [, count ]] ) Print StrRightBack("Eins Zwei Eins Drei", "Zwei") 'liefert " Eins Drei" Print StrRightBack("Eins Zwei Eins Drei", "Eins", 0, 2) 'liefert " Zwei Eins Drei"

Funktionen und Anweisungen für Zeichenketten

73

4.8.11 Die Funktion String Der Funktion String wird ein Zeichencode oder String und eine Anzahl übergeben. Als Rückgabe erhält man einen Zielstring, welcher das als Zeichencode übergebene Zeichen oder das erste Zeichen des Quellstrings in der übergebenen Anzahl enthält. Syntax String String[$] ( length, { charCode | text$ } ) Print String(5, "A") Print String(5, 69)

'liefert "AAAAA" 'liefert "EEEEE"

4.8.12 Die Funktionen InStr, InstrB, InstrBP und InstrC Die Funktion InStr bzw. die Varianten für die entsprechenden Zeichensätze werden verwendet, um in einem Quellstring einen Teilstring zu suchen und dessen Position zurückzugeben. Es kann die Anfangsposition der Suche und die Vergleichsmethode bestimmt werden. Syntax InStr: InStr ( [ start, ] text1$, text2$, [ comparisonType ] ) Print InStr("Test Test", "es") Print InStr(4, "Test Test", "es")

'liefert 2 'liefert 7

4.8.13 Die Anweisung Option Compare Die Anweisung Option Compare dient dazu, die Standardvergleichsmethode bei Zeichenkettenvergleichen festzulegen. Option

Beschreibung

Option Compare Binary

Vergleich erfolgt auf binärer Ebene

Option Compare Case

Groß-/Kleinschreibung ist relevant

Option Compare NoCase

Groß-/Kleinschreibung ist nicht relevant

Option Compare Pitch

Die Größe ist relevant

Option Compare NoPitch

Die Größe ist nicht relevant

4.8.14 Die Funktion Space Die Funktion Space liefert einen String mit einer angegebenen Anzahl von Leerzeichen zurück. Syntax Space: Space[$] ( numberValue# ) Print "-"+Space(4)+"-"

'liefert "-

-"

74

Der Datentyp String

4.8.15 Die Funktion Val Die Funktion wandelt eine Zeichenkette in einen numerischen Wert um. Es wird versucht, den Inhalt der übergebenen Zeichenkette als Zahl zu interpretieren. Syntax Val: Val ( text$ ) Print Val("100")

'liefert 100

4.8.16 Die Funktion Asc Die Funktion liefert den plattformabhängigen numerischen Zeichencode für ein Zeichen zurück. Syntax Asc: Asc ( text$ ) Print Asc("E")

'liefert 69

4.8.17 Die Funktion Chr Die Funktion Chr liefert das Zeichen zurück, welches einem plattformabhängigen numerischen Zeichencode entspricht. Syntax Chr: Chr[$] ( numberValue& ) Print Chr(69)

'liefert E

4.8.18 Die Funktion UChr Die Funktion UChr liefert das Zeichen, welches dem numerischen UNICODE-Zeichencode entspricht. Syntax UChr: UChr[$] ( numberValue& ) Print UChr(69)

'liefert E

Operatoren für das Handling von Zeichenketten

75

4.8.19 Die Funktion Uni Liefert den numerischen UNICODE-Code für das erste Zeichen im übergebenen String zurück. Syntax Uni: Uni ( text$ ) Print

Uni("Hallo")

'liefert 72

4.8.20 Die Funktion UString Der Funktion UString wird eine Anzahl und ein UNICODE-Zeichencode oder ein Quellstring übergeben. Als Rückgabe erhält man einen Zielstring, welcher das als Zeichencode übergebene UNICODE-Zeichen oder das erste Zeichen des Quellstrings in der übergebenen Anzahl enthält. Syntax Funktion UString: UString[$] ( length, { charCode | text$ } ) Print UString(5, "A")

'liefert "AAAAA"

4.9 Operatoren für das Handling von Zeichenketten 4.9.1

Konkatenationsoperatoren

Unter einem Konkatenationsoperator versteht man einen Operator, der für das Aneinanderhängen von zwei Zeichenketten steht. In LotusScript sind das die Symbole & und +. Konkatenation von Zeichenketten bedeutet Aneinanderhängen. In LotusScript gibt es dafür die Symbole & und +.

4.9.2

Vergleichsoperatoren

Bei den Vergleichsoperatoren wird die Einstellung beachtet, die ggf. mit der Anweisung Option Compare getroffen wurde. Mit dieser Anweisung bestimmt man, ob die Groß-/Kleinschreibung bei einem Vergleich relevant ist. Operator

Bedeutung

=

Gleich

oder >
Anzahl Umdrehungen = nStrecke / Radumfang = nStrecke / ' (2 * PI * Radius) '--> Winkelveränderung = Anzahl Umdrehungen * voller Winkel = ' nStrecke / Radius nWinkelÄnderung = nStrecke / oMäher.RadRadius RäderDrehen oMäher, nWinkelÄnderung ' Messer bewegen .... '... End Function

Alle Bewegungen im Sinn zu behalten und zu jeder Zeit sämtliche Vorgänge programmiertechnisch zu kontrollieren, erfordert bei dieser Vorgehensweise also schon einiges von der Fähigkeit eines Jongleurs. Man ahnt schon, worin die Schwierigkeit liegt: Wenn der Jongleur einmal kurz unaufmerksam wird, dann kann die ganze Sache ganz plötzlich zusammenbrechen. Ein weiterer Nachteil ist, dass sämtliche Teilfunktionen (»Horizontal bewegen«, »Räder drehen«, »Messer drehen« usw.), die mit dem Mäher zu tun haben, auf derselben Datenstruktur arbeiten. Wehe also, wenn die Datenstruktur aus irgendeinem Grund nachträglich geändert werden muss! Dann muss jede auf ihr arbeitende Funktion ebenfalls kontrolliert, evtl. angepasst und auf jeden Fall neu kompiliert werden. Das hat wieder etwas von einem Jongleur.

192

Objektorientierte Programmierung unter LotusScript

Funktionale Programmierung

Vorteile

Nachteile

Kleine Programme

Wenig Aufwand.

Die Wiederverwendbarkeit für sich ergebende größere Programme ist eingeschränkt.

Große Programme

Die funktionale Programmierung mag für einzelne laufzeitkritische Teile die bessere Wahl sein. Hier würde man u. U. sogar globale Variablen zulassen. Allerdings ist dieses Argument selten stichhaltig.

Die Übersicht geht verloren. Es treten verstärkt Code-Redundanzen auf. Dies verursacht hohe Wartungskosten und behindert die Weiterentwicklung.

Tabelle 17.2: Vor- und Nachteile der funktionalen Programmierung

Im Folgenden werden wir sehen, wie sich all diese Nachteile mit dem objektorientiertem Ansatz vermeiden lassen.

17.7 Objektorientierte Analyse Die Objektorientierte Analyse wird auch mit dem Kürzel OOA bezeichnet. Bei dieser Vorgehensweise ermitteln wir zunächst die beteiligten Objekte: Gärtner, Rasenmäher, Rasen. Dann betrachten wir die Eigenschaften und Fähigkeiten der Objekte jeweils für sich: Der Gärtner z. B. hat einen Namen, eine typische Schrittgeschwindigkeit (je nachdem, ob fleißig oder faul), eine Schuhgröße; der Rasenmäher hat eine Marke, ein Messer, vier Rollen; der Rasen wiederum hat eine bestimmte Höhe und viele Grashalme und sonstiges (Un)kraut. Der Gärtner kann laufen, essen, wachsen; der Rasenmäher kann schneiden, Krach machen; der Rasen kann wachsen und geschnitten werden. Wir haben nur einige »wesentliche« Eigenschaften aufgezählt. In Wirklichkeit können die einzelnen Objekte noch viel mehr. Bevor wir uns jetzt aber darüber Gedanken machen, welche Konfektionsgröße und Hobbys der Gärtner hat und welche Schrauben zum Bau des Rasenmähers gebraucht werden, halten wir erst einmal inne. Wir vergegenwärtigen uns, dass wir für das »Problem« Rasenmähen nicht jedes mögliche Detail benötigen, das die Objekte aufweisen mögen. Daher spezifizieren wir die Objekte nur soweit, wie es momentan notwendig erscheint. Insofern haben wir auch beim Erstellen des OOD (Objektorientiertes Design) die Funktionalität im Auge. Allerdings ist es nicht sehr schädlich, wenn die Funktionalität noch nicht bis ins Kleinste festgelegt wird. Bei der funktionalen Analyse wäre das tödlich.

Kerngedanken der Funktionalen und der Objektorientierten Programmierung

193

Die OOP hat i. A. zunächst mehr die Eigenschaften und das Verhalten der beteiligten Objekte im Auge. Das heißt aber nicht, dass man sich über die letztendlich gewünschte Funktionalität keine Gedanken zu machen braucht. Die Auswahl der passenden Objekte mit den passenden Eigenschaften und Methoden orientiert sich an der gewünschten Programmfunktionalität. Das Gute an der OOP ist, dass man den Objekten eventuell vergessene Eigenschaften und Fähigkeiten jederzeit hinzufügen kann, ohne dass dadurch ein bereits erstelltes Programm beeinträchtigt würde.

17.8 Kerngedanken der Funktionalen und der Objektorientierten Programmierung Designmethode

Grundidee

Funktionale Analyse

Ein Programm wird als eine einzige große Aufgabe (Funktion) aufgefasst. Diese wird immer weiter in kleinere Funktionen aufgegliedert, bis man zu elementaren Funktionen gelangt, die sich praktisch unmittelbar aus der Spezifikation in Programmcode umsetzen lassen.

Objektorientierte Analyse (OOA, OOD)

Ein Programm wird als das Zusammenwirken von Objekten aufgefasst. Objekte sind Datenstrukturen mit darauf wirkenden Funktionen. Die nach außen sichtbaren Daten eines Objektes werden als Eigenschaften bezeichnet, die Funktionen als Methoden. Objekte »kommunizieren« miteinander und mit der Außenwelt über ihre Methoden. Diese Designmethode kommt i. A. dem natürlichen Verständnis von Aufgabenstellungen wesentlich näher als die funktionale Vorgehensweise.

Tabelle 17.3: Gegenüberstellung Funktionale und Objektorientierte Programmierung

17.9 Objekte in LotusScript »bauen« Wie bauen wir nun solche Objekte in LotusScript? Zunächst einmal muss es für jedes Programmobjekt eine zugrunde liegende »Klasse« geben. Eine Klasse ist der Bauplan für ein Objekt. So wie es für unseren Rasenmäher in der Herstellerfirma einen Bauplan gibt, nach dem Hunderte und Tausende gleicher Rasenmäher gebaut werden, so kann man auch nach Erstellung einer Klasse so viele darauf basierende Objekte anlegen, wie man will. Die Klasse ist der Bauplan, der als Schablone (einmal) irgendwo im Arbeitsspeicher abgelegt wird, selbst aber über keinerlei sonstige Fähigkeiten verfügt. Das Objekt dagegen ist eine Bit- und Bytestruktur

194

Objektorientierte Programmierung unter LotusScript

(ebenfalls im Speicher), die genau das tut, was der Bauplan ihr vorgibt. Objekte kann es im Gegensatz zur Klasse so viele geben, wie der Arbeitsspeicher hergibt. Eine Klasse ist der Bauplan, nach dem bei der Instanziierung die Objekte im Arbeitsspeicher angelegt werden. Das Programm selbst arbeitet mit Objekten, nicht mit Klassen. Doch häufig werden beide Begriffe synonym verwendet. Das ist auch in diesem Buch der Fall. Dies ist zwar nicht ganz korrekt, liegt aber nahe, weil sich die Objekte genau nach dem Bauplan der Klassen verhalten. Klassen müssen wie Variablen und Datentypen vor ihrer Verwendung deklariert werden. Objekte hingegen werden auf Basis dieser Deklaration definiert oder, wie man auch sagt, instanziiert. Deklaration von Klassen: Class Gärtner End Class Class Rasenmäher End Class Class Rasen End Class

Die Class End-Anweisung legt den Beginn und den Abschluss des Gültigkeitsbereiches einer Klasse fest. Das bedeutet, dass sämtliche innerhalb dieser Anweisung deklarierten Elemente (dies können Variablen und Funktionen bzw. Prozeduren sein) nur über die Angabe des Bezeichners der Objektreferenzvariablen und des Bezeichners des jeweiligen Elements (getrennt durch einen Punkt) aufgerufen werden können. Beispiele hierzu finden Sie in Abschnitt 17.11. Definition von Objekten: Dim oFleißig As New Gärtner Dim oKlappergestell As New Rasenmäher Dim oUnserGanzerStolz As New Rasen

Das Präfix »o« bei den Objektvariablennamen macht deutlich, dass sich diese Variablen auf Objekte beziehen. Sie können natürlich auch jedes andere Ihnen zusagende Präfix verwenden, oder es je nach Geschmack ganz weglassen. Letzteres ist allerdings aus Gründen der Lesbarkeit nicht zu empfehlen. Zusammenfassend können wir sagen: Wir haben mit der Class End-Anweisung zunächst die »Baupläne« erstellt und darauf aufbauend mit Dim Objektname As New Klassenname von jedem Bauplan ein Objekt im Arbeitsspeicher erzeugt.

Eigenschaften und Methoden

195

17.10 Eigenschaften und Methoden Allerdings sind das noch sehr nichtssagende Objekte. Denn sie verfügen zurzeit weder über Eigenschaften noch irgendwelche Fähigkeiten. Fähigkeiten nennt man in der OOP auch »Methoden«. Eigenschaften sind ganz einfach Variablen, die einem Objekt zugeordnet werden, während Methoden ihm zugeordnete Funktionen bzw. Prozeduren sind. Eigenschaften werden durch Variablen beschrieben, die innerhalb des Gültigkeitsbereiches einer Klasse definiert sind. Methoden werden durch Funktionen und Prozeduren beschrieben, die innerhalb des Gültigkeitsbereiches einer Klasse definiert sind. Versehen wir also den Gärtner mit einigen Eigenschaften und Fähigkeiten. Zunächst die Eigenschaften: Class Gärtner Public Name As String Public SchrittGeschwindigkeit As Single Schuhgröße As Integer End Class

Eigenschaften werden innerhalb der Class End-Anweisung wie Variablen deklariert. Dabei gibt es zwei wichtige Unterschiede zur normalen Variablen-Deklaration: innerhalb einer Klassendeklaration können Variablen nicht definiert werden. Das heißt, man kann sie zwar deklarieren, ihnen aber keine Werte zuweisen. Also fällt auch eine Anweisung wie Dim Objektname As New Klassenname für eine Eigenschaftendeklaration flach. Wertzuweisungen sind nur über Klassenmethoden oder durch Zuweisung »von außen« möglich. Des Weiteren ist Ihnen sicherlich aufgefallen, dass wir bei der Schuhgröße das Schlüsselwort Dim ausgelassen haben. Es ist in diesem Kontext nicht erlaubt. Und noch etwas Interessantes: die Eigenschaften Name und SchrittGeschwindigkeit sind Public deklariert worden. Damit sind diese Eigenschaften von außen sichtbar, die Schuhgröße hingegen nicht. Das heißt, die Schuhgröße ist nur dem Gärtner selbst bekannt (er verrät nicht gerne, dass seine Plattfüße schon Größe 52 erfordern). Wenn das Objekt auch diese Eigenschaft nach außen bekannt geben will, so muss es dies auf andere Weise tun, wie wir noch sehen werden. Man hätte zur Verdeutlichung dieses Sachverhalts vor die Schuhgröße auch das Schlüsselwort Private setzen können. Das hat aber keinen anderen Effekt als das bereits vom Compiler »unsichtbar eingefügte« Private. Wenn wir von dieser erweiterten Klasse den Gärtner Fleißig mit der Anweisung Dim oFleißig As New Gärtner anlegen, dann hat Fleißig also die Eigenschaften Name, SchrittGeschwindigkeit und Schuhgröße. Allerdings sind die Eigenschaftsvariablen noch leer.

196

Objektorientierte Programmierung unter LotusScript

Noch ein Hinweis zu den Bezeichnern der Eigenschaftsvariablen. Normalerweise sollen Präfixe anzeigen, welchen Datentyp eine Variable repräsentiert. Nun gibt es in Klassendefinitionen bei den Eigenschaftsvariablen noch die Unterscheidung in Public und Private. Eine Möglichkeit, dies deutlich zu machen, wäre ein weiteres Präfix. Dies würde ein weitergehendes Stilkonzept erfordern, mit dem wir den Stoff dieses Buches nicht belasten wollen. Daher wird bei den Public-Eigenschaften das Präfix einfach weggelassen.

17.11 Abfrage von Eigenschaften Den Namen von oFleißig erhält man analog zur Abfrage von Type-Elementen mit dem Punktoperator: oFleißig.Name

Diesen Namen kann man einer String- oder auch Variant-Variablen zuweisen: Dim sGärtnerName As String sGärtnerName = oFleißig.Name

Die Abfrage von Eigenschaften anderer Datentypausprägung erfolgt analog. Eigenschaften vom Datentyp Integer würde man also einer Integer- oder Variantvariablen zuweisen, Eigenschaften vom Datentyp Long dagegen einer Long- oder einer Variantvariablen usw.

17.12 Zuweisen von Eigenschaften 17.12.1 Explizites Setzen von Eigenschaften Da der Name noch leer ist, müssen wir ihm erst einmal einen Wert zuweisen; dies geschieht über den Zuweisungsoperator: oFleißig.Name = "Anton"

Wenn wir einen zweiten Gärtner haben, z. B. den Gärtner oFaul, dann legen wir vom gleichen »Bauplan« (= Klasse Gärtner) ein zweites Objekt an und geben diesem den entsprechenden individuellen Namen: Dim oFaul As New Gärtner oFaul.Name = "Wilhelm"

Nun geben wir noch die Arbeitsgeschwindigkeiten der beiden Gärtner an: oFleißig.SchrittGeschwindigkeit = 2 oFaul.SchrittGeschwindigkeit = 0.5

Zuweisen von Eigenschaften

197

Die Zahlen mögen für km/h stehen. Dies vereinbaren wir ganz willkürlich. Denn noch haben wir dafür keine Eigenschaft deklariert. Dies folgt im nächsten Abschnitt.

17.12.2 Implizites Setzen von Eigenschaften Wenn die Maßeinheit im Objekt festgehalten werden soll, dann können auch hierfür Eigenschaftsvariablen deklariert und später entsprechend belegt werden. Allerdings wäre es lästig, für zehn Gärtner jedesmal nach der Erzeugung des Objektes die Maßeinheit explizit definieren zu müssen. Wie können wir dies umgehen? N ew-M etho de Für solche Probleme gibt es die New-Methode, den Konstruktor in Basic-Sprachen. Dies ist eine Methode der Klasse, die beim Erzeugen der Objekte automatisch in Aktion tritt, wenn beispielsweise die Anweisung Dim Durchschnittlich As New Gärtner einen weiteren elektronischen Gärtner erzeugt. Eine New-Methode kann in jeder Klasse angelegt werden. Man kann sie aber auch ohne Schaden weglassen. Nur ist die Initialisierung des Objektes dann dem Programmierer überlassen. Objekte können bei der Erzeugung (Instanziierung) automatisch initialisiert werden. Dazu dient die New-Methode, in anderen Programmiersprachen auch Konstruktor oder New-Operator genannt. Da wir selbstverständlich zu viel Arbeit vermeiden wollen, spendieren wir unserem Gärtner eine New-Methode: Class Gärtner Public Name As String Public SchrittGeschwindigkeit As Single Public MassEinheit As String Sub New MassEinheit = "km/h" End Sub End Class

Erzeugen wir nun ein weiteres Gärtnerobjekt, dann wird die Maßeinheit automatisch bei der Erzeugung eingetragen. Wir können sie bereits unmittelbar danach ohne weiteres Zutun abfragen: Dim oDurchschnittlich As New Gärtner Dim sEinheit As String sEinheit = oDurchschnittlich.MassEinheit

198

Objektorientierte Programmierung unter LotusScript

I n i ti ali liss i e r un g i m De b u gg e r Wenn wir die Variable Einheit im Debugger betrachten, stellen wir fest, dass sie den Wert »km/h« enthält. Sie sollten sich überhaupt möglichst viele Beispiele im Debugger anschauen, um ein Gefühl dafür zu bekommen, wie sich die Objekte zur Laufzeit verhalten. Dazu kann ein einfacher Agent dienen. Die Klassendeklarationen packen Sie in den Abschnitt »(Declarations)« und im Abschnitt »Initialize« legen Sie die Objekte an und führen auch die Verarbeitung durch. Welche Möglichkeiten Ihnen der Debugger bietet, um die Initialisierung der Objekte und ihre Verarbeitung zu verfolgen, finden Sie im Kapitel Entwicklungsumgebung (IDE). U n te r s c h i e d l ic h e I n i ti a li s i e r un g v e r w a n d t e r O b j e k t e Solange sich alle Gärtner mit metrischer Geschwindigkeit fortbewegen, ist diese Art der Objektinitialisierung ausreichend. Was ist aber, wenn wir nicht nur deutsche, sondern auch britische Gärtner einsetzen möchten? Ein britischer Gärtner wird sich vorzugsweise in »miles/h« bewegen. Die weniger elegante Möglichkeit wäre, eine Klasse DeutscherGärtner und eine Klasse BritscherGärtner zu erzeugen, die unterschiedliche New-Methoden enthalten: Class DeutscherGärtner ... Public MassEinheit As String Sub New MassEinheit = "km/h" End Sub End Class Class BritischerGärtner ... Public MassEinheit As String Sub New MassEinheit = "miles/h" End Sub End Class

N e w- M e t h o de pa ra me tr i s i e r e n Etwas unelegant ist dieses Vorgehen, weil wir jetzt zwei Klassen erzeugt haben, die einander ziemlich ähnlich sind. Dadurch müssen wir unter Umständen eine Menge Code doppelt schreiben. Und ihn auch an doppelt so vielen Stellen warten. Da schüttelt’s einen vernünftigen Softwareentwickler: brrrrrr ...! Was können wir tun?

Zuweisen von Eigenschaften

199

Die einfachere Lösung führt zur Parametrisierung der New-Methode: Class Gärtner ... Public MassEinheit As String Sub New(in_MassEinheit As String) MassEinheit = in_MassEinheit End Sub End Class

Beim Erzeugen eines neuen Gärtner-Objektes müssen wir nun dem New-Operator mitteilen, mit welchen Werten das Objekt initialisiert werden soll: Dim oDurchschnittlich As New Gärtner("km/h")

oder Dim oDurchschnittlich As New Gärtner("miles/h")

K o n t r o l le im D e b u g g e r Wie wir uns im Debug-Modus überzeugen können, wird der Gärtner Durchschnittlich entweder mit der deutschen oder der britischen Maßeinheit ausstaffiert, je nachdem welchen Parameterwert wir bei der Erzeugung mitgeben. Die hier beschriebene Methode ist gut geeignet, wenn sich die zu erzeugenden Objekte nur durch wenige Initialisierungswerte unterscheiden. W e i t e r e V e re i n f a c h un g b e i vi e l e n P a r a me t e r n Bei der Betreuung einer großen Parkanlage kann es sein, dass wir viele deutsche und viele britische Gärtner zu betreuen haben. Wenn wir dann bei jeder Objekterzeugung alle Parameterwerte, die deutsche und britische Gärtner voneinander unterscheiden, jeweils angeben müssten, so wäre das nicht besonders schön. Also verändern wir unsere Gärtner-Klasse folgendermaßen: Class Gärtner ... Public MassEinheit As String Public Sprache As String Sub New(in_Nationalität As String) If in_Nationalität = "deutsch" then MassEinheit = "km/h" Sprache = "Deutsch" Elseif in_Nationalität = "britisch" then MassEinheit = "miles/h" Sprache = "Englisch" End if End Sub End Class

200

Objektorientierte Programmierung unter LotusScript

Jetzt brauchen wir beim Erzeugen neuer Gärtner nur noch die jeweilige Nationalität anzugeben und schon werden alle zugehörigen Eigenschaften richtig gesetzt. Ein britischer Kollege würde so erzeugt: Dim oDurchschnittlich As New Gärtner("britisch")

Dieser Gärtner hat automatisch die Maßeinheit »miles/h« und die Sprache »Englisch«. Dies ist von Vorteil, wenn die Gärtner sich durch eine ganze Anzahl Unterschiede auszeichnen, die bei der Initialisierung durch Angabe der Nationalität automatisch festgelegt werden können.

17.13 Vererbung Angenommen, wir beschäftigen Gärtner vieler Nationalitäten. Dann kann man sich sofort ausmalen, dass die New-Methode unter Umständen sehr lang und unhandlich werden kann. Denn wir müssten in dieser einen Methode sämtliche Unterschiede für alle vorkommenden Nationalitäten beschreiben. Dieses Problem kann man durch das Konzept der Vererbung ganz leicht aus der Welt schaffen. Vererbung bedeutet vereinfacht gesagt, dass neue Klassen von bereits vorhandenen abgeleitet werden. Sie erben dann die spezifischen Merkmale und Methoden der zugrunde liegenden Basisklassen. Dies geschieht in LotusScript mit der Class Klassenname As Basisklasse End-Anweisung. Das Konzept der Vererbung beschreibt die Beziehung von zwei Klassen, bei der die so genannte Subklasse Eigenschaften der Basisklasse übernimmt (also »erbt«). Die Basisklasse einer Subklasse wird auch als Superklasse bezeichnet, da man sich die Vererbungshierarchie als »von oben nach unten«, also topdown verlaufend, vorstellt. Setzt man das Konzept der Vererbung ein, so ist zunächst zu überlegen, welche Klassen gemeinsame Merkmale besitzen, die sich von einer gemeinsamen Basisklasse ableiten lassen. Bei den Gärtnern verschiedener Herkunft könnte die Basisklasse so aussehen: Class Gärtner Name As String SchrittGeschwindigkeit As String MassEinheit As String Sprache As String Kleidung As String Sub New End Sub End Class

Vererbung

201

Die abgeleiteten Klassen: Class BritischerGärtner As Gärtner Sub New MassEinheit = "miles/h" Sprache = "Englisch" End Sub End Class Class DeutscherGärtner As Gärtner Sub New MassEinheit = "km/h" Sprache = "Deutsch" End Sub End Class

Die Erzeugung der einzelnen Gärtnerobjekte sieht jetzt wie folgt aus: Dim oDurchschnittlich As BritischerGärtner

oder Dim oDurchschnittlich As DeutscherGärtner

Man kann die Vererbung beliebig weitertreiben. So kann man zum Beispiel von BritischerGärtner die Klasse SchottischerGärtner und die Klasse EnglischerGärtner ableiten und von DeutscherGärtner die Klasse BayrischerGärtner und die Klasse PreussischerGärtner. Dies tun wir stellvertretend für zwei Gärtner-Klassen: Class SchottischerGärtner As BritischerGärtner Sub New Kleidung = "Schottenrock" End Sub End Class Class BayerischerGärtner As DeutscherGärtner Sub New Kleidung = "Lederhose" End Sub End Class

Wollten wir diesen Code so abspeichern bzw. kompilieren, würden wir eine entsprechende Fehlermeldung erhalten, die besagt, dass wir eine Eigenschaftsvariable (Kleidung) ansprechen, die die Klasse gar nicht kennt. Wir könnten diese Eigenschaft noch in die jeweilige Klassendeklaration einfügen, also z. B.: Class BayerischerGärtner As DeutscherGärtner Public Kleidung As String Sub New Kleidung = "Lederhose" End Sub End Class

202

Objektorientierte Programmierung unter LotusScript

Dies zeigt, wie man in abgeleitete Klassen zusätzliche Eigenschaften einfügen kann, die dann nur für diese und alle von ihr wiederum abgeleiteten Klassen zur Verfügung stehen. Abgeleitete Klassen können zusätzliche Eigenschaften und Methoden erhalten. Diese werden in der abgeleiteten Klasse einfach zusätzlich deklariert und definiert. In unserem Beispiel benötigen wir die Eigenschaft »Kleidung« allerdings für sämtliche Landsmänner. Wir müssten also die Ergänzung in jeder der vier abgeleiteten Klassen der untersten Ebene anwenden. So würden wir unversehens redundanten Code erzeugen. Daher verlegen wir die Deklaration der Eigenschaft in die in der Vererbungshierarchie höchstliegende Basisklasse. Dadurch kann die Vererbung ihre volle Kraft entfalten. In diesem Fall würden wir uns für die Basisklasse Gärtner entscheiden. (Wir könnten auch die Klassen BritischerGärtner und DeutscherGärtner wählen. Dann müssten wir die Definition nur noch zweimal vollziehen. Aber auch zweifache Redundanz ist ungesund. Besser ist gar keine!) Class Gärtner Name As String SchrittGeschwindigkeit As String MassEinheit As String Sprache As String Kleidung As String Sub New End Sub End Class

Die Eigenschaft Kleidung steht jetzt für alle abgeleiteten Klassen in allen Ableitungsebenen zur Verfügung. Sie kann in jeder dieser Klassen angesprochen werden, ohne dass sie jedesmal neu deklariert werden müsste. Nun haben wir Maßeinheiten speziell für deutsche und britische Gärtner implementiert. Dies müssten wir auch für alle Gärtner anderer Nationalitäten ganz analog tun. Da aber fast die ganze Welt im metrischen System rechnet, kann dies ganz schön lästig und schon wieder redundant werden. Was mit dieser Redundanz passiert, wenn die ganze Welt ihr metrisches System auf ein anderes umstellen sollte, kann man sich schon vorstellen. An allen Gärtner-Klassen, die auf dieses System zurückgreifen, müssten Veränderungen vorgenommen werden. We i t e r e R e du n da n zv e r me i d un g Man kann die Vornahme so umfangreicher Änderungen aber sehr einfach vermeiden. Zu diesem Zweck legen wir für die allgemeine Basisklasse »Gärtner« mit deren NewMethode zunächst das metrische System fest:

Vererbung

203

Class Gärtner ... MassEinheit As String ... Sub New MassEinheit = "km/h" End Sub End Class

Alle von dieser Klasse abgeleiteten Gärtner-Klassen sind jetzt auf das metrische System eingestellt. Dazu muss deren New-Methode natürlich entsprechend gekürzt werden. Man entfernt dort jeweils die Zeile MassEinheit = ... Lediglich in der Klasse der britischen Gärtner bleibt die New-Methode, wie sie ist: Class BritischerGärtner As Gärtner Sub New MassEinheit = "miles/h" Sprache = "Englisch" End Sub End Class

A b l a u f d e s V e r e r b u n g sm e c h a n i s m us Was passiert denn nun, wenn ein Objekt der Klasse BritischerGärtner angelegt wird? Sie sollten das einmal tun und dabei den Vorgang der Initialisierung im Debugger beobachten. Sie werden feststellen, dass als Erstes die New-Methode der Basisklasse Gärtner abgearbeitet wird und anschließend diejenige der abgeleiteten Klasse BritischerGärtner. Dabei wird die MassEinheit zunächst mit »km/h« initialisiert und anschließend mit »miles/h« überschrieben. So hat der britische Kollege zwar für einen winzigen Moment den falschen Wert, aber dies wird sofort wieder richtig gestellt. Wenn man anschließend mit dem so erzeugten Objekt arbeitet, merkt man von dem kurzen Umweg nichts. Es verhält sich so, als wäre die Eigenschaft von Anfang an richtig gesetzt worden. Warum wird denn dieser Umweg überhaupt beschritten? Er ist eine Folge des Vererbungskonzeptes. Dies wird sofort deutlich, wenn wir einen bayrischen Gärtner produzieren. Tun Sie dies bitte einmal und beobachten Sie das Ganze wieder im Debug-Modus. Sie werden wiederum feststellen, dass zunächst die New-Methode der Basisklasse Gärtner die MassEinheit auf »km/h« setzt. Dann wird die New-Methode der nächsten abgeleiteten Klasse DeutscherGärtner tätig und setzt die Sprache auf Deutsch. Zu guter Letzt sorgt die dritte Ableitungsstufe für die richtige Kleidung eines Bayern. So erbt jede abgeleitete Klasse die Einstellungen der vorherigen Klasse. Dabei wird folgerichtig die Vererbung von der obersten Ebene bis zur untersten abgearbeitet. Dies gilt für die New-Methode. Analoges gilt auch noch für die Delete-Methode, auf die wir etwas weiter unten eingehen. Für alle anderen Methoden, die Sie

204

Objektorientierte Programmierung unter LotusScript

implementieren mögen, gilt dieser Vorgang nicht. Dies ist auch logisch. Denn die New-Methode dient normalerweise der Initialisierung. Und dass diese der Vererbungshierarchie folgen muss, lässt sich gut einsehen. Alle anderen Methoden beschreiben irgendeine Funktionalität der Klassen bzw. Objekte. Und wie soll eine Funktionalität »in Teilen« vererbt werden? Man müsste einen Mechanismus erfinden, der festlegt, welche Teile zu vererben sind und welche nicht. Das wäre aber recht schwierig. Deshalb gibt es einen solchen Mechanismus auch nicht. Kr i t e r ie n fü r d i e G l e i chh hhe e i t v o n M e th o d e n Im Allgemeinen überschreibt eine Methode, die in Name, Typ und Parameterliste mit einer Methode der Basisklasse übereinstimmt, diese vollständig. Für eine Gleichheit zweier Parameterlisten genügt es, wenn die Anzahl und die Typen der Parameter übereinstimmen. Die Namen der Parameter selbst brauchen nicht identisch zu sein. Wird eine Methode auf diese Weise überschrieben, dann wird bei ihrem Aufruf nur die überschreibende Methode angesprochen. Es erfolgt kein Aufruf der namensgleichen Methode der zugrunde liegenden Basisklasse. Hat das Objekt selbst keine solche Methode, so wird dynamisch gesucht, welche nächste Superklasse eine solche hat, und diese wird ausgeführt. Auch diese überschreibt eine eventuell noch weiter oben in der Vererbungshierarchie angesiedelte Methode, die im obigen Sinne gleich ist, vollständig. Wir wollen uns diesen Vorgang mit Rasenmäher-Klassen vergegenwärtigen. Zunächst produzieren wir eine grundlegende Klasse Rasenmäher (die Definition der Klasse »Rasenmäher«, die in der Methode Schneiden verwendet wird, finden Sie etwas weiter unten im Abschnitt 17.19 »Benutzerdefinierte Containerklassen«): Class Rasenmäher nSchnittbreite As Integer nSchnitthöhe As Integer IstAmLaufen As Integer Sub New IstAmLaufen = False End Sub Function Anlassen As Integer Anlassen = Not IstAmLaufen End Function Sub Schneiden(in_oRasenStück As RasenStück) Forall halm In in_oRasenStück.Grashalme halm.Höhe = Schnitthöhe End Forall End Sub End Class

Zustandsvariablen

205

Wenn wir von dieser Klasse Rasenmäher ein Objekt oMäher anlegen, Dim oMäher As New Rasenmäher

dann wird die Eigenschaft IstAmLaufen auf FALSE gesetzt. Denn wenn man den Rasenmäher aus dem Geräteschuppen holt, kann man im Allgemeinen davon ausgehen, dass er noch nicht läuft. IstAmLaufen ist eine einfache Zustandsvariable. Solche Zustandsvariablen verdienen oft eine Sonderbehandlung, wie wir später noch sehen werden.

17.14 Zustandsvariablen Wenn wir den Anlasser betätigen, wird der Rasenmäher (hoffentlich) anspringen. Allerdings freut sich kaum ein Motor darüber, im laufenden Betrieb angelassen zu werden. Deshalb schlägt die Methode Anlassen auch fehl, falls der Motor bereits angelassen worden ist. Ansonsten wird sie den Motor starten. Da dies bei elektrischen Rasenmähern ein ganz anderer Vorgang ist als bei Benzinern, verlegen wir diesen Teil der Anlasser-Methode in die jeweiligen abgeleiteten Klassen. (Beispielsweise muss man beim Benziner mit Schwung an der Strippe ziehen, je doller, desto mehr Chancen auf Erfolg. Wer dasselbe beim Elektromäher versucht, wird einen ganz anderen »Erfolg« feststellen können. Der Kundendienst freut sich schon ...) Class Rasenmäher Sub New End Sub Function Anlassen As Integer Anlassen = Not IstAmLaufen End Function End Class

Die Eigenschaften »Schnittbreite«, »Schnitthöhe« und »IstAmLaufen« werden vererbt und brauchen daher nicht noch einmal definiert zu werden. Da das Schneiden mit einem Elektromäher und einem Benziner der gleiche Vorgang ist, kann auch diese Methode vererbt werden.

17.15 Methodenvererbung Betrachten wir also lediglich das Anlassen. Da beide Mäher nicht im laufenden Betrieb »angelassen« werden sollten, haben wir ein berechtigtes Interesse daran, den Teil, der dies sicherstellt, aus der Funktion Anlassen aus der Basisklasse an die Superklassen zu vererben. Vorher haben wir behauptet, dass dies nicht geht. Und jetzt zeigen wir den Mechanismus, mit dessen Hilfe es doch geht (es ist nur nicht ganz so einfach wie bei der New-Methode, wo der Mechanismus automatisch arbeitet!).

206

Objektorientierte Programmierung unter LotusScript

Das syntaktische Geheimnis lautet: NameDerBasisklasse..NameDerFunktionDerBasisklasse

Man kann das Ausführen einer Methode einer Basisklasse durch den ..-Operator erzwingen. Der Nachteil gegenüber der Automatik in der New-Methode ist gleichzeitig ihr Vorteil: Wir sind zwar gezwungen, die Methode der Basisklasse über den ..-Operator explizit aufzurufen, wir können aber auf diese Weise auch steuern, zu welchem Zeitpunkt dies geschieht. Somit ist diese »künstliche« Vererbung wesentlich flexibler als die automatische. Darüber hinaus kann man natürlich genauso gut irgendeine andere Methode der Basisklasse aufrufen. Es braucht keine namensgleiche zu sein. Und noch ein Vorteil: man kann einige Vererbungsebenen überspringen, indem man den Namen der gewünschten Superklasse angibt. Wir deklarieren also eine Klasse Benzinmäher: Class Benzinmäher As Rasenmäher IstTankLeer As Integer Sub New End Sub Sub AnStrippeZiehen IstAmLaufen = Not IstTankLeer End Sub Function Anlassen As Integer If Not Rasenmäher..Anlassen Then Exit Function AnStrippeZiehen Anlassen = IstAmLaufen End Function End Class

Und eine Klasse Elektromäher: Class Elektromäher As Rasenmäher nHatStrom As Integer IstKabelAnStrom As Integer Sub New nHatStrom = False IstKabelAnStrom = False End Sub Sub AnStrippeZiehen nHatStrom = False End Sub Function Anlassen As Integer Anlassen = Rasenmäher..Anlassen End Function End Class

Properties

207

Sie erkennen, wie unterschiedlich die Methode Anlassen bei den unterschiedlichen Rasenmähertypen arbeitet. In dem einen Fall greift sie erfolgreich auf die Anlasserstrippe zurück. Im anderen Fall wäre es fatal, an der »Strippe«, nämlich dem Elektrokabel, zu ziehen. In beiden Fällen müssen unterschiedliche Randbedingungen geprüft werden. Beim Benziner darf der Tank nicht leer sein, beim Elektromäher muss Strom anliegen.

17.16 Properties Warum haben wir eigentlich für die Sache mit dem Strom zwei Eigenschaften angelegt: »nHatStrom« und »IstKabelAnStrom«? Weil es zwei verschiedene Dinge sind, ob der Mäher selbst Strom hat oder nur das Kabel, aber der Mäher nicht. Letzteres würde einen Kabelbruch signalisieren. Wir kommen daher auf die Idee, dass die Klasse Elektromäher mit der Eigenschaft IstKabelGebrochen versehen werden könnte. Da sich diese Eigenschaft aber aus dem Vergleich zweier anderer Eigenschaften ergibt, können wir sie nicht einfach als Eigenschaftsvariable deklarieren. Was uns hilft, ist das Konstrukt der Property. Eine »Property« können Sie sich als einen Zwitter von Methode und Eigenschaft einer Klasse vorstellen. Eine Property kann wie eine Eigenschaftsvariable abgefragt werden. Zusätzlich kann sie während der Abfrage wie eine Methode eine Berechnung vornehmen oder irgendwelche anderen Vorgänge anstoßen. Und eine dritte bemerkenswerte Eigenschaft der Properties ist, dass man mit ihrer Hilfe Eigenschaftsvariablen vor Schreib- oder Lesezugriffen nach außen schützen kann. Theoretisch könnte man sie auch vor beidem schützen. Allerdings dürfte Letzteres kaum von praktischem Nutzen sein. Properties können zwei »Richtungen« haben. Die eine Richtung der Property wird mit dem Schlüsselwort Get bezeichnet und dient dazu, Abfragen an die Property zu bedienen. Die andere Richtung wird mit Set bezeichnet und bietet die Möglichkeit, zugewiesene Werte entgegenzunehmen. Durch die Aufspaltung in die beiden »Richtungen« können Zuweisungen an ein Objekt ganz anders behandelt werden als Abfragen. Wir setzen nun eine Property Get ein, um feststellen zu können, ob das Kabel eines Elektromähers gebrochen ist. Class Elektromäher As Rasenmäher nHatStrom As Integer IstKabelAnStrom As Integer Property Get IstKabelGebrochen As Integer IstKabelGebrochen = _ (IstKabelAnStrom And Not nHatStrom) End Property ... End Class

208

Objektorientierte Programmierung unter LotusScript

Wenn Sie ein Objekt auf Basis dieser Klasse anlegen, können Sie die Auswirkungen beim Aufruf der Eigenschaft IstKabelGebrochen im Debugger studieren: Dim oMäher As Elektromäher Dim nKabelGebrochen As Integer nKabelGebrochen = oMäher.IstKabelGebrochen

Die durch den Property-Code erzeugten Berechnungen lesen sich so: Lies zunächst die Eigenschaften IstKabelAnStrom und nHatStrom aus und bilde die boolesche Verknüpfung »And Not«. Das Ergebnis wird der Property zugewiesen, wodurch dieses einer »äußeren Abfrage« zur Verfügung steht. Das Ergebnis wird also in der Zuweisung nKabelGebrochen = oMäher.IstKabelGebrochen an die Variable nKabelGebrochen weitergereicht. Wollen Sie umgekehrt der Eigenschaft IstKabelGebrochen einen Wahrheitswert zuweisen, so wird der Compiler einen Fehler auswerfen: oMäher.IstKabelGebrochen = True

Der Grund ist, dass das Schlüsselwort »Get« im Kopf der Property angibt, dass diese Property nur abgefragt, aber nicht beschrieben werden kann. Wollen wir den Wert für IstKabelGebrochen nicht nur implizit über die beiden Teil-Eigenschaften nHatStrom und IstKabelAnStrom, sondern auch ganz explizit setzen können, so müssen wir eine Property Set definieren: Class Elektromäher As Rasenmäher nHatStrom As Integer IstKabelAnStrom As Integer Property Get IstKabelGebrochen As Integer IstKabelGebrochen = _ (IstKabelAnStrom And Not nHatStrom) End Property Property Set IstKabelGebrochen As Integer If IstKabelGebrochen Then nHatStrom = False Else If IstKabelAnStrom Then nHatStrom = True End If End Property ... End Class

Die Vorgänge zur Laufzeit lesen sich so: Zunächst wird der an die Property übergebene Wert in der If-Abfrage auf den enthaltenen Wahrheitswert hin geprüft. Je nach dem Ergebnis werden innerhalb des Objektes Berechnungen bzw. Zuweisungen vorgenommen. Auf diese Weise wird also ein »von außen« zugewiesener Wert in das Objekt »hineingereicht«.

Klassenvariablen

209

Wir sehen an diesem Beispiel sehr schön, wie uns das Property-Konzept eine große Flexibilität beim Umgang mit Eigenschaften erlaubt. Das Property-Konzept erlaubt eine große Flexibilität im Umgang mit Objekteigenschaften. Es gibt für die zwei Richtungen der Zuweisung (an eine Eigenschaft oder von einer Eigenschaft, Letzteres wird auch als Abfrage der Eigenschaft bezeichnet) auch zwei Typen von Properties: die Property Get und die Property Set. Das Property-Konzept wird auch eingesetzt, um Eigenschaften zu definieren, die von außen abgefragt, aber nicht gesetzt werden können. Zum Beispiel ist die Schnittbreite eine normalerweise unwandelbare Eigenschaft eines bestimmten Mähermodells. Daher schützen wir sie durch eine Property GetKonstruktion. Dazu benennen wir die Schnittbreite in der Basisklasse Rasenmäher um, schützen sie vor äußerem Zugriff durch das Schlüsselwort Private und bauen eine Property Get, die den Namen der Eigenschaft trägt: Class Rasenmäher ... nSchnittbreite As Integer ... Property Get Schnittbreite As Integer Schnittbreite = nSchnittbreite End Property Sub New (in_Schnittbreite As Integer) IstAmLaufen = False nSchnittbreite = in_Schnittbreite End Sub ... End Class

Auf diese Weise wird die Schnittbreite beim Anlegen eines Rasenmäher-Objektes über die New-Methode und den Parameter in_Schnittbreite einmal intern belegt. Danach kann sie von außen nur noch über die Property Schnittbreite abgefragt werden.

17.17 Klassenvariablen Allen bis jetzt definierten Eigenschaften ist gemeinsam, dass sie zwar teilweise von Basisklassen vererbt wurden, aber letztlich für jedes von einer Klasse erzeugte Objekt jede Eigenschaft speziell für dieses Objekt gesetzt wurde. Im Arbeitsspeicher existiert also für eine Objekt-Eigenschaft jedes Objektes ein separater Speicherplatz. Daher können diese Eigenschaftsvariablen prinzipiell alle unabhängig voneinander gesetzt werden. Sie werden auch Objektvariablen genannt.

210

Objektorientierte Programmierung unter LotusScript

Manchmal möchte man aber, dass eine Eigenschaft für alle Objekte einer Klasse denselben Wert hat. Und wenn sich dieser Wert ändert, soll er sich gleichzeitig auch für alle anderen Objekte gleichermaßen ändern. Solche Eigenschaften nennt man auch Klassenvariablen. Für Klassenvariablen wird nur ein einziger Wert gespeichert, auf den alle von dieser Klasse erzeugten Objekte zugreifen. Eine Objektvariable ist eine Objekteigenschaft, deren Wert nur für dieses eine Objekt Gültigkeit hat. Andere Objekte der gleichen Klasse können davon völlig unabhängige Werte haben. Eine Klassenvariable dagegen gilt für alle davon abgeleiteten Objekte. Verändert ein Objekt diesen Wert, ist er gleichermaßen auch in allen anderen Objekten der gleichen Klasse verändert. In Java beispielsweise gibt es das Konstrukt der Klassenvariable von Haus aus. Dies ist in LotusScript nicht der Fall. Aber man kann Klassenvariablen zumindest annähernd nachbauen. Zu diesem Zweck deklarieren wir die Klassenvariable im Bereich »Declarations« in der Bibliothek, in der sich auch die Klassendeklaration befindet. Zum Beispiel: Dim nHatMesser As Integer

(Wir deklarieren sie nicht mit dem Schlüsselwort »Public«, da sie sonst von außen unkontrolliert manipuliert werden könnte. Wenn dies egal ist, kann sie natürlich Public deklariert sein.) In der Basisklasse fügen wir jetzt eine Zugriffs-Property ein: Property Get HatMesser As Integer HatMesser = nHatMesser End Property

Die Initialisierung nehmen wir jetzt an zentraler Stelle für die ganze Klasse nur einmal vor. Wir könnten dies die New-Methode der Basisklasse erledigen lassen. Dann würde die Variable allerdings bei jeder Instanzerzeugung neu überschrieben. Dies ließe sich natürlich mit einer entsprechenden If-Abfrage verhindern. Aber es gibt einen eleganteren Weg. Wir nutzen das »Initialize«-Event der Bibliothek aus, die die Basisklasse enthält. Dort fügen wir die folgende Zeile ein: nHatMesser = True

Leider gibt es bei dieser Hilfskonstruktion keinerlei Möglichkeit zu verhindern, dass eine andere Methode, Funktion oder Property innerhalb der Bibliothek diese Klassenvariable überschreibt. Sie ist nur außerhalb dieser Bibliothek geschützt. Aber so viel Selbstdisziplin bringen wir doch noch auf, oder?

-

New-Methoden mit unterschiedlichen Parameterlisten in derselben Ableitungshierarchie

211

17.18 New-Methoden mit unterschiedlichen Parameterlisten in derselben Ableitungshierarchie Methoden, die von abgeleiteten Klassen überschrieben werden, müssen den gleichen Funktionskopf nutzen wie die jeweilige Basisklasse. Sonst wirft der Compiler einen Fehler aus. Dies gilt auch für die New-Methode. Dies kann aber ganz schön lästig werden, da man die komplette Parameterliste über alle über die Hierarchie verbundenen Klassen mitführen muss. Und das, obwohl manche Parameter vielleicht bereits in einer viel tiefer liegenden Vererbungsstufe gesetzt werden könnten. Als Beispiel betrachten wir noch einmal unsere Rasenmäher-Klasse. Wir stellen fest, dass Rasenmäher mit allen anderen großen beweglichen Geräten ein Fahrgestell in irgendeiner Form gemeinsam haben. Wir definieren daher eine Klasse Class Fahrgestell AnzahlRäder As Integer Sub New (in_AnzahlRäder As Integer, in_AnzahlAchsen As Integer) AnzahlRäder = in_AnzahlRäder End Sub End Class

Und Rasenmäher werden jetzt von dieser Klasse abgeleitet: Class Rasenmäher As Fahrgestell ... nSchnittbreite As Integer ... Sub New(in_Schnittbreite As Integer) IstAmLaufen = False nSchnittbreite = in_Schnittbreite End Sub ... End Class

Das Problem, das sich sofort stellt, sind die beiden unterschiedlichen Funktionsköpfe bei den New-Methoden. Die erste Lösungsmöglichkeit wäre, beide Methoden so zu erweitern, dass sie eine gemeinsame Parameterliste enthalten. Dazu müssten wir also alle Parameter der einzelnen New-Methoden in einer Ableitungshierarchie betrachten und die einfache Vereinigungsmenge aller vorkommenden Parameter für jede Methode verwenden. Die Köpfe sähen in unserem Beispiel so aus: Sub New(in_Schnittbreite As Integer, in_AnzahlRäder As Integer,_ in_AnzahlAchsen As Integer)

212

Objektorientierte Programmierung unter LotusScript

oder beispielsweise auch: Sub New(in_AnzahlRäder As Integer, in_AnzahlAchsen As Integer,_ in_Schnittbreite As Integer)

Welche Reihenfolge bei den Parametern gewählt wird ist egal, solange sie in allen zu betrachtenden New-Methoden gleich ist. Nun ist es aber nicht sehr befriedigend, für jeden Mäher immer mit angeben zu müssen, wie viele Räder er hat. Dies kann man glücklicherweise durch eine Besonderheit der New-Methode verhindern. Die zu verwendende Konstruktion lautet: Sub New(Parameterliste), NameBasisklasse(Argumentliste)

Die der Basisklasse übergebene Argumentliste stellt keine Parameter dar, sondern konkrete Werte. Sie werden an die New-Methode der Basisklasse übergeben. Wenn sie auf diese Weise an die Basisklasse übergeben werden, müssen die Anzahl und der Typ genau mit den von der Basisklasse erwarteten Merkmalen übereinstimmen. In der Liste »Parameter« werden die Parameter aufgelistet, die dieser abgeleiteten Klasse bei der Instanziierung übergeben werden sollen. Was machen wir aber, wenn die Basisklasse zwei Parameter benötigt, wir aber bei der Konstruktion einer Subklasse nur einen davon mit einem Wert füllen können? Das heißt, ein Parameter wird jetzt vorbelegt, der andere soll bei Anlage eines Objektes vom Typ der Subklasse weiterhin von außen übergeben werden. Nun, wir müssen auf jeden Fall beide Parameter der Basisklasse mit einem festen Wert belegen. Oder wir können das Ganze gleich vergessen. Also tun wir das. Zusätzlich wird der Parameter, der von außen übergeben werden soll, in der NewMethode der Subklasse wieder aufgeführt. Im Prozedurrumpf muss dafür gesorgt werden, dass die Zuweisung und/oder die Berechnungen, die die New-Methode der Basisklasse mit dem übergebenen Wert vornimmt, durch die New-Methode der Subklasse wieder mit dem von außen übergebenen Parameter überschrieben wird. Hier wirkt es sich günstig aus, dass die Private-deklarierten Eigenschaften von Basisklassen innerhalb der abgeleiteten Klassen voll zugänglich sind (anders als bei C++, wo solche Properties nur in der Basisklasse, in der sie angelegt wurden, angesprochen werden können). In unserem Beispiel sieht das wie folgt aus: Class Rasenmäher As Fahrgestell ... Sub New(in_Schnittbreite As Integer), Fahrgestell(4, 2)_ 'setzt Anzahl Räder auf 4 und Anzahl Achsen auf 2 IstAmLaufen = False nSchnittbreite = in_Schnittbreite 'setzt Schnittbreite auf 'übergebenen Parameterwert End Sub ... End Class

Benutzerdefinierte Containerklassen

213

Bei einem räderlosen Luftkissenmäher würde der Code entsprechend verändert: Class LuftkissenMäher As Fahrgestell ... Sub New(in_Schnittbreite As Integer), Fahrgestell(0, 0) 'setzt Anzahl Räder und Achsen auf 0 IstAmLaufen = False nSchnittbreite = in_Schnittbreite End Sub ... End Class

Wenn wir jetzt ein Objekt instantiieren (z. B. einen Luftkissenmäher), dann brauchen wir nur noch die Schnittbreite zu übergeben. Die Anzahl der Räder »berechnet« die entsprechende Klasse schon selbsttätig. Dim oMäher1 As New LuftkissenMäher(40) Dim oMäher2 As New RasenMäher(40)

Wenn Sie die Sache im Debugger überprüfen, werden Sie feststellen, dass oMäher1 null (0) Räder aufweist, oMäher2 hingegen vier (4).

17.19 Benutzerdefinierte Containerklassen Containerklassen zeichnen sich dadurch aus, dass sie eine unbestimmte Menge anderer Objekte beinhalten können. Im Allgemeinen bieten sie Methoden an, die einen Zugriff auf diese Objekte ermöglichen. Es stellt sich die Frage, wie die beinhalteten Objekte »aufbewahrt« und referenziert werden können. Dies werden die folgenden Beispiele deutlich machen. Eine Containerklasse ist eine Klasse, die auf eine unbestimmte Menge Instanzen (Objekte) anderer Klassen Zugriff hat. Da wir unsere Objekte letztlich dazu nutzen wollen, um einen Rasen »programmtechnisch« zu stutzen, benötigen wir noch ein Rasen-Objekt. Dieses Rasen-Objekt wird eine benutzerdefinierte Containerklasse sein. Wie kann der Rasen im Computer aussehen? Nun, ein Rasen besteht naturgemäß aus vielen Grashalmen. Daher definieren wir zunächst die Klasse Grashalm: Class Grashalm Public Höhe As Integer Breite As Integer Sub New(in_AktuelleHöhe As Integer) Höhe = in_AktuelleHöhe Breite = 1 End Sub

214

Objektorientierte Programmierung unter LotusScript

Sub Wachsen(in_GewachseneLänge As Integer) Höhe = Höhe + in_GewachseneLänge End Sub End Class

Wir tun einmal so, als wären alle Grashalme dieser Welt gleich breit (= 1). Um das Schützen der Eigenschaftsvariablen Höhe und Breite machen wir uns an dieser Stelle nicht so viele Sorgen. Wenn Sie einen solchen Schutz vor ungewollten Zugriffen brauchen, dann wissen Sie ja schon, wie Sie ihn errichten können (Property usw.). Nun benötigen wir noch das Rasenobjekt. Dieses wird im Wesentlichen aus vielen Grashalmen bestehen. Beispielsweise so: Class Rasenstück Länge As Integer Breite As Integer Public Grashalme List As Grashalm

'Diese Liste macht das 'Rasenstück 'zur Containerklasse

Sub New(in_Länge As Single, in_Breite As Single, _ in_Grashalme List As Grashalm) Höhe = in_Länge Breite = in_Breite Erase in_Grashalme Forall x In in_Grashalme Set Grashalme(Listtag(x)) = x End Forall End Sub Sub Schneiden(in_SchnittHöhe As Integer) Forall halm in Grashalme halm.Höhe = in_SchnittHöhe End Forall End Sub End Class

Der interessante neue Aspekt an dieser Klasse ist in der Eigenschaftsvariablen »Grashalme« begründet. Da in dieser Liste einzelne Objekte vom Typ Grashalm abgelegt werden können, haben wir der Klasse Rasenstück auf diese Weise Unterobjekte zugeordnet. Man nennt diese Beziehung zwischen einem Ober- und einem Unterobjekt auch eine »Hat-Beziehung«. Das Oberobjekt vom Typ Rasenstück hat also einige Unterobjekte vom Typ Grashalm. Dass wir hier eine Script-Liste gewählt haben, liegt nur daran, dass wir einen Container für viele Unterobjekte benötigen. Man sagt auch, es handelt sich um eine 1:n-Beziehung. Bei einer 1:1-Beziehung hätte auch eine einfache Objektvariable statt der Liste ausgereicht.

Benutzerdefinierte Containerklassen

215

Objekte können in unterschiedlicher Hat-Beziehung zu anderen Objekten stehen. So gibt es beispielsweise die 1:n-Beziehung und die 1:1-Beziehung. In diesem Fall wird die Liste der Grashalme durch die New-Methode gefüllt. Man hätte genauso gut eine Methode »AddGrashalm« wählen können, die dann nach der Objektinstanziierung die Grashalme einzeln übernommen hätte. Daher hierzu ein kurzes Codestück: Class Rasenstück ... Public Grashalme List As Grashalm Zähler As Long Sub New (in_Länge As Single, in_Breite As Single) Höhe = in_Länge Breite = in_Breite End Sub Sub AddGrashalm(in_Grashalm As Grashalm) Zähler = Zähler + 1 Set Grashalme(Zähler) = in_Grashalm End Sub ... End Class

Der Einsatz des Zählers dient der Unterscheidung der einzelnen Listenelemente. Leider arbeitet dieser Container, der von LotusScript zur Verfügung gestellt wird, nicht ohne solche »Listtags«. Wollen Sie eine namenlose Speicherung erreichen, so müssen Sie selbst eine entsprechende Datenstruktur bauen, z. B. einen Heap. Wie man solche Strukturen in LotusScript verwirklichen kann, betrachten wir etwas später. Als Listtag werden normalerweise Stringwerte verlangt. Allerdings können auch Zahlenwerte übergeben werden, da diese implizit in Strings umgewandelt werden. Analog haben Container-Klassen im Allgemeinen weitere Standard-Methoden wie »DeleteObject«, »GetObject«. Auch eine Property »HasObject« kann sehr nützlich sein. Wenn man Container-Klassen baut (also Klassen, deren Objekte eine Anzahl anderer Objekte aufnehmen können), so ist es i. A. zu empfehlen, solche StandardMethoden von vornherein vorzusehen. Man wird sie nicht immer im ersten Moment benötigen. Aber irgendwann wird man sie dann doch vermissen. Hier zeigt sich wieder, dass Klassen bzw. Objekte vor Erstellung eines damit arbeitenden Programmes zunächst getrennt betrachtet und hinsichtlich ihrer Objekteigenschaften komplettiert werden sollten.

216

Objektorientierte Programmierung unter LotusScript

Containerklassen stellen i. A. Standardmethoden zur Verfügung, die einen gezielten Zugriff auf die beinhalteten Objekte ermöglichen. Solche Methoden heißen beispielsweise GetObject, DeleteObject, AddObject, GetFirstObject, GetNextObject usw. Object ist hier als ein Platzhalter für den Namen des Typs der tatsächlich beinhalteten Objekte zu sehen. Eine Oberklasse kann auf ihre Unterklassen und deren Eigenschaften und Methoden zugreifen. Dies gilt allerdings nur für die Eigenschaften und Methoden, die Public deklariert sind (egal ob implizit oder explizit). Demgegenüber kann eine abgeleitete Klasse auf alle Eigenschaften und Methoden von Superklassen zugreifen. Dies gilt also selbst für Private deklarierte Elemente. Eine Subklasse (abgeleitete Klasse) kann in LotusSript auch auf die privaten Elemente einer Superklasse (= Oberklasse oder Basisklasse) zugreifen. Dies ist bei lediglich in irgendeiner Hat-Beziehung stehenden Objekten nicht möglich. Zum Schluss dieses Abschnitts optimieren wir unsere Klasse Rasenstück noch ein wenig. Denn die einzelnen Grashalme interessieren uns nur wenig. Wir erwarten, dass ein Rasenstück seine Grashalme selbst kennt und verwaltet. Lediglich die Menge an Grashalmen, die so ein Stück beinhaltet, wollen wir noch vorgeben können: Class Rasenstück Länge As Integer Breite As Integer Public Grashalme List As Grashalm

'Diese Liste macht das 'Rasenstück 'zur Containerklasse

Sub New(in_Länge As Single, in_Breite As Single, _ nMenge As Long, nHöhe As Integer) Dim i% Höhe = in_Länge Breite = in_Breite For i% = 1 To nMenge Dim oHalm As New Grashalm(nHöhe) Set Grashalme(i%) = oHalm Next End Sub Function Höhe ... End Function ... End Class

Ein Rasenmäher in Aktion

217

17.20 Ein Rasenmäher in Aktion Um ein Stück Rasen zu mähen, benötigen wir einen Gärtner, einen Mäher und den zu schneidenden Rasen. Da wir im metrischen System bleiben wollen, entscheiden wir uns für einen bayrischen Gärtner: Dim oGärtner As New BayerischerGärtner oGärtner.Schrittgeschwindigkeit = 2 Dim oMäher As New Elektromäher(50) oMäher.Schnitthöhe = 3

'2 km/h 'Schnittbreite 50 cm '3 cm

Den Rasen vereinfachen wir ein wenig. Wir gehen davon aus, dass er sehr schmal und dafür lang ist. Er bestehe aus lauter hintereinander gelegten Stücken, die einen Meter lang und genauso breit sind, wie die Schnittbreite des Mähers. Auf diese Weise kann sich der Gärtner eindimensional fortbewegen. Da wir nur das Prinzip zeigen möchten, erhält jedes Rasenstück auch nur einen einzigen Grashalm. Der Rasen sei genau 1000 m lang (wie gut, dass wir diese Arbeit dem elektronischen Gärtner überlassen können). Außerdem bauen wir noch eine Funktion ein, die uns gestattet, die Länge einer bestimmten Stelle im Rasen zu prüfen. Damit können wir feststellen, wo bereits gemäht wurde und wo noch nicht: Class Rasen Public Stücke List As Rasenstück Position As Long Sub AddStück (oStück As Rasenstück) Position = Position + 1 Set Stücke(Position) = oStück End Sub Function GetHöhe(nPosition as Long) Dim oStück AS Rasenstück Set oStück = Stücke(nPosition) GetHöhe = oStück.Höhe End Function End Class Dim oRasen As New Rasen For i% = 0 To 999 'Erzeuge Stücke von 1 m Länge, 0,5 m Breite, mit 'je 100 Grashalmen und 10 cm Höhe Dim oStück As New Rasenstück(1, 0.5, 100, 10) Call oRasen.AddStück(oStück) Next

Der Gärtner mäht eine Viertelstunde, bevor er eine kurze Pause einlegt: Call oGärtner.Mähen(oRasen, oMäher, 0.25)

218

Objektorientierte Programmierung unter LotusScript

Die Methode Mähen hatten wir noch nicht definiert. Da alle Gärtner in der Lage sind, Rasen zu schneiden, definieren wir sie zweckmäßigerweise in der Basisklasse Gärtner. Wir möchten aus Vereinfachungsgründen eine Funktion haben, die einen Rasen jeweils bei Position 0 zu mähen beginnt, und die Strecke kürzt, die seiner Schrittgeschwindigkeit und der Mähdauer entspricht: Class Gärtner ... Sub Mähen(oRasen As Rasen, oMäher As Rasenmäher, _ nDauer As Single) 'Mähstrecke in m bestimmen (= Anzahl der Rasenstücke) Dim nMähStrecke As Long nMähStrecke = nDauer * Schrittgeschwindigkeit * 1000 If Not oMäher.IstAmLaufen Then _ Error nERR_MÄHER_PROBLEM, "Mäher läuft nicht" Dim i% For i% = 1 To nMähStrecke oMäher.Schneiden oRasen.Stücke(i%) Next End Sub ... End Class

Wie hoch ist jetzt der Rasen auf dem ersten Stück? Auf dem Abschnitt an Position 500 (499 - 500 m)? Und wie hoch an der Position 501 (500 m – 501 m)? MessageBox oRasen.GetLänge(1) MessageBox oRasen.GetLänge(500) MessageBox oRasen.GetLänge(501)

Die Ausgaben lauten: 3, 3, 10 Wir sehen, wie selbst komplexe Abläufe unter OOP starkt vereinfacht werden können. Vor allem hat man die Abläufe i. A. viel besser im Griff, weil Objekte in einem guten Design häufig eine konkrete Anschauung vermitteln, wie sie arbeiten. Im Umgang mit ihnen hat man nur mit deren unmittelbaren Funktionalitäten zu tun. Wie das Objekt die jeweilige Funktionalität bewerkstelligt, mit welchen weiteren Objekten es dazu in anderen Ebenen kommunizieren muss und welche Reaktionen darauf erfolgen, interessiert den Entwickler dann kaum noch. Er verlässt sich darauf, dass jedes Objekt »weiss«, wie es die angebotene Funktionalität (Methode) umzusetzen hat. Natürlich läuft bei einer funktionalen Analyse und Programmierung letztlich das Gleiche ab. Allerdings ist der Aufbau solcher Programme wesentlich komplexer. Es ist kaum möglich, auf höhere Ebenen zu abstrahieren, die dennoch stark anschaulichen Charakter haben und einen so einfachen und intuitiven Umgang mit den zusammenwirkenden Programmteilen ermöglichen.

Virtuelle Funktionen und Mächtigkeit von LotusScript contra C++ u. a.

219

17.21 Virtuelle Funktionen und Mächtigkeit von LotusScript contra C++ u. a. Ein wichtiges Argument von Gegnern der OOP unter LotusScript ist: »LotusScript bietet keine virtuellen Funktionen. Also ist LotusScript nicht objektorientiert.« Selbst wenn es das Konzept der virtuellen Funktionen nicht gäbe, so wäre LotusScript gleichwohl objektorientiert. Den Beweis dafür haben wir in diesem Kapitel bereits zur Genüge erbracht, denn wir haben vielerlei Objekte erzeugt. Dabei haben wir ausgiebig vom Mechanismus der Vererbung Gebrauch gemacht. Die Frage kann daher höchstens sein: Hat LotusScript die gleiche Mächtigkeit wie C++ und andere objektorientierte Sprachen, was die Werkzeuge für die OOP betrifft? Und hier können wir klar sagen: Dies hat LotusScript nicht! Wozu auch? LotusScript und C++ haben einen sehr unterschiedlichen Anspruch zu erfüllen. C++ bietet sehr ausgefeilte Programmiertechniken für alle möglichen Anwendungsgebiete. Dadurch ist C++ auch nicht ganz einfach zu erlernen, was jeder Anfänger bestätigen wird. Im Gegensatz dazu ist LotusScript im Notes-Kontext in erster Linie dazu gedacht, Notes-Anwendungen schnell und einfach programmieren zu können. Und das kann man! Dabei wird der Entwickler vor den vielen Fehlern, denen er in C++ aufgrund der umfangreichen Möglichkeiten zur Zeigermanipulation immer wieder begegnet, von vornherein bewahrt. Wem die Möglichkeiten von LotusScript dennoch nicht genügen, der kann ohne weiteres die Möglichkeiten von C++ über die API-Programmierung ausnutzen. Hier können wir mittels C++-API und auch C-API viele Dinge erreichen, die unter LotusScript definitiv nicht möglich sind. Beispielsweise das Schreiben von Server-Tasks, Abfangen des Notes-Login-Prompts usw. Mit der API erzeugte Funktionalitäten lassen sich dann sogar in LotusScript einbinden. Eine weitere mächtige Möglichkeit ist die Programmierung von LSX-Klassen. Mit dem LSX-Toolkit von Notes lassen sich mittels C/C++-API Klassen konstruieren, die dann über die LSX-Schnittstelle vollständig in LotusScript eingebunden werden können. Sie erscheinen dort wie Domino-Klassen. Kein Wunder; schließlich bedienen sich Domino-Klassen selbst des LSX-Mechanismus. LotusScript bietet durch diese zahlreichen Schnittstellen viele Möglichkeiten, die Stärken der verschiedenen Sprachen gezielt auszunutzen. Zudem kann man spätestens ab Notes R 5 auf die ebenfalls mögliche Java-Programmierung umsteigen. Allerdings muss man einschränkend sagen, dass sich nur Teile von Notes über Java ansprechen und programmieren lassen. Genauso wie LotusScript nach wie vor nicht in allen Designelementen von Notes verwendet werden kann (z. B. Spaltenformeln von Ansichten). Wie ist es nun mit den virtuellen Funktionen? Gibt es sie oder gibt es sie nicht? Es gibt sie! Allerdings nur implizit. Und man kann über sie auch keine rein abstrakten Klassen erzeugen, wie dies unter C++ der Fall ist. Aber wenn man virtuelle Funktionen zunächst mal hauptsächlich unter dem Aspekt des Polymorphismus betrachtet, dann gibt es auch unter LotusScript virtuelle Funktionen.

220

Objektorientierte Programmierung unter LotusScript

Es gibt in LotusScript keine virtuellen Funktionen im strengen Sinne. Insbesondere lassen sich dadurch auch keine rein abstrakten Klassen implementieren. Allerdings lassen sich in Hinblick auf den Polymorphismus auch in LotusScript Methoden implementieren, die sich wie virtuelle Funktionen verhalten.

17.22 Polymorphismus Polymorphismus ist die Fähigkeit, den Typ eines Objektes zur Laufzeit dynamisch zu erkennen. Und zwar, ohne dass der Programmierer ein spezielles Typkennzeichen setzt. Der Nutzen des Polymorphismus liegt darin, dass zur Laufzeit die dem speziellen Objekt zugeordnete Methode oder Eigenschaft angesprochen wird. Der Polymorphismus baut auf das Konzept der virtuellen Funktionen auf. Um diesen Sachverhalt besser zu verstehen, betrachten wir wieder ein Beispiel. Wir stellen uns vor, jemand übergibt uns ein Objekt, das in irgendeiner Weise einen Rasenmäher darstellt. Wir wissen aber nicht, was für ein Rasenmäher es ist. Wir möchten dies ohne genaueres Hinsehen erfahren können. Dazu bauen wir unsere Rasenmäher-Klassen so um, dass sie den Polymorphismus unterstützen. Zunächst nehmen wir eine entsprechende Änderung an der Klasse Rasenmäher vor: Class Rasenmäher As Fahrgestell ... Sub Print Print "Ich bin ein Rasenmäher." End Sub ... End Class Class Elektromäher As Rasenmäher HatStrom As Integer IstKabelAnStrom As Integer Property Get IstKabelGebrochen As Integer IstKabelGebrochen = _ (IstKabelAnStrom And Not HatStrom) End Property ... Sub Print Print "Ich bin ein Elektromäher."

Polymorphismus

221

If IstKabelGebrochen Then Print "Mein Kabel ist gebrochen." Else Print "Mein Kabel ist OK." End If End Sub ... End Class Class LuftkissenMäher As Fahrgestell ... Sub Print Print "Ich bin ein Luftkissenmäher." End Sub ... End Class

Anschließend schreiben wir in einem Agenten oder auch in einem Button einer Maske eine Funktion, die ein Rasenmäher-Objekt übernehmen kann. Sie soll die Print-Funktion des Rasenmäher-Objektes anstoßen: Sub AnalysiereRasenmäher(oMäher As Rasenmäher) oMäher.Print End Sub

Was wird nun passieren? Angenommen wir übergeben ein Objekt vom Typ Rasenmäher, dann wird die Analysefunktion den Text »Ich bin ein Rasenmäher« auswerfen. Übergeben wir dagegen ein Objekt vom Typ Elektromäher, so wird die Botschaft sein: »Ich bin ein Elektromäher.« Und falls es zutrifft, wird auch noch die folgende Meldung hinterhergeschoben: »Mein Kabel ist gebrochen.« Analog wirft die Analysefunktion für einen Luftkissenmäher die Nachricht »Ich bin ein Luftkissenmäher.« aus. Diese Erscheinung ist der beschriebene Polymorphismus. Ohne dass wir uns irgendwelche Gedanken machen mussten, hat der Compiler selbst erkannt, welches Objekt der Funktion übergeben wurde, und er hat die zugehörige Print-Funktion angestoßen.

222

Objektorientierte Programmierung unter LotusScript

Die Print-Funktion der Basisklasse, in der sie das erste Mal deklariert wurde, ist somit eine virtuelle Funktion, ohne dass dies explizit angegeben werden muss. Dafür gibt es in LotusScript auch kein Schlüsselwort. Polymorphismus ist die Fähigkeit, beim Aufruf einer Objektmethode zu unterscheiden, zu welcher Hierarchiestufe das übergebene Objekt in einer Vererbungshierarchie gehört und die dazu passende Methode aufzurufen.

17.22.1 Variantvariablen für Pseudopolymorphismus Wir könnten den gleichen Effekt wie im letzten Abschnitt erzielen, indem wir den Funktionskopf der AnalysiereRasenmäher-Funktion leicht ändern: Sub AnalysiereRasenmäher(vMäher As Variant) vMäher.Print End Sub

Der kleine Unterschied ist, dass hier als Parameter kein Objekt vom Typ Rasenmäher spezifiziert wurde. Stattdessen lässt der Variant alle möglichen Argumente zu. Dies ist allerdings recht gefährlich, da zur Compilierzeit nicht erkannt werden kann, ob der Aufruf vMäher.Print überhaupt möglich ist. Wählen Sie eine solche Konstruktion, so kann es sein, dass Sie erst zur Laufzeit durch eine Meldung erfahren, dass Sie gerade versuchen, auf eine nicht existente Methode zuzugreifen. Vorteile hat der Einsatz einer Variantvariablen, wenn Sie unterschiedliche Objekte übergeben möchten, die nicht von einer gemeinsamen Basisklasse abgeleitet sind. Dann lässt sich der Mechanismus des Polymorphismus nicht nutzen, auch wenn sie beide Methoden mit gleichem Namen anbieten. Wenn Sie also beispielsweise noch eine Klasse Baum definieren, die ebenfalls eine Methode Print aufweist, dann können Sie auch diese einer Prozedur AnalysiereObjekt übergeben, ohne dass die Klassen eine gemeinsame Basisklasse benötigen würden: Class Baum Sub Print Print "Ich bin ein Baum." End Sub End Class Sub AnalysiereObjekt(vObjekt As Variant) vObjekt.Print End Sub

Man kann Variant-Variablen einsetzen, um auf namensgleiche Methoden unterschiedlicher Objekte mit dem gleichen Codestück zugreifen zu können, ohne dass die automatische Typprüfung des Compilers eine Fehlermeldung generiert. Man sollte sich aber der Gefahren der daduch unterlaufenen Typprüfung bewusst sein.

Datenstrukturen unter LotusScript

223

17.23 Datenstrukturen unter LotusScript Etwas weiter oben haben wir angekündigt, dass noch gezeigt wird, wie man unter LotusScript Datenstrukturen wie binäre Bäume, verkettete Listen, Heaps usw. erstellen kann. Motivation Sie werden vermutlich nicht gleich am Anfang vor die Herausforderung gestellt, eigene Datenstrukturen in LotusScript entwerfen zu müssen. Allerdings entstehen zurzeit viele Notes-Anwendungen, die verschiedene Schnittstellen zu anderen Systemen unterhalten müssen. Wenn vor der Übergabe die Daten zunächst in Notes zusammengesucht werden müssen, kann es sein, dass Sie diese gerne in entsprechenden möglichst performant arbeitenden Strukturen ablegen möchten. Oder Sie möchten gewisse Sortierungen vornehmen, ohne dass Sie dabei auf Ansichten zurückgreifen können. Dann benötigen Sie zum Aufbau einer schnellen Sortierfunktion die zum Algorithmus passenden Datenstrukturen. Ein dritter Fall, der sich zum Gebrauch eigener Datenstrukturen anbietet, ist der Wunsch, Werte in einer Struktur abspeichern zu können, ohne dazu irgendein Unterscheidungskriterium angeben zu müssen, wie Sie es bei einer LotusScriptListe tun müssten. Spätestens zu einer solchen Zeit werden Sie dieses Kapitel wieder zu Rate ziehen wollen. Und es ist gut, schon im Vorfeld die Möglichkeiten, die LotusScript zu diesem Thema bietet, zu kennen. Die Kernfrage Der wesentliche Aspekt, der geklärt werden muss, um eigene Datenstrukturen zu erzeugen, ist: Wie kann man in LotusScript Objekte (per Zeiger) miteinander verketten? Nun, Zeiger werden unter LotusScript durch Objektreferenzen bzw. Objektvariablen repräsentiert. Zudem lassen sich Objekte rekursiv definieren. Das heißt, man kann innerhalb des Gültigkeitsbereichs von Klassen dieselben Klassen verwenden. Verschiedene Datenstrukturen Verkettete Liste Ein Element einer einfach verketteten Liste ließe sich beispielsweise so definieren: Class ListElement Public Nachfolger As ListElement Public Value As Variant End Class

224

Objektorientierte Programmierung unter LotusScript

Die Eigenschaft Nachfolger speichert die Referenz auf das Nachfolgeelement, die Variable Wert den Wert des Listenelements. Die Operationen auf dieser Struktur können entweder als Funktionen und Prozeduren in das gleiche Modul wie die Klassendefinition gelegt werden (also zum Beispiel in die gleiche Script-Bibliothek). Oder Sie legen eine weitere Klasse an, die die Datenstruktur an sich repräsentiert und die einerseits die Listenelemente referenziert und andererseits die Operationen auf der Struktur als ihre Methoden anbietet. Dieses ist der elegantere Weg und wir wollen ihn kurz demonstrieren. Um dem Beispiel etwas mehr Praxisbezug zu geben, demonstrieren wir es gleich bei einer anderen Datenstruktur, die sich in diesem Fall einer Liste bedienen soll, und zwar konstruieren wir einen Stack (Keller). 1. Stack (LIFO-Struktur) Class Stack Private Ende As ListElement Function IstLeer As Integer If Ende Is Nothing Then IstLeer = True End Function Sub Push(vValue As Variant) Dim oElement As New ListElement If IsObject(vValue) then Set oElement.Value = vValue Else oElement.Value = vValue End If End Sub Sub Pop If Not IstLeer Then Dim oEnde As ListElement Set oEnde = Ende Set Ende = oEnde.Nachfolger Delete oEnde End If End Sub Function Top As Variant If IsObject(Ende.Value) then Set Top = vValue Else Top = vValue End If End Function End Class

Praktisches Beispiel für Objekte aus dem Kontaktmanagement

225

Dieser Stack verfügt über alle Methoden, die ein Stack benötigt. Die im Stack gespeicherten Werte werden in einer verketteten Liste aufbewahrt. Da wir im Stack immer nur auf das Ende der Liste zugreifen müssen, wird dieses Ende über die Eigenschaftsvariable Ende »festgehalten«, also referenziert. Dadurch, dass wir zur Aufnahme der zu speichernden Werte in den Listenelementen einen Variant gewählt haben, sind wir in der Lage, sehr unterschiedliche Arten von Werten in dem Stack abzulegen: skalare Werte, Arrays, Objekte, LotusScriptListen usw. Weitere Datenstrukturen Die bisher behandelten Beipiele müssten ausreichen, um

Ihnen einen Einblick zu gewähren, wie Sie unter LotusScript Datenstrukturen erzeugen können. Ideen für weitere Strukturen können Sie der einschlägigen Literatur entnehmen, zum Beispiel dem Klassiker »Algorithmen in C« von R. Sedgewick aus dem Addison-Wesley-Verlag, oder auch der für C++ angepassten Version »Algorithmen in C++«.

17.24 Praktisches Beispiel für Objekte aus dem Kontaktmanagement Anschauliche Objekte aus dem Kontaktmanagement sind zum Beispiel die Personen und die Kontakte zu diesen Personen. Es bietet sich an, eine Klasse Person zu definieren, die die Adressdaten aufnimmt und auf eine Liste aller Kontakte verweist. Die Kontakte selbst werden auch als Objekte modelliert. Mit Hilfe dieser beiden Klassen könnten wir beispielsweise mehrere Personen mit deren Kontakten komfortabel im Arbeitsspeicher halten und komfortabel darauf zugreifen, ohne dass wir die Kontakte jedesmal wieder über eine Ansicht suchen müssten. (Die Suche über eine Ansicht ist zwar schon recht schnell, aber die Referenzierung innerhalb des Objektes kann noch schneller sein.) Der Hauptnutzen ist aber, dass die Daten in übersichtlichen und anschaulichen Strukturen bearbeitet werden können. Wir konstruieren zunächst die Klasse Kontakt: Class Kontakt Public Public Public Public Public Public End Class

Zeitpunkt As Variant Thema As String Kontaktart As String Ergebnis As String NächsteAktion As String NächsterZeitpunkt As String

Dann kümmern wir uns um die Klasse Person: Class Person Nachname As String Vorname As String

226

Objektorientierte Programmierung unter LotusScript

Titel As String Strasse As String PLZ As String Ort As String Firma As String Kontakte List As Kontakt Sub AddKontakt(oKontakt As NotesDocument) ... End Sub End Class

In der Eigenschaftsvariablen Kontakte werden alle Kontakte zur Person abgespeichert. Der Listtag zu einem Kontakt könnte beispielweise eine Kombination aus Namen des Kontaktierten, Datum und Art des Kontakts sein. Da die Kontakte schon über die Hat-Beziehung der Person des Kontaktierten zugeordnet werden, genügt als Schlüssel die Kombination Datum und Kontaktart: Sub AddKontakt(oKontNote As NotesDocument) 'In der Realität müsste hier zunächst geprüft werden, 'ob es sich bei dem Dokument wirklich um einen Kontakt 'handelt. Lassen wir als für unser Beispiel unwesentlich 'weg. 'Schlüssel bilden Dim sKey As String sKey = oKontNote.Zeitpunkt(0) & "," & _ oKontNote.KontaktArt(0) 'Kontaktobjekt anlegen Dim oKontakt As New Kontakt oKontakt.Zeitpunkt = oKontNote.Zeitpunkt oKontakt.Thema = oKontNote.Thema oKontakt.Kontaktart = oKontNote.KontaktArt oKontakt.Ergebnis = oKontNote.Ergebnis oKontakt.NächsteAktion = oKontNote.NächstAktion oKontakt.NächsterZeitpunkt = oKontNote.NächsterZeitpunkt 'Der internen Liste hinzufügen Set Kontakte(sKey) = oKontakt End Sub

Allerdings ist auch diese Schlüssel-Kombination nicht unbedingt eindeutig und so wird man sich eher für einen anderen Schlüssel entscheiden, wahrscheinlich einen numerischen Schlüssel, der in der relationalen Datenbank gepflegt und in den Notes-Dokumenten hinterlegt wird. Bis jetzt besteht der Hauptnutzen der beiden Klassen darin, dass wir zusammengehörige Daten übersichtlich strukturiert verwalten können. Da mag man noch

Praktisches Beispiel für Objekte aus dem Kontaktmanagement

227

sagen: Das kann ich auch anders lösen, zum Beispiel mit Hilfe von benutzerdefinierten Datentypen. Allerdings wird es jetzt noch einmal richtig spannend. Angenommen, Sie möchten dafür sorgen, dass die Richtigkeit der Daten über Script geprüft wird. Also, die über die einzelnen Felder einer Notes-Maske verstreuten Validierungsformeln sagen Ihnen nicht so recht zu. Sie möchten es übersichtlich und bequem haben. Kein Problem! Konstruieren Sie eine Validierungsklasse: Class Validierung Function Text(sText As String, nMaxLänge As Long) As Integer Text = (Len(sText)