{"meta":{"title":"Evaluación de expresiones en flujos de trabajo y acciones","intro":"Buscar información sobre las expresiones en GitHub Actions.","product":"GitHub Actions","breadcrumbs":[{"href":"/es/enterprise-cloud@latest/actions","title":"GitHub Actions"},{"href":"/es/enterprise-cloud@latest/actions/reference","title":"Referencia"},{"href":"/es/enterprise-cloud@latest/actions/reference/workflows-and-actions","title":"Flujos de trabajo y acciones"},{"href":"/es/enterprise-cloud@latest/actions/reference/workflows-and-actions/expressions","title":"Expresiones"}],"documentType":"article"},"body":"# Evaluación de expresiones en flujos de trabajo y acciones\n\nBuscar información sobre las expresiones en GitHub Actions.\n\n## Literales\n\nComo parte de una expresión, puedes usar los tipos de datos `boolean`, `null`, `number` o `string`.\n\n| Tipo de datos    | Valor literal                                                                                                                                                                                                                                                                                                     |\n| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `boolean`        |                                                                                                                                                                                                                                                                                                                   |\n| `true` o `false` |                                                                                                                                                                                                                                                                                                                   |\n| `null`           | `null`                                                                                                                                                                                                                                                                                                            |\n| `number`         | Cualquier formato de número compatible con JSON.                                                                                                                                                                                                                                                                  |\n| `string`         | No es necesario incluir las cadenas en `${` y `}`. Sin embargo, en caso de que lo hagas, debes utilizar comillas simples (`'`) alrededor de la cadena. Para utilizar una comilla simple literal, escápala utilizando una comilla simple adicional (`''`). El ajuste con comillas dobles (`\"`) producirá un error. |\n\nTen en cuenta que en los condicionales, los valores falsificados (`false`, `0`, `-0`, `\"\"`, `''`, `null`) se convierten a `false` y los verdaderos (`true` y otros valores no falsificados) se convierten a `true`.\n\n### Ejemplo de literales\n\n```yaml\nenv:\n  myNull: ${{ null }}\n  myBoolean: ${{ false }}\n  myIntegerNumber: ${{ 711 }}\n  myFloatNumber: ${{ -9.2 }}\n  myHexNumber: ${{ 0xff }}\n  myExponentialNumber: ${{ -2.99e-2 }}\n  myString: Mona the Octocat\n  myStringInBraces: ${{ 'It''s open source!' }}\n```\n\n## Operadores\n\n| Operator          | Descripción                |\n| ----------------- | -------------------------- |\n| `( )`             | Agrupación lógica          |\n| `[ ]`             | Índice                     |\n| `.`               | Desreferencia de propiedad |\n| `!`               | Not                        |\n| `<`               | Menor que                  |\n| `<=`              | Menor o igual que          |\n| `>`               | Mayor que                  |\n| `>=`              | Mayor o igual que          |\n| `==`              | Es igual a                 |\n| `!=`              | No es igual                |\n| `&&`              | And                        |\n| <code>\\|\\|</code> | Or                         |\n\n> \\[!NOTE]\n> \\*\n> GitHub no distingue entre mayúsculas y minúsculas al comparar cadenas.\n> \\*\n> `steps.<step_id>.outputs.<output_name>` se evalúa como una cadena.\n> Debes usar una sintaxis específica para decirle a GitHub que evalúe una expresión en lugar de tratarla como una cadena. Para obtener más información, consulte [Contextos de referencia](/es/enterprise-cloud@latest/actions/reference/workflows-and-actions/contexts#steps-context).\n>\n> * Para la comparación numérica, la función `fromJSON()` se puede usar para convertir una cadena en un número. Para obtener más información sobre la función `fromJSON()`, consulte [fromJSON](#fromjson).\n\nGitHub realiza comparaciones de igualdad no estricta.\n\n* Si los tipos no coinciden, GitHub convierte el tipo en un número.\n  GitHub convierte los tipos de datos en un número mediante estas conversiones:\n\n  | Tipo    | Resultado |\n  | ------- | --------- |\n  | Null    | `0`       |\n  | Boolean |           |\n\n`true` devuelve `1` <br />\n`false` devuelve `0` |\n\\| String  | Se analiza desde cualquier formato de número JSON legal; de lo contrario, `NaN`. <br /> Nota: La cadena vacía devuelve `0`. |\n\\| Array   | `NaN` |\n\\| Object  | `NaN` |\n\n* Cuando `NaN` es uno de los operandos de cualquier comparación relacional (`>`, `<`, `>=`, `<=`), el resultado siempre es `false`. Para obtener más información, consulte la [documentación de NaN Mozilla](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).\n* GitHub no distingue entre mayúsculas y minúsculas al comparar cadenas.\n* Los objetos y matrices solo se consideran iguales cuando son la misma instancia.\n\n## Funciones\n\nGitHub ofrece un conjunto de funciones integradas que puede usar en expresiones. Algunas funciones fusionan valores en una cadena para realizar las comparaciones.\nGitHub convierte los tipos de datos en una cadena mediante estas conversiones:\n\n| Tipo                 | Resultado                                         |\n| -------------------- | ------------------------------------------------- |\n| Null                 | `''`                                              |\n| Boolean              |                                                   |\n| `'true'` o `'false'` |                                                   |\n| Number               | Formato decimal, exponencial para números grandes |\n| Array                | Las matrices no se convierten en cadenas          |\n| Object               | Los objetos no se convierten en cadenas           |\n\n### contains\n\n`contains( search, item )`\n\nDevuelve `true` si `search` contiene `item`. Si `search` es una matriz, esta función devuelve `true` si `item` es un elemento de la matriz. Si `search` es una cadena, esta función devuelve `true` si `item` es una subcadena de `search`. Esta función no distingue mayúsculas de minúsculas. Fusiona valores en una cadena.\n\n#### Ejemplo usando una cadena\n\n`contains('Hello world', 'llo')` devuelve `true`.\n\n#### Ejemplo de uso de un filtro de objetos\n\n`contains(github.event.issue.labels.*.name, 'bug')` devuelve `true` si el problema relacionado con el evento tiene una etiqueta \"bug\".\n\nPara obtener más información, consulte [Filtros de objetos](#object-filters).\n\n#### Ejemplo que coincide con una matriz de cadenas\n\nEn lugar de escribir `github.event_name == \"push\" || github.event_name == \"pull_request\"`, puedes usar `contains()` con `fromJSON()` para comprobar si una matriz de cadenas contiene un `item`.\n\nPor ejemplo, `contains(fromJSON('[\"push\", \"pull_request\"]'), github.event_name)` devuelve `true` si `github.event_name` es \"push\" o \"pull\\_request\".\n\n### startsWith\n\n`startsWith( searchString, searchValue )`\n\nDevuelve `true` cuando `searchString` empieza por `searchValue`. Esta función no distingue mayúsculas de minúsculas. Fusiona valores en una cadena.\n\n#### Ejemplo de `startsWith`\n\n`startsWith('Hello world', 'He')` devuelve `true`.\n\n### endsWith\n\n`endsWith( searchString, searchValue )`\n\nDevuelve `true` si la cadena `searchString` está situada al final de la cadena `searchValue`. Esta función no distingue mayúsculas de minúsculas. Fusiona valores en una cadena.\n\n#### Ejemplo de `endsWith`\n\n`endsWith('Hello world', 'ld')` devuelve `true`.\n\n### formato\n\n`format( string, replaceValue0, replaceValue1, ..., replaceValueN)`\n\nReemplaza los valores de `string`, con la variable `replaceValueN`. Las variables de `string` se especifican mediante la sintaxis `{N}`, donde `N` es un entero. Debes especificar al menos un `replaceValue` y `string`. No hay un máximo para el número de variables (`replaceValueN`) que puedes usar. Escapar las llaves utilizando llaves dobles.\n\n#### Ejemplo de `format`\n\n```javascript\nformat('Hello {0} {1} {2}', 'Mona', 'the', 'Octocat')\n```\n\nDevuelve 'Hello Mona the Octocat'.\n\n#### Ejemplo de evasión de llaves\n\n```javascript\nformat('{{Hello {0} {1} {2}!}}', 'Mona', 'the', 'Octocat')\n```\n\nDevuelve '{Hello Mona the Octocat!}'.\n\n### join\n\n`join( array, optionalSeparator )`\n\nEl valor de `array` puede ser una matriz o una cadena. Todos los valores de `array` se concatenan en una cadena. Si proporcionas `optionalSeparator`, se inserta entre los valores concatenados. De lo contrario, se usa el separador predeterminado `,`. Fusiona valores en una cadena.\n\n#### Ejemplo de `join`\n\n`join(github.event.issue.labels.*.name, ', ')` puede devolver \"bug, help wanted\"\n\n### toJSON\n\n`toJSON(value)`\n\nDevuelve una representación JSON con formato mejorado de `value`. Puedes usar esta función para depurar la información suministrada en contextos.\n\n#### Ejemplo de `toJSON`\n\n`toJSON(job)` puede devolver `{ \"status\": \"success\" }`\n\n### fromJSON\n\n`fromJSON(value)`\n\nDevuelve un objeto JSON o un tipo de datos JSON para `value`. Puedes usar esta función para proporcionar un objeto JSON como una expresión evaluada o convertir cualquier tipo de datos que se pueda representar en JSON o JavaScript, como cadenas, valores booleanos, valores NULL, matrices y objetos.\n\n#### Ejemplo de devolver un objeto JSON\n\nEste flujo de trabajo configura una matriz de JSON en un trabajo, y lo pasa al siguiente trabajo utilizando una salida y `fromJSON`.\n\n```yaml copy\nname: build\non: push\njobs:\n  job1:\n    runs-on: ubuntu-latest\n    outputs:\n      matrix: ${{ steps.set-matrix.outputs.matrix }}\n    steps:\n      - id: set-matrix\n        run: echo \"matrix={\\\"include\\\":[{\\\"project\\\":\\\"foo\\\",\\\"config\\\":\\\"Debug\\\"},{\\\"project\\\":\\\"bar\\\",\\\"config\\\":\\\"Release\\\"}]}\" >> $GITHUB_OUTPUT\n  job2:\n    needs: job1\n    runs-on: ubuntu-latest\n    strategy:\n      matrix: ${{ fromJSON(needs.job1.outputs.matrix) }}\n    steps:\n      - run: echo \"Matrix - Project ${{ matrix.project }}, Config ${{ matrix.config }}\"\n```\n\n#### Ejemplo de devolver un tipo de datos JSON\n\nEste flujo de trabajo usa `fromJSON` para convertir variables de entorno de una cadena a un valor booleano o entero.\n\n```yaml copy\nname: print\non: push\nenv:\n  continue: true\n  time: 3\njobs:\n  job1:\n    runs-on: ubuntu-latest\n    steps:\n      - continue-on-error: ${{ fromJSON(env.continue) }}\n        timeout-minutes: ${{ fromJSON(env.time) }}\n        run: echo ...\n```\n\nEl flujo de trabajo usa la función `fromJSON()` para convertir la variable de entorno `continue` de una cadena en un valor booleano, lo que le permite determinar si desea continuar con el error o no. Del mismo modo, convierte la variable de entorno `time` de una cadena en un entero y establece el tiempo de espera del trabajo en minutos.\n\n### hashFiles\n\n`hashFiles(path)`\n\nDevuelve un hash único para el conjunto de archivos que coincide con el patrón `path`. Puede proporcionar un único patrón `path` o varios patrones `path` separados por comas.\n`path` es relativo al directorio `GITHUB_WORKSPACE` y solo puede incluir archivos dentro de `GITHUB_WORKSPACE`. Esta función calcula un hash SHA-256 individual para cada archivo coincidente, y luego usa esos hashes para calcular un hash SHA-256 final para el conjunto de archivos. Si el patrón `path` no coincide con ningún archivo, devuelve una cadena vacía. Para obtener más información sobre SHA-256, consulte [SHA-2](https://en.wikipedia.org/wiki/SHA-2).\n\nPuedes usar caracteres de coincidencia de patrones para encontrar nombres de archivos. La coincidencia de patrones de `hashFiles` se ajusta a la coincidencia de patrones globales y no distingue mayúsculas de minúsculas en Windows. Para obtener más información sobre los caracteres de coincidencia de patrones admitidos, consulte la sección [Patrones](https://www.npmjs.com/package/@actions/glob#patterns) de la documentación de `@actions/glob`.\n\n#### Ejemplos con un solo patrón\n\nCoincide con cualquier archivo `package-lock.json` del repositorio.\n\n`hashFiles('**/package-lock.json')`\n\nCoincide con todos los archivos `.js` del directorio `src` en el nivel raíz, pero omite los subdirectorios de `src`.\n\n`hashFiles('/src/*.js')`\n\nCoincide con todos los archivos `.rb` del directorio `lib` en el nivel raíz, incluidos los subdirectorios de `lib`.\n\n`hashFiles('/lib/**/*.rb')`\n\n#### Ejemplos con patrones múltiples\n\nCrea un hash para todos los archivos `package-lock.json` y `Gemfile.lock` del repositorio.\n\n`hashFiles('**/package-lock.json', '**/Gemfile.lock')`\n\nCrea un hash para todos los archivos `.rb` del directorio `lib` en el nivel raíz, incluidos los subdirectorios de `lib`, pero sin incluir los archivos `.rb` del subdirectorio `foo`.\n\n`hashFiles('/lib/**/*.rb', '!/lib/foo/*.rb')`\n\n### mayúsculas y minúsculas\n\n`case( pred1, val1, pred2, val2, ..., default )`\n\nEvalúa los predicados en orden y devuelve el valor correspondiente al primer predicado que se evalúa como `true`. Si no coincide ningún predicado, devuelve el último argumento como valor predeterminado.\n\n#### Ejemplo con un solo predicado\n\n```yaml\nenv:\n  MY_ENV_VAR: ${{ case(github.ref == 'refs/heads/main', 'production', 'development') }}\n```\n\nEstablece `MY_ENV_VAR` en `production` cuando la referencia es `refs/heads/main`, de lo contrario, la establece en `development`.\n\n#### Ejemplo con varios predicados\n\n```yaml\nenv:\n  MY_ENV_VAR: |-\n    ${{ case(\n      github.ref == 'refs/heads/main', 'production',\n      github.ref == 'refs/heads/staging', 'staging',\n      startsWith(github.ref, 'refs/heads/feature/'), 'development',\n      'unknown'\n    ) }}\n```\n\nEstablece `MY_ENV_VAR` en función de la rama: `production` para `main`, `staging` para `staging`, `development` para ramas a partir de `feature/`, o `unknown` para todas las demás ramas.\n\n## Funciones de verificación del estado\n\nPuedes usar las siguientes funciones de comprobación de estado como expresiones en condicionales `if`. Se aplica una comprobación de estado predeterminada de `success()` a menos que incluyas una de estas funciones. Para más información sobre los condicionales `if`, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idif) y [Guía de referencia de la sintaxis de metadatos](/es/enterprise-cloud@latest/actions/reference/workflows-and-actions/metadata-syntax#runsstepsif).\n\nAdemás de las condicionales `if`, puedes usar `job.status` para acceder al estado del trabajo. Para más información, consulta [Contextos de referencia](/es/enterprise-cloud@latest/actions/reference/workflows-and-actions/contexts#job-context).\n\n### correcto\n\nDevuelve `true` cuando todos los pasos anteriores se han realizado correctamente.\n\n#### Ejemplo de `success`\n\n```yaml\nsteps:\n  ...\n  - name: The job has succeeded\n    if: ${{ success() }}\n```\n\n### Siempre\n\nHace que el paso siempre se ejecute y devuelve `true`, incluso cuando se cancela. La expresión `always` se usa mejor en el nivel de paso o en las tareas que se espera ejecutar incluso cuando se cancela un trabajo. Por ejemplo, puedes usar `always` para enviar registros incluso cuando se cancela un trabajo.\n\n> \\[!WARNING]\n> Evite el uso de `always` para cualquier tarea que pueda sufrir un error crítico, como obtener orígenes; de lo contrario, el flujo de trabajo podría bloquearse hasta que se agote el tiempo de espera. Si desea ejecutar un trabajo o un paso independientemente de si se ha ejecutado correctamente o no, use la alternativa recomendada: `if: ${{ !cancelled() }}`.\n\n#### Ejemplo de `always`\n\n```yaml\nif: ${{ always() }}\n```\n\n### cancelled\n\nDevuelve `true` si el flujo de trabajo se ha cancelado.\n\n#### Ejemplo de `cancelled`\n\n```yaml\nif: ${{ cancelled() }}\n```\n\n### failure\n\nDevuelve `true` cuando se produce un error en cualquier paso anterior de un trabajo. Si tienes una cadena de trabajos dependientes, `failure()` devuelve `true` si se produce un error en algún trabajo antecesor.\n\n#### Ejemplo de `failure`\n\n```yaml\nsteps:\n  ...\n  - name: The job has failed\n    if: ${{ failure() }}\n```\n\n#### error con condiciones\n\nPuedes incluir condiciones adicionales para que un paso se ejecute después de un error, pero todavía debes incluir `failure()` para invalidar la comprobación de estado predeterminada de `success()` que se aplica automáticamente a las condiciones `if` que no contienen una función de comprobación de estado.\n\n##### Ejemplo de `failure` con condiciones\n\n```yaml\nsteps:\n  ...\n  - name: Failing step\n    id: demo\n    run: exit 1\n  - name: The demo step has failed\n    if: ${{ failure() && steps.demo.conclusion == 'failure' }}\n```\n\n## Filtros de objetos\n\nPuedes usar la sintaxis `*` para aplicar un filtro y seleccionar los elementos coincidentes en una colección.\n\nPor ejemplo, considera una matriz de objetos denominada `fruits`.\n\n```json\n[\n  { \"name\": \"apple\", \"quantity\": 1 },\n  { \"name\": \"orange\", \"quantity\": 2 },\n  { \"name\": \"pear\", \"quantity\": 1 }\n]\n```\n\nEl filtro `fruits.*.name` devuelve la matriz `[ \"apple\", \"orange\", \"pear\" ]`.\n\nTambién puedes usar la sintaxis `*` en un objeto. Por ejemplo, supongamos que tienes un objeto denominado `vegetables`.\n\n```json\n\n{\n  \"scallions\":\n  {\n    \"colors\": [\"green\", \"white\", \"red\"],\n    \"ediblePortions\": [\"roots\", \"stalks\"],\n  },\n  \"beets\":\n  {\n    \"colors\": [\"purple\", \"red\", \"gold\", \"white\", \"pink\"],\n    \"ediblePortions\": [\"roots\", \"stems\", \"leaves\"],\n  },\n  \"artichokes\":\n  {\n    \"colors\": [\"green\", \"purple\", \"red\", \"black\"],\n    \"ediblePortions\": [\"hearts\", \"stems\", \"leaves\"],\n  },\n}\n```\n\nEl filtro `vegetables.*.ediblePortions` podría evaluarse como:\n\n```json\n\n[\n  [\"roots\", \"stalks\"],\n  [\"hearts\", \"stems\", \"leaves\"],\n  [\"roots\", \"stems\", \"leaves\"],\n]\n```\n\nDado que los objetos no conservan el orden, no se puede garantizar el orden de la salida."}