

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

# Processori di mutazione delle stringhe
<a name="CloudWatch-Logs-Transformation-StringMutate"></a>

Questa sezione contiene informazioni sui processori di mutazione delle stringhe che è possibile utilizzare con un trasformatore di eventi di registro. 

**Contents**
+ [lowerCaseString](#CloudWatch-Logs-Transformation-lowerCaseString)
+ [upperCaseString](#CloudWatch-Logs-Transformation-upperCaseString)
+ [SplitString](#CloudWatch-Logs-Transformation-splitString)
+ [Stringa sostitutiva](#CloudWatch-Logs-Transformation-substituteString)
+ [TrimString](#CloudWatch-Logs-Transformation-trimString)

## lowerCaseString
<a name="CloudWatch-Logs-Transformation-lowerCaseString"></a>

Il `lowerCaseString` processore converte una stringa nella sua versione minuscola.


| Campo | Description | Obbligatorio? | Predefinita | Limits | 
| --- | --- | --- | --- | --- | 
| Con chiavi | Un elenco di chiavi da convertire in lettere minuscole | Sì |  | Numero massimo di voci: 10 | 

**Esempio**

Prendiamo il seguente esempio di evento di registro:

```
{
    "outer_key": {
        "inner_key": "INNER_VALUE"
    }
}
```

La configurazione del trasformatore è questa, utilizzata `lowerCaseString` con`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "lowerCaseString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]
```

L'evento di registro trasformato sarebbe il seguente.

```
{
  "outer_key": {
    "inner_key": "inner_value"
  }
}
```

## upperCaseString
<a name="CloudWatch-Logs-Transformation-upperCaseString"></a>

Il `upperCaseString` processore converte una stringa nella sua versione maiuscola.


| Campo | Description | Obbligatorio? | Predefinita | Limits | 
| --- | --- | --- | --- | --- | 
| Con chiavi | Un elenco di chiavi da convertire in lettere maiuscole | Sì |  | Numero massimo di voci: 10 | 

**Esempio**

Prendiamo il seguente esempio di evento di registro:

```
{
    "outer_key": {
        "inner_key": "inner_value"
    }
}
```

La configurazione del trasformatore è questa, utilizzata `upperCaseString` con`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "upperCaseString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]
```

L'evento di registro trasformato sarebbe il seguente.

```
{
  "outer_key": {
    "inner_key": "INNER_VALUE"
  }
}
```

## SplitString
<a name="CloudWatch-Logs-Transformation-splitString"></a>

Il `splitString` processore è un tipo di processore di mutazione di stringhe che divide un campo in un array utilizzando un carattere delimitante.


| Campo | Description | Obbligatorio? | Predefinita | Limits | 
| --- | --- | --- | --- | --- | 
| voci | Matrice di voci. Ogni elemento dell'array deve contenere source delimiter campi. | Sì |  | Numero massimo di iscrizioni: 10 | 
| origine | La chiave del valore del campo da dividere | Sì |  | Lunghezza massima: 128. | 
| delimitatore | La stringa delimitatrice su cui dividere il valore del campo | Sì |  | Lunghezza massima: 128. | 

**Esempio 1**

Prendiamo il seguente esempio di evento di registro:

```
{
    "outer_key": {
        "inner_key": "inner_value"
    }
}
```

La configurazione del trasformatore è questa, utilizzata `splitString` con`parseJSON`:

```
[
     {
        "parseJSON": {}
    },
    {
         "splitString": {
            "entries": [
                {
                    "source": "outer_key.inner_key",
                    "delimiter": "_"
                }
            ]
        }
    }
]
```

L'evento di registro trasformato sarebbe il seguente.

```
{
  "outer_key": {
    "inner_key": [
      "inner",
      "value"
    ]
  }
}
```

**Esempio 2**

Il delimitatore su cui dividere la stringa può contenere più caratteri.

Prendiamo il seguente esempio di evento di registro:

```
{
    "outer_key": {
        "inner_key": "item1, item2, item3"
    }
}
```

La configurazione del trasformatore è la seguente:

```
[
     {
        "parseJSON": {}
    },
    {
         "splitString": {
            "entries": [
                {
                    "source": "outer_key.inner_key",
                    "delimiter": ", "
                }
            ]
        }
    }
]
```

L'evento di registro trasformato sarebbe il seguente.

```
{
  "outer_key": {
    "inner_key": [
      "item1",
      "item2",
      "item3"
    ]
  }
}
```

## Stringa sostitutiva
<a name="CloudWatch-Logs-Transformation-substituteString"></a>

Il `substituteString` processore è un tipo di processore di mutazione di stringhe che abbina il valore di una chiave a un'espressione regolare e sostituisce tutte le corrispondenze con una stringa sostitutiva.


| Campo | Description | Obbligatorio? | Predefinita | Limits | 
| --- | --- | --- | --- | --- | 
| voci | Matrice di voci. Ogni elemento dell'array deve contenere source to campi e. from | Sì |  | Numero massimo di iscrizioni: 10 | 
| origine | La chiave del campo da modificare | Sì |  | Lunghezza massima: 128.<br />Profondità massima della chiave annidata: 3 | 
| from | La stringa di espressioni regolari da sostituire. I caratteri regex speciali come [e] devono essere evitati usando\\\\ quando si usano le virgolette doppie e con\\ quando si usano le virgolette singole o quando sono configurati da. Console di gestione AWS Per ulteriori informazioni, vedere [Class Pattern](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html) sul sito Web di Oracle.<br />È possibile inserire un pattern `(...)` per creare un gruppo di acquisizione numerato e creare gruppi di acquisizione `(?P<group_name>...)` denominati a cui è possibile fare riferimento nel campo. `to` | Sì |  | Lunghezza massima: 128. | 
| in | È possibile utilizzare la stringa da sostituire per ogni corrispondenza di Backreference ai gruppi di from acquisizione. Usa il modulo $n  per gruppi numerati come $1 e ${group\_name} usalo per gruppi denominati come $. {my\_group} > | Sì |  | Lunghezza massima: 128.<br />Numero massimo di riferimenti retrospettivi: 10<br />Numero massimo di riferimenti retrospettivi duplicati: 2 | 

**Esempio 1**

Prendiamo il seguente esempio di evento di registro:

```
{
    "outer_key": {
        "inner_key1": "[]",
        "inner_key2": "123-345-567",
        "inner_key3": "A cat takes a catnap."
    }
}
```

La configurazione del trasformatore è questa, utilizzata `substituteString` con`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "substituteString": {
            "entries": [
                {
                    "source": "outer_key.inner_key1",
                    "from": "\\[\\]",
                    "to": "value1"
                },
                {
                    "source": "outer_key.inner_key2",
                    "from": "[0-9]{3}-[0-9]{3}-[0-9]{3}",
                    "to": "xxx-xxx-xxx"
                },
                {
                    "source": "outer_key.inner_key3",
                    "from": "cat",
                    "to": "dog"
                }
            ]
        }
    }
]
```

L'evento di registro trasformato sarebbe il seguente.

```
{
  "outer_key": {
    "inner_key1": "value1",
    "inner_key2": "xxx-xxx-xxx",
    "inner_key3": "A dog takes a dognap."
  }
}
```

**Esempio 2**

Prendiamo il seguente esempio di evento di registro:

```
{
    "outer_key": {
        "inner_key1": "Tom, Dick, and Harry",
        "inner_key2": "arn:aws:sts::123456789012:assumed-role/MyImportantRole/MySession"
    }
}
```

La configurazione del trasformatore è questa, utilizzata `substituteString` con`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "substituteString": {
            "entries": [
                {
                    "source": "outer_key.inner_key1",
                    "from": "(\w+), (\w+), and (\w+)",
                    "to": "$1 and $3"
                },
                {
                    "source": "outer_key.inner_key2",
                    "from": "^arn:aws:sts::(?P<account_id>\\d{12}):assumed-role/(?P<role_name>[\\w+=,.@-]+)/(?P<role_session_name>[\\w+=,.@-]+)$",
                    "to": "${account_id}:${role_name}:${role_session_name}"
                }
            ]
        }
    }
]
```

L'evento di registro trasformato sarebbe il seguente.

```
{
  "outer_key": {
    "inner_key1": "Tom and Harry",
    "inner_key2": "123456789012:MyImportantRole:MySession"
  }
}
```

## TrimString
<a name="CloudWatch-Logs-Transformation-trimString"></a>

Il `trimString` processore rimuove gli spazi bianchi dall'inizio e dalla fine di una chiave.


| Campo | Description | Obbligatorio? | Predefinita | Limits | 
| --- | --- | --- | --- | --- | 
| Con chiavi | Un elenco di tasti da tagliare | Sì |  | Numero massimo di iscrizioni: 10 | 

**Esempio**

Prendiamo il seguente esempio di evento di registro:

```
{
    "outer_key": {
        "inner_key": "   inner_value  "
    }
}
```

La configurazione del trasformatore è questa, utilizzata `trimString` con`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "trimString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]
```

L'evento di registro trasformato sarebbe il seguente.

```
{
  "outer_key": {
    "inner_key": "inner_value"
  }
}
```