Pagsisimula sa Git: isang komprehensibong gabay para sa mga baguhan

Sa halip na isang pagpapakilala

Kamusta! Ngayon ay pag-uusapan natin ang tungkol sa isang version control system, ang Git. Wala kang kinalaman sa programming kung hindi mo alam/naiintindihan ang Git. Ngunit ang kagandahan ay hindi mo kailangang panatilihin ang lahat ng mga utos at tampok ng Git sa iyong ulo upang patuloy na magamit. Kailangan mong malaman ang isang hanay ng mga utos na tutulong sa iyo na maunawaan ang lahat ng nangyayari.

Mga pangunahing kaalaman sa Git

Ang Git ay isang distributed version control system para sa aming code. Bakit kailangan natin ito? Ang mga distributed team ay nangangailangan ng ilang uri ng sistema para sa pamamahala ng kanilang trabaho. Ito ay kinakailangan upang subaybayan ang mga pagbabago na nagaganap sa paglipas ng panahon. Ibig sabihin, kailangan nating makita ang step-by-step kung aling mga file ang nagbago at kung paano. Ito ay lalong mahalaga kapag sinisiyasat mo kung ano ang nagbago sa konteksto ng isang gawain, na ginagawang posible na ibalik ang mga pagbabago.

Pag-install ng Git

I-install natin ang Java sa iyong computer.

Pag-install sa Windows

Gaya ng dati, kailangan mong mag-download at magpatakbo ng isang exe file. Ang lahat ay simple dito: mag-click sa unang link ng Google , gawin ang pag-install, at iyon na. Upang gawin ito, gagamitin namin ang bash console na ibinigay ng Windows. Sa Windows, kailangan mong patakbuhin ang Git Bash. Ganito ang hitsura nito sa Start Menu: Ngayon ito ay isang command prompt na maaari mong gamitin. Upang maiwasan ang pagpunta sa folder na may proyekto sa bawat oras upang buksan ang Git doon, maaari mong buksan ang command prompt sa folder ng proyekto gamit ang kanang pindutan ng mouse na may landas na kailangan namin:

Pag-install sa Linux

Karaniwan ang Git ay bahagi ng mga pamamahagi ng Linux at naka-install na, dahil isa itong tool na orihinal na isinulat para sa pagbuo ng kernel ng Linux. Ngunit may mga sitwasyon na hindi. Upang suriin, kailangan mong buksan ang isang terminal at isulat ang: git --version. Kung makakakuha ka ng isang maliwanag na sagot, pagkatapos ay walang kailangang i-install. Magbukas ng terminal at i-install ang Git sa Ubuntu . Nagtatrabaho ako sa Ubuntu, kaya masasabi ko sa iyo kung ano ang isusulat para dito: sudo apt-get install git.

Pag-install sa macOS

Dito rin, kailangan mo munang suriin kung naroon na ang Git. Kung wala ka nito, ang pinakamadaling paraan para makuha ito ay ang pag-download ng pinakabagong bersyon dito . Kung naka-install ang Xcode, tiyak na awtomatikong mai-install ang Git.

Mga setting ng Git

Ang Git ay may mga setting ng user para sa user na magsusumite ng trabaho. Makatuwiran ito at kinakailangan, dahil kinukuha ng Git ang impormasyong ito para sa field ng May-akda kapag gumawa ng commit. Mag-set up ng username at password para sa lahat ng iyong proyekto sa pamamagitan ng pagpapatakbo ng mga sumusunod na command:

git config --global user.name "Ivan Ivanov"
git config --global user.email ivan.ivanov@gmail.com

Kung kailangan mong baguhin ang may-akda para sa isang partikular na proyekto, maaari mong alisin ang "--global". Bibigyan tayo nito ng sumusunod:

git config user.name "Ivan Ivanov"
git config user.email ivan.ivanov@gmail.com

Medyo teorya...

