Git හි නමකින් තොගයක් නම් කර නැවත ලබා ගන්නේ කෙසේද?

මම නිතරම සිතුවේ ඔබට එසේ කිරීමෙන් git stash save stashnameඔබට නමක් ලබා දිය හැකි බවත්, පසුව ඔබට එය කිරීමෙන් අයදුම් කළ හැකි git stash apply stashnameබවත්ය. නමුත් මෙම අවස්ථාවේ දී සිදු වන සියල්ල stashnameතොග විස්තරය ලෙස භාවිතා කරන බව පෙනේ .

ඇත්ත වශයෙන්ම තොගයක් නම් කිරීමට ක්‍රමයක් නැද්ද? එසේ නොවේ නම්, සමාන ක්‍රියාකාරීත්වයක් ලබා ගැනීමට ඔබ නිර්දේශ කරන්නේ කුමක්ද? අත්‍යාවශ්‍යයෙන්ම මා සතුව කුඩා තොගයක් ඇත, එය වරින් වර අයදුම් කිරීමට මා කැමතිය, නමුත් සෑම විටම git stash listඑහි සත්‍ය තොග අංකය කුමක් දැයි දඩයම් කිරීමට අවශ්‍ය නැත .

ඔබ එය කරන්නේ මෙයයි:

git stash save "my_stash"

"my_stash"ස්ටෑෂ් නම කොහෙද .

දැන ගැනීමට තවත් ප්‍රයෝජනවත් කරුණු කිහිපයක්: සියලුම තොග තොගයක් තුළ ගබඩා කර ඇත. වර්ගය:

git stash list

මෙය ඔබගේ සියලු කොටස් ලැයිස්තුගත කරනු ඇත.

තොගයක් යෙදීමට සහ එය තොග ගබඩාවෙන් ඉවත් කිරීමට, ටයිප් කරන්න:

git stash pop stash@{n}

තොගයක් යෙදීමට සහ එය තොග ගබඩාවේ තබා ගැනීමට, ටයිප් කරන්න:

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 පිටුව

එය ප්‍රමාණවත් තරම් වැදගත් යැයි ඔබට හැඟේ නම් ඔබට ශාඛාවක් ශාඛාවක් බවට පත් කළ හැකිය:

git stash branch <branchname> [<stash>]

මිනිසා පිටුවෙන්:

මෙම නිර්මාණය හා 'නමින් නව ශාඛා සිදු චෙක්පත් <branchname>ද දී ඇති නසා සිට ආරම්භ <stash>මුලින් නිර්මාණය කරන ලදී, වාර්තා වී ඇති වෙනස්කම් අදාළ <stash>නව කම්කරු ගස සහ දර්ශකය, පසුව පහළ බසී <stash>සාර්ථකව බව සූර්යයා නම්. කිසිවක් <stash>ලබා නොදුන් විට, නවතම එක අදාළ වේ.

git stash saveගැටුම් හේතුවෙන් git stash අදාළ වන පරිදි ඔබ ධාවනය කළ ශාඛාව ප්‍රමාණවත් ලෙස වෙනස් වී ඇත්නම් මෙය ප්‍රයෝජනවත් වේ . Git stash ක්‍රියාත්මක වන අවස්ථාවේ දී HEAD හි තිබූ බැඳීමට ඉහළින් මෙම තොගය යොදන බැවින්, එය ගැටුම්වලින් තොරව මුලින් ගබඩා කර ඇති තත්වය යථා තත්වයට පත් කරයි.

ඔබට පසුව මෙම නව ශාඛාව වෙනත් ස්ථානයකට නැවත ප්‍රතිස්ථාපනය කළ හැකිය.

ඔබගේ වර්තමාන වැඩ කරන පිටපත් වෙනස් කිරීම් කිහිපයක් හෝ සියල්ලම සුරැකීමට ඔබ සැහැල්ලු ක්‍රමයක් සොයන්නේ නම් සහ පසුව ඒවා නැවත ඉල්ලුම් කරන්නේ නම්, පැච් ගොනුවක් සලකා බලන්න:

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

# re-apply it later
git apply some.patch

සෑම විටම මම කල්පනා කරන්නේ මම මේ සඳහා ස්ටෑෂ් භාවිතා කළ යුතුද යන්නයි, එවිට ඉහත උමතුව වැනි දේවල් මා දකින අතර මා කරන දෙයින් මම සෑහීමට පත් වෙමි :)

