Penggunaan Git Dasar

Jika anda seorang mahasiswa/mahasiswi pasti anda akan mengalami moment pengerjaan tugas akhir atau skripsi. Ketika anda bimbingan dan mengajukan skripsi anda ke dosen pembimbing, ada saat skripsi anda mengalami revisi. Revisi minggu-1, minggu-2, minggu-3 dan seterusnya. Apa yang terjadi dengan file revisi skripsi anda? apakah satu file tersebut anda rubah dengan revisi yang baru? Bagaimana jika anda perlu kembali ke revisi minggu-1? Ok, anda buat copy file masing-masing, seperti copy revisi minggu-1, copy revisi minggu-2, dan seterusnya. Akan ada banyak file versi disetiap revisi. Tidak efisien. Disinilah peran version control.

Version control merupakan suatu system yang dapat mencatat setiap perubahan terhadap sebuah file atau sekumpulan file, sehingga pada suatu saat anda dapat kembali ke salah satu versi dari file tersebut. Version control memungkinkan anda untuk mengembalikan file pada kondisi/keadaan sebelumnya, membandingkan perubahan pada suatu file, bahkan melihat siapa saja yang melakukan perubahan terhadap file karena version control mencatat user yang melakukan suatu perubahan. Dengan version control, jika anda telah mengacaukan atau bahkan kehilangan suatu file, anda dapat dengan mudah untuk mengembalikannya ke keadaan versi yang anda mau.

Version Control Terpusat

Ada kondisi dimana suatu file atau kumpulan berkas dikerjakan oleh beberapa orang sekaligus diwaktu yang sama ditempat yang berbeda. Maka dibangunlah Centralized Version Control Systems (CVCS). Salah satu tools yang mengadopsi CVCS yang pernah saya gunakan adalah Subversion. Setiap berkas perubahan akan disimpan di suatu server terpusat, dan setiap user akan mengakses server tersebut untuk mendapatkan data perubahan terbaru dari berkas yang dikerjakan. Masalah muncul jika server terpusat itu mengalami gangguan atau bahkan datanya hilang. User tidak bisa mengakses lagi data setiap versi perubahan, karena semua itu disimpan di server terpusat.

Version Control Terdistribusi

Masalah dari CVCS dapat diselesaikan dengan sangat elegan oleh Distributed Version Control System (DVCS). Dengan DVCS, user tidak hanya mengakses (checkout) untuk versi file (snapshot) terbaru, namun user memiliki salinan penuh dari repository tersebut. Jadi jika server mati, maka setiap user dapat mengirimkan salinan repository tersebut kembali ke server. Setiap checkout pada DVCS merupakan sebuah backupdari keseluruhan data. Salah satu tools yang mengadopsi system ini adalah Git.

Penggunaan Git

Sebelum mulai menggunakan Git, ada baiknya kita mengetahui beberapa istilah yang digunakan oleh Git.

clone: Salinan seluruh direktori kerja Git. Jika di version control lain menggunakan istilah Checkout. Ini yang membedakan Git dengan version control lain, Checkout mengacu kepada hanya versi terbaru dari suatu berkas (atau salah satu versi), sedangkan Clone mengacu kepada seluruh data perubahan suatu berkas.
repository/working folder: Folder kerja Git. Ditandai dengan adanya folder .git yang menampung seluruh data perubahan pada working folder.
changeset: Kumpulan diff.
staging: Tempat persiapan changeset yang siap untuk dicommit.
commit: Snapshot dari posisi folder dan file pada waktu tertentu.
head: Commit paling ujung(terbaru).
HEAD: head yang sedang aktif.
branch: head yang diberi nama.
merge: Menggabungkan lebih dari satu commit.

Perintah dasar Git

Mendaftarkan user Git

git config --global user.name 'Your Name'
git config --global user.email 'you@example.com'

Membuat repository baru (mendaftarkan suatu direktori menjadi repository Git)
```
git init
```
Membuat repository baru di folder project baru
```
git init [project-name]
```
Membuat salinan repository dari remote repository
```
git clone [repo-url]
```
Melihat status repository (menampilkan informasi branch yang sedang aktif juga)
```
git status
```
Memasukkan file ke dalam staging area
```
git add [file-name]
```
Memasukkan seluruh file dalam folder ke dalam staging area
```
git add .
```
Commit file yang ada pada staging area
```
git commit -m 'description'
```
Commit file langsung tanpa memasukkan ke dalam staging area
```
git commit -am 'description'
```
Menghapus file yang sudah di commit
```
git rm --cached path/to/file
```
Menghapus folder beserta isinya yang sudah di commit
```
git rm --cached -r path/to/file
```
Mengeluarkan file dari stagin area
```
git reset [file-name]
```
Mengembalikan file dari staging area ke versi commit terakhir
```
git reset --hard
```
Melihat daftar branch
```
git branch -av
```
Membuat branch baru
```
git branch [branch-name]
```
Masuk ke suatu branch
```
git checkout [branch-name]
```

Menggabungkan(merge) branch-a → branch-b

git checkout branch-b
git merge branch-a

Menghapus suatu branch
```
git branch -d [branch-name]
```
Menampilkan list commit
```
git log --pretty=format:'%h - %an: %s'
```
Kembali ke versi suatu commit (HEAD detached mode)
```
git checkout [commit-id]
```
Kembali ke versi suatu commit (di branch yang sama)
```
git checkout [commit-id] .
```
Melihat list alamat URL remote repository
```
git remote -v
```
Menambahkan URL remote repository
```
git remote add [short-name] [url]
```

Mengubah short-name remote repository

git remote rename [old-name] [new-name]

Mengambil data dari remote repository (no merge)
```
git fetch [short-name]
```
Mengambil data dari remote repository
```
git pull [short-name] [branch-name]
```
Memasukkan data ke remote repository
```
git push [short-name] [branch-name]
```
Memeriksa detail remote repository
```
git remote show [short-name]
```
Menghapus URL remote repository dari daftar
```
git remote remove [short-name]
```