Paano matutunan ang Git: plano, trainer, dokumentasyon, at praktika

Natutuhan ang Git sa pamamagitan ng praktika, hindi sa pagbabasa lang. Para makapagtrabaho nang kumpiyansa sa team, sapat na ang humigit-kumulang dalawampung command at ang pag-unawa sa tatlong ideya: ang commit ay snapshot ng proyekto, ang branch ay pointer sa commit, at ang remote repository ay isa pang kopya ng history. Narito ang plano ng pag-aaral ng Git sa mga yugto, kasama ang mga ehersisyo, libreng resources, at mga pamantayan kung kailan masasabing tapos na ang yugto.

Para sa baguhan ang planong ito, na marunong nang gumamit ng terminal kahit sa antas ng cd at ls. Kung hindi pa, maglaan muna ng isang gabi sa mga batayan ng command line: mas mahirap matutunan ang Git kung wala ito.

Bakit dapat pag-aralan nang sistematiko ang Git

Maraming taon nang nabubuhay ang ilan sa limang command na kinopya mula sa tutorial ng iba, at nagpa-panic sila sa unang conflict o "detached HEAD". Halos palaging iisa ang dahilan: walang mental model, kaya hindi alam ng tao kung ano ang binabago ng command sa history at sa mga file.

Mabilis magbunga ang sistematikong pag-aaral ng Git. Hindi na kayo natatakot mag-eksperimento, dahil alam ninyo kung paano mag-rollback; kalmado ninyong nareresolba ang mga conflict; at may malinis na history na makikita ng mga reviewer at employer. Tinatanong ang Git sa halos lahat ng uri ng IT job, mula frontend hanggang DevOps at data analysis.

Yugto 1. Mga batayan: repository, index, commit

Layunin ng unang yugto na maintindihan ang pangunahing ikot at ang tatlong lugar ng Git: working directory, index, at repository. Aabutin ito ng 2 hanggang 4 na araw, tig-isang oras.

• Pag-install at unang setup: git config --global user.name, user.email, at default na branch na main.
• Paggawa ng repository: git init.
• Ikot ng git status → git add → git commit; piling pagdagdag gamit ang git add -p.
• Pagtingin sa history: git log --oneline, git diff, git diff --staged, git show.
• File na .gitignore: ano ang hindi dapat mapunta sa repository.

Ehersisyo. Gumawa ng repository para sa sarili ninyong mga tala o maliit na script. Gumawa ng 15 hanggang 20 commit, bawat isa ay isang lohikal na pagbabago na may malinaw na mensahe. Pagkatapos ng bawat command, patakbuhin ang git status at ipaliwanag sa sarili kung ano ang nagbago.

Tapos na ang yugto kapag masasabi ninyo nang walang tulong kung ano ang pagkakaiba ng output ng git diff at git diff --staged, at kaya ninyong mag-commit ng bahagi lang ng mga binagong file.

Yugto 2. Mga branch at merge

Ang mga branch ang puso ng Git at ang pangunahing pinagmumulan ng takot ng mga baguhan. Dito, hindi kabisado ang mga command ang mahalaga, kundi ang kakayahang mailarawan ang graph ng mga commit. Maglaan ng halos isang linggo para dito.

• Paggawa at paglipat: git branch, git switch, git switch -c.
• Ano ang HEAD at ang estadong detached HEAD.
• Merge: git merge, fast-forward at merge commit, ang flag na --no-ff.
• Mga conflict: mga marker na <<<<<<< at >>>>>>>, git merge --abort.
• Pagbisualisa: git log --oneline --graph --all.

Ehersisyo. Gumawa ng dalawang branch mula sa main at baguhin ang parehong linya ng isang file sa bawat isa. I-merge ang mga ito nang paisa-isa, makakuha ng conflict, at ayusin ito. Ulitin hanggang maging nakakabagot ang proseso.

Sa yugtong ito, pinakamalaking tulong ang interactive na trainer ng Git, na tatalakayin sa ibaba. Ipinapakita nito ang graph pagkatapos ng bawat command at mabilis nitong nabubuo ang intuwisyon.

Yugto 3. Remote repository at teamwork

