මගේ ශාඛාවේ වෙනස් කළ ගොනු වලින් එකක් පමණක් ගබඩා කරන්නේ කෙසේද?

වියාචනය : පහත දැක්වෙන පිළිතුර git 2.13 ට පෙර git සඳහා වේ. Git 2.13 සහ ඊට වැඩි සඳහා, තවත් පිළිතුරක් තවත් පහළට බලන්න .

අවවාදයයි

අදහස් දැක්වීම්වල සඳහන් කර ඇති පරිදි, මෙය වේදිකාගත කර ඇති සහ වේදිකාගත නොවූ සෑම දෙයක්ම තොගයට දමයි. --Kep-index මඟින් තොගය අවසන් වූ පසු දර්ශකය තනිවම තබයි. ඔබ පසුව තොගය පොප් කරන විට මෙය ඒකාබද්ධ කිරීමේ ගැටුම් ඇති කළ හැකිය.

මෙය ඔබ මීට පෙර එකතු නොකළ සෑම දෙයක්ම තැන්පත් කරනු ඇත. git addඔබට තබා ගැනීමට අවශ්‍ය දේවල් පමණක් ක්‍රියාත්මක කරන්න.

git stash --keep-index

උදාහරණයක් ලෙස, ඔබට පැරණි බැඳීමක් එකකට වඩා වෙනස් කිරීමට අවශ්‍ය නම්, ඔබට මෙම ක්‍රියා පටිපාටිය භාවිතා කළ හැකිය:

1. git rebase -i <last good commit>
2. සමහර වෙනස්කම් ලෙස සලකුණු කරන්න edit.
3. git reset HEAD^
4. git add <files you want to keep in this change>
5. git stash --keep-index
6. අවශ්‍ය පරිදි දේවල් සකස් කරන්න. git addකිසිදු වෙනසක් කිරීමට අමතක නොකරන්න .
7. git commit
8. git stash pop
9. අවශ්‍ය පරිදි # 5 සිට නැවත කරන්න.
10. git rebase --continue

ඔබට ද භාවිතා කළ හැකිය git stash save -p "my commit message". මේ ආකාරයෙන් ඔබට තොග එකතු කළ යුත්තේ කුමන හන්කද යන්න තෝරා ගත හැකිය, සම්පූර්ණ ලිපිගොනුද තෝරා ගත හැකිය.

එක් එක් හන්ක් සඳහා ක්‍රියා කිහිපයක් ඔබෙන් විමසනු ඇත:

   y - stash this hunk
   n - do not stash this hunk
   q - quit; do not stash this hunk or any of the remaining ones
   a - stash this hunk and all later hunks in the file
   d - do not stash this hunk or any of the later hunks in the file
   g - select a hunk to go to
   / - search for a hunk matching the given regex
   j - leave this hunk undecided, see next undecided hunk
   J - leave this hunk undecided, see next hunk
   k - leave this hunk undecided, see previous undecided hunk
   K - leave this hunk undecided, see previous hunk
   s - split the current hunk into smaller hunks
   e - manually edit the current hunk
   ? - print help

Git මූලික වශයෙන් සියලු නිධිය අන්තර්ගතය සහ දර්ශකය කළමනාකරණය කිරීම (සහ ගොනු එකක් හෝ කිහිපයක් නොවේ), git stashගනුදෙනු කිරීම පුදුමයක් නොවේ.සියලු වැඩ කරන නාමාවලිය සමඟ.

ඇත්තටම, Git 2.13 (Q2 2017) සිට, ඔබ තනි තනි ගොනු, සමග මත්කුඩු ග්රෑම් හැකි git stash push:

git stash push [--] [<pathspec>...]

pathspec' git stash push' වෙත ලබා දුන් විට , නව ස්ටෑෂ් විසින් වෙනස් කරන ලද තත්වයන් සටහන් කරන්නේ මාර්ගයට ගැලපෙන ලිපිගොනු සඳහා පමණි. වැඩි විස්තර සඳහා " විශේෂිත ලිපිගොනු වල වෙනස්කම් " බලන්න .

