Wie benenne und rufe ich einen Vorrat in Git nach Namen ab?

Ich hatte immer den Eindruck, dass man einem Versteck einen Namen geben könnte git stash save stashname, den man später anwenden könnte git stash apply stashname. Aber es scheint, dass in diesem Fall alles, was passiert, stashnameals Stash-Beschreibung verwendet wird.

Gibt es keine Möglichkeit, einen Vorrat zu benennen? Wenn nicht, was würden Sie empfehlen, um eine gleichwertige Funktionalität zu erreichen? Im Wesentlichen habe ich einen kleinen Vorrat, den ich regelmäßig anwenden möchte, aber ich möchte nicht immer nach git stash listder tatsächlichen Vorratsnummer suchen müssen.

Das ist wie man es macht:

git stash save "my_stash"

Wo "my_stash"ist der Versteckname?

Einige weitere nützliche Dinge zu wissen: Alle Verstecke werden in einem Stapel gespeichert. Art:

git stash list

Dadurch werden alle Ihre Verstecke aufgelistet.

Geben Sie Folgendes ein, um einen Stash anzuwenden und aus dem Stash-Stack zu entfernen:

git stash pop stash@{n}

Geben Sie Folgendes ein, um einen Stash anzuwenden und im Stack-Stack zu behalten:

git stash apply stash@{n}

Wo nist der Index der versteckten Änderung?

git stash saveist ab 2.15.x / 2.16 veraltet , stattdessen können Sie verwendengit stash push -m "message"

Sie können es so verwenden:

git stash push -m "message"

Dabei ist "Nachricht" Ihre Notiz für diesen Vorrat.

Um den Vorrat abzurufen, können Sie Folgendes verwenden : git stash list. Dies gibt eine Liste wie diese aus, zum Beispiel:

stash@{0}: On develop: perf-spike
stash@{1}: On develop: node v10

Dann geben Sie einfach applyFolgendes an stash@{index}:

git stash apply stash@{1}

Referenzen git stash manpage

Sie können einen Vorrat in einen Zweig verwandeln, wenn Sie der Meinung sind, dass dies wichtig genug ist:

git stash branch <branchname> [<stash>]

von der Manpage:

Dadurch wird ein neuer Zweig mit dem Namen erstellt und ausgecheckt, <branchname>der mit dem Commit beginnt, bei dem der <stash>ursprünglich erstellt wurde. Er wendet die aufgezeichneten Änderungen <stash>auf den neuen Arbeitsbaum und Index an und löscht dann den, <stash>wenn dies erfolgreich abgeschlossen wurde. Wenn nein <stash>angegeben ist, wird die neueste angewendet.

Dies ist nützlich, wenn sich der Zweig, auf dem Sie ausgeführt haben, so git stash savestark geändert hat, dass die Anwendung von git stash aufgrund von Konflikten fehlschlägt. Da der Stash zusätzlich zu dem Commit angewendet wird, der zum Zeitpunkt der Ausführung von git stash HEAD war, wird der ursprünglich gestaute Status ohne Konflikte wiederhergestellt.

Sie können diesen neuen Zweig später an einen anderen Ort zurückversetzen, der von Ihrem Standort abhängt, als Sie ihn versteckt haben.

Wenn Sie nur nach einer einfachen Möglichkeit suchen, einige oder alle Ihrer aktuellen Änderungen an der Arbeitskopie zu speichern und sie später nach Belieben erneut anzuwenden, ziehen Sie eine Patch-Datei in Betracht:

# save your working copy changes
git diff > some.patch

# re-apply it later
git apply some.patch

Hin und wieder frage ich mich, ob ich dafür Verstecke verwenden sollte und dann sehe ich Dinge wie den Wahnsinn oben und bin zufrieden mit dem, was ich tue :)

Stashes sind keine dauerhaften Dinge, wie Sie sie wollen. Sie sollten wahrscheinlich besser mit Tags für Commits bedient werden. Konstruieren Sie das Ding, das Sie verstauen möchten. Machen Sie ein Commit daraus. Erstellen Sie ein Tag für dieses Commit. Dann rollen Sie Ihren Zweig zurück zu HEAD^. Wenn Sie diesen Stash erneut anwenden möchten, können Sie ihn verwenden git cherry-pick -n tagname( -nis --no-commit).

Verwenden Sie git stash push -m aNameForYourStash, um es zu speichern. Verwenden Sie dann git stash list, um den Index des Stashs zu lernen, den Sie anwenden möchten. Verwenden Sie dann, git stash pop --index 0um den Stash zu öffnen und anzuwenden.

Hinweis: Ich verwende Git Version 2.21.0.windows.1

Ich habe diese beiden Funktionen in meiner .zshrcDatei:

function gitstash() {
    git stash push -m "zsh_stash_name_$1"
}

