# Operatoren

Operatoren sind die kleinen Symbole und Schlüsselwörter, die Ninox Logik funktionieren lassen. Du verwendest sie, um Summen zu berechnen, Werte zu vergleichen, Ergebnisse zu speichern und auf Daten zuzugreifen.

Diese Seite zeigt jeden Operator als Symbol und mit Namen.

So erkennst du Operatoren hier leichter und kannst in anderen Kapiteln konsistent darauf verweisen.

In diesem Kapitel lernst du:

* Werte Feldern und Variablen zuzuweisen
* mit Text, Datensatzfeldern und strukturierten Daten zu arbeiten
* Werte mit arithmetischen Operatoren zu berechnen
* Werte zu vergleichen und `true` oder `false` zurückzugeben

### **Den richtigen Operator wählen**

Verwende diese Operatorgruppen für unterschiedliche Aufgaben:

* **Werte und Referenzen schreiben** zum Zuweisen von Werten, Schreiben von Text und Zugreifen auf Felder
* **Arithmetische Operatoren** für Summen, Mengen, Rabatte und andere Berechnungen
* **Vergleichsoperatoren** für Prüfungen in `if`-Bedingungen und Filtern

Wenn du gerade erst anfängst, konzentriere dich zuerst auf `+`, `-`, `*`, `/`, `=`, `!=`, `:=` und `.`.

## **Werte und Referenzen schreiben**

Diese Operatoren helfen dir, gültige Logik zu schreiben, Werte zuzuweisen und auf Text, Felder und Datensatzdaten zu verweisen. Du nutzt sie in fast jedem Skript, auch in sehr kurzen.

<table><thead><tr><th width="189.6953125">Operator und Name</th><th>Was er macht</th><th>Beispiel</th></tr></thead><tbody><tr><td><code>:=</code> Zuweisung</td><td>Weist einer Variable oder einem Feld einen Wert zu.</td><td><code>let myN := 1000;</code></td></tr><tr><td><code>;</code> Semikolon</td><td>Beendet eine Anweisung, besonders wenn danach eine weitere folgt.</td><td><code>let myN := 1000;</code></td></tr><tr><td><code>""</code> Doppelte Anführungszeichen</td><td>Kennzeichnet Text als String-Wert.</td><td><code>"Hello" + " " + "world!"</code></td></tr><tr><td><code>.</code> Punkt</td><td>Greift auf ein Feld in einem Datensatz oder einen Wert in einem Objekt zu.</td><td><code>(select Customers).Name</code></td></tr></tbody></table>

{% hint style="success" %}
Beziehe dich im Ninox Skripting bei Feld- oder Tabellennamen auf den Internen Namen und nicht auf die Bezeichnung.\
Interne Namen dürfen keine Leerzeichen oder Sonderzeichen enthalten und müssen eindeutig sein. Ninox erzeugt den Internen Namen automatisch, du kannst ihn aber ändern. Wenn die Bezeichnung zum Beispiel "First name" lautet, ist der automatisch erzeugte Interne Name "first\_name".
{% endhint %}

### **Werte mit `:=` zuweisen**

Verwende `:=`, um einen Wert in einer Variable zu speichern oder in ein Feld zu schreiben.

```ninox
let myN := 1000;
myN := 2;
Text := "Hello world!";
alert(Text + " We are " + myN + " Ninox users.")
```

Dieses Beispiel zeigt drei verschiedene Zuweisungen.

* Die erste Zeile erstellt die Variable `myN` und speichert die Zahl `1000`.
* Die zweite Zeile aktualisiert `myN` und ersetzt den alten Wert durch `2`.
* Die dritte Zeile schreibt den Text `Hello world!` in das Feld `Text`.

### **Anweisungen mit `;` beenden**

Verwende `;`, um Anweisungen zu trennen.

Ninox fügt Semikolons oft automatisch ein, wenn sie nötig sind, besonders nach `let`-Anweisungen.

```ninox
let myX := 1000;
let myY := 500;
myX + myY
```

Dieses Beispiel trennt Anweisungen und kombiniert zwei Werte.