සරල කළ උදාහරණය:

 git stash push path/to/file

මෙම විශේෂාංගය සඳහා වන පරීක්ෂණ අවස්ථාව තවත් විකල්ප කිහිපයක් පෙන්වයි:

test_expect_success 'stash with multiple pathspec arguments' '
    >foo &&
    >bar &&
    >extra &&
    git add foo bar extra &&

    git stash push -- foo bar &&   

    test_path_is_missing bar &&
    test_path_is_missing foo &&
    test_path_is_file extra &&

    git stash pop &&
    test_path_is_file foo &&
    test_path_is_file bar &&
    test_path_is_file extra

මුල් පිළිතුර (පහත, 2010 ජුනි) ඔබට ගබඩා කිරීමට අවශ්‍ය දේ අතින් තෝරා ගැනීමයි.

කේස්බෑෂ් අදහස්:

මෙය ( stash --patchමුල් විසඳුම) හොඳයි, නමුත් බොහෝ විට මම ලිපිගොනු විශාල ප්‍රමාණයක් වෙනස් කර ඇති නිසා පැච් භාවිතා කිරීම කරදරකාරී වේ

bukzor ගේ පිළිතුර (ඉහළට, 2011 නොවැම්බර්)
git add+git stash --keep-index මත පදනම්ව වඩාත් ප්‍රායෝගික විසඳුමක් යෝජනා කරයි .
ගොස් ඔහුගේ පිළිතුර ඉහළට ඔසවන්න, එය නිල පිළිතුර විය යුතුය (මගේ වෙනුවට).

එම විකල්පය ගැන, chhh අදහස් දැක්වීම්වල විකල්ප කාර්ය ප්‍රවාහයක් පෙන්වා දෙයි:

git reset --softඔබේ පැහැදිලි වේදිකාව නැවත ලබා ගැනීම සඳහා ඔබ එවැනි තොගයක් පසු කළ යුතුය :
පැහැදිලි වේදිකා ප්‍රදේශයක් වන සහ තෝරා නොගත් වේදිකාගත නොකළ වෙනස් කිරීම් කිහිපයක් සහිත මුල් තත්වයට පත්වීම සඳහා යමෙකුට දර්ශකය ලබා ගැනීම සඳහා මෘදු ලෙස නැවත සැකසිය හැකිය (නොමැතිව) ඔබ වැනි ඕනෑම දෙයක් කිරීම - බුසෝර් - කළා).

(මුල් පිළිතුර 2010 ජුනි: අත්පොත)

එහෙත්, git stash save --patchඔබට පසුව ඇති අර්ධ වශයෙන් මුදල් ඉපයීම ලබා ගත හැකිය:

සමඟ --patch, ඔබට HEAD සහ වැඩ කළ ගස අතර ඇති වෙනසෙහි සිට අන්තර්ක්‍රියාකාරීව තෝරා ගත හැකිය.
තොග ඇතුළත් කිරීම ඉදිකර ඇත්තේ එහි දර්ශක තත්වය ඔබේ ගබඩාවේ දර්ශක තත්වයට සමාන වන අතර එහි වැඩ කොටසෙහි අඩංගු වන්නේ ඔබ අන්තර්ක්‍රියාකාරීව තෝරාගත් වෙනස්කම් පමණි. තෝරාගත් වෙනස්කම් ඔබගේ වැඩපලෙන් ආපසු පෙරළනු ලැබේ.

කෙසේ වෙතත් එය සම්පූර්ණ දර්ශකය සුරකිනු ඇත (එය දැනටමත් සුචිගත කර ඇති වෙනත් ලිපිගොනු ඇතුළත් විය හැකි බැවින් ඔබට අවශ්‍ය දේ නොවිය හැක), සහ අර්ධ වැඩපොළක් (ඔබට ගබඩා කිරීමට අවශ්‍ය එක මෙන් පෙනේ).

git stash --patch --no-keep-index

වඩා හොඳ සුදුසුකමක් විය හැකිය.

