Bagaimana cara memberi nama dan mengambil simpanan berdasarkan nama di git?

Saya selalu mendapat kesan bahwa Anda bisa memberi simpanan nama dengan melakukan git stash save stashname, yang nantinya bisa Anda lakukan dengan melakukan git stash apply stashname. Tetapi tampaknya dalam hal ini semua yang terjadi adalah yang stashnameakan digunakan sebagai deskripsi simpanan.

Apakah tidak ada cara untuk benar-benar menamai simpanan? Jika tidak, apa yang akan Anda rekomendasikan untuk mencapai fungsi yang setara? Pada dasarnya saya memiliki simpanan kecil yang ingin saya terapkan secara berkala, tetapi tidak ingin selalu harus mencari git stash listnomor simpanan sebenarnya.

Inilah cara Anda melakukannya:

git stash save "my_stash"

Di mana "my_stash"nama simpanan.

Beberapa hal yang lebih berguna untuk diketahui: Semua simpanan disimpan dalam tumpukan. Tipe:

git stash list

Ini akan mencantumkan semua simpanan Anda.

Untuk menerapkan simpanan dan menghapusnya dari tumpukan simpanan, ketik:

git stash pop stash@{n}

Untuk menerapkan simpanan dan menyimpannya di tumpukan simpanan, ketik:

git stash apply stash@{n}

Di mana nindeks perubahan disimpan.

git stash savesudah usang pada 2.15.x / 2.16, sebagai gantinya Anda dapat menggunakangit stash push -m "message"

Anda bisa menggunakannya seperti ini:

git stash push -m "message"

di mana "message" adalah catatan Anda untuk simpanan itu.

Dalam rangka untuk mengambil simpanan Anda dapat menggunakan: git stash list. Ini akan menampilkan daftar seperti ini, misalnya:

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

Maka Anda cukup menggunakan applymemberi itu stash@{index}:

git stash apply stash@{1}

Referensi man page simpanan git

Anda dapat mengubah simpanan menjadi cabang jika Anda merasa itu cukup penting:

git stash branch <branchname> [<stash>]

dari halaman manual:

Ini membuat dan memeriksa cabang baru bernama <branchname>mulai dari komit di mana <stash>awalnya dibuat, menerapkan perubahan yang tercatat di <stash>pohon dan indeks kerja yang baru, kemudian menjatuhkan <stash>jika itu berhasil selesai. Ketika tidak <stash>diberikan, terapkan yang terbaru.

Ini berguna jika cabang tempat Anda berlari git stash savetelah cukup berubah sehingga git stash berlaku gagal karena konflik. Karena simpanan diterapkan di atas komit yang HEAD pada saat simpanan git dijalankan, simpanan memulihkan kondisi simpanan semula tanpa konflik.

Anda nanti dapat rebase cabang baru ini ke tempat lain yang merupakan keturunan di mana Anda berada saat Anda simpanan.

Jika Anda hanya mencari cara yang ringan untuk menyimpan sebagian atau semua perubahan copy pekerjaan Anda saat ini dan kemudian menerapkannya kembali nanti, pertimbangkan file patch:

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

# re-apply it later
git apply some.patch

Sesekali saya bertanya-tanya apakah saya harus menggunakan simpanan untuk ini dan kemudian saya melihat hal-hal seperti kegilaan di atas dan saya puas dengan apa yang saya lakukan :)

Stash tidak dimaksudkan untuk menjadi hal yang permanen seperti yang Anda inginkan. Anda mungkin akan lebih baik dilayani menggunakan tag saat melakukan. Bangun benda yang ingin Anda sembunyikan. Buat komitmen darinya. Buat tag untuk komit itu. Kemudian putar kembali cabang Anda ke HEAD^. Sekarang ketika Anda ingin mengajukan permohonan kembali bahwa simpanan Anda dapat menggunakan git cherry-pick -n tagname( -nadalah --no-commit).

gunakan git stash push -m aNameForYourStashuntuk menyimpannya. Kemudian gunakan git stash listuntuk mempelajari indeks simpanan yang ingin Anda terapkan. Kemudian gunakan git stash pop --index 0untuk menghapus simpanan dan menerapkannya.

Catatan: Saya menggunakan git versi 2.21.0.windows.1

Saya memiliki dua fungsi ini di .zshrcfile saya :

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

Menggunakannya dengan cara ini:

gitstash nice

gitstashapply nice

Bagaimana dengan ini?

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"

Pemakaian

git sapply "<regex>"

• kompatibel dengan Git untuk Windows

Sunting: Saya berpegang teguh pada solusi asli saya, tetapi saya melihat mengapa mayoritas lebih suka versi Etan Reisner (di atas). Jadi hanya sebagai catatan:

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

Sangat disayangkan itu git stash apply stash^{/<regex>}tidak bekerja (itu tidak benar-benar mencari daftar simpanan, lihat komentar di bawah jawaban yang diterima ).

Berikut adalah pengganti drop-in yang mencari git stash listdengan regex untuk menemukan yang pertama (terbaru) stash@{<n>}dan kemudian meneruskannya ke 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")

Perhatikan bahwa kode hasil yang tepat dikembalikan sehingga Anda dapat menggunakan perintah ini dalam skrip lain. Ini dapat diverifikasi setelah menjalankan perintah dengan:

echo $?

Hanya berhati-hati tentang eksploitasi ekspansi variabel karena saya tidak yakin tentang --grep=$1porsinya. Mungkin seharusnya --grep="$1"tetapi saya tidak yakin apakah itu akan mengganggu pembatas regex (saya terbuka untuk saran).

