# Zentrale Elemente des Skriptings kennenlernen

Skripting wird leichter, sobald du ein paar kleine Muster kennst. In Ninox lesen die meisten Skripte Werte, treffen Entscheidungen oder aktualisieren Daten. Wenn dir diese Grundlagen vertraut sind, werden die tieferen Kapitel deutlich einfacher.

Beziehe dich im Ninox Skripting bei Feld- oder Tabellennamen auf den Internen Namen und nicht auf die Bezeichnung.\
Interne Namen werden automatisch erzeugt und enthalten keine Leerzeichen oder Sonderzeichen.\
Wenn dein Feld die Bezeichnung "First name" hat, lautet der automatisch generierte Interne Name `first_name`.\
Wenn die Bezeichnung deines Felds oder deiner Tabelle Sonderzeichen wie `(` oder `.` enthält, ersetzt der automatisch generierte Interne Name diese durch Unterstriche. Die Feldbezeichnung "My.Customers (New)" hätte zum Beispiel den automatisch generierten Internen Namen `my_customers_new`.\
Du kannst Interne Namen jederzeit ändern. Verwende dabei nur Kleinbuchstaben (a-z), Zahlen (0-9) und Unterstriche.

In diesem Leitfaden lernst du:

* mit Anweisungen und Variablen zu arbeiten
* die richtigen Datentypen auszuwählen
* Operatoren zu verwenden
* integrierte Funktionen aufzurufen
* Logik mit gängigen Skriptmustern zu steuern

{% hint style="info" %}
Wenn du neu im Skripting bist, starte mit einem **Button**. Du klickst ihn, siehst das Ergebnis und passt es schnell an.
{% endhint %}

## **Anweisungen in Ninox verstehen** <a href="#understand-statements-in-ninox" id="understand-statements-in-ninox"></a>

Eine Anweisung ist eine einzelne Instruktion. Ein Skript ist eine Folge von Anweisungen.

Häufige Ninox Anweisungen sind:

<table><thead><tr><th width="286.2421875">Anweisung</th><th>Was sie macht</th></tr></thead><tbody><tr><td><code>let</code></td><td>Definiert eine Variable, die mit einem Wert gefüllt wird</td></tr><tr><td><code>if ... then ... else ... end</code></td><td>Trifft eine Entscheidung anhand von Bedingungen</td></tr><tr><td><code>for ... do ... end</code></td><td>Wiederholt Logik für mehrere Datensätze</td></tr><tr><td><code>while ... do ... end</code></td><td>Wiederholt Logik, solange eine Bedingung wahr bleibt</td></tr><tr><td><code>alert()</code></td><td>Zeigt eine Nachricht an</td></tr><tr><td><code>select()</code></td><td>Findet Datensätze</td></tr><tr><td><code>create()</code></td><td>Erstellt einen Datensatz</td></tr><tr><td><code>delete()</code></td><td>Löscht einen oder mehrere Datensätze</td></tr></tbody></table>

Diese Muster siehst du ebenfalls oft:

* `else if` für mehr als zwei Ergebnisse
* `switch ... case` für feste Optionen
* `select ... where`, um Datensätze zu filtern
* `order by`, um Datensätze zu sortieren
* `for ... in ... do ... end`, um Datensätze oder Listeneinträge zu durchlaufen
* `for ... from ... to ... do ... end`, um einen Zahlenbereich zu durchlaufen

Probiere dieses Skript als erstes aus:

```ninox
alert("Hello! You clicked the button.")
```

Dieses Skript öffnet eine Nachricht, wenn der Button ausgeführt wird.

Darum ist das ein gutes erstes Beispiel:

* Du siehst das Ergebnis sofort.
* Es lässt sich leicht testen.
* Du verstehst schneller, wo die Skriptausgabe erscheint.

<figure><img src="/files/tAbYhK8N5vMWaWQsFYX1" alt=""><figcaption></figcaption></figure>