තොග යනු ඔබට අවශ්‍ය පරිදි ස්ථිර දේවල් නොවේ. කොමිස් වල ටැග් භාවිතා කරමින් ඔබට වඩා හොඳ සේවාවක් ලැබෙනු ඇත. ඔබට ගබඩා කිරීමට අවශ්‍ය දේ සාදන්න. එයින් කැපවීමක් කරන්න. එම කැපවීම සඳහා ටැගයක් සාදන්න. ඉන්පසු ඔබේ ශාඛාව පෙරළන්න 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 සමඟ අනුකූල වේ

සංස්කරණය කරන්න: මම මගේ මුල් විසඳුමට ඇලී සිටියෙමි, නමුත් බහුතරයක් ඊතන් රයිස්නර්ගේ අනුවාදයට (ඉහළ) කැමති වීමට හේතුව මම දකිමි. එබැවින් වාර්තාව සඳහා පමණි:

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 listregex විසින් පළමු (වඩාත් ම මෑත) සොයා ගැනීමට 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")

නිසි ප්‍රති result ල කේත ආපසු ලබා දෙන බව සලකන්න, එවිට ඔබට මෙම විධාන වෙනත් ස්ක්‍රිප්ට් තුළ භාවිතා කළ හැකිය. විධාන ක්‍රියාත්මක කිරීමෙන් පසු මෙය සත්‍යාපනය කළ හැකිය:

echo $?

විචල්ය විස්තාරණ සූරාකෑම ගැන සැලකිලිමත් වන්න, මන්දයත් මට එම --grep=$1කොටස ගැන විශ්වාසයක් නොතිබුණි . එය එසේ විය හැකි --grep="$1"නමුත් එය රීජෙක්ස් පරිසීමකයන්ට බාධාවක් වේ දැයි මට විශ්වාස නැත (මම යෝජනා සඳහා විවෘතව සිටිමි).

මෙම පිළිතුර ක්ලෙමන් ස්ලාවික්ට බොහෝ සෙයින් ණයගැතියි. පිළිගත් පිළිතුර ගැන මා අදහස් දැක්වීමට ඉඩ තිබුනද මට තවම ප්‍රමාණවත් නියෝජිතයෙකු නොමැත :(

ඔබට ස්ටෑෂ් රීෆ් සොයා ගැනීමට git අන්වර්ථයක් එකතු කර පෙන්වීම, අයදුම් කිරීම, අතහැර දැමීම යනාදිය සඳහා වෙනත් අන්වර්ථ නාමවල භාවිතා කළ හැකිය.

[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>};රටාවට හේතුව හිස් නූලක් ආපසු නොපැමිණීම නිසා යමෙකු අපේක්ෂා කරන පරිදි අසමත් වීම වෙනුවට sshhow, sapply සහ sdrop නවතම තොගය ඉලක්ක කර ගැනීමට හේතු වේ.

ඉතින්, මෙම මාතෘකාව පිළිබඳ මෙතරම් ව්‍යාකූලත්වයක් පවතින්නේ මන්දැයි මට විශ්වාස නැත. මට a සහ අවලංගු කරන ලද දෙකම සමඟ නම්git stash කළ හැකි pushඅතර save, මට එය සමඟ ආපසු ඇද ගැනීමට රීජෙක්ස් භාවිතා කළ හැකියapply :

ඉල්ලුම් කිරීමට නමක් භාවිතා කිරීමට Git stash ක්‍රමය

$ git stash push -m "john-hancock"

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

එය කලින් සඳහන් කළ පරිදි, saveවිධානය අවලංගු කර ඇත, නමුත් එය තවමත් ක්‍රියාත්මක වේ, එබැවින් ඔබට pushඇමතුමකින් ඒවා යාවත්කාලීන කළ නොහැකි පැරණි පද්ධතිවල මෙය භාවිතා කළ හැකිය . pushවිධානය මෙන් නොව , -mස්විචය අවශ්‍ය නොවේ save.

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

මෙය Git 2.2 සහ Windows 10 ය.

දෘශ්‍ය සාධනය

ක්‍රියාවලිය නිරූපණය කරන ලස්සන සජීවිකරණ GIF මෙන්න.

සිදුවීම් අනුපිළිවෙල

GIF ඉක්මනින් ක්‍රියාත්මක වේ, නමුත් ඔබ බැලුවහොත්, ක්‍රියාවලිය මෙයයි:

1. මෙම lsබහලුම තුල විධාන දර්ශන 4 ගොනු
2. touch example.html 5 වන ගොනුවක් එක් කරයි
3. git stash push -m "john-hancock" -a (එම -a ඇතුළත් නොකළ ලිපිගොනු ඇතුළත් වේ)
4. මෙම lsමැට්ටෙක් පසු විධානය දර්ශන 4 ගොනු, මැට්ටෙක් හා ගම්ය දුෂ්කර යළි පිහිටුවීමේ වැඩ අර්ථය
5. git stash apply stash^{/john-hancock} ලකුණු
6. මෙම lsවිධානය ලැයිස්තු 5 ගොනු පෙන්වමින් example.html ගොනුව අර්ථය, ආපසු ගෙන එන ලදී git stash applyවිධානය වැඩ කළා.

මෙය පවා අර්ථවත්ද?

අවංකව කිවහොත්, මෙම ප්‍රවේශයේ වාසිය කුමක් දැයි මට විශ්වාස නැත. තොගයට නමක් ලබා දීමේ වටිනාකමක් ඇත, නමුත් ලබා ගැනීම නොවේ. සමහර විට රාක්කය සහ නොකැඩූ ක්‍රියාවලිය ස්ක්‍රිප්ට් කිරීම ප්‍රයෝජනවත් වනු ඇත, නමුත් නමකින් තොගයක් පොප් කිරීම තවමත් පහසුය.

$ git stash pop 3
$ git stash apply 3

එය රීජෙක්ස් වලට වඩා මට පහසු බව පෙනේ.

අන්වර්ථය මෙය ශ්‍රිතයක් තුළට සංයුක්ත කිරීමකින් තොරව යුනික්ස් වැනි පද්ධති සඳහා වඩාත් සෘජු වාක්‍ය ඛණ්ඩයක් විය හැකිය. [අන්වර්ථය] යටතේ ~ / .gitconfig වෙත පහත සඳහන් දෑ එක් කරන්න.

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

භාවිතය: sapply 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

මම කැමතියි තොගවල නම් දැක බලා තෝරා ගැනීමට. එසේම මම ෂෙල් භාවිතා කරන අතර ඉහත සමහර බාෂ් අන්වර්ථයන් භාවිතා කරන්නේ කෙසේදැයි අවංකවම දැන සිටියේ නැත;)

