Git
Chapters ▾ 2nd Edition

7.3 Mga Git na Kasangkapan - Pag-stash at Paglilinis

Pag-stash at Paglilinis

Kadalasan, kapag nagtatrabaho ka sa bahagi ng iyong proyekto, ang mga bagay ay nasa isang kalat na estado at gusto mong lumipat ng mga branch para sa isang kaunting trabaho upang magtrabaho sa ibang bagay. Ang problema ay, hindi mo gustong gumawa ng isang commit sa kalahating natapos na trabaho para lamang makuha mong bumalik sa punto ito mamaya. Ang sagot sa isyung ito ay ang utos na git stash.

Kumukuha ang pag-stash ng maruming estado ng iyong gumaganang direktoryo — iyon ay, ang iyong binagong sinusubaybayan na mga file at mga naka-stage na mga pagbabago — at i-save ito sa isang stack ng mga hindi natapos ng mga pagbabago na maaari mong muling ilapat sa anumang oras (kahit na sa ibang branch).

Example 11. Paglilipat sa git stash push

Sa huling Oktubre 2017, nagkaroon ng malawak na talakayan sa listahan ng pag-mail ng Git, kung saan ang utos na git stash save ay hindi na magagamit na pabor sa umiiral na alternatibong git stash push. Ang pangunahing dahilan para rito ay ang git stash push ay nagpapakilala ng opsyon sa pag-stash ng napiling pathspecs, isang bagay na hindi suportado ng git stash save.

Ang git stash save ay hindi aalis sa anumang oras sa lalong madaling panahon, kaya huwag mag-alala tungkol dito na biglang mawawala. Ngunit maaaring gusto mong simulan ang paglipat sa alternibo na push para sa bagong pag-andar.

Pag-stash ng Iyong Trabaho

Upang ipakita ang pag-stash, pupunta ka sa iyong proyekto at simulan ang pagtatrabaho sa isang iilang mga file at posibleng i-stage ang isa sa mga pagbabago. Kung papatakbuhin mo ang git status, makikita mo ang iyong maruming estado:

$ git status
Ang mga pagbabagong dapat i-commit:
  (gumamit ng "git reset HEAD <file>..." upang mag-unstage)

	nabago:   index.html

Mga pagbabago na hindi na-stage para sa commit:
  (gumamit ng "git add <file>..." upang ma-update kung ano ang iko-commit)
  (gumamit ng "git checkout -- <file>..." upang iwaksi ang mga pagbababago sa iyong tinatrabahong direktoryo)

	nabago:   lib/simplegit.rb

Ngayon nais mong magpalit ng mga branch, ngunit hindi mo pa gusto na i-commit kung ano ang iyong tinatrabaho; kaya i-stash mo ang iyong mga pagbabago. Para mag-push ng isang bagong stash sa iyong stack, patakbuhin ang git stash o git stash save:

$ git stash
Naka-save na gumaganang direktoryo at estado ng indeks \
  "WIP sa master: 049d078 idinagdag ang indeks na file"
Ang HEAD ngayon ay nasa 049d078 na nagdagdag sa indeks na file
(Upang maibalik ang mga ito, magtipa ng "git stash apply")

Maaari mo ng makita na ang iyong gumaganang direktoryo ay malinis:

$ git status
# Sa branch na master
walang mai-commit, malinis ang gumaganang direktoryo

Sa puntong ito, maaari kang magpalit ng mga branch at magtrabaho sa ibang lugar; ang iyong mga pagbabago ay naka-imbak sa iyong stack Upang makita kung anong mga stash na iyong inimbak, maaari kang gumamit ng git stash list:

$ git stash list
stash@{0}: WIP sa master: 049d078 idinagdag ang indeks na file
stash@{1}: WIP sa master: c264051 Ibalik ang "idinagdag ang file_size"
stash@{2}: WIP sa master: 21d80a5 idinagdag ang bilang sa log