## **Mit Datentypen und Variablen arbeiten** <a href="#work-with-data-types-and-variables" id="work-with-data-types-and-variables"></a>

Bevor du Logik schreibst, prüfe, mit welcher Art von Wert du arbeitest. Eine Zahl verhält sich anders als Text, ein Datum oder ein Datensatz.

{% hint style="info" %}
Ein Feld ist etwas, das du im **Builder-Modus** hinzufügst. Ein Datentyp ist die Art von Wert, den dein Skript liest, speichert oder zurückgibt.
{% endhint %}

### **Was ist ein Datentyp in Ninox?** <a href="#what-is-a-data-type-in-ninox" id="what-is-a-data-type-in-ninox"></a>

Ein Datentyp definiert, was ein Wert ist. Der richtige Typ sorgt dafür, dass Bedingungen, Berechnungen und Vergleiche zuverlässig funktionieren.

Häufige Zuordnungen von Feldtypen zu Datentypen sind:

* **Text**- und **Mehrzeiliger Text**-Felder geben **Text** zurück
* **Zahl**-Felder geben **Number** zurück
* **Ja/nein**-Felder geben **Yes or No** zurück
* **Datum**-Felder geben **Date** zurück
* **Datum und Uhrzeit**-Felder geben **Timestamp** zurück
* **Uhrzeit**-Felder geben **Time** zurück
* **Dauer**-Felder geben **Timeinterval** zurück
* **Verknüpfungsfelder** geben **Record(s)** zurück

Einige Ausdrücke geben **Array**- oder **JSON**-Werte zurück.

Häufige Datentypen im Skripting sind:

* **Text** für Bezeichnungen, Nachrichten und Namen
* **Number** für Werte, mit denen du rechnest
* **Yes/No** für `true` und `false`
* **Date**, **Time** und **Datetime** für zeitbasierte Logik
* **Record** für einen verknüpften Datensatz
* **Array** für Listen von Werten oder Datensätzen
* **JSON** für strukturierte Schlüssel-Wert-Daten
* **File**, **Location** und **User** für spezielle Werte

### **Was ist eine Variable?** <a href="#what-is-a-variable" id="what-is-a-variable"></a>

Eine Variable speichert einen Wert für die spätere Verwendung. Variablen machen Skripte leichter lesbar, testbar und wiederverwendbar. Wenn du einen Wert speicherst und erneut nutzt, hast du die Kernidee schon verstanden.

{% stepper %}
{% step %}

### Erstelle eine Variable

```ninox
let total := 100;
```

Das speichert die Zahl `100` in der Variable `total`.
{% endstep %}

{% step %}

### Ändere den Wert

```ninox
total := total + 50;
```

Das addiert `50` zum aktuellen Wert. `total` ist jetzt `150`.
{% endstep %}

{% step %}

### Nutze den Wert in einer Bedingung

```ninox
if total > 100 then "High" else "Low" end
```

Das prüft den Wert und gibt `"High"` oder `"Low"` zurück.
{% endstep %}
{% endstepper %}

## **Operatoren zum Rechnen und Vergleichen verwenden** <a href="#use-operators-to-calculate-and-compare" id="use-operators-to-calculate-and-compare"></a>

Operatoren sagen Ninox, was mit Werten passieren soll. Sie helfen dir beim Rechnen, Vergleichen und Kombinieren von Bedingungen.

### **Arithmetische Operatoren**

Verwende arithmetische Operatoren für Berechnungen:

* `+` addiert Werte
* `-` subtrahiert Werte
* `*` multipliziert Werte
* `/` dividiert Werte
* `%` gibt den Rest einer ganzzahligen Division zurück
* `()` ändert die Reihenfolge der Berechnung

Beispiele:

* `let sum := 10 + 5;`
* `let difference := 20 - 8;`
* `let product := 4 * 3;`
* `let ratio := 20 / 4;`
* `13 % 5`
* `(1 + 2) * 3`

