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

# Opérateurs et tests d'expression

> Afin d'étendre la logique et la fonctionnalité de vos modèles, HubL prend en charge plusieurs opérateurs et tests d'expression clés. Les opérateurs vous permettent d'exécuter des fonctions mathématiques, d'effectuer des comparaisons, de compliquer la logique des modèles et de modifier la restitution du balisage. En outre, cet article contient une liste complète des tests d'expression qui peuvent être utilisés dans HubL.

Afin d'étendre la logique et la fonctionnalité de vos modèles, HubL prend en charge plusieurs opérateurs et tests d'expression clés. Les [opérateurs](/docs/cms/reference/hubl/operators-and-expression-tests#operators) vous permettent d'exécuter des fonctions mathématiques, d'effectuer des comparaisons, de compliquer la logique des modèles et de modifier la restitution du balisage. En outre, cet article contient une liste complète des [tests d'expression](/docs/cms/reference/hubl/operators-and-expression-tests#expression-tests) qui peuvent être utilisés dans HubL.

## Opérateurs

Les opérateurs sont des symboles qui indiquent au compilateur HubL d'exécuter diverses opérations qui aboutissent à la sortie finale. Les opérateurs sont placés entre opérandes afin de relier les deux valeurs, que ce soit pour exécuter des fonctions mathématiques, effectuer des comparaisons ou implémenter des expressions booléennes.

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

Vous trouverez ci-dessous les opérateurs que vous pouvez utiliser dans HubL, organisés par type.

### Mathématiques

Les opérateurs mathématiques standard peuvent être utilisés pour calculer des valeurs dans le contexte d'un modèle.

```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 -->
```

| Symbole | Description                                                                                                                                                                 |
| ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `+`     | Ajoute deux objets, généralement des valeurs numériques. Pour concaténer des chaînes ou des listes, vous devez utiliser l'[opérateur`~`](#other-hubl-operators) à la place. |
| `-`     | Soustrait un nombre d'un autre.                                                                                                                                             |
| `/`     | Divise des nombres.                                                                                                                                                         |
| `%`     | Renvoie le reste de la division de nombres.                                                                                                                                 |
| `//`    | Divise deux nombres et renvoie le résultat entier tronqué. Par exemple, `{{ 20 // 7 }}` ou `2`.                                                                             |
| `*`     | Multiplie des nombres.                                                                                                                                                      |
| `**`    | Élève l'opérande gauche à la puissance de l'opérande droit                                                                                                                  |

### Comparaison

Les opérateurs de comparaison peuvent être utilisés pour évaluer les valeurs pour la logique de modèle. Vous pouvez consulter quelques exemples d'utilisation d'opérateurs de comparaison dans les [fonctions if](/docs/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 -->
```

| Symbole | sténographie | Description                                                                                                 |
| ------- | ------------ | ----------------------------------------------------------------------------------------------------------- |
| `==`    | eq           | Égal à. Est défini sur true si les deux objets ont des valeurs égales.                                      |
| `!=`    | ne           | N'est pas égal à. Est défini sur true si les deux objets ne sont pas égaux.                                 |
| `>`     | gt           | Est supérieur à. Est défini sur true si la valeur de l'opérande gauche est supérieure à l'opérande droit.   |
| `>=`    | gte          | Est supérieur ou égal à. Est défini sur true si l'opérande gauche est supérieur ou égal à l'opérande droit. |
| `<`     | lt           | Inférieur à. Est défini sur true si l'opérande gauche est inférieur à l'opérande droit.                     |
| `<=`    | lte          | Est inférieur ou égal à. Est défini sur true si l'opérande gauche est inférieur ou égal à l'opérande droit. |

<Tip>
  La version abrégée des opérateurs de comparaison est utilisable dans les filtres HubL qui impliquent de tester une expression comme [`|selectattr()`](/docs/cms/reference/hubl/filters#selectattr).
</Tip>

### Logique

Les opérateurs logiques vous permettent d'implémenter des expressions booléennes ainsi que de combiner plusieurs expressions en instructions conditionnelles uniques.

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

| Symbole  | Description                                                                                                                                                                                                                                                                                              |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `and`    | Renvoie `true` si l'opérande gauche et l'opérande droit sont exacts. Dans le cas contraire, renvoie `false`. <br /><br />Cet opérateur ne se comporte pas comme l'opérateur `and` en Python ou l'opérateur `&&` en JavaScript. Découvrez-en davantage sur l'utilisation des opérateurs `and` ci-dessous. |
| `or`     | Renvoie le premier opérande s'il est exact. Sinon, renvoie le deuxième opérande. <br /><br />Cet opérateur est équivalent à `or` en Python et JavaScript<code>\|\|</code> Découvrez-en davantage sur l'utilisation des opérateurs `or` ci-dessous.                                                       |
| `is`     | Associe deux opérandes pour un énoncé affirmatif.                                                                                                                                                                                                                                                        |
| `not`    | Invalide une instruction conditionnelle, en conjonction avec `is`.                                                                                                                                                                                                                                       |
| `(expr)` | Regroupe une expression conditionnelle pour l'ordre des opérations. Par exemple : `(10 - 2) * variable`.                                                                                                                                                                                                 |
| `?`      | L'[opérateur ternaire](/docs/cms/reference/hubl/if-statements) peut être utilisé pour écrire rapidement une logique conditionnelle. Il accepte 3 arguments (expression, condition true, condition false). Il évalue une expression et renvoie la condition correspondante.                                    |

**Utilisation des opérateurs et/ou**

Dans HubL, l'opérateur `or` se comporte comme l'opérateur `or` en Python et l'opérateur `||` en JavaScript. Il renverra le premier opérande si l'expression conditionnelle est définie comme true, sinon il renverra le deuxième opérande. Un cas d'utilisation courant de l'opérateur `or` consiste à définir une valeur de secours lorsqu'une valeur de variable n'est pas définie.

```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" -->
```

Cependant, l'opérateur `and` se comporte différemment de l'opérateur `and` en Python et de l'opérateur `&&` en JavaScript. Dans HubL, `and` renvoie toujours une valeur booléenne : lorsque l'expression est évaluée comme true, `true` est renvoyée, sinon elle renvoie `false`. Les opérateurs Python et JavaScript, quant à eux, renverront une valeur d'opérande selon que l'instruction est définie sur true ou false.

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

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

Dans HubL, les listes vides (`[]`) et les dictionnaires vides (`{}`) sont considérés comme faux. C'est équivalent au comportement de Python, mais différent de JavaScript, où `[]` et `{}` sont exacts.

```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 -->
```

### Autres opérateurs HubL

Vous trouverez ci-dessous d'autres opérateurs HubL importants qui peuvent être utilisés pour effectuer diverses tâches.

| Symbole         | Description                                                                                           |
| --------------- | ----------------------------------------------------------------------------------------------------- |
| `in`            | Vérifie si une valeur se trouve dans une séquence.                                                    |
| `is`            | Effectue un [test d'expression](/docs/cms/reference/hubl/operators-and-expression-tests#expression-tests). |
| <code>\|</code> | Applique un filtre.                                                                                   |
| `~`             | Concatène les valeurs.                                                                                |

## Tests d'expression

Les tests d'expression sont diverses conditions booléennes qui peuvent être évaluées à l'aide d'opérateurs logiques.

### boolean

Vérifie si l'objet est booléen (au sens strict, pas dans sa capacité d'évaluation pour une expression véridique).

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

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

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

### containing

Vérifie si une variable de liste contient une valeur.

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

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

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

### containingall

Vérifie si une variable de liste contient toutes les valeurs d'une autre liste.

<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 sortie rendue.txt theme={null}
  Set contains 2 and 3!
  ```
</CodeGroup>

### defined

Vérifie si une variable est définie dans le contexte du modèle. Bien que vous puissiez utiliser ce test d'expression, l'écriture d'une fonction if sans aucun opérateur aura pour effet de vérifier par défaut si la variable est définie ou non.

Dans l'exemple ci-dessous, le paramètre color d'un module de couleur est testé. Si le paramètre color n'avait pas de valeur, le modèle afficherait une couleur de fond noire par défaut. S'il est défini, la couleur d'arrière-plan définie par l'utilisateur sera restituée.

<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

Vérifie si un objet est divisible par un autre nombre.

Par exemple, ci-dessous, une boucle for est créée pour parcourir une liste de types d'animaux. Chaque type d'animal est imprimé dans une division et un style en ligne différent est appliqué toutes les 5 divisions (largeur :100 %). Ce concept pourrait être appliqué à un blog où un balisage différent est restitué pour un certain modèle d'article. Pour en savoir plus sur les boucles for et loop.index, [consultez cet article](/docs/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

Vérifie si la valeur d'une variable est égale à une constante ou à une autre variable. Vous pouvez également utiliser l'opérateur `==` pour effectuer le même test.

Dans l'exemple ci-dessous, la largeur des articles du blog est ajustée en fonction du nombre total d'articles dans la boucle. L'exemple de sortie suppose qu'il y a 4 articles dans le blog.

<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

Vérifie si une variable numérique est un nombre pair.

L'exemple ci-dessous montre une boucle simplifiée d'énumération de blog, où si l'itération actuelle de la boucle est paire, une classe `even-post` est attribuée à la division d'élément d'article. Autrement, une classe `odd-post` est attribuée.

<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

Vérifie si une variable numérique est un nombre à virgule flottante.

<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

Vérifie si une variable est un nombre entier.

<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

Vérifie si une variable peut être parcourue en boucle.

Cet exemple vérifie une variable appelée `jobs` pour voir si elle peut être parcourue par itération. Comme la variable contient une liste de tâches, la [fonction if](/docs/cms/reference/hubl/if-statements) est définie sur `true` et la boucle s'exécute. Si la variable avait contenu une seule valeur, la fonction if aurait imprimé cette valeur avec un balisage différent à la place. [ Découvrez-en davantage sur les boucles for](/docs/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

Vérifie si une chaîne est en minuscules.

L'exemple ci-dessous utilise une [fonction unless](/docs/cms/reference/hubl/if-statements#unless-statements) et un filtre pour vérifier qu'une chaîne de texte saisie dans un module de texte est toujours en minuscules.

<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 sortie rendue.txt theme={null}
  some text that should be lowercase
  ```
</CodeGroup>

### mapping

Vérifie si un objet est un dictionnaire

L'exemple ci-dessous vérifie si l'objet de contact est un dictionnaire.

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

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

### none

Vérifie si une variable a une valeur `null`.

<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 sortie rendue.txt theme={null}
  example@hubspot.com
  ```
</CodeGroup>

### number

Vérifie si la valeur d'une variable est un nombre.

L'exemple ci-dessous vérifie si une variable est ou non une variable et, si tel est le cas, la convertit en millions.

<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 sortie rendue.txt theme={null}
  40000000
  ```
</CodeGroup>

### odd

Vérifie si une variable numérique est un nombre impair.

Vous trouverez ci-dessous le même exemple que le test d'expression inverse even décrit précédemment.

<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

Vérifie si deux variables ont ou non la même valeur.

L'exemple ci-dessous définit deux variables et vérifie ensuite si elles sont identiques ou non.

<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 sortie rendue.txt theme={null}
  The variables values are the same.
  ```
</CodeGroup>

### sequence

Semblable au test **iterable**, ce test d'expression vérifie si une variable est une séquence.

L'exemple ci-dessous vérifie si une variable est une séquence, puis parcourt cette séquence de genres musicaux.

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

### chaîne

Vérifie si la valeur stockée dans une variable est du texte.

L'exemple ci-dessous vérifie si une variable est une chaîne de caractères et, si tel est le cas, applique un filtre de titre pour modifier la capitalisation.

<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 sortie rendue.txt theme={null}
  Title Of Section
  ```
</CodeGroup>

### string\_containing

Vérifie si une sous-chaîne fournie est contenue dans une autre chaîne. Ce test d'expression est utilisé en conjonction avec l'opérateur `is`.

<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 sortie rendue.txt theme={null}
  Markup that will render on all other domains
  ```
</CodeGroup>

### string\_startingwith

Vérifie si une chaîne commence par une chaîne particulière. Il est utilisé en conjonction avec l'opérateur `is`.

<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 sortie rendue.txt theme={null}
  Markup that will render on all subdirectories
  ```
</CodeGroup>

### truthy

Vérifie si une expression est égale à `True`.

L'exemple ci-dessous utilise un module de case à cocher booléenne pour afficher un message d'alerte.

<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

Vérifie si une variable est indéfinie dans le contexte du modèle. Ce test est différent du test d'expression `none`, dans la mesure où le test undefined est défini sur `true` lorsque la variable est présente mais n'a pas de valeur, alors que none est défini sur `true` lorsque la variable a une valeur nulle.

L'exemple ci-dessous vérifie l'existence de la variable "my\_var" dans un modèle.

<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 sortie rendue.txt theme={null}
  A variable named "my_var" does not exist on this template.
  ```
</CodeGroup>

### upper

Vérifie si une chaîne est entièrement en majuscules. Vous trouverez ci-dessous un exemple inverse du test d'expression `lower` [ci-dessus](#lower).

<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 sortie rendue.txt theme={null}
  SOME TEXT THAT SHOULD BE UPPERCASE
  ```
</CodeGroup>

### within

Vérifie si une variable est présente dans une liste.

<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 sortie rendue.txt theme={null}
  2 is in the list!
  ```
</CodeGroup>