Làm thế nào để đặt tên và lấy một stash theo tên trong git?

Tôi luôn có ấn tượng rằng bạn có thể đặt tên cho stash bằng cách thực hiện git stash save stashname, điều mà sau này bạn có thể áp dụng bằng cách thực hiện git stash apply stashname. Nhưng có vẻ như trong trường hợp này, tất cả những gì xảy ra là stashnamesẽ được sử dụng làm mô tả stash.

Có cách nào để thực sự đặt tên cho một stash? Nếu không, bạn muốn giới thiệu gì để đạt được chức năng tương đương? Về cơ bản, tôi có một số tiền nhỏ mà tôi muốn áp dụng định kỳ, nhưng không muốn luôn phải tìm kiếm git stash listsố lượng thực tế của nó.

Đây là cách bạn làm điều đó:

git stash save "my_stash"

Trong trường hợp "my_stash"là tên stash.

Một số điều hữu ích hơn cần biết: Tất cả các stash được lưu trữ trong một ngăn xếp. Kiểu:

git stash list

Điều này sẽ liệt kê tất cả các stash của bạn.

Để áp dụng một ngăn chứa và loại bỏ nó khỏi ngăn xếp, hãy gõ:

git stash pop stash@{n}

Để áp dụng stash và giữ nó trong ngăn xếp stash, gõ:

git stash apply stash@{n}

Đâu nlà chỉ số của sự thay đổi được cất giấu.

git stash saveđang bị phản đối như của 2.15.x / 2.16, thay vào đó bạn có thể sử dụnggit stash push -m "message"

Bạn có thể sử dụng nó như thế này:

git stash push -m "message"

trong đó "tin nhắn" là ghi chú của bạn cho stash đó.

Để lấy lại stash, bạn có thể sử dụng : git stash list. Điều này sẽ xuất ra một danh sách như thế này, ví dụ:

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

Sau đó, bạn chỉ cần sử dụng applycho nó stash@{index}:

git stash apply stash@{1}

Tài liệu tham khảo git stash man page

Bạn có thể biến một stash thành một nhánh nếu bạn cảm thấy nó đủ quan trọng:

git stash branch <branchname> [<stash>]

từ trang người đàn ông:

Điều này tạo và kiểm tra một nhánh mới có tên <branchname>bắt đầu từ cam kết mà tại đó <stash>ban đầu được tạo, áp dụng các thay đổi được ghi vào <stash>cây và chỉ mục làm việc mới, sau đó loại bỏ <stash>nếu hoàn thành thành công. Khi không <stash>được đưa ra, áp dụng cái mới nhất.

Điều này rất hữu ích nếu nhánh mà bạn chạy git stash saveđã thay đổi đủ để áp dụng git stash không thành công do xung đột. Vì stash được áp dụng trên đỉnh của cam kết đó là HEAD tại thời điểm git stash được chạy, nó khôi phục trạng thái stash ban đầu mà không có xung đột.

Sau này bạn có thể nổi loạn chi nhánh mới này đến một nơi khác, đó là hậu duệ của nơi bạn ở khi bạn cất giấu.

Nếu bạn chỉ tìm kiếm một cách nhẹ nhàng để lưu một số hoặc tất cả các thay đổi bản sao làm việc hiện tại của bạn và sau đó áp dụng lại chúng sau này, hãy xem xét một tệp vá:

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

# re-apply it later
git apply some.patch

Thỉnh thoảng tôi tự hỏi liệu tôi có nên sử dụng stash cho việc này không và sau đó tôi thấy những thứ như sự điên rồ ở trên và tôi hài lòng với những gì tôi đang làm :)

Stash không có nghĩa là những thứ vĩnh viễn như bạn muốn. Bạn có thể được phục vụ tốt hơn bằng cách sử dụng thẻ trên các cam kết. Xây dựng những thứ bạn muốn stash. Thực hiện một cam kết từ nó. Tạo một thẻ cho cam kết đó. Sau đó cuộn lại chi nhánh của bạn để HEAD^. Bây giờ khi bạn muốn áp dụng lại stash đó, bạn có thể sử dụng git cherry-pick -n tagname( -nis --no-commit).

