Advanced na Tutorial sa Git

Advanced na Tutorial sa Git

Ang pag-deploy ng iyong proyekto sa pamamagitan ng isang remote na imbakan ay nagbibigay-daan sa iyo na madaling pamahalaan ang bawat bahagi nito. Ang mga pag-aayos ng bug, pag-update ng tampok, pagtanggal ng file, pagtutulungan ng koponan, mga open-source na kontribusyon, pag-deploy ng code, at higit pa ay nasa iyong mga kamay na may isang malakas na kaalaman sa Git.





Kaya, ginagamit mo na ang Git ngunit nais mong malaman ang higit pa? Narito ang ilang mas advanced na mga tip sa Git na gagawing makontrol ng isang bersyon ng iyong proyekto ang simoy.



Sangay ng Git

Pinipigilan ka ng isang sangay ng Git na direktang itulak sa master branch. Kapaki-pakinabang kung pinamamahalaan mo ang isang proyekto kasama ang isang pangkat ng mga developer. Maaari kang lumikha ng maraming mga sangay ng Git hangga't gusto mo at pagkatapos ay pagsamahin ang mga ito sa master branch sa paglaon.





Lumikha ng isang Sangay ng Git

Upang lumikha ng isang sangay ng Git, gamitin ang:

git branch branch_name

Lumipat sa isang Sangay ng Git

Gamitin Tignan mo upang lumipat sa isang sangay ng Git:



git checkout branch_name

Pagkatapos lumipat sa isang sangay, maaari mong i-entablado ang iyong mga pagbabago gamit ang git idagdag --lahat . Pagkatapos ay itaguyod ang mga ito gamit ang git gumawa -m 'gumawa ng pangalan' utos

Paghambingin ang isang Sangay Sa Master

Gamitin ang git diff utos:



git diff master..branch_name

Upang ihambing ang mga tukoy na file:

git diff master..testb -- main.html

Ang paghahambing ng dalawang sangay ay katulad ng kung paano mo ihinahambing ang isang sangay sa master:



git diff branch1..branch2

Upang makita ang mga pagkakaiba sa isang tukoy na file sa pagitan ng dalawang sangay:

git diff branch1..branch2 -- main.html

Itulak ang mga Pagbabago sa isang Remote na Sangay

Maaaring gusto mong tingnan ng isa pang developer ang mga pagbabagong nagawa mo sa isang file sa iyong lokal na sangay bago itulak silang live. Ang isang mahusay na kasanayan ay upang itulak ang iyong lokal na sangay ng Git sa isang remote na kopya upang magkaroon sila ng hitsura.

Ipagpalagay na dati ka nang lumikha ng isang lokal na sangay na pinangalanan mga pagbabago . Maaari kang lumipat sa lokal na sangay na iyon, ayusin ang lahat ng mga file na gusto mo, pagkatapos ay i-entablado at itaguyod ang mga ito sa sangay na iyon.

Maaari mong itulak ang mga pagbabago sa malayong bersyon ng sangay:

git push origin changes

Pagsamahin ang Remote na Sangay Sa Master Gamit ang Pull Request

Kaya't isa pang programmer ang nag-awdit ng mga pagbabago sa remote branch ( mga pagbabago ). Ngunit nais mong pagsamahin ito sa master branch at itulak ito ng live.

Tandaan na ang iyong remote branch ay nagmamana ng pangalan ng iyong lokal na branch ng Git ( mga pagbabago ). Narito kung paano pagsamahin ang mga pagbabago:

Lumipat sa master branch:

git checkout master

Hilahin ang pinagmulan o ULO ng sangay ( mga pagbabago ) upang pagsamahin ito sa master branch:

git pull origin changes

Itulak nang live ang pagsanib na ito sa master branch:

git push origin master

Gumamit Sa halip ng Pagsamahin ang Git

Upang pagsamahin ang isang sangay sa master gamit ang punta ka na utos:

Lumipat sa master branch:

git checkout master

