git-checkout - Online di Cloud

PROGRAM:

NAMA

git-checkout - Beralih cabang atau pulihkan file pohon yang berfungsi

RINGKASAN

git pemeriksaan [-q] [-f] [-m] [ ]
git pemeriksaan [-q] [-f] [-m] --lepaskan [ ]
git pemeriksaan [-q] [-f] [-m] [--lepaskan]
git pemeriksaan [-q] [-f] [-m] [[-b|-B|--yatim piatu] ] [ ]
git pemeriksaan [-f|--milik kita|--milik mereka|-m|--conflict= ] [] [--] ...
git pemeriksaan [-p|--patch] [ ] [-] [ ...]

DESKRIPSI

Memperbarui file di pohon kerja agar sesuai dengan versi dalam indeks atau pohon yang ditentukan.
Jika tidak ada jalan yang diberikan, git pemeriksaan juga akan memperbarui HEAD untuk mengatur cabang yang ditentukan sebagai
cabang saat ini.

git pemeriksaan
Untuk mempersiapkan bekerja pada , alihkan dengan memperbarui indeks dan file
di pohon kerja, dan dengan menunjuk KEPALA di cabang. Modifikasi lokal untuk
file di pohon kerja disimpan, sehingga mereka dapat dikomit ke .

Jika tidak ditemukan tetapi ada cabang pelacakan tepat di satu remote
(sebut saja ) dengan nama yang cocok, perlakukan sebagai setara dengan

$ git checkout -b --melacak /

Anda bisa menghilangkan , dalam hal ini perintah berubah menjadi "periksa
cabang saat ini", yang merupakan no-op yang dimuliakan dengan efek samping yang agak mahal untuk
hanya tampilkan informasi pelacakan, jika ada, untuk cabang saat ini.

git pemeriksaan -b|-B [ ]
Menentukan -b menyebabkan cabang baru dibuat seolah-olah git-cabang(1) dipanggil dan
kemudian diperiksa. Dalam hal ini Anda dapat menggunakan opsi --track atau --no-track, yang
akan diteruskan ke git cabang. Sebagai kenyamanan, --track tanpa -b menyiratkan cabang
penciptaan; lihat deskripsi --track di bawah ini.

Jika -B diberikan, dibuat jika tidak ada; jika tidak, itu diatur ulang.
Ini adalah padanan transaksional dari

$ git cabang -f [ ]
$git checkout

artinya, cabang tidak disetel ulang/dibuat kecuali "git checkout" berhasil.

git pemeriksaan --lepaskan [ ], git pemeriksaan [--melepaskan]
Bersiaplah untuk bekerja di atas , dengan melepaskan HEAD (lihat "LEPAS KEPALA"
bagian), dan memperbarui indeks dan file di pohon kerja. Lokal
modifikasi pada file di pohon kerja disimpan, sehingga hasil kerja
tree akan menjadi status yang direkam dalam komit ditambah modifikasi lokal.

Ketika argumen adalah nama cabang, opsi --detach dapat digunakan untuk melepaskan
KEPALA di ujung cabang (git checkout akan memeriksa cabang itu
tanpa melepaskan KEPALA).

Menghilangkan melepaskan HEAD di ujung cabang saat ini.

git pemeriksaan [-p|--patch] [ ] [--] ...
Kapan atau --patch diberikan, git pemeriksaan tidak tidak beralih cabang. Ini memperbarui
jalur bernama di pohon kerja dari file indeks atau dari nama
(paling sering komit). Dalam hal ini, opsi -b dan --track tidak ada artinya dan
memberikan salah satu dari mereka menghasilkan kesalahan. NS argumen dapat digunakan untuk
tentukan tree-ish tertentu (yaitu komit, tag atau pohon) untuk memperbarui indeks untuk
jalur yang diberikan sebelum memperbarui pohon kerja.

git pemeriksaan dengan atau --patch digunakan untuk memulihkan jalur yang dimodifikasi atau dihapus ke
konten aslinya dari indeks atau ganti jalur dengan konten dari yang bernama
(paling sering merupakan komitmen).

