Git Commit: Isang Master Class

Buod: Ang Git commit command ay nag-iimbak ng mga kopya ng mga pagbabago mula sa iyong gumaganang direktoryo sa iyong Git repository. Ngunit maaari rin itong gamitin para baguhin ang mga kasalukuyang commit at ibalik din ang mga commit.

Ang pangunahing kinakailangan ng anumang version control system ay ang mag-imbak ng iba't ibang bersyon ng mga file para sa iyo. Sa Git, ang command na gumagawa nito ay commit. Narito ang lahat ng kailangan mong malaman.

Ano ang isang Commit sa Git?

Ang mga commit ay ang serye ng mga snapshot na ginawa sa buong lifecycle ng isang proyekto na bumubuo sa kasaysayan ng pag-unlad nito. Ang mga commit ang nagbibigay-daan sa amin na mag-extract ng isang bersyon ng proyekto tulad ng nangyari sa iba't ibang mga punto sa nakaraan. Bakit ito mahalaga?

Ang mga version control system (mga VCS) ay pinakakaraniwang ginagamit sa source code ng software at mga proyekto sa pag-develop. Ngunit matagumpay na magagamit ang mga ito sa anumang koleksyon ng mga text file, tulad ng mga Markdown file na naglalaman ng mga kabanata ng isang libro.

Maaaring hindi mo nais na ang bawat file sa iyong mga direktoryo ng proyekto ay pangasiwaan ng VCS, kaya kailangan mong ma-nominate ang mga file na gusto mong kontrolin ang bersyon. Ito ay nagdaragdag sa kanila sa view ng kontrol ng bersyon ng proyekto. Susubaybayan sila para sa mga pagbabago.

Ang isa pang paraan para makamit ito ay gumamit ng listahan ng balewalain. Sinasabi nito sa Git kung aling mga file, direktoryo, o mga uri ng mga file ang dapat nitong palaging balewalain.

Sa paglipas ng panahon, habang ang mga bagong file ay idinagdag sa proyekto, ang ilan ay mangangailangan na idagdag sa system ng kontrol ng bersyon. Sa Git, ito ay pinangangasiwaan ng add command. Sa totoo lang, ang command na add ay nagsasagawa ng dobleng serbisyo, gaya ng makikita natin.

Upang mapanatili ang kasaysayan ng mga pagbabagong ginawa sa proyekto, pana-panahon mong hihilingin sa Git na mag-imbak ng snapshot ng estado ng proyekto, gamit ang command na commit. Dito lumalabas ang command na add sa aming workflow. Ginagamit namin ang command na add para sabihin sa Git kung aling nagbago mga file ang gusto naming isama sa snapshot. Pagkatapos ay ginagamit namin ang commit para sabihin sa Git na gawin ang snapshot.

Pag-configure ng commit Command

Ang impormasyon tungkol sa commit ay naka-store kasama nito, para laging posible na malaman kung sino ang gumawa ng commit, kailan, at kung ano ang nilalaman ng commit. Kinukuha ang ilan sa metadata na ito sa oras ng pag-commit, gaya ng mensahe ng commit.

Ang metadata na nauugnay sa pagkakakilanlan ng mga miyembro ng development team ay maaaring i-configure ng bawat user, upang maiwasan ang paulit-ulit na pagbibigay ng parehong impormasyon.

Upang itakda ang iyong pangalan sa buong mundo para sa lahat ng mga repositoryo sa iyong computer, gamitin ang command na ito.

git config --global user.name "Dave McKay"

Upang i-verify na naitakda ang iyong pangalan, gamitin ang command na ito.

git config --global user.name

Kung kailangan mong gumamit ng ibang pangalan sa isang partikular na repository, lumipat sa direktoryo ng proyekto at gamitin ang parehong command nang walang --global na opsyon.

git config user.name "McKay, David"

git config user.name

Mayroon na kaming ibang default na user name para sa repositoryong ito, at ang aming pandaigdigang pangalan ay ginagamit pa rin para sa iba pang mga repository.

Sa katulad na paraan, maaari tayong magtakda ng isang email address sa buong mundo o para sa iisang repository sa pamamagitan ng pagsasama o pag-alis ng opsyon na --global.

git config user.email "dave@phony-domain.com"

git config --global user.email "dave@fake-domain.com"

git config user.email

git config --global user.email

Ang mga setting na ito ay gaganapin sa mga config file. Ang mga setting ng Global Git ay gaganapin sa ~/.gitconfig, at ang mga setting na partikular sa repositoryo ay gaganapin sa .git/config na file ng repositoryo.

