{"meta":{"title":"Gestapelte Pullanforderungen CLI-Befehle","intro":"Suchen Sie jeden Befehls-, Kennzeichnungs- und Beendigungscode für die gh stack Erweiterung in GitHub CLI.","product":"Pull Requests","breadcrumbs":[{"href":"/de/pull-requests","title":"Pull Requests"},{"href":"/de/pull-requests/reference","title":"Referenz"},{"href":"/de/pull-requests/reference/stacked-prs-cli-commands","title":"Gestapelte PRs CLI-Befehle"}],"documentType":"article"},"body":"# Gestapelte Pullanforderungen CLI-Befehle\n\nSuchen Sie jeden Befehls-, Kennzeichnungs- und Beendigungscode für die gh stack Erweiterung in GitHub CLI.\n\n> \\[!NOTE] Dieses Feature befindet sich in der öffentlichen Vorschau und kann geändert werden.\n\nDie `gh stack` Erweiterung zum GitHub CLI Erstellen und Verwalten von Stapeln von Pullanforderungen aus Ihrem lokalen Repository. Eine Einführung in Stapel finden Sie unter [Gestapelte Pullanforderungen](/de/pull-requests/reference/stacked-pull-requests).\n\n## Einrichtung\n\n```shell\ngh extension install github/gh-stack\n```\n\nDie Erweiterung erfordert GitHub CLI (`gh`) Version 2.0 oder höher.\n\n> \\[!NOTE]\n> Die `gh stack` Erweiterung verwendet Ihre GitHub CLI Authentifizierung. Wenn Sie sich noch nicht authentifiziert haben, führen Sie die Ausführung aus `gh auth login`.\n\n## Befehlszusammenfassung\n\n| Befehl | Purpose |\n| ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |\n| [`gh stack init`](#gh-stack-init) | Initialisieren Sie einen neuen Stapel im aktuellen Repository. |\n| [`gh stack add`](#gh-stack-add) | Fügen Sie oben im aktuellen Stapel eine neue Verzweigung hinzu. |\n| [`gh stack view`](#gh-stack-view) | Zeigen Sie den aktuellen Stapel an. |\n| [`gh stack checkout`](#gh-stack-checkout) | Sehen Sie sich einen Stapel nach Stapelnummer, Pullanforderungsnummer, Pullanforderungs-URL oder Verzweigungsname an. |\n| [`gh stack modify`](#gh-stack-modify) | Restrukturieren Sie den aktuellen Stapel interaktiv neu. |\n| [`gh stack unstack`](#gh-stack-unstack) | Entfernen Sie einen Stapel aus der lokalen Nachverfolgung, und heben Sie ihn auf GitHub. |\n| [`gh stack submit`](#gh-stack-submit) | Pushen Sie alle Verzweigungen, erstellen oder aktualisieren Sie dann Pullanforderungen und den Stapel auf GitHub. |\n| [`gh stack sync`](#gh-stack-sync) | Abrufen, Neubasis, Push- und Synchronisierungsanforderungsstatus in einem einzigen Befehl. |\n| [`gh stack rebase`](#gh-stack-rebase) | Ziehen Sie von der Fernbedienung, und führen Sie eine kaskadierende Neubasis über den Stapel aus. |\n| [`gh stack push`](#gh-stack-push) | Verschieben Sie die aktiven Verzweigungen im aktuellen Stapel an die Remoteseite. |\n| [`gh stack link`](#gh-stack-link) | Verknüpfen Sie Pullanforderungen in einen Stapel GitHub ohne lokale Nachverfolgung. |\n| [`gh stack merge`](#gh-stack-merge) | Zusammenführen einer oder mehrerer gestapelter Pullanforderungen auf einmal. |\n| [`gh stack switch`](#gh-stack-switch) | Interaktiver Wechsel zu einer anderen Verzweigung im Stapel. |\n| [`gh stack up`](#gh-stack-up) | Bewegen Sie sich nach oben in Richtung des Stapels, weg vom Trunk. |\n| [`gh stack down`](#gh-stack-down) | Bewegen Sie sich nach unten zum Ende des Stapels in Richtung des Trunks. |\n| [`gh stack top`](#gh-stack-top) | Springen Sie zum Anfang des Stapels. |\n| [`gh stack bottom`](#gh-stack-bottom) | Springen Sie zum Ende des Stapels. |\n| [`gh stack trunk`](#gh-stack-trunk) | Springen Sie zum Trunkzweig. |\n| [`gh stack alias`](#gh-stack-alias) | Erstellen Sie einen kurzen Befehlsalias, damit Sie weniger eingeben können. |\n| [`gh stack feedback`](#gh-stack-feedback) | Teilen Sie Feedback zur `gh stack` Erweiterung. |\n\n## Stapelverwaltung\n\n### `gh stack init`\n\nInitialisieren Sie einen neuen Stapel im aktuellen Repository.\n\n```shell\ngh stack init [flags] [branches...]\n```\n\nInitialisiert einen neuen Stapel lokal. Im interaktiven Modus (keine Argumente) werden die Eingabeaufforderungen für einen Verzweigungsnamen und die Verwendung der aktuellen Verzweigung als erste Ebene angeboten.\n\nWenn Sie explizite Verzweigungsnamen angeben, werden vorhandene Verzweigungen automatisch übernommen, und fehlende Verzweigungen werden erstellt. Der Trunk ist standardmäßig auf die Standardverzweigung des Repositorys festgelegt, es sei denn, Sie überschreiben ihn mit `--base`.\n\nDer Befehl wird automatisch aktiviert `git rerere` , sodass Konfliktauflösungen für alle Basiswerte gespeichert werden.\n\n| Flag | Beschreibung |\n| --------------------- | ------------------------------------------------------------------------ |\n| `-b, --base ` | Trunk branch for the stack (defaults to the repository's default branch) |\n\n**Beispiele:**\n\n```shell\n# Interactive — prompts for branch names\ngh stack init\n\n# Non-interactive — specify first branch upfront\ngh stack init feature-auth\n\n# Use a different trunk branch\ngh stack init --base develop feature-auth\n\n# Adopt or create multiple branches at once\ngh stack init feature-auth feature-api feature-ui\n```\n\n### `gh stack add`\n\nFügen Sie oben im aktuellen Stapel eine neue Verzweigung hinzu.\n\n```shell\ngh stack add [flags] [branch]\n```\n\nErstellt eine neue Verzweigung am aktuellen HEAD, fügt sie am Anfang des Stapels hinzu und checkt sie aus. Sie müssen diesen Befehl ausführen, während Sie sich am oberen Rand eines Stapels befinden. Wenn Sie keinen Verzweigungsnamen angeben, werden die Eingabeaufforderungen für eine Eingabeaufforderung angezeigt.\n\nOptional können Sie Änderungen stufen und einen Commit als Teil des `add` Flusses erstellen. Wenn Sie ohne expliziten Verzweigungsnamen angeben `-m` , wird der Verzweigungsname automatisch im Datums- und Slug-Format generiert, z `03-24-add_login`. B. .\n\n| Flag | Beschreibung |\n| ------------------------ | ------------------------------------------------------------------------------------- |\n| `-A, --all` | Alle Änderungen, einschließlich nicht nachverfolgter Dateien, stufen. Erfordert `-m`. |\n| `-u, --update` | Stufen Sie Änderungen nur auf nachverfolgte Dateien. Erfordert `-m`. |\n| `-m, --message ` | Erstellen eines Commits mit dieser Nachricht vor dem Erstellen der Verzweigung |\n\n> \\[!NOTE]\n> `-A` und `-u` schließen sich gegenseitig aus.\n\n**Beispiele:**\n\n```shell\n# Create a branch by name\ngh stack add api-routes\n\n# Prompt for a branch name interactively\ngh stack add\n\n# Stage all changes, commit, and auto-generate the branch name\ngh stack add -Am \"Add login endpoint\"\n\n# Stage only tracked files, commit, and auto-generate the branch name\ngh stack add -um \"Fix auth bug\"\n\n# Commit already-staged changes and auto-generate the branch name\ngh stack add -m \"Add user model\"\n\n# Stage all changes, commit, and use an explicit branch name\ngh stack add -Am \"Add tests\" test-layer\n\n# Stage only tracked files, commit, and use an explicit branch name\ngh stack add -um \"Update docs\" docs-layer\n```\n\n### `gh stack view`\n\nZeigen Sie den aktuellen Stapel an.\n\n```shell\ngh stack view [flags]\n```\n\nZeigt alle Verzweigungen im Stapel, deren Sortierung, Pullanforderungslinks und den letzten Commit mit einem relativen Zeitstempel an. Die Ausgabe wird über einen Pager weitergeleitet, der bzw `GIT_PAGER``PAGER`. die standardmäßig auf `less -R`.\n\n| Flag | Beschreibung |\n| ------------- | ---------------------------------------- |\n| `-s, --short` | Kompakte Ausgabe (nur Verzweigungsnamen) |\n| `--json` | Ausgabestapeldaten als JSON |\n\n**Beispiele:**\n\n```shell\ngh stack view\ngh stack view --short\ngh stack view --json\n```\n\n### `gh stack checkout`\n\nSehen Sie sich einen Stapel anhand seiner Stapelnummer, einer Pullanforderungsnummer, einer Pullanforderungs-URL oder eines Verzweigungsnamens an.\n\n```shell\ngh stack checkout [ | | | ]\n```\n\nEine nackte Zahl wird zuerst als Stapel- oder Pullanforderungsnummer interpretiert. Hierbei handelt es sich um repositorybezogene Bezeichner, die in der GitHub Benutzeroberfläche angezeigt werden. Wenn nichts mit der Zahl übereinstimmt, wird sie als Verzweigungsname versucht.\n\nWenn Sie auf einen Remotestapel verweisen, ruft der Befehl den Stapel ab GitHub, ruft die Verzweigungen ab und richtet den Stapel lokal ein. Wenn der Stapel bereits lokal vorhanden ist und übereinstimmt, wechselt der Befehl zur Verzweigung. Wenn die lokalen und Remotestapel unterschiedliche Kompositionen aufweisen, werden Sie aufgefordert, den Konflikt zu lösen.\n\nWenn Sie einen Verzweigungsnamen angeben, löst der Befehl ihn nur für lokal nachverfolgte Stapel auf.\n\nWenn Sie den Befehl ohne Argumente in einem interaktiven Terminal ausführen, öffnet es eine durchsuchbare Auswahl, die alle für Sie verfügbaren Stapel auflistet, sowohl die lokal nachverfolgten Stapel als auch die Stapel, die nur auf GitHub. Jede Zeile zeigt die Stapelnummer, deren untere und obere Verzweigung, Basiszweig, eine Statusleiste, die zusammenfasst, wie viele ihrer Pullanforderungen zusammengeführt, geöffnet, geschlossen oder noch nicht pusht werden und ob der Stapel lokal oder nur auf der Remoteseite verfügbar ist. Filtern Sie mit den Registerkarten **\"Alle**\", \" **Lokal**\" und \" **Remote** \", oder geben Sie den Suchbegriff ein `/` . Vollständig zusammengeführte Stapel werden weggelassen. Wenn Sie einen reinen Remotestapel auswählen, klonen Sie ihn lokal, bevor Sie zu ihr wechseln.\n\n**Beispiele:**\n\n```shell\n# Check out a stack by its stack number\ngh stack checkout 7\n\n# Check out a stack by pull request number\ngh stack checkout 42\n\n# Check out a stack by pull request URL\ngh stack checkout https://github.com/owner/repo/pull/42\n\n# Check out a stack by branch name (local only)\ngh stack checkout feature-auth\n\n# Interactive — pick from all available stacks (local and remote)\ngh stack checkout\n```\n\n### `gh stack modify`\n\nRestrukturieren Sie den aktuellen Stapel interaktiv neu.\n\n```shell\ngh stack modify [flags]\n```\n\nÖffnet eine interaktive Terminal-UI zur Umstrukturierung eines Stapels. Alle Änderungen werden auf der Benutzeroberfläche angeordnet und zusammen angewendet, wenn Sie STRG+S drücken. Verzweigungen von zusammengeführten Pullanforderungen können nicht geändert werden.\n\n| Flag | Beschreibung |\n| ------------ | --------------------------------------------------------------------------------------------------------------------- |\n| `--continue` | Fortfahren nach dem Auflösen von Konflikten |\n| `--abort` | Abbrechen der Änderungssitzung und Wiederherstellen des Stapels in den Zustand, bevor Sie den Befehl ausgeführt haben |\n\n**Voraussetzungen**\n\nDer Befehl überprüft diese Bedingungen vor dem Öffnen der Schnittstelle:\n\n1. Sie müssen einen aktiven Stapel lokal ausgecheckt haben.\n2. Ihre Arbeitsstruktur muss sauber sein, ohne dass keine nicht übernommenen Änderungen vorgenommen werden.\n3. Es wird keine Neubasis ausgeführt.\n4. Für die Zusammenführung wird keine Pullanforderung im Stapel in die Warteschlange gestellt.\n5. Der Commit-Verlauf muss linear sein, ohne Zusammenführungs-Commits und keine divergierten Verzweigungen.\n\n**Operations**\n\n| Operation | Schlüssel | Effect |\n| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ------ |\n| Entfernen | | |\n| x | Entfernen Sie Verzweigung und deren Commits aus dem Stapel. Die lokale Verzweigung und die zugeordnete Pullanforderung werden beibehalten. | |\n| Nach unten falten | | |\n| d | Absorb setzt sich in die untere Verzweigung hin zum Trunk ein. Der gefaltete Zweig wird aus dem Stapel entfernt. | |\n| Nach oben falten | | |\n| u | Absorb commits into the branch above, away from the trunk. Der gefaltete Zweig wird aus dem Stapel entfernt. | |\n| Unten einfügen | | |\n| i | Fügen Sie eine neue leere Verzweigung unterhalb des Cursors in Richtung des Trunks ein. | |\n| Oben einfügen | | |\n| Ich | Fügen Sie einen neuen leeren Verzweigung oberhalb des Cursors ein, weg vom Trunk. | |\n| Nach unten | | |\n| Umschalten+↓ | Ordnen Sie die Verzweigung nach unten in Richtung des Trunks an. | |\n| Nach oben | | |\n| UMSCHALT+↑ | Ordnen Sie die Verzweigung nach oben an, weg vom Trunk. | |\n| Umbenennen | | |\n| r | Benennen Sie die Verzweigung mithilfe einer Inlineaufforderung um. | |\n| Undo | | |\n| Z | Rückgängigmachen der letzten mehrstufigen Aktion. | |\n\n**Phase anwenden**\n\nWenn Sie STRG+S drücken, werden die mehrstufigen Änderungen durch Umbenennen von Verzweigungen, Einfügen neuer Verzweigungen, Faltung oder Ablegen von Verzweigungen und Ausführen einer Cascading Rebase angewendet, um einen linearen Commitverlauf mit dem gewünschten Stapelzustand zu erstellen.\n\nWenn ein Rebase-Konflikt auftritt, können Sie eine der folgenden Aktionen ausführen:\n\n* Lösen Sie die Konflikte, stufen Sie die Dateien auf, und führen Sie dann aus `gh stack modify --continue`.\n* Führen Sie die Ausführung `gh stack modify --abort` aus, um den Vorgang abzubrechen und den Stapel in den vorherigen Zustand wiederherzustellen.\n\n**Nach dem Ändern**\n\nWenn Sie bereits einen Stapel von Pullanforderungen GitHuberstellt haben, führen `gh stack submit` Sie diese aus, um die aktualisierten Verzweigungen zu übertragen und den Stapel neu zu erstellen. Der alte Stapel wird automatisch ersetzt.\n\n**Beispiele:**\n\n```shell\n# Open the interactive modify interface\ngh stack modify\n\n# Continue after resolving a conflict\ngh stack modify --continue\n\n# Abort and restore to the previous state\ngh stack modify --abort\n```\n\n### `gh stack unstack`\n\nEntfernen Sie einen Stapel aus der lokalen Nachverfolgung, und heben Sie ihn auf GitHub. Dieser Befehl ist auch als `gh stack delete`.\n\n```shell\ngh stack unstack [] [flags]\n```\n\nOhne Argument zielt der Befehl auf den aktiven Stapel ab, bei dem es sich um den Stapel handelt, der die aktuell ausgecheckte Verzweigung enthält. Er entstapelt den Stapel auf GitHub und entfernt die lokale Nachverfolgung.\n\nGeben Sie eine Stapelnummer an, den Bezeichner, der in der Stapelbenutzeroberfläche GitHubangezeigt wird, um einen bestimmten Stapel aufzuheben. Dies funktioniert von praktisch überall im Repository, unabhängig davon, ob der Stapel lokal ausgecheckt ist, da der Stapel direkt über die GitHub API gestapelt wird. Wenn der Stapel auch lokal verfügbar ist, wird auch die lokale Nachverfolgung entfernt.\n\nPullanforderungen, die zusammengeführt, zusammengeführt oder für die Zusammenführung in die Warteschlange gestellt werden, können nicht aus einem Stapel GitHub entfernt und bleiben Teil des Stapels. Wenn jede Pullanforderung entfernt wird, wird der Stapel aufgelöst, und jede lokale Nachverfolgung wird entfernt. Wenn einige Pullanforderungen gestapelt bleiben, wird der Stapel beibehalten, und die lokale Nachverfolgung bleibt unverändert. Wird verwendet `--local` , um den Remotevorgang zu überspringen und nur die lokale Nachverfolgung zu entfernen.\n\nDieser Befehl ist nützlich, wenn Sie einen Stapel neu strukturieren müssen, indem Sie eine Verzweigung entfernen, eine Verzweigung einfügen, Verzweigungen neu anordnen, Verzweigungen umbenennen oder andere große Änderungen vornehmen. Verwenden Sie `gh stack init` nach dem Aufpacken den Stapel mit der gewünschten Struktur neu. Bestehende Verzweigungen werden automatisch übernommen.\n\n| Flag | Beschreibung |\n| --------- | ------------------------------------------------------------------- |\n| `--local` | Entfernen Sie den Stapel nur lokal, und behalten Sie ihn bei GitHub |\n\n**Beispiele:**\n\n```shell\n# Unstack the current stack on GitHub and remove local tracking\ngh stack unstack\n\n# Unstack a specific stack by its number\ngh stack unstack 7\n\n# Only remove local tracking\ngh stack unstack --local\n```\n\n## Remotevorgänge\n\n### `gh stack submit`\n\nPushen Sie alle Verzweigungen, erstellen oder aktualisieren Sie dann Pullanforderungen und den Stapel auf GitHub.\n\n```shell\ngh stack submit [flags]\n```\n\nErstellt eine Pullanforderung für jede Verzweigung im Stapel, wobei Verzweigungen an die Remoteseite verschoben werden. Nach dem Erstellen von Pullanforderungen wird automatisch ein Stapel `submit` erstellt, GitHub um die Pullanforderungen zusammen zu verknüpfen. Wenn der Stapel bereits vorhanden GitHubist , z. B. aus einem vorherigen Absenden, werden dem vorhandenen Stapel neue Pullanforderungen hinzugefügt.\n\nWenn jede Pullanforderung im Stapel bereits zusammengeführt wurde, ist dieser Stapel abgeschlossen und kann nicht erweitert werden. In diesem Fall startet automatisch ein neuer Stapel, `submit` der am Trunk für Ihre nicht verbundenen Verzweigungen gestammt ist, und erstellt ihn auf GitHub, sodass der zusammengeführte Stapel unverändert bleibt.\n\nÖffnet in einem interaktiven Terminal `submit` einen Vollbild-Editor auf einem einzigen Bildschirm.\n\n* **Linker Bereich.** Jede Verzweigung ohne Pullanforderung ist standardmäßig enthalten. Deaktivieren Sie die Auswahl aller, die Sie nicht mit STRG+X übermitteln möchten. Da jede Pullanforderung auf der darunter liegenden Verzweigung aufbaut, wird durch Deaktivieren einer Verzweigung auch die darüber gestapelten abgewählt, und das erneute Einschließen einer Verzweigung schließt die darunter liegenden ab, von denen sie abhängt. Verzweigungen, die bereits über eine Pullanforderung verfügen, ob geöffnet, entwurf, in die Warteschlange gestellt oder zusammengeführt werden, werden für kontextbezogene, aber gesperrte Verzweigungen angezeigt. Bearbeiten Sie diese im Web.\n* **Rechtes Panel.** Entwerfen Sie für die fokussierte Verzweigung den Titel und die Beschreibung, und wählen Sie aus, ob die Pullanforderung zur Überprüfung oder als Entwurf geöffnet wird. Die Beschreibung wird aus der Pull-Anforderungsvorlage Ihres Repositorys oder commits mit einer Markdownvorschau und einem `$EDITOR` Escapezeichen ausgefüllt. Beim Fokussieren eines gesperrten Zweigs wird eine schreibgeschützte Karte mit einem Link zu seiner Pullanforderung angezeigt. Drücken Sie o , um sie im Browser zu öffnen.\n\nDrücken Sie STRG+S , um alle enthaltenen Pullanforderungen gleichzeitig zu übermitteln. Der Editor unterstützt sowohl Tastatur- als auch Mauseingaben. Übergeben `--auto`Oder führen Sie den Befehl in einem nicht interaktiven Terminal wie CI aus, um den Editor zu überspringen und automatisch generierte Titel zu verwenden.\n\nWenn die Verzweigungen bereits geöffnete Pullanforderungen haben, aber kein Stapel vorhanden ist GitHub, haben Sie die Möglichkeit, die Pullanforderungen mit STRG+B in einen Stapel zu verknüpfen.\n\nIm Editor werden neue Pullanforderungen standardmäßig für die Überprüfung bereit. Sie können jede Pullanforderung mit der Umschaltfläche in den Entwurf kippen. Mit `--auto`, werden neue Pullanforderungen als Entwürfe erstellt, es sei denn, Sie übergeben `--open`.\n\n| Flag | Beschreibung |\n| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `--auto` | Überspringen des Editors und Verwenden automatisch generierter Pullanforderungstitel |\n| `--open` | Erstellen sie neue Pullanforderungen als bereit für die Überprüfung anstelle von Entwürfen, und markieren Sie vorhandene Pullanforderungen als bereit für die Überprüfung. |\n| `--remote ` | Remote zum Pushen an (Standardeinstellung für die automatisch erkannte Remoteverbindung) |\n\n**Beispiele:**\n\n```shell\ngh stack submit\ngh stack submit --auto\ngh stack submit --open\n```\n\n### `gh stack sync`\n\nAbrufen, Neubasis, Push- und Synchronisierungsanforderungsstatus in einem einzigen Befehl.\n\n```shell\ngh stack sync [flags]\n```\n\nSynchronisiert den gesamten Stapel.\n\n1. **Holen.** Ruft die neuesten Änderungen von `origin`.\n2. **Abstimmung des Remotestapels.** Spiegelt den Stapel lokal wieder GitHub . Wenn pull-Anforderungen dem Stapel GitHubhinzugefügt wurden, sodass die Remote vor dem lokalen Stapel liegt, werden ihre Verzweigungen automatisch nach unten gezogen und an den lokalen Stapel angefügt. Wenn die lokalen und Remotestapel wirklich voneinander abweichen, z. B. weil Sie eine Verzweigung lokal hinzugefügt haben, während dem Stapel GitHubverschiedene Pullanforderungen hinzugefügt wurden, werden Sie aufgefordert, den Unterschied zu beheben. Siehe [\"Diverged stacks\"](#diverged-stacks). In einem nicht interaktiven Terminal bricht eine Divergenz die Synchronisierung ab, und nichts wird pushed oder aktualisiert.\n3. **Schnell-Vorwärts-Trunk.** Leitet die Trunkverzweigung schnell weiter, um mit der Remote zu übereinstimmen. Dieser Schritt wird übersprungen, wenn sich die Verzweigungen voneinander unterscheiden.\n4. **Kaskadierungs-Neubasis.** Basiert auf allen Stapelverzweigungen auf die aktualisierten Übergeordneten, aber nur dann, wenn trunk verschoben wird. Wenn ein Konflikt erkannt wird, werden alle Verzweigungen in ihrem ursprünglichen Zustand wiederhergestellt, und Sie werden empfohlen `gh stack rebase` , Konflikte interaktiv zu lösen.\n5. **Push.** Verschiebt alle Verzweigungen, wenn `--force-with-lease` eine Neubasis aufgetreten ist.\n6. **Synchronisieren von Pullanforderungen.** Synchronisiert den Abrufanforderungsstatus und GitHub meldet den Status jeder Pullanforderung.\n7. **Synchronisieren Sie den Stapel.** Verknüpft die geöffneten Pullanforderungen des Stapels in einen Stapel GitHub, erstellt das Remotestapelobjekt, falls es noch nicht vorhanden ist, oder aktualisiert es, wenn er teilweise gebildet ist. Dies geschieht nur, wenn zwei oder mehr Pullanforderungen vorhanden sind. Die Synchronisierung öffnet nie Pullanforderungen. Verwenden Sie `gh stack submit` dafür.\n8. **Pflaume.** In interaktiven Terminals werden Sie aufgefordert, lokale Verzweigungen für zusammengeführte Pullanforderungen zu löschen. Wird `--prune` verwendet, um automatisch zu schneiden.\n\nEin sauberes Remote-Ahead-Update, bei dem Pullanforderungen über Ihrem lokalen Stapel hinzugefügt werden, wird automatisch nach unten gezogen, ohne dazu aufgefordert zu werden. Daher `sync` ist die Ausführung in der Automatisierung sicher. Synchronisieren Sie nur Eingabeaufforderungen, wenn die Stapel wirklich voneinander abweichen.\n\n#### Divergierte Stapel\n\nWenn kein Stapel ein klares Präfix des anderen ist, z. B. weil Sie eine Verzweigung lokal hinzugefügt haben, während separate Pullanforderungen demselben Stapel GitHubhinzugefügt wurden, kann die Synchronisierung die beiden nicht automatisch zusammenführen. In einem interaktiven Terminal bietet es drei Auswahlmöglichkeiten.\n\n* **Verwenden Sie den Remotestapel als Wahrheitsquelle.** Ersetzt ihre lokale Stapelkomposition durch die Remote-Elemente, wobei alle fehlenden Verzweigungen abgerufen werden. Wenn Sie sich auf einer Verzweigung befinden, die der Remotestapel nicht mehr enthält, werden Sie in die nächste überlebende Verzweigung verschoben. Dies erfordert einen sauberen Arbeitszustand ohne nicht abgeschlossene Änderungen.\n* **Löschen Sie den Stapel auf GitHub.** Löscht das Stapelobjekt an GitHub und beendet die Synchronisierung. Ihre Pullanforderungen und lokale Verzweigungen bleiben unberührt, und nur der Stapel wird GitHub entfernt. Erstellen Sie den Stapel neu, `gh stack submit`wobei sie zuerst ausgeführt `gh stack modify` wird, wenn Sie die Struktur ändern möchten. Dies ist die Möglichkeit, ihren lokalen Stapel abzugleichen GitHub , da `submit`im Gegensatz dazu `sync`auch Pullanforderungen für alle Verzweigungen erstellt werden, die Sie noch nicht übermittelt haben.\n* **Abbrechen.** Bricht die Synchronisierung ab, ohne Verzweigungen zu übertragen oder Pullanforderungen zu aktualisieren.\n\nIn einem nicht interaktiven Terminal bricht eine Divergenz die Synchronisierung ab, wird erfolgreich beendet, ohne Verzweigungen zu pushen oder Pullanforderungen zu aktualisieren. Lösen Sie sie durch Auflisten und Erneutes Erstellen des Stapels auf.\n\n| Flag | Beschreibung |\n| ----------------- | -------------------------------------------------------------------------------------------------------- |\n| `--remote ` | Remote zum Abrufen von und Push an (Standardeinstellungen für die automatisch erkannte Remoteverbindung) |\n| `--prune` | Löschen lokaler Verzweigungen für zusammengeführte Pullanforderungen |\n\n**Beispiele:**\n\n```shell\ngh stack sync\n\n# Sync and automatically prune merged branches\ngh stack sync --prune\n```\n\n### `gh stack rebase`\n\nZiehen Sie von der Fernbedienung, und führen Sie eine kaskadierende Neubasis über den Stapel aus.\n\n```shell\ngh stack rebase [flags] [branch]\n```\n\nRuft die neuesten Änderungen von `origin`, und stellt dann sicher, dass jeder Verzweigung im Stapel die Spitze der vorherigen Ebene im Commit-Verlauf hat. Verzweigungen werden von oben nach oben sortiert.\n\nWenn die Pullanforderung einer Verzweigung zusammengeführt wurde, wechselt die Basis automatisch in `--onto` den Modus, um commits korrekt wieder auf dem Seriendruckziel wiederzuverwenden.\n\nWenn ein Rebase-Konflikt auftritt, wird der Vorgang angehalten und die konfliktierten Dateien mit Zeilennummern gedruckt. Lösen Sie die Konflikte auf, stellen Sie sie mit `git add`, und fahren Sie dann mit `--continue`. Wenn Sie die gesamte Basis rückgängig machen möchten, stellen Sie `--abort` alle Verzweigungen vor der Basis wieder her.\n\n| Flag | Beschreibung |\n| --------------------------------- | ----------------------------------------------------------------------------------------------------------- |\n| `--downstack` | Nur Basisverzweigungen vom Trunk bis zur aktuellen Verzweigung |\n| `--upstack` | Nur Basisverzweigungen von der aktuellen Verzweigung bis zum oberen Rand |\n| `--no-trunk` | Überspringen Sie den Trunk. Nur rebase stack branches to each other, with no fetch and no trunk rebase. |\n| `--continue` | Fortsetzen der Neubasis nach dem Auflösen von Konflikten |\n| `--abort` | Abbrechen der Basis und Wiederherstellen aller Verzweigungen in ihren Zustand vor der Neubasis |\n| `--remote ` | Remote zum Abrufen von (Standardeinstellungen für die automatisch erkannte Remoteverbindung) |\n| `--committer-date-is-author-date` | Legen Sie das Committerdatum während der Neubasis auf das Erstellungsdatum fest. Alias: `--preserve-dates`. |\n\n| Argument | Beschreibung |\n| ---------- | ------------------------------------------------------------------ |\n| `[branch]` | Zielverzweigung (Standardeinstellung für die aktuelle Verzweigung) |\n\n**Beispiele:**\n\n```shell\n# Rebase the entire stack\ngh stack rebase\n\n# Only rebase branches below the current one\ngh stack rebase --downstack\n\n# Only rebase branches above the current one\ngh stack rebase --upstack\n\n# Rebase stack branches without pulling from or rebasing with trunk\ngh stack rebase --no-trunk\n\n# After resolving a conflict\ngh stack rebase --continue\n\n# Abort rebase and restore everything\ngh stack rebase --abort\n\n# Rebase and preserve committer date as author date\ngh stack rebase --committer-date-is-author-date\n```\n\n### `gh stack push`\n\nVerschieben Sie die aktiven Verzweigungen im aktuellen Stapel an die Remoteseite.\n\n```shell\ngh stack push [flags]\n```\n\nVerschiebt alle aktiven Verzweigungen, ausgenommen zusammengeführte und in die Warteschlange eingereihte Verzweigungen in einer einzigen `git push`Verzweigung, wobei eine explizite Verzweigungsprüfung `--force-with-lease` verwendet wird. Das Update ist nicht atomar. Verzweigungen, deren Leases bestehen, können auch dann aktualisiert werden, wenn eine andere Verzweigung abgelehnt wird. Korrigieren Sie den abgelehnten Verzweigung, und führen Sie den Befehl erneut aus. Verzweigungen, die bereits aktualisiert wurden, bleiben unverändert. Mit diesem Befehl werden keine Pullanforderungen erstellt oder aktualisiert. Verwenden Sie `gh stack submit` dafür.\n\n| Flag | Beschreibung |\n| ----------------- | ---------------------------------------------------------------------------------------- |\n| `--remote ` | Remote zum Pushen an (Standardeinstellung für die automatisch erkannte Remoteverbindung) |\n\n**Beispiele:**\n\n```shell\ngh stack push\ngh stack push --remote upstream\n```\n\n### `gh stack link`\n\nVerknüpfen Sie Pullanforderungen in einen Stapel GitHub ohne lokale Nachverfolgung.\n\n```shell\ngh stack link [flags] [...]\n```\n\nErstellt oder aktualisiert einen Stapel GitHub aus Verzweigungsnamen oder Pullanforderungsnummern und URLs. Dieser Befehl erstellt oder ändert keinen lokalen Nachverfolgungsstatus. Es wurde für Personen entwickelt, die Filialen mit anderen Tools lokal verwalten, z. B. Jujutsu, Sapling oder Git-Town, und möchten einen Stapel von Pullanforderungen öffnen. Siehe [Verwenden anderer Tools mit gestapelten Pullanforderungen](/de/pull-requests/reference/use-other-tools-with-stacked-pull-requests).\n\nSie stellen Argumente in Stapelreihenfolge von unten nach oben bereit. Verzweigungsargumente werden automatisch an die Remote übertragen, bevor Pullanforderungen erstellt oder nachschlagen. Bei Verzweigungen, die bereits offene Pullanforderungen haben, werden diese Pullanforderungen verwendet. Bei Verzweigungen ohne Pullanforderungen werden neue Pullanforderungen automatisch mit der richtigen Basiszweigkette erstellt. Vorhandene Pullanforderungen, deren Basiszweig nicht mit der erwarteten Kette übereinstimmt, werden automatisch korrigiert.\n\nWenn sich die Pullanforderungen noch nicht in einem Stapel befinden, wird ein neuer Stapel erstellt. Wenn sich einige der Pullanforderungen bereits in einem Stapel befinden, wird der vorhandene Stapel aktualisiert, um die neuen Pullanforderungen einzuschließen. Vorhandene Pullanforderungen werden nie aus einem Stapel entfernt, da das Update nur additiv ist.\n\nUm einen vorhandenen Stapel zu vergrößern, ohne seine Pullanforderungen erneut aufzulisten, übergeben Sie eine Stapelnummer, die in der Stapel-UI GitHubangezeigt wird, als erstes Argument. Die übrigen Argumente werden oben in diesem Stapel angefügt. Argumente, die bereits im Stapel vorhanden sind, werden übersprungen, und Argumente, die zu einem anderen Stapel gehören, werden abgelehnt. Da Stapel- und Pullanforderungsnummern niemals überlappen, wird ein numerisches erstes Argument nur dann als Stapel behandelt, wenn es mit einem vorhandenen Stapel übereinstimmt. Andernfalls wird sie als Pullanforderung oder Verzweigung behandelt.\n\n| Flag | Beschreibung |\n| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `--base ` | Base branch for the bottom of the stack (default to the repository's default branch). Dieses Kennzeichen wird ignoriert, wenn Sie einem vorhandenen Stapel hinzufügen. |\n| `--open` | Markieren neuer und vorhandener Pullanforderungen als bereit für die Überprüfung |\n| `--remote ` | Remote zum Pushen an (Standardeinstellung für die automatisch erkannte Remoteverbindung) |\n\n**Beispiele:**\n\n```shell\n# Link branches into a stack (pushes, creates pull requests, creates stack)\ngh stack link feature-auth feature-api feature-ui\n\n# Link existing pull requests by number\ngh stack link 10 20 30\n\n# Link existing pull requests by URL\ngh stack link https://github.com/owner/repo/pull/10 https://github.com/owner/repo/pull/20\n\n# Add branches to an existing stack of pull requests\ngh stack link 42 43 feature-auth feature-ui\n\n# Append to the top of an existing stack by its stack number, with no need\n# to list the pull requests already in stack 7 again\ngh stack link 7 48 feature-ui\n\n# Use a different base branch and mark pull requests as ready for review\ngh stack link --base develop --open feat-a feat-b feat-c\n```\n\n### `gh stack merge`\n\nZusammenführen einer oder mehrerer gestapelter Pullanforderungen auf einmal.\n\n```shell\ngh stack merge [ | ]\n```\n\nFührt jede Pullanforderung im Stapel zusammen, bis zu der pull-Anforderung, die Sie auswählen, in den Basiszweig. Bei der Zusammenführung handelt es sich um einen einzigen Vorgang ohne Aktion. Wenn eine Pullanforderung nicht zusammengeführt werden kann, werden sie nicht zusammengeführt.\n\nOhne Argument verwendet der Befehl den aktiven lokalen Stapel. Stellen Sie eine Stapelnummer zum Zusammenführen eines Stapels bereit, den Sie nicht ausgecheckt haben, bei dem es sich um einen rein remote Vorgang handelt, oder stellen Sie eine Pullanforderungsnummer bereit, um direkt bis zu dieser Pullanforderung zusammenzuführen.\n\nIn einem interaktiven Terminal werden Sie aufgefordert, auszuwählen, welche Pullanforderungen zusammengeführt werden sollen, wählen Sie die Merge-Methode aus, und bestätigen Sie. In einem nicht interaktiven Terminal oder wenn Sie den gesamten Stapel oder alles bis zur von Ihnen angegebenen Pullanforderung verwenden `--yes`, wird ohne Aufforderung zusammengeführt, indem Sie die zuletzt verwendete Zusammenführungsmethode verwenden, es sei denn, Sie geben eine an.\n\nNur der grundlegende Pullanforderungsstatus wird vor dem Zusammenführen überprüft. Jede Pullanforderung muss geöffnet sein und darf kein Entwurf sein.\nGitHub wertet Verzweigungsschutz- und Repositoryregeln aus, wenn der Seriendruck ausgeführt wird, und alle Fehler werden ihnen gemeldet.\n\n> \\[!NOTE]\n> Sie können die Zusammenführungsanforderungen nicht umgehen, wenn Sie gestapelte Pullanforderungen zusammenführen.\n\nWenn der Basiszweig eine Seriendruckwarteschlange verwendet, wird der Stapel der Warteschlange hinzugefügt, anstatt direkt zusammengeführt zu werden. Die Warteschlange wählt die Zusammenführungsmethode aus, sodass die Eingabeaufforderung den Schritt der Zusammenführungsmethode überspringt, und `--merge-method` die `--squash``--rebase``--merge`Flags werden mit einer Warnung ignoriert. Die von Ihnen ausgewählten Pullanforderungen werden der Warteschlange zusammen hinzugefügt, aber sie werden zusammengeführt, während die Warteschlange sie verarbeitet, sodass sie nicht alle gleichzeitig in separaten Gruppen landen können.\n\n| Flag | Beschreibung |\n| ------------------------------- | ----------------------------------------------------------------------------------- |\n| `--merge-method ` | Zusammenführen-Methode, die verwendet werden soll: `merge`, , `squash`oder `rebase` |\n| `--merge`, `--squash``--rebase` | Kurzhands für die entsprechende Zusammenführungsmethode |\n| `-y, --yes` | Zusammenführen ohne Bestätigungsaufforderung |\n\n**Beispiele:**\n\n```shell\n# Merge the current stack, choosing pull requests interactively\ngh stack merge\n\n# Merge a stack you do not have checked out, by stack number\ngh stack merge 7\n\n# Merge everything up to and including pull request 42\ngh stack merge 42\n\n# Merge the whole current stack without prompting, squashing commits\ngh stack merge --yes --squash\n```\n\n## Navigation\n\nNavigationsbefehle verschieben Sie zwischen Verzweigungen im aktuellen Stapel, ohne sich Verzweigungsnamen merken zu müssen. Der untere Teil des Stapels ist die Verzweigung, die dem Trunk am nächsten kommt, und der Obere ist der Verzweigung, der am weitesten davon entfernt ist.\n`up` bewegt sich vom Trunk weg und `down` bewegt sich in Richtung.\n\nAlle Navigationsbefehle klammern die Grenzen des Stapels. Wenn Sie von oben nach oben oder unten von unten wechseln, wird nichts ausgeführt und eine Meldung angezeigt.\n\n### `gh stack switch`\n\nInteraktiver Wechsel zu einer anderen Verzweigung im Stapel.\n\n```shell\ngh stack switch\n```\n\nZeigt eine interaktive Auswahl mit allen Verzweigungen im aktuellen Stapel an, sortiert von oben, am weitesten vom Trunk bis unten, am nächsten am Trunk mit ihrer Positionsnummer. Wählen Sie eine Verzweigung aus, um sie auszuchecken.\n\nDieser Befehl erfordert ein interaktives Terminal.\n\n**Beispiele:**\n\n```shell\ngh stack switch\n# → Select a branch in the stack to switch to\n# 5. frontend\n# 4. api-endpoints\n# 3. auth-layer\n# 2. db-schema\n# 1. config-setup\n```\n\n### `gh stack up`\n\nBewegen Sie sich nach oben in Richtung des Stapels, weg vom Trunk.\n\n```shell\ngh stack up [n]\n```\n\nVerschiebt Verzweigungen nach oben `n` , standardmäßig auf 1. Wenn Sie sich in der Trunkverzweigung befinden, `up` wechselt sie zum ersten Stapelzweig.\n\n**Beispiele:**\n\n```shell\n# Move up one layer\ngh stack up\n\n# Move up three layers\ngh stack up 3\n```\n\n### `gh stack down`\n\nBewegen Sie sich nach unten zum Ende des Stapels in Richtung des Trunks.\n\n```shell\ngh stack down [n]\n```\n\nVerschiebt Verzweigungen nach unten `n` , standardmäßig auf 1.\n\n**Beispiele:**\n\n```shell\n# Move down one layer\ngh stack down\n\n# Move down two layers\ngh stack down 2\n```\n\n### `gh stack top`\n\nSpringen Sie zum Anfang des Stapels.\n\n```shell\ngh stack top\n```\n\nCheckt die Verzweigung am weitesten vom Trunk aus.\n\n### `gh stack bottom`\n\nSpringen Sie zum Ende des Stapels.\n\n```shell\ngh stack bottom\n```\n\nCheckt die Verzweigung aus, die dem Trunk am nächsten kommt.\n\n### `gh stack trunk`\n\nSpringen Sie zum Trunkzweig.\n\n```shell\ngh stack trunk\n```\n\nÜberprüft den Trunkzweig des aktuellen Stapels, z `main`. B. . Sie müssen sich auf einer Verzweigung befinden, die Teil eines Stapels ist.\n\n## Versorgungsdienste\n\n### `gh stack alias`\n\nErstellen Sie einen kurzen Befehlsalias, damit Sie weniger eingeben können.\n\n```shell\ngh stack alias [flags] [name]\n```\n\nInstalliert ein kleines Wrapperskript, das `~/.local/bin/` alle Argumente `gh stack`weiterleitet. Der Standardaliasname lautet `gs`, Aber Sie können einen beliebigen Namen auswählen, indem Sie ihn als Argument übergeben. Nach dem Setup können `gs push` Sie anstelle von `gh stack push`.\n\nBei Windows wird die automatische Aliaserstellung nicht unterstützt. Der Befehl druckt manuelle Anweisungen zum Erstellen einer Batchdatei oder PowerShell-Funktion.\n\n| Flag | Beschreibung |\n| ---------- | -------------------------------------- |\n| `--remove` | Entfernen eines zuvor erstellten Alias |\n\n**Beispiele:**\n\n```shell\n# Create the default alias (gs), so that \"gs push\" and \"gs view\" both work\ngh stack alias\n\n# Create a custom alias\ngh stack alias gst\n\n# Remove an alias\ngh stack alias --remove\ngh stack alias --remove gst\n```\n\n### `gh stack feedback`\n\nTeilen Sie Feedback zur `gh stack` Erweiterung.\n\n```shell\ngh stack feedback [title]\n```\n\nÖffnet eine Diskussion im [Gh-Stack-Repository](https://github.com/github/gh-stack) , damit Sie Feedback übermitteln können. Optional können Sie einen Titel für den Diskussionsbeitrag angeben.\n\n**Beispiele:**\n\n```shell\ngh stack feedback\ngh stack feedback \"Support for reordering branches\"\n```\n\n## Umgebungsvariablen\n\n| Variable | Werte | Beschreibung |\n| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------ |\n| `GH_STACK_THEME` | | |\n| `auto` (Standardwert), `light`, `dark` | Steuert die Farbpalette der interaktiven Bildschirme für `submit`, `modify`und `view`alle farbigen Befehlsausgabe. Farben passen sich automatisch an den Terminalhintergrund an. Legen Sie diese Variable fest, um die helle oder dunkle Palette zu erzwingen, wenn ein Terminal seinen Hintergrund nicht meldet, was in einigen SSH- oder `tmux` Setups auftreten kann. | |\n\n```shell\n# Force the light palette for one command\nGH_STACK_THEME=light gh stack view\n```\n\n## Exitcodes\n\n| Code | Bedeutung |\n| ----------------- | --------------------------------------------------------------------------- |\n| 0 | Success |\n| 1 | Allgemeiner Fehler |\n| 2 | Nicht in einem Stapel oder Stapel nicht gefunden |\n| 3 | Rebase-Konflikt |\n| 4 | |\n| GitHub API-Fehler | |\n| 5 | Ungültige Argumente oder Kennzeichnungen |\n| 6 | Mehrdeutigkeit erforderlich, da die Verzweigung zu mehreren Stapeln gehört |\n| 7 | Rebase wird bereits ausgeführt |\n| 8 | Stapel ist durch einen anderen Prozess gesperrt. |\n| 9 | Gestapelte Pullanforderungen sind für dieses Repository nicht aktiviert. |\n| 10 | Die Sitzung wurde unterbrochen, und die Wiederherstellung ist erforderlich. |\n\n## Weiterführende Lektüre\n\n* [Gestapelte Pullanforderungen](/de/pull-requests/reference/stacked-pull-requests)\n* [Erstellen von gestapelten Pullanforderungen](/de/pull-requests/how-tos/create-pull-requests/creating-stacked-pull-requests)\n* [Verwalten von gestapelten Pullanforderungen](/de/pull-requests/how-tos/create-pull-requests/managing-stacked-pull-requests)\n* [Problembehandlung für gestapelte Pullanforderungen](/de/pull-requests/how-tos/merge-and-close-pull-requests/troubleshooting-stacked-pull-requests)"}