ක්‍රියා නොකරන්නේ නම් --patch, අතින් ක්‍රියාවලියක් විය හැකිය:

ලිපිගොනු එකක් හෝ කිහිපයක් සඳහා, අතරමැදි විසඳුමක් වනුයේ:

• ඒවා Git repo වලින් පිටත පිටපත් කරන්න
  (ඇත්ත වශයෙන්ම, eleotlecram සිත්ගන්නා විකල්පයක් යෝජනා කරයි )
• git stash
• ඒවා නැවත පිටපත් කරන්න
• git stash # මෙවර, ඔබට අවශ්‍ය ගොනු පමණක් ගබඩා කර ඇත
• git stash pop stash@{1} # ඔබගේ සියලුම ගොනු වෙනස් කිරීම් නැවත අයදුම් කරන්න
• git checkout -- afile ඕනෑම දේශීය වෙනස් කිරීමකට පෙර ගොනුව HEAD අන්තර්ගතයට නැවත සකසන්න

එම තරමක් අවුල් සහගත ක්‍රියාවලිය අවසානයේදී, ඔබ සතුව ඇත්තේ ගොනු එකක් හෝ කිහිපයක් පමණි.

විට git stash -p(හෝ git add -pසමග stash --keep-index) ඉතා කරදරකාරී වීම වනු ඇත, මම එය භාවිතා කිරීම පහසු සොයා diff, checkoutසහ apply:

විශේෂිත ගොනුවක් "ගබඩා කිරීම" සඳහා / dir පමණි:

git diff path/to/dir > stashed.diff
git checkout path/to/dir

ඉන්පසු

git apply stashed.diff

git stash pushමේ වගේ භාවිතා කරන්න :

git stash push [--] [<pathspec>...]

උදාහරණයක් වශයෙන්:

git stash push -- my/file.sh

මෙය 2017 වසන්තයේ දී නිකුත් කරන ලද Git 2.13 සිට ලබා ගත හැකිය.

අපි ඔබට ලිපිගොනු 3 ක් ඇති බව කියමු

a.rb
b.rb
c.rb

ඔබට අවශ්‍ය වන්නේ b.rb සහ c.rb පමණක් වන නමුත් a.rb නොවේ

ඔබට මේ වගේ දෙයක් කළ හැකිය

# commit the files temporarily you don't want to stash
git add a.rb
git commit -m "temp" 

# then stash the other files
git stash save "stash message"

# then undo the previous temp commit
git reset --soft HEAD^
git reset

ඔබ ඉවරයි! HTH.

මෙය කිරීමට තවත් ක්‍රමයක්:

# Save everything
git stash 

# Re-apply everything, but keep the stash
git stash apply

git checkout <"files you don't want in your stash">

# Save only the things you wanted saved
git stash

# Re-apply the original state and drop it from your stash
git stash apply stash@{1}
git stash drop stash@{1}

git checkout <"files you put in your stash">

මම (නැවත වරක්) මෙම පිටුවට පැමිණ පළමු පිළිතුරු දෙකට අකමැති වීමෙන් පසුව මම මෙය ඉදිරිපත් කළෙමි (පළමු පිළිතුර ප්‍රශ්නයට පිළිතුරු නොදෙන අතර -pඅන්තර්ක්‍රියාකාරී මාදිලිය සමඟ වැඩ කිරීමට මා අකමැති විය ).

OvVonC විසින් ගබඩාවෙන් පිටත ලිපිගොනු භාවිතා කිරීමට යෝජනා කළ දෙයට සමාන අදහසක්, ඔබට අවශ්‍ය වෙනස්කම් කොහේ හරි සුරකින්න, ඔබේ තොගයේ අවශ්‍ය නොවන වෙනස්කම් ඉවත් කරන්න, ඉන්පසු ඔබ ඉවත් කළ වෙනස්කම් නැවත යොදන්න. කෙසේ වෙතත්, මම "කොහේ හරි" ලෙස git stash භාවිතා කළෙමි (එහි ප්‍රති result ලයක් වශයෙන්, අවසානයේ එක් අමතර පියවරක් ඇත: ඔබ තොගයේ දමා ඇති කැන්ජ් ඉවත් කිරීම, මන්ද ඔබ මේවාද ඉවතට ගෙන ගිය හෙයිනි).

