Variablen

Lerne, wie du Variablen deklarierst, Werte speicherst und Ergebnisse in Ninox Logik wiederverwendest.

Variablen helfen dir, einen Wert zu speichern und später in deiner Logik wiederzuverwenden. Sie machen Skripte leichter lesbar, testbar und änderbar. Stell dir eine Variable als benannten Behälter für einen Wert vor. Du legst einmal etwas hinein und nutzt es dann überall dort, wo du es brauchst. Eine Variable hat einen Namen und einen Wert.

In diesem Kapitel lernst du:

• eine Variable mit let zu deklarieren

• mit := einen Wert zuzuweisen

• einen gültigen Variablennamen zu wählen

Eine Variable deklarieren

Verwende let, um eine neue Variable zu erstellen. Verwende :=, um ihr einen Wert zuzuweisen.

Das Grundmuster sieht so aus:

let variableName := value

Schauen wir uns ein Beispiel an:

let myText := "Hello " + first_name + "!";
myText

Dieses Beispiel deklariert die Variable myText und speichert einen Textwert darin.

• "Hello " ist fester Text.

• first_name liest den Wert aus dem Feld.

• "!" ergänzt das abschließende Satzzeichen.

• Die zweite Zeile gibt den in myText gespeicherten Wert zurück.

Wenn first_name den Wert Sam enthält, gibt das Skript "Hello Sam!" zurück.

Variablen existieren nur, solange die aktuelle Logik läuft. Sie erstellen kein neues Feld in deiner Tabelle. Ninox bestimmt den Werttyp anhand des Werts, den du zuweist.

Verwende eine Variable für temporäre Werte in der Logik. Verwende ein Feld, wenn der Wert im Datensatz gespeichert werden soll.

Was eine Variable enthalten kann

Eine Variable kann verschiedene Arten von Werten enthalten.

In Ninox sind dies häufige Werttypen:

• Text-Werte wie Namen oder Nachrichten

• Number-Werte wie Preise, Mengen oder Summen

• Yes/No-Werte wie true, false und auch null

• Date-Werte

• Record-Referenzen

let customerName := "Sam";
let total := 125.50;
let isPaid := true

Dieses Beispiel zeigt drei verschiedene Werttypen:

• customerName speichert Text.

• total speichert eine Zahl.

• isPaid speichert einen Yes/No-Wert.

Du musst den Werttyp nicht separat deklarieren. Ein Textausdruck gibt zum Beispiel Text zurück, eine Berechnung eine Zahl.

Warum Variablen nützlich sind

Variablen sind nützlich, wenn du einen Wert einmal speichern und später erneut verwenden willst. Das macht deine Logik leichter lesbar und leichter änderbar.

Du kannst zum Beispiel eine Begrüßung in einer Variable speichern und sie in der nächsten Zeile verwenden:

let myText := "Hello " + first_name + "!";
alert(myText)

Dieses Beispiel erstellt die Begrüßung einmal und speichert sie in myText.

• Die erste Zeile erstellt den Text.

• Die zweite Zeile verwendet den gespeicherten Wert.

Ohne Variable müsstest du den vollständigen Ausdruck jedes Mal wiederholen.

Variablen sind auch hilfreich, wenn du ein Feld aus dem aktuellen Datensatz in einer Suche verwendest. Speichere den Feldwert zuerst in einer Variable. Nutze die Variable dann in der Bedingung.

let myName := first_name;
let myCount := cnt(select Contacts where first_name = myName);
alert(myCount + " records have the same first name.")

Diese Logik arbeitet in drei Schritten:

• myName speichert den Wert aus dem aktuellen Datensatz.

• select Contacts where first_name = myName findet passende Datensätze.

• cnt(...) zählt diese Datensätze.

Wenn im aktuellen Datensatz in first_name der Wert Sam steht, zählt Ninox alle Datensätze in Contacts, in denen first_name ebenfalls Sam ist.

Variablen sind besonders nützlich, wenn du:

• einen Wert einmal berechnest und wiederverwendest

• einen Text einmal erstellst und an mehreren Stellen nutzt

• einen Feldwert aus dem aktuellen Datensatz in einer Suchbedingung verwendest

• längere Logik in kleinere, klarere Schritte aufteilst

Einen berechneten Wert wiederverwenden

Variablen können Zahlen genauso speichern wie Text.

let total := price * quantity;
let message := "Total: " + text(total);
alert(message)

Dieses Beispiel berechnet eine Summe und speichert sie, bevor das Ergebnis angezeigt wird.

• total speichert das numerische Ergebnis von price * quantity.

• message wandelt diesen Wert in lesbaren Text um.

• alert(message) zeigt die fertige Nachricht an.

Dieses Muster macht deine Logik später leichter erweiterbar. Du kannst total zum Beispiel für einen Rabatt, eine Steuer oder eine Statusprüfung wiederverwenden.

Einen gültigen Variablennamen wählen

Wähle einen Namen, der den in der Variable gespeicherten Wert klar beschreibt.

Verwende kein Ninox Schlüsselwort als Variablennamen. this und let sind zum Beispiel reservierte Wörter und können deshalb nicht als Variablennamen verwendet werden:

let this := 1

Schlüsselwörter sind Wörter, die Ninox in seiner eigenen Syntax bereits verwendet. Häufige Beispiele sind let, if, then, else, this und end.

Vermeide außerdem Namen, die mit Feldnamen in Tabellen übereinstimmen, die dein Skript verwendet. Das kann zu falschen Ergebnissen oder versehentlichen Feldaktualisierungen führen.

Wenn es hilft, verwende ein Benennungsmuster wie myTotal oder customerName. So erkennst du Variablen auf einen Blick.

Verwende klare Namen wie:

• myText

• totalAmount

• customerName

• isValid

Muster, die du bei Variablen vermeiden solltest

Diese Stolperfallen sind beim Einstieg in Variablen häufig:

• einen Variablennamen zu wählen, der mit einem Schlüsselwort oder Feldnamen verwechselt werden kann

• einen Namen wie x oder temp zu wählen, der nichts über den Wert aussagt

• denselben Ausdruck zu wiederholen, statt ihn einmal zu speichern

Zu ungenaue Namen wählen

Kurze Namen lassen sich schnell tippen, sind später aber schwerer zu verstehen.

Vergleiche diese beiden Versionen:

let x := price * quantity

let myTotal := price * quantity

Die zweite Version ist leichter zu verstehen. x sagt nicht, was der Wert bedeutet. myTotal zeigt direkt, dass die Variable eine Summe speichert. Das macht spätere Änderungen schneller und sicherer.

Denselben Ausdruck wiederholen

Wenn du dieselbe Berechnung mehr als einmal verwendest, speichere sie in einer Variable. So bleibt die Logik kürzer und leichter änderbar.

Vergleiche diese beiden Versionen:

if price * quantity > 100 then
	alert("High value")
end;
"Total: " + text(price * quantity)

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

Die zweite Version ist leichter nachzuvollziehen.

• myTotal speichert die Berechnung einmal.

• Die Bedingung ist kürzer.

• Die letzte Zeile ist leichter zu lesen.

Wenn du die Berechnung später änderst, änderst du sie nur an einer Stelle.