Isang tugmang ginawa sa langit: Git at IntelliJ IDEA

Nananatili sa itinatag na tradisyon, binabati kita bilang mga senior software engineer sa hinaharap. Ang artikulo ngayong araw ay ang lohikal na extension ng aking artikulo sa Git . Sa artikulo tungkol sa Git, inilarawan ko kung paano magtrabaho kasama ang Git sa command line. Ngayon ay ipapakita ko sa iyo kung paano gawin ang lahat sa IntelliJ IDEA. Sa simula ng aking paglalakbay bilang isang developer, ginamit ko ang command line at naisip ko na hindi ko kailangan ng GUI para dito. Pagkatapos ng lahat, ang lahat ay malinaw tulad ng dati... Ngunit iyon ay hanggang sa sandaling sinimulan kong gamitin ang Git sa IntelliJ IDEA... Mula sa simula, gusto kong sabihin na inilalarawan ko ang aking personal na karanasan. Mayroong ilang mga paraan upang malutas ang anumang ibinigay na problema sa IntelliJ IDEA. Kung alam mo ang isang mas mahusay na paraan kaysa sa kung ano ang ilalarawan ko sa artikulo, isulat ito sa mga komento at tatalakayin natin ito.

Mga kinakailangang input:

1. Basahin, sundan, at unawain ang aking artikulo tungkol sa Git . Makakatulong ito na matiyak na naka-set up at handa na ang lahat.
2. I-install ang IntelliJ IDEA.
3. Maglaan ng isang oras ng personal na oras upang makamit ang kumpletong karunungan.

Gawin natin ang demo project na ginamit ko para sa artikulo tungkol sa Git. I-UPDATE:Sa oras ng paglalathala, magiging available ang bagong GitHub UI, at ang ilang mga icon ay hindi kung saan ipinapakita ang mga ito sa artikulo. Huwag maalarma: kailangan mo lang na huwag lumipat sa bagong UI, o hanapin ang mga ito.

I-clone ang proyekto nang lokal

Mayroong dalawang mga pagpipilian dito:

1. Kung mayroon ka nang GitHub account at gusto mong itulak ang isang bagay sa ibang pagkakataon, mas mainam na i-fork ang proyekto at i-clone ang iyong sariling kopya.
2. I-clone ang aking repositoryo at gawin ang lahat nang lokal nang walang kakayahang itulak ang buong bagay sa server. Pagkatapos ng lahat, ito ang aking imbakan :)

Upang mai-clone ang isang proyekto mula sa GitHub, kailangan mong kopyahin ang link ng proyekto at ipasa ito sa IntelliJ IDEA:

1. Kopyahin ang address ng proyekto:

2. Buksan ang IntelliJ IDEA at piliin ang "Kumuha mula sa Kontrol ng Bersyon":

3. Kopyahin at i-paste ang address ng proyekto:

4. Ipo-prompt kang lumikha ng proyekto ng IntelliJ IDEA. Tanggapin ang alok:

5. Dahil walang build system at iyon ay lampas sa saklaw ng artikulong ito, pipiliin namin ang Lumikha ng proyekto mula sa mga kasalukuyang pinagmumulan :

6. Susunod na makikita mo ang magandang screen na ito: Ngayong naisip namin ang pag-clone, maaari mong tingnan ang paligid.

Unang sulyap sa IntelliJ IDEA bilang isang Git UI