යාවත්කාලීන කිරීම (2/14/2015) - ගැටුම් පිළිබඳ සිද්ධිය වඩා හොඳින් හසුරුවා ගැනීම සඳහා මම පිටපත ටිකක් නැවත ලියා ඇත, ඒවා දැන් ඉදිරිපත් කළ යුත්තේ .rej ගොනු වලට වඩා නොගැලපෙන ගැටුම් ලෙස ය.

@ බුසෝර්ගේ ප්‍රවේශයේ ප්‍රතිලෝම කිරීම බොහෝ විට මට වඩාත් බුද්ධිමත් ය. එනම්, යම් යම් වෙනස්කම් සිදු කිරීම, පසුව සිදු කරන ලද වෙනස්කම් පමණක් තැන්පත් කිරීම.

අවාසනාවකට මෙන්, git විසින් git stash --only-index හෝ ඊට සමාන ඉදිරිපත් නොකරයි, එබැවින් මෙය සිදු කිරීම සඳහා මම ස්ක්‍රිප්ට් එකක් කසයෙන් තළමි.

#!/bin/sh

# first, go to the root of the git repo
cd `git rev-parse --show-toplevel`

# create a commit with only the stuff in staging
INDEXTREE=`git write-tree`
INDEXCOMMIT=`echo "" | git commit-tree $INDEXTREE -p HEAD`

# create a child commit with the changes in the working tree
git add -A
WORKINGTREE=`git write-tree`
WORKINGCOMMIT=`echo "" | git commit-tree $WORKINGTREE -p $INDEXCOMMIT`

# get back to a clean state with no changes, staged or otherwise
git reset -q --hard

# Cherry-pick the index changes back to the index, and stash.
# This cherry-pick is guaranteed to succeed
git cherry-pick -n $INDEXCOMMIT
git stash

# Now cherry-pick the working tree changes. This cherry-pick may fail
# due to conflicts
git cherry-pick -n $WORKINGCOMMIT

CONFLICTS=`git ls-files -u`
if test -z "$CONFLICTS"; then
    # If there are no conflicts, it's safe to reset, so that
    # any previously unstaged changes remain unstaged
    #
    # However, if there are conflicts, then we don't want to reset the files
    # and lose the merge/conflict info.
    git reset -q
fi

ඔබට ඉහත පිටපත git-stash-indexඔබගේ මාර්ගයේ කොතැනක හෝ සුරැකිය හැකි අතර පසුව එය git stash-index ලෙස භාවිතා කළ හැකිය

# <hack hack hack>
git add <files that you want to stash>
git stash-index

දැන් ස්ටෑෂ් හි නව ප්‍රවේශයක් අඩංගු වන අතර එය ඔබ විසින් සිදු කරන ලද වෙනස්කම් පමණක් අඩංගු වන අතර ඔබේ වැඩ කරන ගසෙහි තවමත් අස්ථායී වෙනස්කම් තිබේ.

සමහර අවස්ථා වලදී, වැඩ කරන ගස් වෙනස්වීම් දර්ශක වෙනස්වීම් මත රඳා පවතී, එබැවින් ඔබ දර්ශක වෙනස්වීම් වලක්වන විට, වැඩ කරන ගස් වෙනස්වීම් ගැටුමක් ඇති කරයි. මෙම අවස්ථාවේදී, ඔබට git merge / git mergetool / etc සමඟ විසඳා ගත හැකි සුපුරුදු නොවිසඳුනු ගැටුම් ඔබට ලැබෙනු ඇත.

ඔබගේ ගබඩා කර ඇති වෙනස්කම් සමඟ පණිවිඩයක් සඳහන් කිරීමට ඔබට අවශ්‍ය නැතිනම්, ද්විත්ව ඉරකින් පසු ගොනු නාමය පසු කරන්න.