සටහන: කෙවින් පවසන පරිදි, ඔබ ඒ වෙනුවට ටැග් සහ චෙරි පික් භාවිතා කළ යුතුය.

පවර්ෂෙල් භාවිතයෙන් මෙය ඉටු කර ගත හැකි එක් ක්‍රමයක් මෙයයි:

<#
.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) විවෘත කර "පොප් ස්ටෑෂ්" ටයිප් කිරීමයි, ඔබට ඔබේ තොගය නමෙන් ලබා ගත හැක git CLI භාවිතා කිරීමේ අවශ්‍යතාවයකින් තොරව

git stash applyහැර වෙනත් යොමු කිරීම් සමඟ ද ක්‍රියා කරයි stash@{0}. එබැවින් නිරන්තර නමක් ලබා ගැනීම සඳහා ඔබට සාමාන්‍ය ටැග් භාවිතා කළ හැකිය . මෙය ඔබට අහම්බෙන් git stash dropහෝ git stash popඑය කළ නොහැකි වාසියක් ඇත.

එබැවින් ඔබට pstashමේ වගේ අන්වර්ථයක් අර්ථ දැක්විය හැකිය (aka "නිරන්තර stash"):

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

තොග නිර්මාණයට අමතරව සෑම දෙයක් සඳහාම, මම fzf හඳුන්වා දීමෙන් තවත් විසඳුමක් යෝජනා කරමි ලෙස . ඔබගේ කාලය මිනිත්තු 5 ක් ගත කර එය හඳුන්වා දීමට මම නිර්දේශ කරමි, මන්ද එය සියල්ලටම වඩා produc ලදායිතා බූස්ටරයකි.

කෙසේ වෙතත්, ඔවුන්ගේ නිදසුන් පිටුවෙන් අදාළ සෙවීමක් ඉදිරිපත් කරයි. අතිරේක ක්‍රියාකාරිත්වය එක් කිරීම සඳහා ස්ක්‍රිප්ට්ලට් එක වෙනස් කිරීම ඉතා පහසුය (ස්ටෑෂ් යෙදුම හෝ හැලීම වැනි):

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
}

මම හිතන්නේ නැහැ පොප් පොෂ් එකක් එහි නමින් ගිට් කිරීමට ක්‍රමයක් තියෙනවා කියලා.

මම එය කරන bash ශ්‍රිතයක් නිර්මාණය කර ඇත.

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

එය උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි!