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

# Filtros de array

> Filtros de array para trabalhar com coleções em templates Liquid.

## `first`

Retorna o primeiro item de um array.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ "Ground control to Major Tom." | split: " " | first }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Ground
    ```
  </CodeGroup>
</Columns>

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign my_array = "zebra, polvo, girafa, tigre" | split: ", " %}
    {{ my_array.first }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    zebra
    ```
  </CodeGroup>
</Columns>

Você pode usar `first` com notação de ponto quando precisar usar o filtro dentro de uma tag:

```liquid theme={null}
{% if my_array.first == "zebra" %}
  Aqui vem uma zebra!
{% endif %}
```

## `last`

Retorna o último item de um array.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ "Ground control to Major Tom." | split: " " | last }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Tom.
    ```
  </CodeGroup>
</Columns>

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign my_array = "zebra, polvo, girafa, tigre" | split: ", " %}
    {{ my_array.last }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    tigre
    ```
  </CodeGroup>
</Columns>

Você pode usar `last` com notação de ponto quando precisar usar o filtro dentro de uma tag:

```liquid theme={null}
{% if my_array.last == "tigre" %}
  Lá vai um tigre!
{% endif %}
```

## `join`

Combina os itens de um array em uma única string usando o argumento como separador.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign beatles = "John, Paul, George, Ringo" | split: ", " %}
    {{ beatles | join: " e " }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    John e Paul e George e Ringo
    ```
  </CodeGroup>
</Columns>

## `reverse`

Inverte a ordem dos itens em um array. `reverse` não pode inverter uma string.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign my_array = "maçãs, laranjas, pêssegos, ameixas" | split: ", " %}

    {{ my_array | reverse | join: ", " }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    ameixas, pêssegos, laranjas, maçãs
    ```
  </CodeGroup>
</Columns>

Embora `reverse` não possa ser usado diretamente em uma string, você pode dividir uma string em um array, inverter o array e juntá-lo novamente encadeando filtros:

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ "Ground control to Major Tom." | split: "" | reverse | join: "" }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    .moT rojaM ot lortnoc dnuorG
    ```
  </CodeGroup>
</Columns>

## `size`

Retorna o número de caracteres em uma string ou o número de itens em um array.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ "Ground control to Major Tom." | size }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    28
    ```
  </CodeGroup>