Sa kasong ito, dalawang stash ang natapos sa nakaraan, kaya mayroon kang access sa tatlong iba’t-ibang naka-stash na mga trabaho. Maaari mo muling ilapat ang isa na iyong na-stash sa pamamagitan ng paggamit ng utos na ipanapakita sa output ng tulong ng orihinal na utos ng stash: git stash apply. Kung nais mo na ilapat ang isa sa mas lumang mga stash, maaari mong matukoy ito sa pamamagitan ng pagbibigay ng pangalan nito, tulad nito: git stash apply stash@{2}. Kung hindi ka nagtukoy ng isang stash, ipinagpapalagay ng Git ang pinakabago na stash at sinusubukan na ilapat ito:

$ git stash apply
Sa branch master
Ang mga pagbabago ay hindi na-stage para sa commit:
  (gumamit ng "git add <file>..." upang ma-update kung ang mako-commit)
  (gumamit ng "git checkout -- <file>..." upang iwaksi ang mga pagbabago sa gumaganang direktoryo)

	nabago:   index.html
	nabago:   lib/simplegit.rb

walang naidagdag na mga pagbabago sa commit (gumamit ng "git add" at/o "git commit -a")

Maaari mong makita na ang Git ay nagbabago muli ng mga file na iyong ibinalik kapag ikaw ay nag-save ng stash. Sa kasong ito, mayroon kang isang malinis na gumaganang direktoryo kapag sinubukan mo na mag-lapat ng stash, at sinubukan mo na ilapat ito sa parehong branch kung saan mo ito si-nave. Ang pagkakaroon ng isang malinis na gumaganang direktoryo at paglalapat nito sa parehong branch ay hindi kinakailangan upang matagumpay na maglapat ng isang stash. Maaari mo i-save ang isang stash sa isang branch, palitan sa ibang branch mamaya, at subukan na muling ilapat ang mga pagbabago. Maaari mo ka ring magkaroon ng mga file na binago o hindi na-commit sa iyong gumaganang direktoryo kapag ikaw ay naglapat ng isang stash — Binibigyan ka ng Git ng mga kasalungatan sa pag-merge kung hindi na mailalapat nang malinis.

Ang mga pagbabago sa iyong mga file ay muli ng nailapat, ngunit ang file na naka-stage noon ay hindi na muling ma-stage. Upang gawin iyon, dapat mong patakbuhin ang utos na git stash apply na may isang opsyon na --index upang sabihan ang utos na subukan na muling ilapat ang naka-stage na mga pagbabago. Kung sa halip ay napatakbo mo ito , naibalik ka sa iyong orihinal na posisyon:

$ git stash apply --index
Sa branch master
Ang mga pagbabago na i-commit:
  (gumamit ng "git reset HEAD <file>..." para i-unstage)

	nabago:   index.html

Ang mga pagbabago na hindi na-stage para sa commit:
  (gumamit ng "git add <file>..." upang mag-update kung ano ang mako-commit)
  (gumamit ng "git checkout -- <file>..." upang iwaksi ang mga pagbabago sa gumaganang direktoryo)

	nabago:   lib/simplegit.rb

Ang opsyon na apply ay sinusubukan lamang na maglapat ng naka-stash na trabaho — ituloy mo upang magkaroon ka nito sa iyong stack. Upang matanggal ito, maaari mong patakbuhin ang git stash drop na may pangalan ng stash na tatanggalin:

$ git stash list
stash@{0}: WIP on master: 049d078 added the index file
stash@{1}: WIP sa master: c264051 Ibinalik ang  "idinagdag na file_size"
stash@{2}: WIP sa master: 21d80a5 idinagdag ang bilang sa log
$ git stash drop stash@{0}
Alisin ang stash@{0} (364e91f3f268f0900bc3ee613f9f733e82aaed43)

Maaari mo ring patakbuhin ang git stash pop upang ilapat ang stash at pagkatapos ay kaagad na alisin ito mula sa iyong stack.

Malikhain na Pag-stash

Mayroong ilang ibang stash na maaari ring kapaki-pakinabang. Ang unang opsyon na medyo sikat ay ang opsyon na --keep-index sa utos na stash save. Ito ay nagsasabi sa Git na hindi lamang isali ang lahat ng naka-stage na nilalaman sa stash na nilikha, sabay na iwanan ito sa indeks.

