Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Utilice operadores de comparación en los documentos TOE de AWS de componentes
Puede utilizar los siguientes operadores de comparación con el módulo de acción **[Assert](toe-action-modules.md#action-modules-assertion)** y con las expresiones condicionales que utilizan [Constructo ifSintaxis](toe-conditional-constructs.md#toe-conditional-if). Un operador de comparación puede operar con un único valor, por ejemplo, `stringIsEmpty`, o puede comparar un valor de referencia con un segundo valor (valor variable) para determinar si la expresión condicional se evalúa como `true` o `false`.
Si la comparación funciona con dos valores, el segundo valor puede ser una variable encadenante.
Al comparar valores de un tipo diferente, se pueden producir las siguientes conversiones de valores antes de la comparación:
+ Para las comparaciones numéricas, si el valor de la variable es una cadena, TOE de AWS convierte la cadena en un número antes de la evaluación. Si la conversión no es posible, la comparación devuelve el resultado `false`. Por ejemplo, si el valor de la variable es `"1.0"`, la conversión funciona, pero si el valor de la variable es `"a10"`, la conversión falla.
+ Para las comparaciones de cadenas, si el valor de la variable es un número, lo TOE de AWS convierte en una cadena antes de la evaluación.
## Comparación de cadenas
Los siguientes operadores de comparación funcionan con cadenas para comparar valores, comprobar si hay espacios o una cadena vacía, o para comparar un valor de entrada con un patrón de expresiones regulares. Las comparaciones de cadenas no distinguen entre mayúsculas y minúsculas y no recortan los espacios desde el principio o el final de las entradas de cadenas.
**Operadores de comparación de cadenas**
+ [stringIsEmpty](#stringIsEmpty)
+ [stringIsWhitespace](#stringIsWhitespace)
+ [stringEquals](#stringEquals)
+ [stringLessThan](#stringLessThan)
+ [stringLessThanEquals](#stringLessThanEquals)
+ [stringGreaterThan](#stringGreaterThan)
+ [stringGreaterThanEquals](#stringGreaterThanEquals)
+ [patternMatches](#patternMatches)
**stringIsEmpty**
El operador `stringIsEmpty` devuelve `true` si la cadena especificada no contiene ningún carácter. Por ejemplo:
```
# Evaluates to true
stringIsEmpty: ""
# Evaluates to false
stringIsEmpty: " "
# Evaluates to false
stringIsEmpty: "Hello."
```
**stringIsWhitespace**
Comprueba si la cadena especificada para `stringIsWhitespace` contiene solo espacios. Por ejemplo:
```
# Evaluates to true
stringIsWhitespace: " "
# Evaluates to false
stringIsWhitespace: ""
# Evaluates to false
stringIsWhitespace: " Hello?"
```
**stringEquals**
Comprueba si la cadena especificada para `stringEquals` coincide exactamente con la cadena especificada en el parámetro `value`. Por ejemplo:
```
# 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**
Comprueba si la cadena especificada para `stringLessThan` es inferior a la cadena especificada en el parámetro `value`. Por ejemplo:
```
# 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'
```
**stringLessThanEs igual a**
Comprueba si la cadena especificada para `stringLessThanEquals` es inferior o igual a la cadena especificada en el parámetro `value`. Por ejemplo:
```
# 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**
Comprueba si la cadena especificada para `stringGreaterThan` es superior a la cadena especificada en el parámetro `value`. Por ejemplo:
```
# 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'
```
**stringGreaterThanIguales**
Comprueba si la cadena especificada para `stringGreaterThanEquals` es superior o igual a la cadena especificada en el parámetro `value`. Por ejemplo:
```
# 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**
Comprueba si la cadena especificada en el parámetro `value` coincide con el patrón de expresiones regulares especificado para `patternMatches`. La comparación utiliza el [paquete de expresiones regulares de Golang](https://pkg.go.dev/regexp), que se ajusta a la sintaxis. RE2 Para obtener más información sobre RE2 las reglas, consulte el repositorio [google/](https://github.com/google/re2/wiki/Syntax) re2 en. *GitHub*
En el siguiente ejemplo, se muestra una coincidencia de patrones que devuelve `true`:
```
patternMatches: '^[a-z]+$'
value: 'ThisIsValue'
```
## Comparación de números
Los siguientes operadores de comparación funcionan con números. Los valores proporcionados para estos operadores deben ser de uno de los siguientes tipos, según la especificación YAML. La admisión de comparaciones numéricas utiliza el operador de comparación de paquetes grandes de Golang, por ejemplo: [func (\$1Float) Cmp](https://pkg.go.dev/math/big#Float.Cmp).
+ Entero
+ Float (basado en float64, admite números del -1,7e\$1308 al \$11,7e\$1308)
+ Cadena que coincide con el siguiente patrón de expresiones regulares: `^[-+]?([0-9]+[.])?[0-9]+$`
**Operadores de comparación de números**
+ [numberEquals](#numberEquals)
+ [numberLessThan](#numberLessThan)
+ [numberLessThanEquals](#numberLessThanEquals)
+ [numberGreaterThan](#numberGreaterThan)
+ [numberGreaterThanEquals](#numberGreaterThanEquals)
**numberEquals**
Comprueba si el número especificado para `numberEquals` es igual al número especificado en el parámetro `value`. Todos los ejemplos de comparación siguientes devuelven `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**
Comprueba si el número especificado para `numberLessThan` es inferior al número especificado en el parámetro `value`. Por ejemplo:
```
# Evaluates to true
numberLessThan: 2
value: 1
# Evaluates to true
numberLessThan: 2
value: 1.9
# Evaluates to false
numberLessThan: 2
value: '2'
```
**numberLessThanEs igual a**
Comprueba si el número especificado para `numberLessThanEquals` es inferior o igual al número especificado en el parámetro `value`. Por ejemplo:
```
# 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**
Comprueba si el número especificado para `numberGreaterThan` es superior al número especificado en el parámetro `value`. Por ejemplo:
```
# Evaluates to true
numberGreaterThan: 1
value: 2
# Evaluates to true
numberGreaterThan: 1
value: 1.1
# Evaluates to false
numberGreaterThan: 1
value: '1'
```
**numberGreaterThanIguales**
Comprueba si el número especificado para `numberGreaterThanEquals` es superior o igual al número especificado en el parámetro `value`. Por ejemplo:
```
# 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
```
## Control de archivos
Los siguientes operadores de comparación comprueban el hash del archivo o comprueban si existe un archivo o una carpeta.
**Operadores de archivos y carpetas**
+ [binaryExists](#binaryExists)
+ [fileExists](#fileExists)
+ [folderExists](#folderExists)
+ [fileMD5Equals](#fileMD5Equals)
+ [fileSHA1Equals](#fileSHA1Equals)
+ [fileSHA256Equals](#fileSHA256Equals)
+ [fileSHA512Equals](#fileSHA512Equals)
**binaryExists**
Comprueba si una aplicación está disponible en la ruta actual. Por ejemplo:
```
binaryExists: 'foo'
```
En los sistemas Linux y macOS, para una aplicación llamada*foo*, esto funciona igual que el siguiente comando bash:**type *foo* >/dev/null 2>&1**, donde **\$1? == 0** indica que la comparación se ha realizado correctamente.
En los sistemas Windows, para una aplicación denominada*foo*, funciona igual que el PowerShell comando que **\$1LASTEXITCODE = 0** indica que la comparación **& C:\$1Windows\$1System32\$1where.exe /Q *foo*** se ha realizado correctamente.
**fileExists**
Comprueba si un archivo existe en la ruta especificada. Puede proporcionar una ruta absoluta o relativa. Si la ubicación que especifique existe y es un archivo, la comparación se evaluará como `true`. Por ejemplo:
```
fileExists: '/path/to/file'
```
En los sistemas Linux y macOS, funciona igual que el siguiente comando bash: **-d */path/to/file***, donde **\$1? == 0** indica que la comparación se ha realizado correctamente.
En los sistemas Windows, funciona igual que el PowerShell comando**Test-Path -Path '*C:\$1path\$1to\$1file*' -PathType 'Leaf'**.
**folderExists**
Comprueba si existe una carpeta en la ruta especificada. Puede proporcionar una ruta absoluta o relativa. Si la ubicación que especifique existe y es una carpeta, la comparación se evaluará como `true`. Por ejemplo:
```
folderExists: '/path/to/folder'
```
En los sistemas Linux y macOS, funciona igual que el siguiente comando bash: **-d */path/to/folder***, donde **\$1? == 0** indica que la comparación se ha realizado correctamente.
En los sistemas Windows, funciona igual que el PowerShell comando**Test-Path -Path '*C:\$1path\$1to\$1folder*' -PathType 'Container'**.
**el archivo MD5 es igual a**
Comprueba si el MD5 hash de un archivo es igual a un valor especificado. Por ejemplo:
```
fileMD5Equals: ''
path: '/path/to/file'
```
**el archivo SHA1 es igual a**
Comprueba si el SHA1 hash de un archivo es igual a un valor especificado. Por ejemplo:
```
fileSHA1Equals: ''
path: '/path/to/file'
```
**el archivo SHA256 es igual a**
Comprueba si el SHA256 hash de un archivo es igual a un valor especificado. Por ejemplo:
```
fileSHA256Equals: ''
path: '/path/to/file'
```
**el archivo SHA512 es igual a**
Comprueba si el SHA512 hash de un archivo es igual a un valor especificado. Por ejemplo:
```
fileSHA512Equals: ''
path: '/path/to/file'
```