Indeks mungkin berisi entri yang tidak digabungkan karena penggabungan yang gagal sebelumnya. Secara default,
jika Anda mencoba untuk memeriksa entri seperti itu dari indeks, operasi checkout akan gagal
dan tidak ada yang akan diperiksa. Menggunakan -f akan mengabaikan entri yang tidak digabungkan ini. NS
konten dari sisi tertentu penggabungan dapat diperiksa dari indeks dengan menggunakan
--milik kita atau --milik mereka. Dengan -m, perubahan yang dibuat pada file pohon kerja dapat dibuang ke
buat kembali hasil penggabungan konflik asli.

PILIHAN

-q, --tenang
Tenang, tekan pesan umpan balik.

--[tidak ada perkembangan
Status kemajuan dilaporkan pada aliran kesalahan standar secara default ketika itu
dilampirkan ke terminal, kecuali --quiet ditentukan. Bendera ini memungkinkan kemajuan
pelaporan bahkan jika tidak terpasang ke terminal, terlepas dari --quiet.

-f, --kekuatan
Saat berpindah cabang, lanjutkan meskipun indeks atau pohon kerja berbeda dari
KEPALA. Ini digunakan untuk membuang perubahan lokal.

Saat memeriksa jalur dari indeks, jangan gagal pada entri yang tidak digabungkan; sebagai gantinya,
entri yang tidak digabungkan akan diabaikan.

--milik kita, --milik mereka
Saat memeriksa jalur dari indeks, periksa tahap #2 (menanggung) atau #3 (mereka) Untuk
jalur yang tidak menyatu.

Perhatikan bahwa selama git rebase dan git pull --rebase, menanggung dan mereka mungkin tampak tertukar;
--ours memberikan versi dari cabang yang menjadi dasar perubahan, sementara --theirs
memberikan versi dari cabang yang menampung pekerjaan Anda yang sedang dibuat ulang.

Ini karena rebase digunakan dalam alur kerja yang memperlakukan riwayat di jarak jauh sebagai
yang kanonik bersama, dan memperlakukan pekerjaan yang dilakukan pada cabang yang Anda rebasing sebagai
pekerjaan pihak ketiga untuk diintegrasikan, dan Anda untuk sementara mengambil peran
penjaga sejarah kanonik selama rebase. Sebagai penjaga kanonik
sejarah, Anda perlu melihat sejarah dari jarak jauh sebagai milik kita (yaitu "kita bersama
sejarah kanonik"), sedangkan apa yang Anda lakukan di sisi Anda bercabang sebagai milik mereka (yaitu "satu
pekerjaan kontributor di atasnya").

-B
Buat cabang baru bernama dan mulai di ; Lihat git-
cabang(1) untuk rincian.

-B
Membuat cabang dan mulai di ; jika sudah ada,
lalu setel ulang ke . Ini sama dengan menjalankan "git branch" dengan "-f";
melihat git-cabang(1) untuk rincian.

-t, --lacak
Saat membuat cabang baru, atur konfigurasi "upstream". Lihat "--track" di git-
cabang(1) untuk rincian.

Jika tidak -b pilihan diberikan, nama cabang baru akan diturunkan dari
cabang pelacakan jarak jauh, dengan melihat bagian lokal dari refspec yang dikonfigurasi untuk
remote yang sesuai, dan kemudian melucuti bagian awal hingga "*". Ini akan
beri tahu kami untuk menggunakan "retas" sebagai cabang lokal saat bercabang dari "asal/retas" (atau
"jarak jauh/asal/retas", atau bahkan "ref/remote/asal/retas"). Jika nama yang diberikan tidak memiliki
slash, atau tebakan di atas menghasilkan nama kosong, tebakan dibatalkan. Anda
dapat secara eksplisit memberi nama dengan -b dalam kasus seperti itu.

--tidak ada jalur
Jangan mengatur konfigurasi "upstream", meskipun branch.autoSetupMerge
variabel konfigurasi benar.

-l
Buat reflog cabang baru; Lihat git-cabang(1) untuk rincian.

--melepaskan
Daripada memeriksa cabang untuk mengerjakannya, periksa komit untuk inspeksi dan
eksperimen yang dapat dibuang. Ini adalah perilaku default "git checkout " Kapan
bukan nama cabang. Lihat bagian "KEPALA TERLEPAS" di bawah ini untuk detailnya.

--yatim piatu
Buat yang baru anak yatim cabang, bernama , dimulai dari dan beralih
untuk itu. Komit pertama yang dibuat di cabang baru ini tidak akan memiliki orang tua dan itu akan menjadi
akar sejarah baru benar-benar terputus dari semua cabang lain dan
berkomitmen.

Indeks dan pohon kerja disesuaikan seolah-olah Anda sebelumnya menjalankan "git checkout
". Ini memungkinkan Anda untuk memulai sejarah baru yang mencatat serangkaian jalur
mirip dengan dengan menjalankan "git commit -a" dengan mudah untuk membuat root commit.

Ini bisa berguna ketika Anda ingin mempublikasikan pohon dari komit tanpa mengekspos
sejarah lengkapnya. Anda mungkin ingin melakukan ini untuk menerbitkan cabang sumber terbuka dari a
proyek yang pohonnya saat ini "bersih", tetapi riwayat lengkapnya berisi or
jika tidak, bit kode terbebani.

Jika Anda ingin memulai riwayat terputus yang merekam serangkaian jalur yang
benar-benar berbeda dari yang satu , maka Anda harus menghapus indeks dan
pohon yang berfungsi tepat setelah membuat cabang yatim piatu dengan menjalankan "git rm -rf ." dari
tingkat atas dari pohon kerja. Setelah itu Anda akan siap untuk mempersiapkan yang baru
file, mengisi kembali pohon kerja, dengan menyalinnya dari tempat lain, mengekstraksi a
tarbal, dll.

--abaikan-lewati-pohon kerja-bit
Dalam mode checkout jarang, git checkout -- hanya akan memperbarui entri yang cocok dengan
dan pola jarang di $GIT_DIR/info/sparse-checkout. Opsi ini mengabaikan
pola jarang dan menambahkan kembali file apa pun di .

-m, --gabung
Saat berpindah cabang, jika Anda memiliki modifikasi lokal ke satu atau lebih file yang
berbeda antara cabang saat ini dan cabang yang Anda alihkan,
perintah menolak untuk berpindah cabang untuk mempertahankan modifikasi Anda dalam konteks.
Namun, dengan opsi ini, penggabungan tiga arah antara cabang saat ini, pekerjaan Anda
isi pohon, dan cabang baru selesai, dan Anda akan berada di cabang baru.

Ketika konflik penggabungan terjadi, entri indeks untuk jalur yang berkonflik dibiarkan
tidak digabungkan, dan Anda perlu menyelesaikan konflik dan menandai jalur yang diselesaikan dengan git
add (atau git rm jika penggabungan harus menghasilkan penghapusan jalur).

Saat memeriksa jalur dari indeks, opsi ini memungkinkan Anda membuat ulang yang berkonflik
bergabung di jalur yang ditentukan.

--konflik=
Sama seperti opsi --merge di atas, tetapi mengubah cara orang-orang yang berkonflik
disajikan, mengesampingkan variabel konfigurasi merge.conflictStyle. Nilai yang mungkin
adalah "merge" (default) dan "diff3" (selain apa yang ditunjukkan oleh gaya "merge",
menunjukkan isi aslinya).

-p, --tambalan
Pilih bingkah secara interaktif dalam perbedaan antara (atau indeks, jika
tidak ditentukan) dan pohon kerja. Bakhil yang dipilih kemudian diterapkan secara terbalik ke
pohon kerja (dan jika a ditentukan, indeks).

Ini berarti Anda dapat menggunakan git checkout -p untuk membuang suntingan secara selektif dari
pohon kerja saat ini. Lihat bagian "Mode Interaktif" dari git-tambahkan(1) untuk mempelajari caranya
mengoperasikan mode --patch.

--abaikan-pekerjaan-lainnya
git checkout menolak ketika ref yang diinginkan sudah diperiksa oleh worktree lain.
Opsi ini membuatnya tetap memeriksa ref. Dengan kata lain, wasit dapat dipegang oleh
lebih dari satu pohon kerja.


Cabang untuk checkout; jika mengacu pada cabang (yaitu, nama yang, bila diawali dengan
"refs/heads/", adalah referensi yang valid), maka cabang tersebut akan diperiksa. Jika tidak, jika
mengacu pada komit yang valid, KEPALA Anda menjadi "terlepas" dan Anda tidak lagi berada di mana pun
cabang (lihat di bawah untuk detailnya).

Sebagai kasus khusus, sintaks "@{-N}" untuk cabang/komit ke-N terakhir diperiksa
cabang (bukan memisahkan). Anda juga dapat menentukan - yang identik dengan
"@{-1}".

Sebagai kasus khusus lebih lanjut, Anda dapat menggunakan "A...B" sebagai jalan pintas untuk basis gabungan A
dan B jika ada tepat satu basis gabungan. Anda dapat meninggalkan paling banyak satu dari A dan B, di
dalam hal ini defaultnya adalah HEAD.


Nama untuk cabang baru.


Nama komit untuk memulai cabang baru; Lihat git-cabang(1) untuk rincian.
Default ke KEPALA.


Pohon untuk checkout dari (ketika jalur diberikan). Jika tidak ditentukan, indeks akan menjadi
bekas.

TERPISAH KEPALA

HEAD biasanya mengacu pada cabang bernama (mis menguasai). Sementara itu, setiap cabang mengacu pada
komit tertentu. Mari kita lihat repo dengan tiga komit, salah satunya ditandai, dan dengan
cabang menguasai memeriksa:

HEAD (mengacu pada cabang 'master')
|
v
a---b---c cabang 'master' (mengacu pada komit 'c')
^
|
tag 'v2.0' (mengacu pada komit 'b')

Saat komit dibuat dalam keadaan ini, cabang diperbarui untuk merujuk ke komit baru.
Secara khusus, git melakukan membuat komitmen baru d, yang orang tuanya komit c, Dan kemudian
cabang pembaruan menguasai untuk merujuk ke komit baru d. HEAD masih mengacu pada cabang menguasai dan sebagainya
secara tidak langsung sekarang mengacu pada komit d:

$mengedit; git tambahkan; git komit

HEAD (mengacu pada cabang 'master')
|
v
a---b---c---d cabang 'master' (mengacu pada komit 'd')
^
|
tag 'v2.0' (mengacu pada komit 'b')

Terkadang berguna untuk dapat memeriksa komit yang tidak ada di ujung nama apa pun
cabang, atau bahkan untuk membuat komit baru yang tidak direferensikan oleh cabang bernama. mari kita
lihat apa yang terjadi ketika kita checkout komit b (di sini kami menunjukkan dua cara ini dapat dilakukan):

$ git checkout v2.0 # atau
$git checkout master^^

HEAD (mengacu pada komit 'b')
|
v
a---b---c---d cabang 'master' (mengacu pada komit 'd')
^
|
tag 'v2.0' (mengacu pada komit 'b')

Perhatikan bahwa terlepas dari perintah checkout mana yang kita gunakan, HEAD sekarang merujuk langsung ke
melakukan b. Ini dikenal sebagai keadaan HEAD yang terpisah. Ini berarti bahwa HEAD merujuk
ke komit tertentu, sebagai lawan merujuk ke cabang bernama. Mari lihat apa yang terjadi
saat kita membuat komit:

$mengedit; git tambahkan; git komit

HEAD (mengacu pada komit 'e')
|
v
e
/
a---b---c---d cabang 'master' (mengacu pada komit 'd')
^
|
tag 'v2.0' (mengacu pada komit 'b')

Sekarang ada komitmen baru e, tetapi hanya direferensikan oleh HEAD. Kami tentu saja dapat menambahkan
komit lain dalam keadaan ini:

$mengedit; git tambahkan; git komit

HEAD (mengacu pada komit 'f')
|
v
e---f
/
a---b---c---d cabang 'master' (mengacu pada komit 'd')
^
|
tag 'v2.0' (mengacu pada komit 'b')

Faktanya, kita dapat melakukan semua operasi Git normal. Tapi, mari kita lihat apa yang terjadi
ketika kami kemudian checkout master:

$git checkout master

HEAD (mengacu pada cabang 'master')
e--f |
/v
a---b---c---d cabang 'master' (mengacu pada komit 'd')
^
|
tag 'v2.0' (mengacu pada komit 'b')

Penting untuk disadari bahwa pada titik ini tidak ada yang mengacu pada komitmen f. Akhirnya
melakukan f (dan dengan ekstensi komit e) akan dihapus oleh pengumpulan sampah rutin Git
proses, kecuali kita membuat referensi sebelum itu terjadi. Jika kita belum pindah
dari komit f, salah satu dari ini akan membuat referensi ke sana:

$ git checkout -b foo (1)
$ git cabang foo (2)
$git tag foo (3)

1. membuat cabang baru foo, yang mengacu pada komit f, lalu perbarui HEAD untuk merujuk ke
cabang foo. Dengan kata lain, kita tidak akan lagi berada dalam status HEAD terpisah setelah perintah ini.
2. sama membuat cabang baru foo, yang mengacu pada komit f, tetapi membiarkan HEAD terlepas.
3. membuat tag baru foo, yang mengacu pada komit f, membiarkan HEAD terlepas.

Jika kita telah pindah dari komit f, maka pertama-tama kita harus memulihkan nama objeknya (biasanya
dengan menggunakan git reflog), dan kemudian kita dapat membuat referensi untuk itu. Misalnya, untuk melihat
dua komit terakhir yang dirujuk HEAD, kita dapat menggunakan salah satu dari perintah ini:

$ git reflog -2 KEPALA # atau
$ git log -g -2 KEPALA

CONTOH

1. Urutan berikut memeriksa cabang master, mengembalikan Makefile menjadi dua
revisi kembali, menghapus hello.c karena kesalahan, dan mendapatkannya kembali dari indeks.

$git checkout master (1)
$ git checkout master~2 Makefile (2)
$ rm -f halo.c
$git checkout halo.c (3)

1. beralih cabang
2. ambil file dari komit lain
3. pulihkan hello.c dari indeks

Jika Anda ingin memeriksa semua File sumber C keluar dari indeks, Anda dapat mengatakan

$ git checkout -- '*.c'

Perhatikan kutipan di sekitar *.c. File hello.c juga akan diperiksa, meskipun itu
tidak lagi di pohon kerja, karena file globbing digunakan untuk mencocokkan entri
dalam indeks (bukan di pohon kerja oleh Shell).

Jika Anda memiliki cabang malang bernama hello.c, langkah ini akan membingungkan
sebagai instruksi untuk beralih ke cabang itu. Anda seharusnya menulis:

$ git checkout -- halo.c

2. Setelah bekerja di cabang yang salah, beralih ke cabang yang benar akan dilakukan
menggunakan:

$ git checkout topik saya

Namun, cabang "salah" Anda dan cabang "mytopic" yang benar mungkin berbeda dalam file yang Anda
telah dimodifikasi secara lokal, dalam hal ini checkout di atas akan gagal seperti ini:

$ git checkout topik saya
error: Anda memiliki perubahan lokal pada 'frotz'; tidak berpindah cabang.

Anda dapat memberikan tanda -m ke perintah, yang akan mencoba penggabungan tiga arah:

$ git checkout -m topik saya
Penggabungan otomatis frotz

Setelah penggabungan tiga arah ini, modifikasi lokal adalah tidak terdaftar di indeks Anda
file, jadi git diff akan menunjukkan kepada Anda perubahan apa yang Anda buat sejak ujung yang baru
cabang.

3. Ketika konflik penggabungan terjadi selama berpindah cabang dengan opsi -m, Anda akan
melihat sesuatu seperti ini:

$ git checkout -m topik saya
Penggabungan otomatis frotz
KESALAHAN: Gabungkan konflik dalam frotz
fatal: menggabungkan program gagal

Pada titik ini, git diff menunjukkan perubahan yang digabungkan dengan rapi seperti pada contoh sebelumnya,
serta perubahan dalam file yang berkonflik. Edit dan selesaikan konflik dan tandai
itu diselesaikan dengan git add seperti biasa:

$ sunting frotz
$ git tambahkan frotz

GIT

Bagian dari git(1) kamar

Gunakan git-checkout online menggunakan layanan onworks.net