* Ninox speichert `1000` in `myX`.
* Ninox speichert `500` in `myY`.
* Die letzte Zeile addiert beide Werte und gibt `1500` zurück.

### **Text mit Anführungszeichen kennzeichnen**

Verwende doppelte Anführungszeichen für Textwerte.

```ninox
"Hello" + " " + "world!"
```

Dieses Beispiel verbindet drei Textwerte zu einem Ergebnis.

* Jeder Teil in Anführungszeichen wird als Text behandelt.
* Der Operator `+` verbindet die drei Textteile zu einem String.
* Das Ergebnis ist `Hello world!`.

Doppelte Anführungszeichen sind auch nützlich, wenn du kurzen dynamischen Text mit Feldwerten erstellst.

```ninox
"Hello " + first_name + "!"
```

Dieses Beispiel kombiniert festen Text mit einem Feldwert.

* `"Hello "` ist fester Text.
* `first_name` liest den Feldwert.
* `"!"` ergänzt das abschließende Satzzeichen.
* Wenn `first_name` den Wert `Sam` enthält, ist das Ergebnis `Hello Sam!`.

```ninox
"Your choice: " + text(choices)
```

Dieses Beispiel kombiniert festen Text mit einer Zahl.

* `choices` gibt den numerischen Index der gewählten Option zurück, der einem Textwert zugeordnet ist.
* `text(...)` liest den zugeordneten Text aus.
* Das Ergebnis wird zu einem Textwert wie `Your choice: Apples`.

### **Mit `.` auf Werte zugreifen**

Verwende den Punktoperator, um auf ein Feld in einem Datensatz oder auf einen Wert in einem strukturierten Objekt zuzugreifen.

```ninox
(first(select customers)).name
```

Dieses Beispiel liest ein Feld aus einem Datensatz.

* `select customers` gibt Datensätze aus der Tabelle "Customers" zurück.
* `first(...)` nimmt den ersten Datensatz aus diesem Ergebnis.
* Der Punktoperator liest den Wert im Feld `name` dieses Datensatzes.

## **Werte berechnen**

Verwende arithmetische Operatoren, um Werte direkt in deiner Logik zu berechnen.

Sie sind nützlich für Preise, Mengen, Prozente, Dauern und Zähler.

<table><thead><tr><th width="184.546875">Operator und Name</th><th width="348.6171875">Was er macht</th><th>Beispiel und Ergebnis</th></tr></thead><tbody><tr><td><code>+</code> Plus</td><td>Addiert Zahlen. Kann auch Text verbinden.</td><td><code>1 + 2</code> gibt <code>3</code> zurück</td></tr><tr><td><code>-</code> Minus</td><td>Subtrahiert eine Zahl von einer anderen.</td><td><code>3 - 2</code> gibt <code>1</code> zurück</td></tr><tr><td><code>*</code> Sternchen</td><td>Multipliziert Zahlen.</td><td><code>2 * 3</code> gibt <code>6</code> zurück</td></tr><tr><td><code>/</code> Schrägstrich</td><td>Dividiert eine Zahl durch eine andere.</td><td><code>6 / 3</code> gibt <code>2</code> zurück</td></tr><tr><td><code>%</code> Modulo</td><td>Gibt den Rest nach einer Division zurück.</td><td><code>13 % 5</code> gibt <code>3</code> zurück</td></tr><tr><td><code>()</code> Klammern</td><td>Ändert die Reihenfolge der Berechnung.</td><td><code>(1 + 2) * 3</code> gibt <code>9</code> zurück</td></tr></tbody></table>

### **Arithmetische Operatoren in alltäglicher Logik verwenden**

Das sind typische Anwendungsfälle:

* Einen Preis mit einer Menge multiplizieren
* Einen Zuschlag oder Rabatt addieren
* Eine Summe auf mehrere Datensätze verteilen
* Prüfen, ob sich eine Zahl mit `%` ohne Rest teilen lässt

```ninox
let myTotal := price * quantity;
let myDiscounted := myTotal - discount;
```

Dieses Beispiel berechnet einen Wert in zwei Schritten.

* Die erste Zeile multipliziert `price` mit `quantity`.
* Ninox speichert das Ergebnis in `myTotal`.
* Die zweite Zeile zieht `discount` von `myTotal` ab und speichert das neue Ergebnis in `myDiscounted`.

