289 Zeilen
7,5 KiB
Markdown
289 Zeilen
7,5 KiB
Markdown
# Tutorial 1: Omnis Kickstart - Von Null zum ersten Verstaendnis
|
|
|
|
**Dauer**: ca. 30 Minuten
|
|
**Voraussetzung**: Grundkenntnisse in irgendeiner Programmiersprache (JS, Python, VB, C#, Java...)
|
|
**Ziel**: Du verstehst die Grundstruktur von Omnis und kannst einfachen Code lesen
|
|
|
|
---
|
|
|
|
## 1. Was ist Omnis Studio?
|
|
|
|
Stell dir vor: Visual Studio + Access + Node.js in einem Tool. Das ist Omnis.
|
|
|
|
| Was du kennst | Omnis-Aequivalent |
|
|
|---------------|-------------------|
|
|
| VS Code / IDE | Omnis Studio IDE (integriert) |
|
|
| .sln / Projekt | Library (.lbs Datei) |
|
|
| Klassen / Dateien | Classes (in der Library) |
|
|
| Funktionen | Methods |
|
|
| npm packages | Externe Libraries |
|
|
| HTML/React | Windows (Desktop) oder Remote Forms (Web) |
|
|
| SQL Workbench | Eingebauter SQL Browser |
|
|
|
|
**Der groesste Unterschied:** Omnis ist eine **Kommando-basierte Sprache**, keine Expression-basierte. Jede Zeile beginnt mit einem Befehl.
|
|
|
|
---
|
|
|
|
## 2. Die Sprache: Befehle statt Ausdruecke
|
|
|
|
### In JavaScript:
|
|
```javascript
|
|
let name = "Harry"; // Deklaration + Zuweisung
|
|
let total = price * quantity; // Ausdruck
|
|
console.log(name); // Funktionsaufruf
|
|
```
|
|
|
|
### In Omnis:
|
|
```omnis
|
|
Calculate lName as "Harry" ;; Zuweisung mit dem Befehl "Calculate"
|
|
Calculate lTotal as lPrice * lQty ;; Berechnung mit "Calculate"
|
|
OK message {[lName]} ;; Nachricht anzeigen (wie alert/console.log)
|
|
```
|
|
|
|
**Merke:**
|
|
- `Calculate` = "Berechne und weise zu"
|
|
- Variablen haben Praefix: `l` = lokal, `i` = Instanz, `t` = Task, `p` = Parameter
|
|
- `;;` oder `#` fuer Kommentare
|
|
- `{[variable]}` fuer String-Interpolation in Texten
|
|
|
|
---
|
|
|
|
## 3. Variablen: Das Praefix-System
|
|
|
|
In Omnis hat JEDE Variable einen Praefix, der ihren **Scope** anzeigt:
|
|
|
|
| Praefix | Scope | Wie in JS/Python |
|
|
|---------|-------|-----------------|
|
|
| `l` | Lokal (nur diese Methode) | `let x` / lokale Variable |
|
|
| `i` | Instanz (dieses Objekt) | `this.x` / `self.x` |
|
|
| `t` | Task (globale Session) | Globale Variable |
|
|
| `p` | Parameter (Eingabe) | Funktionsparameter |
|
|
| `c` | Klassen-Variable (statisch) | `static` / Klassenvariable |
|
|
|
|
```omnis
|
|
# Beispiel: Methode mit Parameter und lokaler Variable
|
|
Calculate lFullName as con(pFirstName, " ", pLastName)
|
|
Calculate iCustomerName as lFullName ;; In Instanz-Var speichern
|
|
```
|
|
|
|
**Uebung 1:** Was ist der Scope dieser Variablen?
|
|
- `lCounter` -> ???
|
|
- `iOrderList` -> ???
|
|
- `tCurrentUser` -> ???
|
|
- `pAmount` -> ???
|
|
|
|
<details>
|
|
<summary>Loesung</summary>
|
|
|
|
- `lCounter` -> Lokal (nur in der aktuellen Methode)
|
|
- `iOrderList` -> Instanz (gehoert zum Objekt)
|
|
- `tCurrentUser` -> Task (global in der Session)
|
|
- `pAmount` -> Parameter (wurde der Methode uebergeben)
|
|
|
|
</details>
|
|
|
|
---
|
|
|
|
## 4. Datentypen
|
|
|
|
| Omnis Typ | Konstante | Wie in JS |
|
|
|-----------|-----------|-----------|
|
|
| Character (String) | kCharacter | string |
|
|
| Integer | kInteger | number (int) |
|
|
| Number (Dezimal) | kNumber | number (float) |
|
|
| Boolean | kBoolean | boolean |
|
|
| Date | kDate | Date |
|
|
| List | kList | Array of Objects |
|
|
| Row | kRow | Object / Record |
|
|
| Object Reference | kObjectref | Referenz auf ein Objekt |
|
|
|
|
```omnis
|
|
# Variablen werden im IDE deklariert (nicht im Code!)
|
|
# Im IDE: Variable "lName" anlegen, Typ = Character
|
|
# Dann im Code:
|
|
Calculate lName as "Harry"
|
|
Calculate lAge as 42
|
|
Calculate lActive as kTrue
|
|
```
|
|
|
|
**Wichtig:** Variablen werden im Omnis IDE deklariert (wie in VB mit Dim), NICHT im Code!
|
|
|
|
---
|
|
|
|
## 5. Kontrollstrukturen
|
|
|
|
### If / Else
|
|
```omnis
|
|
;; JavaScript: if (age >= 18) { ... } else { ... }
|
|
;; Omnis:
|
|
If lAge >= 18
|
|
OK message {Erwachsen}
|
|
Else
|
|
OK message {Minderjaehrig}
|
|
End If
|
|
```
|
|
|
|
### For-Schleife
|
|
```omnis
|
|
;; JavaScript: for (let i = 1; i <= 10; i++) { ... }
|
|
;; Omnis:
|
|
For lCounter from 1 to 10 step 1
|
|
Calculate lSum as lSum + lCounter
|
|
End For
|
|
```
|
|
|
|
### While-Schleife
|
|
```omnis
|
|
;; JavaScript: while (condition) { ... }
|
|
;; Omnis:
|
|
While lCounter < 100
|
|
Calculate lCounter as lCounter + 1
|
|
End While
|
|
```
|
|
|
|
### Switch/Case
|
|
```omnis
|
|
;; JavaScript: switch(status) { case 'A': ... }
|
|
;; Omnis:
|
|
Switch lStatus
|
|
Case 'A'
|
|
# Aktiv
|
|
Case 'I'
|
|
# Inaktiv
|
|
Default
|
|
# Unbekannt
|
|
End Switch
|
|
```
|
|
|
|
**Uebung 2:** Uebersetze diesen JavaScript-Code in Omnis:
|
|
```javascript
|
|
let sum = 0;
|
|
for (let i = 1; i <= 100; i++) {
|
|
if (i % 2 === 0) {
|
|
sum += i;
|
|
}
|
|
}
|
|
console.log("Summe: " + sum);
|
|
```
|
|
|
|
<details>
|
|
<summary>Loesung</summary>
|
|
|
|
```omnis
|
|
Calculate lSum as 0
|
|
For lI from 1 to 100 step 1
|
|
If mod(lI, 2) = 0
|
|
Calculate lSum as lSum + lI
|
|
End If
|
|
End For
|
|
OK message {Summe: [lSum]}
|
|
```
|
|
|
|
</details>
|
|
|
|
---
|
|
|
|
## 6. Methoden (Funktionen)
|
|
|
|
In Omnis sind Methoden immer Teil einer Klasse (wie in Java/C#, nie wie freie Funktionen in JS/Python).
|
|
|
|
### Methode aufrufen:
|
|
```omnis
|
|
;; JavaScript: let result = myObject.calculate(10, 20);
|
|
;; Omnis:
|
|
Do iMyObject.$calculate(10, 20) Returns lResult
|
|
```
|
|
|
|
### Das `Do` Kommando:
|
|
- `Do` = "Fuehre aus" (wie ein Funktionsaufruf)
|
|
- `$methodname` = Dollar-Praefix fuer Methoden
|
|
- `Returns lVar` = Fange den Rueckgabewert auf
|
|
|
|
### Methode definieren (im IDE):
|
|
Methoden werden im Omnis IDE erstellt, nicht im Code deklariert.
|
|
```omnis
|
|
# Methode "$calculate" mit Parametern pA, pB:
|
|
Calculate lResult as pA + pB
|
|
Quit method lResult ;; = return lResult
|
|
```
|
|
|
|
---
|
|
|
|
## 7. Die $-Notation: Das Herz von Omnis
|
|
|
|
Das ist DER groesste Unterschied zu allen anderen Sprachen. In Omnis adressierst du ALLES ueber Dollar-Pfade:
|
|
|
|
```omnis
|
|
;; Objekt-Property lesen:
|
|
Calculate lVal as $cinst.$objs.myField.$contents
|
|
|
|
;; Aufgeschluesselt:
|
|
;; $cinst = aktuelle Instanz (= this)
|
|
;; .$objs = alle UI-Objekte darauf
|
|
;; .myField = das Feld namens "myField"
|
|
;; .$contents = dessen Inhalt
|
|
```
|
|
|
|
### Die wichtigsten $-Pfade:
|
|
|
|
| Pfad | Bedeutung | JS-Aequivalent |
|
|
|------|-----------|----------------|
|
|
| `$cinst` | Aktuelle Instanz | `this` |
|
|
| `$cclass` | Aktuelle Klasse | `this.constructor` |
|
|
| `$clib` | Aktuelle Library | - |
|
|
| `$ctask` | Aktueller Task | - |
|
|
| `$objs` | UI-Objekte auf einem Window | `document.querySelectorAll` |
|
|
| `$contents` | Wert/Inhalt | `.value` / `.textContent` |
|
|
| `$visible` | Sichtbarkeit | `.style.display` |
|
|
| `$enabled` | Aktiv/Inaktiv | `.disabled` |
|
|
|
|
### Property SETZEN (nicht = sondern $assign!):
|
|
```omnis
|
|
;; JavaScript: element.style.display = 'none';
|
|
;; Omnis:
|
|
Do $cinst.$objs.myField.$visible.$assign(kFalse)
|
|
|
|
;; JavaScript: element.value = "Hello";
|
|
;; Omnis:
|
|
Do $cinst.$objs.myField.$contents.$assign("Hello")
|
|
```
|
|
|
|
**Das ist anfangs verwirrend, wird aber schnell natuerlich!**
|
|
|
|
---
|
|
|
|
## 8. Zusammenfassung: Die 7 goldenen Regeln
|
|
|
|
1. **Jede Zeile ist ein Befehl**: `Calculate`, `Do`, `If`, `For`, etc.
|
|
2. **Variablen haben Scope-Praefixe**: `l`okal, `i`nstanz, `t`ask, `p`arameter
|
|
3. **$ ist ueberall**: Methoden, Properties, Pfade - alles mit Dollar
|
|
4. **$assign() zum Setzen**: Nie `=` fuer Notation-Properties
|
|
5. **Variablen werden im IDE deklariert**: Nicht im Code
|
|
6. **`Do` fuer Aufrufe, `Calculate` fuer Berechnungen**: Die zwei Hauptbefehle
|
|
7. **`Returns` / `#F` fuer Ergebnisse**: Rueckgabewerte und der globale Flag
|
|
|
|
---
|
|
|
|
## Mini-Quiz: Teste dich selbst!
|
|
|
|
**Frage 1:** Was macht dieser Code?
|
|
```omnis
|
|
Calculate lList as $cinst.$objs.orderGrid.$dataname
|
|
```
|
|
|
|
**Frage 2:** Wie liest man die `$visible`-Property eines Feldes namens "btnSave"?
|
|
|
|
**Frage 3:** Was ist der Unterschied zwischen `Calculate` und `Do`?
|
|
|
|
<details>
|
|
<summary>Antworten</summary>
|
|
|
|
1. Holt den Datennamen (= gebundene Variable) des UI-Elements "orderGrid" auf der aktuellen Instanz.
|
|
2. `Calculate lVisible as $cinst.$objs.btnSave.$visible`
|
|
3. `Calculate` = Berechnung/Zuweisung, `Do` = Methodenaufruf/Befehlsausfuehrung
|
|
|
|
</details>
|
|
|
|
---
|
|
|
|
**Naechstes Tutorial:** [02 - Notation Mastery](02-notation-mastery.md) - Tiefer eintauchen in das $-Notationssystem
|