$ git stash -- filename.ext

එය හඳුනා නොගත් / නව ගොනුවක් නම්, ඔබට එය පළමුව වේදිකා ගත කිරීමට සිදුවේ.

මෙම ක්‍රමය 2.13+ git අනුවාද වල ක්‍රියාත්මක වේ

Git හි ශාඛා සෑදීම ඉතා සුළු බැවින් ඔබට තාවකාලික ශාඛාවක් සාදා ඒ තුළට තනි ලිපිගොනු පරීක්ෂා කළ හැකිය.

ඔබට මෙය සරලව කළ හැකිය:

git stash push "filename"

හෝ විකල්ප පණිවිඩයක් සමඟ

git stash push -m "Some message" "filename"

පහත කේතය ගොනුවකට සුරකින්න, උදාහරණයක් ලෙස නම් කර stashඇත. භාවිතය stash <filename_regex>. තර්කය යනු ගොනුවේ සම්පූර්ණ මාර්ගය සඳහා නිත්‍ය ප්‍රකාශනයයි. උදාහරණයක් ලෙස, a / b / c.txt, stash a/b/c.txtහෝ stash .*/c.txt, ආදිය ගබඩා කිරීම .

$ chmod +x stash
$ stash .*.xml
$ stash xyz.xml

ගොනුවට පිටපත් කිරීමට කේතය:

#! /usr/bin/expect --
log_user 0
set filename_regexp [lindex $argv 0]

spawn git stash -p

for {} 1 {} {
  expect {
    -re "diff --git a/($filename_regexp) " {
      set filename $expect_out(1,string)
    }
    "diff --git a/" {
      set filename ""
    }
    "Stash this hunk " {
      if {$filename == ""} {
        send "n\n"
      } else {
        send "a\n"
        send_user "$filename\n"
      }
    }
    "Stash deletion " {
      send "n\n"
    }
    eof {
      exit
    }
  }
}

ඔබ සැබවින්ම අදහස් කරන්නේ ඔබ භාවිතා කරන සෑම විටම වෙනස්කම් ඉවතලන්නgit stash (සහ එය තාවකාලිකව ගබඩා කිරීම සඳහා git stash භාවිතා නොකරන්න), එවැනි අවස්ථාවකදී ඔබට භාවිතා කළ හැකිය

git checkout -- <file>

[ සටහන ]

එය git stashඅතු බෙදීම හා කිරීම සඳහා ඉක්මන් හා සරල විකල්පයකි.

Git repo එකෙන් පිටත ලිපිගොනු පිටපත් කිරීමේ VonC හි 'අතරමැදි' විසඳුමේ ඇති ගැටළුව නම්, ඔබට මාර්ග තොරතුරු අහිමි වීමයි, එමඟින් ලිපිගොනු පොකුරක් පසුකාලීනව යම් කරදරයකින් පිටපත් කිරීම සිදු කරයි.

පිටපතක් වෙනුවට තාර භාවිතා කිරීම පහසු බව සොයා ගැනීම (සමාන මෙවලම් බොහෝ විට කරනු ඇත):

• tar cvf /tmp/stash.tar path / to / some / file path / to / some / other / file (... etc.)
• git checkout path / to / some / file path / to / some / other / file
• git stash
• tar xvf /tmp/stash.tar
• ආදිය (VonC හි 'අතරමැදි' යෝජනාව බලන්න)

සමහර විට මම එය සිදු කිරීමට පෙර මගේ ශාඛාවේ සම්බන්ධයක් නැති වෙනසක් කර ඇති අතර, එය වෙනත් ශාඛාවකට ගෙන ගොස් වෙනමම (ස්වාමියා වැනි) කැප කිරීමට මට අවශ්‍යය. මම මෙය කරමි:

git stash
git checkout master
git stash pop
git add <files that you want to commit>
git commit -m 'Minor feature'
git stash
git checkout topic1
git stash pop
...<resume work>...