Upang sumisid sa paksa, dapat naming ipakilala sa iyo ang ilang mga bagong salita at aksyon...

• git repository
• mangako
• sangay
• pagsamahin
• mga salungatan
• hilahin
• itulak
• paano balewalain ang ilang file (.gitignore)

At iba pa.

Mga katayuan sa Git

Ang Git ay may ilang mga estatwa na kailangang maunawaan at tandaan:

• hindi sinusubaybayan
• binago
• itinanghal
• nakatuon

Paano mo dapat maunawaan ito?

Ito ang mga status na nalalapat sa mga file na naglalaman ng aming code:

1. Ang isang file na nilikha ngunit hindi pa naidagdag sa imbakan ay may katayuang "hindi nasubaybayan".
2. Kapag gumawa kami ng mga pagbabago sa mga file na naidagdag na sa Git repository, ang kanilang status ay "binago".
3. Kabilang sa mga file na binago namin, pinipili namin ang mga kailangan namin, at ang mga klase na ito ay binago sa katayuang "itinatanghal".
4. Ang isang commit ay ginawa mula sa mga inihandang file sa naka-stage na estado at napupunta sa Git repository. Pagkatapos nito, walang mga file na may "staged" status. Ngunit maaaring may mga file pa rin na ang status ay "nabago".

Narito ang hitsura nito:

Ano ang commit?

Ang commit ay ang pangunahing kaganapan pagdating sa kontrol ng bersyon. Naglalaman ito ng lahat ng pagbabagong ginawa mula noong nagsimula ang commit. Ang mga commit ay naka-link nang magkasama tulad ng isang solong naka-link na listahan. Mas partikular: May unang commit. Kapag nalikha ang pangalawang commit, alam nito kung ano ang darating pagkatapos ng una. At sa ganitong paraan, masusubaybayan ang impormasyon. Ang isang commit ay mayroon ding sariling impormasyon, tinatawag na metadata:

• ang natatanging identifier ng commit, na magagamit upang mahanap ito
• ang pangalan ng may-akda ng commit, na lumikha nito
• ang petsa kung kailan ginawa ang commit
• isang komento na naglalarawan kung ano ang ginawa sa panahon ng commit

Narito ang hitsura nito:

Ano ang isang sangay?

Ang isang sangay ay isang pointer sa ilang commit. Dahil alam ng isang commit kung aling commit ang nauuna dito, kapag ang isang branch ay tumuturo sa isang commit, lahat ng mga nakaraang commit ay nalalapat din dito. Alinsunod dito, maaari naming sabihin na maaari kang magkaroon ng maraming sangay hangga't gusto mo na tumuturo sa parehong commit. Ang trabaho ay nangyayari sa mga sangay, kaya kapag ang isang bagong commit ay ginawa, ang sangay ay naglilipat ng pointer nito sa mas kamakailang commit.

Pagsisimula sa Git

Maaari kang magtrabaho sa isang lokal na imbakan nang nag-iisa pati na rin sa isang malayuan. Upang maisagawa ang mga kinakailangang utos, maaari mong limitahan ang iyong sarili sa lokal na imbakan. Iniimbak lamang nito ang lahat ng impormasyon ng proyekto nang lokal sa .git na folder. Kung pinag-uusapan natin ang malayong imbakan, kung gayon ang lahat ng impormasyon ay naka-imbak sa isang lugar sa malayong server: isang kopya lamang ng proyekto ang naka-imbak nang lokal. Ang mga pagbabagong ginawa sa iyong lokal na kopya ay maaaring itulak (git push) sa malayong imbakan. Sa aming talakayan dito at sa ibaba, pinag-uusapan natin ang tungkol sa pagtatrabaho sa Git sa console. Siyempre, maaari kang gumamit ng isang uri ng solusyon na nakabatay sa GUI (halimbawa, IntelliJ IDEA), ngunit dapat mo munang malaman kung anong mga utos ang isinasagawa at kung ano ang ibig sabihin ng mga ito.