Tingnang mabuti ang na-clone na proyekto: maaari ka nang makakuha ng maraming impormasyon tungkol sa version control system. Una, mayroon kaming Control pane ng Bersyon sa ibabang kaliwang sulok. Dito mahahanap mo ang lahat ng lokal na pagbabago at makakuha ng listahan ng mga commit (katulad ng "git log"). Lumipat tayo sa isang talakayan ng Log . Mayroong tiyak na visualization na tumutulong sa amin na maunawaan nang eksakto kung paano natuloy ang pag-unlad. Halimbawa, makikita mo na may ginawang bagong branch na may idinagdag na header sa txt commit, na pagkatapos ay pinagsama sa master branch. Kung nag-click ka sa isang commit, makikita mo sa kanang sulok ang lahat ng impormasyon tungkol sa commit: lahat ng mga pagbabago at metadata nito.Bukod dito, makikita mo ang mga aktwal na pagbabago. Nakikita rin natin na naresolba ang isang salungatan doon. Inilalahad din ito ng IDEA nang napakahusay. Kung nag-double click ka sa file na binago sa panahon ng commit na ito, makikita namin kung paano nalutas ang salungatan: Napansin namin na sa kaliwa at kanan mayroon kaming dalawang bersyon ng parehong file na kailangang pagsamahin sa isa. At sa gitna, mayroon kaming huling pinagsamang resulta. Kapag maraming branch, commit, at user ang isang proyekto, kailangan mong maghanap nang hiwalay ayon sa branch, user, at petsa: Ang huling bagay na gusto kong ipaliwanag bago tayo magsimula ay kung paano intindihin kung saang branch tayo naroroon. Ibibigay ko sa iyo isang minuto upang malaman ito... Nahanap mo ba ito? Sumuko? :D Sa kanang sulok sa ibaba, mayroong isang button na may label na Git: master. Anuman ang sumusunod sa "Git:" ay ang kasalukuyang sangay. Kung iki-click mo ang pindutan, maaari kang gumawa ng maraming kapaki-pakinabang na bagay: lumipat sa isa pang sangay, lumikha ng bago, palitan ang pangalan ng isang umiiral na, at iba pa.

Paggawa gamit ang isang imbakan

Mga kapaki-pakinabang na hotkey

Para sa trabaho sa hinaharap, kailangan mong tandaan ang ilang napaka-kapaki-pakinabang na mga hotkey:

0. CTRL+T — Kunin ang pinakabagong mga pagbabago mula sa malayuang imbakan (git pull).
1. CTRL+K — Gumawa ng commit / tingnan ang lahat ng kasalukuyang pagbabago. Kabilang dito ang parehong hindi sinusubaybayan at binagong mga file (tingnan ang aking artikulo tungkol sa git, na nagpapaliwanag nito) (git commit).
2. CTRL+SHIFT+K — Ito ang utos para sa pagtulak ng mga pagbabago sa remote repository. Ang lahat ng mga commit na nilikha nang lokal at wala pa sa remote na imbakan ay itulak (git push).
3. ALT+CTRL+Z — Nagbabago ang rollback sa isang partikular na file sa estado ng huling commit na ginawa sa lokal na repositoryo. Kung pipiliin mo ang buong proyekto sa kaliwang sulok sa itaas, maaari mong ibalik ang mga pagbabago sa lahat ng file.

Ano ang gusto natin?

Upang magawa ang trabaho, kailangan nating makabisado ang isang pangunahing senaryo na ginagamit sa lahat ng dako. Ang layunin ay upang ipatupad ang bagong pag-andar sa isang hiwalay na sangay at pagkatapos ay itulak ito sa isang malayong imbakan (pagkatapos ay kailangan mo ring lumikha ng isang kahilingan sa paghila sa pangunahing sangay, ngunit iyon ay lampas sa saklaw ng artikulong ito). Ano ang kinakailangan upang gawin ito?

1. Kunin ang lahat ng kasalukuyang pagbabago sa pangunahing sangay (halimbawa, "master").

2. Mula sa pangunahing sangay na ito, lumikha ng isang hiwalay na sangay para sa iyong trabaho.

3. Ipatupad ang bagong functionality.

4. Pumunta sa pangunahing sangay at tingnan kung may mga bagong pagbabago habang kami ay nagtatrabaho. Kung hindi, kung gayon ang lahat ay maayos. Ngunit kung may mga pagbabago, gagawin namin ang sumusunod: pumunta sa nagtatrabaho na sangay at i-rebase ang mga pagbabago mula sa pangunahing sangay patungo sa atin. Kung maayos ang lahat, mahusay. Ngunit lubos na posible na magkakaroon ng mga salungatan. Habang nangyayari ito, maaari lamang silang malutas nang maaga, nang hindi nag-aaksaya ng oras sa malayong imbakan.

   Nagtataka ka ba kung bakit kailangan mong gawin ito? Ito ay mabuting asal at pinipigilan ang mga salungatan na mangyari pagkatapos na itulak ang iyong sangay sa lokal na imbakan (mayroong, siyempre, isang posibilidad na magaganap pa rin ang mga salungatan, ngunit ito ay nagiging mas maliit ).

5. Itulak ang iyong mga pagbabago sa malayong repositoryo.