</Columns>

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign my_array = "maçãs, laranjas, pêssegos, ameixas" | split: ", " %}

    {{ my_array.size }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    4
    ```
  </CodeGroup>
</Columns>

Você pode usar `size` com notação de ponto quando precisar usar o filtro dentro de uma tag:

```liquid theme={null}
{% if site.pages.size > 10 %}
  Este é um website grande!
{% endif %}
```

## `sort`

Classifica itens em um array em ordem sensível a maiúsculas e minúsculas.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign my_array = "zebra, polvo, girafa, Sara Serpente" | split: ", " %}

    {{ my_array | sort | join: ", " }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Sara Serpente, girafa, polvo, zebra
    ```
  </CodeGroup>
</Columns>

Um argumento opcional especifica qual propriedade dos itens do array usar para classificação.

```liquid theme={null}
{% assign products_by_price = collection.products | sort: "price" %}
{% for product in products_by_price %}
  <h4>{{ product.title }}</h4>
{% endfor %}
```

## `sort_natural`

Classifica itens em um array em ordem insensível a maiúsculas e minúsculas.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign my_array = "zebra, polvo, girafa, Sara Serpente" | split: ", " %}

    {{ my_array | sort_natural | join: ", " }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    girafa, polvo, Sara Serpente, zebra
    ```
  </CodeGroup>
</Columns>

Um argumento opcional especifica qual propriedade dos itens do array usar para classificação.

```liquid theme={null}
{% assign products_by_company = collection.products | sort_natural: "company" %}
{% for product in products_by_company %}
  <h4>{{ product.title }}</h4>
{% endfor %}
```

## `map`

Cria um array de valores extraindo os valores de uma propriedade nomeada de outro objeto.

Neste exemplo, assumimos que o objeto `site.pages` contém todos os metadados de um website. Usando `assign` com o filtro `map` cria uma variável que contém apenas os valores das propriedades `category` de tudo no objeto `site.pages`.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign all_categories = site.pages | map: "category" %}

    {% for item in all_categories %}
    - {{ item }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - negócios
    - celebridades
    - estilo de vida
    - esportes
    - tecnologia
    ```
  </CodeGroup>
</Columns>

## `concat`

Concatena (junta) múltiplos arrays. O array resultante contém todos os itens dos arrays de entrada.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign fruits = "maçãs, laranjas, pêssegos" | split: ", " %}
    {% assign vegetables = "cenouras, nabos, batatas" | split: ", " %}

    {% assign everything = fruits | concat: vegetables %}

    {% for item in everything %}
    - {{ item }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - maçãs
    - laranjas
    - pêssegos
    - cenouras
    - nabos
    - batatas
    ```
  </CodeGroup>
</Columns>

Você pode encadear filtros `concat` para juntar mais de dois arrays:

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign furniture = "cadeiras, mesas, prateleiras" | split: ", " %}

    {% assign everything = fruits | concat: vegetables | concat: furniture %}

    {% for item in everything %}
    - {{ item }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - maçãs
    - laranjas
    - pêssegos
    - cenouras
    - nabos
    - batatas
    - cadeiras
    - mesas
    - prateleiras
    ```
  </CodeGroup>
</Columns>

## `uniq`

Remove qualquer elemento duplicado em um array.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign my_array = "formigas, insetos, abelhas, insetos, formigas" | split: ", " %}
    {{ my_array | uniq | join: ", " }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    formigas, insetos, abelhas
    ```
  </CodeGroup>
</Columns>

## `where`

Cria um array incluindo apenas os objetos com um valor de propriedade específico, ou qualquer valor verdadeiro por padrão.

Neste exemplo, suponha que você tem uma lista de produtos e quer mostrar seus produtos de cozinha separadamente. Usando `where`, você pode criar um array contendo apenas os produtos que têm um `"type"` de `"kitchen"`.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    Todos os produtos:
    {% for product in products %}
    - {{ product.title }}
    {% endfor %}

    {% assign kitchen_products = products | where: "type", "kitchen" %}

    Produtos de cozinha:
    {% for product in kitchen_products %}
    - {{ product.title }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Todos os produtos:
    - Aspirador
    - Espátula
    - Televisão
    - Espremedor de alho

    Produtos de cozinha:
    - Espátula
    - Espremedor de alho
    ```
  </CodeGroup>
</Columns>

Digamos que em vez disso você tenha uma lista de produtos e só queira mostrar aqueles que estão disponíveis para compra. Você pode usar `where` com um nome de propriedade mas sem valor de destino para incluir todos os produtos com um valor `"available"` verdadeiro.
Como caso especial, o mesmo acontecerá se o valor de destino for fornecido mas avaliado como `undefined`.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    Todos os produtos:
    {% for product in products %}
    - {{ product.title }}
    {% endfor %}

    {% assign available_products = products | where: "available" %}

    Produtos disponíveis:
    {% for product in available_products %}
    - {{ product.title }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Todos os produtos:
    - Caneca de café
    - Tênis edição limitada
    - Tênis básico

    Produtos disponíveis:
    - Caneca de café
    - Tênis básico
    ```
  </CodeGroup>
</Columns>

O filtro `where` também pode ser usado para encontrar um único objeto em um array quando combinado com o filtro `first`. Por exemplo, digamos que você queira destacar a camisa da sua nova coleção de outono.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign new_shirt = products | where: "type", "shirt" | first %}
    Produto em destaque: {{ new_shirt.title }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Produto em destaque: Colete de tricô estampado havaiano
    ```
  </CodeGroup>
</Columns>

Além disso, `property` pode ser qualquer expressão de variável Liquid válida como usada na sintaxe de saída, exceto que o escopo desta expressão está dentro de cada item. Para o seguinte array `products`:

```javascript theme={null}
const products = [
    { meta: { details: { class: 'A' } }, order: 1 },
    { meta: { details: { class: 'B' } }, order: 2 },
    { meta: { details: { class: 'B' } }, order: 3 }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign selected = products | where: 'meta.details["class"]', "B" %}
    {% for item in selected -%}
    - {{ item.order }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - 2
    - 3
    ```
  </CodeGroup>
</Columns>

## `slice`

Retorna uma substring de 1 caractere começando no índice especificado pelo primeiro argumento. Um segundo argumento opcional especifica o comprimento da substring a ser retornada.

Os índices de string são numerados começando do 0.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ "Liquid" | slice: 0 }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    L
    ```
  </CodeGroup>
</Columns>

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ "Liquid" | slice: 2 }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    q
    ```
  </CodeGroup>
</Columns>

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ "Liquid" | slice: 2, 5 }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    quid
    ```
  </CodeGroup>
</Columns>

Se o primeiro argumento for um número negativo, os índices são contados a partir do final da string:

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ "Liquid" | slice: -3, 2 }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    ui
    ```
  </CodeGroup>
