Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden Sie Vergleichsoperatoren in AWSTOE Komponentendokumenten
Sie können die folgenden Vergleichsoperatoren mit dem **[Bestätigen](toe-action-modules.md#action-modules-assertion)** Aktionsmodul und mit bedingten Ausdrücken verwenden, die den verwenden[wenn KonstruktSyntax](toe-conditional-constructs.md#toe-conditional-if). Ein Vergleichsoperator kann beispielsweise `stringIsEmpty` mit einem einzelnen Wert arbeiten oder einen Basiswert mit einem zweiten Wert (Variablenwert) vergleichen, um festzustellen, ob der bedingte Ausdruck als `true` oder `false` ausgewertet wird.
Wenn der Vergleich auf zwei Werten basiert, kann der zweite Wert eine verkettete Variable sein.
Beim Vergleich von Werten eines anderen Typs können vor dem Vergleich die folgenden Wertekonvertierungen erfolgen:
+ Wenn der Variablenwert bei numerischen Vergleichen eine Zeichenfolge ist, wird die Zeichenfolge vor der Auswertung in eine Zahl AWSTOE umgewandelt. Wenn die Konvertierung nicht möglich ist, kehrt der Vergleich zurück`false`. Wenn der Variablenwert beispielsweise ist`"1.0"`, funktioniert die Konvertierung, aber wenn der Variablenwert ist, schlägt `"a10"` die Konvertierung fehl.
+ Wenn der Variablenwert bei Zeichenkettenvergleichen eine Zahl ist, wird er vor der Auswertung in eine Zeichenfolge AWSTOE umgewandelt.
## Vergleiche Zeichenketten
Die folgenden Vergleichsoperatoren verwenden Zeichenketten, um Werte zu vergleichen, auf Leerzeichen oder eine leere Zeichenfolge zu testen oder einen Eingabewert mit einem Regex-Muster zu vergleichen. Bei Zeichenfolgenvergleichen wird nicht zwischen Groß- und Kleinschreibung unterschieden und Leerzeichen am Anfang oder Ende der Zeichenketteneingaben werden nicht gekürzt.
**Operatoren zum Vergleich von Zeichenketten**
+ [stringIsEmpty](#stringIsEmpty)
+ [stringIsWhitespace](#stringIsWhitespace)
+ [stringEquals](#stringEquals)
+ [stringLessThan](#stringLessThan)
+ [stringLessThanEquals](#stringLessThanEquals)
+ [stringGreaterThan](#stringGreaterThan)
+ [stringGreaterThanEquals](#stringGreaterThanEquals)
+ [patternMatches](#patternMatches)
**stringIsEmpty**
Der `stringIsEmpty` Operator kehrt zurück, `true` wenn die angegebene Zeichenfolge keine Zeichen enthält. Beispiel:
```
# Evaluates to true
stringIsEmpty: ""
# Evaluates to false
stringIsEmpty: " "
# Evaluates to false
stringIsEmpty: "Hello."
```
**stringIsWhitespace**
Testet, ob die für angegebene Zeichenfolge nur Leerzeichen `stringIsWhitespace` enthält. Beispiel:
```
# Evaluates to true
stringIsWhitespace: " "
# Evaluates to false
stringIsWhitespace: ""
# Evaluates to false
stringIsWhitespace: " Hello?"
```
**Zeichenfolge ist gleich**
Testet, ob die für `stringEquals` angegebene Zeichenfolge exakt mit der im Parameter angegebenen Zeichenfolge übereinstimmt. `value` Beispiel:
```
# 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**
Testet, ob die für angegebene Zeichenfolge kleiner als die im `value` Parameter angegebene Zeichenfolge `stringLessThan` ist. Beispiel:
```
# 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'
```
**stringLessThanEntspricht**
Testet, ob die für angegebene Zeichenfolge kleiner oder gleich der im `value` Parameter angegebenen Zeichenfolge `stringLessThanEquals` ist. Beispiel:
```
# 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**
Testet, ob die für angegebene Zeichenfolge größer als die im `value` Parameter angegebene Zeichenfolge `stringGreaterThan` ist. Beispiel:
```
# 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'
```
**stringGreaterThanEntspricht**
Testet, ob die für angegebene Zeichenfolge größer oder gleich der im `value` Parameter angegebenen Zeichenfolge `stringGreaterThanEquals` ist. Beispiel:
```
# 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'
```
**PatternMatches**
Testet, ob die im `value` Parameter angegebene Zeichenfolge mit dem für angegebenen Regex-Muster übereinstimmt. `patternMatches` Der Vergleich verwendet das [Golang-Regexp-Paket, das](https://pkg.go.dev/regexp) der Syntax entspricht. RE2 Weitere Informationen zu RE2 Regeln finden Sie im [google/re2-Repository](https://github.com/google/re2/wiki/Syntax) unter. *GitHub*
Das folgende Beispiel zeigt eine Musterübereinstimmung, die Folgendes zurückgibt`true`:
```
patternMatches: '^[a-z]+$'
value: 'ThisIsValue'
```
## Zahlen vergleichen
Die folgenden Vergleichsoperatoren arbeiten mit Zahlen. Bei den für diese Operatoren bereitgestellten Werte muss es sich gemäß der YAML-Spezifikation um einen der folgenden Typen handeln. Die Support für numerische Vergleiche verwendet den Golang Big Package Comparison Operator, zum Beispiel: [func (\$1Float](https://pkg.go.dev/math/big#Float.Cmp)) Cmp.
+ Ganzzahl
+ Float (basiert auf float64, das Zahlen von -1.7e\$1308 bis \$11.7e\$1308 unterstützt)
+ Eine Zeichenfolge, die dem folgenden Regex-Muster entspricht: `^[-+]?([0-9]+[.])?[0-9]+$`
**Operatoren für den Zahlenvergleich**
+ [numberEquals](#numberEquals)
+ [numberLessThan](#numberLessThan)
+ [numberLessThanEquals](#numberLessThanEquals)
+ [numberGreaterThan](#numberGreaterThan)
+ [numberGreaterThanEquals](#numberGreaterThanEquals)
**Zahl ist gleich**
Testet, ob die für `numberEquals` angegebene Zahl der im Parameter angegebenen Zahl entspricht. `value` Alle folgenden Beispielvergleiche geben Folgendes zurück`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**
Testet, ob die für angegebene Zahl kleiner als die im `value` Parameter angegebene Zahl `numberLessThan` ist. Beispiel:
```
# Evaluates to true
numberLessThan: 2
value: 1
# Evaluates to true
numberLessThan: 2
value: 1.9
# Evaluates to false
numberLessThan: 2
value: '2'
```
**numberLessThanEntspricht**
Testet, ob die für angegebene Zahl kleiner oder gleich der im `value` Parameter angegebenen Zahl `numberLessThanEquals` ist. Beispiel:
```
# 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**
Testet, ob die für angegebene Zahl größer als die im `value` Parameter angegebene Zahl `numberGreaterThan` ist. Beispiel:
```
# Evaluates to true
numberGreaterThan: 1
value: 2
# Evaluates to true
numberGreaterThan: 1
value: 1.1
# Evaluates to false
numberGreaterThan: 1
value: '1'
```
**numberGreaterThanEntspricht**
Testet, ob die für angegebene Zahl größer oder gleich der im `value` Parameter angegebenen Zahl `numberGreaterThanEquals` ist. Beispiel:
```
# 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
```
## Überprüfen Sie die Dateien
Die folgenden Vergleichsoperatoren überprüfen den Datei-Hash oder prüfen, ob eine Datei oder ein Ordner existiert.
**Datei- und Ordneroperatoren**
+ [binaryExists](#binaryExists)
+ [fileExists](#fileExists)
+ [folderExists](#folderExists)
+ [fileMD5Equals](#fileMD5Equals)
+ [fileSHA1Equals](#fileSHA1Equals)
+ [fileSHA256Equals](#fileSHA256Equals)
+ [fileSHA512Equals](#fileSHA512Equals)
**Binärdatei existiert**
Testet, ob eine Anwendung im aktuellen Pfad verfügbar ist. Beispiel:
```
binaryExists: 'foo'
```
Auf Linux- und macOS-Systemen funktioniert dies für eine Anwendung mit dem Namen *foo* genauso wie der folgende Bash-Befehl:**type *foo* >/dev/null 2>&1**, wobei **\$1? == 0** auf einen erfolgreichen Vergleich hinweist.
Auf Windows-Systemen funktioniert dies für eine Anwendung mit dem Namen genauso wie der PowerShell Befehl *foo***& C:\$1Windows\$1System32\$1where.exe /Q *foo***, der **\$1LASTEXITCODE = 0** auf einen erfolgreichen Vergleich hinweist.
**Die Datei ist vorhanden**
Testet, ob eine Datei im angegebenen Pfad existiert. Sie können einen absoluten oder relativen Pfad angeben. Wenn der von Ihnen angegebene Speicherort existiert und es sich um `true` eine Datei handelt, ergibt der Vergleich Folgendes: Beispiel:
```
fileExists: '/path/to/file'
```
Auf Linux- und macOS-Systemen funktioniert dies genauso wie der folgende Bash-Befehl:**-d */path/to/file***, wobei **\$1? == 0** auf einen erfolgreichen Vergleich hinweist.
Auf Windows-Systemen funktioniert das genauso wie der PowerShell Befehl**Test-Path -Path '*C:\$1path\$1to\$1file*' -PathType 'Leaf'**.
**Ordner ist vorhanden**
Testet, ob ein Ordner im angegebenen Pfad existiert. Sie können einen absoluten oder relativen Pfad angeben. Wenn der von Ihnen angegebene Speicherort vorhanden ist und es sich um `true` einen Ordner handelt, ergibt der Vergleich Folgendes: Beispiel:
```
folderExists: '/path/to/folder'
```
Auf Linux- und macOS-Systemen funktioniert dies genauso wie der folgende Bash-Befehl:**-d */path/to/folder***, wobei **\$1? == 0** auf einen erfolgreichen Vergleich hinweist.
Auf Windows-Systemen funktioniert das genauso wie der PowerShell Befehl**Test-Path -Path '*C:\$1path\$1to\$1folder*' -PathType 'Container'**.
**Datei MD5 ist gleich**
Testet, ob der MD5 Hash einer Datei einem bestimmten Wert entspricht. Beispiel:
```
fileMD5Equals: ''
path: '/path/to/file'
```
**Datei SHA1 ist gleich**
Testet, ob der SHA1 Hash einer Datei einem bestimmten Wert entspricht. Beispiel:
```
fileSHA1Equals: ''
path: '/path/to/file'
```
**Datei SHA256 ist gleich**
Testet, ob der SHA256 Hash einer Datei einem bestimmten Wert entspricht. Beispiel:
```
fileSHA256Equals: ''
path: '/path/to/file'
```
**Datei SHA512 ist gleich**
Testet, ob der SHA512 Hash einer Datei einem bestimmten Wert entspricht. Beispiel:
```
fileSHA512Equals: ''
path: '/path/to/file'
```