පළමුවැන්න stashසහ stash popඉවත් කළ හැකි බව සලකන්න, ඔබ පිටවීමේදී ඔබගේ සියලු වෙනස්කම් masterශාඛාවට ගෙන යා හැකිය , නමුත් ගැටුම් නොමැති නම් පමණි. අර්ධ වෙනස්කම් සඳහා ඔබ නව ශාඛාවක් නිර්මාණය කරන්නේ නම් ඔබට තොගය අවශ්‍ය වේ.

ගැටුම් හා නව ශාඛාවක් නොමැති බව උපකල්පනය කර ඔබට එය සරල කළ හැකිය:

git checkout master
git add <files that you want to commit>
git commit -m 'Minor feature'
git checkout topic1
...<resume work>...

ස්ටෑෂ් පවා අවශ්‍ය නොවේ ...

SourceTree භාවිතයෙන් පියවර 3 කින් මෙය පහසුවෙන් කළ හැකිය.

1. ඔබට අවශ්‍ය නැති සියල්ල තාවකාලිකව කරන්න.
2. Git අනෙක් සියල්ල එකතු කරන්න, ඉන්පසු එය ගබඩා කරන්න.
3. ඔබගේ තාවකාලික එකකට පෙර බැඳීම ඉලක්ක කර ගනිමින්, git reset ධාවනය කිරීමෙන් ඔබගේ තාවකාලික කැපවීම සිදු කරන්න.

මේ සියල්ල SourceTree හි තත්පර කිහිපයකින් කළ හැකිය, එහිදී ඔබට එකතු කිරීමට අවශ්‍ය ලිපිගොනු (හෝ තනි රේඛා) මත ක්ලික් කළ හැකිය. එකතු කළ පසු, ඒවා තාවකාලික කැපවීමකට යොමු කරන්න. ඊළඟට, සියලු වෙනස්කම් එක් කිරීමට පිරික්සුම් කොටුව ක්ලික් කරන්න, ඉන්පසු සියල්ල ගොඩගැසීමට stash ක්ලික් කරන්න. තැන්පත් කර ඇති වෙනස්වීම් සමඟ, ඔබගේ බැඳීම් ලැයිස්තුව දෙස බලා ඔබගේ තාවකාලික කැපවීමට පෙර කැපවීම සඳහා හැෂ් සටහන් කරන්න, ඉන්පසු 'git reset hash_b4_temp_commit' ධාවනය කරන්න, එය මූලික වශයෙන් ඔබේ ශාඛාව නැවත සකස් කිරීමෙන් බැඳීම "පැනීම" වැනි ය. ඊට පෙර කැප වන්න. දැන්, ඔබට ඉතිරි කිරීමට අවශ්‍ය නැති දේවල් පමණක් ඉතිරිව ඇත.

මම පාවිච්චි කරනවා git stash save --patch. අන්තර්ක්‍රියාකාරිත්වය කරදරකාරී යැයි මට නොපෙනේ, මන්දයත් අපේක්ෂිත මෙහෙයුම සම්පූර්ණ ලිපිගොනු වලට යෙදීම සඳහා විකල්ප ඇති බැවිනි.

මෙහි සෑම පිළිතුරක්ම එතරම් සංකීර්ණයි ...

"ගොඩගැසීමට" මේ ගැන කුමක් කිව හැකිද:

git diff /dir/to/file/file_to_stash > /tmp/stash.patch
git checkout -- /dir/to/file/file_to_stash

ගොනුව නැවත වෙනස් කිරීම සඳහා මෙය වෙනස් වේ:

git apply /tmp/stash.patch

එක් ගොනුවක් ගබඩා කර එය නැවත ඇතුල් කිරීම වැනි එකම හැසිරීම.

මම මේ සඳහා පිළිතුරු සහ අදහස් සහ ඒ හා සමාන නූල් ගණනාවක් සමාලෝචනය කර ඇත්තෙමි. කිසියම් නිශ්චිත ලුහුබැඳ ඇති / සොයා නොගත් ලිපිගොනු ගබඩා කිරීමට හැකිවීම සඳහා පහත දැක්වෙන විධානයන් කිසිවක් නිවැරදි නොවන බව මතක තබා ගන්න :

