{"meta":{"title":"Auswerten von Ausdrücken in Workflows und Aktionen","intro":"Informationen zu Ausdrücken findest du in GitHub Actions.","product":"GitHub Actions","breadcrumbs":[{"href":"/de/actions","title":"GitHub Actions"},{"href":"/de/actions/reference","title":"Verweis"},{"href":"/de/actions/reference/workflows-and-actions","title":"Workflows und Aktionen"},{"href":"/de/actions/reference/workflows-and-actions/expressions","title":"Ausdrücke"}],"documentType":"article"},"body":"# Auswerten von Ausdrücken in Workflows und Aktionen\n\nInformationen zu Ausdrücken findest du in GitHub Actions.\n\n## Literale\n\nIn Ausdrücken kannst du die Datentypen `boolean`, `null`, `number` oder `string` verwenden.\n\n| Datentyp  | Literalwert |\n| --------- | ----------- |\n| `boolean` |             |\n\n```\n          `true` oder `false` |\n```\n\n\\| `null`    | `null` |\n\\| `number`  | Alle von JSON unterstützten Zahlenformate |\n\\| `string`  | Du musst Zeichenfolgen nicht mit `${` und `}` umschließen. Wenn du dich jedoch dazu entscheidest, musst du die Zeichenfolge mit einfachen Anführungszeichen (`'`) umschließen. Wenn du ein einzelnes Anführungszeichen als Literal verwenden möchtest, musst du ein zusätzliches einzelnes Anführungszeichen (`''`) als Escapezeichen verwenden. Das Umschließen mit doppelten Anführungszeichen (`\"`) löst einen Fehler aus. |\n\nBeachten Sie, dass in Bedingungen falsche Werte (`false`, `0`, `-0`, `\"\"`, `''`, `null`) zu `false` gezwungen werden und wahre Werte (`true` und andere nicht falsche Werte) zu `true`gezwungen werden.\n\n### Beispiel für Literale\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## Operatoren\n\n| Operator          | BESCHREIBUNG                 |\n| ----------------- | ---------------------------- |\n| `( )`             | Logische Gruppierung         |\n| `[ ]`             | Index                        |\n| `.`               | Eigenschaftsdereferenzierung |\n| `!`               | Not                          |\n| `<`               | Kleiner als                  |\n| `<=`              | Kleiner als oder gleich      |\n| `>`               | Größer als                   |\n| `>=`              | Größer als oder gleich       |\n| `==`              | Equal                        |\n| `!=`              | Ungleich                     |\n| `&&`              | And                          |\n| <code>\\|\\|</code> | oder                         |\n\n> \\[!NOTE]\n>\n> * GitHub ignoriert die Groß-/Kleinschreibung beim Vergleichen von Zeichenfolgen.\n> *\n\n```\n          `steps.<step_id>.outputs.<output_name>` wird als Zeichenfolge ausgewertet. Du musst eine spezielle Syntax verwenden, um GitHub mitzuteilen, dass ein Ausdruck nicht als Zeichenfolge behandelt, sondern ausgewertet werden soll. Weitere Informationen finden Sie unter [AUTOTITLE](/actions/learn-github-actions/contexts#steps-context).\n```\n\n> * Für numerische Vergleiche kann die Funktion `fromJSON()` verwendet werden, um eine Zeichenfolge in eine Zahl zu konvertieren. Weitere Informationen zur Funktion `fromJSON()` finden Sie unter [fromJSON](#fromjson).\n\nGitHub vergleicht auf Gleichheit in toleranter Weise.\n\n* Wenn die Typen nicht übereinstimmen, wandelt GitHub den Typ in eine Zahl um. GitHub übergibt Datentypen anhand der folgenden Umwandlungen an eine Zahl:\n\n  | type    | Ergebnis |\n  | ------- | -------- |\n  | Null    | `0`      |\n  | Boolean |          |\n\n  ```\n          `true` gibt `1` zurück. <br /> \n          `false` gibt `0` zurück. |\n  ```\n\n  \\| String  | Aus einem zulässigem JSON-Zahlenformat geparst, andernfalls `NaN`. <br /> Hinweis: Eine leere Zeichenfolge gibt `0` zurück. |\n  \\| Array   | `NaN` |\n  \\| Object  | `NaN` |\n* Wenn `NaN` einer der Operanden eines relationalen Vergleichs (`>`, `<`, `>=`, `<=`) ist, ist das Ergebnis immer `false`. Weitere Informationen finden Sie in der [Mozilla-Dokumentation zu NaN-Werten](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).\n* GitHub ignoriert beim Vergleichen der Strings die Groß- und Kleinschreibung.\n* Objekte und Arrays werden nur dann als gleich betrachtet, wenn sie dieselbe Instanz sind.\n\n## Functions\n\nGitHub bietet integrierte Funktionen, die du in Ausdrücken verwenden kannst. Manche Funktionen verwandeln Werte an einen String, um Vergleiche durchzuführen. GitHub verwandelt Daten verschiedener Typen folgendermaßen in einen String:\n\n| type    | Ergebnis |\n| ------- | -------- |\n| Null    | `''`     |\n| Boolean |          |\n\n```\n          `'true'` oder `'false'` |\n```\n\n\\| Number  | Dezimalformat, bei großen Zahlen exponentiell |\n\\| Array   | Arrays werden nicht in einen String umgewandelt. |\n\\| Object  | Objekte werden nicht in einen String umgewandelt. |\n\n### contains\n\n`contains( search, item )`\n\nGibt `true` zurück, wenn `search``item` enthält. Wenn `search` ein Array ist, gibt diese Funktion `true` zurück, wenn es sich bei `item` um ein Arrayelement handelt. Wenn `search` einer Zeichenfolge entspricht, gibt diese Funktion `true` zurück, wenn es sich bei `item` um eine Unterzeichenfolge von `search` handelt. Bei dieser Funktion wird die Groß- und Kleinschreibung nicht berücksichtigt. Wandelt Werte in einen String um.\n\n#### Beispiel mit einem String\n\n```\n          `contains('Hello world', 'llo')` gibt `true` zurück.\n```\n\n#### Beispiel für die Verwendung eines Objektfilters\n\n```\n          `contains(github.event.issue.labels.*.name, 'bug')` gibt `true` zurück, wenn das Problem im Zusammenhang mit dem Ereignis als Fehler (bug) bezeichnet wird.\n```\n\nWeitere Informationen finden Sie unter [Objektfilter](#object-filters).\n\n#### Beispiel für den Abgleich eines Arrays aus Zeichenfolgen\n\nAnstatt `github.event_name == \"push\" || github.event_name == \"pull_request\"` zu schreiben, kannst du `contains()` mit `fromJSON()` verwenden, um zu überprüfen, ob ein Array aus Zeichenfolgen ein `item` enthält.\n\n```\n          `contains(fromJSON('[\"push\", \"pull_request\"]'), github.event_name)` gibt beispielsweise `true` zurück, wenn `github.event_name` „push“ oder „pull_request“ lautet.\n```\n\n### startsWith\n\n`startsWith( searchString, searchValue )`\n\nGibt `true` zurück, wenn `searchString` mit `searchValue` beginnt. Bei dieser Funktion wird die Groß- und Kleinschreibung nicht berücksichtigt. Wandelt Werte in einen String um.\n\n#### Beispiel für `startsWith`\n\n```\n          `startsWith('Hello world', 'He')` gibt `true` zurück.\n```\n\n### endsWith\n\n`endsWith( searchString, searchValue )`\n\nGibt `true` zurück, wenn `searchString` mit `searchValue` endet. Bei dieser Funktion wird die Groß- und Kleinschreibung nicht berücksichtigt. Wandelt Werte in einen String um.\n\n#### Beispiel für `endsWith`\n\n```\n          `endsWith('Hello world', 'ld')` gibt `true` zurück.\n```\n\n### format\n\n`format( string, replaceValue0, replaceValue1, ..., replaceValueN)`\n\nErsetzt Werte in der `string` durch die Variable `replaceValueN`. Variablen in `string` werden mit der `{N}`-Syntax angegeben, wobei es sich bei `N` um eine ganze Zahl handelt. Du musst mindestens einen `replaceValue`- und einen `string`-Wert angeben. Es gibt kein Maximum für die Anzahl der Variablen (`replaceValueN`), die du verwenden kannst. Verwende geschweifte Klammern doppelt, um eine als Escapezeichen zu verwenden.\n\n#### Beispiel für `format`\n\n```javascript\nformat('Hello {0} {1} {2}', 'Mona', 'the', 'Octocat')\n```\n\nGibt „Hello Mona the Octocat“ zurück\n\n#### Beispiel mit maskierten Klammern\n\n```javascript\nformat('{{Hello {0} {1} {2}!}}', 'Mona', 'the', 'Octocat')\n```\n\nGibt „{Hello Mona the Octocat!}“ zurück\n\n### join\n\n`join( array, optionalSeparator )`\n\nDer Wert von `array` kann ein Array oder eine Zeichenfolge sein. Alle Werte im `array` sind zu einer Zeichenfolge verkettet. Wenn du `optionalSeparator` angibst, wird der Wert in die verketteten Werte eingefügt. Andernfalls wird das Standardtrennzeichen `,` verwendet. Wandelt Werte in einen String um.\n\n#### Beispiel für `join`\n\n```\n          `join(github.event.issue.labels.*.name, ', ')` gibt möglicherweise „bug, help wanted“ (Fehler, Hilfe benötigt) zurück.\n```\n\n### toJSON\n\n`toJSON(value)`\n\nGibt eine Pretty-Print-JSON-Darstellung von `value` zurück. Diese Funktion hilft Dir bei der Fehlersuche in den Informationen, die in Kontexten enthalten sind.\n\n#### Beispiel für `toJSON`\n\n```\n          `toJSON(job)` gibt möglicherweise `{ \"status\": \"success\" }` zurück.\n```\n\n### fromJSON\n\n`fromJSON(value)`\n\nGibt ein JSON-Objekt oder einen JSON-Datentyp für `value` zurück. Sie können diese Funktion verwenden, um ein JSON-Objekt als ausgewerteten Ausdruck bereitzustellen oder einen beliebigen Datentyp zu konvertieren, der in JSON oder JavaScript dargestellt werden kann, z. B. Zeichenfolgen, boolesche Werte, Nullwerte, Arrays und Objekte.\n\n#### Beispiel für die Rückgabe eines JSON-Objekts\n\nDieser Workflow legt eine JSON-Matrix in einem Auftrag fest und übergibt sie mit einer Ausgabe und `fromJSON` an den nächsten Auftrag.\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#### Beispiel für die Rückgabe eines JSON-Datentyps\n\nDieser Workflow konvertiert Umgebungsvariablen mithilfe von `fromJSON` von einer Zeichenfolge in eine boolesche oder eine ganze Zahl.\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\nDer Workflow verwendet die Funktion `fromJSON()`, um die Umgebungsvariable `continue` aus einer Zeichenfolge in einen booleschen Wert zu konvertieren, sodass sie bestimmen kann, ob der Vorgang fortgesetzt werden soll oder nicht. Ebenso konvertiert sie die Umgebungsvariable `time` von einer Zeichenfolge in eine ganze Zahl, wobei das Timeout für den Auftrag in Minuten festgelegt wird.\n\n### hashFiles\n\n`hashFiles(path)`\n\nGibt einen einzelnen Hash für Dateien zurück, die dem `path`-Muster entsprechen. Du kannst ein einzelnes `path`-Muster oder mehrere `path`-Muster bereitstellen, die durch Kommas getrennt sind.\n`path` ist relativ zum `GITHUB_WORKSPACE`-Verzeichnis und kann nur Dateien innerhalb des `GITHUB_WORKSPACE`-Verzeichnisses enthalten. Diese Funktion berechnet einen individuellen SHA-256-Hash für jede passende Datei und verwendet diese Hashes dann zur Berechnung eines endgültigen SHA-256-Hashs für den Satz von Dateien. Wenn das `path`-Muster keinen Dateien entspricht, gibt es eine leere Zeichenfolge zurück. Weitere Informationen zu SHA-256 finden Sie unter [SHA-2](https://en.wikipedia.org/wiki/SHA-2).\n\nDu kannst Zeichen zum Musterabgleich verwenden, um Dateien mit passenden Namen auszuwählen. Der Musterabgleich für `hashFiles` entspricht dem Globmusterabgleich und unter Windows wird die Groß-/Kleinschreibung nicht beachtet. Weitere Informationen zu den unterstützten Zeichen für den Musterabgleich sind im Abschnitt [Muster](https://www.npmjs.com/package/@actions/glob#patterns) in der `@actions/glob`-Dokumentation zu finden.\n\n#### Beispiele mit einem einzelnen Muster\n\nStimmt mit allen `package-lock.json`-Dateien im Repository überein\n\n`hashFiles('**/package-lock.json')`\n\nStimmt alle `.js`-Dateien im Verzeichnis `src` auf Stammebene ab, ignoriert jedoch alle Unterverzeichnisse von `src`.\n\n`hashFiles('/src/*.js')`\n\nStimmt alle `.rb`-Dateien im Verzeichnis `lib` auf Stammebene ab, einschließlich Unterverzeichnissen von `lib`.\n\n`hashFiles('/lib/**/*.rb')`\n\n#### Beispiele mit mehreren Mustern\n\nErstellt einen Hash für alle `package-lock.json`- und `Gemfile.lock`-Dateien im Repository\n\n`hashFiles('**/package-lock.json', '**/Gemfile.lock')`\n\nErstellt einen Hash für alle `.rb`-Dateien im Verzeichnis `lib` auf Stammebene, einschließlich Unterverzeichnissen von `lib`, jedoch ohne `.rb`-Dateien im Unterverzeichnis `foo`.\n\n`hashFiles('/lib/**/*.rb', '!/lib/foo/*.rb')`\n\n### case\n\n`case( pred1, val1, pred2, val2, ..., default )`\n\nWertet Prädikate in der Reihenfolge aus und gibt den Wert zurück, der zum ersten Prädikat passt, das auf `true` ausgewertet wird. Wenn kein Prädikat übereinstimmt, wird das letzte Argument als Standardwert zurückgegeben.\n\n#### Beispiel mit einem einzelnen Prädikat\n\n```yaml\nenv:\n  MY_ENV_VAR: ${{ case(github.ref == 'refs/heads/main', 'production', 'development') }}\n```\n\nSetzt `MY_ENV_VAR` auf `production`, wenn die Referenz `refs/heads/main` ist, sonst auf `development`.\n\n#### Beispiel mit mehreren Prädikaten\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\nSets `MY_ENV_VAR` basierend auf dem Branch: `production` für `main`, `staging` für `staging`, `development` für Branches, die mit `feature/` beginnen, oder `unknown` für alle anderen Branches.\n\n## Statusprüfungsfunktionen\n\nDu kannst die nachfolgenden Statusüberprüfungsfunktionen als Ausdrücke in `if`-Bedingungen verwenden. Eine Standardstatusprüfung von `success()` wird angewendet, sofern du keine dieser Funktionen einfügst. Weitere Informationen zu `if`-Bedingungen findest du unter [Workflowsyntax für GitHub Actions](/de/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idif) und [Referenz zur Metadatensyntax](/de/actions/creating-actions/metadata-syntax-for-github-actions#runsstepsif).\n\nAußerhalb von `if`-Bedingungen kannst du `job.status` verwenden, um auf den Auftragsstatus zuzugreifen. Weitere Informationen finden Sie unter [Kontextreferenz](/de/actions/reference/contexts-reference#job-context).\n\n### success\n\nGibt `true` zurück, wenn alle vorherigen Schritte erfolgreich waren.\n\n#### Beispiel für `success`\n\n```yaml\nsteps:\n  ...\n  - name: The job has succeeded\n    if: ${{ success() }}\n```\n\n### immer\n\nBewirkt, dass der Schritt immer ausgeführt wird, und gibt selbst bei Abbruch `true` zurück Der `always`-Ausdruck wird am besten auf der Schrittebene oder für Aufgaben verwendet, die du voraussichtlich ausführst, auch wenn ein Auftrag abgebrochen wird. Du kannst beispielsweise `always` verwenden, um Protokolle zu senden, auch wenn ein Auftrag abgebrochen wird.\n\n> \\[!WARNING]\n> Vermeiden Sie die Verwendung von `always` für eine Aufgabe, bei der ein kritischer Fehler auftreten könnte, z. B. beim Abrufen von Quellen. Andernfalls bleibt der Workflow möglicherweise bis zum Auftreten eines Timeouts hängen. Wenn Sie einen Auftrag oder Schritt unabhängig von Erfolg oder Fehlschlag ausführen möchten, verwenden Sie die empfohlene Alternative: `if: ${{ !cancelled() }}`\n\n#### Beispiel für `always`\n\n```yaml\nif: ${{ always() }}\n```\n\n### cancelled\n\nGibt `true` zurück, wenn der Workflow abgebrochen wurde\n\n#### Beispiel für `cancelled`\n\n```yaml\nif: ${{ cancelled() }}\n```\n\n### failure\n\nGibt `true` zurück, wenn ein vorheriger Schritt eines Auftrags fehlschlägt. Wenn du über eine Kette abhängiger Aufträge verfügst, gibt `failure()``true` zurück, wenn ein vorheriger Auftrag fehlschlägt.\n\n#### Beispiel für `failure`\n\n```yaml\nsteps:\n  ...\n  - name: The job has failed\n    if: ${{ failure() }}\n```\n\n#### Fehler bei Bedingungen\n\nDu kannst zusätzliche Bedingungen für einen Schritt einschließen, der nach einem Fehler ausgeführt werden soll. Allerdings musst du dennoch `failure()` einfügen, um die Standardstatusüberprüfung für `success()` außer Kraft zu setzen, die automatisch auf `if`-Bedingungen angewendet wird, die keine Statusprüfungsfunktion enthalten.\n\n##### Beispiel für `failure` mit Bedingungen\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## Objektfilter\n\nMit der `*`-Syntax kannst du einen Filter anwenden und übereinstimmende Elemente in einer Sammlung auswählen.\n\nAls Beispiel sei das Objektarray namens `fruits` gegeben.\n\n```json\n[\n  { \"name\": \"apple\", \"quantity\": 1 },\n  { \"name\": \"orange\", \"quantity\": 2 },\n  { \"name\": \"pear\", \"quantity\": 1 }\n]\n```\n\nDer Filter `fruits.*.name` gibt das Array `[ \"apple\", \"orange\", \"pear\" ]` zurück.\n\nDu kannst auch die `*`-Syntax für ein Objekt verwenden. Angenommen, du verfügst über ein Objekt namens `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\nDer Filter `vegetables.*.ediblePortions` kann wie folgt ausgewertet werden:\n\n```json\n\n[\n  [\"roots\", \"stalks\"],\n  [\"hearts\", \"stems\", \"leaves\"],\n  [\"roots\", \"stems\", \"leaves\"],\n]\n```\n\nDa Objekte keine Reihenfolge beibehalten, kann die Reihenfolge der Ausgabe nicht garantiert werden."}