วิธีการตั้งชื่อและดึงที่ซ่อนตามชื่อในคอมไพล์?

ฉันถูกเสมอภายใต้ความประทับใจที่คุณจะให้ซ่อนชื่อโดยการทำซึ่งคุณสามารถนำไปใช้ในภายหลังด้วยการทำgit stash save stashname git stash apply stashnameแต่ดูเหมือนว่าในกรณีนี้สิ่งที่เกิดขึ้นคือstashnameจะใช้เป็นคำอธิบายที่ซ่อน

ไม่มีทางที่จะตั้งชื่อที่ซ่อนจริงหรือไม่? ถ้าไม่คุณจะแนะนำให้ใช้ฟังก์ชันการทำงานที่เทียบเท่าได้อย่างไร โดยพื้นฐานแล้วฉันมีที่ซ่อนเล็ก ๆ ซึ่งฉันต้องการใช้เป็นระยะ แต่ไม่ต้องการที่จะตามล่าในgit stash listจำนวนที่สะสมที่แท้จริงของมัน

นี่คือวิธีที่คุณทำ:

git stash save "my_stash"

"my_stash"ชื่อที่ซ่อนอยู่ที่ไหน

สิ่งที่มีประโยชน์เพิ่มเติมที่ควรทราบ: ที่เก็บข้อมูลทั้งหมดจะถูกเก็บไว้ในสแต็ก ประเภท:

git stash list

นี่จะแสดงรายการการหยุดทั้งหมดของคุณ

หากต้องการใช้ stash และลบออกจาก stash stack ให้พิมพ์:

git stash pop stash@{n}

หากต้องการใช้ stash และเก็บไว้ใน stash stack ให้พิมพ์:

git stash apply stash@{n}

nดัชนีการเปลี่ยนแปลงที่ซ่อนอยู่ที่ไหน

git stash saveถูกเลิกใช้ตั้งแต่ 2.15.x / 2.16 แต่คุณสามารถใช้ได้git stash push -m "message"

คุณสามารถใช้สิ่งนี้:

git stash push -m "message"

โดยที่ "ข้อความ" เป็นบันทึกย่อของคุณสำหรับที่เก็บสะสมนั้น

เพื่อที่จะดึงที่ซ่อนคุณสามารถใช้: git stash list. สิ่งนี้จะแสดงรายการเช่นนี้ตัวอย่างเช่น:

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

จากนั้นคุณเพียงแค่ใช้applyให้มันstash@{index}:

git stash apply stash@{1}

การอ้างอิง git stash man page

คุณสามารถเปลี่ยนที่ซ่อนเป็นสาขาหากคุณรู้สึกว่ามันสำคัญพอ:

git stash branch <branchname> [<stash>]

จากหน้าคน:

สิ่งนี้สร้างและตรวจสอบสาขาใหม่ที่ชื่อ<branchname>เริ่มต้นจากการคอมมิชชันที่<stash>ถูกสร้างขึ้นในตอนแรกใช้การเปลี่ยนแปลงที่บันทึกไว้ในแผนผัง<stash>การทำงานใหม่และดัชนีจากนั้นปล่อย<stash>ถ้าทำเสร็จสมบูรณ์ เมื่อไม่<stash>ได้รับให้ใช้อันล่าสุด

สิ่งนี้มีประโยชน์ถ้าสาขาที่คุณวิ่งgit stash saveมีการเปลี่ยนแปลงมากพอที่จะใช้การเก็บซ่อนคอมไพล์ล้มเหลวเนื่องจากความขัดแย้ง เนื่องจากที่เก็บถูกนำไปใช้บนการคอมมิทที่เป็น HEAD ในขณะที่ git stash ถูกรันมันจะกู้คืนสถานะ stashed ดั้งเดิมโดยไม่มีข้อขัดแย้ง

คุณสามารถรีบูทสาขาใหม่นี้ไปยังที่อื่นที่เป็นของคุณเมื่อคุณถูกซ่อน

