> ## Documentation Index
> Fetch the complete documentation index at: https://developers.hubspot.de/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Operatoren und Ausdrucktests

> Um die Logik und Funktionalität Ihrer Vorlagen zu erweitern, unterstützt HubL mehrere wichtige Operatoren und Ausdruckstests. Operatoren ermöglichen es Ihnen, mathematische Funktionen auszuführen, Vergleiche durchzuführen, die Logik von Vorlagen komplexer zu machen und die Darstellung durch Markup zu ändern. Darüber hinaus enthält dieser Artikel eine umfassende Liste von Ausdruckstests, die in HubL verwendet werden können.

Um die Logik und Funktionalität Ihrer Vorlagen zu erweitern, unterstützt HubL mehrere wichtige Operatoren und Ausdruckstests. [Operatoren](/cms/reference/hubl/operators-and-expression-tests#operators) ermöglichen es Ihnen, mathematische Funktionen auszuführen, Vergleiche durchzuführen, die Logik von Vorlagen komplexer zu machen und die Darstellung durch Markup zu ändern. Darüber hinaus enthält dieser Artikel eine umfassende Liste von [Ausdruckstests](/cms/reference/hubl/operators-and-expression-tests#expression-tests), die in HubL verwendet werden können.

## Operatoren

Operatoren sind Symbole, die den HubL-Compiler anweisen, verschiedene Operationen auszuführen, die zur endgültigen Ausgabe führen. Operatoren werden zwischen Operanden platziert, um die beiden Werte zueinander in Beziehung zu setzen, sei es zur Ausführung mathematischer Funktionen, zum Erstellen von Vergleichen oder zum Implementieren von booleschen Ausdrücken.

<Frame>
  <img src="https://www.hubspot.de/hubfs/Knowledge_Base_2023-24-25/operators-and-operands.png" alt="operators-and-operands-diagram" />
</Frame>

Nachfolgend finden Sie die Operatoren, die Sie in HubL verwenden können, nach Typ geordnet.

### Mathematik

Mathematische Standardoperatoren können zur Berechnung von Werten im Kontext einer Vorlage verwendet werden.

```hubl theme={null}
{% set my_num = 11 %}
{% set my_number = 2 %}

{{ my_num + my_number }}
<!-- 11 + 2 = 13 -->

{{ my_num - my_number }}
<!-- 11 - 2 = 9 -->

{{ my_num / my_number }}
<!-- 11 / 2 = 5.5 -->

{{ my_num % my_number }}
<!-- 11 % 2 = 1 -->

{{ my_num // my_number }}
<!-- 11 // 2 = 5 -->

{{ my_num * my_number }}
<!-- 11 * 2 = 22 -->

{{ my_num ** my_number }}
<!-- 11 ** 2 = 121 -->
```

| Symbol | Beschreibung                                                                                                                                                                  |
| ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `+`    | Fügt zwei Objekte zusammen, in der Regel Zahlenwerte. Um Zeichenfolgen oder Listen zu verketten, sollten Sie stattdessen den [`~`-Operator](#other-hubl-operators) verwenden. |
| `-`    | Subtrahiert eine Zahl von einer anderen.                                                                                                                                      |
| `/`    | Dividiert Zahlen.                                                                                                                                                             |
| `%`    | Gibt den Rest aus der Division von Zahlen zurück.                                                                                                                             |
| `//`   | Teilt zwei Zahlen und gibt das gerundete ganzzahlige Ergebnis zurück. `{{ 20 // 7 }}` ergibt zum Beispiel `2`.                                                                |
| `*`    | Multipliziert Zahlen.                                                                                                                                                         |
| `**`   | Nimmt den linken Operanden hoch dem rechten Operanden.                                                                                                                        |

### Vergleich

Vergleichsoperatoren können verwendet werden, um Werte für Vorlagenlogik auszuwerten. Einige Beispiele für die Verwendung von Vergleichsoperatoren finden Sie in [if-Anweisungen](/cms/reference/hubl/if-statements).

```hubl theme={null}
{% set my_num = 11 %}
{% set my_number = 2 %}

{{ my_num == my_number }}
<!-- Evaluates to false -->

{{ my_num != my_number }}
<!-- Evaluates to true -->

{{ my_num > my_number }}
<!-- Evaluates to true -->

{{ my_num >= my_number }}
<!-- Evaluates to true -->

{{ my_num < my_number }}
<!-- Evaluates to false -->

{{ my_num <= my_number }}
<!-- Evaluates to false -->
```

| Symbol | Kurzschreibweise | Beschreibung                                                                                                              |
| ------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------- |
| `==`   | ==eq             | Gleich. Wird als true ausgewertet, wenn die beiden Objekte gleiche Werte haben.                                           |
| `!=`   | ne               | Ungleich. Wird als true ausgewertet, wenn die beiden Objekte nicht gleich sind.                                           |
| `>`    | gt               | Größer als. Wird als true ausgewertet, wenn der Wert des linken Operanden größer als der rechte Operand ist.              |
| `>=`   | gte              | Größer als oder gleich. Wird als true ausgewertet, wenn der linke Operand größer oder gleich dem rechten Operanden ist.   |
| `<`    | lt               | Kleiner als. Wird als true ausgewertet, wenn der linke Operand kleiner als der rechte Operand ist.                        |
| `<=`   | lte              | Kleiner als oder gleich. Wird als true ausgewertet, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist. |

<Tip>
  Die Kurzschreibweise der Vergleichsoperatoren kann in HubL-Filtern verwendet werden, bei denen ein Ausdruck getestet wird, z. B. [`|selectattr()`](/cms/reference/hubl/filters#selectattr).
</Tip>

### Logisch

Mit logischen Operatoren können Sie boolesche Ausdrücke implementieren sowie mehrere Ausdrücke in einzelnen Anweisungen kombinieren.

<CodeGroup>
  ```text and.txt theme={null}
  Two non-empty strings:
  {{ "a" and "b" }}
  <!-- Evaluates to true -->

  Empty string and non-empty string:
  {{ "" and "b" }}
  <!-- Evaluates to false -->

  Two non-zero numbers:
  {{ 1 and 2 }}
  <!-- Evaluates to true -->

  Zero and non-zero number:
  {{ 0 and 1 }}
  <!-- Evaluates to false -->

  Two non-empty lists:
  {{ [1] and [2] }}
  <!-- Evaluates to true -->

  Empty list and non-empty list:
  {{ [] and [2] }}
  <!-- Evaluates to false -->

  Two non-empty dicts:
  {{ {a: 1} and {b: 2} }}
  <!-- Evaluates to true -->

  Empty dict and non-empty dict:
  {{ {} and {b: 2} }}
  <!-- Evaluates to false -->
  ```

  ```text or.txt theme={null}
  Two non-empty strings:
  {{ "a" or "b" }}
  <!-- Evaluates to "a" -->

  Empty string and non-empty string:
  {{ "" or "b" }}
  <!-- Evaluates to "b" -->

  Two non-zero numbers:
  {{ 1 or 2 }}
  <!-- Evaluates to 1 -->

  Zero and non-zero number:
  {{ 0 or 1 }}
  <!-- Evaluates to 0 -->

  Two non-empty lists:
  {{ [1] or [2] }}
  <!-- Evaluates to [1] -->

  Empty list and non-empty list:
  {{ [] or [2] }}
  <!-- Evaluates to [2] -->

  Two non-empty dicts:
  {{ {a: 1} or {b: 2} }}
  <!-- Evaluates to {a=1} -->

  Empty dict and non-empty dict:
  {{ {} or {b: 2} }}
  <!-- Evaluates to {b=2} -->
  ```

  ```text is / is not.txt theme={null}
  Conditional using `is` operator:
  {% set string = "strings are a cat's best friend" %}
  {% if string is string_containing "cat" %}
  Meow
  {% else %}
  Woof
  {% endif %}
  <!-- Evaluates to Meow -->

  Conditional using `not` operator:
  {% set string = "strings are a cat's best friend" %}
  {% if string is not string_containing "cat" %}
  Meow
  {% else %}
  Woof
  {% endif %}
  <!-- Evaluates to Woof -->
  ```

  ```text (expr).txt theme={null}
  {% set my_num = 10 %}
  {% set my_variable = 5 %}

  {{ (my_num + 2) * my_variable }}
  <!-- Evaluates to 60 -->
  ```

  ```text ?.txt theme={null}
  {% set date = local_dt %}
  {{ date ? date : 'No date'}}
  <!-- Evaluates to the date variable value -->

  {{ todays_date ? todays_date : 'No date'}}
  <!-- Evaluates to 'No date' since no value is set for todays_date -->
  ```
</CodeGroup>

| Symbol   | Beschreibung                                                                                                                                                                                                                                                                                                              |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `and`    | Gibt `true` zurück, wenn sowohl der linke als auch der rechte Operand truthy sind. Andernfalls wird `false` zurückgegeben. <br /><br />Dieser Operator verhält sich nicht wie der `and`-Operator in Python oder der `&&`-Operator in JavaScript. Im Folgenden erfahren Sie mehr über die Verwendung von `and`-Operatoren. |
| `or`     | Gibt den ersten Operanden zurück, wenn er truthy ist. Andernfalls wird der zweite Operand zurückgegeben. <br /><br />Dieser Operator ist äquivalent zu `or` in Python und<code>\|\|</code> JavaScript. Im Folgenden erfahren Sie mehr über die Verwendung von `or`-Operatoren.                                            |
| `is`     | Verbindet zwei Operanden für eine positive Anweisung.                                                                                                                                                                                                                                                                     |
| `not`    | Negiert eine Anweisung in Verbindung mit `is`.                                                                                                                                                                                                                                                                            |
| `(expr)` | Gruppieren Sie einen Ausdruck für die Reihenfolge der Operationen. Zum Beispiel: `(10 - 2) * variable`.                                                                                                                                                                                                                   |
| `?`      | Der [ternäre Operator](/cms/reference/hubl/if-statements) kann verwendet werden, um schnell bedingte Logik zu schreiben. Akzeptiert drei Argumente (Ausdruck, „true“-Bedingung, „false“-Bedingung). Wertet einen Ausdruck aus und gibt die entsprechende Bedingung zurück.                                                |

**Verwenden von und/oder-Operatoren**

In HubL verhält sich der `or`-Operator wie der `or`-Operator in Python und der `||`-Operator in JavaScript. Der erste Operand wird zurückgegeben, wenn der Ausdruck als true ausgewertet wird, andernfalls wird der zweite Operand zurückgegeben. Ein häufiger Anwendungsfall für diesen `or` Operator ist das Festlegen eines Fallback-Werts, wenn kein Variablenwert definiert ist.

```hubl theme={null}
Two non-empty strings:
{{ "a" or "b" }}
<!-- Evaluates to "a" -->

Empty string and non-empty string:
{{ "" or "b" }}
<!-- Evaluates to "b" -->

Defining a fallback value:
{{ some_variable or "default value" }}
<!-- If some_variable is defined, print its value,
otherwise print "default value" -->
```

Der `and`-Operator verhält sich jedoch anders als der `and`-Operator in Python und der `&&`-Operator in JavaScript. In HubL gibt `and` immer einen booleschen Wert zurück: Wenn der Ausdruck als true ausgewertet wird, wird `true` zurückgegeben, andernfalls wird `false` zurückgegeben. Die Python- und JavaScript-Operatoren hingegen geben einen Operandenwert zurück, der darauf basiert, ob die Anweisung als true oder false ausgewertet wird.

```hubl theme={null}
Two non-empty strings:
{{ "a" and "b" }}
<!-- Evaluates to true -->

Empty string and non-empty string:
{{ "" and "b" }}
<!-- Evaluates to false -->
```

In HubL werden leere Listen (`[]`) und leere Dicts (`{}`) als falsch betrachtet. Dies entspricht dem Verhalten in Python, unterscheidet sich jedoch von JavaScript, wo `[]` und `{}` truthy sind.

```hubl theme={null}
Empty list and non-empty list:
{{ [] or [2] }}
<!-- Evaluates to [2] -->

Empty dict and non-empty dict:
{{ {} and {b: 2} }}
<!-- Evaluates to false -->
```

### Andere HubL-Operatoren

Nachfolgend sind weitere wichtige HubL-Operatoren aufgeführt, die zur Durchführung verschiedener Aufgaben verwendet werden können.

| Symbol          | Beschreibung                                                                                            |
| --------------- | ------------------------------------------------------------------------------------------------------- |
| `in`            | Überprüft, ob ein Wert in einer Sequenz enthalten ist.                                                  |
| `is`            | Führt einen [Ausdruckstest](/cms/reference/hubl/operators-and-expression-tests#expression-tests) durch. |
| <code>\|</code> | Wendet einen Filter an.                                                                                 |
| `~`             | Verkettet Werte.                                                                                        |

## Ausdrucktests

Ausdruckstests sind verschiedene boolesche Bedingungen, die mithilfe von logischen Operatoren ausgewertet werden können.

### boolean

Überprüft, ob das Objekt boolesch ist (im strengen Sinne, nicht in seiner Fähigkeit, zu einem wahrheitsgemäßen Ausdruck auszuwerten).

<CodeGroup>
  ```text hubl.txt theme={null}
  {% set isActive = false %}

  {% if isActive is boolean %}
  isActive is a boolean
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  isActive is a boolean
  ```
</CodeGroup>

### containing

Überprüft, ob eine Listenvariable einen Wert enthält.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% set numbers = [1, 2, 3] %}

  {% if numbers is containing 2 %}
  Set contains 2!
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  Set contains 2!
  ```
</CodeGroup>

### containingall

Überprüft, ob eine Listenvariable alle Werte einer anderen Liste enthält.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% set numbers = [1, 2, 3] %}

  {% if numbers is containingall [2, 3] %}
  Set contains 2 and 3!
  {% endif %}

  {% if numbers is containingall [2, 4] %}
  Set contains 2 and 4!
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  Set contains 2 and 3!
  ```
</CodeGroup>

### defined

Überprüft, ob eine Variable im Kontext der Vorlage definiert ist. Sie können diesen Ausdruckstest zwar verwenden, aber beim Schreiben einer if-Anweisung ohne Operatoren wird standardmäßig geprüft, ob die Variable definiert ist.

In dem folgenden Beispiel wird der color-Parameter eines Farbmoduls getestet. Hätte der color-Parameter keinen Wert, würde die Vorlage standardmäßig eine schwarze Hintergrundfarbe darstellen. Wenn er angegeben ist, wird die vom Benutzer festgelegte Hintergrundfarbe dargestellt.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% color "my_color" color="#930101", export_to_template_context=True %}
  <style>
  {% if widget_data.my_color.color is defined %}
  body{
  background: {{ widget_data.my_color.color }};
  }
  {% else %}
  body{
  background: #000;
  }
  {% endif %}
  </style>
  ```

  ```html example.html theme={null}
  <style>
  body {
  background: #930101;
  }
  </style>
  ```
</CodeGroup>

### divisibleby

Überprüft, ob ein Objekt durch eine andere Zahl teilbar ist.

Im Folgenden wird zum Beispiel eine for-Schleife erstellt, die eine Liste von Tierarten durchläuft. Jede Tierart wird in einem div gedruckt, und jedes 5. div hat ein anderes Inline-Styling (Breite:100 %). Dieses Konzept könnte auf einen Blog angewendet werden, in dem für ein bestimmtes Muster von Beiträgen ein anderes Markup gerendert wird. Weitere Informationen zu for-Schleifen und loop.index finden Sie [in diesem Artikel](/cms/reference/hubl/loops).

<CodeGroup>
  ```text hubl.txt theme={null}
  {% set animals = ["lions", "tigers", "bears", "dogs", "sharks"] %}
  {% for animal in animals %}
  {% if loop.index is divisibleby 5 %}
  <div style="width:100%">{{animal}}</div>
  {% else %}
  <div style="width:25%">{{animal}}</div>
  {% endif %}
  {% endfor %}
  ```

  ```html example.html theme={null}
  <div style="width:25%">lions</div>
  <div style="width:25%">tigers</div>
  <div style="width:25%">bears</div>
  <div style="width:25%">dogs</div>
  <div style="width:100%">sharks</div>
  ```
</CodeGroup>

### equalto

Überprüft, ob der Wert einer Variablen gleich einer Konstanten oder einer anderen Variablen ist. Sie können auch den Operator `==` verwenden, um denselben Test durchzuführen.

Im folgenden Beispiel wird die Breite der Blogbeiträge auf der Grundlage der Gesamtzahl der Beiträge in der Schleife angepasst. In der Beispielausgabe wird davon ausgegangen, dass der Blog 4 Beiträge enthält.

<CodeGroup>
  ```html example.html theme={null}
  {% for content in contents %}
  {% if loop.length is equalto 2 %}
  <div style="width:50%;">Post content</div>
  {% elif loop.length is equalto 3 %}
  <div style="width:33.333332%;">Post content</div>
  {% elif loop.length is equalto 4 %}
  <div style="width:25%;">Post content</div>
  {% else %}
  <div style="width:100%;>Post content</div>
  {% endif %}
  {% endfor %}
  ```

  ```html example.html theme={null}
  <div style="width:25%;">Post content</div>
  <div style="width:25%;">Post content</div>
  <div style="width:25%;">Post content</div>
  <div style="width:25%;">Post content</div>
  ```
</CodeGroup>

### even

Überprüft, ob eine numerische Variable eine gerade Zahl ist.

Das folgende Beispiel zeigt eine vereinfachte Blog-Listing-Schleife. Wenn die aktuelle Iteration der Schleife gerade ist, wird dem post item-div die `even-post`-Klasse zugewiesen. Andernfalls wird die `odd-post`-Klasse zugewiesen.

<CodeGroup>
  ```html example.html theme={null}
  {% for content in contents %}
  {% if loop.index is even %}
  <div class="post-item even-post">Post content</div>
  {% else %}
  <div class="post-item odd-post">Post content</div>
  {% endif %}
  {% endfor %}
  ```

  ```html example.html theme={null}
  <div class="post-item odd-post">Post content</div>
  <div class="post-item even-post">Post content</div>
  <div class="post-item odd-post">Post content</div>
  <div class="post-item even-post">Post content</div>
  ```
</CodeGroup>

### float

Überprüft, ob eine numerische Variable eine Gleitkommazahl ist.

<CodeGroup>
  ```html example.html theme={null}
  {% set quantity = 1.20 %}
  {% if quantity is float %}
  quantity is a floating point number
  {% endif %}
  ```

  ```html example.html theme={null}
  quantity is a floating-point number
  ```
</CodeGroup>

### integer

Überprüft, ob eine Variable eine ganze Zahl ist.

<CodeGroup>
  ```html example.html theme={null}
  {% set quantity = 120 %}
  {% if quantity is integer %}
  Quantity is an integer
  {% endif %}
  ```

  ```html example.html theme={null}
  Quantity is an integer
  ```
</CodeGroup>

### iterable

Überprüft, ob eine Variable in einer Schleife durchlaufen werden kann.

In diesem Beispiel wird eine Variable namens `jobs` daraufhin überprüft, ob sie durchlaufen werden kann. Da die Variable eine Liste von Jobs enthält, würde die [if-Anweisung](/cms/reference/hubl/if-statements) als `true` ausgewertet werden, und die Schleife würde ausgeführt werden. Hätte die Variable einen einzelnen Wert enthalten, würde die if-Anweisung diesen Wert stattdessen mit anderem Markup ausgeben. [Erfahren Sie mehr über for-Schleifen](/cms/reference/hubl/loops).

<CodeGroup>
  ```html example.html theme={null}
  {% set jobs = ["Accountant", "Developer", "Manager", "Marketing", "Support"] %}

  {% if jobs is iterable %}
  <h3>Available positions</h3>
  <ul>
  {% for job in jobs %}
  <li>{{ job }}</li>
  {% endfor %}
  </ul>
  {% else %}
  <h3>Available position</h3>
  <div class="single-position">{{ jobs }}</div>
  {% endif %}
  ```

  ```html example.html theme={null}
  <h3>Available positions</h3>
  <ul>
  <li>Accountant</li>
  <li>Developer</li>
  <li>Manager</li>
  <li>Marketing</li>
  <li>Support</li>
  </ul>
  ```
</CodeGroup>

### lower

Überprüft, ob eine Zeichenfolge kleingeschrieben ist.

Im folgenden Beispiel wird mithilfe einer [unless-Anweisung](/cms/reference/hubl/if-statements#unless-statements) und eines lower-Filter sichergestellt, dass eine in einen Textbaustein eingegebene Textzeichenfolge immer kleingeschrieben wird.

<CodeGroup>
  ```html example.html theme={null}
  {% module "my_text" path="@hubspot/text" label="Enter text", value="Some TEXT that should be Lowercase", export_to_template_context=True %}

  {% unless widget_data.my_text.value is lower %}
  {{ widget_data.my_text.value|lower }}
  {% endunless %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  some text that should be lowercase
  ```
</CodeGroup>

### mapping

Überprüft, ob ein Objekt ein Dict (Dictionary/Wörterbuch) ist.

Im folgenden Beispiel wird überprüft, ob das Kontaktobjekt ein Dictionary ist.

<CodeGroup>
  ```html example.html theme={null}
  {% if contact is mapping %}
  This object is a dictionary.
  {% else %}
  This object is not a dictionary.
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  This object is a dictionary.
  ```
</CodeGroup>

### none

Überprüft, ob eine Variable einen `null`-Wert enthält.

<CodeGroup>
  ```html example.html theme={null}
  {% module "user_email" path="@hubspot/text" label="Enter user email", value="example@hubspot.com", export_to_template_context=True %}
  {% unless widget_data.user_email.value is none %}
  {{ widget_data.user_email.value }}
  {% endunless %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  example@hubspot.com
  ```
</CodeGroup>

### number

Überprüft, ob der Wert einer Variablen eine Zahl ist.

Im folgenden Beispiel wird überprüft, ob es sich bei einer Variablen um eine Variable handelt, und wenn ja, wird sie in Millionen umgewandelt.

<CodeGroup>
  ```html example.html theme={null}
  {% set my_var = 40 %}
  {% if my_var is number %}
  {{ my_var * 1000000 }}
  {% else %}
  my_var is not a number.
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  40000000
  ```
</CodeGroup>

### odd

Überprüft, ob eine numerische Variable eine ungerade Zahl ist.

Im Folgenden wird dasselbe Beispiel wie der zuvor beschriebene inverse-even-Ausdruckstest verwendet.

<CodeGroup>
  ```html example.html theme={null}
  {% for content in contents %}
  {% if loop.index is odd %}
  <div class="post-item odd-post">Post content</div>
  {% else %}
  <div class="post-item even-post">Post content</div>
  {% endif %}
  {% endfor %}
  ```

  ```html example.html theme={null}
  <div class="post-item odd-post">Post content</div>
  <div class="post-item even-post">Post content</div>
  <div class="post-item odd-post">Post content</div>
  <div class="post-item even-post">Post content</div>
  ```
</CodeGroup>

### sameas

Überprüft, ob zwei Variablen den gleichen Wert haben.

Im folgenden Beispiel werden zwei Variablen festgelegt und dann wird überprüft, ob sie gleich sind.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% set var_one = True %}
  {% set var_two = True %}
  {% if var_one is sameas var_two  %}
  The variables values are the same.
  {% else %}
  The variables values are different.
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  The variables values are the same.
  ```
</CodeGroup>

### sequence

Ähnlich wie der **iterable**-Test wird mit diesem Ausdruckstest überprüft, ob eine Variable eine Sequenz ist.

Im folgenden Beispiel wird überprüft, ob eine Variable eine Sequenz ist, und dann wird diese Sequenz von Musikgenres durchlaufen.

<CodeGroup>
  ```html example.html theme={null}
  {% set genres = ["Pop", "Rock", "Disco", "Funk", "Folk", "Metal", "Jazz", "Country", "Hip-Hop", "Classical", "Soul", "Electronica" ] %}
  {% if genres is sequence %}
  <h3>Favorite genres</h3>
  <ul>
  {% for genre in genres %}
  <li>{{ genre }}</li>
  {% endfor %}
  </ul>
  {% else %}
  <h3>Favorite genre:</h3>
  <div class="single-genre">{{ genres }}</div>
  {% endif %}
  ```

  ```html example.html theme={null}
  <ul>
  <li>Pop</li>
  <li>Rock</li>
  <li>Disco</li>
  <li>Funk</li>
  <li>Folk</li>
  <li>Metal</li>
  <li>Jazz</li>
  <li>Country</li>
  <li>Hip-Hop</li>
  <li>Classical</li>
  <li>Soul</li>
  <li>Electronica</li>
  </ul>
  ```
</CodeGroup>

### string

Überprüft, ob der in einer Variablen gespeicherte Wert ein Text ist.

Im folgenden Beispiel wird überprüft, ob eine Variable eine Zeichenkette ist, und wenn ja, wird ein title-Filter angewendet, um die Großschreibung zu ändern.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% set my_var = "title of section" %}
  {% if my_var is string %}
  {{ my_var|title }}
  {% else %}
  my_var is not a string
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  Title Of Section
  ```
</CodeGroup>

### string\_containing

Überprüft, ob ein bereitgestellter Substring in einer anderen Zeichenfolge enthalten ist. Dieser Ausdruckstest wird in Verbindung mit dem Operator `is` verwendet.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% if content.domain is string_containing ".es" %}
  Markup that will only render on content hosted on .es domains
  {% elif content.domain is string_containing ".jp" %}
  Markup that will only render on content hosted on .jp domains
  {% else %}
  Markup that will render on all other domains
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  Markup that will render on all other domains
  ```
</CodeGroup>

### string\_startingwith

Überprüft, ob eine Zeichenkette mit einer bestimmten Zeichenkette beginnt. Er wird in Verbindung mit dem Operator `is` verwendet.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% if content.slug is string_startingwith "es/" %}
  Markup that will only render on content hosted in a /es/ subdirectory
  {% elif content.slug is string_startingwith "jp/" %}
  Markup that will only render on content hosted in a /jp/ subdirectory
  {% else %}
  Markup that will render on all subdirectories
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  Markup that will render on all subdirectories
  ```
</CodeGroup>

### truthy

Überprüft, ob ein Ausdruck als `True` ausgewertet wird.

Im folgenden Beispiel wird ein boolesches Kontrollkästchenmodul verwendet, um eine Warnmeldung anzuzeigen.

<CodeGroup>
  ```html example.html theme={null}
  {% boolean "check_box" label="Show alert", value=True, export_to_template_context=True %}

  {% if widget_data.check_box.value is truthy %}
  <div class="alert">Danger!</div>
  {% endif %}
  ```

  ```html example.html theme={null}
  <div class="alert">Danger!</div>
  ```
</CodeGroup>

### undefined

Überprüft, ob eine Variable im Kontext der Vorlage undefiniert ist. Dieser Test unterscheidet sich vom `none`-Ausdruckstest dadurch, dass undefined `true` ist, wenn die Variable vorhanden ist, aber keinen Wert hat; none hingegen ist `true`, wenn die Variable einen Nullwert hat.

Im folgenden Beispiel wird eine Vorlage auf das Vorhandensein der Variablen "my\_var" überprüft.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% if my_var is undefined %}
  A variable named "my_var" does not exist on this template.
  {% else %}
  {{ my_var }}
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  A variable named "my_var" does not exist on this template.
  ```
</CodeGroup>

### upper

Überprüft, ob eine Zeichenkette durchgehend in Großbuchstaben geschrieben ist. Nachfolgend finden Sie ein umgekehrtes Beispiel für den [obigen Test](#lower) des `lower`-Ausdrucks.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% module "my_text" path="@hubspot/text" label="Enter text", value="Some TEXT that should be Uppercase", export_to_template_context=True %}

  {% unless widget_data.my_text.value is upper %}
  {{ widget_data.my_text.value|upper }}
  {% endunless %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  SOME TEXT THAT SHOULD BE UPPERCASE
  ```
</CodeGroup>

### within

Überprüft, ob eine Variable in einer Liste vorhanden ist.

<CodeGroup>
  ```text hubl.txt theme={null}
  {% set numbers = [1, 2, 3] %}

  {% if 2 is within numbers %}
  2 is in the list!
  {% endif %}

  {% if 4 is within numbers %}
  4 is in the list!
  {% endif %}
  ```

  ```text gerenderte ausgabe.txt theme={null}
  2 is in the list!
  ```
</CodeGroup>