Sa halip na isang pagpapakilala
Kamusta! Ngayon ay pag-uusapan natin ang tungkol sa isang version control system, ang Git.
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:

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)
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:- Ang isang file na nilikha ngunit hindi pa naidagdag sa imbakan ay may katayuang "hindi nasubaybayan".
- Kapag gumawa kami ng mga pagbabago sa mga file na naidagdag na sa Git repository, ang kanilang status ay "binago".
- Kabilang sa mga file na binago namin, pinipili namin ang mga kailangan namin, at ang mga klase na ito ay binago sa katayuang "itinatanghal".
- 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".

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

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

git status

- 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.
git add *.txt
Upang suriin ang katayuan, ginagamit namin ang utos na alam na namin:
git status

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

git log

git status

git status

git diff

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

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
git status


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

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

- 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

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

git branch -a

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

git checkout -b feature/update-txt-files

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:

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

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

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"

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: 

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

git status

git add *.txt

git commit

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…
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


git add test_resource.txt
git commit -m "prepared txt for pushing"
Ang utos upang itulak ito sa malayong imbakan ay:
git push

Kapaki-pakinabang na link
- Opisyal na dokumentasyon ng Git . Inirerekomenda ko ito bilang isang sanggunian.
GO TO FULL VERSION