หากคุณกำลังมองหาวิธีที่มีน้ำหนักเบาในการบันทึกการเปลี่ยนแปลงสำเนาการทำงานปัจจุบันบางส่วนหรือทั้งหมดแล้วนำไปใช้ใหม่ในภายหลังให้ลองพิจารณาไฟล์แพตช์:

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

# re-apply it later
git apply some.patch

ทุกขณะนี้แล้วฉันสงสัยว่าฉันควรใช้ stashes สำหรับสิ่งนี้และจากนั้นฉันเห็นสิ่งต่าง ๆ เช่นความวิกลจริตข้างต้นและฉันพอใจกับสิ่งที่ฉันทำ :)

การหยุดชะงักไม่ได้หมายถึงการเป็นสิ่งถาวรตามที่คุณต้องการ คุณน่าจะได้รับบริการที่ดีขึ้นโดยใช้แท็กในการกระทำ สร้างสิ่งที่คุณต้องการซ่อน ทำให้ความมุ่งมั่นออกมาจากมัน สร้างแท็กสำหรับการส่ง HEAD^จากนั้นย้อนกลับไปยังสาขาของคุณ ตอนนี้เมื่อคุณต้องการนำไปใช้สะสมที่คุณสามารถใช้git cherry-pick -n tagname( -nคือ--no-commit)

ใช้git stash push -m aNameForYourStashเพื่อบันทึก จากนั้นใช้git stash listเพื่อเรียนรู้ดัชนีของที่เก็บที่คุณต้องการใช้ จากนั้นใช้git stash pop --index 0ป๊อปอัพสะสมและใช้มัน

หมายเหตุ: ฉันใช้git เวอร์ชั่น 2.21.0.windows.1

ฉันมีทั้งสองฟังก์ชั่นใน.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)
}

ใช้พวกเขาด้วยวิธีนี้:

gitstash nice

gitstashapply nice

แล้วเรื่องนี้ล่ะ

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

นามแฝง

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

การใช้

git sapply "<regex>"

• เข้ากันได้กับ Git สำหรับ Windows

แก้ไข: ฉันยึดติดกับโซลูชันดั้งเดิมของฉัน แต่ฉันเห็นว่าทำไมคนส่วนใหญ่ถึงชอบรุ่นของ Etan Reisner (ด้านบน) ดังนั้นสำหรับบันทึก:

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

มันโชคร้ายที่git stash apply stash^{/<regex>}ใช้งานไม่ได้ (จริงๆแล้วมันไม่ได้ค้นหารายชื่อที่ซ่อนดูความคิดเห็นภายใต้คำตอบที่ได้รับการยอมรับ )

นี่คือการแทนที่แบบหล่นในที่ค้นหาgit stash listโดย regex เพื่อค้นหาแรก (ล่าสุด) stash@{<n>}จากนั้นส่งต่อไปที่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")

โปรดทราบว่าจะส่งคืนรหัสผลลัพธ์ที่ถูกต้องเพื่อให้คุณสามารถใช้คำสั่งเหล่านี้ภายในสคริปต์อื่น ๆ สิ่งนี้สามารถตรวจสอบได้หลังจากรันคำสั่งด้วย:

echo $?

เพียงระวังเกี่ยวกับการหาประโยชน์ส่วนขยายของตัวแปรเนื่องจากฉันไม่แน่ใจเกี่ยวกับ--grep=$1ส่วนนี้ อาจจะเป็น--grep="$1"แต่ฉันไม่แน่ใจว่าจะรบกวนตัวคั่น regex (ฉันเปิดรับข้อเสนอแนะ)

