Git'te bir zulayı nasıl adlandırır ve alırsınız?

Ben her zaman bir zulası yaparak bir isim verebileceğine dair izlenim altındaydım, git stash save stashnamebunu daha sonra yaparak uygulayabilirsin git stash apply stashname. Ama öyle görünüyor ki, bu durumda olan her şey, stashnamesaklı açıklama olarak kullanılacak.

Zulası isimlendirmenin bir yolu yok mu? Değilse, eşdeğer işlevsellik elde etmek için ne önerirsiniz? Esasen, periyodik olarak uygulamak istediğim küçük bir zulası var, ama her zaman git stash listasıl saklanma numarasının ne olduğunu avlamak istemiyorum .

Bunu şu şekilde yapabilirsiniz:

git stash save "my_stash"

"my_stash"Stash adı nerede .

Bilmeniz gereken bazı yararlı şeyler: Tüm zulalar bir yığın halinde saklanır. Tür:

git stash list

Bu, tüm depolamaklarınızı listeleyecektir.

Bir saklamak uygulamak ve saklamak yığınından kaldırmak için şunu yazın:

git stash pop stash@{n}

Bir saklamak uygulamak ve saklamak için saklayın, şunu yazın:

git stash apply stash@{n}

nSaklı değişimin endeksi nerede .

git stash saveolduğu kaldırılmış 2.15.x / 2,16 olarak yerine kullanabileceğinizgit stash push -m "message"

Bu şekilde kullanabilirsiniz:

git stash push -m "message"

burada "mesaj" bu saklamak için notunuz.

: Kullanabileceğiniz zulası almak için git stash list. Bu, şöyle bir liste çıkarır, örneğin:

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

Sonra sadece şunu applyvererek kullanın stash@{index}:

git stash apply stash@{1}

Referanslar git stash man page

Yeterince önemli olduğunu düşünüyorsanız bir zulayı bir şubeye dönüştürebilirsiniz:

git stash branch <branchname> [<stash>]

man sayfasından:

Bu , başlangıçta oluşturulduğu <branchname>taahhütten başlayarak yeni bir şube oluşturur ve denetler <stash>, kaydedilen değişiklikleri <stash>yeni çalışma ağacına ve dizine uygular , ardından <stash>başarıyla tamamlanırsa bırakır . Hayır <stash>verildiğinde, en sonuncusu uygulanır.

Bu, çalıştırdığınız dalın git stash savegit stash uygulamasının çakışmaları nedeniyle başarısız olacağı kadar değişmesi durumunda yararlıdır . Stash, git stash çalıştırıldığı sırada HEAD olan taahhüdün üzerine uygulandığından, çakışma olmadan başlangıçta saklanan durumu geri yükler.

Daha sonra bu yeni şubeyi sakladığınız yerin soyundan gelen başka bir yere yeniden atabilirsiniz.

Mevcut çalışan kopya değişikliklerinizin bir kısmını veya tamamını kaydetmek ve daha sonra bunları istediğiniz zaman yeniden uygulamak için hafif bir yol arıyorsanız, bir yama dosyası düşünün:

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

# re-apply it later
git apply some.patch

Arada sırada bunun için saklamak mı kullanmam gerektiğini merak ediyorum ve sonra yukarıdaki delilik gibi şeyler görüyorum ve yaptığım şeyden memnunum :)

Zararlar sizin gibi kalıcı şeyler değildir. Muhtemelen taahhütlerde etiketleri kullanarak daha iyi hizmet alırsınız. Saklamak istediğiniz şeyi oluşturun. Bir taahhütte bulunun. Bu taahhüt için bir etiket oluşturun. Ardından şubenizi geri alın HEAD^. Şimdi bu zulayı yeniden uygulamak istediğinizde git cherry-pick -n tagname( -nis --no-commit) kullanabilirsiniz .

git stash push -m aNameForYourStashkaydetmek için kullanın . Ardından , uygulamak istediğiniz zula dizinigit stash list öğrenmek için kullanın . Sonra zulayı patlatmak ve uygulamak için kullanın.git stash pop --index 0

not: git sürüm 2.21.0.windows.1 kullanıyorum

Benim dosyamda bu iki işlevi var .zshrc:

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)
}

Bunları şu şekilde kullanmak:

gitstash nice

gitstashapply nice

Peki buna ne dersin?

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

takma ad

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

kullanım

git sapply "<regex>"

• Windows için Git ile uyumlu

Düzenleme: Orijinal çözümüme bağlı kaldım, ancak çoğunluğun neden Etan Reisner'ın sürümünü tercih ettiğini görüyorum (yukarıda). Yani sadece kayıt için:

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

İşe git stash apply stash^{/<regex>}yaramazsa talihsiz bir durumdur (aslında saklamak listesinde arama yapmaz, kabul edilen cevabın altındaki yorumlara bakın ).

git stash listİlkini (en son) bulmak için regex ile arama yapan stash@{<n>}ve daha sonra bunu ileten açılan yedekler 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")

Bu komutları diğer komut dosyalarında kullanabilmeniz için uygun sonuç kodlarının döndürüldüğünü unutmayın. Bu, şu komutları çalıştırdıktan sonra doğrulanabilir:

echo $?

Değişken genişleme istismarlarına dikkat edin, çünkü bu --grep=$1kısımdan emin değildim . Belki de olmalı --grep="$1"ama bunun regex sınırlayıcılarına müdahale edip etmeyeceğinden emin değilim (önerilere açığım).

Bu cevap Klemen Slavič'e çok şey borçludur. Ben sadece kabul edilen cevap hakkında yorum olurdu ama henüz yeterli temsilcisi yok :(