$ git status -s
M  index.html
 M lib/simplegit.rb

$ git stash --keep-index
Naka-save na gumaganang direktoryo at estado ng indeks WIP sa master: 1b65b17 idinagdag sa indeks na file
Ang HEAD ngayon ay nasa 1b65b17 idinagdag sa indeks na file

$ git status -s
M  index.html

Iba pang karaniwan na bagay na gugustuhin mo sa stash ay para i-stash ang hindi sinubaybayan na mga file pati na rin ang sinibaybayan. Bilang default, ang git stash ay mag-stash lamang ng binagong at naka-stage na tracked files. Kung tinutukoy mo ang --include-untracked o -u, isasama ng Git ang mga file na hindi sinubaybayan sa nilikhang stash.

$ git status -s
M  index.html
 M lib/simplegit.rb
?? new-file.txt

$ git stash -u
Naka-save na gumaganang direktoryo at estado ng indeks WIP sa master: 1b65b17 idinagdag ang indeks na file
Ang HEAD ngayon ay nasa 1b65b17 na idinagdag ang indeks na file

$ git status -s
$

Sa wakas, kung ikaw ay nagtutukoy ng flag na --patch, hindi i-stash ng Git ang lahat na binago ngunit sa halip ay mag-prompt sa iyo kung alin ang mga pagbabago na gusto mong i-stash at kung ano ang gusto mo na panatilihin sa iyong gumaganang direktoryo.

$ git stash --patch
diff --git a/lib/simplegit.rb b/lib/simplegit.rb
index 66d332e..8bb5674 100644
--- a/lib/simplegit.rb
+++ b/lib/simplegit.rb
@@ -16,6 +16,10 @@ class SimpleGit
         return `#{git_cmd} 2>&1`.chomp
       end
     end
+
+    def show(treeish = 'master')
+      command("git show #{treeish}")
+    end

 end
 test
I-stash ang hunk na ito [y,n,q,a,d,/,e,?]? y

Naka-save na gumaganang direktoryo at estado ng indeks WIP sa master: 1b65b17 idinagdag ang indeks na file

Paglilikha ng isang Branch mula sa isang Stash

Kung ikaw ay nag-stash ng ilang trabaho, iwanan ito sa ilang saglit, at magpatuloy sa branch kung saan ikaw nag-stash ng trabaho, maaari kang magkaroon ng isang problema sa muling paglalapat ng trabaho. Kung sinusubukan ng paglalapat na baguhin ang isang file na binago mo na, makakakuha ka ng salungatan sa pagsasama-sama at kakailanganin mong lutasin ito. Kung gusto ang isang mas madaling paraan upang suriing muli ang mga naka-stash na pagbabago, maaari mong patakbuhin ang git stash branch <branch>, kung saan ay lumilikha ng isang bagong branch para sa iyong napiling pangalan ng branch, nagsusuri sa iyong commit kapag ikaw ay nag-stash ng iyong trabaho, muling naglalapat sa iyong trabaho doon, at pagkatapos ay naghuhulog sa stash kung ito ay matagumpay na nailalapat:

$ git stash branch testchanges
M	index.html
M	lib/simplegit.rb
Nagpalit sa isang bagong branch na 'testchanges'
Sa branch na testchanges
Mga pagbabago na iko-commit:
  (gumamit ng "git reset HEAD <file>..." upang mag-unstage)

	nabago:   index.html

Mga pagbabago na hindi na-stage para sa commit:
  (gumamit ng "git add <file>..." upang baguhin kung ano ang iko-commit)
  (gumamit ng "git checkout -- <file>..." upang iwaksi ang mga pagbabago sa gumaganang direktoryo)

	nabago:   lib/simplegit.rb

Inilaglag ang refs/stash@{0} (29d385a81d163dfd45a452a2ce816487a6b8b014)

Ito ay isang magandang shortcut upang madaling maisauli ang naka-stash na trabaho at trabahuin ito sa isang bagong branch.

Paglilinis ng iyong Tinatrabahuang Direktoryo