Nagtatrabaho sa Git sa isang lokal na imbakan

Susunod, iminumungkahi ko na sundin mo at gawin ang lahat ng mga hakbang na ginawa ko habang binabasa mo ang artikulo. Mapapabuti nito ang iyong pag-unawa at karunungan sa materyal. Well, bon appetit! :) Upang lumikha ng isang lokal na imbakan, kailangan mong isulat:

git init

Gagawa ito ng .git na folder sa kasalukuyang direktoryo ng console. Ang .git na folder ay nag-iimbak ng lahat ng impormasyon tungkol sa Git repository. Huwag tanggalin ito ;) Susunod, idinaragdag ang mga file sa proyekto, at itinalaga sa kanila ang katayuang "Hindi Nasubaybayan". Upang suriin ang kasalukuyang katayuan ng iyong trabaho, isulat ito:

git status

Nasa master branch kami, at dito kami mananatili hanggang lumipat kami sa ibang branch. Ipinapakita nito kung aling mga file ang nagbago ngunit hindi pa naidagdag sa katayuang "itinatanghal." Upang idagdag ang mga ito sa "staged" na katayuan, kailangan mong isulat ang "git add". Mayroon kaming ilang mga pagpipilian dito, halimbawa:

• git add -A - idagdag ang lahat ng mga file sa "staged" status
• git add . — idagdag ang lahat ng mga file mula sa folder na ito at lahat ng mga subfolder. Sa esensya, ito ay kapareho ng nauna
• git add <file name> - nagdaragdag ng isang partikular na file. Dito maaari kang gumamit ng mga regular na expression upang magdagdag ng mga file ayon sa ilang pattern. Halimbawa, git add *.java: Nangangahulugan ito na gusto mo lang magdagdag ng mga file na may extension ng java.

Ang unang dalawang pagpipilian ay malinaw na simple. Ang mga bagay ay nagiging mas kawili-wili sa pinakabagong karagdagan, kaya't sumulat tayo:

git add *.txt

Upang suriin ang katayuan, ginagamit namin ang utos na alam na namin:

git status

Dito makikita mo na gumana nang tama ang regular na expression: ang test_resource.txt ay mayroon na ngayong "staged" status. At sa wakas, ang huling yugto para sa pagtatrabaho sa isang lokal na imbakan (mayroong isa pa kapag nagtatrabaho sa malayong imbakan ;)) — paglikha ng isang bagong commit:

git commit -m "all txt files were added to the project"

Ang susunod ay isang mahusay na utos para sa pagtingin sa kasaysayan ng commit sa isang sangay. Gamitin natin ito:

git log

Dito makikita mo na ginawa namin ang aming unang commit at kasama dito ang text na ibinigay namin sa command line. Napakahalagang maunawaan na ang tekstong ito ay dapat na ipaliwanag nang tumpak hangga't maaari kung ano ang ginawa sa panahon ng commit na ito. Makakatulong ito sa atin ng maraming beses sa hinaharap. Ang isang matanong na mambabasa na hindi pa natutulog ay maaaring nagtataka kung ano ang nangyari sa GitTest.java file. Alamin natin ngayon din. Upang gawin ito, ginagamit namin ang:

git status

Tulad ng makikita mo, ito ay "untracked" pa rin at naghihintay sa mga pakpak. Ngunit paano kung hindi namin nais na idagdag ito sa proyekto sa lahat? Minsan nangyayari yan. Upang gawing mas kawili-wili ang mga bagay, subukan natin ngayon na baguhin ang aming test_resource.txt file. Magdagdag tayo ng ilang teksto doon at suriin ang katayuan:

git status

Dito mo malinaw na makikita ang pagkakaiba sa pagitan ng mga "untracked" at "modified" status. Ang GitTest.java ay "untracked", habang ang test_resource.txt ay "modified". Ngayon na mayroon kaming mga file sa binagong estado, maaari naming suriin ang mga pagbabagong ginawa sa kanila. Magagawa ito gamit ang sumusunod na command:

git diff

Ibig sabihin, malinaw mong makikita dito kung ano ang idinagdag ko sa aming text file: hello world! Idagdag natin ang ating mga pagbabago sa text file at gumawa ng commit:

git add test_resource.txt
git commit -m "added hello word! to test_resource.txt"

Upang tingnan ang lahat ng commit, isulat ang:

git log

Tulad ng nakikita mo, mayroon na tayong dalawang pangako. Magdaragdag kami ng GitTest.java sa parehong paraan. Walang komento dito, utos lang:

git add GitTest.java
git commit -m "added GitTest.java"
git status

Nagtatrabaho sa .gitignore

Maliwanag, gusto lang naming panatilihing nag-iisa ang source code, at wala nang iba pa, sa repositoryo. Kaya ano pa ang maaaring mayroon? Sa pinakamababa, pinagsama-samang mga klase at/o mga file na nabuo ng mga kapaligiran sa pag-unlad. Upang sabihin sa Git na huwag pansinin ang mga ito, kailangan nating lumikha ng isang espesyal na file. Gawin ito: gumawa ng file na tinatawag na .gitignore sa ugat ng proyekto. Ang bawat linya sa file na ito ay kumakatawan sa isang pattern na huwag pansinin. Sa halimbawang ito, magiging ganito ang hitsura ng .gitignore file:

```
*.class
target/
*.iml
.idea/
```

Tignan natin:

• Ang unang linya ay huwag pansinin ang lahat ng mga file na may extension na .class
• Ang pangalawang linya ay huwag pansinin ang "target" na folder at lahat ng nilalaman nito
• Ang ikatlong linya ay huwag pansinin ang lahat ng mga file na may extension na .iml
• Ang ikaapat na linya ay huwag pansinin ang .idea folder

Subukan nating gumamit ng halimbawa. Upang makita kung paano ito gumagana, idagdag natin ang pinagsama-samang GitTest.class sa proyekto at suriin ang katayuan ng proyekto:

git status

Maliwanag, hindi namin nais na kahit papaano ay hindi sinasadyang idagdag ang pinagsama-samang klase sa proyekto (gamit ang git add -A). Upang gawin ito, gumawa ng .gitignore file at idagdag ang lahat ng inilarawan kanina: Ngayon, gumamit tayo ng commit upang idagdag ang .gitignore file sa proyekto:

git add .gitignore
git commit -m "added .gitignore file"

At ngayon ang sandali ng katotohanan: mayroon kaming isang pinagsama-samang klase na GitTest.class na "hindi sinusubaybayan", na hindi namin gustong idagdag sa Git repository. Ngayon ay dapat nating makita ang mga epekto ng .gitignore file:

git status

Perpekto! .gitignore +1 :)

Nagtatrabaho sa mga sangay at iba pa

Naturally, ang pagtatrabaho sa isang sangay lamang ay hindi maginhawa para sa mga nag-iisa na developer, at ito ay imposible kapag mayroong higit sa isang tao sa isang koponan. Ito ang dahilan kung bakit mayroon kaming mga sangay. Tulad ng sinabi ko kanina, ang isang sangay ay isang movable pointer lamang upang mag-commit. Sa bahaging ito, tutuklasin natin ang pagtatrabaho sa iba't ibang sangay: kung paano pagsamahin ang mga pagbabago mula sa isang sangay patungo sa isa pa, kung anong mga salungatan ang maaaring lumitaw, at marami pang iba. Upang makita ang isang listahan ng lahat ng mga sangay sa repositoryo at maunawaan kung alin ka, kailangan mong isulat:

git branch -a