sử dụng git stash push -m aNameForYourStashđể lưu nó Sau đó sử dụng git stash listđể tìm hiểu chỉ số của stash mà bạn muốn áp dụng. Sau đó sử dụng git stash pop --index 0để bật stash và áp dụng nó.

lưu ý: Tôi đang sử dụng git phiên bản 2.21.0.windows.1

Tôi có hai chức năng này trong .zshrctập tin của mình :

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

Sử dụng chúng theo cách này:

gitstash nice

gitstashapply nice

Cái này thì sao?

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

Bí danh

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

Sử dụng

git sapply "<regex>"

• tương thích với Git cho Windows

Chỉnh sửa: Tôi đã gắn bó với giải pháp ban đầu của mình, nhưng tôi thấy lý do tại sao đa số thích phiên bản của Etan Reisner (ở trên). Vì vậy, chỉ cho hồ sơ:

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

Thật không may là git stash apply stash^{/<regex>}nó không hoạt động (nó không thực sự tìm kiếm danh sách stash, xem các bình luận dưới câu trả lời được chấp nhận ).

Dưới đây là các thay thế thả xuống tìm kiếm git stash listtheo regex để tìm đầu tiên (gần đây nhất) stash@{<n>}và sau đó chuyển nó tới 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")

Lưu ý rằng mã kết quả phù hợp được trả về để bạn có thể sử dụng các lệnh này trong các tập lệnh khác. Điều này có thể được xác minh sau khi chạy các lệnh với:

echo $?

Chỉ cần cẩn thận về khai thác mở rộng biến vì tôi không chắc chắn về --grep=$1phần này. Có thể là như --grep="$1"vậy nhưng tôi không chắc liệu điều đó có can thiệp vào các dấu phân cách regex không (tôi mở để đề xuất).

Câu trả lời này nợ nhiều cho Klemen Slavič. Tôi sẽ chỉ nhận xét về câu trả lời được chấp nhận nhưng tôi chưa có đủ đại diện :(

Bạn cũng có thể thêm một bí danh git để tìm stash ref và sử dụng nó trong các bí danh khác để hiển thị, áp dụng, thả, v.v.

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

Lưu ý rằng lý do của ref=$( ... ); echo ${ref:-<no_match>};mẫu là một chuỗi trống không được trả về, điều này sẽ gây ra sshow, sapply và sdrop để nhắm mục tiêu stash mới nhất thay vì thất bại như mong đợi.

Bí danh Đây có thể là một cú pháp trực tiếp hơn cho các hệ thống giống Unix mà không cần phải gói gọn trong một hàm. Thêm phần sau vào ~ / .gitconfig trong [bí danh]

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

Cách sử dụng: regex sapply

Ví dụ: git sshow MySecretStash

Dấu gạch nối ở cuối cho biết lấy đầu vào từ đầu vào tiêu chuẩn.

Sử dụng một tập lệnh bash nhỏ để tra cứu số lượng stash. Gọi nó là "gitapply":

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

Sử dụng:

gitapply foo

... Trong đó foo là một chuỗi con của tên của stash bạn muốn.

Sử dụng git stash save NAMEđể tiết kiệm.

Sau đó ... bạn có thể sử dụng tập lệnh này để chọn áp dụng (hoặc 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

Tôi thích có thể nhìn thấy tên của stash và chọn. Ngoài ra tôi sử dụng Zshell và thẳng thắn không biết cách sử dụng một số bí danh Bash ở trên;)

Lưu ý: Như Kevin nói, bạn nên sử dụng thẻ và cherry-picks thay thế.

Đây là một cách để thực hiện việc này bằng 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''
    }
}

Thêm chi tiết tại đây

trong vỏ cá của tôi

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

sử dụng

tên gsap_of_stash