### **Modulo verstehen**

Der Modulo-Operator `%` gibt zurück, was nach einer ganzzahligen Division übrig bleibt.

```ninox
13 % 5
```

Dieses Beispiel zeigt, wie Modulo den Rest zurückgibt.

* Ninox teilt `13` durch `5`.
* Das ganzzahlige Ergebnis ist `2`, weil `5` zweimal in `13` passt.
* Danach bleibt `3` übrig.
* Deshalb gibt der Ausdruck `3` zurück.

### **Die Reihenfolge der Berechnung steuern**

Ninox folgt der üblichen Operatorpriorität. Multiplikation und Division werden vor Addition und Subtraktion ausgeführt.

Vergleiche diese Beispiele:

```ninox
1 + 2 * 3
```

Dieses Beispiel zeigt die Standardreihenfolge der Berechnung.

* Ninox rechnet das nicht von links nach rechts.
* Zuerst multipliziert es `2 * 3`, das ergibt `6`.
* Danach addiert es `1`.
* Das Endergebnis ist `7`.

```ninox
(1 + 2) * 3
```

Dieses Beispiel zeigt, wie Klammern die Berechnungsreihenfolge ändern.

* Ninox addiert zuerst `1 + 2`, das ergibt `3`.
* Danach multipliziert es dieses Ergebnis mit `3`.
* Das Endergebnis ist `9`.

{% hint style="info" %}
Ninox formatiert Logik automatisch für bessere Lesbarkeit. Es entfernt unnötige Leerzeichen und Klammern und ergänzt Leerzeichen, wo sie hilfreich sind. Das Berechnungsergebnis ändert sich nicht, solange die Logik gleich bleibt.
{% endhint %}

## **Werte vergleichen**

Vergleichsoperatoren prüfen, ob zwei Werte eine Bedingung erfüllen. Sie helfen Ninox zu entscheiden, was als Nächstes passieren soll.

Sie geben ein boolesches Ergebnis zurück:

* `true`
* `false`

In einem Yes/No-Feld zeigt Ninox diese Ergebnisse als **Yes** und **No** an.

<table><thead><tr><th width="241.41796875">Operator und Name</th><th width="295.9765625">Was er macht</th><th>Beispiel und Ergebnis</th></tr></thead><tbody><tr><td><code>=</code> Gleich</td><td>Prüft, ob zwei Werte gleich sind.</td><td><code>1 + 1 = 3 - 1</code> gibt <code>true</code> zurück</td></tr><tr><td><code>!=</code> Ungleich</td><td>Prüft, ob zwei Werte unterschiedlich sind.</td><td><code>"Apples" != "Pears"</code> gibt <code>true</code> zurück</td></tr><tr><td><code>&#x3C;</code> Kleiner als</td><td>Prüft, ob der linke Wert kleiner ist.</td><td><code>4 * 2 &#x3C; 10</code> gibt <code>true</code> zurück</td></tr><tr><td><code>&#x3C;=</code> Kleiner oder gleich</td><td>Prüft, ob der linke Wert kleiner oder gleich ist.</td><td><code>5 * 2 &#x3C;= 10</code> gibt <code>true</code> zurück</td></tr><tr><td><code>></code> Größer als</td><td>Prüft, ob der linke Wert größer ist.</td><td><code>10 > 4 * 2</code> gibt <code>true</code> zurück</td></tr><tr><td><code>>=</code> Größer oder gleich</td><td>Prüft, ob der linke Wert größer oder gleich ist.</td><td><code>5 * 2 >= 10</code> gibt <code>true</code> zurück</td></tr><tr><td><code>like</code> Like</td><td>Prüft, ob Text einen Wert enthält.</td><td><code>"Hello" like "el"</code> gibt <code>true</code> zurück</td></tr><tr><td><code>not</code> Nicht</td><td>Prüft, ob eine Bedingung <code>false</code> ist</td><td><code>not 1 = 3</code> gibt <code>true</code> zurück</td></tr></tbody></table>

### **Vergleichsergebnisse in Logik verwenden**

