Memulai dengan Git: panduan komprehensif untuk pemula

Alih-alih perkenalan

Halo! Hari ini kita akan berbicara tentang sistem kontrol versi, yaitu Git. Anda tidak ada hubungannya dengan pemrograman jika Anda tidak tahu/mengerti Git. Tetapi keindahannya adalah Anda tidak harus menyimpan semua perintah dan fitur Git di kepala Anda untuk terus digunakan. Anda perlu mengetahui sekumpulan perintah yang akan membantu Anda memahami semua yang terjadi.

Dasar Git

Git adalah sistem kontrol versi terdistribusi untuk kode kita. Mengapa kita membutuhkannya? Tim terdistribusi memerlukan semacam sistem untuk mengelola pekerjaan mereka. Diperlukan untuk melacak perubahan yang terjadi dari waktu ke waktu. Artinya, kita harus bisa melihat langkah demi langkah file mana yang telah berubah dan bagaimana caranya. Ini sangat penting saat Anda menyelidiki apa yang berubah dalam konteks satu tugas, sehingga memungkinkan untuk mengembalikan perubahan tersebut.

Menginstal Git

Mari instal Java di komputer Anda.

Menginstal di Windows

Seperti biasa, Anda perlu mengunduh dan menjalankan file exe. Semuanya sederhana di sini: klik tautan Google pertama , lakukan penginstalan, dan hanya itu. Untuk melakukan ini, kami akan menggunakan konsol bash yang disediakan oleh Windows. Di Windows, Anda perlu menjalankan Git Bash. Begini tampilannya di Start Menu: Sekarang ini adalah prompt perintah yang dapat Anda gunakan. Untuk menghindari keharusan pergi ke folder dengan proyek setiap saat untuk membuka Git di sana, Anda dapat membuka command prompt di folder proyek dengan tombol kanan mouse dengan jalur yang kita butuhkan:

Menginstal di Linux

Biasanya Git adalah bagian dari distribusi Linux dan sudah diinstal, karena ini adalah alat yang awalnya ditulis untuk pengembangan kernel Linux. Tetapi ada situasi ketika tidak. Untuk memeriksa, Anda perlu membuka terminal dan menulis: git --version. Jika Anda mendapatkan jawaban yang dapat dipahami, maka tidak ada yang perlu diinstal. Buka terminal dan instal Git di Ubuntu . Saya sedang mengerjakan Ubuntu, jadi saya dapat memberi tahu Anda apa yang harus ditulis untuknya: sudo apt-get install git.

Menginstal di macOS

Di sini juga, Anda harus terlebih dahulu memeriksa apakah Git sudah ada. Jika belum punya, maka cara termudah untuk mendapatkannya adalah dengan mendownload versi terbarunya disini . Jika Xcode diinstal, maka Git pasti akan diinstal secara otomatis.

Pengaturan Git

Git memiliki pengaturan pengguna untuk pengguna yang akan mengirimkan pekerjaan. Ini masuk akal dan perlu, karena Git mengambil informasi ini untuk bidang Penulis saat komit dibuat. Siapkan nama pengguna dan kata sandi untuk semua proyek Anda dengan menjalankan perintah berikut:

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

Jika Anda perlu mengubah penulis untuk proyek tertentu, Anda dapat menghapus "--global". Ini akan memberi kita yang berikut:

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

Sedikit teori...

Untuk menyelami topik ini, kami harus memperkenalkan Anda pada beberapa kata dan tindakan baru...

• repositori git
• melakukan
• cabang
• menggabungkan
• konflik
• menarik
• dorongan
• cara mengabaikan beberapa file (.gitignore)

Dan seterusnya.

Status di Git

Git memiliki beberapa patung yang perlu dipahami dan diingat:

• tidak terlacak
• diubah
• dipentaskan
• berkomitmen

Bagaimana seharusnya Anda memahami ini?

Ini adalah status yang berlaku untuk file yang berisi kode kami:

1. File yang dibuat tetapi belum ditambahkan ke repositori memiliki status "tidak terlacak".
2. Saat kami melakukan perubahan pada file yang telah ditambahkan ke repositori Git, maka statusnya "dimodifikasi".
3. Di antara file yang telah kami ubah, kami memilih yang kami butuhkan, dan kelas-kelas ini diubah menjadi status "bertahap".
4. Komit dibuat dari file yang disiapkan dalam keadaan bertahap dan masuk ke repositori Git. Setelah itu, tidak ada file dengan status "dipentaskan". Tapi mungkin masih ada file yang statusnya "dimodifikasi".

Berikut tampilannya:

Apa itu komit?

Komit adalah acara utama dalam hal kontrol versi. Ini berisi semua perubahan yang dibuat sejak komit dimulai. Komit ditautkan bersama seperti daftar tertaut tunggal. Lebih khusus lagi: Ada komit pertama. Saat komit kedua dibuat, komit tahu apa yang muncul setelah komit pertama. Dan dengan cara ini, informasi dapat dilacak. Sebuah komit juga memiliki informasinya sendiri, yang disebut metadata:

• pengidentifikasi unik komit, yang dapat digunakan untuk menemukannya
• nama pembuat komit, yang membuatnya
• tanggal komit dibuat
• komentar yang menjelaskan apa yang dilakukan selama komit

Begini tampilannya:

Apa itu cabang?

Cabang adalah penunjuk ke beberapa komit. Karena sebuah komit mengetahui komit mana yang mendahuluinya, ketika sebuah cabang menunjuk ke sebuah komit, semua komit sebelumnya juga berlaku untuknya. Karenanya, kami dapat mengatakan bahwa Anda dapat memiliki cabang sebanyak yang Anda inginkan untuk menunjuk ke komit yang sama. Pekerjaan terjadi di cabang, jadi saat komit baru dibuat, cabang memindahkan penunjuknya ke komit yang lebih baru.

Memulai dengan Git

Anda dapat bekerja dengan repositori lokal sendiri maupun dengan repositori jarak jauh. Untuk mempraktikkan perintah yang diperlukan, Anda dapat membatasi diri pada repositori lokal. Itu hanya menyimpan semua informasi proyek secara lokal di folder .git. Jika kita berbicara tentang repositori jarak jauh, maka semua informasi disimpan di suatu tempat di server jarak jauh: hanya salinan proyek yang disimpan secara lokal. Perubahan yang dilakukan pada salinan lokal Anda dapat didorong (git push) ke repositori jarak jauh. Dalam diskusi kami di sini dan di bawah ini, kami berbicara tentang bekerja dengan Git di konsol. Tentu saja, Anda dapat menggunakan semacam solusi berbasis GUI (misalnya, IntelliJ IDEA), tetapi pertama-tama Anda harus mencari tahu perintah apa yang sedang dijalankan dan apa artinya.

Bekerja dengan Git di repositori lokal

Selanjutnya, saya sarankan Anda mengikuti dan melakukan semua langkah yang saya lakukan saat Anda membaca artikel. Hal ini akan meningkatkan pemahaman dan penguasaan materi. Nah, selamat makan! :) Untuk membuat repositori lokal, Anda perlu menulis:

git init

Ini akan membuat folder .git di direktori konsol saat ini. Folder .git menyimpan semua informasi tentang repositori Git. Jangan hapus ;) Selanjutnya, file ditambahkan ke proyek, dan diberi status "Tidak Dilacak". Untuk memeriksa status pekerjaan Anda saat ini, tulis ini:

git status

Kami berada di cabang master, dan di sini kami akan tetap sampai kami beralih ke cabang lain. Ini menunjukkan file mana yang telah diubah tetapi belum ditambahkan ke status "dipentaskan". Untuk menambahkannya ke status "staged", Anda perlu menulis "git add". Kami memiliki beberapa opsi di sini, misalnya:

• git add -A — tambahkan semua file ke status "staged".
• git tambahkan. — tambahkan semua file dari folder ini dan semua subfolder. Pada dasarnya, ini sama dengan yang sebelumnya
• git add <file name> — menambahkan file tertentu. Di sini Anda dapat menggunakan ekspresi reguler untuk menambahkan file menurut beberapa pola. Misalnya, git add *.java: Ini berarti Anda hanya ingin menambahkan file dengan ekstensi java.

Dua opsi pertama jelas sederhana. Segalanya menjadi lebih menarik dengan tambahan terbaru, jadi mari kita menulis:

git add *.txt

Untuk memeriksa statusnya, kami menggunakan perintah yang sudah kami kenal:

git status

Di sini Anda dapat melihat bahwa regular expression telah bekerja dengan benar: test_resource.txt sekarang memiliki status "staged". Dan terakhir, tahap terakhir untuk bekerja dengan repositori lokal (ada satu lagi saat bekerja dengan repositori jarak jauh;)) — membuat komit baru:

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

Selanjutnya adalah perintah yang bagus untuk melihat riwayat komit di cabang. Mari kita manfaatkan:

git log

Di sini Anda dapat melihat bahwa kami telah membuat komit pertama kami dan menyertakan teks yang kami sediakan di baris perintah. Sangat penting untuk dipahami bahwa teks ini harus menjelaskan seakurat mungkin apa yang dilakukan selama komit ini. Ini akan membantu kita berkali-kali di masa depan. Pembaca yang ingin tahu yang belum tertidur mungkin bertanya-tanya apa yang terjadi dengan file GitTest.java. Mari kita cari tahu sekarang. Untuk melakukan ini, kami menggunakan:

git status

Seperti yang Anda lihat, itu masih "tidak terlacak" dan menunggu di sayap. Tetapi bagaimana jika kita sama sekali tidak ingin menambahkannya ke proyek? Terkadang itu terjadi. Agar lebih menarik, sekarang mari kita coba ubah file test_resource.txt kita. Mari tambahkan beberapa teks di sana dan periksa statusnya:

git status

Di sini Anda dapat dengan jelas melihat perbedaan antara status "tidak terlacak" dan "dimodifikasi". GitTest.java "tidak terlacak", sedangkan test_resource.txt "dimodifikasi". Sekarang kita memiliki file dalam keadaan dimodifikasi, kita dapat memeriksa perubahan yang dilakukan padanya. Ini dapat dilakukan dengan menggunakan perintah berikut:

git diff

Artinya, Anda dapat dengan jelas melihat di sini apa yang saya tambahkan ke file teks kami: halo dunia! Mari tambahkan perubahan kita ke file teks dan buat komit:

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

Untuk melihat semua komitmen, tulis:

git log

Seperti yang Anda lihat, kami sekarang memiliki dua komitmen. Kami akan menambahkan GitTest.java dengan cara yang sama. Tidak ada komentar di sini, hanya perintah:

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

Bekerja dengan .gitignore

Jelas, kami hanya ingin menyimpan kode sumber saja, dan tidak ada yang lain, di dalam repositori. Jadi apa lagi yang bisa ada? Minimal, kelas dan/atau file yang dikompilasi dihasilkan oleh lingkungan pengembangan. Untuk memberi tahu Git agar mengabaikannya, kita perlu membuat file khusus. Lakukan ini: buat file bernama .gitignore di root proyek. Setiap baris dalam file ini mewakili pola yang harus diabaikan. Dalam contoh ini, file .gitignore akan terlihat seperti ini:

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

Mari lihat:

• Baris pertama adalah mengabaikan semua file dengan ekstensi .class
• Baris kedua adalah mengabaikan folder "target" dan semua isinya
• Baris ketiga adalah mengabaikan semua file dengan ekstensi .iml
• Baris keempat adalah mengabaikan folder .idea

Mari kita coba menggunakan contoh. Untuk melihat cara kerjanya, mari tambahkan GitTest.class yang dikompilasi ke proyek dan periksa status proyek:

git status