คำตอบนี้เป็นหนี้มากกับ Klemen Slavič ฉันเพิ่งจะแสดงความคิดเห็นในคำตอบที่ยอมรับ แต่ฉันยังไม่มีตัวแทนมากพอ :(

คุณสามารถเพิ่มนามแฝงคอมไพล์เพื่อค้นหาการอ้างอิงการสะสมและใช้ในนามแฝงอื่น ๆ สำหรับการแสดง, การประยุกต์, การดรอปและอื่น ๆ

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

โปรดทราบว่าเหตุผลของref=$( ... ); echo ${ref:-<no_match>};รูปแบบคือดังนั้นสตริงว่างจะไม่ถูกส่งคืนซึ่งจะทำให้ sshow, sapply และ sdrop เพื่อกำหนดเป้าหมายที่เก็บล่าสุดแทนที่จะล้มเหลวอย่างที่คาดหวัง

นามแฝง นี่อาจเป็นไวยากรณ์โดยตรงสำหรับระบบที่คล้าย Unix โดยไม่จำเป็นต้องใส่แค็ปซูลในฟังก์ชั่น เพิ่มรายการต่อไปนี้ใน ~ / .gitconfig ภายใต้ [alias]

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

การใช้งาน: regex อย่างราบรื่น

ตัวอย่าง: git sshow MySecretStash

เครื่องหมายยัติภังค์ที่ท้ายว่ารับข้อมูลจากอินพุตมาตรฐาน

ใช้สคริปต์ทุบตีเล็ก ๆ เพื่อค้นหาจำนวนที่ซ่อน เรียกมันว่า "gitapply":

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

การใช้งาน:

gitapply foo

... โดยที่ foo เป็นซับสตริงของชื่อของที่เก็บที่คุณต้องการ

ใช้git stash save NAMEสำหรับบันทึก

จากนั้น ... คุณสามารถใช้สคริปต์นี้เพื่อเลือกสิ่งที่จะใช้ (หรือป๊อป):

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

ฉันชอบที่จะเห็นชื่อของการหยุดชะงักและเลือก นอกจากนี้ฉันใช้ Zshell และไม่ทราบวิธีใช้นามแฝง Bash บางอย่างด้านบน;)

หมายเหตุ: ตามที่เควินบอกคุณควรใช้แท็กและหยิบเชอร์รี่แทน

นี่เป็นวิธีหนึ่งในการทำให้สำเร็จโดยใช้ 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''
    }
}

รายละเอียดเพิ่มเติมที่นี่

ในเปลือกปลาของฉัน

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

ใช้

gsap name_of_stash

ไปงานปาร์ตี้ที่นี่ช้า แต่ถ้าใช้ VSCode วิธีที่รวดเร็วในการทำเช่นนี้คือการเปิดพาเล็ทคำสั่ง (CTRL / CMD + SHIFT + P) และพิมพ์ "Pop Stash" คุณจะสามารถเรียกข้อมูลที่ซ่อนของคุณตามชื่อ โดยไม่จำเป็นต้องใช้ git CLI

git stash applyยังทำงานร่วมกับ refs stash@{0}อื่นที่ไม่ใช่ ดังนั้นคุณสามารถใช้แท็กสามัญเพื่อรับชื่อถาวร นี่เป็นข้อดีที่คุณไม่สามารถทำได้โดยไม่ตั้งใจgit stash dropหรือgit stash popมัน

ดังนั้นคุณสามารถกำหนดนามแฝงpstash(aka "ที่เก็บถาวร") ดังนี้:

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

ตอนนี้คุณสามารถสร้างที่ซ่อนที่ติดแท็ก:

git pstash x-important-stuff

และshowและapplyอีกครั้งตามปกติ:

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

ฉันไม่คิดว่าจะมีวิธีการคอมไพล์ป๊อปซ่อนโดยชื่อของมัน

ฉันได้สร้างฟังก์ชั่นทุบตีที่ทำมัน

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

ตัวอย่างการใช้งาน:

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

ฉันหวังว่ามันจะช่วย!

