Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Logica AND/OR
<a name="and-or-logic"></a>

Usa AND/OR la logica nelle politiche di filtro per abbinare gli attributi o le proprietà del corpo del messaggio in Amazon SNS. Ciò consente un filtraggio dei messaggi più preciso e flessibile.

## Logica AND
<a name="and-logic"></a>

Puoi applicare l'operatore logico AND utilizzando più nomi di proprietà.

Esaminiamo la seguente policy:

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

Corrisponde a qualsiasi attributo di messaggio o corpo del messaggio che abbia il valore di `customer_interests` impostato su `rugby` *e* il valore di `price_usd` impostato su un numero superiore a 100.

**Nota**  
Non è possibile applicare la logica AND ai valori dello stesso attributo.

## Logica OR
<a name="or-logic"></a>

Puoi applicare l'operatore logico OR assegnando più valori a un nome di proprietà.

Esaminiamo la seguente policy:

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

Corrisponde a qualsiasi attributo di messaggio o proprietà del corpo di messaggio con il valore di `customer_interests` impostato su `rugby`, `football` *o* `baseball`.

## Operatore OR
<a name="or-operator"></a>

È possibile utilizzare l'operatore `"$or"` per definire in modo esplicito una policy di filtro per esprimere la relazione OR tra più attributi della policy.

Amazon SNS riconosce una relazione `"$or"` solo quando la policy soddisfa tutte le seguenti condizioni. Se tutte queste condizioni non sono soddisfatte, `"$or"` viene considerato come un normale nome di attributo, come qualsiasi altra stringa della policy.
+ Nella regola seguita da un array è presente un attributo di campo `"$or"`, ad esempio, `“$or” : []`.
+ Ci sono almeno 2 oggetti nell'array `"$or"`: `"$or": [{}, {}]`.
+ Nessuno degli oggetti nell'array `"$or"` ha nomi di campo che sono parole chiave riservate.

Altrimenti `"$or"` viene considerato come un normale nome di attributo, come le altre stringhe della policy.

La seguente policy non viene analizzata come una relazione OR perché numerico e prefisso sono parole chiave riservate.

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

**Esempi di operatori `OR`**

`OR` standard:

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

La logica di filtro per questa policy è:

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

Corrisponde a uno dei seguenti set di attributi di messaggio:

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

or

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

Corrisponde anche a uno dei seguenti corpi dei messaggi:

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

or

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

### Vincoli della policy che includono le relazioni `OR`
<a name="or-operator-constraints"></a>

Esaminiamo la seguente policy:

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

La logica di questa policy può anche essere semplificata come segue:

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

Il calcolo della complessità per le policy con relazioni OR può essere semplificato come somma delle complessità di combinazioni per ogni istruzione OR.

La combinazione totale si calcola nel seguente modo:

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

`source` ha un valore, `metricName` ha due valori, `metricType` ha un valore, `metricId` ha due valori e `spaceId` ha tre valori.

Considera la seguente policy di filtro nidificata:

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

La logica di questa policy può essere semplificata come segue:

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

Il calcolo per le combinazioni totali è lo stesso per le policy non nidificate, tranne per il fatto che è necessario considerare il livello di nidificazione di una chiave.

La combinazione totale si calcola nel seguente modo:

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

`metricName` ha due valori, `namespace` ha due valori, `scope` è una chiave nidificata a due livelli con un valore, `source` è una chiave nidificata a due livelli con un valore e `type` è una chiave nidificata a due livelli con un valore.