feat: content import system - Markdown parser, importer, 7 decks + 3 tutorials + 5 cheatsheets
Dieser Commit ist enthalten in:
Ursprung
1c59b667f2
Commit
6a504254b0
17 geänderte Dateien mit 2658 neuen und 0 gelöschten Zeilen
289
edu/content/tutorials/01-omnis-kickstart.md
Normale Datei
289
edu/content/tutorials/01-omnis-kickstart.md
Normale Datei
|
|
@ -0,0 +1,289 @@
|
|||
# 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
|
||||
Laden …
Tabelle hinzufügen
Einen Link hinzufügen
In neuem Issue referenzieren