As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Use operadores de comparação em documentos de AWSTOE componentes
Você pode usar os operadores de comparação a seguir com o módulo de ação **[Assert](toe-action-modules.md#action-modules-assertion)** e com expressões condicionais que usam o [Constructo “if”Sintaxe](toe-conditional-constructs.md#toe-conditional-if). Um operador de comparação pode operar em um único valor (por exemplo, `stringIsEmpty`) ou comparar um valor de referência com um segundo valor (valor variável) para determinar se a expressão condicional é avaliada como `true` ou `false`.
Se a comparação operar em dois valores, o segundo valor poderá ser uma variável de encadeamento.
Ao comparar valores de um tipo diferente, as seguintes conversões de valor podem ocorrer antes da comparação:
+ Para comparações numéricas, se o valor da variável for uma string, AWSTOE converte a string em um número antes da avaliação. Se a conversão não for possível, a comparação responderá com `false`. Por exemplo, se o valor da variável for `"1.0"`, a conversão funcionará, mas, se o valor da variável for `"a10"`, a conversão falhará.
+ Para comparações de strings, se o valor da variável for um número, AWSTOE converte-o em uma string antes da avaliação.
## Comparar strings
Os operadores de comparação a seguir funcionam com strings de caracteres para comparar valores, testar espaços ou uma string vazia ou comparar um valor de entrada com um padrão regex. As comparações de strings não diferenciam maiúsculas de minúsculas e não removem os espaços do início ou do final das entradas de string.
**Operadores de comparação de strings**
+ [stringIsEmpty](#stringIsEmpty)
+ [stringIsWhitespace](#stringIsWhitespace)
+ [stringEquals](#stringEquals)
+ [stringLessThan](#stringLessThan)
+ [stringLessThanEquals](#stringLessThanEquals)
+ [stringGreaterThan](#stringGreaterThan)
+ [stringGreaterThanEquals](#stringGreaterThanEquals)
+ [patternMatches](#patternMatches)
**stringIsEmpty**
O operador `stringIsEmpty` responderá com `true` se a string especificada não contiver nenhum caractere. Por exemplo:
```
# Evaluates to true
stringIsEmpty: ""
# Evaluates to false
stringIsEmpty: " "
# Evaluates to false
stringIsEmpty: "Hello."
```
**stringIsWhitespace**
Testa se a string especificada para `stringIsWhitespace` contém somente espaços. Por exemplo:
```
# Evaluates to true
stringIsWhitespace: " "
# Evaluates to false
stringIsWhitespace: ""
# Evaluates to false
stringIsWhitespace: " Hello?"
```
**stringEquals**
Testa se a string especificada para `stringEquals` é uma correspondência exata para a string especificada no parâmetro `value`. Por exemplo:
```
# 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**
Testa se a string especificada para `stringLessThan` é menor do que a string especificada no parâmetro `value`. Por exemplo:
```
# 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'
```
**stringLessThanIgual**
Testa se a string especificada para `stringLessThanEquals` é menor ou igual à string especificada no parâmetro `value`. Por exemplo:
```
# 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**
Testa se a string especificada para `stringGreaterThan` é maior do que a string especificada no parâmetro `value`. Por exemplo:
```
# 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'
```
**stringGreaterThanIgual**
Testa se a string especificada para `stringGreaterThanEquals` é maior ou igual à string especificada no parâmetro `value`. Por exemplo:
```
# 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**
Testa se a string especificada para `value` corresponde ao padrão regex especificado para `patternMatches`. A comparação usa o [pacote Golang regexp](https://pkg.go.dev/regexp), que está em conformidade com a sintaxe. RE2 Para obter mais informações sobre RE2 regras, consulte o repositório [google/ re2](https://github.com/google/re2/wiki/Syntax) em. *GitHub*
O exemplo a seguir mostra uma correspondência de padrões que responde com `true`:
```
patternMatches: '^[a-z]+$'
value: 'ThisIsValue'
```
## Comparar números
Os operadores de comparação a seguir funcionam com números. Os valores fornecidos para esses operadores devem ser de um dos tipos a seguir, de acordo com a especificação YAML. O suporte a comparações numéricas usa o operador de comparação do pacote Golang Big, por exemplo: [func (\$1Float) Cmp](https://pkg.go.dev/math/big#Float.Cmp).
+ Inteiro
+ Float (com base no float64, compatível com números de -1.7e\$1308 a \$11.7e\$1308)
+ Uma string que corresponde ao seguinte padrão de regex: `^[-+]?([0-9]+[.])?[0-9]+$`
**Operadores de comparação de números**
+ [numberEquals](#numberEquals)
+ [numberLessThan](#numberLessThan)
+ [numberLessThanEquals](#numberLessThanEquals)
+ [numberGreaterThan](#numberGreaterThan)
+ [numberGreaterThanEquals](#numberGreaterThanEquals)
**numberEquals**
Testa se o número especificado para `numberEquals` é igual ao número especificado no parâmetro `value`. Todos os seguintes exemplos de comparação respondem com `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**
Testa se o número especificado para `numberLessThan` é menor do que o número especificado no parâmetro `value`. Por exemplo:
```
# Evaluates to true
numberLessThan: 2
value: 1
# Evaluates to true
numberLessThan: 2
value: 1.9
# Evaluates to false
numberLessThan: 2
value: '2'
```
**numberLessThanIgual**
Testa se o número especificado para `numberLessThanEquals` é menor ou igual ao número especificado no parâmetro `value`. Por exemplo:
```
# 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**
Testa se o número especificado para `numberGreaterThan` é maior do que o número especificado no parâmetro `value`. Por exemplo:
```
# Evaluates to true
numberGreaterThan: 1
value: 2
# Evaluates to true
numberGreaterThan: 1
value: 1.1
# Evaluates to false
numberGreaterThan: 1
value: '1'
```
**numberGreaterThanIgual**
Testa se o número especificado para `numberGreaterThanEquals` é maior ou igual ao número especificado no parâmetro `value`. Por exemplo:
```
# 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
```
## Verificar arquivos
Os operadores de comparação a seguir verificam o hash do arquivo ou se um arquivo ou pasta existe.
**Operadores de arquivos e pastas**
+ [binaryExists](#binaryExists)
+ [fileExists](#fileExists)
+ [folderExists](#folderExists)
+ [fileMD5Equals](#fileMD5Equals)
+ [fileSHA1Equals](#fileSHA1Equals)
+ [fileSHA256Equals](#fileSHA256Equals)
+ [fileSHA512Equals](#fileSHA512Equals)
**binaryExists**
Testa se uma aplicação está disponível no caminho atual. Por exemplo:
```
binaryExists: 'foo'
```
Em sistemas Linux e macOS, para um aplicativo chamado*foo*, isso funciona da mesma forma que o seguinte comando bash:**type *foo* >/dev/null 2>&1**, onde **\$1? == 0** indica uma comparação bem-sucedida.
Em sistemas Windows, para um aplicativo chamado*foo*, isso funciona da mesma forma que o PowerShell comando **& C:\$1Windows\$1System32\$1where.exe /Q *foo*** que **\$1LASTEXITCODE = 0** indica uma comparação bem-sucedida.
**fileExists**
Testa se um arquivo existe no caminho especificado. Você pode fornecer um caminho absoluto ou relativo. Se o local especificado existir e for um arquivo, a comparação será avaliada como `true`. Por exemplo:
```
fileExists: '/path/to/file'
```
Nos sistemas Linux e macOS, isso funciona da mesma forma que o seguinte comando bash: **-d */path/to/file***, em que **\$1? == 0** indica uma comparação bem-sucedida.
Nos sistemas Windows, isso funciona da mesma forma que o PowerShell comando**Test-Path -Path '*C:\$1path\$1to\$1file*' -PathType 'Leaf'**.
**folderExists**
Testa se uma pasta existe no caminho especificado. Você pode fornecer um caminho absoluto ou relativo. Se o local especificado existir e for uma pasta, a comparação será avaliada como `true`. Por exemplo:
```
folderExists: '/path/to/folder'
```
Nos sistemas Linux e macOS, isso funciona da mesma forma que o seguinte comando bash: **-d */path/to/folder***, em que **\$1? == 0** indica uma comparação bem-sucedida.
Nos sistemas Windows, isso funciona da mesma forma que o PowerShell comando**Test-Path -Path '*C:\$1path\$1to\$1folder*' -PathType 'Container'**.
**arquivo é igual MD5 a**
Testa se o MD5 hash de um arquivo é igual a um valor especificado. Por exemplo:
```
fileMD5Equals: ''
path: '/path/to/file'
```
**arquivo é igual SHA1 a**
Testa se o SHA1 hash de um arquivo é igual a um valor especificado. Por exemplo:
```
fileSHA1Equals: ''
path: '/path/to/file'
```
**arquivo é igual SHA256 a**
Testa se o SHA256 hash de um arquivo é igual a um valor especificado. Por exemplo:
```
fileSHA256Equals: ''
path: '/path/to/file'
```
**arquivo é igual SHA512 a**
Testa se o SHA512 hash de um arquivo é igual a um valor especificado. Por exemplo:
```
fileSHA512Equals: ''
path: '/path/to/file'
```