• git stash -p (--patch): හඳුනා නොගත් ලිපිගොනු හැර, අතින් අතින් තෝරන්න
• git stash -k (--keep-index): ලුහුබැඳ ඇති / සොයා නොගත් සියලුම ලිපිගොනු තැන්පත් කර ඒවා වැඩ කරන නාමාවලියෙහි තබා ගන්න
• git stash -u (--include-untracked): ලුහුබැඳ ඇති / සොයා නොගත් සියලුම ගොනු ගබඩා කරන්න
• git stash -p (--patch) -u (--include-untracked): අවලංගු විධානය

දැනට, නිශ්චිත ලුහුබැඳ ඇති / සොයා නොගත් ලිපිගොනු ගබඩා කිරීමට හැකි වඩාත් සාධාරණ ක්‍රමය වන්නේ:

• ඔබට ගබඩා කිරීමට අවශ්‍ය නොවන ලිපිගොනු තාවකාලිකව සිදු කරන්න
• එකතු කරන්න
• තාවකාලික කැපවීම කරන්න

මම තවත් ප්රශ්නයකට පිළිතුරක් දී මෙම ක්රියාවලිය සඳහා සරල තිර රචනය ලියා , එහි සිටින මෙතන SourceTree අනුගමනය කරන ලද ක්රියා පටිපාටිය සිදු කිරීම සඳහා පියවර .

විසඳුමක්

දේශීය වෙනස්කම්:

• file_A (වෙනස් කරන ලද) වේදිකාගත කර නොමැත
• file_B (වෙනස් කරන ලදි) වේදිකාගත කර නොමැත
• file_C (වෙනස් කරන ලදි) වේදිකාගත කර නොමැත

File_C හි වෙනස්කම් පමණක් සහිත "my_stash" තොගයක් සෑදීමට :

1. git add file_C
2. git stash save --keep-index temp_stash
3. git stash save my_stash
4. git stash pop stash@#{1}

සිදු විය.

පැහැදිලි කිරීම

1. වේදිකා ප්‍රදේශයට file_C එක් කරන්න
2. "temp_stash" නමින් තාවකාලික තොගයක් සාදන්න සහ ගොනු_සී හි වෙනස්කම් තබා ගන්න
3. file_C හි වෙනස්කම් පමණක් සහිතව අවශ්‍ය තොගය ("my_stash") සාදන්න
4. ඔබගේ දේශීය කේතයේ "temp_stash" (file_A සහ file_B) හි වෙනස්කම් යොදන්න

සිදුවන්නේ කුමක්දැයි බැලීමට ඔබට පියවර අතර git තත්ත්වය භාවිතා කළ හැකිය .

ඔබ ශාඛා දෙකක් අතර මාරු වීමට උත්සාහ කරන විට, මෙම තත්වය ඇතිවේ.

" git add filepath" භාවිතා කරමින් ගොනු එක් කිරීමට උත්සාහ කරන්න .

පසුව මෙම රේඛාව ක්‍රියාත්මක කරන්න

git stash --keep-index

තනි ගොනු භාවිතයක් ගොඩගැසීමට git stash --patch [file].

මෙය විමසීමට යන්නේ : Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]? ?. ටයිප් කරන්න a(මෙම හන්ක් එක සහ පසුව ඇති සියලුම හන්ක්ස් ගොනුවේ තැන්පත් කරන්න) එවිට ඔබ හොඳින්.

ඒ හා සමාන තත්වයක්. කැපවී තේරුම් ගත්තා එය අවුලක් නොවන බව.

git commit -a -m "message"
git log -p

පිළිතුරු මත පදනම්ව මෙය මට උපකාර විය.

# revert to previous state, keeping the files changed
git reset HEAD~
#make sure it's ok
git diff
git status
#revert the file we don't want to be within the commit
git checkout specs/nagios/nagios.spec
#make sure it's ok
git status
git diff
#now go ahead with commit
git commit -a -m "same|new message"
#eventually push tu remote
git push