Layunin: matutunang makipagtrabaho sa server gaya ng ginagawa sa mga team. Kailangan ng account sa GitHub, GitLab, o anumang Git hosting. Mga isang linggo ang aabutin.

• Pagkonekta at pag-clone: git remote add, git clone, pag-login gamit ang SSH key.
• Pag-sync: git push, git push -u, git fetch, git pull, at ang pagkakaiba nila.
• Mga remote-tracking branch gaya ng origin/main.
• Fork, feature branch, at pull request na may code review.
• Mga proseso ng team: GitHub Flow, Git Flow, trunk-based development.

Ehersisyo. Magtrabaho sa iisang repository mula sa dalawang "computer": i-clone ito sa dalawang magkaibang folder. Mag-commit sa isa, i-push, at kunin sa isa pa. Lumikha ng sitwasyong ma-reject ang push dahil nauna na ang server, at alamin kung bakit.

git clone git@github.com:you/sandbox.git copy-a
git clone git@github.com:you/sandbox.git copy-b
cd copy-a && echo "mula sa A" >> notes.txt && git commit -am "Pagbabago mula sa A" && git push
cd ../copy-b && echo "mula sa B" >> notes.txt && git commit -am "Pagbabago mula sa B"
git push          # rejected: nauna na ang server
git pull          # kukunin ang pagbabago ng A, ayusin ang conflict sa notes.txt
git push

Ginagaya ng maikling senaryong ito ang pinakakaraniwang sitwasyon sa team. Basahin ang output ng bawat command: bakit na-reject ang push, ano ang lumitaw sa origin/main pagkatapos ng fetch, saan galing ang merge commit. Pagkatapos, ulitin gamit ang git pull --rebase at ihambing ang mga graph gamit ang git log --oneline --graph --all.

Mas mabuti pa, humanap ng kapareha at gumawa ng maliit na proyekto nang sabay sa pamamagitan ng pull request: sa ganitong paraan, mararamdaman ninyo ang review, conflict, at mga kasunduan sa branch.

Yugto 4. Pag-undo ng mga pagkakamali

Ginagawang safety net ng yugtong ito ang Git mula sa pinagmumulan ng pangamba. 3 hanggang 5 araw.

• git restore at git restore --staged: pag-undo sa mga file at sa index.
• git commit --amend: itama ang huling commit.
• git reset sa mga mode na --soft, --mixed, --hard.
• git revert: ligtas na pag-undo ng commit na nai-publish na.
• git reflog: pagbawi ng "nawalang" commit.

Ehersisyo. Gumawa ng ilang commit, patakbuhin ang git reset --hard HEAD~3, at ibalik ang mga ito gamit ang reflog. I-undo ang commit sa "shared" na branch gamit ang revert, at tingnan kung paano ito lumalabas sa history.

Yugto 5. Mga advanced na tool

Natutuhan ang mga ito habang kailangan, pero makabubuting alam na ninyo nang maaga na umiiral ang mga ito.

Mga Git trainer: saan magpapraktis

Mabuti ang trainer dahil nagbibigay ito ng ligtas na sandbox at agad na ipinapakita ang resulta. Ilang libreng opsyon:

• Learn Git Branching (learngitbranching.js.org): pinakamagaling na trainer para sa mga branch. May mga level na may gawain, animated na graph ng commit, at available ang Russian na interface. Sakop nito ang commit, branch, merge, rebase, cherry-pick, interactive rebase, at pagtatrabaho sa remote.
• Oh My Git!: libreng larong open source kung saan kinakatawan ang mga command ng Git bilang mga card, at ang tunay na Git ang tumatakbo sa ilalim.
• Sariling repository na sandbox: ang pinakamaliit na napapahalagahang trainer. Gumawa ng folder na git-sandbox at sirain ang lahat doon: walang mawawala.

Malaking tulong ang mga trainer sa pag-unawa ng graph, pero hindi nila napapalitan ang tunay na proyekto: walang totoong file, editor, conflict sa code, at IDE. Gamitin ang mga ito bilang dagdag.

Dokumentasyon ng Git at mga aklat