Pagsamahin ito sa sangay ( mga pagbabago ):

git merge changes

Pagkatapos ay itulak ang sumanib nang live sa master branch:

kung paano hadlangan ang isang tao sa twitch
git push origin master

Siguraduhin na papalitan mo mga pagbabago na may pangalan ng iyong sangay.

Kapag matagumpay ang isang pagsasama, maaari mo na pagkatapos tanggalin ang sangay nang lokal at malayuan kung hindi mo na kailangan ito:

Kaugnay: Paano Pangalanang Pangalan ang isang Sangay sa Git

Git Rebase

Kung mayroon kang maraming mga sangay na may lipas na sa panahon na mga pangako, maaari mong bawasan muli o muling ituro ang ulo / ref ng mga sangay na iyon upang manahin ang ulo / ref ng isang na-update.

Samakatuwid, ang rebasing, ay madaling gamitin kapag kailangan mong i-update ang ilang mga sangay na may batayan ng isang kasalukuyang.

Ang rebasing ay hindi dapat maging isang madalas na aksyon, gayunpaman, lalo na kung nagtatrabaho ka sa isang koponan dahil maaari nitong abalahin ang buong daloy ng trabaho. Ngunit kung nagtatrabaho ka nang nag-iisa at pamilyar ka sa iyong daloy ng trabaho at mga sangay, ang muling pagbabago ay hindi dapat makapinsala kung alam mo kung saan at paano ito gamitin.

Halimbawa, ipalagay na mayroon kang dalawang sangay; sangay1 at sangay2. Ngayon, hindi ka pa nakagawa ng anumang mga pagbabago sa branch1 nang matagal. Ngunit patuloy kang nagbabago sa branch2, kasama kamakailan.

Kaya't nagpasya kang magdala ng branch1 kasama ang daloy. Ang pag-rebal ng branch1 sa branch2, samakatuwid, ay nangangahulugang sinasabi mo sa branch1 na huwag pansinin ang dating mga nagawa nito at manahin ang kamakailang pangako na ginawa sa branch2.

Narito kung paano mo magagawa iyon:

Lumipat sa inabandunang sangay (branch1):

git checkout branch1

Pagkatapos i-rebase ang branch1 sa na-update na branch2:

git rebase branch2

Git Squash

Hinahayaan ka ng Git squash na pagsamahin ang maraming mga pag-commit sa isa. Nakakatulong ito kapag tumakbo ka git gumawa maraming beses sa isang solong pag-update. Ang isang praktikal na halimbawa ay kapag ang bawat pag-aayos ng bug o code refactor para sa isang solong tampok ay may hiwalay na gumawa.

Ngunit maaaring hindi mo nais na itulak ang HEAD na gumawa sa mga kasamang lahat sila ay may parehong layunin. Ang isang inirekumendang diskarte ay i-squash ang mga ito sa isa upang maiwasan ang pagkalito kapag sumusubaybay na nakakagawa.

Ang pinakamahusay na paraan upang magawa ang kalabasa ay sa pamamagitan ng interactive rebase mode. Tingnan ang halimbawa sa ibaba upang mas maintindihan ito.

Sa halimbawang ito, ipagpalagay na mayroon kang limang pag-aayos ng bug. At mayroong isang komit para sa bawat isa sa kanila. Narito kung paano mo mai-squash ang limang mga gawing ito sa isa:

Takbo git reflog upang matingnan ang hash code ng iyong mga pangako:

git reflog

Narito ang resulta sa kasong ito:

Ngayon ang iyong hangarin ay kalabasa ang huling limang mga pag-commits, simula sa ayusin muna hanggang sa ikalimang pag-aayos .

Upang magawa iyon, kopyahin ang hash code ng pagbibigay sa ibaba lamang ayusin muna ( 0a83962 ). Pagkatapos ay pindutin Q upang umalis sa tanggihan .

Tumakbo ngayon git rebase --interactive sa hash na iyon

git rebase --interactive 0a83962

