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

# Operadores de comparação para uso em padrões de eventos na Amazon EventBridge
<a name="eb-create-pattern-operators"></a>

Abaixo, um resumo de todos os operadores de comparação disponíveis em EventBridge. 

Os operadores de comparação só funcionam em nós folha, com exceção de `$or` e `anything-but`. 


| **Comparação** | **Exemplo** | **Sintaxe da regra** | **Compatível com barramento de eventos** | **Compatível com pipe** | 
| --- | --- | --- | --- | --- | 
|  E  |  Local é “Nova York” e o dia é “Segunda-feira”  |  `"Location": [ "New York" ], "Day": ["Monday"]`  |  Sim  |  Sim  | 
| [Tudo, exceto](#eb-filtering-anything-but) | Estado é qualquer valor além de “inicializar”. | `"state": [ { "anything-but": "initializing" } ]` |  Sim  |  Sim  | 
| [Tudo, exceto (começa com)](#eb-filtering-anything-but-prefix) | A região não é nos EUA. |  `"Region": [ { "anything-but": {"prefix": "us-" } } ]`  |  Sim  |  Não  | 
| [Tudo, exceto (termina com)](#eb-filtering-anything-but-suffix) | FileName não termina com uma extensão.png. |  `"FileName": [ { "anything-but": { "suffix": ".png" } } ]`  |  Sim  |  Não  | 
| [Tudo, exceto (ignorar maiúsculas e minúsculas)](#eb-filtering-anything-but-ignore-case) | Estado é qualquer valor além de “inicializar” ou qualquer outra variação de maiúsculas e minúsculas, como “INICIALIZAR”. | `"state": : [{ "anything-but": { "equals-ignore-case": "initializing" }}]}` |  Sim  |  Não  | 
| [Tudo, exceto usando um curinga](#eb-filtering-anything-but-wildcard) | FileName não é um caminho de arquivo que inclua`/lib/`. |  `"FilePath" : [{ "anything-but": { "wildcard": "*/lib/*" }}]`  |  Sim  |  Não  | 
|  [Começa com](#eb-filtering-prefix-matching)  |  A região é nos EUA.  |  `"Region": [ {"prefix": "us-" } ]`  |  Sim  |  Sim  | 
| Começa com (ignorar maiúsculas e minúsculas) | O nome do serviço começa com as letras “eventb”, sem diferenciar maiúsculas e minúsculas. | `{"service" : [{ "prefix": { "equals-ignore-case": "eventb" }}]}` |  Sim  |  Sim  | 
|  [Vazio](eb-event-patterns-null-values.md)  |  LastName está vazio.  |  `"LastName": [""]`  |  Sim  |  Sim  | 
|  Igual  |  Name é “Alice”  |  `"Name": [ "Alice" ]`  |  Sim  |  Sim  | 
|  [É igual a (ignorar maiúsculas e minúsculas)](#eb-filtering-equals-ignore-case-matching)  |  Name é “Alice”  |  `"Name": [ { "equals-ignore-case": "alice" } ]`  |  Sim  |  Sim  | 
|  [Termina com](#eb-filtering-suffix-matching)  |  FileName termina com uma extensão.png  |  `"FileName": [ { "suffix": ".png" } ]`  |  Sim  |  Sim  | 
| Termina com (ignorar maiúsculas e minúsculas) | O nome do serviço termina com as letras “tbridge” ou qualquer outra variação de maiúsculas e minúsculas, como “TBRIDGE”. | `{"service" : [{ "suffix": { "equals-ignore-case": "tBridge" }}]}` |  Sim  |  Sim  | 
|  [Existe](#eb-filtering-exists-matching)  |  ProductName existe  |  `"ProductName": [ { "exists": true } ]`  |  Sim  |  Sim  | 
|  [Não existe](#eb-filtering-exists-matching)  |  ProductName não existe  |  `"ProductName": [ { "exists": false } ]`  |  Sim  |  Sim  | 
|  [Não](#eb-filtering-anything-but)  |  Weather é qualquer valor, exceto “Raining” (Chovendo)  |  `"Weather": [ { "anything-but": [ "Raining" ] } ]`  |  Sim  |  Sim  | 
|  [Nulo](eb-event-patterns-null-values.md)  |  UserID é null  |  `"UserID": [ null ]`  |  Sim  |  Sim  | 
|  [Numérico (é iguais a)](#filtering-numeric-matching)  |  Price é 100  |  `"Price": [ { "numeric": [ "=", 100 ] } ]`  |  Sim  |  Sim  | 
|  [Numérico (intervalo)](#filtering-numeric-matching)  |  Price é superior a 10 e menor que ou igual a 20  |  `"Price": [ { "numeric": [ ">", 10, "<=", 20 ] } ]`  |  Sim  |  Sim  | 
|  Ou  |  PaymentType é “Crédito” ou “Débito”  |  `"PaymentType": [ "Credit", "Debit"]`  |  Sim  |  Sim  | 
|  [Ou (vários campos)](#eb-filtering-complex-example-or)  |  Location é “New York” ou Day é “Monday”.  |  `"$or": [ { "Location": [ "New York" ] }, { "Day": [ "Monday" ] } ]`  |  Sim  |  Sim  | 
|  [Curinga](#eb-filtering-wildcard-matching)  |  Qualquer arquivo com extensão .png, localizado na pasta "dir"  |  `"FileName": [ { "wildcard": "dir/*.png" } ] `  |  Sim  |  Não  | 

## Correspondência de prefixo
<a name="eb-filtering-prefix-matching"></a>

É possível fazer uma correspondência de um evento com um valor na origem do evento no prefixo. É possível usar a correspondência de prefixos para valores de string.

Por exemplo, haveria correspondência do padrão de evento a seguir em qualquer evento em que o campo `"time"` começasse com `"2017-10-02"`, como `"time": "2017-10-02T18:43:48Z"`. 

```
{
  "time": [ { "prefix": "2017-10-02" } ]
}
```

### Correspondência de prefixo ignorando maiúsculas e minúsculas
<a name="eb-filtering-prefix-matching-ignore-case"></a>

Você também pode fazer a correspondência com um valor de prefixo, sem diferenciar maiúsculas e minúsculas dos caracteres que iniciam um valor, usando `equals-ignore-case` com `prefix.`

Por exemplo, haveria correspondência do padrão de eventos a seguir com qualquer evento em que o campo `service` começasse com a string de caracteres `EventB`, mas também `EVENTB`, `eventb` ou qualquer combinação de maiúsculas e minúsculas desses caracteres.

```
{
  "detail": {"service" : [{ "prefix": { "equals-ignore-case": "EventB" }}]}
}
```

## Correspondência de sufixo
<a name="eb-filtering-suffix-matching"></a>

É possível combinar um evento dependendo do sufixo de um valor na origem do evento. É possível usar a correspondência de sufixos para valores de string.

Por exemplo, haveria correspondência do padrão de evento a seguir em qualquer evento em que o campo `"FileName"` terminasse com a extensão de arquivo `.png`. 

```
{
  "FileName": [ { "suffix": ".png" } ]
}
```

### Correspondência de sufixo ignorando maiúsculas e minúsculas
<a name="eb-filtering-suffix-matching-ignore-case"></a>

Você também pode fazer a correspondência com um valor de sufixo, sem diferenciar maiúsculas e minúsculas dos caracteres que terminam com um valor, usando `equals-ignore-case` com `suffix.`

Por exemplo, haveria correspondência do padrão de eventos a seguir com qualquer evento em que o campo `FileName` começasse com a string de caracteres `.png`, mas também `.PNG` ou qualquer outra combinação de maiúsculas e minúsculas desses caracteres.

```
{
  "detail": {"FileName" : [{ "suffix": { "equals-ignore-case": ".png" }}]}
}
```

## Correspondência anything-but
<a name="eb-filtering-anything-but"></a>

A correspondência *tudo, exceto* faz a correspondência com qualquer valor, exceto o que for especificado na regra. 

É possível excluir correspondências com strings e valores numéricos, incluindo listas que contenham somente strings ou números.

O evento a seguir mostra tudo menos uma correspondência com uma lista de strings e números.

```
{
  "detail": {
    "state": [ { "anything-but": "initializing" } ]
  }
}

{
  "detail": {
    "x-limit": [ { "anything-but": 123 } ]
  }
}
```

O evento a seguir mostra tudo menos uma correspondência com uma lista de strings.

```
{
  "detail": {
    "state": [ { "anything-but": [ "stopped", "overloaded" ] } ]
  }
}
```

O evento a seguir mostra tudo menos uma correspondência com uma lista de números.

```
{
  "detail": {
    "x-limit": [ { "anything-but": [ 100, 200, 300 ] } ]
  }
}
```

### Correspondência “tudo, exceto” ignorando maiúsculas e minúsculas
<a name="eb-filtering-anything-but-ignore-case"></a>

Você também pode usar `equals-ignore-case` com `anything-but` para fazer a correspondência com valores de string sem diferenciar maiúsculas e minúsculas.

O padrão de eventos a seguir faz a correspondência com os campos `state` que não contêm a string “inicializar”, “INICIALIZAR”, “Inicializar” ou qualquer outra combinação de maiúsculas e minúsculas desses caracteres. 

```
{
  "detail": {"state" : [{ "anything-but": { "equals-ignore-case": "initializing" }}]}
}
```

Você também pode usar `equals-ignore-case` com `anything-but` para fazer a correspondência com uma lista de valores:

```
{
  "detail": {"state" : [{ "anything-but": { "equals-ignore-case": ["initializing", "stopped"] }}]}
}
```

### Correspondência “tudo, exceto” em prefixos
<a name="eb-filtering-anything-but-prefix"></a>

Você pode usar `prefix` com `anything-but` para fazer a correspondência com valores de string que não iniciam com o valor especificado. Isso inclui valores únicos ou uma lista de valores.

O padrão de eventos a seguir mostra a correspondência “tudo, exceto” que faz a correspondência com qualquer evento que não tenha o prefixo `"init"` no campo `"state"`.

```
{
  "detail": {
    "state": [ { "anything-but": { "prefix": "init" } } ]
  }
}
```

O padrão de eventos a seguir mostra a correspondência “tudo, exceto” com uma lista de valores de prefixos. Esse padrão de eventos faz a correspondência com qualquer evento que não tenha os prefixos `"init"` ou `"stop"` no campo `"state"`.

```
{
"detail": {
  "state" : [{ "anything-but": { "prefix": ["init", "stop"] } } ] }
  }
}
```

### Correspondência “tudo, exceto” em sufixos
<a name="eb-filtering-anything-but-suffix"></a>

Você pode usar `suffix` com `anything-but` para fazer a correspondência com valores de string que não terminam com o valor especificado. Isso inclui valores únicos ou uma lista de valores.

O padrão de eventos a seguir faz a correspondência com a qualquer valor do campo `FileName` que não termina com `.txt`.

```
{
  "detail": {
    "FileName": [ { "anything-but": { "suffix": ".txt" } } ]
  }
}
```

O padrão de eventos a seguir mostra a correspondência “tudo, exceto” com uma lista de valores de sufixos. Este padrão de eventos faz a correspondência com qualquer valor do campo `FileName` que não termina com `.txt` ou `.rtf`.

```
{
  "detail": {
    "FileName": [ { "anything-but": { "suffix": [".txt", ".rtf"] } } ]
  }
}
```

### Correspondência “tudo, exceto” usando curingas
<a name="eb-filtering-anything-but-wildcard"></a>

É possível usar o caractere curinga (\$1) dentro dos valores que você especificar para a correspondência “tudo, exceto”. Isso inclui valores únicos ou uma lista de valores.

O padrão de eventos a seguir faz a correspondência com qualquer valor do campo `FileName` que não contém `/lib/`.

```
{
"detail": {
  "FilePath" : [{ "anything-but": { "wildcard": "*/lib/*" }}]
  }
}
```

O padrão de eventos a seguir mostra a correspondência “tudo, exceto” com uma lista de valores que inclui curingas. Este padrão de eventos faz a correspondência com qualquer valor do campo `FileName` que não contém `/lib/` ou `/bin/`.

```
{
"detail": {
  "FilePath" : [{ "anything-but": { "wildcard": ["*/lib/*", "*/bin/*"] }}]
  }
}
```

Para obter mais informações, consulte [Como corresponder usando curingas](#eb-filtering-wildcard-matching).

## Correspondência numérica
<a name="filtering-numeric-matching"></a>

A correspondência numérica funciona com valores que são números JSON. Está limitada a valores entre -5.0e9 e \$15.0e9 inclusive, com 15 dígitos de precisão ou seis dígitos à direita do ponto decimal.

O exemplo a seguir mostra a correspondência numérica para um padrão de evento que corresponde somente aos eventos que são verdadeiros para todos os campos. 

```
{
  "detail": {
    "c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ],
    "d-count": [ { "numeric": [ "<", 10 ] } ],
    "x-limit": [ { "numeric": [ "=", 3.018e2 ] } ]
  }
}
```

## Correspondência de endereço IP
<a name="eb-filtering-ip-matching"></a>

Você pode usar a correspondência de endereços IP para IPv4 e IPv6 endereços. O padrão de eventos a seguir mostra o endereço IP correspondente aos endereços IP que começam com 10.0.0 e terminam com um número entre 0 e 255.

```
{
  "detail": {
    "sourceIPAddress": [ { "cidr": "10.0.0.0/24" } ]
  }
}
```

## Existe correspondência
<a name="eb-filtering-exists-matching"></a>

A *correspondência existe* funciona na presença ou ausência de um campo no JSON do evento.

A correspondência “existe” funciona somente em nós folha. Ela não funciona em nós intermediários.

O padrão de evento a seguir corresponde a qualquer evento que tenha um campo `detail.state`.

```
{
  "detail": {
    "state": [ { "exists": true  } ]
  }
}
```

Os padrões de evento anterior seriam correspondentes ao evento de exemplo a seguir.

```
{
  "version": "0",
  "id": "7bf73129-1428-4cd3-a780-95db273d1602",
  "detail-type": "EC2 Instance State-change Notification",
  "source": "aws.ec2",
  "account": "123456789012",
  "time": "2015-11-11T21:29:54Z",
  "region": "us-east-1",
  "resources": ["arn:aws:ec2:us-east-1:123456789012:instance/i-abcd1111"],
  "detail": {
    "instance-id": "i-abcd1111",
    "state": "pending"
  }
}
```

O padrão do evento anterior NÃO corresponde ao evento seguinte porque não tem um campo `detail.state`.

```
{
  "detail-type": [ "EC2 Instance State-change Notification" ],
  "resources": [ "arn:aws:ec2:us-east-1:123456789012:instance/i-02ebd4584a2ebd341" ],
  "detail": {
    "c-count" : {
       "c1" : 100
    }
  }
}
```

## Equals-ignore-case combinando
<a name="eb-filtering-equals-ignore-case-matching"></a>

*A quals-ignore-case correspondência E* funciona em valores de string, independentemente do caso.

O padrão de evento a seguir corresponde a qualquer evento que tenha um campo `detail-type` que corresponda à string especificada, independentemente do caso.

```
{
  "detail-type": [ { "equals-ignore-case": "ec2 instance state-change notification" } ]
}
```

Os padrões de evento anterior seriam correspondentes ao evento de exemplo a seguir.

```
{
  "detail-type": [ "EC2 Instance State-change Notification" ],
  "resources": [ "arn:aws:ec2:us-east-1:123456789012:instance/i-02ebd4584a2ebd341" ],
  "detail": {
    "c-count" : {
       "c1" : 100
    }
  }
}
```

## Como corresponder usando curingas
<a name="eb-filtering-wildcard-matching"></a>

É possível usar o caractere curinga (\$1) para encontrar o valor correspondente a valores de string em padrões de eventos.

**nota**  
No momento, o caractere curinga é compatível somente com as regras do barramento de eventos.

Considerações ao usar curingas em seus padrões de eventos:
+ É possível especificar qualquer número de caracteres curinga em um determinado valor de cadeia de caracteres; no entanto, caracteres curinga consecutivos não são compatíveis.
+ EventBridge suporta o uso do caractere de barra invertida (\$1) para especificar os caracteres literais \$1 e\$1 em filtros curinga:
  + A string `\*` representa o caractere literal \$1
  + A string `\\` representa o caractere literal \$1

  Não há compatibilidade para usar a barra invertida no escape de outros caracteres.

### Curingas e complexidade do padrão de eventos
<a name="eb-filtering-wildcard-matching-complexity"></a>

Há um limite para a complexidade de uma regra que usa curingas. Se uma regra for muito complexa, EventBridge retornará um `InvalidEventPatternException` ao tentar criar a regra. Se sua regra gerar esse erro, considere usar a orientação abaixo para reduzir a complexidade do padrão do evento:
+ **Reduza o número de caracteres curinga usados**

  Use somente caracteres curinga quando realmente precisar comparar com vários valores possíveis. Por exemplo, considere o seguinte padrão de eventos, em que deseja comparar com os barramentos de eventos na mesma região:

  ```
  {
  "EventBusArn": [ { "wildcard": "*:*:*:*:*:event-bus/*" } ]
  }
  ```

  No caso acima, muitas das seções do ARN serão baseadas diretamente na região em que seus barramentos de eventos residem. Portanto, se estiver usando a região `us-east-1`, um padrão menos complexo que ainda corresponda aos valores desejados pode ser o seguinte exemplo:

  ```
  {
  "EventBusArn": [ { "wildcard": "arn:aws:events:us-east-1:*:event-bus/*" } ]
  }
  ```
+ **Reduza as sequências de caracteres repetidas que ocorrem após um caractere curinga**

  Ter a mesma sequência de caracteres aparecendo várias vezes após o uso de um curinga aumenta a complexidade do processamento do padrão do evento. Reformule seu padrão de eventos para minimizar sequências repetidas. Por exemplo, considere o seguinte exemplo, que corresponde ao arquivo de nome `doc.txt` de arquivo de qualquer usuário:

  ```
  {
  "FileName": [ { "wildcard": "/Users/*/dir/dir/dir/dir/dir/doc.txt" } ]
  }
  ```

  Se soubesse que o arquivo `doc.txt` só ocorreria no caminho especificado, poderia reduzir a sequência de caracteres repetidos desta forma:

  ```
  {
  "FileName": [ { "wildcard": "/Users/*/doc.txt" } ]
  }
  ```

## Exemplo complexo com correspondência múltipla
<a name="eb-filtering-complex-example"></a>

Você pode combinar vários critérios de correspondência em um padrão de eventos mais complexo. Por exemplo, o padrão de evento a seguir combina `anything-but` e `numeric`.

```
{
  "time": [ { "prefix": "2017-10-02" } ],
  "detail": {
    "state": [ { "anything-but": "initializing" } ],
    "c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ],
    "d-count": [ { "numeric": [ "<", 10 ] } ],
    "x-limit": [ { "anything-but": [ 100, 200, 300 ] } ]
  }
}
```

**nota**  
Ao criar padrões de eventos, se incluir uma chave mais de uma vez, a última referência será aquela usada para avaliar eventos. Por exemplo, para o seguinte padrão:  

```
{
  "detail": {
    "location": [ { "prefix": "us-" } ],
    "location": [ { "anything-but": "us-east" } ]
  }
}
```
somente `{ "anything-but": "us-east" }` serão levados em consideração ao avaliar a `location`.

## Exemplo complexo com correspondências de `$or`
<a name="eb-filtering-complex-example-or"></a>

Também é possível criar padrões de eventos complexos que verificam se os valores de *algum* campo coincidem em vários campos. Use `$or` para criar um padrão de evento que corresponda se algum dos valores de vários campos for correspondido.

Observe que pode incluir outros tipos de filtro, como [correspondência numérica](#filtering-numeric-matching) e [matrizes](eb-event-patterns-arrays.md), na correspondência de padrões para campos individuais em sua estrutura `$or`.

O seguinte padrão de evento corresponderá se alguma das condições a seguir for atendida:
+ O campo `c-count` é maior que 0 ou menor que ou igual a 5.
+ O campo `d-count` é inferior a 10.
+ O campo `x-limit` é igual a 3.018e2.

```
{
  "detail": {
    "$or": [
      { "c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ] },
      { "d-count": [ { "numeric": [ "<", 10 ] } ] },
      { "x-limit": [ { "numeric": [ "=", 3.018e2 ] } ] }
    ]
  }
}
```

**nota**  
APIs que aceitam um padrão de evento (como`PutRule`, `CreateArchive``UpdateArchive`, e`TestEventPattern`) gerarão um `InvalidEventPatternException` if o uso de `$or` resultados em mais de 1000 combinações de regras.  
Para determinar o número de combinações de regras em um padrão de evento, multiplique o número total de argumentos de cada matriz `$or` no padrão de evento. Por exemplo, o padrão acima contém uma única matriz `$or` com três argumentos, então o número total de combinações de regras também é três. Se adicionasse outra matriz `$or` com dois argumentos, o total de combinações de regras seria então seis.