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à.
# Usa gli operatori di confronto nei documenti AWSTOE dei componenti
È possibile utilizzare i seguenti operatori di confronto con il modulo di **[Affermare](toe-action-modules.md#action-modules-assertion)** azione e con le espressioni condizionali che utilizzano il[if ConstructSintassi](toe-conditional-constructs.md#toe-conditional-if). Un operatore di confronto può operare su un singolo valore, ad esempio`stringIsEmpty`, oppure confrontare un valore di base con un secondo valore (valore variabile) per determinare se l'espressione condizionale restituisce o. `true` `false`
Se il confronto opera su due valori, il secondo valore può essere una variabile di concatenamento.
Quando si confrontano valori di tipo diverso, prima del confronto possono verificarsi le seguenti conversioni di valore:
+ Per i confronti numerici, se il valore della variabile è una stringa, AWSTOE converte la stringa in un numero prima della valutazione. Se la conversione non è possibile, viene restituito il confronto. `false` Ad esempio, se il valore della variabile è`"1.0"`, la conversione funziona, ma se il valore della variabile è `"a10"` la conversione fallisce.
+ Per i confronti tra stringhe, se il valore della variabile è un numero, lo AWSTOE converte in una stringa prima della valutazione.
## Confronta le stringhe
I seguenti operatori di confronto utilizzano le stringhe per confrontare valori, verificare la presenza di spazi o una stringa vuota o confrontare un valore di input con un modello regex. I confronti tra stringhe non fanno distinzione tra maiuscole e minuscole e non tagliano gli spazi dall'inizio o dalla fine degli input di stringa.
**Operatori di confronto tra stringhe**
+ [stringIsEmpty](#stringIsEmpty)
+ [stringIsWhitespace](#stringIsWhitespace)
+ [stringEquals](#stringEquals)
+ [stringLessThan](#stringLessThan)
+ [stringLessThanEquals](#stringLessThanEquals)
+ [stringGreaterThan](#stringGreaterThan)
+ [stringGreaterThanEquals](#stringGreaterThanEquals)
+ [patternMatches](#patternMatches)
**stringIsEmpty**
L'`stringIsEmpty`operatore restituisce `true` se la stringa specificata non contiene caratteri. Esempio:
```
# Evaluates to true
stringIsEmpty: ""
# Evaluates to false
stringIsEmpty: " "
# Evaluates to false
stringIsEmpty: "Hello."
```
**stringIsWhitespace**
Verifica se la stringa specificata per `stringIsWhitespace` contiene solo spazi. Esempio:
```
# Evaluates to true
stringIsWhitespace: " "
# Evaluates to false
stringIsWhitespace: ""
# Evaluates to false
stringIsWhitespace: " Hello?"
```
**StringEquals**
Verifica se la stringa specificata per `stringEquals` corrisponde esattamente alla stringa specificata nel parametro. `value` Esempio:
```
# Evaluates to true
stringEquals: 'Testing, testing...'
value: 'Testing, testing...'
# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'Hello again.'
# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'TESTING, TESTING....'
# Evaluates to false
stringEquals: 'Testing, testing...'
value: ' Testing, testing...'
# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'Testing, testing... '
```
**stringLessThan**
Verifica se la stringa specificata per `stringLessThan` è inferiore alla stringa specificata nel `value` parametro. Esempio:
```
# Evaluates to true
# This comparison operator isn't case sensitive
stringlessThan: 'A'
value: 'a'
# Evaluates to true - 'a' is less than 'b'
stringlessThan: 'b'
value: 'a'
# Evaluates to true
# Numeric strings compare as less than alphabetic strings
stringlessThan: 'a'
value: '0'
# Evaluates to false
stringlessThan: '0'
value: 'a'
```
**stringLessThanUguale a**
Verifica se la stringa specificata per `stringLessThanEquals` è minore o uguale alla stringa specificata nel `value` parametro. Esempio:
```
# Evaluates to true - 'a' is equal to 'a'
stringLessThanEquals: 'a'
value: 'a'
# Evaluates to true - since the comparison isn't case sensitive, 'a' is equal to 'A'
stringLessThanEquals: 'A'
value: 'a'
# Evaluates to true - 'a' is less than 'b'
stringLessThanEquals: 'b'
value: 'a'
# Evaluates to true - '0' is less than 'a'
stringLessThanEquals: 'a'
value: '0'
# Evaluates to false - 'a' is greater than '0'
stringLessThanEquals: '0'
value: 'a'
```
**stringGreaterThan**
Verifica se la stringa specificata per `stringGreaterThan` è maggiore della stringa specificata nel `value` parametro. Esempio:
```
# Evaluates to false - since the comparison isn't case sensitive, 'A' is equal to 'a'
stringGreaterThan: 'a'
value: 'A'
# Evaluates to true - 'b' is greater than 'a'
stringGreaterThan: 'a'
value: 'b'
# Evaluates to true - 'a' is greater than '0'
stringGreaterThan: '0'
value: 'a'
# Evaluates to false - '0' is less than 'a'
stringGreaterThan: 'a'
value: '0'
```
**stringGreaterThanUguale a**
Verifica se la stringa specificata per `stringGreaterThanEquals` è maggiore o uguale alla stringa specificata nel `value` parametro. Esempio:
```
# Evaluates to true - 'a' is equal to 'A'
stringGreaterThanEquals: 'A'
value: 'a'
# Evaluates to true - 'b' is greater than 'a'
stringGreaterThanEquals: 'a'
value: 'b'
# Evaluates to true - 'a' is greater than '0'
stringGreaterThanEquals: '0'
value: 'a'
# Evaluates to false - '0' is less than 'a'
stringGreaterThanEquals: 'a'
value: '0'
```
**Pattern Matches**
Verifica se la stringa specificata nel `value` parametro corrisponde al modello regex specificato per. `patternMatches` Il confronto utilizza il [pacchetto Golang regexp](https://pkg.go.dev/regexp), che è conforme alla sintassi. RE2 Per ulteriori informazioni sulle RE2 regole, consulta il repository [google/re2](https://github.com/google/re2/wiki/Syntax) in. *GitHub*
L'esempio seguente mostra un pattern match che restituisce: `true`
```
patternMatches: '^[a-z]+$'
value: 'ThisIsValue'
```
## Confronta i numeri
I seguenti operatori di confronto funzionano con i numeri. I valori forniti per questi operatori devono essere di uno dei seguenti tipi, in base alla specifica YAML. Il supporto per i confronti numerici utilizza l'operatore di confronto di pacchetti golang big, ad esempio: [func (](https://pkg.go.dev/math/big#Float.Cmp)\$1Float) Cmp.
+ Numero intero
+ Float (basato su float64, che supporta numeri da -1.7e\$1308 a \$11.7e\$1308)
+ Una stringa che corrisponde al seguente schema regex: `^[-+]?([0-9]+[.])?[0-9]+$`
**Operatori di confronto numerico**
+ [numberEquals](#numberEquals)
+ [numberLessThan](#numberLessThan)
+ [numberLessThanEquals](#numberLessThanEquals)
+ [numberGreaterThan](#numberGreaterThan)
+ [numberGreaterThanEquals](#numberGreaterThanEquals)
**Numero uguale a**
Verifica se il numero specificato per `numberEquals` è uguale al numero specificato nel parametro. `value` Tutti i seguenti esempi di confronto restituiscono`true`:
```
# Values provided as a positive number
numberEquals: 1
value: 1
# Comparison value provided as a string
numberEquals: '1'
value: 1
# Value provided as a string
numberEquals: 1
value: '1'
# Values provided as floats
numberEquals: 5.0
value: 5.0
# Values provided as a negative number
numberEquals: -1
value: -1
```
**numberLessThan**
Verifica se il numero specificato per `numberLessThan` è inferiore al numero specificato nel `value` parametro. Esempio:
```
# Evaluates to true
numberLessThan: 2
value: 1
# Evaluates to true
numberLessThan: 2
value: 1.9
# Evaluates to false
numberLessThan: 2
value: '2'
```
**numberLessThanUguale a**
Verifica se il numero specificato per `numberLessThanEquals` è inferiore o uguale al numero specificato nel `value` parametro. Esempio:
```
# Evaluates to true
numberLessThanEquals: 2
value: 1
# Evaluates to true
numberLessThanEquals: 2
value: 1.9
# Evaluates to true
numberLessThanEquals: 2
value: '2'
# Evaluates to false
numberLessThanEquals: 2
value: 2.1
```
**numberGreaterThan**
Verifica se il numero specificato per `numberGreaterThan` è maggiore del numero specificato nel `value` parametro. Esempio:
```
# Evaluates to true
numberGreaterThan: 1
value: 2
# Evaluates to true
numberGreaterThan: 1
value: 1.1
# Evaluates to false
numberGreaterThan: 1
value: '1'
```
**numberGreaterThanUguale a**
Verifica se il numero specificato per `numberGreaterThanEquals` è maggiore o uguale al numero specificato nel `value` parametro. Esempio:
```
# Evaluates to true
numberGreaterThanEquals: 1
value: 2
# Evaluates to true
numberGreaterThanEquals: 1
value: 1.1
# Evaluates to true
numberGreaterThanEquals: 1
value: '1'
# Evaluates to false
numberGreaterThanEquals: 1
value: 0.8
```
## Controlla i file
I seguenti operatori di confronto controllano l'hash del file o controllano se esiste un file o una cartella.
**Operatori di file e cartelle**
+ [binaryExists](#binaryExists)
+ [fileExists](#fileExists)
+ [folderExists](#folderExists)
+ [fileMD5Equals](#fileMD5Equals)
+ [fileSHA1Equals](#fileSHA1Equals)
+ [fileSHA256Equals](#fileSHA256Equals)
+ [fileSHA512Equals](#fileSHA512Equals)
**Il binario esiste**
Verifica se un'applicazione è disponibile nel percorso corrente. Esempio:
```
binaryExists: 'foo'
```
Sui sistemi Linux e macOS, per un'applicazione denominata*foo*, funziona come il seguente comando bash:**type *foo* >/dev/null 2>&1**, dove **\$1? == 0** indica un confronto riuscito.
Sui sistemi Windows, per un'applicazione denominata*foo*, funziona come il PowerShell comando **& C:\$1Windows\$1System32\$1where.exe /Q *foo*** dove **\$1LASTEXITCODE = 0** indica un confronto riuscito.
**Il file esiste**
Verifica se un file esiste nel percorso specificato. È possibile fornire un percorso assoluto o relativo. Se la posizione specificata esiste ed è un file, il confronto restituisce. `true` Esempio:
```
fileExists: '/path/to/file'
```
Sui sistemi Linux e macOS, funziona come il seguente comando bash:**-d */path/to/file***, dove **\$1? == 0** indica un confronto riuscito.
Sui sistemi Windows, funziona come il PowerShell comando. **Test-Path -Path '*C:\$1path\$1to\$1file*' -PathType 'Leaf'**
**La cartella esiste**
Verifica se esiste una cartella nel percorso specificato. È possibile fornire un percorso assoluto o relativo. Se la posizione specificata esiste ed è una cartella, il confronto restituisce. `true` Esempio:
```
folderExists: '/path/to/folder'
```
Sui sistemi Linux e macOS, funziona come il seguente comando bash:**-d */path/to/folder***, dove **\$1? == 0** indica un confronto riuscito.
Sui sistemi Windows, funziona come il PowerShell comando. **Test-Path -Path '*C:\$1path\$1to\$1folder*' -PathType 'Container'**
**file è uguale MD5 a**
Verifica se l' MD5 hash di un file è uguale a un valore specificato. Esempio:
```
fileMD5Equals: ''
path: '/path/to/file'
```
**file è uguale a SHA1**
Verifica se l' SHA1 hash di un file è uguale a un valore specificato. Esempio:
```
fileSHA1Equals: ''
path: '/path/to/file'
```
**file è uguale a SHA256**
Verifica se l' SHA256 hash di un file è uguale a un valore specificato. Esempio:
```
fileSHA256Equals: ''
path: '/path/to/file'
```
**file è uguale a SHA512**
Verifica se l' SHA512 hash di un file è uguale a un valore specificato. Esempio:
```
fileSHA512Equals: ''
path: '/path/to/file'
```