สำหรับทุกอย่างนอกเหนือจากการสร้างที่ซ่อนฉันจะเสนอวิธีแก้ไขปัญหาอื่นโดยแนะนำfzfเป็นการพึ่งพา ฉันขอแนะนำให้คุณสละเวลา 5 นาทีและแนะนำให้รู้จักกับมันเพราะมันเป็นเครื่องช่วยเพิ่มประสิทธิภาพการทำงาน

อย่างไรก็ตามข้อความที่ตัดตอนมาที่เกี่ยวข้องจากหน้าตัวอย่างของพวกเขาเสนอการค้นหาที่ซ่อน มันง่ายมากที่จะเปลี่ยน scriptlet เพื่อเพิ่มฟังก์ชั่นเพิ่มเติม (เช่นแอพพลิเคชั่นสะสมหรือวาง):

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
}

ดังนั้นฉันไม่แน่ใจว่าทำไมหัวข้อนี้จึงตกตะลึงมาก ฉันสามารถตั้งชื่อ stash ด้วยการกดและการบันทึกที่ไม่สนับสนุนและฉันสามารถใช้ regex เพื่อดึงกลับมาพร้อมกับการใช้:

วิธีการเก็บซ่อน Git เพื่อใช้ชื่อที่จะใช้

$ git stash push -m "john-hancock"

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

ดังที่ได้กล่าวมาแล้วคำสั่งบันทึกเลิกใช้แล้ว แต่ก็ยังใช้งานได้ดังนั้นคุณสามารถใช้สิ่งนี้กับระบบเก่าที่คุณไม่สามารถอัปเดตพวกเขาด้วยการโทรแบบกด ต่างจากคำสั่ง push ไม่จำเป็นต้องใช้สวิตช์ -m กับการบันทึก

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

มีปัญหากับป๊อปและวาง

ฉันไม่เชื่อว่ามันใช้งานได้กับป๊อป แต่ฉันคิดว่านั่นเป็นเพราะป๊อปทำงานได้ไม่ดีหลังจากการสมัครและ regex ไม่เป็นมิตร นั่นเป็นเพียงลางสังหรณ์ ฉันยังไม่ได้ทดสอบ

นี่คือ Git 2.2 และ Windows 10

หลักฐานภาพ

นี่คือภาพเคลื่อนไหว GIF ที่สวยงามที่แสดงให้เห็นถึงกระบวนการ

ลำดับเหตุการณ์

GIF ทำงานได้อย่างรวดเร็ว แต่ถ้าคุณมองกระบวนการก็คือ:

1. คำสั่ง ls แสดงไฟล์ 4 ไฟล์ในไดเรกทอรี
2. แตะ example.html เพิ่มไฟล์ที่ 5
3. git stash push -m "john-hancock" -a (-a มีไฟล์ที่ไม่ได้ติดตาม)
4. คำสั่ง ls แสดงไฟล์ 4 ไฟล์หลังจาก stash หมายถึง stash และการฮาร์ดรีเซ็ตโดยนัยทำงาน
5. git stash ใช้ stash ^ {/ john-hancock} วิ่ง
6. คำสั่ง ls แสดงรายการไฟล์ 5 ไฟล์ซึ่งแสดงไฟล์ example.html กลับมาซึ่งหมายความว่าคำสั่ง git stash Apply ใช้งานได้

มันสมเหตุสมผลหรือไม่

พูดตรงไปตรงมาฉันไม่แน่ใจว่าประโยชน์ของวิธีนี้คืออะไร มีค่าในการให้ชื่อที่ซ่อน แต่ไม่ใช่การดึง อาจจะเขียนสคริปต์กระบวนการที่จะเป็นประโยชน์ แต่ก็ยังง่ายกว่าที่จะเพียงแค่ป๊อปซ่อนโดยใช้ชื่อ

$ git stash pop 3
$ git stash apply 3

นั่นดูง่ายกว่าสำหรับฉันมากกว่า regex