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

# Testes de expressão e operadores

> Para expandir a lógica e a funcionalidade dos seus modelos, o HubL aceita vários operadores-chave e testes de expressão. Os operadores permitem executar funções matemáticas, fazer comparações, complicar a lógica do modelo e alterar a renderização da marcação. Além disso, este artigo contém uma lista abrangente de testes de expressão que podem ser usados no HubL.

Para expandir a lógica e a funcionalidade dos seus modelos, o HubL aceita vários operadores-chave e testes de expressão. Os [operadores](/cms/reference/hubl/operators-and-expression-tests#operators) permitem executar funções matemáticas, fazer comparações, complicar a lógica do modelo e alterar a renderização da marcação. Além disso, este artigo contém uma lista abrangente de[ testes de expressão](/cms/reference/hubl/operators-and-expression-tests#expression-tests) que podem ser usados no HubL.

## Operadores

Os operadores são símbolos que dizem ao compilador HubL para executar várias operações que resultam na saída final. Operadores são colocados entre operandos para relacionar os dois valores, seja para executar funções matemáticas, fazer comparações ou implementar expressões booleanas.

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

Abaixo estão os operadores que você pode usar no HubL, organizados por tipo.

### Matemática

Os operadores matemáticos padrão podem ser usados para calcular valores no contexto de um modelo.

```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 | Descrição                                                                                                                                            |
| ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `+`     | Soma dois objetos, geralmente valores numéricos. Para concatenar strings ou listas, você deve usar o [operador`~`](#other-hubl-operators) em vez de. |
| `-`     | Subtrai um número de outro.                                                                                                                          |
| `/`     | Divide números.                                                                                                                                      |
| `%`     | Retorna o restante da divisão de números                                                                                                             |
| `//`    | Divida dois números e retorne o resultado inteiro truncado. Por exemplo, `{{ 20 // 7 }}` é `2`.                                                      |
| `*`     | Multiplica números.                                                                                                                                  |
| `**`    | Eleve o operando esquerdo ao poder do operando direito.                                                                                              |

### Comparação

Os operadores de comparação podem ser usados para avaliar os valores da lógica do modelo. Você pode ver alguns exemplos de operadores de comparação sendo usados nas [instruções se](/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 | encurtado | Descrição                                                                                               |
| ------- | --------- | ------------------------------------------------------------------------------------------------------- |
| `==`    | eq        | Igual a. Avalia como verdadeiro se os dois objetos têm valores iguais.                                  |
| `!=`    | ne        | Não é igual a. Avalia como verdadeiro se os dois objetos não forem iguais.                              |
| `>`     | gt        | Maior que. Avalia como verdadeiro se o valor do operando esquerdo for maior que o do operando direito.  |
| `>=`    | gte       | Maior ou igual a. Avalia como verdadeiro se o operando esquerdo for maior ou igual ao operando direito. |
| `<`     | It        | Menor que. Avalia como verdadeiro se o operando esquerdo for menor que o operando direito.              |
| `<=`    | lte       | Menor ou igual a. Avalia como verdadeiro se o operando esquerdo for menor ou igual ao operando direito. |

<Tip>
  A versão abreviada dos operadores de comparação pode ser usada em filtros HubL que envolvem testar uma expressão como [`|selectattr()`](/cms/reference/hubl/filters#selectattr).
</Tip>

### Lógico

Operadores lógicos permitem implementar expressões booleanas, bem como combinar múltiplas expressões em instruções únicas.

<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  | Descrição                                                                                                                                                                                                                                                                        |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `and`    | Retornos `true` se tanto o operando esquerdo quanto o direito forem verdadeiros. Caso contrário, retorna `false`. <br /><br />Este operador não se comporta como o operador `and` em Python ou o operador `&&` em JavaScript. Saiba mais sobre o uso de operadores `and` abaixo. |
| `or`     | Retorna o primeiro operando se for verdadeiro. Caso contrário, retorna o segundo operando. <br /><br />Este operador é equivalente a `or` em Python e <code>\|\|</code> em JavaScript. Saiba mais sobre o uso de operadores `or` abaixo.                                         |
| `is`     | Une dois operandos para uma declaração afirmativa.                                                                                                                                                                                                                               |
| `not`    | Nega uma afirmação, em conjunto com `is`.                                                                                                                                                                                                                                        |
| `(expr)` | Agrupa uma expressão para a ordem de operações. Por exemplo, `(10 - 2) * variable`.                                                                                                                                                                                              |
| `?`      | O [operador ternário](/cms/reference/hubl/if-statements) pode ser usado para escrever rapidamente lógica condicional. Aceita 3 argumentos: expressão, condição verdadeira, condição falsa. Avalia uma expressão e retorna a condição correspondente.                             |

**Usando operadores e/ou**

No HubL, o operador `or` se comporta como o operador `or` em Python e o operador `||` em JavaScript. Ele retornará o primeiro operando se a expressão for avaliada como verdadeira, caso contrário, retornará o segundo operando. Um caso de uso comum para o operador `or` está definindo um valor de fallback quando um valor de variável não está definido.

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

No entanto, o operador `and` se comporta de forma diferente do operador `and` em Python e o operador `&&` em JavaScript. No HubL, `and` sempre retornará um valor booleano: quando a expressão for avaliada como verdadeira, `true` é retornado, caso contrário retornará `false`. Os operadores Python e JavaScript, por outro lado, retornarão um valor de operando com base na avaliação da instrução como verdadeira ou 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 -->
```

No HubL, listas vazias (`[]`) e dicionários vazios (`{}`) são considerados falsos. Isso é equivalente ao comportamento em Python, mas diferente do JavaScript, onde `[]` e `{}` são verdadeiros.

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

### Outros operadores do HubL

Veja abaixo outros operadores do HubL importantes que podem ser usados para executar várias tarefas.

| Símbolo         | Descrição                                                                                             |
| --------------- | ----------------------------------------------------------------------------------------------------- |
| `in`            | Verifica se um valor está em uma sequência.                                                           |
| `is`            | Executa um [teste de expressão](/cms/reference/hubl/operators-and-expression-tests#expression-tests). |
| <code>\|</code> | Aplica um filtro.                                                                                     |
| `~`             | Concatena valores.                                                                                    |

## Testes de expressão

Os testes de expressão são várias condições booleanas que podem ser avaliadas por operadores lógicos.

### boolean

Testa se o objeto é booleano (em sentido estrito, não em sua capacidade de ser avaliado como uma expressão verdadeira).

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

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

  ```text saída renderizada.txt theme={null}
  isActive is a boolean
  ```
</CodeGroup>

### containing

Testa se uma variável de lista tem um valor.

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

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

  ```text saída renderizada.txt theme={null}
  Set contains 2!
  ```
</CodeGroup>

### containingall

Testa se uma variável de lista contém todos os valores de outra 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 saída renderizada.txt theme={null}
  Set contains 2 and 3!
  ```
</CodeGroup>

### defined

Testa se uma variável está definida dentro do contexto do modelo. Embora você possa usar esse teste de expressão, escrever uma instrução if sem operador será o padrão para verificar se a variável está definida ou não.

No exemplo abaixo, o parâmetro de cor de um módulo de cor é testado. Se o parâmetro de cor não contiver um valor, o modelo renderizará uma cor de fundo preta padrão. Se for definido, ele renderizará a cor de fundo definida pelo usuário.

<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

Testa se um objeto é divisível por outro número.

Por exemplo, abaixo, é criado um loop for que itera através de uma lista de tipos de animais. Cada tipo de animal é impresso em uma div, e cada 5ª div tem um estilo em linha diferente aplicado (largura:100%). Esse conceito pode ser aplicado a um blog em que uma marcação diferente é renderizada para um determinado padrão de posts. Para saber mais sobre loops e loop.index,[ confira este artigo](/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

Testa se o valor de uma variável é igual a uma constante ou a outra variável. Você também pode usar o operador `==` para fazer o mesmo teste.

No exemplo abaixo, a largura dos posts do blog é ajustada com base no número total de postagens no loop. O exemplo de saída pressupõe que havia 4 posts no 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

Testa se uma variável numérica é um número par.

O exemplo abaixo mostra um loop de listagem de blog simplificado, em que, se a iteração atual do loop for par, uma classe de `even-post` será atribuída ao div do item do post. Caso contrário, uma classe de `odd-post` é atribuída.

<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

Testa se uma variável numérica é um número de ponto flutuante.

<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

Testa se uma variável é um inteiro.

<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

Testa se uma variável pode ser percorrida em loop.

Este exemplo verifica uma variável chamada `jobs` para ver se é possível iterar. Como a variável contém uma lista de empregos, o [declaração if](/cms/reference/hubl/if-statements) avaliaria para `true`, e o loop seria executado. Se a variável contivesse um único valor, a instrução if imprimiria esse valor com marcação diferente. [ Saiba mais sobre loops 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

Testa se uma string é minúscula.

O exemplo abaixo usa uma[ instrução unless](/cms/reference/hubl/if-statements#unless-statements) e um filtro inferior para garantir que uma sequência de texto inserida em um módulo de texto esteja sempre em 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 saída renderizada.txt theme={null}
  some text that should be lowercase
  ```
</CodeGroup>

### mapping

Testa se um objeto é um dict (dicionário).

O exemplo abaixo verifica se o objeto de contato é um dicionário.

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

  ```text saída renderizada.txt theme={null}
  This object is a dictionary.
  ```
</CodeGroup>

### none

Testa se uma variável tem um 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 saída renderizada.txt theme={null}
  example@hubspot.com
  ```
</CodeGroup>

### number

Testa se o valor de uma variável é um número.

O exemplo abaixo verifica uma variável para ver se ela é ou não uma variável e, em caso afirmativo, converte-a em milhões.

<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 saída renderizada.txt theme={null}
  40000000
  ```
</CodeGroup>

### odd

Testa se uma variável numérica é um número ímpar.

Abaixo está o mesmo exemplo do teste de expressão inversa par descrito 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

Testa se duas variáveis têm ou não o mesmo valor.

O exemplo abaixo define duas variáveis e, em seguida, verifica se elas são ou não as mesmas.

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

### sequence

Semelhante ao teste **iterável**, esta expressão teste verifica se uma variável é uma sequência.

O exemplo abaixo testa se uma variável é uma sequência e, em seguida, itera por essa sequência de gêneros musicais.

<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

Testa se o valor armazenado em uma variável é texto.

O exemplo abaixo verifica se uma variável é uma string e, se for, aplica um filtro de título para alterar a capitalização.

<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 saída renderizada.txt theme={null}
  Title Of Section
  ```
</CodeGroup>

### string\_containing

Testa se uma substring fornecida está contida em outra string. Este teste de expressão é usado em conjunto com o 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 saída renderizada.txt theme={null}
  Markup that will render on all other domains
  ```
</CodeGroup>

### string\_startingwith

Testa se uma string começa com uma string específica. É usado em conjunto com o 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 saída renderizada.txt theme={null}
  Markup that will render on all subdirectories
  ```
</CodeGroup>

### truthy

Testa se uma expressão é avaliada como `True`.

O exemplo abaixo usa um módulo de caixa de seleção booleana para exibir uma mensagem 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

Testa se uma variável é indefinida no contexto do modelo. Este teste é diferente do teste de expressão `none` em que indefinido será `true` quando a variável está presente, mas não tem valor; enquanto que nenhum será `true` quando a variável tem um valor nulo.

O exemplo abaixo verifica um modelo para a existência da variável "my\_var".

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

### upper

Testa se uma string está toda em letras maiúsculas. Abaixo está um exemplo inverso do teste de expressão `lower` [acima](#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 saída renderizada.txt theme={null}
  SOME TEXT THAT SHOULD BE UPPERCASE
  ```
</CodeGroup>

### within

Testa se uma variável está presente em uma 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 saída renderizada.txt theme={null}
  2 is in the list!
  ```
</CodeGroup>