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

# Operadores y pruebas de expresiones

> Para ampliar la lógica y la funcionalidad de tus plantillas, HubL admite varios operadores clave y pruebas de expresión. Los operadores permiten ejecutar funciones matemáticas, realizar comparaciones, generar lógica más compleja en las plantillas y modificar la representación del marcado. Además, este artículo contiene una lista completa de pruebas de expresión que pueden utilizarse en HubL.

Para ampliar la lógica y la funcionalidad de tus plantillas, HubL admite varios operadores clave y pruebas de expresión. Los [operadores](/cms/reference/hubl/operators-and-expression-tests#operators) permiten ejecutar funciones matemáticas, realizar comparaciones, generar lógica más compleja en las plantillas y modificar la representación del marcado. Además, este artículo contiene una lista completa de [pruebas de expresión](/cms/reference/hubl/operators-and-expression-tests#expression-tests) que se pueden utilizar en HubL.

## Operadores

Los operadores son símbolos que indican al compilador de HubL que ejecute diversas operaciones que dan lugar al output final del marcador. Los operadores se colocan entre los operadores para relacionar ambos valores, ya sea para ejecutar funciones matemáticas, realizar comparaciones o implementar expresiones booleanas.

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

A continuación están los operadores que puedes utilizar en HubL, organizados por el tipo.

### Matemáticas

Los operadores matemáticos estándar pueden utilizarse para calcular valores en el contexto de una plantilla.

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

| Símbolo | Descripción                                                                                                                                  |
| ------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `+`     | Suma dos objetos, generalmente valores numéricos. Para concatenar cadenas o listas, debes utilizar el [operador `~`](#other-hubl-operators). |
| `-`     | Resta un número de otro.                                                                                                                     |
| `/`     | Divide números                                                                                                                               |
| `%`     | Devuelve el resto de la división de números                                                                                                  |
| `//`    | Divide dos números y devuelve el resultado entero truncado. Por ejemplo, `{{ 20 // 7 }}` es `2`.                                             |
| `*`     | Multiplica números                                                                                                                           |
| `**`    | Eleva el operador izquierdo a la potencia del operador derecho                                                                               |

### Comparación

Los operadores de comparación se pueden utilizar para evaluar valores para la lógica de la plantilla. Puedes ver algunos ejemplos de operadores de comparación en las [sentencias if](/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 -->
```

| Símbolo | Abreviación | Descripción                                                                                                   |
| ------- | ----------- | ------------------------------------------------------------------------------------------------------------- |
| `==`    | eq          | Igual a. Evalúa como verdadero si los dos objetos tienen valores iguales.                                     |
| `!=`    | ne          | No es igual a. Se evalúa como verdadero si dos objetos no son iguales.                                        |
| `>`     | gt          | Mayor que. Evalúa como verdadero si el valor del operador izquierdo es mayor que el del operador derecho.     |
| `>=`    | gte         | Mayor que o igual a. Evalúa como verdadero si el operador izquierdo es mayor o igual que el operador derecho. |
| `<`     | lt          | Menor que. Evalúa como verdadero si el operador izquierdo es menor que el operador derecho.                   |
| `<=`    | lte         | Menor que o igual a. Evalúa como verdadero si el operador izquierdo es menor o igual que el operador derecho. |

<Tip>
  La versión abreviada de los operadores de comparación se puede utilizar en filtros que implican la comprobación de una expresión como [`|selectattr()`](/cms/reference/hubl/filters#selectattr).
</Tip>

### Lógica

Los operadores lógicos te permiten implementar expresiones booleanas, así como combinar varias expresiones en una sola instrucción.

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

| Símbolo  | Descripción                                                                                                                                                                                                                                                                                          |
| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `and`    | Devuelve `true` si tanto el operador izquierdo como el derecho son verdaderos. En caso contrario, devuelve `false`. <br /><br />Este operador no se comporta como el operador `and` en Python o el operador `&&` en JavaScript. Más información sobre el uso de los operadores `and` a continuación. |
| `or`     | Devuelve el primer operador si es verdadero. En caso contrario, devuelve el segundo operador. <br /><br />Este operador es equivalente a `or` en Python y <code>\|\|</code> en JavaScript Más información sobre el uso de los operadores `or` a continuación.                                        |
| `is`     | Une dos operadores para una declaración afirmativa.                                                                                                                                                                                                                                                  |
| `not`    | Niega una afirmación, junto con `is`.                                                                                                                                                                                                                                                                |
| `(expr)` | Agrupa una expresión para el orden de las operaciones. Por ejemplo, `(10 - 2) * variable`.                                                                                                                                                                                                           |
| `?`      | El [operador ternario](/cms/reference/hubl/if-statements) puede utilizarse para escribir rápidamente la lógica condicional. Acepta 3 argumentos: expresión, condición verdadera, condición falsa. Evalúa una expresión y devuelve la condición correspondiente.                                      |

**Utilizar operadores "and" y "or"**

En HubL, el operador `or` se comporta como el operador `or` en Python y como el operador `||` en JavaScript. Devolverá el primer operador si la expresión se evalúa como verdadera, en caso contrario devolverá el segundo operador. Un caso de uso habitual del operador `or` es el ajuste de un valor alternativo cuando no está definido el valor de una variable.

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

Sin embargo, el operador `and` se comporta de forma diferente al operador `and` en Python y al operador `&&` en JavaScript. En HubL, `and` siempre devolverá un valor booleano: cuando la expresión se evalúe como verdadera, se devolverá `true`, de lo contrario devolverá `false`. Por otra parte, los operadores de Python y JavaScript devolverán un valor de operando dependiendo si la instrucción se evalúa como verdadera o falsa.

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

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

En HubL, las listas vacías (`[]`) y los dicc. vacíos (`{}`) se consideran falsos. Esto es equivalente al comportamiento en Python, pero diferente de JavaScript, donde `[]` y `{}` son veraces.

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

### Otros operadores de HubL

A continuación se encuentran otros operadores importantes de HubL que pueden utilizarse para realizar diversas tareas.

| Símbolo         | Descripción                                                                                             |
| --------------- | ------------------------------------------------------------------------------------------------------- |
| `in`            | Comprueba si un valor está en una secuencia.                                                            |
| `is`            | Realiza una [prueba de expresión](/cms/reference/hubl/operators-and-expression-tests#expression-tests). |
| <code>\|</code> | Aplica un filtro.                                                                                       |
| `~`             | Concatena los valores.                                                                                  |

## Pruebas de expresión

Las pruebas de expresión son varias condiciones booleanas que pueden evaluarse utilizando operadores lógicos.

### boolean

Verifica si el objeto es booleano (en un sentido estricto, no solo si puede evaluarse como una expresión verdadera).

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

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

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

### containing

La prueba de expresión comprueba si una variable de lista tiene un valor en ella.

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

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

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

### containingall

La prueba de expresión comprueba si una variable de lista contiene todos los valores de otra lista.

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

### defined

La prueba de expresión comprueba si una variable está definida en el contexto de la plantilla. Aunque puedes utilizar esta prueba de expresión, al escribir una sentencia if sin ningún operador se comprobará por opción predeterminada si la variable está definida o no.

En el siguiente ejemplo, se comprueba el parámetro de color de un módulo de color. Si el parámetro de color no tuviera ningún valor, la plantilla, por opción predeterminada, mostraría un color de fondo negro. Si se define, muestra el color de fondo establecido por el usuario.

<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

Comprueba si un objeto es divisible por otro número.

Por ejemplo, a continuación se crea un bucle for que itera a través de una lista de tipos de animales. Cada tipo de animal se imprime en un div, y al quinto div tiene aplicado un estilo en línea diferente (width:100%). Este concepto podría aplicarse a un blog en el que se renderiza un marcador diferente para un determinado patrón de entradas. Para saber más sobre los bucles for y loop.index, [consulta este artículo](/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

Comprueba si el valor de una variable es igual a una constante o a otra variable. También puedes utilizar el operador `==` para realizar la misma prueba.

En el siguiente ejemplo, el ancho de loas publicaciones del blog se ajusta en función del número total de entradas en el bucle. La salida del ejemplo supone que hay 4 publicaciones en el 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

Comprueba si una variable numérica es un número par.

El siguiente ejemplo muestra un bucle simplificado de listado de blogs, en el que si la iteración actual del bucle es par, se asigna una clase de `even-post` al div del elemento de la entrada. De lo contrario, se asigna una clase de `odd-post`.

<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

Comprueba si una variable numérica es un número de punto flotante.

<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

Comprueba si una variable es un entero.

<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

Comprueba si una variable se puede recorrer en bucle.

Este ejemplo comprueba una variable llamada `jobs` para ver si puede ser iterada. Como la variable contiene una lista de trabajos, la [sentencia if](/cms/reference/hubl/if-statements) se evaluaría como `true` y el bucle se ejecutaría. Si la variable contuviera un solo valor, la sentencia if imprimiría ese valor con un marcador diferente. [Más información sobre los bucles for](/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

Comprueba si una cadena está en minúsculas.

El siguiente ejemplo utiliza una [instrucción unless](/cms/reference/hubl/if-statements#unless-statements) y un filtro lower para asegurar que una cadena de texto introducida en un módulo de texto esté siempre en minúsculas.

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

### mapping

Comprueba si un objeto es un dicc. (diccionario).

El siguiente ejemplo comprueba si el objeto de contacto es un diccionario.

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

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

### none

Comprueba si una variable tiene un valor `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 resultados renderizados.txt theme={null}
  example@hubspot.com
  ```
</CodeGroup>

### number

Comprueba si el valor de una variable es un número.

El siguiente ejemplo comprueba si una variable es o no una variable, y si es así la convierte en millones.

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

### odd

Comprueba si una variable numérica es un número impar.

A continuación se muestra el mismo ejemplo que la prueba de expresión par inversa descrita anteriormente.

<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

Comprueba si dos variables tienen o no el mismo valor.

El siguiente ejemplo establece dos variables y luego comprueba si son iguales o no.

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

### sequence

Similar a la prueba **iterable**, esta prueba de expresión comprueba si una variable es una secuencia.

El siguiente ejemplo comprueba si una variable es una secuencia y luego itera a través de esa secuencia de géneros musicales.

<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

Comprueba si el valor almacenado en una variable es texto.

El siguiente ejemplo comprueba si una variable es o no una cadena, y si es así, aplica un filtro de título para cambiar las mayúsculas.

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

### string\_containing

Comprueba si una subcadena está contenida dentro de otra cadena. Esta prueba de expresión se utiliza junto con el operador `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 resultados renderizados.txt theme={null}
  Markup that will render on all other domains
  ```
</CodeGroup>

### string\_startingwith

Comprueba si una cadena empieza por una cadena determinada. Se utiliza junto con el operador `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 resultados renderizados.txt theme={null}
  Markup that will render on all subdirectories
  ```
</CodeGroup>

### truthy

Comprueba si una expresión se evalúa como `True`.

El siguiente ejemplo utiliza un módulo de casilla de verificación booleana para mostrar un mensaje de alerta.

<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

Comprueba si una variable está indefinida en el contexto de la plantilla. Esta prueba es diferente de la de `none`, ya que undefined será `true` cuando la variable esté presente pero no tenga ningún valor; mientras que none será `true` cuando la variable tenga un valor nulo.

El siguiente ejemplo comprueba la existencia de la variable "my\_var" en una plantilla.

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

### upper

Comprueba si una cadena está toda en mayúsculas. A continuación se muestra un ejemplo inverso de la prueba de expresión `lower` [anterior](#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 resultados renderizados.txt theme={null}
  SOME TEXT THAT SHOULD BE UPPERCASE
  ```
</CodeGroup>

### within

Comprueba si una variable está presente en una lista.

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