Vergleichsoperatoren werden oft in `if`-Bedingungen verwendet.

```ninox
if total > 100 then
	alert("High value")
end
```

Dieses Beispiel führt eine Aktion nur aus, wenn eine Bedingung `true` ist.

* Ninox prüft, ob das Feld `total` größer als `100` ist.
* Wenn die Bedingung `true` ist, zeigt Ninox die Nachricht `High value` an.
* Wenn die Bedingung `false` ist, passiert nichts.

Du kannst Feldwerte auch direkt vergleichen:

```ninox
if status = "Open" then
	alert("This record still needs attention.")
end
```

Dieses Beispiel vergleicht einen Feldwert mit einem festen Textwert.

* Ninox vergleicht das Feld `status` mit dem Text `Open`.
* Wenn beide Werte exakt übereinstimmen, zeigt Ninox den Hinweis an.
* Dieses Muster ist nützlich für Erinnerungen, Prüfungen und Workflow-Kontrollen.

### **Text mit `like` vergleichen**

Verwende `like`, wenn du prüfen willst, ob ein Textwert in einem anderen vorkommt.

```ninox
"Hello" like "el"
```

Dieses Beispiel prüft, ob ein Text einen anderen Text enthält.

* Ninox prüft, ob der Text `el` an einer beliebigen Stelle in `Hello` vorkommt.
* Weil `Hello` den Text `el` enthält, gibt die Bedingung `true` zurück.

```ninox
"el" like "Hello"
```

Dieses Beispiel zeigt, dass `like` nicht symmetrisch ist.

* Ninox prüft, ob der kürzere Text `el` den Text `Hello` enthält.
* Das ist nicht der Fall.
* Die Bedingung gibt `false` zurück.

{% hint style="info" %}
`like` prüft, ob ein Text enthalten ist. Es prüft nicht, ob beide Werte identisch sind. Verwende `=`, wenn du eine exakte Übereinstimmung brauchst.
{% endhint %}

### **Operatoren zusammen verwenden**

Die meisten echten Skripte kombinieren mehrere Operatoren in einem Block.

```ninox
let myTotal := price * quantity;
if myTotal > 100 then
	alert("High-value record: " + text(myTotal))
end
```

Dieses Beispiel kombiniert Zuweisung, Berechnung, Vergleich und Textausgabe.

* Die erste Zeile berechnet eine Summe und speichert sie in der Variablen `myTotal`.
* Das `if`-Statement prüft, ob diese Summe größer als `100` ist.
* Wenn das der Fall ist, erstellt Ninox eine Nachricht aus dem Text `High-value record:` und der berechneten Summe.
* `text(myTotal)` konvertiert die Zahl in Text, damit sie in der Meldung angezeigt werden kann.

```ninox
let myFullName := first_name + " " + last_name;
if last_name != "" then
	alert("Customer: " + myFullName)
end
```

Dieses Beispiel kombiniert Feldzugriff, Textverkettung, Zuweisung und Vergleich.

* Die erste Zeile liest die Felder `first_name` und `last_name`.
* Sie verbindet beide Werte mit einem Leerzeichen und speichert das Ergebnis in der Variablen `myFullName`.
* Das `if`-Statement prüft, ob `last_name` nicht leer ist.
* Wenn das Feld Text enthält, zeigt Ninox den vollständigen Namen in einer Meldung an.

```ninox
let myReference := "INV-" + text(number);
reference := myReference;
```

Dieses Beispiel kombiniert Texterstellung, Konvertierung und Zuweisung an ein Feld.

* Die erste Zeile erstellt einen neuen Textwert, der mit `INV-` beginnt.
* `text(number)` konvertiert den numerischen Wert in `number` in Text.
* Ninox speichert das vollständige Ergebnis in der Variablen `myReference`.
* Die zweite Zeile schreibt diesen Wert in das Feld `reference`.

An diesen Beispielen siehst du, wie Operatoren dir helfen:

* Werte mit `:=` zuzuweisen
* Text mit `+` zu verbinden
* Ergebnisse mit `*` zu berechnen
* Werte mit `>` und `!=` zu vergleichen


---

# 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/operators.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.