මෙම තත්වය තුළ මම git add -p(අන්තර්ක්‍රියාකාරී), git commit -m blahපසුව අවශ්‍ය නම් ඉතිරිව ඇති දේ ගබඩා කරන්න.

විධාන රේඛාවෙන් එය කරන්නේ කෙසේදැයි මම නොදනිමි, SourceTree භාවිතා කිරීම පමණි. ඔබ A ගොනුව වෙනස් කර ඇති බවත්, B ගොනුවේ වෙනස් කිරීමේ හන්ක් දෙකක් ඇති බවත් කියමු. ඔබට B ගොනුවේ දෙවන හක්ක පමණක් තබා අනෙක් සියල්ල අතපසු කිරීමට අවශ්‍ය නම්, මෙය කරන්න:

1. සෑම දෙයක්ම වේදිකා ගත කරන්න
2. A ගොනුවේ ඇති සියලුම වෙනස්කම් අහෝසි කරන ඔබගේ වැඩ කරන පිටපතෙහි වෙනස්කම් සිදු කරන්න. (උදා: බාහිර වෙනස මෙවලම දියත් කර ගොනු ගැලපෙන්න.)
3. B ගොනුව පෙනෙන්නේ එයට දෙවන වෙනසක් පමණක් යොදන ආකාරයට ය. (උදා: බාහිර වෙනස මෙවලම දියත් කර පළමු වෙනස අහෝසි කරන්න.)
4. "වේදිකාගත වෙනස්කම් තබා ගන්න" භාවිතා කරමින් තොගයක් සාදන්න.
5. සෑම දෙයක්ම අස්ථිර කරන්න
6. කළා!

git add .                           //stage all the files
git reset <pathToFileWillBeStashed> //unstage file which will be stashed
git stash                           //stash the file(s)
git reset .                         // unstage all staged files
git stash pop                       // unstash file(s)

එක් සංකීර්ණ ක්‍රමයක් වනුයේ පළමුව සියල්ල කැප කිරීමයි:

git add -u
git commit // creates commit with sha-1 A

මුල් බැඳීම වෙත නැවත සකසන්න, නමුත් නව බැඳීමෙන් the_one_file පරීක්ෂා කරන්න:

git reset --hard HEAD^
git checkout A path/to/the_one_file

දැන් ඔබට the_one_file ගබඩා කළ හැකිය:

git stash

මුල් බැඳීමට නැවත සැකසීමේදී ඔබගේ ගොනු පද්ධතියේ කැපවූ අන්තර්ගතය සුරැකීමෙන් පිරිසිදු කිරීම:

git reset --hard A
git reset --soft HEAD^

ඔව්, තරමක් අමුතුයි ...

මට අවශ්‍ය දේ වීමට පිළිතුරක් මට හමු නොවූ අතර එය එතරම් පහසු ය:

git add -A
git reset HEAD fileThatYouWantToStash
git commit -m "committing all but one file"
git stash

මෙය හරියටම එක් ගොනුවක් ගබඩා කරයි.

ඉක්මන් පිළිතුර

නිශ්චිත වෙනස් කළ ගොනුවක් git වලින් ආපසු හැරවීම සඳහා, ඔබට පහත පේළිය කළ හැකිය:

git checkout <branch-name> -- <file-path>

මෙන්න සැබෑ උදාහරණයක්:

git checkout master -- battery_monitoring/msg_passing.py

ඔබට වෙනස් කළ ලිපිගොනු කිහිපයක් ගබඩා කිරීමට අවශ්‍ය නම්, හුදෙක්

ඔබට ගබඩා කිරීමට අවශ්‍ය නැති ලිපිගොනු එකතු කරන්න, අදියර , ඉන්පසු ක්‍රියාත්මක කරන්නgit stash save --keep-index

එය සියලු වෙනස් නොකළ ගොනු ගබඩා කරනු ඇත