Pagkatapos ay magbubukas ang Git ng isang interactive na rebase file na ganito ang hitsura:

Upang kalabasa ang mga nakatuon, hindi kasama ang ayusin muna , palitan Pumili kasama si s para sa bawat isa sa iba pang mga gumawa:

I-save at isara ang file na ito.

Ang isa pang file ay magbubukas para sa iyo upang palitan ang pangalan ng squash commit:

paano makita kung sino ang nag-unfollow sa instagram

Linisin ang mga iyon at i-type ang isang ginustong pangalan para sa squash commit:

I-save ang file na iyon. Pagkatapos isara ito at dapat kang makatanggap ng isang mensahe sa tagumpay sa iyong terminal.

Tandaan: Maaaring buksan ang interactive na file sa loob ng terminal. Ngunit kung nasa Windows ka, maaaring gusto mong pilitin ang iyong terminal na global na magbukas ng mga file sa iyong paboritong text editor upang gawing madali ang pag-squash.

Upang magawa iyon, buksan ang iyong linya ng utos at patakbuhin:

git config --global core.editor ''path to choice text editor' -n -w'

Git Fork kumpara sa Git Clone

Ang forking at cloning ay dalawang magkakaibang termino sa Git. Hindi mo maaaring tinidor ang iyong imbakan dahil nandiyan na ito sa iyo. Gayunpaman, maaari mong tinidor ang imbakan ng ibang tao at i-clone ito pagkatapos.

Ang paghingi ng isang lalagyan ay nangangahulugang kumukuha ka ng isang kopya ng imbakan ng isang tao at gawin itong iyo. Kapag nakakuha ka ng isang kopya ng lalagyan na iyon, maaari mo nang mai-clone ito tulad ng nais mong anuman sa iyong git repository para sa mga lokal na pagbabago.

Narito kung paano i-clone ang isang remote na imbakan sa GitHub at simulan ang isang pag-download sa iyong lokal na direktoryo:

git clone https://github.com/username/repository_name.git/

Ibalik ang isang File sa Default na Estado Nito

Kung nais mong i-clear ang mga pagbabago sa isang file pagkatapos ng huling gumawa, maaari mong gamitin ang git ibalik utos:

git restore filename

Susugan ang isang Pangako

Maaari kang bumalik sa nakaraang nakatuon kung nakalimutan mong gumawa ng mga pagbabago sa ilang mga file habang itinatakda ang mga ito.

Gumawa ng mga pagbabago sa file na nakalimutan mo. Pagkatapos gamitin git susog upang suriin ang isang nakatuon:

git add file_forgotten
git commit --amend

Mga Unstage na File

Maaari mong alisin ang mga tukoy na file na iyong itinanghal para sa isang paggamit na nais go rm utos:

git rm --cached filename

Maaari mo ring alisin ang maraming mga file nang sabay-sabay:

git rm --cached file1 file2 file3 file4

Tandaang idagdag ang nauugnay na extension ng file sa anumang file na iyong ibinubukod. Halimbawa, dapat na isang payak na text file filename.txt .

Kaugnay: Paano linisin ang Git at Alisin ang mga Hindi Na-track na File

I-reset ang Git

Gamit git reset ay kapaki-pakinabang kung nais mong i-drop ang lahat ng mga file na itinanghal mo para sa isang gawing sabay-sabay:

git reset

Gayunpaman, itinuturo ng Git ang PUNO, ang HEAD ng isang sangay sa isang tukoy na gumawa sa iyong gumaganang puno. Halimbawa, kung hindi mo pa natulak ang iyong kasalukuyang pagkakasunud-sunod, maaari kang bumalik sa kamakailang itinulak na pangako:

git reset --soft HEAD~1

Palitan - matalino kasama si --mahirap kung naitulak mo na ang kasalukuyang gumawa:

git reset --hard HEAD~1

Pumunta Bumalik

