Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utiliser des opérateurs de comparaison dans les documents relatifs aux AWSTOE composants
Vous pouvez utiliser les opérateurs de comparaison suivants avec le module **[Affirmer](toe-action-modules.md#action-modules-assertion)** d'action et avec les expressions conditionnelles qui utilisent le[si ConstructSyntaxe](toe-conditional-constructs.md#toe-conditional-if). Un opérateur de comparaison peut agir sur une seule valeur, par exemple`stringIsEmpty`, ou il peut comparer une valeur de référence à une deuxième valeur (valeur variable) pour déterminer si l'expression conditionnelle est évaluée à `true` ou`false`.
Si la comparaison fonctionne sur deux valeurs, la seconde valeur peut être une variable de chaînage.
Lorsque vous comparez des valeurs d'un type différent, les conversions de valeurs suivantes peuvent avoir lieu avant la comparaison :
+ Pour les comparaisons numériques, si la valeur de la variable est une chaîne, AWSTOE convertit la chaîne en nombre avant l'évaluation. Si la conversion n'est pas possible, la comparaison est renvoyée`false`. Par exemple, si la valeur de la variable est`"1.0"`, la conversion fonctionne, mais si c'est la valeur de la variable, `"a10"` la conversion échoue.
+ Pour les comparaisons de chaînes, si la valeur de la variable est un nombre, elle est AWSTOE convertie en chaîne avant l'évaluation.
## Comparez les chaînes
Les opérateurs de comparaison suivants fonctionnent avec des chaînes pour comparer des valeurs, pour tester la présence d'espaces ou d'une chaîne vide, ou pour comparer une valeur d'entrée à un modèle d'expression régulière. Les comparaisons de chaînes ne font pas la distinction majuscules/majuscules et ne réduisent pas les espaces entre le début et la fin des entrées de chaîne.
**Opérateurs de comparaison de chaînes**
+ [stringIsEmpty](#stringIsEmpty)
+ [stringIsWhitespace](#stringIsWhitespace)
+ [stringEquals](#stringEquals)
+ [stringLessThan](#stringLessThan)
+ [stringLessThanEquals](#stringLessThanEquals)
+ [stringGreaterThan](#stringGreaterThan)
+ [stringGreaterThanEquals](#stringGreaterThanEquals)
+ [patternMatches](#patternMatches)
**stringIsEmpty**
L'`stringIsEmpty`opérateur revient `true` si la chaîne spécifiée ne contient aucun caractère. Par exemple :
```
# Evaluates to true
stringIsEmpty: ""
# Evaluates to false
stringIsEmpty: " "
# Evaluates to false
stringIsEmpty: "Hello."
```
**stringIsWhitespace**
Teste si la chaîne spécifiée pour ne `stringIsWhitespace` contient que des espaces. Par exemple :
```
# Evaluates to true
stringIsWhitespace: " "
# Evaluates to false
stringIsWhitespace: ""
# Evaluates to false
stringIsWhitespace: " Hello?"
```
**String est égal**
Teste si la chaîne spécifiée pour `stringEquals` correspond exactement à la chaîne spécifiée dans le `value` paramètre. Par exemple :
```
# 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**
Teste si la chaîne spécifiée pour `stringLessThan` est inférieure à la chaîne spécifiée dans le `value` paramètre. Par exemple :
```
# 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'
```
**stringLessThanÉgal**
Teste si la chaîne spécifiée pour `stringLessThanEquals` est inférieure ou égale à la chaîne spécifiée dans le `value` paramètre. Par exemple :
```
# 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**
Teste si la chaîne spécifiée pour `stringGreaterThan` est supérieure à la chaîne spécifiée dans le `value` paramètre. Par exemple :
```
# 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'
```
**stringGreaterThanÉgal**
Teste si la chaîne spécifiée pour `stringGreaterThanEquals` est supérieure ou égale à la chaîne spécifiée dans le `value` paramètre. Par exemple :
```
# 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'
```
**Correspondances à motifs**
Teste si la chaîne spécifiée dans le `value` paramètre correspond au modèle d'expression régulière spécifié pour`patternMatches`. La comparaison utilise le [package Golang regexp](https://pkg.go.dev/regexp), qui est conforme à la syntaxe. RE2 Pour plus d'informations sur RE2 les règles, consultez le référentiel [google/ re2](https://github.com/google/re2/wiki/Syntax) dans *GitHub*.
L'exemple suivant montre une correspondance de modèle qui renvoie `true` :
```
patternMatches: '^[a-z]+$'
value: 'ThisIsValue'
```
## Comparez les chiffres
Les opérateurs de comparaison suivants fonctionnent avec des nombres. Les valeurs fournies pour ces opérateurs doivent être de l'un des types suivants, conformément à la spécification YAML. Support pour les comparaisons numériques utilisant l'opérateur de comparaison de gros paquets Golang, par exemple : [func (\$1Float](https://pkg.go.dev/math/big#Float.Cmp)) Cmp.
+ Entier
+ Float (basé sur float64, qui prend en charge les nombres de -1,7e\$1308 à \$11,7e\$1308)
+ Une chaîne qui correspond au modèle d'expression régulière suivant : `^[-+]?([0-9]+[.])?[0-9]+$`
**Opérateurs de comparaison de nombres**
+ [numberEquals](#numberEquals)
+ [numberLessThan](#numberLessThan)
+ [numberLessThanEquals](#numberLessThanEquals)
+ [numberGreaterThan](#numberGreaterThan)
+ [numberGreaterThanEquals](#numberGreaterThanEquals)
**Le nombre est égal**
Teste si le nombre spécifié pour `numberEquals` est égal au nombre spécifié dans le `value` paramètre. Tous les exemples de comparaison suivants renvoient `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**
Teste si le nombre spécifié pour `numberLessThan` est inférieur au nombre spécifié dans le `value` paramètre. Par exemple :
```
# Evaluates to true
numberLessThan: 2
value: 1
# Evaluates to true
numberLessThan: 2
value: 1.9
# Evaluates to false
numberLessThan: 2
value: '2'
```
**numberLessThanÉgal**
Teste si le nombre spécifié pour `numberLessThanEquals` est inférieur ou égal au nombre spécifié dans le `value` paramètre. Par exemple :
```
# 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**
Teste si le nombre spécifié pour `numberGreaterThan` est supérieur au nombre spécifié dans le `value` paramètre. Par exemple :
```
# Evaluates to true
numberGreaterThan: 1
value: 2
# Evaluates to true
numberGreaterThan: 1
value: 1.1
# Evaluates to false
numberGreaterThan: 1
value: '1'
```
**numberGreaterThanÉgal**
Teste si le nombre spécifié pour `numberGreaterThanEquals` est supérieur ou égal au nombre spécifié dans le `value` paramètre. Par exemple :
```
# 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
```
## Vérifier les fichiers
Les opérateurs de comparaison suivants vérifient le hachage du fichier ou vérifient si un fichier ou un dossier existe.
**Opérateurs de fichiers et de dossiers**
+ [binaryExists](#binaryExists)
+ [fileExists](#fileExists)
+ [folderExists](#folderExists)
+ [fileMD5Equals](#fileMD5Equals)
+ [fileSHA1Equals](#fileSHA1Equals)
+ [fileSHA256Equals](#fileSHA256Equals)
+ [fileSHA512Equals](#fileSHA512Equals)
**Le binaire existe**
Teste si une application est disponible dans le chemin actuel. Par exemple :
```
binaryExists: 'foo'
```
Sur les systèmes Linux et macOS, pour une application nommée*foo*, cela fonctionne de la même manière que la commande bash suivante :**type *foo* >/dev/null 2>&1**, où **\$1? == 0** indique une comparaison réussie.
Sur les systèmes Windows, pour une application nommée*foo*, cela fonctionne de la même manière que la PowerShell commande **& C:\$1Windows\$1System32\$1where.exe /Q *foo*** où **\$1LASTEXITCODE = 0** indique une comparaison réussie.
**Le fichier existe**
Teste si un fichier existe au chemin spécifié. Vous pouvez fournir un chemin absolu ou relatif. Si l'emplacement que vous spécifiez existe et est un fichier, la comparaison est évaluée à`true`. Par exemple :
```
fileExists: '/path/to/file'
```
Sur les systèmes Linux et macOS, cela fonctionne de la même manière que la commande bash suivante :**-d */path/to/file***, où **\$1? == 0** indique une comparaison réussie.
Sur les systèmes Windows, cela fonctionne de la même manière que la PowerShell commande**Test-Path -Path '*C:\$1path\$1to\$1file*' -PathType 'Leaf'**.
**Le dossier existe**
Teste si un dossier existe sur le chemin spécifié. Vous pouvez fournir un chemin absolu ou relatif. Si l'emplacement que vous spécifiez existe et qu'il s'agit d'un dossier, la comparaison est évaluée à`true`. Par exemple :
```
folderExists: '/path/to/folder'
```
Sur les systèmes Linux et macOS, cela fonctionne de la même manière que la commande bash suivante :**-d */path/to/folder***, où **\$1? == 0** indique une comparaison réussie.
Sur les systèmes Windows, cela fonctionne de la même manière que la PowerShell commande**Test-Path -Path '*C:\$1path\$1to\$1folder*' -PathType 'Container'**.
**le fichier MD5 est égal**
Teste si le MD5 hachage d'un fichier est égal à une valeur spécifiée. Par exemple :
```
fileMD5Equals: ''
path: '/path/to/file'
```
**le fichier SHA1 est égal**
Teste si le SHA1 hachage d'un fichier est égal à une valeur spécifiée. Par exemple :
```
fileSHA1Equals: ''
path: '/path/to/file'
```
**le fichier SHA256 est égal**
Teste si le SHA256 hachage d'un fichier est égal à une valeur spécifiée. Par exemple :
```
fileSHA256Equals: ''
path: '/path/to/file'
```
**le fichier SHA512 est égal**
Teste si le SHA512 hachage d'un fichier est égal à une valeur spécifiée. Par exemple :
```
fileSHA512Equals: ''
path: '/path/to/file'
```