Sa wakas, maaaring hindi mo nais na i-stash ang ilang trabaho o mga file sa iyong tinatrabahuang direktoryo, ngunit palayain mo lang sila. Ang utos na git clean ang gagawa nito para sa iyo.

Ilan sa mga kariniwang dahilan para rito ay maaaring alisin ang cruft na binuo ng mga merge o mga panlabas na kagamitan o upang alisin ang mga build artifact upang mapatakbo ang isang malinis na build.

Nanaisin mong maging maingat sa kautusan na ito, dahil ito ay idinisenyo upang tanggalin ang mga file mula sa iyong tinatrabahuang direktoryo na hindi sinubaybayan. Kung nagbago ang iyong isipan, madalas na walang pagkukuha ng nilalaman ng mga file na iyon. Isang mas ligtas na opsyon ay ang magpatakbo ng git stash --all upang tanggalin ang lahat ngunit i-save ito sa isang stash.

Ipagpalagay na nais mong magtanggal ng mga cruft na file o maglinis ng iyong tinatrabahuang direktoryo, maaari mo itong gawin gamit ang git clean. Upang alisin ang lahat ng mga hindi sinubaybayan na mga file sa iyong tinatrabahuang direktoryo, maaari mong patakbuhin ang git clean -f -d, na nagtatanggal ng anumang mga file at pati na rin ang anumang mga subdirectory na nagiging walang laman bilang resulta. Ang -f ay nangangahulugan na force o "gawin talaga ito".

Kung gusto mong makita kung ano ang gagawin nito, maaari mong patakbuhin ang utos na may opsyon na -n, na nangangahulugan na “gumawa ng isang dry run at sabihin sa akin kung ano ang iyong inalis”.

$ git clean -d -n
Would remove test.o
Would remove tmp/

Bilang default, ang utos na git clean ay tinatanggal lamang ang mga hindi sinubaybayan na mga file na hindi binabalewala. Anumang file na tumutugma sa isang pattern sa iyong .gitignore o ibang hindi pansinin ng mga file ay hindi matatanggal. Kung gusto mo na tanggalin din ang mga file na ito, tulad ng tanggalin lahat ang mga file na .o na binuo mula sa isang build upang makakagawa ka ng buong malinis na build, maaari kang magdagdag ng -x sa clean na utos.

$ git status -s
 M lib/simplegit.rb
?? build.TMP
?? tmp/

$ git clean -n -d
Magtanggal build.TMP
Magtanggal tmp/

$ git clean -n -d -x
Magtanggal build.TMP
Magtanggal test.o
Magtanggal tmp/

Kung hindi mo alam kung ano ang gagawin ng utos na git clean, palaging patakbuhin ito ng may isang` -n` muna upang doubleng suriin bago baguhin ang -n sa isang` -f` at gagawain ito sa totoo. Ang iba pang mga paraan na maaari kang maging maingat tungkol sa proseso ay ang patakbuhin ito sa flag ng -i o “interactive”.

Papatakbuhin nito ang clean na utos sa isang interactive na mode.

$ git clean -x -i
Magtanggal ng mga sumusunod na mga aytem:
  build.TMP  test.o
*** Mga kautusan ***
    1: clean                2: mag-filter gamit ang pattern    3: pumili ng mga numero    4: tanungin ang bawat isa             5: huminto
    6: tulong
Ano na>

Sa ganitong paraan maaari kang humakbang sa bawat file nang isa-isa o tukuyin ang mga pattern para sa pagtanggal nang interactive.

May isang pambihirang sitwasyon kung saan maaaring kailangan mong labis na malakas sa pagtatanong sa Git upang linisin ang iyong tinatrabahuang direktoryo. Kung ikaw ay nasa isang gumaganang direktoryo kung saan mo kinopya o kopyahin ang iba pang mga repository ng Git (marahil bilang mga submodule), kahit na ang git clean -fd ay tatangging tanggalin ang mga direktoryo na iyon. Sa mga sitwasyong katulad nito, kailangan mong magdagdag ng pangalawang opsyon na -f para sa diin.