Makikita mo na isa lang ang master branch namin. Ang asterisk sa harap nito ay nagpapahiwatig na tayo ay nasa loob nito. Siyanga pala, maaari mo ring gamitin ang utos na "git status" para malaman kung saang sangay tayo naroroon. Pagkatapos ay may ilang mga opsyon para sa paggawa ng mga sangay (maaaring marami pa — ito ang mga ginagamit ko):

• lumikha ng bagong sangay batay sa kung saan tayo nasa (99% ng mga kaso)
• lumikha ng isang sangay batay sa isang partikular na pangako (1% ng mga kaso)

Gumawa tayo ng branch batay sa isang partikular na commit

Aasa kami sa natatanging identifier ng commit. Upang mahanap ito, sumulat kami:

git log

Na-highlight ko ang commit sa komentong "nagdagdag ng hello world..." Ang natatanging identifier nito ay 6c44e53d06228f888f2f454d3cb8c1c976dd73f8. Gusto kong lumikha ng isang "development" na sangay na magsisimula sa commit na ito. Upang gawin ito, sumulat ako:

git checkout -b development 6c44e53d06228f888f2f454d3cb8c1c976dd73f8

Ang isang sangay ay nilikha na ang unang dalawang commit lamang mula sa master branch. Para i-verify ito, siguraduhin muna naming lumipat sa ibang branch at tingnan ang bilang ng mga commit doon:

git status
git log

And as expected, dalawa ang commit namin. Siyanga pala, narito ang isang kawili-wiling punto: wala pang .gitignore na file sa sangay na ito, kaya ang aming pinagsama-samang file (GitTest.class) ay naka-highlight na ngayon na may "untracked" status. Ngayon ay maaari nating suriin muli ang ating mga sangay sa pamamagitan ng pagsulat nito:

git branch -a

Makikita mo na mayroong dalawang sangay: "master" at "development". Kasalukuyan kaming nasa development.

Gumawa tayo ng isang sangay batay sa kasalukuyang isa

Ang pangalawang paraan upang lumikha ng isang sangay ay ang paglikha nito mula sa isa pa. Gusto kong lumikha ng isang sangay batay sa master branch. Una, kailangan kong lumipat dito, at ang susunod na hakbang ay gumawa ng bago. Tignan natin:

• git checkout master - lumipat sa master branch
• git status — i-verify na nasa master branch talaga kami

Dito makikita mo na lumipat kami sa master branch, ang .gitignore file ay may bisa, at ang compiled class ay hindi na naka-highlight bilang "untracked". Ngayon lumikha kami ng bagong sangay batay sa master branch:

git checkout -b feature/update-txt-files

Kung hindi ka sigurado kung ang sangay na ito ay kapareho ng "master", madali mong masuri sa pamamagitan ng pagsasagawa ng "git log" at pagtingin sa lahat ng mga commit. Dapat silang apat.

Pag-ayos ng gulo

Bago natin tuklasin kung ano ang isang salungatan, kailangan nating pag-usapan ang tungkol sa pagsasama ng isang sangay sa isa pa. Inilalarawan ng larawang ito ang proseso ng pagsasama ng isang sangay sa isa pa: Dito, mayroon tayong pangunahing sangay. Sa ilang mga punto, ang isang pangalawang sangay ay nilikha mula sa pangunahing sangay at pagkatapos ay binago. Kapag tapos na ang gawain, kailangan nating pagsamahin ang isang sangay sa isa pa. Hindi ko ilalarawan ang iba't ibang mga tampok: Sa artikulong ito, nais ko lamang maghatid ng pangkalahatang pag-unawa. Kung kailangan mo ang mga detalye, maaari mong hanapin ang mga ito sa iyong sarili. Sa aming halimbawa, ginawa namin ang feature/update-txt-files branch. Gaya ng ipinahiwatig ng pangalan ng sangay, nag-a-update kami ng text. Ngayon ay kailangan nating gumawa ng bagong commit para sa gawaing ito:

git add *.txt
git commit -m "updated txt files"
git log