function gitstashapply() {
    git stash apply $(git stash list | grep "zsh_stash_name_$1" | cut -d: -f1)
}

Verwenden Sie sie auf diese Weise:

gitstash nice

gitstashapply nice

Was ist damit?

git stash save stashname
git stash apply stash^{/stashname}

Alias

sapply = "!f() { git stash apply \"$(git stash list | awk -F: --posix -vpat=\"$*\" \"$ 0 ~ pat {print $ 1; exit}\")\"; }; f"

Verwendungszweck

git sapply "<regex>"

• kompatibel mit Git für Windows

Bearbeiten: Ich habe mich an meine ursprüngliche Lösung gehalten, aber ich sehe, warum die Mehrheit die Version von Etan Reisner (oben) bevorzugen würde. Also nur fürs Protokoll:

sapply = "!f() { git stash apply \"$(git stash list | grep -E \"$*\" | awk \"{ print $ 1; }\" | sed -n \"s/://;1p\")\"; }; f"

Es ist bedauerlich, dass git stash apply stash^{/<regex>}das nicht funktioniert (es durchsucht die Stash-Liste nicht wirklich, siehe die Kommentare unter der akzeptierten Antwort ).

Hier sind Drop-In-Ersetzungen, die nach git stash listRegex suchen , um die erste (neueste) zu finden stash@{<n>}und diese dann an folgende Adresse zu übergeben git stash <command>:

# standalone (replace <stash_name> with your regex)
(n=$(git stash list --max-count=1 --grep=<stash_name> | cut -f1 -d":") ; if [[ -n "$n" ]] ; then git stash show "$n" ; else echo "Error: No stash matches" ; return 1 ; fi)
(n=$(git stash list --max-count=1 --grep=<stash_name> | cut -f1 -d":") ; if [[ -n "$n" ]] ; then git stash apply "$n" ; else echo "Error: No stash matches" ; return 1 ; fi)

# ~/.gitconfig
[alias]
  sshow = "!f() { n=$(git stash list --max-count=1 --grep=$1 | cut -f1 -d":") ; if [[ -n "$n" ]] ; then git stash show "$n" ; else echo "Error: No stash matches $1" ; return 1 ; fi }; f"
  sapply = "!f() { n=$(git stash list --max-count=1 --grep=$1 | cut -f1 -d":") ; if [[ -n "$n" ]] ; then git stash apply "$n" ; else echo "Error: No stash matches $1" ; return 1 ; fi }; f"

# usage:

$ git sshow my_stash
 myfile.txt | 1 +
 1 file changed, 1 insertion(+)

$ git sapply my_stash
On branch master
Your branch is up to date with 'origin/master'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   myfile.txt

no changes added to commit (use "git add" and/or "git commit -a")

Beachten Sie, dass die richtigen Ergebniscodes zurückgegeben werden, damit Sie diese Befehle in anderen Skripten verwenden können. Dies kann überprüft werden, nachdem Befehle ausgeführt wurden mit:

echo $?

Seien Sie nur vorsichtig bei Exploits mit variabler Erweiterung, da ich mir über den --grep=$1Teil nicht sicher war . Es sollte vielleicht sein, --grep="$1"aber ich bin mir nicht sicher, ob dies die Regex-Begrenzer stören würde (ich bin offen für Vorschläge).

