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:

OperatorBeschreibungVorlageErgebnis
+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:

OperatorBeschreibungVorlageErgebnis
+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:

OperatorBeschreibungVorlageErgebnis
== 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:

OperatorBeschreibungVorlageErgebnis
&&Logisches UND<<{true && true}>>true
||Logisches ODER<<{true || false}>>true
!Logisches NICHT<<{!false}>>true

Logische Operatoren Visualisierung

UND (&&)
true && true = true
true && false = false
false && true = false
false && false = false
ODER (||)
true || true = true
true || false = true
false || true = true
false || false = false

Bedingte Logik-Alternativen

map() Funktion für bedingte Werte

VerwendungVorlageBeschreibung
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

VerwendungTemplateBeschreibung
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: 11

Vorrangregeln-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.

Höchste zu niedrigste Verarbeitungsreihenfolge:
1. Klammern ( )
2. Unäre Operatoren +, -, !
3. Multiplikation *, Division /, Modulo %
4. Addition +, Subtraktion -
5. Vergleichsoperatoren <, >, <=, >=
6. Gleichheitsoperatoren ==, !=
7. Logisches UND &&
8. Logisches ODER ||

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}>> → 8
    • wert1 - 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.