{"meta":{"title":"Évaluer des expressions dans les workflows et les actions.","intro":"Rechercher des informations pour les expressions dans GitHub Actions.","product":"GitHub Actions","breadcrumbs":[{"href":"/fr/actions","title":"GitHub Actions"},{"href":"/fr/actions/reference","title":"Référence"},{"href":"/fr/actions/reference/workflows-and-actions","title":"Flux de travail et actions"},{"href":"/fr/actions/reference/workflows-and-actions/expressions","title":"Expressions"}],"documentType":"article"},"body":"# Évaluer des expressions dans les workflows et les actions.\n\nRechercher des informations pour les expressions dans GitHub Actions.\n\n## Littéraux\n\nDans le cadre d’une expression, vous pouvez utiliser des types de données `boolean`, `null`, `number` ou `string`.\n\n| Type de données   | Valeur littérale                                                                                                                                                                                                                                                                                                                                                           |\n| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `boolean`         |                                                                                                                                                                                                                                                                                                                                                                            |\n| `true` ou `false` |                                                                                                                                                                                                                                                                                                                                                                            |\n| `null`            | `null`                                                                                                                                                                                                                                                                                                                                                                     |\n| `number`          | Tout format de nombre pris en charge par JSON.                                                                                                                                                                                                                                                                                                                             |\n| `string`          | Vous n’avez pas besoin de placer les chaînes entre `${` et `}`. Toutefois, si vous le faites, vous devez utiliser des guillemets simples (`'`) autour de la chaîne. Pour utiliser un guillemet simple littéral, échappez le guillemet simple littéral en utilisant un guillemet simple supplémentaire (`''`). L’utilisation de guillemets doubles (`\"`) génère une erreur. |\n\nNotez que dans les conditions, les valeurs erronées (`false`, `0`, `-0`, `\"\"`, `''`, `null`) sont forcées vers `false`, et les valeurs vraies (`true` et d’autres valeurs non erronées) sont forcées vers `true`.\n\n### Exemple de littéraux\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## Opérateurs\n\n| Opérateur         | Description                          |\n| ----------------- | ------------------------------------ |\n| `( )`             | Regroupement logique                 |\n| `[ ]`             | Index                                |\n| `.`               | Annulation de référence de propriété |\n| `!`               | Not                                  |\n| `<`               | Inférieur à                          |\n| `<=`              | Inférieur ou égal à                  |\n| `>`               | Supérieur à                          |\n| `>=`              | Supérieur ou égal à                  |\n| `==`              | Égal à                               |\n| `!=`              | Différent de                         |\n| `&&`              | And                                  |\n| <code>\\|\\|</code> | ou                                   |\n\n> \\[!NOTE]\n> \\*\n> GitHub ne tient pas compte de la casse lors de la comparaison de chaînes.\n> \\*\n> `steps.<step_id>.outputs.<output_name>` est évalué en tant que chaîne.\n> Vous devez utiliser une syntaxe spécifique pour indiquer à GitHub d’évaluer une expression plutôt que de la traiter comme une chaîne. Pour plus d’informations, consultez [Référence des contextes](/fr/actions/reference/workflows-and-actions/contexts#steps-context).\n>\n> * Pour la comparaison numérique, la fonction `fromJSON()` peut être utilisée pour convertir une chaîne en nombre. Pour plus d’informations sur la fonction `fromJSON()`, consultez [fromJSON](#fromjson).\n\nGitHub effectue des comparaisons d’égalité libre.\n\n* Si les types ne correspondent pas, GitHub force le type à un nombre.\n  GitHub convertit les types de données en un nombre à l’aide de ces conversions :\n\n  | Type    | Résultats |\n  | ------- | --------- |\n  | Null    | `0`       |\n  | Boolean |           |\n\n`true`retourne`1` <br />\n`false`retourne`0` |\n\\| String  | Analysé depuis n’importe quel format de nombre JSON légal ; sinon `NaN`. <br /> Remarque : une chaîne vide retourne `0`. |\n\\| Array   | `NaN` |\n\\| Object  | `NaN` |\n\n* Quand `NaN` est l’un des opérandes d’une comparaison relationnelle (`>`, `<`, `>=`, `<=`), le résultat est toujours `false`. Pour plus d’informations, consultez les [documents Mozilla sur NaN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).\n* GitHub ne tient pas compte de la casse lors de la comparaison de chaînes.\n* Les objets et les tableaux sont considérés comme égaux uniquement lorsqu’ils sont une même instance.\n\n## Fonctions\n\nGitHub offre un ensemble de fonctions intégrées que vous pouvez utiliser dans des expressions. Certaines fonctions convertissent les valeurs en chaîne pour effectuer des comparaisons.\nGitHub convertit des types de données en chaîne de caractères selon les conversions suivantes :\n\n| Type                  | Résultats                                          |\n| --------------------- | -------------------------------------------------- |\n| Null                  | `''`                                               |\n| Boolean               |                                                    |\n| `'true'` ou `'false'` |                                                    |\n| Number                | Format décimal, exponentiel pour de grands nombres |\n| Array                 | Les tableaux ne sont pas convertis en chaîne       |\n| Object                | Les objets ne sont pas convertis en chaîne         |\n\n### contient\n\n`contains( search, item )`\n\nRetourne `true` si `search` contient `item`. Si `search` est un tableau, cette fonction retourne `true` si `item` est un élément dans le tableau. Si `search` est une chaîne, cette fonction retourne `true` si l’élément `item` est une sous-chaîne de `search`. Cette fonction ne respecte pas la casse. Convertit les valeurs en chaîne.\n\n#### Exemple utilisant une chaîne\n\n`contains('Hello world', 'llo')` retourne `true`.\n\n#### Exemple utilisant un filtre d’objet\n\n`contains(github.event.issue.labels.*.name, 'bug')` retourne `true` si le problème lié à l’événement a une étiquette « bug ».\n\nPour plus d’informations, consultez [Filtres d’objet ](#object-filters).\n\n#### Exemple mettant en correspondance un tableau de chaînes\n\nAu lieu d’écrire `github.event_name == \"push\" || github.event_name == \"pull_request\"`, vous pouvez utiliser `contains()` avec `fromJSON()` pour vérifier si un tableau de chaînes contient un `item`.\n\nPar exemple, `contains(fromJSON('[\"push\", \"pull_request\"]'), github.event_name)` retourne `true` si `github.event_name` est « push » ou « pull\\_request ».\n\n### startsWith\n\n`startsWith( searchString, searchValue )`\n\nRetourne `true` quand `searchString` commence par `searchValue`. Cette fonction ne respecte pas la casse. Convertit les valeurs en chaîne.\n\n#### Exemple de `startsWith`\n\n`startsWith('Hello world', 'He')` retourne `true`.\n\n### endsWith\n\n`endsWith( searchString, searchValue )`\n\nRetourne `true` si `searchString` se termine par `searchValue`. Cette fonction ne respecte pas la casse. Convertit les valeurs en chaîne.\n\n#### Exemple de `endsWith`\n\n`endsWith('Hello world', 'ld')` retourne `true`.\n\n### format\n\n`format( string, replaceValue0, replaceValue1, ..., replaceValueN)`\n\nRemplace les valeurs dans la chaîne `string`, par la variable `replaceValueN`. Les variables dans la chaîne `string` sont spécifiées à l’aide de la syntaxe `{N}`, où `N` est un entier. Vous devez spécifier au moins une valeur `replaceValue` et une chaîne `string`. Il n’existe pas de maximum pour le nombre de variables (`replaceValueN`) utilisables. Échappez les accolades à l’aide d’accolades doubles.\n\n#### Exemple de `format`\n\n```javascript\nformat('Hello {0} {1} {2}', 'Mona', 'the', 'Octocat')\n```\n\nRetourne « Hello Mona the Octocat ».\n\n#### Exemple d’échappement d’accolades\n\n```javascript\nformat('{{Hello {0} {1} {2}!}}', 'Mona', 'the', 'Octocat')\n```\n\nRetourne « {Hello Mona the Octocat!} ».\n\n### join\n\n`join( array, optionalSeparator )`\n\nLa valeur pour `array` peut être un tableau ou une chaîne. Toutes les valeurs contenues dans `array` sont concaténées en une chaîne. Si vous fournissez `optionalSeparator`, il est inséré entre les valeurs concaténées. Sinon, le séparateur par défaut `,` est utilisé. Convertit les valeurs en chaîne.\n\n#### Exemple de `join`\n\n`join(github.event.issue.labels.*.name, ', ')` peut retourner « bug, help wanted »\n\n### toJSON\n\n`toJSON(value)`\n\nRetourne une représentation JSON d’impression formatée de `value`. Vous pouvez utiliser cette fonction pour déboguer les informations fournies dans les contextes.\n\n#### Exemple de `toJSON`\n\n`toJSON(job)` peut retourner `{ \"status\": \"success\" }`\n\n### fromJSON\n\n`fromJSON(value)`\n\nRetourne un objet JSON ou un type de données JSON pour `value`. Vous pouvez utiliser cette fonction pour fournir un objet JSON en tant qu’expression évaluée ou pour convertir n’importe quel type de données qui peut être représenté dans JSON ou JavaScript, comme des chaînes, des booléens, des valeurs null, des tableaux et des objets.\n\n#### Exemple de retour d’un objet JSON\n\nCe workflow définit une matrice JSON dans un travail et le transmet au travail suivant à l’aide d’une sortie et de `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#### Exemple retournant un type de données JSON\n\nCe workflow utilise `fromJSON` pour convertir les variables d’environnement d’une chaîne en booléen ou entier.\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\nLe flux de travail utilise la fonction `fromJSON()` pour convertir la variable d’environnement `continue` d’une chaîne en valeur booléenne, ce qui lui permet de déterminer s’il faut continuer à l’erreur ou non. De même, il convertit la variable d’environnement `time` d’une chaîne en entier, en définissant le délai d’expiration du projet en minutes.\n\n### hashFiles\n\n`hashFiles(path)`\n\nRetourne un hachage unique pour l’ensemble des fichiers qui correspondent au modèle `path`. Vous pouvez fournir un modèle `path` unique ou plusieurs modèles `path` séparés par des virgules. L’élément `path` est relatif au répertoire `GITHUB_WORKSPACE` et ne peut inclure que des fichiers à l’intérieur de `GITHUB_WORKSPACE`. Cette fonction calcule un hachage SHA-256 individuel pour chaque fichier correspondant, puis utilise ces hachages pour calculer un hachage SHA-256 final pour l’ensemble de fichiers. Si le modèle `path` ne correspond à aucun fichier, une chaîne vide est retournée. Pour plus dʼinformations sur SHA-256, consultez la section [SHA-2](https://en.wikipedia.org/wiki/SHA-2).\n\nVous pouvez utiliser des caractères de correspondance de modèle pour mettre en correspondance des noms de fichiers. La correspondance de modèle pour `hashFiles` suit la correspondance de modèle global et est insensible à la casse sur Windows. Pour plus d’informations sur les caractères de correspondance de modèle pris en charge, consultez la section [Modèles](https://www.npmjs.com/package/@actions/glob#patterns) dans la documentation `@actions/glob`.\n\n#### Exemples avec un modèle unique\n\nCorrespond à n’importe quel fichier `package-lock.json` dans le dépôt.\n\n`hashFiles('**/package-lock.json')`\n\nCorrespond à tous les fichiers `.js` dans le répertoire `src` au niveau racine, mais ignore les sous-répertoires de `src`.\n\n`hashFiles('/src/*.js')`\n\nCorrespond à tous les fichiers `.rb` dans le répertoire `lib` au niveau racine, y compris les sous-répertoires de `lib`.\n\n`hashFiles('/lib/**/*.rb')`\n\n#### Exemples avec plusieurs modèles\n\nCrée un hachage pour n’importe quels fichiers `package-lock.json` et `Gemfile.lock` dans le dépôt.\n\n`hashFiles('**/package-lock.json', '**/Gemfile.lock')`\n\nCrée un hachage pour tous les fichiers `.rb` dans le répertoire `lib` au niveau racine, y compris les sous-répertoires de `lib`, mais pas les fichiers `.rb` dans le sous-répertoire `foo`.\n\n`hashFiles('/lib/**/*.rb', '!/lib/foo/*.rb')`\n\n### case\n\n`case( pred1, val1, pred2, val2, ..., default )`\n\nÉvalue les prédicats dans l'ordre et retourne la valeur correspondant au premier prédicat qui évalue à `true`. Si aucun prédicat ne correspond, il retourne le dernier argument comme valeur par défaut.\n\n#### Exemple avec un seul prédicat\n\n```yaml\nenv:\n  MY_ENV_VAR: ${{ case(github.ref == 'refs/heads/main', 'production', 'development') }}\n```\n\nDéfinit `MY_ENV_VAR` à `production` lorsque la référence est `refs/heads/main`, sinon, la définit à `development`.\n\n#### Exemple avec plusieurs prédicats\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\nDéfinit `MY_ENV_VAR` en fonction de la branche : `production` pour `main`, `staging` pour `staging`, `development` pour les branches commençant par `feature/`, ou `unknown` pour toutes les autres branches.\n\n## Fonctions de vérification d’état\n\nVous pouvez utiliser les fonctions de vérification d’état suivantes en tant qu’expressions dans les conditions `if`. Une vérification d’état par défaut de `success()` est appliquée, sauf si vous incluez l’une de ces fonctions. Pour plus d’informations sur les conditions `if`, consultez [Syntaxe de flux de travail pour GitHub Actions](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idif) et [Référence syntaxique des métadonnées](/fr/actions/reference/workflows-and-actions/metadata-syntax#runsstepsif).\n\nEn dehors des conditions `if`, vous pouvez utiliser `job.status` pour accéder au statut de la tâche. Pour plus d’informations, consultez « [Référence des contextes](/fr/actions/reference/workflows-and-actions/contexts#job-context) ».\n\n### success\n\nRetourne `true` quand toutes les étapes précédentes ont réussi.\n\n#### Exemple de `success`\n\n```yaml\nsteps:\n  ...\n  - name: The job has succeeded\n    if: ${{ success() }}\n```\n\n### toujours\n\nProvoque l’exécution systématique de l’étape et retourne `true`, même lorsqu’elle est annulée. L’expression `always` est à utiliser de préférence au niveau de l’étape ou sur des tâches que vous prévoyez d’exécuter même quand un travail est annulé. Par exemple, vous pouvez utiliser `always` pour envoyer des journaux même quand un travail est annulé.\n\n> \\[!WARNING]\n> Évitez d’utiliser `always` pour une tâche susceptible de subir une défaillance critique, comme l’obtention de sources ; sinon, le workflow peut se bloquer jusqu’à ce qu’il arrive à expiration. Si vous souhaitez exécuter un travail ou une étape indépendamment de sa réussite ou de son échec, utilisez l’alternative recommandée : `if: ${{ !cancelled() }}`\n\n#### Exemple de `always`\n\n```yaml\nif: ${{ always() }}\n```\n\n### annulé\n\nRetourne `true` si le workflow a été annulé.\n\n#### Exemple de `cancelled`\n\n```yaml\nif: ${{ cancelled() }}\n```\n\n### failure\n\nRetourne `true` quand une étape précédente quelconque d’un travail échoue. Si vous avez une chaîne de travaux dépendants, `failure()` retourne `true` si un travail ancêtre quelconque échoue.\n\n#### Exemple de `failure`\n\n```yaml\nsteps:\n  ...\n  - name: The job has failed\n    if: ${{ failure() }}\n```\n\n#### échec avec conditions\n\nVous pouvez inclure des conditions supplémentaires pour qu’une étape s’exécute après un échec. Toutefois, vous devez toujours inclure `failure()` pour remplacer la vérification d’état par défaut `success()`, qui s’applique automatiquement aux conditions `if` qui ne contiennent pas de fonction de vérification d’état.\n\n##### Exemple de `failure` avec des conditions\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## Filtres d’objets\n\nVous pouvez utiliser la syntaxe `*` pour appliquer un filtre et sélectionner des éléments correspondants dans une collection.\n\nPar exemple, considérez un tableau d’objets nommé `fruits`.\n\n```json\n[\n  { \"name\": \"apple\", \"quantity\": 1 },\n  { \"name\": \"orange\", \"quantity\": 2 },\n  { \"name\": \"pear\", \"quantity\": 1 }\n]\n```\n\nLe filtre `fruits.*.name` retourne le tableau `[ \"apple\", \"orange\", \"pear\" ]`.\n\nVous pouvez également utiliser la syntaxe `*` sur un objet. Par exemple, supposons que vous avez un objet nommé `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\nLe filtre `vegetables.*.ediblePortions` peut donner pour résultats :\n\n```json\n\n[\n  [\"roots\", \"stalks\"],\n  [\"hearts\", \"stems\", \"leaves\"],\n  [\"roots\", \"stems\", \"leaves\"],\n]\n```\n\nComme les objets ne conservent pas l’ordre, l’ordre de la sortie ne peut pas être garanti."}