Ang susunod ay depende sa iyong mga gawain at iyong imahinasyon.

Kumuha ng mga pagbabago mula sa malayong server?

Nagdagdag ako ng paglalarawan sa README na may bagong commit at gusto kong makuha ang mga pagbabagong ito. Kung ang mga pagbabago ay ginawa pareho sa lokal na repositoryo at sa malayong isa, pagkatapos ay iniimbitahan kaming pumili sa pagitan ng isang merge at isang rebase. Pinipili nating pagsamahin. Ipasok ang CTRL+T : Makikita mo na ngayon kung paano nagbago ang README, ibig sabihin, ang mga pagbabago mula sa remote na imbakan ay nakuha, at sa kanang sulok sa ibaba makikita mo ang lahat ng mga detalye ng mga pagbabago na nagmula sa server.

Gumawa ng bagong sangay batay sa master

Simple lang ang lahat dito.

1. Pumunta sa kanang sulok sa ibaba at i-click ang Git: master . Piliin ang + Bagong Sangay .

Iwanan ang checkbox ng Checkout branch na napili at ilagay ang pangalan ng bagong branch. Para sa akin, ito ay magiging readme-improver .

Git: ang master ay magbabago sa Git: readme-improver .

Gayahin natin ang parallel work

Para lumitaw ang mga salungatan, kailangang may gumawa ng mga ito :D I-edit ko ang README na may bagong commit sa pamamagitan ng browser, kaya ginagaya ang parallel work. Para bang may gumawa ng mga pagbabago sa parehong file habang ginagawa ko ito. Magiging conflict ang resulta. Aalisin ko ang salitang "fully" mula sa linya 10.

Ipatupad ang aming functionality

Ang aming gawain ay baguhin ang README at magdagdag ng paglalarawan sa bagong artikulo. Iyon ay, ang gawain sa Git ay dumadaan sa IntelliJ IDEA. Idagdag ito: Tapos na ang mga pagbabago. Ngayon ay maaari na tayong gumawa ng commit. Pindutin ang CTRL+K , na nagbibigay sa atin ng: Bago gumawa ng commit, kailangan nating tingnang mabuti kung ano ang inaalok ng window na ito. Nagdagdag ako ng mga pulang arrow upang ipakita sa iyo kung saan titingin. Mayroong maraming mga kawili-wiling bagay dito. Sa seksyong Commit Message , nagsusulat kami ng text na nauugnay sa commit. Pagkatapos para magawa ito, kailangan nating i-click ang Commit. Hindi ko pa nalaman kung paano ito gagawin gamit ang isang hotkey. Kung may nakakaalam kung paano, mangyaring sumulat sa akin — iyon ay lubos na magpapasaya sa akin. Isinulat namin na ang README ay nagbago at lumikha ng commit. May lalabas na alerto sa ibabang kaliwang sulok na may pangalan ng commit:

Suriin kung ang pangunahing sangay ay nagbago

Natapos namin ang aming gawain. Gumagana siya. Nagsulat kami ng mga pagsubok. Maayos ang lahat. Ngunit bago itulak sa server, kailangan pa rin nating suriin kung mayroong anumang mga pagbabago sa pangunahing sangay sa ngayon. Paano nangyari iyon? Medyo madali: may nakatanggap ng isang gawain pagkatapos mo, at na may nakakatapos nito nang mas mabilis kaysa natapos mo ang iyong gawain. Kaya kailangan nating pumunta sa master branch. Upang gawin ito, kailangan nating gawin ang ipinapakita sa kanang sulok sa ibaba sa screenshot sa ibaba: Sa master branch, pindutin ang CTRL+T upang makuha ang mga pinakabagong pagbabago nito mula sa remote server. Sa pagtingin sa kung ano ang mga pagbabago, madali mong makita kung ano ang nangyari:Ang salitang "fully" ay inalis. Marahil ay nagpasya ang isang tao mula sa marketing na hindi ito dapat isulat ng ganoon at binigyan ang mga developer ng isang gawain upang i-update ito. Mayroon na kaming lokal na kopya ng pinakabagong bersyon ng master branch. Bumalik sa readme-improver . Ngayon ay kailangan nating i-rebase ang mga pagbabago mula sa master branch patungo sa atin. Ginagawa namin ito: Kung ginawa mo ang lahat ng tama at sumunod sa akin, ang resulta ay dapat magpakita ng hindi pagkakasundo sa README file: Dito mayroon din kaming maraming impormasyon na dapat maunawaan at ibabad. Ipinapakita dito ang isang listahan ng mga file (sa aming kaso, isang file) na may mga salungatan. Maaari tayong pumili sa tatlong opsyon:

1. tanggapin ang sa iyo — tanggapin lamang ang mga pagbabago mula sa readme-improver.
2. tanggapin ang sa kanila - tanggapin lamang ang mga pagbabago mula sa master.
3. pagsamahin — piliin ang iyong sarili kung ano ang gusto mong panatilihin at kung ano ang itatapon.

Hindi malinaw kung ano ang nagbago. Kung may mga pagbabago ay ang master branch, kailangan sila doon, kaya hindi natin basta-basta tanggapin ang ating mga pagbabago. Alinsunod dito, pipiliin namin ang merge : Dito makikita namin na mayroong tatlong bahagi:

1. Ito ang mga pagbabago mula sa readme-improver.
2. Ang pinagsamang resulta. Sa ngayon, ito ang umiiral bago ang mga pagbabago.
3. Ang mga pagbabago mula sa master branch.

Kailangan nating gumawa ng pinagsama-samang resulta na magbibigay-kasiyahan sa lahat. Pagrepaso kung ano ang binago BAGO ang aming mga pagbabago, napagtanto namin na inalis lang nila ang salitang "fully". Okay walang problema! Nangangahulugan iyon na aalisin din namin ito sa pinagsamang resulta at pagkatapos ay idagdag ang aming mga pagbabago. Kapag naitama na namin ang pinagsamang resulta, maaari naming i-click ang Ilapat . Pagkatapos ay may lalabas na notification, na nagsasabi sa amin na matagumpay ang rebase: Ayan! Nalutas namin ang aming unang salungatan sa pamamagitan ng IntelliJ IDEA :D

Itulak ang mga pagbabago sa malayong server

Ang susunod na hakbang ay itulak ang mga pagbabago sa remote server at gumawa ng pull request. Upang gawin ito, pindutin lamang ang CTRL+SHIFT+K . Pagkatapos ay makukuha natin: Sa kaliwa, magkakaroon ng listahan ng mga commit na hindi pa nai-push sa remote na imbakan. Sa kanan ay makikita ang lahat ng mga file na nagbago. At ayun na nga! Pindutin ang Push at makakaranas ka ng kaligayahan :) Kung matagumpay ang push, makakakita ka ng notification na ganito sa kanang sulok sa ibaba:

Bahagi ng bonus

Noong una, ayaw kong idagdag ang paggawa ng pull request sa artikulong ito, ngunit hindi ito kumpleto kung wala ito. Kaya, pumunta tayo sa isang GitHub repository (isang sa iyo, siyempre :)) at nakita namin na alam na ng GitHub kung ano ang gusto namin: I-click ang Ihambing at hilahin ang kahilingan . Pagkatapos ay i-click ang Lumikha ng pull request . Dahil naresolba namin ang mga salungatan nang maaga, ngayon kapag gumagawa ng kahilingan sa paghila, maaari namin itong pagsamahin kaagad: At iyon lang ang gusto kong sabihin sa pagkakataong ito. Syempre, konti lang ang binuksan ko para sayo at may ipinakita akong maliit na parte. Malalaman mo ang tungkol sa iba kung kailangan mo ito. Nakaugalian kong imbitahan kang sundan ako sa GitHub, kung saan ako nagpo-post ng aking mga proyekto na may kinalaman sa iba't ibang teknolohiya na ginagamit ko sa trabaho. Nakagawa ako kamakailan ng isang personal na tagumpay: ang isa sa aking mga proyekto ay binigyan ng mga bituin ng higit sa isang daang mga developer. May isang hindi kapani-paniwalang pakiramdam ng kagalakan kapag alam mong ang iyong ginawa ay ginagamit ng iba. At gamitin ito para sa kabutihan.

Mga kapaki-pakinabang na link

1. CodeGym: Pagsisimula sa Git: isang komprehensibong gabay para sa mga baguhan
2. GitHub: Demo na proyekto para sa pagsasanay
3. JetBrains: Mag-set up ng Git Repository
4. GitHub: Aking account