Ang opisyal na dokumentasyon ng Git ay nasa git-scm.com. Doon din libre ang aklat na Pro Git nina Scott Chacon at Ben Straub, pati ang salin sa Russian. Ito ang pinakamahusay na aklat tungkol sa Git: obligado ang unang tatlong kabanata (mga batayan at branching), at ang kabanatang "Git Internals" ay para sa mga gustong maintindihan nang lubusan ang data model.

Laging available ang built-in na tulong: git help <command> ang nagbubukas ng buong manual, at git <command> -h ang maikling listahan ng mga flag. Tuyo pero tumpak ang dokumentasyon ng Git; sanayin ang sarili na sumangguni dito, hindi sa unang sagot na lumabas sa paghahanap.

git help rebase        # buong manual
git switch -h          # maikling tulong sa mga flag
git help -g            # listahan ng mga konseptong gabay (gitworkflows, gittutorial…)

Kapaki-pakinabang din ang mga gabay na gittutorial at giteveryday. Kasama ang mga ito sa standard na distribusyon ng Git, at mabubuksan gamit ang git help.

Mag-isa o sa kurso

Posibleng matutunan ang Git nang mag-isa: sapat na ang libro, trainer, at sandbox. Ang hirap ay nasa estruktura: madaling matigil sa teorya, o kaya ay makakalap ng mga command nang walang pag-unawa, at walang feedback na magsasabing magulo ang history ninyo.

Makakatulong ang kurso ng Git kung gusto ninyong dumaan nang mabilis at maayos: mula sa unang commit hanggang pull request sa tunay na repository, na may mga gawain sa bawat hakbang. Sa pagpili ng kurso, tingnan hindi ang haba nito kundi ang bahagi ng praktika: may mga gawaing conflict, pag-undo ng pagkakamali, teamwork, at huling proyekto ba.

Gaano katagal ang kailangan para matutunan ang Git

Tinatayang mga bilang lang ang mga ito: ang regularidad ang nagpapasya. Mas malaki ang naitutulong ng isang oras kada araw kaysa sa maraton tuwing katapusan ng buwan.

Karaniwang pagkakamali sa pag-aaral ng Git

• Pag-aaral lang sa pamamagitan ng GUI. Kapaki-pakinabang ang graphical client, pero tinatago nito ang modelo. Unahin ang command line, saka pumili ng kasangkapang gusto ninyo.
• Pagkakabisado ng mga flag. Ang dapat tandaan ay ang mga ideya; laging nasa -h ang mga flag.
• Takot na masira ang lahat. Hangga't hindi pa kayo nakagawa ng reset --hard at nakabawi, hindi ninyo alam na sinasalo kayo ng Git.
• Paglaktaw sa remote repository. Ang lokal na Git na walang push, pull, at pull request ay kalahati lang ng kasanayan.
• Mga commit na "fix" at "update". Mas madaling masanay sa malinaw na mensahe mula sa simula.

Huling proyekto para sa pagpapatibay

Ang pinakamagandang pagsusuri ay ang simulasyon ng teamwork. Gumawa ng repository, protektahan ang branch na main laban sa direktang push, at mag-imbita ng kapareha o magtrabaho gamit ang dalawang account. Ang bawat gawain ay hiwalay na feature branch at pull request na may review; kahit isang beses, lumikha ng conflict, kahit isang beses, i-revert ang masamang commit, at markahan ng tag ang release.

Pagkatapos ng ganitong proyekto, hindi na lang koleksyon ng mga mahika ang Git. Nakikita ninyo ang graph, nauunawaan ang epekto ng mga command, at handa na kayo sa mga tanong sa job interview.

Buod

Maayos ang pagkatuto ng Git kapag sunud-sunod: pangunahing ikot, mga branch, pakikipagtrabaho sa server, pag-undo ng pagkakamali, at saka ang mga advanced na tool. Nakakatulong ang trainer para makita ang graph, nagbibigay ng lalim ang Pro Git at ang opisyal na dokumentasyon, at ang sariling sandbox at proyekto ng team ang ginagawang kasanayan ang kaalaman. Sa ganitong landas, mula git init hanggang pull request sa huling proyekto, nakabatay ang kurso ng Git sa Skillaria.