Ngayon, kung gusto nating pagsamahin ang feature/update-txt-files branch sa master, kailangan nating pumunta sa master at isulat ang "git merge feature/update-txt-files":

git checkout master
git merge feature/update-txt-files
git log

Bilang resulta, kasama na ngayon ng master branch ang commit na idinagdag sa feature/update-txt-files. Idinagdag ang functionality na ito, para ma-delete mo ang isang feature branch. Upang gawin ito, sumulat kami:

git branch -D feature/update-txt-files

Ang lahat ay malinaw sa ngayon, oo? Palubhain natin ang sitwasyon: ngayon sabihin natin na kailangan mong baguhin muli ang txt file. Ngunit ngayon ang file na ito ay babaguhin din sa master branch. Sa madaling salita, ito ay magbabago nang magkatulad. Hindi malalaman ng Git kung ano ang gagawin kapag gusto naming pagsamahin ang aming bagong code sa master branch. Tara na! Gagawa kami ng bagong branch batay sa master, gagawa ng mga pagbabago sa text_resource.txt, at gagawa ng commit para sa gawaing ito:

git checkout -b feature/add-header
... we make changes to the file

git add *.txt
git commit -m "added header to txt"

Pumunta sa master branch at i-update din ang text file na ito sa parehong linya tulad ng sa feature branch:

git checkout master
… we updated test_resource.txt

git add test_resource.txt
git commit -m "added master header to txt"

At ngayon ang pinakakawili-wiling punto: kailangan nating pagsamahin ang mga pagbabago mula sa feature/add-header na sangay patungo sa master. Nasa master branch kami, kaya kailangan lang naming isulat:

git merge feature/add-header

Ngunit ang resulta ay isang salungatan sa test_resource.txt file: Dito makikita natin na hindi makapagpasya ang Git sa sarili nitong paraan kung paano pagsamahin ang code na ito. Sinasabi nito sa amin na kailangan muna nating lutasin ang hindi pagkakasundo, at pagkatapos lamang gawin ang pangako. OK. Binuksan namin ang file na may salungatan sa isang text editor at tingnan ang: Upang maunawaan kung ano ang ginawa ni Git dito, kailangan naming tandaan kung aling mga pagbabago ang ginawa namin at kung saan, at pagkatapos ay ihambing:

1. Ang mga pagbabago na nasa linyang ito sa master branch ay matatagpuan sa pagitan ng "<<<<<<<< HEAD" at "=======".
2. Ang mga pagbabago na nasa feature/add-header branch ay matatagpuan sa pagitan ng "=======" at ">>>>>>> feature/add-header".

Ito ay kung paano sinasabi sa amin ng Git na hindi nito maisip kung paano isasagawa ang pagsasanib sa lokasyong ito sa file. Hinati nito ang seksyong ito sa dalawang bahagi mula sa iba't ibang sangay at iniimbitahan kaming lutasin ang pagsasanib ng hindi pagkakasundo. Sapat na. Matapang akong nagpasya na tanggalin ang lahat, na iniiwan lamang ang salitang "header": Tingnan natin ang katayuan ng mga pagbabago. Ang paglalarawan ay bahagyang naiiba. Sa halip na isang "binagong" status, mayroon kaming "unmerged". Kaya't maaari ba nating nabanggit ang ikalimang katayuan? Sa tingin ko ay hindi ito kailangan. Tingnan natin:

git status

Maaari nating kumbinsihin ang ating sarili na ito ay isang espesyal, hindi pangkaraniwang kaso. Ituloy natin:

git add *.txt

Maaari mong mapansin na ang paglalarawan ay nagmumungkahi ng pagsulat lamang ng "git commit". Subukan nating isulat iyon:

git commit

