# Variablen 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: ```ninox let variableName := value ``` Schauen wir uns ein Beispiel an: ```ninox 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. {% hint style="info" %} Verwende eine Variable für temporäre Werte in der Logik. Verwende ein Feld, wenn der Wert im Datensatz gespeichert werden soll. {% endhint %} ### **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 ```ninox 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: ```ninox 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. ```ninox 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. ```ninox 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: ```ninox 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: ```ninox let x := price * quantity ``` ```ninox 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: ```ninox if price * quantity > 100 then alert("High value") end; "Total: " + text(price * quantity) ``` ```ninox 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. --- # 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/variables.md?ask= ``` 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.