Diese Antwort hat Klemen Slavič viel zu verdanken. Ich hätte die akzeptierte Antwort nur kommentiert, aber ich habe noch nicht genug Repräsentanten :(

Sie können auch einen Git-Alias ​​hinzufügen, um den Stash-Ref zu finden und ihn in anderen Aliasen zum Anzeigen, Anwenden, Löschen usw. zu verwenden.

[alias]
    sgrep = "!f() { ref=$(git --no-pager stash list | grep "$1" | cut -d: -f1 | head -n1); echo ${ref:-<no_match>}; }; f"
    sshow = "!f() { git stash show $(git sgrep "$1") -p; }; f"
    sapply = "!f() { git stash apply $(git sgrep "$1"); }; f"
    sdrop = "!f() { git stash drop $(git sgrep "$1"); }; f"

Beachten Sie, dass der Grund für das ref=$( ... ); echo ${ref:-<no_match>};Muster darin besteht, dass keine leere Zeichenfolge zurückgegeben wird, die dazu führen würde, dass sshow, sapply und sdrop auf den neuesten Stash abzielen, anstatt wie erwartet zu scheitern.

Alias Dies ist möglicherweise eine direktere Syntax für Unix-ähnliche Systeme, ohne dass eine Funktion gekapselt werden muss. Fügen Sie ~ / .gitconfig unter [alias] Folgendes hinzu

sshow = !sh -c 'git stash show stash^{/$*} -p' -
sapply = !sh -c 'git stash apply stash^{/$*}' -
ssave = !sh -c 'git stash save "${1}"' -

Verbrauch: sapply regex

Beispiel: git sshow MySecretStash

Der Bindestrich am Ende lautet "Eingabe von Standardeingabe übernehmen".

Verwenden Sie ein kleines Bash-Skript, um die Nummer des Stashs zu ermitteln. Nennen Sie es "gitapply":

NAME="$1"
if [[ -z "$NAME" ]]; then echo "usage: gitapply [name]"; exit; fi
git stash apply $(git stash list | grep "$NAME" | cut -d: -f1)

Verwendungszweck:

gitapply foo

... wobei foo eine Teilzeichenfolge des Namens des gewünschten Stashs ist.

Verwenden Sie git stash save NAMEzu speichern.

Dann ... können Sie mit diesem Skript auswählen, welche Anwendung angewendet werden soll (oder Pop):

#!/usr/bin/env ruby
#git-stash-pick by Dan Rosenstark

# can take a command, default is apply
command = ARGV[0]
command = "apply" if !command
ARGV.clear

stashes = []
stashNames = []
`git stash list`.split("\n").each_with_index { |line, index|
    lineSplit = line.split(": ");
    puts "#{index+1}. #{lineSplit[2]}"
    stashes[index] = lineSplit[0]
    stashNames[index] = lineSplit[2]
}
print "Choose Stash or ENTER to exit: "
input = gets.chomp
if input.to_i.to_s == input
    realIndex = input.to_i - 1
    puts "\n\nDoing #{command} to #{stashNames[realIndex]}\n\n"
    puts `git stash #{command} #{stashes[realIndex]}`
end

Ich mag es, die Namen der Verstecke zu sehen und zu wählen. Außerdem benutze ich Zshell und wusste ehrlich gesagt nicht, wie ich einige der oben genannten Bash-Aliase verwenden soll;)

Hinweis: Wie Kevin sagt, sollten Sie stattdessen Tags und Cherry-Picks verwenden.

Dies ist eine Möglichkeit, dies mit PowerShell zu erreichen:

<#
.SYNOPSIS
Restores (applies) a previously saved stash based on full or partial stash name.

.DESCRIPTION
Restores (applies) a previously saved stash based on full or partial stash name and then optionally drops the stash. Can be used regardless of whether "git stash save" was done or just "git stash". If no stash matches a message is given. If multiple stashes match a message is given along with matching stash info.

.PARAMETER message
A full or partial stash message name (see right side output of "git stash list"). Can also be "@stash{N}" where N is 0 based stash index.

.PARAMETER drop
If -drop is specified, the matching stash is dropped after being applied.

.EXAMPLE
Restore-Stash "Readme change"
Apply-Stash MyStashName
Apply-Stash MyStashName -drop
Apply-Stash "stash@{0}"
#>
function Restore-Stash  {
    [CmdletBinding()]
    [Alias("Apply-Stash")]
    PARAM (
        [Parameter(Mandatory=$true)] $message,         
        [switch]$drop
    )

    $stashId = $null

    if ($message -match "stash@{") {
        $stashId = $message
    }

    if (!$stashId) {
        $matches = git stash list | Where-Object { $_ -match $message }

        if (!$matches) {
            Write-Warning "No stashes found with message matching '$message' - check git stash list"
            return
        }

        if ($matches.Count -gt 1) {
            Write-Warning "Found $($matches.Count) matches for '$message'. Refine message or pass 'stash{@N}' to this function or git stash apply"
            return $matches
        }

        $parts = $matches -split ':'
        $stashId = $parts[0]
    }

    git stash apply ''$stashId''

    if ($drop) {
        git stash drop ''$stashId''
    }
}

Weitere Details hier

in meiner Fischschale

function gsap
  git stash list | grep ": $argv" | tr -dc '0-9' | xargs git stash apply
end

verwenden

gsap name_of_stash

Spät zur Party hier, aber wenn Sie VSCode verwenden, können Sie dies schnell tun, indem Sie die Befehlspalette (STRG / CMD + UMSCHALT + P) öffnen und "Pop Stash" eingeben. Sie können Ihren Stash nach Namen abrufen ohne die git CLI verwenden zu müssen

git stash applyfunktioniert auch mit anderen refs als stash@{0}. Sie können also normale Tags verwenden , um einen dauerhaften Namen zu erhalten. Dies hat auch den Vorteil, dass Sie nicht versehentlich git stash dropoder git stash popes.

So können Sie einen Alias pstash(auch als "persistenter Stash" bezeichnet) wie folgt definieren :

git config --global alias.pstash '!f(){ git stash && git tag "$1" stash && git stash drop; }; f'

Jetzt können Sie einen getaggten Stash erstellen:

git pstash x-important-stuff

und showund applyes wieder wie gewohnt:

git stash show x-important-stuff
git stash apply x-important-stuff