Ang command na commit ay tumutukoy at ginagamit ang mga halagang ito habang ito ay tumatakbo.

Gamit ang commit Command

Ang pangunahing paggamit ng command na commit ay kunin ang mga file na nasa staging area, na kilala bilang index, at iimbak ang mga ito bilang commit sa kasalukuyang sangay ng repository.

Isang Pangunahing Pangako

Mayroon kaming proyekto na may binagong file. Gagamitin namin ang command na add para i-stage ang file, pagkatapos ay i-commit ito. Ginagamit namin ang opsyong -m (commit message) para makapagbigay kami ng maikling paglalarawan ng layunin ng mga pagbabago. Kung hindi namin gagamitin ang opsyong ito, ipo-prompt kami para sa isang commit message habang nagaganap ang commit. Mas maginhawang magdagdag ng isa sa command line.

git add jibber.c

git commit -m "Updated help text"

Kung gagamitin namin ang command na git log maaari naming suriin ang mga detalye ng mga commit, sa magkakasunod na pagkakasunud-sunod, kasama ang pinakabagong commit sa tuktok ng listahan.

git log

Ang mga commit ay ipinapakita sa mas mababa.

Ang commit ay na-tag ng pangalan at email address na ibinigay namin kanina, at ang aming commit na mensahe ay naitala rin.

Auto-Staging Files

Ang pagtatanghal ng maraming mga file ay maaaring tumagal ng kaunting oras. Ang ibang diskarte ay ang paggamit ng -A (lahat) na opsyon na may add.

Awtomatiko nitong itinatanghal ang lahat ng binago na mga file kasama ang lahat ng kasalukuyang hindi sinusubaybayan na mga file. Ang pagtatanghal ng mga hindi sinusubaybayang file ay nirerespeto ang mga setting sa iyong .gitignore na file. Hindi gagawin ng Git ang mga file na sinabi mo dito na ayaw mong isama. Sa wakas, ang mga file sa index na wala na sa working directory ay inaalis mula sa index.

Malinaw, ang pagpipiliang -A ay maaaring maging sanhi ng maraming mangyari nang sabay-sabay. Ang --dry-run na opsyon ay nagbibigay sa iyo ng preview ng mga pagbabago nang hindi aktwal na ginagawa ang mga ito.

git add -A --dry-run

Sa aming halimbawa, gagawa ito ng dalawang binagong kasalukuyang file, at dalawang bagong file. Sige at gamitin natin ang opsyong -A bago natin gamitin ang command na commit.

git add -A

git commit -m "Enhanced parsing"

Nakikita namin na lahat ng apat na file ay binago. Dalawa sa mga ito ay ang mga bagong likhang file, na nakalista.

Pagtatanghal at Pagbibigay ng Sabay

Ang command na commit ay may lowercase na -a (lahat) na opsyon. Ginagawa nito ang pagtatanghal ng dula at ang paggawa ng mga file sa isang hakbang.

Ang commit -a na mga yugto ng opsyon at nag-commit ng mga binagong umiiral na file, at nag-aalis ng mga file mula sa index kung naalis ang mga ito sa iyong gumaganang direktoryo. Ito ay hindi awtomatikong itinatanghal ang mga hindi sinusubaybayang file.

Tulad ng add command, ang commit command ay may --dry-run na opsyon na nagbibigay-daan sa iyong i-preview ang mga aksyon nito bago ito isagawa.

git commit -a --dry-run

Ngayon ay isakatuparan natin ang utos.

git commit -a --dry-run

Ang mga file ay itinanghal at nakatuon para sa amin.

Mag-commit sa Ibang Sangay

Kung nakagawa ka ng ilang pagbabago sa mga file sa iyong direktoryo ng trabaho pagkatapos ay napagtanto mong hindi mo na-checkout ang tamang branch, kailangan mong ibigay ang iyong mga pagbabago sa tamang branch nang hindi naaapektuhan ang kasalukuyang branch.

Ang Git ay walang utos para sa pag-commit sa ibang sangay. Ngunit maaari mong iwasto ang sitwasyong ito gamit ang kaunting dexterity ng Git.

Gagamitin namin ang Git stash command para gumawa ng kopya ng mga pagbabago. Pagkatapos ay titingnan namin ang tamang sangay at ilalapat ang mga pagbabago mula sa itago. Upang ilapat ang mga nakatagong pagbabago, ginagamit namin ang command na pop kaysa sa command na apply. Inilalapat ng command na pop ang mga pagbabago at inaalis din ang mga ito sa itago.