Ayrıca stash ref'yi bulmak için bir git takma adı ekleyebilir ve bunu göstermek, uygulamak, bırakmak vb.İçin diğer takma adlarda kullanabilirsiniz.

[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"

Nedeni, Not ref=$( ... ); echo ${ref:-<no_match>};sapply, sshow neden olacak boş bir dize iade edilmemesi böylece desen ve sdrop son zulası hedef yerine bir beklendiği gibi başarısız olmasına.

Takma Ad Bu, bir işlevde kapsüllemeye gerek kalmadan Unix benzeri sistemler için daha doğrudan bir sözdizimi olabilir. Aşağıdakileri [alias] altındaki ~ / .gitconfig dizinine ekleyin

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

Kullanım: sapply regex

Örnek: git sshow MySecretStash

Sondaki kısa çizgi, standart girişten girdi al diyor.

Zuvanın numarasını aramak için küçük bir bash betiği kullanın. Buna "gitapply" deyin:

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

Kullanımı:

gitapply foo

... burada foo, istediğiniz zuvanın adının bir alt dizesidir.

git stash save NAMEKaydetmek için kullanın .

Sonra ... hangisini uygulayacağınızı (veya pop) seçeceğinizi seçmek için bu komut dosyasını kullanabilirsiniz:

#!/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

Zulaların isimlerini görebilmeyi ve seçebilmeyi seviyorum. Ayrıca Zshell kullanıyorum ve açıkçası yukarıdaki Bash takma adlarının nasıl kullanılacağını bilmiyordum;)

Not: Kevin'in dediği gibi, bunun yerine etiketleri ve kiraz seçimlerini kullanmalısınız.

PowerShell kullanarak bunu yapmanın bir yolu budur:

<#
.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''
    }
}

Daha fazla ayrıntı burada

balık kabuğumda

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

kullanım

gsap name_of_stash

Burada partiye geç, ancak VSCode kullanıyorsanız, bunu yapmanın hızlı bir yolu komut paletini (CTRL / CMD + SHIFT + P) açmak ve "Pop Stash" yazmak, zulayı isminizle alabilirsiniz. git CLI kullanmaya gerek kalmadan

git stash applyAyrıca diğer refs ile çalışır stash@{0}. Böylece kalıcı bir ad almak için normal etiketleri kullanabilirsiniz . Bunun, yanlışlıkla yapamayacağınız git stash dropveyagit stash pop da.

Böylece şöyle bir takma ad pstash(diğer adıyla "persistent stash") tanımlayabilirsiniz :

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

Şimdi etiketli bir stash oluşturabilirsiniz:

git pstash x-important-stuff

ve showve applyher zamanki gibi:

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

Ben adıyla bir zulası git gitmenin bir yolu olduğunu sanmıyorum.

Bunu yapan bir bash işlevi yarattım.

#!/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"
}

Kullanım örneği:

[~/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"

Umut ediyorum bu yardım eder!

Stash yaratılışının dışındaki her şey için, fzf'yi bağımlılık olarak tanıtarak başka bir çözüm öneriyorum . Her şeyden önce harika bir üretkenlik artırıcı olduğu için 5 dakikanızı ayırmanızı ve tanıtmanızı öneririm.

Her neyse, örnek sayfalarından stash araması sunan ilgili bir alıntı . Ek işlevsellik eklemek için komut dosyasını değiştirmek çok kolaydır (stash uygulaması veya bırakma gibi):

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
}

Bu yüzden, neden bu konuda bu kadar çok şaşkınlık olduğundan emin değilim. Bir itme hem itme hem de kullanımdan kaldırma ile adlandırabilirim ve bir uygulama ile geri çekmek için bir regex kullanabilirim:

Uygulamak için bir ad kullanmak için Git stash yöntemi

$ git stash push -m "john-hancock"

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

Daha önce de belirtildiği gibi, kaydetme komutu kullanımdan kaldırıldı, ancak yine de çalışıyor, bu yüzden bunları bir push çağrısıyla güncelleyemediğiniz eski sistemlerde kullanabilirsiniz. Push komutunun aksine, -m anahtarı save ile gerekli değildir.

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

Pop ve bırak ile ilgili sorunlar

Bir pop ile çalıştığına inanmıyorum, ancak bence pop uygulandıktan sonra bir damla yapıyor ve normal ifade damla dostu değil. Bu sadece bir önsezi. Test etmedim.

Bu Git 2.2 ve Windows 10.

Görsel Kanıt

İşte süreci gösteren güzel bir animasyonlu GIF.

Olayların sırası

GIF hızlı çalışır, ancak bakarsanız işlem şu şekildedir:

1. Ls komutu dizinde 4 dosya gösterir
2. touch example.html 5. dosya ekler
3. git stash push -m "john-hancock" -a (-a izlenmemiş dosyaları içerir)
4. Ls komutu, stash'tan sonra 4 dosya gösterir, bu da stash ve örtük donanımsal sıfırlamanın çalıştığı anlamına gelir
5. git stash uygulamak stash ^ {/ john-hancock} çalışır
6. Ls komutu, example.html dosyasının geri getirildiğini gösteren 5 dosyayı listeler, yani git stash uygulama komutu çalıştı.

Bu mantıklı geliyor mu?

Açıkçası, bu yaklaşımın ne faydası olduğundan emin değilim. Stash'a bir isim vermenin değeri vardır, ancak geri çağırma değil. Belki süreci senaryo olarak yazmak yararlı olabilir, ancak yine de bir zulayı isimle patlatmak çok daha kolaydır.

$ git stash pop 3
$ git stash apply 3

Benim için normalden daha kolay görünüyor.