Jelas, kami tidak ingin secara tidak sengaja menambahkan kelas yang dikompilasi ke proyek (menggunakan git add -A). Untuk melakukan ini, buat file .gitignore dan tambahkan semua yang dijelaskan sebelumnya: Sekarang mari gunakan komit untuk menambahkan file .gitignore ke proyek:

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

Dan sekarang momen kebenaran: kami memiliki kelas terkompilasi GitTest.class yang "tidak terlacak", yang tidak ingin kami tambahkan ke repositori Git. Sekarang kita akan melihat efek dari file .gitignore:

git status

Sempurna! .gitignore +1 :)

Bekerja dengan cabang dan semacamnya

Secara alami, bekerja di satu cabang saja tidak nyaman untuk pengembang tunggal, dan tidak mungkin bila ada lebih dari satu orang dalam satu tim. Makanya kami punya cabang. Seperti yang saya katakan sebelumnya, cabang hanyalah penunjuk yang dapat dipindahkan untuk melakukan. Pada bagian ini, kita akan mengeksplorasi bekerja di cabang yang berbeda: bagaimana menggabungkan perubahan dari satu cabang ke cabang lainnya, konflik apa yang mungkin muncul, dan banyak lagi. Untuk melihat daftar semua cabang di repositori dan memahami di mana Anda berada, Anda perlu menulis:

git branch -a

Anda dapat melihat bahwa kami hanya memiliki satu cabang master. Tanda bintang di depannya menunjukkan bahwa kita ada di dalamnya. Omong-omong, Anda juga dapat menggunakan perintah "git status" untuk mengetahui di cabang mana kita berada. Lalu ada beberapa opsi untuk membuat cabang (mungkin ada lebih banyak — ini yang saya gunakan):

• buat cabang baru berdasarkan cabang tempat kita berada (99% kasus)
• buat cabang berdasarkan komit tertentu (1% kasus)

Mari buat cabang berdasarkan komit tertentu

Kami akan mengandalkan pengidentifikasi unik komit. Untuk menemukannya, kami menulis:

git log

Saya telah menyoroti komit dengan komentar "menambahkan halo dunia..." Pengidentifikasi uniknya adalah 6c44e53d06228f888f2f454d3cb8c1c976dd73f8. Saya ingin membuat cabang "pengembangan" yang dimulai dari komit ini. Untuk melakukan ini, saya menulis:

git checkout -b development 6c44e53d06228f888f2f454d3cb8c1c976dd73f8

Cabang dibuat hanya dengan dua komit pertama dari cabang master. Untuk memverifikasi ini, pertama-tama kami memastikan untuk beralih ke cabang lain dan melihat jumlah komit di sana:

git status
git log

Dan seperti yang diharapkan, kami memiliki dua komitmen. Ngomong-ngomong, inilah poin yang menarik: belum ada file .gitignore di cabang ini, jadi file kompilasi kami (GitTest.class) sekarang disorot dengan status "tidak terlacak". Sekarang kami dapat meninjau kembali cabang kami dengan menulis ini:

git branch -a

Anda dapat melihat bahwa ada dua cabang: "master" dan "development". Kami sedang dalam pengembangan.

Mari buat cabang berdasarkan yang sekarang

Cara kedua untuk membuat cabang adalah dengan membuatnya dari yang lain. Saya ingin membuat cabang berdasarkan cabang master. Pertama, saya perlu beralih ke sana, dan langkah selanjutnya adalah membuat yang baru. Mari lihat:

• git checkout master — beralih ke cabang master
• git status — verifikasi bahwa kita benar-benar berada di cabang master

Di sini Anda dapat melihat bahwa kami beralih ke cabang master, file .gitignore berlaku, dan kelas yang dikompilasi tidak lagi disorot sebagai "tidak terlacak". Sekarang kami membuat cabang baru berdasarkan cabang master:

git checkout -b feature/update-txt-files

Jika Anda tidak yakin apakah cabang ini sama dengan "master", Anda dapat dengan mudah memeriksanya dengan menjalankan "git log" dan melihat semua komit. Seharusnya ada empat dari mereka.