Gumawa kami ng ilang pagbabago sa new-parser branch ng aming repository. Dapat ay ginawa ang mga ito sa classic-parser branch.

git stash

git checkout classic-parser

git stash pop

Maaari na tayong magsagawa ng commit, at i-update ang sangay na ito.

git commit -a -m "Added pre-parser functions"

Kung babalik kami sa new-parser branch makikita namin na ito ay napapanahon, ibig sabihin ay inalis na ang mga pagbabago sa iyong gumaganang direktoryo, at ang iyong repositoryo at mga file ay naka-sync.

git checkout new-parser

git status

Paggawa ng mga Pagbabago sa mga Commit

Kung kailangan mong pagbutihin ang iyong commit message—marahil ay nakakita ka ng typo sa loob nito—o nakalimutan mong i-stage ang isang file na dapat ay kasama sa commit, maaari mong gamitin ang --amend na opsyon upang ayusin ang mga bagay. Ang caveat ay, hindi ito dapat gamitin sa mga commit na na-push sa isang remote na repository.

Sa aming huling commit message, ang fraze ay dapat na phrase. Kung gagamit tayo ng git log makikita natin ito.

Para itama ito, gagamitin namin ang --amend na opsyon na tulad nito.

git commit --amend -m "Optimized phrase identification"

Kung muli naming gagamitin ang git log, makikita namin na ang lumang commit ay napalitan ng bago na may naitama na commit message.

Kung gusto naming magdagdag ng file na nakalimutan naming i-stage, maaari naming i-commit ang file na iyon para lumabas ito bilang bahagi ng nakaraang commit.

Gagamitin namin ang add para i-stage ang file, pagkatapos ay gumawa ng commit gamit ang --amend na opsyon. Ang opsyon na --no-edit ay nangangahulugang hindi namin kailangang magbigay ng bagong commit message. Pinapanatili ang dating mensahe ng commit.

git add jibber.c

git commit --amend --no-edit

Pag-aalis ng Mga Pagbabago sa isang Commit

Kung hindi mo sinasadyang na-stage at nakagawa ng isang file na hindi mo sinasadya, maaari mong alisin ang file na iyon mula sa commit gamit ang command na reset. Ire-reset namin ang commit pabalik sa staging area, o index. Pagkatapos ay aalisin namin ang file, at muling ibibigay ang iba pang mga file.

Para i-reset ang huling commit sa staging area, ginagamit namin ang command na reset --soft. Ang HEAD~ ay shorthand para sa “the commit behind the HEAD of the project commit timeline”, o sa English, “the last commit.”

git reset --soft HEAD~

Upang alisin ang file na hindi dapat kasama, ginagamit namin ang command na reset --mixed. Nire-reset nito ang mga pagbabagong iyon pabalik sa gumaganang direktoryo, na muling nililikha ang binagong file bilang isang unstaged, uncommitted na file.

git reset --mixed jibber.c

Kailangan nating i-commit ang iba pang mga file na natitira sa index.

git commit -m "Experimental tweaks"

Ang iba pang dalawang file na nasa orihinal na commit ay muling ipinangako para sa amin.

Pagbabalik ng Buong Commit

Minsan ang pag-undo ng buong commit ang pinakamadaling gawin. Ibinabalik nito ang iyong gumaganang direktoryo at imbakan sa estado kung saan sila naroroon bago ka gumawa.

Kailangan naming gamitin ang hashed reference ID ng commit. Mahahanap natin ito gamit ang git log:

Kopyahin ang reference na iyon at gamitin ito sa command na revert:

git revert e5bd4560aef8164c6ca9d6d4620b9db7f66aecc8

Bubuksan nito ang iyong default na editor para makapag-edit ka ng isang i-revert na mensahe. May ipinasok na default na mensahe para sa iyo. Maaari mong gamitin ito, o i-edit ito ayon sa gusto mo.

Kapag masaya ka sa iyong ibinalik na mensahe, i-save ang file at lumabas sa editor. Sa nano, gagawin mo ito gamit ang “Ctrl+O”, at “Ctrl+X.”

Gamit ang git log muli, makikita natin na may naidagdag na bagong commit na nag-undo sa mga pagbabago ng na-revert na commit.

Ang Git Swiss Army Knife

Malinaw, ang commit ay isa sa pinakamahalagang Git command. Marami itong magagawa, kaya maraming dapat matutunan. Ang pagkuha sa grips sa kanyang hindi gaanong ginagamit na mga tampok ay oras na ginugol nang maayos. Kapag kailangan mong itama ang isang pagkakamali—ngayon—matutuwa kang naghanda ka nang maaga.