At ganoon din, ginawa namin ito — nalutas namin ang salungatan sa console. Siyempre, maaari itong gawin nang mas madali sa pinagsamang mga kapaligiran sa pag-unlad. Halimbawa, sa IntelliJ IDEA, ang lahat ay naka-set up nang maayos upang maisagawa mo ang lahat ng kinakailangang aksyon sa loob mismo nito. Ngunit ang mga IDE ay gumagawa ng maraming bagay "sa ilalim ng talukbong", at madalas ay hindi natin naiintindihan kung ano ang eksaktong nangyayari doon. At kapag walang pag-unawa, maaaring lumitaw ang mga problema.

Nagtatrabaho sa mga malalayong imbakan

Ang huling hakbang ay upang malaman ang ilang higit pang mga utos na kinakailangan upang gumana sa malayong repositoryo. Tulad ng sinabi ko, ang isang malayong imbakan ay isang lugar kung saan nakaimbak ang imbakan at kung saan maaari mong i-clone ito. Anong uri ng mga malalayong imbakan ang naroroon? Mga halimbawa:

• Ang GitHub ay ang pinakamalaking storage platform para sa mga repositoryo at collaborative development. Inilarawan ko na ito sa mga nakaraang artikulo.
  Sundan ako sa GitHub . Madalas kong ipakita ang aking trabaho doon sa mga lugar na pinag-aaralan ko para sa trabaho.

• Ang GitLab ay isang web-based na tool para sa DevOps lifecycle na may open source . Ito ay isang Git -based system para sa pamamahala ng mga code repository na may sarili nitong wiki, bug tracking system , CI/CD pipeline, at iba pang function.
  Matapos ang balita na binili ng Microsoft ang GitHub, nadoble ng ilang developer ang kanilang mga proyekto sa GitLab.

• Ang BitBucket ay isang web service para sa pagho-host ng proyekto at collaborative development batay sa Mercurial at Git version control system. Sa isang pagkakataon nagkaroon ito ng malaking kalamangan sa GitHub dahil nag-aalok ito ng mga libreng pribadong repositoryo. Noong nakaraang taon, ipinakilala din ng GitHub ang kakayahang ito sa lahat nang libre.

• At iba pa…

Kapag nagtatrabaho sa isang malayuang imbakan, ang unang bagay na dapat gawin ay i-clone ang proyekto sa iyong lokal na imbakan. Para dito, na-export ko ang proyekto na ginawa namin nang lokal, at ngayon ay ma-clone ito ng lahat para sa kanilang sarili sa pamamagitan ng pagsulat:

git clone https://github.com/romankh3/git-demo

Mayroon na ngayong kumpletong lokal na kopya ng proyekto. Upang matiyak na ang lokal na kopya ng proyekto ay ang pinakabago, kailangan mong hilahin ang proyekto sa pamamagitan ng pagsulat:

git pull

Sa aming kaso, walang nagbago sa malayong repositoryo sa kasalukuyan, kaya ang tugon ay: Napapanahon na. Ngunit kung gumawa ako ng anumang mga pagbabago sa malayuang imbakan, ang lokal ay ina-update pagkatapos naming hilahin ang mga ito. At sa wakas, ang huling utos ay itulak ang data sa malayong imbakan. Kapag gumawa kami ng isang bagay sa lokal at nais na ipadala ito sa malayong imbakan, kailangan muna naming lumikha ng bagong commit nang lokal. Upang ipakita ito, magdagdag tayo ng iba pa sa ating text file: Ngayon isang bagay na karaniwan para sa atin — gumawa tayo ng commit para sa gawaing ito:

git add test_resource.txt
git commit -m "prepared txt for pushing"

Ang utos upang itulak ito sa malayong imbakan ay:

git push

Well, yun lang ang gusto kong sabihin. Salamat sa iyong pansin. Sundan mo ako sa GitHub , kung saan nag-post ako ng iba't ibang magagandang halimbawang proyekto na may kaugnayan sa aking personal na pag-aaral at trabaho.

Kapaki-pakinabang na link

• Opisyal na dokumentasyon ng Git . Inirerekomenda ko ito bilang isang sanggunian.