{"meta":{"title":"Avaliar expressões em fluxos de trabalho e ações","intro":"Encontre informações sobre expressões em GitHub Actions.","product":"GitHub Actions","breadcrumbs":[{"href":"/pt/enterprise-cloud@latest/actions","title":"GitHub Actions"},{"href":"/pt/enterprise-cloud@latest/actions/reference","title":"Referência"},{"href":"/pt/enterprise-cloud@latest/actions/reference/workflows-and-actions","title":"Fluxos de trabalho e ações"},{"href":"/pt/enterprise-cloud@latest/actions/reference/workflows-and-actions/expressions","title":"Expressões"}],"documentType":"article"},"body":"# Avaliar expressões em fluxos de trabalho e ações\n\nEncontre informações sobre expressões em GitHub Actions.\n\n## Literais\n\nComo parte de uma expressão, você pode usar os tipos de dados `boolean`, `null`, `number` ou `string`.\n\n| Tipo de dados     | Valor literal                                                                                                                                                                                                                                                                                                                     |\n| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `boolean`         |                                                                                                                                                                                                                                                                                                                                   |\n| `true` ou `false` |                                                                                                                                                                                                                                                                                                                                   |\n| `null`            | `null`                                                                                                                                                                                                                                                                                                                            |\n| `number`          | Qualquer formato de número aceito por JSON.                                                                                                                                                                                                                                                                                       |\n| `string`          | Você não precisa colocar cadeias de caracteres em `${` e `}`. No entanto, se você fizer isso, deverá usar aspas simples (`'`) ao redor da cadeia de caracteres. Para usar uma aspa simples literal, não use as aspas simples literais e use as aspas simples adicionais (`''`). Encapsular com aspas duplas (`\"`) gerará um erro. |\n\nNote que em condicionais, valores falsos (`false`, `0`, `-0`, `\"\"`, `''`, `null`) são coagidos para `false` e valores verdadeiros (`true` e outros valores não falsos) são coagidos para `true`.\n\n### Exemplo de literais\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| Operador          | Descrição                         |\n| ----------------- | --------------------------------- |\n| `( )`             | Agrupamento lógico                |\n| `[ ]`             | Índice                            |\n| `.`               | Desreferenciamento de propriedade |\n| `!`               | Not                               |\n| `<`               | Menor que                         |\n| `<=`              | Inferior ou igual                 |\n| `>`               | Maior que                         |\n| `>=`              | Maior ou igual a                  |\n| `==`              | Igual                             |\n| `!=`              | Diferente                         |\n| `&&`              | E                                 |\n| <code>\\|\\|</code> | Ou                                |\n\n> \\[!NOTE]\n> \\*\n> GitHub ignora maiúsculas e minúsculas ao comparar cadeias de caracteres.\n> \\*\n> `steps.<step_id>.outputs.<output_name>` é avaliada como cadeia de caracteres.\n> É necessário usar uma sintaxe específica para avisar o GitHub para avaliar a expressão e não tratá-la como uma string. Para obter mais informações, consulte [Referência de contextos](/pt/enterprise-cloud@latest/actions/reference/workflows-and-actions/contexts#steps-context).\n>\n> * Para comparação numérica, a função `fromJSON()` pode ser usada para converter uma cadeia de caracteres em um número. Para obter mais informações sobre a função `fromJSON()` confira [fromJSON](#fromjson).\n\nGitHub executa comparações de igualdade soltas.\n\n* Se os tipos não corresponderem, GitHub coagi o tipo a um número.\n  GitHub converte tipos de dados em um número usando estas conversões:\n\n  | Tipo     | Result |\n  | -------- | ------ |\n  | Nulo     | `0`    |\n  | booleano |        |\n\n`true` retorna `1` <br />\n`false` retorna `0` |\n\\| String  | Analisado de qualquer formato de número JSON legal, caso contrário, `NaN`. <br /> Observação: a cadeia de caracteres vazia retorna `0`. |\n\\| Array   | `NaN` |\n\\| Objeto  | `NaN` |\n\n* Quando `NaN` é um dos operandos de qualquer comparação relacional (`>`, `<`, `>=`, `<=`), o resultado é sempre `false`. Para obter mais informações, confira os [documentos do NaN Mozilla](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).\n* GitHub ignora maiúsculas e minúsculas ao comparar cadeias de caracteres.\n* Objetos e arrays só são considerados iguais quando forem a mesma instância.\n\n## Functions\n\nGitHub oferece um conjunto de funções internas que você pode usar em expressões. Algumas funções convertem valores em uma string para realizar comparações.\nGitHub converte tipos de dados em uma cadeia de caracteres usando estas conversões:\n\n| Tipo                  | Result                                          |\n| --------------------- | ----------------------------------------------- |\n| Nulo                  | `''`                                            |\n| booleano              |                                                 |\n| `'true'` ou `'false'` |                                                 |\n| Número                | Formato decimal, exponencial para números altos |\n| Array                 | Arrays não são convertidos em uma string        |\n| Objeto                | Objetos não são convertidos em uma string       |\n\n### contém\n\n`contains( search, item )`\n\nRetorna `true` se `search` contém `item`. Se `search` for uma matriz, essa função retornará `true` se o `item` for um elemento na matriz. Se `search` for uma cadeia de caracteres, essa função retornará `true` se `item` uma substring de `search`. Essa função não diferencia maiúsculas de minúsculas. Lança valores em uma string.\n\n#### Exemplo de uso de string\n\n`contains('Hello world', 'llo')` retorna `true`.\n\n#### Exemplo de como usar um filtro de objeto\n\n`contains(github.event.issue.labels.*.name, 'bug')` retornará `true` se o problema relacionado ao evento tiver um rótulo \"bug\".\n\nPara obter mais informações, confira [Filtros de objeto](#object-filters).\n\n#### Exemplo que corresponde a uma matriz de cadeias de caracteres\n\nEm vez de escrever `github.event_name == \"push\" || github.event_name == \"pull_request\"`, você pode usar `contains()` com `fromJSON()` para verificar se uma matriz de cadeias de caracteres contém um `item`.\n\nPor exemplo, `contains(fromJSON('[\"push\", \"pull_request\"]'), github.event_name)` retornará `true` se `github.event_name` for \"push\" ou \"pull\\_request\".\n\n### startsWith\n\n`startsWith( searchString, searchValue )`\n\nRetorna `true` quando`searchString` começa com `searchValue`. Essa função não diferencia maiúsculas de minúsculas. Lança valores em uma string.\n\n#### Exemplo de `startsWith`\n\n`startsWith('Hello world', 'He')` retorna `true`.\n\n### endsWith\n\n`endsWith( searchString, searchValue )`\n\nRetorna `true` se `searchString` termina com `searchValue`. Essa função não diferencia maiúsculas de minúsculas. Lança valores em uma string.\n\n#### Exemplo de `endsWith`\n\n`endsWith('Hello world', 'ld')` retorna `true`.\n\n### formato\n\n`format( string, replaceValue0, replaceValue1, ..., replaceValueN)`\n\nSubstitui os valores na `string`, com a variável `replaceValueN`. As variáveis na `string` são especificadas usando a sintaxe `{N}`, em que `N` é um inteiro. É necessário especificar pelo menos um `replaceValue` e uma `string`. Não há um máximo para o número de variáveis (`replaceValueN`) que você pode usar. Escape de chaves usando chaves duplas.\n\n#### Exemplo de `format`\n\n```javascript\nformat('Hello {0} {1} {2}', 'Mona', 'the', 'Octocat')\n```\n\nRetorna \"Hello Mona the Octocat\".\n\n#### Exemplo de escape de chaves\n\n```javascript\nformat('{{Hello {0} {1} {2}!}}', 'Mona', 'the', 'Octocat')\n```\n\nRetorna '{Hello Mona the Octocat!}'.\n\n### ingressar\n\n`join( array, optionalSeparator )`\n\nO valor para `array` pode ser uma matriz ou uma cadeia de caracteres. Todos os valores em `array` são concatenados em uma cadeia de caracteres. Se você fornecer `optionalSeparator`, ele será inserido entre os valores concatenados. Caso contrário, o separador padrão `,` será usado. Lança valores em uma string.\n\n#### Exemplo de `join`\n\n`join(github.event.issue.labels.*.name, ', ')` pode retornar \"bug, preciso de ajuda\"\n\n### toJSON\n\n`toJSON(value)`\n\nRetorna uma representação JSON recém-impressa de `value`. Você pode usar essa função para depurar as informações fornecidas em contextos.\n\n#### Exemplo de `toJSON`\n\n`toJSON(job)` pode retornar `{ \"status\": \"success\" }`\n\n### fromJSON\n\n`fromJSON(value)`\n\nRetorna um objeto JSON ou um tipo de dados JSON para `value`. Você pode usar essa função para fornecer um objeto JSON como uma expressão avaliada ou para converter qualquer tipo de dados que possa ser representado em JSON ou JavaScript, como cadeias de caracteres, boolianos, valores nulos, matrizes e objetos.\n\n#### Exemplo que retorna um objeto do JSON\n\nEsse fluxo de trabalho define uma matriz JSON em um trabalho e a passa para o próximo trabalho usando uma saída e `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#### Exemplo que retorna um tipo de dado do JSON\n\nEsse fluxo de trabalho usa `fromJSON` para converter variáveis de ambiente de uma cadeia de caracteres em um booliano ou inteiro.\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\nO fluxo de trabalho usa a função `fromJSON()` para converter a variável de ambiente `continue` de uma cadeia de caracteres em um booliano, permitindo que ele determine se deve continuar no erro ou não. Da mesma forma, ele converte a variável de ambiente `time` de uma cadeia de caracteres em um inteiro, definindo o tempo limite para o trabalho em minutos.\n\n### hashFiles\n\n`hashFiles(path)`\n\nRetorna um único hash para o conjunto de arquivos que corresponde ao padrão `path`. Você pode fornecer um único padrão `path` ou vários padrões `path` separados por vírgulas. O `path` é relativo ao diretório `GITHUB_WORKSPACE` e só pode incluir arquivos dentro do `GITHUB_WORKSPACE`. Essa função calcula uma hash SHA-256 individual para cada arquivo correspondente e, em seguida, usa esses hashes para calcular um hash SHA-256 final para o conjunto de arquivos. Se o padrão `path` não corresponder a nenhum arquivo, isso retornará uma cadeia de caracteres vazia. Para obter mais informações sobre SHA-256, consulte [SHA-2](https://en.wikipedia.org/wiki/SHA-2).\n\nVocê pode usar a correspondência de padrão de caracteres para corresponder os nomes dos arquivos. A correspondência de padrões para `hashFiles` segue a correspondência de padrão glob e não diferencia maiúsculas de minúsculas no Windows. Para obter mais informações sobre caracteres de correspondência de padrão com suporte, confira a seção [Padrões](https://www.npmjs.com/package/@actions/glob#patterns) na documentação `@actions/glob`.\n\n#### Exemplos com um padrão único\n\nCorresponde a qualquer arquivo `package-lock.json` no repositório.\n\n`hashFiles('**/package-lock.json')`\n\nCorresponde a todos os arquivos `.js` no diretório `src` no nível de raiz, mas ignora os subdiretórios de `src`.\n\n`hashFiles('/src/*.js')`\n\nCorresponde a todos os arquivos `.rb` no diretório `lib` no nível de raiz, incluindo os subdiretórios de `lib`.\n\n`hashFiles('/lib/**/*.rb')`\n\n#### Exemplos com vários padrões\n\nCria um hash para qualquer `package-lock.json` e arquivos `Gemfile.lock` no repositório.\n\n`hashFiles('**/package-lock.json', '**/Gemfile.lock')`\n\nCria um hash para todos os arquivos `.rb` no diretório `lib` no nível de raiz, incluindo os subdiretórios de `lib`, mas não os arquivos `.rb` no subdiretório `foo`.\n\n`hashFiles('/lib/**/*.rb', '!/lib/foo/*.rb')`\n\n### caso\n\n`case( pred1, val1, pred2, val2, ..., default )`\n\nAvalia predicados em ordem e retorna o valor correspondente ao primeiro predicado que é avaliado como `true`. Se nenhum predicado corresponder, ele retornará o último argumento como o valor padrão.\n\n#### Exemplo com um único predicado\n\n```yaml\nenv:\n  MY_ENV_VAR: ${{ case(github.ref == 'refs/heads/main', 'production', 'development') }}\n```\n\nDefine `MY_ENV_VAR` como `production` quando o ref é `refs/heads/main`, caso contrário, define-o como `development`.\n\n#### Exemplo com vários 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\nConfigura `MY_ENV_VAR` com base na ramificação: `production` para `main`, `staging` para `staging`, `development` para ramificações começando com `feature/`, ou `unknown` para todas as outras ramificações.\n\n## Funções de verificação de status\n\nVocê pode usar as funções de verificação de status a seguir como expressões em condicionais `if`. Uma verificação de status `success()` padrão é aplicada, a menos que você inclua uma dessas funções. Para obter mais informações sobre condicionais `if`, confira [Sintaxe de fluxo de trabalho para o GitHub Actions](/pt/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idif) e [Referência de sintaxe de metadados](/pt/enterprise-cloud@latest/actions/reference/workflows-and-actions/metadata-syntax#runsstepsif).\n\nFora de condicionais `if`, você pode usar `job.status` para acessar o status do trabalho. Para saber mais, confira [Referência de contextos](/pt/enterprise-cloud@latest/actions/reference/workflows-and-actions/contexts#job-context).\n\n### sucesso\n\nRetorna `true` quando todas as etapas anteriores forem bem-sucedidas.\n\n#### Exemplo de `success`\n\n```yaml\nsteps:\n  ...\n  - name: The job has succeeded\n    if: ${{ success() }}\n```\n\n### sempre\n\nFaz com que a etapa sempre seja executada e retorna `true`, mesmo quando cancelada. A expressão `always` é melhor usada no nível da etapa ou em tarefas que você espera executar mesmo quando um trabalho é cancelado. Por exemplo, você pode usar `always` para enviar logs mesmo quando um trabalho é cancelado.\n\n> \\[!WARNING]\n> Evite usar `always` para qualquer tarefa que possa sofrer uma falha crítica, por exemplo, obtenção de fontes. Caso contrário, o fluxo de trabalho pode travar até atingir o tempo limite. Se você quiser executar um trabalho ou uma etapa independentemente de seu êxito ou falha, use a alternativa recomendada: `if: ${{ !cancelled() }}`\n\n#### Exemplo de `always`\n\n```yaml\nif: ${{ always() }}\n```\n\n### cancelled\n\nRetorna `true` se o fluxo de trabalho foi cancelado.\n\n#### Exemplo de `cancelled`\n\n```yaml\nif: ${{ cancelled() }}\n```\n\n### falha\n\nRetorna `true` quando qualquer etapa anterior de um trabalho falha. Se você tiver uma cadeia de trabalhos dependentes, `failure()` retornará `true` se algum trabalho ancestral falhar.\n\n#### Exemplo de `failure`\n\n```yaml\nsteps:\n  ...\n  - name: The job has failed\n    if: ${{ failure() }}\n```\n\n#### falha com condições\n\nVocê pode incluir condições extras para uma etapa a ser executada após uma falha, mas ainda precisa incluir `failure()` para substituir a verificação de status padrão de `success()` que é aplicada automaticamente a condições `if` que não contêm uma função de verificação de status.\n\n##### Exemplo de `failure` com condições\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 objeto\n\nVocê pode usar a sintaxe `*` para aplicar um filtro e selecionar itens de uma coleção correspondente.\n\nPor exemplo, considere uma matriz de objetos chamados `fruits`.\n\n```json\n[\n  { \"name\": \"apple\", \"quantity\": 1 },\n  { \"name\": \"orange\", \"quantity\": 2 },\n  { \"name\": \"pear\", \"quantity\": 1 }\n]\n```\n\nO filtro `fruits.*.name` retorna a matriz `[ \"apple\", \"orange\", \"pear\" ]`.\n\nVocê também pode usar a sintaxe `*` em um objeto. Por exemplo, suponha que você tenha um objeto chamado `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\nO filtro `vegetables.*.ediblePortions` pode ser avaliado como:\n\n```json\n\n[\n  [\"roots\", \"stalks\"],\n  [\"hearts\", \"stems\", \"leaves\"],\n  [\"roots\", \"stems\", \"leaves\"],\n]\n```\n\nComo os objetos não preservam a ordem, a ordem da saída não pode ser garantida."}