</Columns>

## `where_exp`

Seleciona todos os objetos em um array onde a expressão é verdadeira. Neste exemplo, suponha que você tem uma lista de produtos e quer mostrar seus produtos de cozinha separadamente. Usando `where_exp`, você pode criar um array contendo apenas os produtos que têm um `"type"` de `"kitchen"`.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    Todos os produtos:
    {% for product in products %}
    - {{ product.title }}
    {% endfor %}

    {% assign kitchen_products = products | where_exp: "item", "item.type == 'kitchen'" %}

    Produtos de cozinha:
    {% for product in kitchen_products %}
    - {{ product.title }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Todos os produtos:
    - Aspirador
    - Espátula
    - Televisão
    - Espremedor de alho

    Produtos de cozinha:
    - Espátula
    - Espremedor de alho
    ```
  </CodeGroup>
</Columns>

## `find`

Retorna o primeiro objeto em um array para o qual o atributo consultado tem o valor dado ou retorna `nil` se nenhum item no array satisfizer os critérios dados. Para o seguinte array `members`:

```javascript theme={null}
const members = [
  { graduation_year: 2013, name: 'Jay' },
  { graduation_year: 2014, name: 'John' },
  { graduation_year: 2014, name: 'Jack' }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ members | find: "graduation_year", 2014 | json }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    {"graduation_year":2014,"name":"John"}
    ```
  </CodeGroup>
</Columns>

## `find_exp`

Retorna o primeiro objeto em um array para o qual a expressão dada avalia como verdadeira ou retorna `nil` se nenhum item no array satisfizer a expressão avaliada.

```javascript theme={null}
const members = [
  { graduation_year: 2013, name: 'Jay' },
  { graduation_year: 2014, name: 'John' },
  { graduation_year: 2014, name: 'Jack' }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ members | find_exp: "item", "item.graduation_year == 2014" | json }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    {"graduation_year":2014,"name":"John"}
    ```
  </CodeGroup>
</Columns>

## `find_index`

Retorna o índice baseado em 0 do primeiro objeto em um array para o qual o atributo consultado tem o valor dado ou retorna `nil` se nenhum item no array satisfizer os critérios dados. Para o seguinte array `members`:

```javascript theme={null}
const members = [
  { graduation_year: 2013, name: 'Jay' },
  { graduation_year: 2014, name: 'John' },
  { graduation_year: 2014, name: 'Jack' }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ members | find_index: "graduation_year", 2014 | json }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    1
    ```
  </CodeGroup>
</Columns>

## `find_index_exp`

Retorna o índice baseado em 0 do primeiro objeto em um array para o qual a expressão dada avalia como verdadeira ou retorna `nil` se nenhum item no array satisfizer a expressão avaliada.

```javascript theme={null}
const members = [
  { graduation_year: 2013, name: 'Jay' },
  { graduation_year: 2014, name: 'John' },
  { graduation_year: 2014, name: 'Jack' }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ members | find_index_exp: "item", "item.graduation_year == 2014" | json }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    1
    ```
  </CodeGroup>
</Columns>

## `group_by`

Agrupa os itens de um array por uma propriedade dada. Para o array `members`:

```javascript theme={null}
const members = [
  { graduation_year: 2003, name: 'Jay' },
  { graduation_year: 2003, name: 'John' },
  { graduation_year: 2004, name: 'Jack' }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ members | group_by: "graduation_year" | json: 2 }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    [
      {
        "name": 2003,
        "items": [
          {
            "graduation_year": 2003,
            "name": "Jay"
          },
          {
            "graduation_year": 2003,
            "name": "John"
          }
        ]
      },
      {
        "name": 2004,
        "items": [
          {
            "graduation_year": 2004,
            "name": "Jack"
          }
        ]
      }
    ]
    ```
  </CodeGroup>
</Columns>

## `group_by_exp`

Agrupa os itens de um array usando uma expressão Liquid. Para o array `members` abaixo:

```javascript theme={null}
const members = [
  { graduation_year: 2013, name: 'Jay' },
  { graduation_year: 2014, name: 'John' },
  { graduation_year: 2009, name: 'Jack' }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ members | group_by_exp: "item", "item.graduation_year | truncate: 3, ''" | json: 2 }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    [
      {
        "name": "201",
        "items": [
          {
            "graduation_year": 2013,
            "name": "Jay"
          },
          {
            "graduation_year": 2014,
            "name": "John"
          }
        ]
      },
      {
        "name": "200",
        "items": [
          {
            "graduation_year": 2009,
            "name": "Jack"
          }
        ]
      }
    ]
    ```
  </CodeGroup>
</Columns>

## `has`

Retorna `true` se o array incluir um item para o qual o atributo consultado tem o valor dado ou retorna `false` se nenhum item no array satisfizer os critérios dados. Para o seguinte array `members`:

```javascript theme={null}
const members = [
  { graduation_year: 2013, name: 'Jay' },
  { graduation_year: 2014, name: 'John' },
  { graduation_year: 2014, name: 'Jack' }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ members | has: "graduation_year", 2014 | json }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    true
    ```
  </CodeGroup>
</Columns>

## `has_exp`

Retorna `true` se um item existir em um array para o qual a expressão dada avalia como verdadeira ou retorna `false` se nenhum item no array satisfizer a expressão avaliada.

```javascript theme={null}
const members = [
  { graduation_year: 2013, name: 'Jay' },
  { graduation_year: 2014, name: 'John' },
  { graduation_year: 2014, name: 'Jack' }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {{ members | has_exp: "item", "item.graduation_year == 2014" | json }}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    true
    ```
  </CodeGroup>
</Columns>

## `compact`

Remove quaisquer valores `nil` de um array.

Para este exemplo, suponha que `site.pages` é um array de páginas de conteúdo para um website, e algumas dessas páginas têm um atributo chamado `category` que especifica sua categoria de conteúdo. Se nós mapearmos essas categorias para um array, alguns dos itens do array podem ser `nil` se alguma página não tiver um atributo `category`.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign site_categories = site.pages | map: "category" %}

    {% for category in site_categories %}
    - {{ category }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - negócios
    - celebridades
    -
    - estilo de vida
    - esportes
    -
    - tecnologia
    ```
  </CodeGroup>
</Columns>

Ao usar `compact` quando criamos nosso array `site_categories`, podemos remover todos os valores `nil` no array.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign site_categories = site.pages | map: "category" | compact %}

    {% for category in site_categories %}
    - {{ category }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - negócios
    - celebridades
    - estilo de vida
    - esportes
    - tecnologia
    ```
  </CodeGroup>
</Columns>

## `push`

Adiciona um elemento no array. É NÃO-DESTRUTIVO, ou seja, não modifica o array, mas sim faz uma cópia e modifica essa cópia.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign fruits = "maçãs, laranjas" | split: ", " %}

    {% assign everything = fruits | push: "pêssegos" %}

    {% for item in everything %}
    - {{ item }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - maçãs
    - laranjas
    - pêssegos
    ```
  </CodeGroup>
</Columns>

## `pop`

Remove um elemento do array. É NÃO-DESTRUTIVO, ou seja, não modifica o array, mas sim faz uma cópia e modifica essa cópia.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign fruits = "maçãs, laranjas, pêssegos" | split: ", " %}

    {% assign everything = fruits | pop %}

    {% for item in everything %}
    - {{ item }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - maçãs
    - laranjas
    ```
  </CodeGroup>
</Columns>

## `shift`

Remove um elemento do início do array. É NÃO-DESTRUTIVO, ou seja, não modifica o array, mas sim faz uma cópia e modifica essa cópia.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign fruits = "maçãs, laranjas, pêssegos" | split: ", " %}

    {% assign everything = fruits | shift %}

    {% for item in everything %}
    - {{ item }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - laranjas
    - pêssegos
    ```
  </CodeGroup>
</Columns>

## `unshift`

Adiciona um elemento no início do array. É NÃO-DESTRUTIVO, ou seja, não modifica o array, mas sim faz uma cópia e modifica essa cópia.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign fruits = "laranjas, pêssegos" | split: ", " %}

    {% assign everything = fruits | unshift: "maçãs" %}

    {% for item in everything %}
    - {{ item }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - maçãs
    - laranjas
    - pêssegos
    ```
  </CodeGroup>
</Columns>

## `reject`

Cria um array excluindo os objetos com um valor de propriedade específico, ou excluindo valores verdadeiros por padrão quando uma propriedade não é fornecida.

Neste exemplo, suponha que você tem uma lista de produtos e quer filtrar produtos de cozinha. Usando `reject`, você pode criar um array excluindo apenas os produtos que têm um `"type"` de `"kitchen"`.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    Todos os produtos:
    {% for product in products %}
    - {{ product.title }}
    {% endfor %}

    {% assign non_kitchen_products = products | reject: "type", "kitchen" %}

    Produtos de cozinha:
    {% for product in non_kitchen_products %}
    - {{ product.title }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Todos os produtos:
    - Aspirador
    - Espátula
    - Televisão
    - Espremedor de alho

    Produtos de cozinha:
    - Aspirador 
    - Televisão
    ```
  </CodeGroup>
</Columns>

Digamos que em vez disso você tenha uma lista de produtos e queira excluir produtos tributáveis. Você pode usar `reject` com um nome de propriedade mas sem valor de destino para rejeitar todos os produtos com um valor `"taxable"` verdadeiro.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    Todos os produtos:
    {% for product in products %}
    - {{ product.title }}
    {% endfor %}

    {% assign not_taxed_products = products | reject: "taxable" %}

    Produtos disponíveis:
    {% for product in not_taxed_products %}
    - {{ product.title }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Todos os produtos:
    - Aspirador
    - Espátula
    - Televisão
    - Espremedor de alho

    Produtos disponíveis:
    - Espátula
    - Televisão
    ```
  </CodeGroup>
</Columns>

Além disso, `property` pode ser qualquer expressão de variável Liquid válida como usada na sintaxe de saída, exceto que o escopo desta expressão está dentro de cada item. Para o seguinte array `products`:

```javascript theme={null}
const products = [
    { meta: { details: { class: 'A' } }, order: 1 },
    { meta: { details: { class: 'B' } }, order: 2 },
    { meta: { details: { class: 'B' } }, order: 3 }
]
```

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    {% assign selected = products | reject: 'meta.details["class"]', "B" %}
    {% for item in selected -%}
    - {{ item.order }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    - 1
    ```
  </CodeGroup>
</Columns>

## `reject_exp`

Seleciona todos os objetos em um array onde a expressão é falsa. Neste exemplo, suponha que você tem uma lista de produtos e quer esconder seus produtos de cozinha. Usando `reject_exp`, você pode criar um array que omite apenas os produtos que têm um `"type"` de `"kitchen"`.

<Columns cols={2}>
  <CodeGroup>
    ```liquid Código theme={null}
    Todos os produtos:
    {% for product in products %}
    - {{ product.title }}
    {% endfor %}

    {% assign non_kitchen_products = products | reject_exp: "item", "item.type == 'kitchen'" %}

    Produtos de cozinha:
    {% for product in non_kitchen_products %}
    - {{ product.title }}
    {% endfor %}
    ```
  </CodeGroup>

  <CodeGroup>
    ```liquid Saída theme={null}
    Todos os produtos:
    - Aspirador
    - Espátula
    - Televisão
    - Espremedor de alho

    Produtos de cozinha:
    - Aspirador
    - Televisão
    ```
  </CodeGroup>
</Columns>