Jawaban ini berhutang banyak pada Klemen Slavič. Saya hanya akan mengomentari jawaban yang diterima tetapi saya belum memiliki cukup perwakilan :(

Anda juga bisa menambahkan alias git untuk menemukan simpanan ref dan menggunakannya di alias lain untuk menunjukkan, menerapkan, menjatuhkan, dll.

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

Perhatikan bahwa alasan ref=$( ... ); echo ${ref:-<no_match>};pola ini adalah agar string kosong tidak dikembalikan yang akan menyebabkan sshow, sapply, dan sdrop untuk menargetkan simpanan terbaru alih-alih gagal seperti yang diharapkan.

Alias Ini mungkin sintaks yang lebih langsung untuk sistem mirip Unix tanpa perlu merangkum dalam suatu fungsi. Tambahkan berikut ini ke ~ / .gitconfig di bawah [alias]

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

Penggunaan: regex sapply

Contoh: git sshow MySecretStash

Tanda hubung di bagian akhir mengatakan ambil input dari input standar.

Gunakan skrip bash kecil untuk mencari nomor simpanan. Sebut saja "gitapply":

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

Pemakaian:

gitapply foo

... di mana foo adalah substring dari nama simpanan yang Anda inginkan.

Gunakan git stash save NAMEuntuk menyimpan.

Lalu ... Anda dapat menggunakan skrip ini untuk memilih mana yang akan diterapkan (atau 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

Saya suka bisa melihat nama simpanan dan memilih. Saya juga menggunakan Zshell dan terus terang tidak tahu cara menggunakan beberapa alias Bash di atas;)

Catatan: Seperti kata Kevin, Anda harus menggunakan tag dan ceri-picks sebagai gantinya.

Ini adalah salah satu cara untuk mencapai ini menggunakan PowerShell:

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

Lebih detail di sini

di kulit ikan saya

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

menggunakan

gsap name_of_stash

Terlambat ke pesta di sini, tetapi jika menggunakan VSCode, cara cepat untuk melakukannya adalah dengan membuka palet perintah (CTRL / CMD + SHIFT + P) dan ketik "Pop Stash", Anda akan dapat mengambil simpanan Anda dengan nama tanpa perlu menggunakan git CLI

git stash applyjuga bekerja dengan referensi selain stash@{0}. Jadi, Anda dapat menggunakan tag biasa untuk mendapatkan nama yang persisten. Ini juga memiliki keuntungan yang tidak dapat Anda sembunyikan git stash dropatau git stash poptidak.

Jadi, Anda dapat mendefinisikan alias pstash(alias "persisten simpanan") seperti ini:

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

Sekarang Anda dapat membuat simpanan yang ditandai:

git pstash x-important-stuff

dan showdan applylagi seperti biasa:

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

Saya tidak berpikir ada cara untuk mendapatkan pop simpanan dengan namanya.

Saya telah membuat fungsi bash yang melakukannya.

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

Contoh penggunaan:

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

Saya harap ini membantu!

Untuk semuanya selain penciptaan simpanan, saya akan mengusulkan solusi lain dengan memperkenalkan fzf sebagai ketergantungan. Saya sarankan untuk mengambil 5 menit dari waktu Anda dan diperkenalkan padanya, karena itu adalah penguat produktivitas yang hebat.

Bagaimanapun, kutipan terkait dari halaman contoh mereka menawarkan pencarian simpanan. Sangat mudah untuk mengubah scriptlet untuk menambahkan fungsionalitas tambahan (seperti aplikasi simpanan atau menjatuhkan):

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
}

Jadi, saya tidak yakin mengapa ada begitu banyak kekhawatiran tentang topik ini. Saya dapat memberi nama simpanan git dengan dorongan dan simpanan yang tidak digunakan, dan saya dapat menggunakan regex untuk menariknya kembali dengan menerapkan:

Metode simpanan Git untuk menggunakan nama untuk diterapkan

$ git stash push -m "john-hancock"

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

Seperti yang telah disebutkan sebelumnya, perintah save sudah tidak digunakan lagi, tetapi masih berfungsi, jadi Anda bisa menggunakan ini pada sistem lama di mana Anda tidak dapat memperbaruinya dengan panggilan push. Berbeda dengan perintah push, -m switch tidak diperlukan dengan save.

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

Ini adalah Git 2.2 dan Windows 10.

Bukti Visual

Inilah GIF animasi yang indah yang menunjukkan prosesnya.

Urutan peristiwa

GIF berjalan cepat, tetapi jika Anda perhatikan, prosesnya adalah ini:

1. Perintah ls menunjukkan 4 file dalam direktori
2. touch example.html menambahkan file ke-5
3. git simpanan push -m "john-hancock" -a (-a termasuk file yang tidak terlacak)
4. Perintah ls menunjukkan 4 file setelah simpanan, yang berarti simpanan dan pengaturan ulang implisit berhasil
5. git stash menerapkan simpanan ^ {/ john-hancock} berjalan
6. Perintah ls mencantumkan 5 file, memperlihatkan file example.html dikembalikan, artinya perintah git stash apply bekerja.

Apakah ini masuk akal?

Terus terang, saya tidak yakin apa manfaat dari pendekatan ini. Ada nilai dalam memberikan simpanan nama, tetapi tidak pengambilan. Mungkin untuk skrip proses mengesampingkan dan dua belas itu akan sangat membantu, tetapi masih jauh lebih mudah untuk hanya memasukkan simpanan dengan nama.

$ git stash pop 3
$ git stash apply 3

Bagi saya itu terlihat lebih mudah daripada regex.