Ich glaube nicht, dass es eine Möglichkeit gibt, einen Vorrat mit seinem Namen zu knallen.

Ich habe eine Bash-Funktion erstellt, die dies tut.

#!/bin/bash

function gstashpop {
  IFS="
"
  [ -z "$1" ] && { echo "provide a stash name"; return; }
  index=$(git stash list | grep -e ': '"$1"'$' | cut -f1 -d:)
  [ "" == "$index" ] && { echo "stash name $1 not found"; return; }
  git stash apply "$index"
}

Anwendungsbeispiel:

[~/code/site] on master*
$ git stash push -m"here the stash name"
Saved working directory and index state On master: here the stash name

[~/code/site] on master
$ git stash list
stash@{0}: On master: here the stash name

[~/code/site] on master
$ gstashpop "here the stash name"

Ich hoffe, es hilft!

Für alles außer der Stash-Erstellung würde ich eine andere Lösung vorschlagen, indem ich fzf als Abhängigkeit einführe . Ich empfehle, sich 5 Minuten Zeit zu nehmen und sich damit vertraut zu machen, da es insgesamt ein großer Produktivitätssteigerer ist.

Wie auch immer, ein verwandter Auszug aus ihrer Beispielseite mit Stash-Suche. Es ist sehr einfach, das Scriptlet zu ändern, um zusätzliche Funktionen hinzuzufügen (z. B. Stash-Anwendung oder Löschen):

fstash() {
    local out q k sha
    while out=$(
            git stash list --pretty="%C(yellow)%h %>(14)%Cgreen%cr %C(blue)%gs" |
            fzf --ansi --no-sort --query="$q" --print-query \
                --expect=ctrl-d,ctrl-b); do
        mapfile -t out <<< "$out"
        q="${out[0]}"
        k="${out[1]}"
        sha="${out[-1]}"
        sha="${sha%% *}"
        [[ -z "$sha" ]] && continue
        if [[ "$k" == 'ctrl-d' ]]; then
            git diff $sha
        elif [[ "$k" == 'ctrl-b' ]]; then
            git stash branch "stash-$sha" $sha
            break;
        else
            git stash show -p $sha
        fi
    done
}

Ich bin mir nicht sicher, warum dieses Thema so bestürzt ist. Ich kann einen Stash sowohl mit einem Push als auch mit dem veralteten Speichern benennen, und ich kann einen regulären Ausdruck verwenden, um ihn mit einem Apply zurückzuziehen:

Git-Stash-Methode, um einen Namen zum Anwenden zu verwenden

$ git stash push -m "john-hancock"

$ git stash apply stash^{/john-hancock}

Wie bereits erwähnt, ist der Befehl save veraltet, funktioniert jedoch weiterhin. Sie können ihn daher auf älteren Systemen verwenden, auf denen Sie sie nicht mit einem Push-Aufruf aktualisieren können. Im Gegensatz zum Push-Befehl ist der Schalter -m beim Speichern nicht erforderlich.

// save is deprecated but still functional  
$ git stash save john-hancock

Probleme mit einem Pop & Drop

Ich glaube nicht, dass es mit einem Pop funktioniert, aber ich denke, das liegt daran, dass der Pop nach dem Anwenden einen Drop ausführt und der Regex nicht Drop-freundlich ist. Das ist aber nur eine Vermutung. Ich habe es nicht getestet.

Dies ist Git 2.2 und Windows 10.

Visueller Beweis

Hier ist ein wunderschönes animiertes GIF, das den Prozess demonstriert.

Reihenfolge der Ereignisse

Das GIF läuft schnell, aber wenn Sie schauen, ist der Prozess der folgende:

1. Der Befehl ls zeigt 4 Dateien im Verzeichnis an
2. touch example.html fügt eine fünfte Datei hinzu
3. git stash push -m "john-hancock" -a (Das -a enthält nicht verfolgte Dateien)
4. Der Befehl ls zeigt 4 Dateien nach dem Stash an, was bedeutet, dass der Stash und der implizite Hard-Reset funktioniert haben
5. git stash apply stash ^ {/ john-hancock} läuft
6. Der Befehl ls listet 5 Dateien auf und zeigt, dass die Datei example.html zurückgebracht wurde, was bedeutet, dass der Befehl git stash apply funktioniert hat.

Macht das überhaupt Sinn?

Um ehrlich zu sein, bin ich mir nicht sicher, welchen Nutzen dieser Ansatz hat. Es ist wertvoll, dem Stash einen Namen zu geben, aber nicht den Abruf. Vielleicht wäre es hilfreich, den Prozess zu skripten, aber es ist immer noch viel einfacher, nur einen Vorrat mit Namen zu platzieren.

$ git stash pop 3
$ git stash apply 3

Das sieht für mich viel einfacher aus als der reguläre Ausdruck.