Funktionen
Operatoren
Verwendung von mathematischen, Vergleichs- und logischen Operatoren in Output.Rocks-Ausdrücken.
Output.Rocks unterstützt eine Vielzahl von Operatoren, die in Ausdrücken verwendet werden können, um Berechnungen durchzuführen, Werte zu vergleichen und logische Operationen auszuführen. Diese Operatoren sind ein wesentlicher Bestandteil für die Erstellung dynamischer und interaktiver Vorlagen.
Operatoren werden nach strengen Vorrangregeln ausgewertet. Verwenden Sie Klammern, um die Ausführungsreihenfolge explizit zu steuern und die Lesbarkeit zu verbessern.
Mathematische Operatoren
Mathematische Operatoren führen grundlegende arithmetische Operationen durch:
| Operator | Beschreibung | Vorlage | Ergebnis |
|---|---|---|---|
| + | Addition | <<{5 + 3}>> | 8 |
| - | Subtraktion | <<{5 - 3}>> | 2 |
| * | Multiplikation | <<{5 * 3}>> | 15 |
| / | Division | <<{6 / 2}>> | 3 |
| % | Modulo (Rest) | <<{5 % 2}>> | 1 |
Vermeiden Sie Divisionen durch Null, da diese zu Fehlern führen können.
Textverkettungsoperator
Der +-Operator kann auch zur Verkettung von Texten verwendet werden:
| Operator | Beschreibung | Vorlage | Ergebnis |
|---|---|---|---|
| + | Textverkettung | <<{'Hallo ' + 'Welt'}>> | Hallo Welt |
| + | Gemischte Typen | <<{'Kunde ' + 123}>> | Kunde 123 |
Bei Textverkettung mit dem +-Operator werden andere Datentypen automatisch in Text umgewandelt. Dies ist besonders nützlich für dynamische Ausgaben.
String-Syntax: Verwenden Sie in Output.Rocks immer einfache Anführungszeichen (') für String-Literale in Expressions, niemals doppelte Anführungszeichen (").
Vergleichsoperatoren
Vergleichsoperatoren vergleichen zwei Werte und liefern einen booleschen Wert (true/false) zurück:
| Operator | Beschreibung | Vorlage | Ergebnis |
|---|---|---|---|
| == oder = | Gleich | <<{5 == 5}>> | true |
| != | Ungleich | <<{5 != 3}>> | true |
Die Gleichheitsoperatoren == und = sind in Output.Rocks gleichwertig und können austauschbar verwendet werden. Für bessere Lesbarkeit empfehlen wir die Verwendung von ==.
Logische Operatoren
Output.Rocks unterstützt bedingte Ausdrücke in kompakter Form:
| Operator | Beschreibung | Vorlage | Ergebnis |
|---|---|---|---|
| && | Logisches UND | <<{true && true}>> | true |
| || | Logisches ODER | <<{true || false}>> | true |
| ! | Logisches NICHT | <<{!false}>> | true |
Logische Operatoren Visualisierung
Bedingte Logik-Alternativen
map() Funktion für bedingte Werte
| Verwendung | Vorlage | Beschreibung |
|---|---|---|
| Einfacher Vergleich | <<{map(alter >= 18, true, 'Erwachsener', 'Kind')}>> | Bedingte Ausgabe |
| String-Vergleich | <<{map(status, 'aktiv', 'Kunde aktiv', 'Kunde inaktiv')}>> | Direkter Wert-Vergleich |
| Mehrere Optionen | <<{map(tarif, 'premium', 'VIP', 'standard', 'Normal', 'Unbekannt')}>> | Mit Standard-Wert |
ifBlank() für Null-Behandlung
| Verwendung | Template | Beschreibung |
|---|---|---|
| Fallback-Wert | <<{ifBlank(telefon, 'Nicht angegeben')}>> | Standard bei leerem Wert |
| Berechnung sichern | <<{ifBlank(verbrauch, 0) * preis}>> | Null-sichere Berechnung |
Erweiterte bedingte Logik: Für komplexere If-Else-Strukturen verwenden Sie Bedingte Abschnitte.
Klammern und Vorrangregeln
Klammern ( ) können verwendet werden, um die Ausführungsreihenfolge von Operationen zu steuern:
<<{(5 + 3) * 2}>> // Ergebnis: 16
<<{5 + (3 * 2)}>> // Ergebnis: 11Vorrangregeln-Hierarchie
Output.Rocks verarbeitet Operatoren in einer festgelegten Reihenfolge, ähnlich wie in der Mathematik. Zuerst werden Klammern ausgewertet, dann Vorzeichen und Negationen, gefolgt von Punkt-vor-Strich-Regeln (Multiplikation und Division vor Addition und Subtraktion). Danach kommen Vergleiche, logische Verknüpfungen und zuletzt bedingte Ausdrücke. Diese Hierarchie bestimmt, welche Teile eines Ausdrucks zuerst berechnet werden.
( )+, -, !*, Division /, Modulo %+, Subtraktion -<, >, <=, >===, !=&&||Unterschied zwischen unären und binären Operatoren:
-
Unäre Operatoren (Stufe 2): Wirken auf einen Wert
+wert(positives Vorzeichen):<<{+5}>>→ 5-wert(negatives Vorzeichen):<<{-5}>>→ -5!wert(logische Negation):<<{!true}>>→ false
-
Binäre Operatoren (Stufe 4): Wirken auf zwei Werte
wert1 + wert2(Addition):<<{3 + 5}>>→ 8wert1 - wert2(Subtraktion):<<{8 - 3}>>→ 5
Beispiel: <<{-3 + 5}>> wird als <<{(-3) + 5}>> verarbeitet → 2
Praktische Beispiele
Stromverbrauch-Berechnung
<<$preis_pro_kwh=0.32>>
<<$grundpreis=8.90>>
<<$mwst_satz=0.19>>
Verbrauch: <<verbrauch_kwh>> kWh
Preis pro kWh: <<{$preis_pro_kwh}>> €
Grundpreis: <<{$grundpreis}>> €
Nettobetrag: <<{verbrauch_kwh * $preis_pro_kwh + $grundpreis}>> €
MwSt (19%): <<{(verbrauch_kwh * $preis_pro_kwh + $grundpreis) * $mwst_satz}>> €
Gesamtbetrag: <<{(verbrauch_kwh * $preis_pro_kwh + $grundpreis) * (1 + $mwst_satz)}>> €Tarifprüfung mit Logik
<<$kunde={
'verbrauch_jahr': verbrauchsdaten.jahresverbrauch_kwh,
'haushaltsgroesse': kundenstamm.personen_anzahl,
'waermepumpe': anlagen.hat_waermepumpe,
'nachtstrom': tarif_aktuell.nt_verfuegbar
}>>
Empfohlener Tarif: <<{
map($kunde.verbrauch_jahr > 4000 && $kunde.waermepumpe, true, 'Wärmepumpen-Tarif',
map($kunde.verbrauch_jahr > 2500 && $kunde.haushaltsgroesse >= 3, true, 'Familien-Tarif',
map($kunde.nachtstrom, true, 'HT/NT-Tarif', 'Standard-Tarif')))
}>>
Zusatzoptionen: <<{
map($kunde.waermepumpe && $kunde.verbrauch_jahr > 3000, true, 'Smart-Meter empfohlen', '') +
map($kunde.haushaltsgroesse > 4, true, ' | Energieberatung verfügbar', '')
}>>Operatoren kombiniert mit Funktionen
<<$tage_periode=31>>
<<$verbrauch_pro_tag=verbrauch_kwh / $tage_periode>>
<<$preis_formatiert=numFormat(preis_euro, '¤#,##0.00', 'DE')>>
Verbrauch pro Tag: <<{numFormat($verbrauch_pro_tag, '0.0')}>> kWh/Tag
Berechnung: <<{numFormat(verbrauch_kwh, '#,##0')}>> kWh ÷ <<{$tage_periode}>> Tage = <<{numFormat($verbrauch_pro_tag, '0.00')}>> kWh/Tag
Preis: <<{$preis_formatiert}>>
Datum: <<{dateFormat(stichtag, 'EEEE, dd. MMMM yyyy', null, 'DE')}>>
Einschätzung: <<{map($verbrauch_pro_tag > 20, true, 'Überdurchschnittlich', map($verbrauch_pro_tag > 10, true, 'Durchschnittlich', 'Unterdurchschnittlich'))}>> (<<{numFormat($verbrauch_pro_tag, '0.0')}>> kWh/Tag)Validierung von Daten
<<$validierung={
'email_vorhanden': kunde_email != null && kunde_email != '',
'email_format': kunde_email != null && kunde_email.indexOf('@') > 0 && kunde_email.indexOf('.') > kunde_email.indexOf('@'),
'verbrauch_plausibel': verbrauch_kwh != null && verbrauch_kwh > 0 && verbrauch_kwh < 50000,
'verbrauch_dezimal': numFormat(verbrauch_kwh, '0') == numFormat(verbrauch_kwh, '0.0'),
'zaehlerstand_logisch': zaehlerstand_neu != null && zaehlerstand_alt != null && zaehlerstand_neu > zaehlerstand_alt,
'betrag_gueltig': betrag != null && betrag > 0
}>>
Validierungsstatus: <<{
map($validierung.email_vorhanden && $validierung.email_format &&
$validierung.verbrauch_plausibel && $validierung.verbrauch_dezimal &&
$validierung.zaehlerstand_logisch && $validierung.betrag_gueltig,
true, 'Alle Daten gültig ✓', 'Datenprüfung fehlgeschlagen ✗')
}>>
Detailprüfungen:
E-Mail: <<{map(!$validierung.email_vorhanden, true, 'Fehlt', map(!$validierung.email_format, true, 'Ungültiges Format', 'Gültig ✓'))}>> (<<kunde_email>>)
Verbrauch: <<{map(!$validierung.verbrauch_plausibel, true, 'Wert nicht plausibel', map(!$validierung.verbrauch_dezimal, true, 'Keine ganze Zahl', 'Gültig ✓'))}>> (<<{numFormat(verbrauch_kwh, '#,##0.0')}>> kWh)
Zählerstände: <<{map(!$validierung.zaehlerstand_logisch, true, 'Neuer Wert nicht größer als alter', 'Gültig ✓')}>> (Alt: <<zaehlerstand_alt>>, Neu: <<zaehlerstand_neu>>)
Betrag: <<{map(!$validierung.betrag_gueltig, true, 'Ungültiger oder negativer Wert', 'Gültig ✓')}>> (<<{numFormat(betrag, '#,##0.00')}>> €)Unterschied: Backend-Validierungen vs. Vorlagen-Validierungen
Die hier gezeigte Vorlagen-Validierung erfolgt während des Renderings mit Docmosis-Syntax (&&, ||, !=, etc.).
Backend-Validierungen hingegen erfolgen vor dem Rendering mit Symfony Expression Language (and, or, matches(), etc.) und blockieren das Rendering bei Fehlern komplett.
Vorlagen-Validierungen wie in diesem Beispiel ermöglichen bedingte Ausgaben und Benutzerführung innerhalb des generierten Dokuments.
Wichtige Hinweise
Bei Vergleichen unterschiedlicher Datentypen können unerwartete Ergebnisse auftreten. Sorgen Sie dafür, dass die zu vergleichenden Werte den gleichen Datentyp haben.
Bei Textverkettung mit dem +-Operator werden andere Datentypen automatisch in Text umgewandelt. Dies ist besonders nützlich für dynamische Ausgaben.
Bei komplexen logischen Ausdrücken kann es hilfreich sein, Teilausdrücke in Variablen zu speichern, um die Lesbarkeit zu verbessern.
In Bedingungen können komplexere Ausdrücke mit Klammern gruppiert werden, um die Lesbarkeit zu verbessern und die gewünschte Ausführungsreihenfolge sicherzustellen.