hindi katulad ng i-reset utos, bumalik ka pinapanatili ang integridad ng iyong kasaysayan ng gumawa. Madaling magamit kung nais mong mag-amyenda ng isang dahil sa mga error o bug.

Hindi nito pinababayaan ang target na gumawa o gumawa ng bago. Sa halip, bumabalik ito sa mga kamakailang pagbabago na iyong nagawa nang hindi tinatanggal o pinalitan ng pangalan ang nasabing kagagawan. Mahusay na paraan upang mapanatiling mas malinis ang iyong mga ginawa, kasama itong mas ligtas kaysa sa pag-reset sa lahat ng oras.

Upang bumalik sa isang nakatuon:

git revert HEAD~1

Kung saan Ulo ~ 1 tumuturo sa isang tukoy na gumawa sa iyong nagtatrabaho puno.

Tanggalin ang isang Sinusubaybayang File o isang Direktoryo

Pwede mong gamitin git rm -f upang tanggalin ang anumang mga sinusubaybayang file sa iyong gumaganang puno. Gayunpaman, tandaan na hindi maalis ng Git ang mga hindi naka-track na file, dahil hindi ito nai-cache ang mga ito.

Upang tanggalin ang isang itinanghal na file:

git rm -f filename

Upang alisin ang isang itinanghal na folder:

git rm -r -f foldername

Pag-log ng Git

Upang matingnan ang iyong mga log ng gumawa at kasaysayan sa Git:

git log

Upang mai-log ang mga aktibidad sa isang tukoy na sangay:

git log branch_name

Kaugnay: Paano Masisiyasat ang Kasaysayan ng isang Proyekto Sa git log

Minsan baka gusto mong bumalik sa isang inabandunang gumawa. Kaya upang tingnan ang mga inabandunang komit, kasama ang mga nauugnay:

git reflog

Upang matingnan ang mga ref log para sa isang partikular na sangay:

git reflog branch_name

Pamahalaan ang Iyong Mga Bersyon ng Proyekto Tulad ng isang Pro Sa Git

Sa pag-aalok ng Git ng maraming kalamangan, maaari mong pamahalaan ang paglabas ng iyong proyekto nang malayuan nang walang pag-burgling ng mga file at folder na nasa nasasakupang lugar sa iyong pangunahing sangay. Bilang karagdagan, pinapayagan kang magpatakbo ng mga proyekto nang madali sa isang koponan.

Tulad ng iyong nakita, maraming mga tampok ang Git na maaari mong tuklasin. Ngunit mag-ingat na gamitin ang mga tampok na ito nang may layunin. Kung hindi man, maaari kang mapunta sa paglabag ng mga bagay. Sinabi na, maaari mo pa ring paikutin ang isang demo na remote na lalagyan at maglaro sa mga tampok na ito.

Magbahagi Magbahagi Mag-tweet Email Pamahalaan ang Iyong Pag-bersyon ng File Tulad ng isang Programmer Sa Git

Lumikha ang mga programmer ng mga sistema ng kontrol sa bersyon (VCS) upang malutas ang mga problema sa kontrol ng bersyon ng file. Tingnan natin ang mga pangunahing kaalaman sa kontrol sa bersyon gamit ang nangungunang system ngayon, Git.

Basahin Susunod Mga Kaugnay na Paksa
  • Programming
  • Pag-unlad sa Web
  • GitHub
  • Mga Tutorial sa Coding
Tungkol sa May-akda Idisou Omisola(94 na artikulong nalathala)

Si Idowu ay madamdamin tungkol sa anumang matalinong tech at pagiging produktibo. Sa kanyang libreng oras, naglalaro siya kasama ang pag-coding at paglipat sa chessboard kapag siya ay naiinip, ngunit gusto din niya ang paghihiwalay mula sa nakagawiang gawain sa isang sandali. Ang kanyang hilig sa pagpapakita sa mga tao ng paraan sa paligid ng modernong tech ay nag-uudyok sa kanya na magsulat pa.

Higit pa Mula sa Idowu Omisola

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe