# Auswerten von Ausdrücken in Workflows und Aktionen Hier finden Sie Informationen zu Ausdrücken in GitHub Actions. ## Literale In Ausdrücken kannst du die Datentypen `boolean`, `null`, `number` oder `string` verwenden. | Datentyp | Literalwert | | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `boolean` | | | `true` oder `false` | | | `null` | `null` | | `number` | Alle von JSON unterstützten Zahlenformate | | `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. | Beachten 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. ### Beispiel für Literale ```yaml env: myNull: ${{ null }} myBoolean: ${{ false }} myIntegerNumber: ${{ 711 }} myFloatNumber: ${{ -9.2 }} myHexNumber: ${{ 0xff }} myExponentialNumber: ${{ -2.99e-2 }} myString: Mona the Octocat myStringInBraces: ${{ 'It''s open source!' }} ``` ## Operatoren | Operator | BESCHREIBUNG | | ----------------- | ---------------------------- | | `( )` | Logische Gruppierung | | `[ ]` | Index | | `.` | Eigenschaftsdereferenzierung | | `!` | Not | | `<` | Kleiner als | | `<=` | Kleiner als oder gleich | | `>` | Größer als | | `>=` | Größer als oder gleich | | `==` | Equal | | `!=` | Ungleich | | `&&` | And | | \|\| | oder | > \[!NOTE] > \* > GitHub ignoriert die Groß-/Kleinschreibung beim Vergleichen von Zeichenfolgen. > \* > `steps..outputs.` 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 [Kontextreferenz](/de/actions/reference/workflows-and-actions/contexts#steps-context). > > * 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). GitHub führt lose Gleichheitsvergleiche durch. * Wenn die Typen nicht übereinstimmen, konvertiert GitHub den Typ in eine Zahl. GitHub Wandelt Datentypen mithilfe dieser Konvertierungen in eine Zahl um: | type | Ergebnis | | ------- | -------- | | Null | `0` | | Boolean | | `true` gibt `1` zurück.
`false` gibt `0` zurück. | \| String | Aus einem zulässigem JSON-Zahlenformat geparst, andernfalls `NaN`.
Hinweis: Eine leere Zeichenfolge gibt `0` zurück. | \| Array | `NaN` | \| Object | `NaN` | * 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). * GitHub ignoriert die Groß-/Kleinschreibung beim Vergleichen von Zeichenfolgen. * Objekte und Arrays werden nur dann als gleich betrachtet, wenn sie dieselbe Instanz sind. ## Functions GitHub bietet eine Reihe integrierter Funktionen, die Sie in Ausdrücken verwenden können. Manche Funktionen verwandeln Werte an einen String, um Vergleiche durchzuführen. GitHub wandelt Datentypen mithilfe dieser Konvertierungen in einen String um: | type | Ergebnis | | ----------------------- | ------------------------------------------------- | | Null | `''` | | Boolean | | | `'true'` oder `'false'` | | | Number | Dezimalformat, bei großen Zahlen exponentiell | | Array | Arrays werden nicht in einen String umgewandelt. | | Object | Objekte werden nicht in einen String umgewandelt. | ### contains `contains( search, item )` Gibt `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. #### Beispiel mit einem String `contains('Hello world', 'llo')` gibt `true` zurück. #### Beispiel für die Verwendung eines Objektfilters `contains(github.event.issue.labels.*.name, 'bug')` gibt `true` zurück, wenn das Problem im Zusammenhang mit dem Ereignis als Fehler (bug) bezeichnet wird. Weitere Informationen finden Sie unter [Objektfilter](#object-filters). #### Beispiel für den Abgleich eines Arrays aus Zeichenfolgen Anstatt `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. `contains(fromJSON('["push", "pull_request"]'), github.event_name)` gibt beispielsweise `true` zurück, wenn `github.event_name` „push“ oder „pull\_request“ lautet. ### startsWith `startsWith( searchString, searchValue )` Gibt `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. #### Beispiel für `startsWith` `startsWith('Hello world', 'He')` gibt `true` zurück. ### endsWith `endsWith( searchString, searchValue )` Gibt `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. #### Beispiel für `endsWith` `endsWith('Hello world', 'ld')` gibt `true` zurück. ### format `format( string, replaceValue0, replaceValue1, ..., replaceValueN)` Ersetzt 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. #### Beispiel für `format` ```javascript format('Hello {0} {1} {2}', 'Mona', 'the', 'Octocat') ``` Gibt „Hello Mona the Octocat“ zurück #### Beispiel mit maskierten Klammern ```javascript format('{{Hello {0} {1} {2}!}}', 'Mona', 'the', 'Octocat') ``` Gibt „{Hello Mona the Octocat!}“ zurück ### join `join( array, optionalSeparator )` Der 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. #### Beispiel für `join` `join(github.event.issue.labels.*.name, ', ')` gibt möglicherweise „bug, help wanted“ (Fehler, Hilfe benötigt) zurück. ### toJSON `toJSON(value)` Gibt eine Pretty-Print-JSON-Darstellung von `value` zurück. Diese Funktion hilft Dir bei der Fehlersuche in den Informationen, die in Kontexten enthalten sind. #### Beispiel für `toJSON` `toJSON(job)` gibt möglicherweise `{ "status": "success" }` zurück. ### fromJSON `fromJSON(value)` Gibt 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. #### Beispiel für die Rückgabe eines JSON-Objekts Dieser Workflow legt eine JSON-Matrix in einem Auftrag fest und übergibt sie mit einer Ausgabe und `fromJSON` an den nächsten Auftrag. ```yaml copy name: build on: push jobs: job1: runs-on: ubuntu-latest outputs: matrix: ${{ steps.set-matrix.outputs.matrix }} steps: - id: set-matrix run: echo "matrix={\"include\":[{\"project\":\"foo\",\"config\":\"Debug\"},{\"project\":\"bar\",\"config\":\"Release\"}]}" >> $GITHUB_OUTPUT job2: needs: job1 runs-on: ubuntu-latest strategy: matrix: ${{ fromJSON(needs.job1.outputs.matrix) }} steps: - run: echo "Matrix - Project ${{ matrix.project }}, Config ${{ matrix.config }}" ``` #### Beispiel für die Rückgabe eines JSON-Datentyps Dieser Workflow konvertiert Umgebungsvariablen mithilfe von `fromJSON` von einer Zeichenfolge in eine boolesche oder eine ganze Zahl. ```yaml copy name: print on: push env: continue: true time: 3 jobs: job1: runs-on: ubuntu-latest steps: - continue-on-error: ${{ fromJSON(env.continue) }} timeout-minutes: ${{ fromJSON(env.time) }} run: echo ... ``` Der 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. ### hashFiles `hashFiles(path)` Gibt 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. `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). Du 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. #### Beispiele mit einem einzelnen Muster Stimmt mit allen `package-lock.json`-Dateien im Repository überein `hashFiles('**/package-lock.json')` Stimmt alle `.js`-Dateien im Verzeichnis `src` auf Stammebene ab, ignoriert jedoch alle Unterverzeichnisse von `src`. `hashFiles('/src/*.js')` Stimmt alle `.rb`-Dateien im Verzeichnis `lib` auf Stammebene ab, einschließlich Unterverzeichnissen von `lib`. `hashFiles('/lib/**/*.rb')` #### Beispiele mit mehreren Mustern Erstellt einen Hash für alle `package-lock.json`- und `Gemfile.lock`-Dateien im Repository `hashFiles('**/package-lock.json', '**/Gemfile.lock')` Erstellt einen Hash für alle `.rb`-Dateien im Verzeichnis `lib` auf Stammebene, einschließlich Unterverzeichnissen von `lib`, jedoch ohne `.rb`-Dateien im Unterverzeichnis `foo`. `hashFiles('/lib/**/*.rb', '!/lib/foo/*.rb')` ### case `case( pred1, val1, pred2, val2, ..., default )` Wertet 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. #### Beispiel mit einem einzelnen Prädikat ```yaml env: MY_ENV_VAR: ${{ case(github.ref == 'refs/heads/main', 'production', 'development') }} ``` Setzt `MY_ENV_VAR` auf `production`, wenn die Referenz `refs/heads/main` ist, sonst auf `development`. #### Beispiel mit mehreren Prädikaten ```yaml env: MY_ENV_VAR: |- ${{ case( github.ref == 'refs/heads/main', 'production', github.ref == 'refs/heads/staging', 'staging', startsWith(github.ref, 'refs/heads/feature/'), 'development', 'unknown' ) }} ``` Sets `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. ## Statusprüfungsfunktionen Du 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/reference/workflows-and-actions/workflow-syntax#jobsjob_idif) und [Referenz zur Metadatensyntax](/de/actions/reference/workflows-and-actions/metadata-syntax#runsstepsif). Außerhalb von `if`-Bedingungen kannst du `job.status` verwenden, um auf den Auftragsstatus zuzugreifen. Weitere Informationen finden Sie unter [Kontextreferenz](/de/actions/reference/workflows-and-actions/contexts#job-context). ### success Gibt `true` zurück, wenn alle vorherigen Schritte erfolgreich waren. #### Beispiel für `success` ```yaml steps: ... - name: The job has succeeded if: ${{ success() }} ``` ### immer Bewirkt, 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. > \[!WARNING] > 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() }}` #### Beispiel für `always` ```yaml if: ${{ always() }} ``` ### cancelled Gibt `true` zurück, wenn der Workflow abgebrochen wurde #### Beispiel für `cancelled` ```yaml if: ${{ cancelled() }} ``` ### failure Gibt `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. #### Beispiel für `failure` ```yaml steps: ... - name: The job has failed if: ${{ failure() }} ``` #### Fehler bei Bedingungen Du 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. ##### Beispiel für `failure` mit Bedingungen ```yaml steps: ... - name: Failing step id: demo run: exit 1 - name: The demo step has failed if: ${{ failure() && steps.demo.conclusion == 'failure' }} ``` ## Objektfilter Mit der `*`-Syntax kannst du einen Filter anwenden und übereinstimmende Elemente in einer Sammlung auswählen. Als Beispiel sei das Objektarray namens `fruits` gegeben. ```json [ { "name": "apple", "quantity": 1 }, { "name": "orange", "quantity": 2 }, { "name": "pear", "quantity": 1 } ] ``` Der Filter `fruits.*.name` gibt das Array `[ "apple", "orange", "pear" ]` zurück. Du kannst auch die `*`-Syntax für ein Objekt verwenden. Angenommen, du verfügst über ein Objekt namens `vegetables`. ```json { "scallions": { "colors": ["green", "white", "red"], "ediblePortions": ["roots", "stalks"], }, "beets": { "colors": ["purple", "red", "gold", "white", "pink"], "ediblePortions": ["roots", "stems", "leaves"], }, "artichokes": { "colors": ["green", "purple", "red", "black"], "ediblePortions": ["hearts", "stems", "leaves"], }, } ``` Der Filter `vegetables.*.ediblePortions` kann wie folgt ausgewertet werden: ```json [ ["roots", "stalks"], ["hearts", "stems", "leaves"], ["roots", "stems", "leaves"], ] ``` Da Objekte keine Reihenfolge beibehalten, kann die Reihenfolge der Ausgabe nicht garantiert werden.