Đến bữa tiệc muộn ở đây, nhưng nếu sử dụng VSCode, một cách nhanh chóng để làm điều đó là mở bảng lệnh (CTRL / CMD + SHIFT + P) và nhập "Pop Stash", bạn sẽ có thể truy xuất stash của mình theo tên không cần sử dụng git CLI

git stash applycũng làm việc với các ref khác stash@{0}. Vì vậy, bạn có thể sử dụng các thẻ thông thường để có được một tên liên tục. Điều này cũng có lợi thế là bạn không thể vô tình git stash drophoặc git stash popnó.

Vì vậy, bạn có thể định nghĩa một bí danh pstash(còn gọi là "stash liên tục") như thế này:

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

Bây giờ bạn có thể tạo một stash được gắn thẻ:

git pstash x-important-stuff

và showvà applynó lại như bình thường:

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

Tôi không nghĩ có một cách để git pop stash bằng tên của nó.

Tôi đã tạo ra một hàm bash làm điều đó.

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

Ví dụ về cách sử dụng:

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

Tôi hy vọng nó sẽ giúp!

Đối với tất cả mọi thứ ngoài việc tạo stash, tôi sẽ đề xuất một giải pháp khác bằng cách giới thiệu fzf như một sự phụ thuộc. Tôi khuyên bạn nên dành 5 phút thời gian của bạn và làm quen với nó, vì nó vượt quá tất cả các công cụ tăng năng suất tuyệt vời.

Dù sao, một đoạn trích liên quan từ trang ví dụ của họ cung cấp tìm kiếm stash. Thật dễ dàng để thay đổi scriptlet để thêm chức năng bổ sung (như ứng dụng stash hoặc thả):

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
}

Vì vậy, tôi không chắc tại sao có quá nhiều sự dè dặt về chủ đề này. Tôi có thể đặt tên cho một stash với cả đẩy và lưu không dùng nữa và tôi có thể sử dụng biểu thức chính quy để kéo nó trở lại với một ứng dụng:

Phương pháp Git stash để sử dụng tên để áp dụng

$ git stash push -m "john-hancock"

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

Như đã được đề cập trước đó, lệnh save không được dùng nữa, nhưng nó vẫn hoạt động, vì vậy bạn có thể sử dụng nó trên các hệ thống cũ hơn, nơi bạn không thể cập nhật chúng bằng một cuộc gọi đẩy. Không giống như lệnh đẩy, công tắc -m không bắt buộc phải lưu.

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

Vấn đề với một pop và thả

Tôi không tin rằng nó hoạt động với pop, nhưng tôi nghĩ đó là vì pop thực hiện giảm sau khi áp dụng, và regex không giảm thân thiện. Đó chỉ là một linh cảm. Tôi đã không kiểm tra nó.

Đây là Git 2.2 và Windows 10.

Bằng chứng trực quan

Đây là một GIF hoạt hình đẹp thể hiện quá trình.

Chuỗi các sự kiện

GIF chạy nhanh, nhưng nếu bạn nhìn, quá trình này là:

1. Lệnh ls hiển thị 4 tệp trong thư mục
2. chạm example.html thêm tệp thứ 5
3. git stash đẩy -m "john-hancock" -a (-a bao gồm các tệp không bị theo dõi)
4. Lệnh ls hiển thị 4 tệp sau stash, nghĩa là stash và thiết lập lại cứng ẩn hoạt động
5. git stash áp dụng stash ^ {/ john-hancock} chạy
6. Lệnh ls liệt kê 5 tệp, hiển thị tệp example.html đã được đưa trở lại, nghĩa là lệnh git stash áp dụng đã hoạt động.

Điều này thậm chí có ý nghĩa?

Thành thật mà nói, tôi không chắc lợi ích của phương pháp này là gì. Có giá trị trong việc đặt tên cho stash, nhưng không phải là truy xuất. Có thể kịch bản quá trình này sẽ hữu ích, nhưng vẫn dễ dàng hơn khi chỉ bật một stash theo tên.

$ git stash pop 3
$ git stash apply 3

Điều đó có vẻ dễ dàng với tôi hơn regex.