As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# \$1regexFindAll
<a name="regexFindAll"></a>

Introduzido na versão 5.0

O `$regexFindAll` operador no Amazon DocumentDB é usado para realizar a correspondência de expressões regulares em campos de string em documentos. Ele permite pesquisar e extrair substrings específicas que correspondam a um determinado padrão de expressão regular, retornando todas as correspondências da expressão regular.

**Parâmetros**
+ `input`: O campo de string ou expressão a ser pesquisado.
+ `regex`: O padrão de expressão regular a ser correspondente.
+ `options`: (opcional) Um objeto que especifica parâmetros opcionais para a expressão regular, como distinção entre maiúsculas e minúsculas e correspondência de várias linhas. As opções suportadas são `i` (sem distinção entre maiúsculas e minúsculas) e `m` (várias linhas).

## Exemplo (MongoDB Shell)
<a name="regexFindAll-examples"></a>

O exemplo a seguir demonstra como usar o `$regexFindAll` operador para extrair todas as sequências de letras do `email` campo.

**Crie documentos de amostra**

```
db.users.insertMany([
  { _id: 1, name: "John Doe", email: "john@example.com", phone: "555-1234" },
  { _id: 2, name: "Jane Roe", email: "jane@example.com", phone: "555-5678" },
  { _id: 3, name: "Carlos Salazar", email: "carlos@example.com", phone: "555-3456" },
  { _id: 4, name: "Saanvi Sarkar", email: "saanvi@example.com", phone: "555-7890" }
  
]);
```

**Exemplo de consulta**

```
db.users.aggregate([
  {
    $project: {
      name: 1,
      emailMatches: {
        $regexFindAll: { input: '$email', regex: '[a-z]+', options: 'i' }
      }
    }
  }
])
```

**Saída**

```
[
  {
    _id: 1,
    name: 'John Doe',
    emailMatches: [
      { match: 'john', idx: 0, captures: [] },
      { match: 'example', idx: 5, captures: [] },
      { match: 'com', idx: 13, captures: [] }
    ]
  },
  {
    _id: 2,
    name: 'Jane Roe',
    emailMatches: [
      { match: 'jane', idx: 0, captures: [] },
      { match: 'example', idx: 5, captures: [] },
      { match: 'com', idx: 13, captures: [] }
    ]
  },
  {
    _id: 3,
    name: 'Carlos Salazar',
    emailMatches: [
      { match: 'carlos', idx: 0, captures: [] },
      { match: 'example', idx: 7, captures: [] },
      { match: 'com', idx: 15, captures: [] }
    ]
  },
  {
    _id: 4,
    name: 'Saanvi Sarkar',
    emailMatches: [
      { match: 'saanvi', idx: 0, captures: [] },
      { match: 'example', idx: 7, captures: [] },
      { match: 'com', idx: 15, captures: [] }
    ]
  }
]
```

**Nota:** Se sua consulta estiver usando o planejador Amazon DocumentDB versão 1, você deve usar uma dica para utilizar um índice. Sem uma dica, a consulta pode realizar uma varredura de coleção. Para verificar sua versão do planejador e saber mais sobre o uso de dicas, consulte a [documentação do Amazon DocumentDB Query Planner] (-planner.html). https://docs.aws.amazon.com/documentdb/ latest/developerguide/query

## Exemplos de código
<a name="regexFindAll-code"></a>

Para ver um exemplo de código para usar o `$regexFindAll` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

Aqui está um exemplo de uso do `$regexFind` operador em um aplicativo Node.js:

```
const { MongoClient } = require('mongodb');

async function main() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const users = db.collection('users');

  const results = await users.aggregate([
    {
      $project: {
        name: 1,
        emailMatches: {
          $regexFindAll: { input: "$email", regex: "[a-z]+", options: "i" }
        }
      }
    }
  ]).toArray();
  
  console.log(JSON.stringify(results, null, 2));

  await client.close();
}

main();
```

------
#### [ Python ]

Aqui está um exemplo de uso do `$regexFind` operador em um aplicativo Python:

```
from pymongo import MongoClient

client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
users = db['users']

results = list(users.aggregate([
    { 
        "$project": { 
            "name": 1,
            "emailMatches": { 
                "$regexFindAll": { 
                    "input": "$email", 
                    "regex": "[a-z]+", 
                    "options": "i" 
                }
            }
        }
    }
]))

print(results)

client.close()
```

------