Resolusi konflik

Sebelum kita menjelajahi apa itu konflik, kita perlu berbicara tentang menggabungkan satu cabang ke cabang lainnya. Gambar ini menggambarkan proses penggabungan satu cabang ke cabang lainnya: Di sini, kita memiliki cabang utama. Di beberapa titik, cabang sekunder dibuat dari cabang utama dan kemudian dimodifikasi. Setelah pekerjaan selesai, kita perlu menggabungkan satu cabang ke cabang lainnya. Saya tidak akan menjelaskan berbagai fiturnya: Pada artikel ini, saya hanya ingin menyampaikan pengertian secara umum. Jika Anda memerlukan detailnya, Anda dapat mencarinya sendiri. Dalam contoh kami, kami membuat cabang feature/update-txt-files. Seperti yang ditunjukkan oleh nama cabang, kami memperbarui teks. Sekarang kita perlu membuat komit baru untuk pekerjaan ini:

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

Sekarang, jika kita ingin menggabungkan cabang feature/update-txt-files menjadi master, kita perlu pergi ke master dan menulis "git merge feature/update-txt-files":

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

Akibatnya, cabang master sekarang juga menyertakan komit yang ditambahkan ke file fitur/perbarui-txt. Fungsionalitas ini telah ditambahkan, sehingga Anda dapat menghapus cabang fitur. Untuk melakukan ini, kami menulis:

git branch -D feature/update-txt-files

Semuanya jelas sejauh ini, ya? Mari kita perumit situasinya: sekarang katakanlah Anda perlu mengubah file txt lagi. Tapi sekarang file ini juga akan diubah di cabang master. Dengan kata lain, itu akan berubah secara paralel. Git tidak akan dapat mengetahui apa yang harus dilakukan ketika kita ingin menggabungkan kode baru kita ke dalam cabang master. Ayo pergi! Kami akan membuat cabang baru berdasarkan master, membuat perubahan pada text_resource.txt, dan membuat komit untuk pekerjaan ini:

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

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

Buka cabang master dan perbarui juga file teks ini di baris yang sama seperti di cabang fitur:

git checkout master
… we updated test_resource.txt

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

Dan sekarang hal yang paling menarik: kita perlu menggabungkan perubahan dari cabang feature/add-header ke master. Kami berada di cabang master, jadi kami hanya perlu menulis:

git merge feature/add-header

Tetapi hasilnya akan menjadi konflik dalam file test_resource.txt: Di sini kita dapat melihat bahwa Git tidak dapat memutuskan sendiri cara menggabungkan kode ini. Ini memberi tahu kita bahwa kita perlu menyelesaikan konflik terlebih dahulu, dan baru kemudian melakukan komit. OKE. Kami membuka file dengan konflik di editor teks dan melihat: Untuk memahami apa yang dilakukan Git di sini, kami perlu mengingat perubahan apa yang kami buat dan di mana, lalu membandingkan:

1. Perubahan yang ada di baris ini di cabang master ditemukan antara "<<<<<<<< HEAD" dan "=======".
2. Perubahan yang ada di cabang feature/add-header ditemukan antara "=======" dan ">>>>>>> feature/add-header".

Beginilah cara Git memberi tahu kami bahwa ia tidak dapat menemukan cara melakukan penggabungan di lokasi ini dalam file. Itu membagi bagian ini menjadi dua bagian dari cabang yang berbeda dan mengundang kita untuk menyelesaikan sendiri konflik gabungan. Cukup adil. Saya dengan berani memutuskan untuk menghapus semuanya, hanya menyisakan kata "header": Mari kita lihat status perubahannya. Deskripsi akan sedikit berbeda. Alih-alih status "dimodifikasi", kami telah "membatalkan". Jadi bisakah kita menyebutkan status kelima? Saya rasa ini tidak perlu. Mari kita lihat:

git status

Kita dapat meyakinkan diri sendiri bahwa ini adalah kasus yang spesial dan tidak biasa. Ayo lanjutkan:

git add *.txt

Anda mungkin memperhatikan bahwa deskripsi menyarankan hanya menulis "git commit". Mari kita coba menulis bahwa:

git commit

Dan begitu saja, kami melakukannya — kami menyelesaikan konflik di konsol. Tentu saja, hal ini dapat dilakukan dengan lebih mudah di lingkungan pengembangan terintegrasi. Misalnya, di IntelliJ IDEA, semuanya diatur dengan sangat baik sehingga Anda dapat melakukan semua tindakan yang diperlukan langsung di dalamnya. Tapi IDE melakukan banyak hal "di bawah tenda", dan kita sering tidak mengerti apa yang sebenarnya terjadi di sana. Dan ketika tidak ada pemahaman, masalah bisa muncul.

Bekerja dengan repositori jarak jauh

Langkah terakhir adalah memikirkan beberapa perintah lagi yang diperlukan untuk bekerja dengan repositori jarak jauh. Seperti yang saya katakan, repositori jarak jauh adalah suatu tempat di mana repositori disimpan dan dari mana Anda dapat mengkloningnya. Apa jenis repositori jarak jauh yang ada? Contoh:

• GitHub adalah platform penyimpanan terbesar untuk repositori dan pengembangan kolaboratif. Sudah saya uraikan di artikel sebelumnya.
  Ikuti saya di GitHub . Saya sering memamerkan pekerjaan saya di sana di bidang-bidang yang saya pelajari untuk bekerja.

• GitLab adalah alat berbasis web untuk siklus hidup DevOps dengan sumber terbuka . Ini adalah sistem berbasis Git untuk mengelola repositori kode dengan wikinya sendiri, sistem pelacakan bug , pipa CI/CD, dan fungsi lainnya.
  Setelah berita bahwa Microsoft membeli GitHub, beberapa pengembang menggandakan proyek mereka di GitLab.

• BitBucket adalah layanan web untuk hosting proyek dan pengembangan kolaboratif berdasarkan sistem kontrol versi Mercurial dan Git. Pada suatu waktu itu memiliki keuntungan besar dibandingkan GitHub karena menawarkan repositori pribadi gratis. Tahun lalu, GitHub juga memperkenalkan kemampuan ini kepada semua orang secara gratis.

• Dan seterusnya…

Saat bekerja dengan repositori jarak jauh, hal pertama yang harus dilakukan adalah mengkloning proyek ke repositori lokal Anda. Untuk ini, saya mengekspor proyek yang kami buat secara lokal, dan sekarang semua orang dapat mengkloningnya sendiri dengan menulis:

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

Sekarang ada salinan lokal lengkap dari proyek tersebut. Untuk memastikan bahwa salinan lokal dari proyek tersebut adalah yang terbaru, Anda perlu menarik proyek tersebut dengan menulis:

git pull

Dalam kasus kami, tidak ada yang berubah di repositori jarak jauh saat ini, jadi jawabannya adalah: Sudah diperbarui. Tetapi jika saya membuat perubahan apa pun pada repositori jarak jauh, yang lokal diperbarui setelah kami menariknya. Dan terakhir, perintah terakhir adalah mendorong data ke repositori jarak jauh. Ketika kita telah melakukan sesuatu secara lokal dan ingin mengirimkannya ke repositori jarak jauh, pertama-tama kita harus membuat komit baru secara lokal. Untuk mendemonstrasikan ini, mari tambahkan sesuatu yang lain ke file teks kita: Sekarang sesuatu yang sangat umum bagi kita — kita membuat komit untuk pekerjaan ini:

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

Perintah untuk mendorong ini ke repositori jarak jauh adalah:

git push

Nah, itu saja yang ingin saya katakan. Terima kasih atas perhatian Anda. Ikuti saya di GitHub , tempat saya memposting berbagai contoh proyek keren terkait dengan studi dan pekerjaan pribadi saya.

Tautan yang berguna

• Dokumentasi resmi Git . Saya merekomendasikannya sebagai referensi.