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

# Lógica E/OU
<a name="and-or-logic"></a>

Use a AND/OR lógica nas políticas de filtro para corresponder aos atributos da mensagem ou às propriedades do corpo da mensagem no Amazon SNS. Isso permite uma filtragem de mensagens mais precisa e flexível.

## Lógica E
<a name="and-logic"></a>

Aplique a lógica E usando vários nomes de propriedade.

Considere a seguinte política:

```
{
  "customer_interests": ["rugby"],
  "price_usd": [{"numeric": [">", 100]}]
}
```

Ela estabelece correspondência com qualquer propriedade de atributo ou corpo de mensagem com o valor de `customer_interests` definido como `rugby` *e* o valor de `price_usd` definido como um número maior que 100.

**nota**  
Não é possível aplicar a lógica AND aos valores do mesmo atributo.

## Lógica OU
<a name="or-logic"></a>

Aplique a lógica OU atribuindo vários valores a um nome de propriedade.

Considere a seguinte política:

```
{
   "customer_interests": ["rugby", "football", "baseball"]
}
```

Ela estabelece correspondência com qualquer propriedade de atributo ou corpo de mensagem com o valor de `customer_interests` definido como `rugby`, `football` *ou* `baseball`.

## Operador OU
<a name="or-operator"></a>

Você pode usar o operador `"$or"` para definir explicitamente uma política de filtro para expressar a relação OR entre vários atributos na política.

O Amazon SNS só reconhece uma relação `"$or"` quando a política atende a todas as condições a seguir. Quando todas essas condições não são atendidas, `"$or"` é tratado como um nome de atributo regular, o mesmo que qualquer outra string na política.
+ Há um atributo do campo `"$or"` na regra seguido por uma matriz, por exemplo `“$or” : []`.
+ Há pelo menos dois objetos na matriz `"$or"`: `"$or": [{}, {}]`.
+ Nenhum dos objetos na matriz `"$or"` tem nomes de campo que sejam palavras-chave reservadas.

Caso contrário, `"$or"` é tratado como um nome de atributo normal, o mesmo que outras strings na política.

A política a seguir não é analisada como uma relação OR porque numérico e prefixo são palavras-chave reservadas.

```
{ 
   "$or": [ {"numeric" : 123}, {"prefix": "abc"} ] 
}
```

**Exemplos de operador `OR`**

`OR` padrão:

```
{
  "source": [ "aws.cloudwatch" ], 
  "$or": [
    { "metricName": [ "CPUUtilization" ] },
    { "namespace": [ "AWS/EC2" ] }
  ] 
}
```

A lógica do filtro para essa política é:

```
"source" && ("metricName" || "namespace")
```

Ele corresponde a um dos seguintes atributos de mensagens:

```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"metricName": {"Type": "String", "Value": "CPUUtilization"}
```

or

```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"namespace": {"Type": "String", "Value": "AWS/EC2"}
```

Também estabelece correspondência com um dos seguintes corpos de mensagem:

```
{
    "source": "aws.cloudwatch",
    "metricName": "CPUUtilization"
}
```

or

```
{
    "source": "aws.cloudwatch",
    "namespace": "AWS/EC2"
}
```

### Restrições de políticas que incluem relações `OR`
<a name="or-operator-constraints"></a>

Considere a seguinte política:

```
{
    "source": [ "aws.cloudwatch" ],
    "$or": [
      { "metricName": [ "CPUUtilization", "ReadLatency" ] },
      {
        "metricType": [ "MetricType" ] ,
        "$or" : [
          { "metricId": [ 1234, 4321 ] },
          { "spaceId": [ 1000, 2000, 3000 ] }
        ]
      }
    ]
  }
```

A lógica dessa política também pode ser simplificada como:

```
("source" AND "metricName") 
OR 
("source" AND "metricType" AND "metricId") 
OR 
("source" AND "metricType" AND "spaceId")
```

O cálculo da complexidade para políticas com relacionamentos OR pode ser simplificado como a soma das complexidades da combinação para cada declaração OR.

A combinação total é calculada da seguinte forma:

```
(source * metricName) + (source * metricType * metricId) + (source * metricType * spaceId)
= (1 * 2) + (1 * 1 * 2) + (1 * 1 * 3) 
= 7
```

`source` tem um valor, `metricName` tem dois valores, `metricType` tem um valor, `metricId` tem dois valores e `spaceId` tem três valores.

Considere a seguinte política de filtro aninhada:

```
{
    "$or": [
      { "metricName": [ "CPUUtilization", "ReadLatency" ] },
      { "namespace": [ "AWS/EC2", "AWS/ES" ] }
    ],
    "detail" : {
      "scope" : [ "Service" ],
      "$or": [
        { "source": [ "aws.cloudwatch" ] },
        { "type": [ "CloudWatch Alarm State Change"] }
      ]
    }
  }
```

A lógica dessa política pode ser simplificada como:

```
("metricName" AND ("detail"."scope" AND "detail"."source")
OR
("metricName" AND ("detail"."scope" AND "detail"."type")
OR
("namespace" AND ("detail"."scope" AND "detail"."source")
OR
("namespace" AND ("detail"."scope" AND "detail"."type")
```

O cálculo das combinações totais é o mesmo para políticas não aninhadas, exceto que precisamos considerar o nível de aninhamento de uma chave.

A combinação total é calculada da seguinte forma:

```
(2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) = 32
```

`metricName` tem dois valores, `namespace` tem dois valores, `scope` é uma chave aninhada de dois níveis com um valor, `source` é uma chave aninhada de dois níveis com um valor e `type` é uma chave aninhada de dois níveis com um valor.