### **Vergleichsoperatoren**

Verwende Vergleichsoperatoren, um Werte zu prüfen:

* `=` prüft, ob zwei Werte gleich sind
* `!=` prüft, ob zwei Werte unterschiedlich sind
* `>` prüft, ob ein Wert größer ist
* `<` prüft, ob ein Wert kleiner ist
* `>=` prüft, ob ein Wert größer oder gleich ist
* `<=` prüft, ob ein Wert kleiner oder gleich ist
* `like` prüft, ob Text einen Wert enthält

Beispiele:

* `if status = "Open" then alert("Order is open") end`
* `if status != "Closed" then alert("Still active") end`
* `if total > 100 then alert("High value") end`
* `if age < 18 then alert("Young") end`
* `if total >= 30 then "Card" else "Cash" end`
* `if "Hello" like "el" then "Yes" else "No" end`

### **Logische Operatoren**

Verwende logische Operatoren, um Bedingungen zu kombinieren:

* `and` bedeutet, dass beide Bedingungen wahr sein müssen
* `or` bedeutet, dass nur eine Bedingung wahr sein muss

Beispiele:

* `if is_active and age > 18 then alert("Eligible") end`
* `if status = "Open" or status = "Pending" then alert("Order not closed") end`

### **Weitere Operatoren und Syntax, die du oft siehst**

Diese Bausteine siehst du in vielen Skripten:

* `:=` weist einem Feld oder einer Variable einen Wert zu
* `;` beendet eine Anweisung
* `" "` umschließt Textwerte
* `.` greift auf ein Feld oder einen Wert in einem Datensatz oder JSON-Objekt zu

Wenn du nicht sicher bist, welchen Operator du verwenden sollst, starte mit dieser Regel:

* Verwende `:=`, um Werte zu speichern.
* Verwende `+`, `-`, `*`, `/`, um zu rechnen.
* Verwende `=`, `!=`, `>`, `<`, `>=`, `<=`, um zu vergleichen.
* Verwende `.`, um auf Felder eines Datensatzes zuzugreifen, auch auf Referenzfelder.

## **Integrierte Funktionen verwenden, um Zeit zu sparen** <a href="#use-built-in-functions-to-save-time" id="use-built-in-functions-to-save-time"></a>

Funktionen sind fertige Anweisungen oder Skripte. Du rufst sie auf, statt alles von Grund auf selbst zu schreiben. Sie sparen Zeit, weil sie häufige Aufgaben für dich lösen.

Typische Beispiele sind:

* `sum()`, um Werte zu summieren
* `date()`, um ein Datum zu erstellen
* `alert()`, um eine Nachricht anzuzeigen

Du musst sie nicht alle auswendig lernen. Starte mit ein paar häufigen Funktionen und erweitere dein Wissen von dort aus.

Eine vollständige Liste findest du unter [Mit Funktionen arbeiten](/ninox-scripting/de/automate-your-workflows/work-with-functions.md).

## **Was du als Nächstes lernen kannst** <a href="#what-to-learn-next" id="what-to-learn-next"></a>

Sobald diese Grundlagen sitzen, mach hier weiter:

* [Anweisungen](/ninox-scripting/de/automate-your-workflows/explore-core-scripting-elements/statements.md)
* [Variablen](/ninox-scripting/de/automate-your-workflows/explore-core-scripting-elements/variables.md)
* [Operatoren](/ninox-scripting/de/automate-your-workflows/explore-core-scripting-elements/operators.md)
* [Funktionen des Logik-Editors](/ninox-scripting/de/automate-your-workflows/explore-core-scripting-elements/logic-editor-features.md)

{% hint style="success" %}
Du musst nicht alles auf einmal lernen. Starte mit kurzen Skripten, teste oft und baue Schritt für Schritt Sicherheit auf.
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.ninox.com/ninox-scripting/de/automate-your-workflows/explore-core-scripting-elements.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.