Bagaimana saya bisa mengatur ulang atau mengembalikan file ke revisi tertentu?

Saya telah membuat beberapa perubahan pada file yang telah dilakukan beberapa kali sebagai bagian dari grup file, tetapi sekarang ingin mengatur ulang / mengembalikan perubahan di dalamnya kembali ke versi sebelumnya.

Saya telah melakukan git logbersama dengan git diffuntuk menemukan revisi yang saya butuhkan, tetapi hanya tidak tahu bagaimana mengembalikan file ke keadaan semula di masa lalu.

Dengan asumsi hash dari commit yang Anda inginkan adalah c5f567:

git checkout c5f567 -- file1/to/restore file2/to/restore

The checkout git halaman manual memberikan informasi lebih lanjut.

Jika Anda ingin kembali ke komit sebelumnya c5f567, tambahkan ~1(di mana 1 adalah jumlah komit yang ingin Anda kembali, itu bisa berupa apa saja):

git checkout c5f567~1 -- file1/to/restore file2/to/restore

Sebagai catatan, saya selalu merasa tidak nyaman dengan perintah ini karena ini digunakan untuk hal-hal biasa (perubahan antar cabang) dan hal-hal yang tidak biasa dan merusak (membuang perubahan dalam direktori kerja).

Anda dapat dengan cepat meninjau perubahan yang dilakukan pada file menggunakan perintah diff:

git diff <commit hash> <filename>

Kemudian untuk mengembalikan file tertentu ke komit tersebut gunakan perintah reset:

git reset <commit hash> <filename>

Anda mungkin perlu menggunakan --hardopsi ini jika memiliki modifikasi lokal.

Alur kerja yang baik untuk mengelola titik jalan adalah dengan menggunakan tag untuk menandai poin di garis waktu Anda. Saya tidak mengerti kalimat terakhir Anda, tetapi yang Anda inginkan adalah menyimpang dari cabang dari titik waktu sebelumnya. Untuk melakukan ini, gunakan perintah checkout berguna:

git checkout <commit hash>
git checkout -b <new branch name>

Anda kemudian dapat melakukan rebase terhadap garis utama Anda ketika Anda siap untuk menggabungkan perubahan itu:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Anda dapat menggunakan referensi apa pun untuk komit git, termasuk SHA-1 jika itu yang paling nyaman. Intinya adalah bahwa perintahnya terlihat seperti ini:

git checkout [commit-ref] -- [filename]

git checkout -- foo

Itu akan diatur ulang fooke KEPALA. Anda juga bisa:

git checkout HEAD^ foo

untuk satu revisi kembali, dll.

Dan untuk kembali ke versi terakhir yang berkomitmen, yang paling sering dibutuhkan, Anda dapat menggunakan perintah yang lebih sederhana ini.

git checkout HEAD file/to/restore

Saya memiliki masalah yang sama sekarang dan saya menemukan jawaban ini paling mudah untuk dipahami ( commit-refadalah nilai SHA dari perubahan dalam log yang ingin Anda kembali ke):

git checkout [commit-ref] [filename]

Ini akan menempatkan versi lama itu di direktori kerja Anda dan dari sana Anda bisa mengkomitnya jika mau.

Jika Anda tahu berapa banyak komitmen yang harus Anda kembalikan, Anda dapat menggunakan:

git checkout master~5 image.png

Ini mengasumsikan bahwa Anda berada di mastercabang, dan versi yang Anda inginkan adalah 5 komit kembali.

Saya pikir saya sudah menemukannya .... dari http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Terkadang Anda hanya ingin kembali dan melupakan setiap perubahan yang melewati titik tertentu karena semuanya salah.

Dimulai dari:

$ git log

yang menunjukkan daftar komit terbaru, dan hash SHA1 mereka.

Selanjutnya, ketik:

$ git reset --hard SHA1_HASH

untuk mengembalikan status ke komit yang diberikan dan menghapus semua komit yang lebih baru dari catatan secara permanen.

Ini bekerja untuk saya:

git checkout <commit hash> file

Kemudian lakukan perubahan:

git commit -a

Anda harus berhati-hati ketika mengatakan "kembalikan". Jika Anda dulu memiliki satu versi file dalam komit $ A, dan kemudian membuat dua perubahan dalam dua komit terpisah $ B dan $ C (jadi yang Anda lihat adalah iterasi ketiga file), dan jika Anda mengatakan " Saya ingin kembali ke yang pertama ", apakah Anda sungguh-sungguh?

Jika Anda ingin menyingkirkan perubahan iterasi kedua dan ketiga, ini sangat sederhana:

$ git checkout $A file

dan kemudian Anda melakukan hasilnya. Perintah bertanya "Saya ingin memeriksa file dari negara yang direkam oleh komit $ A".

Di sisi lain, apa yang Anda maksudkan adalah untuk menyingkirkan perubahan iterasi kedua (yaitu komit $ B) yang dibawa, sambil menjaga apa yang komit $ C lakukan untuk file, Anda ingin mengembalikan $ B

$ git revert $B

Perhatikan bahwa siapa pun yang membuat komit $ B mungkin tidak terlalu disiplin dan mungkin telah melakukan perubahan yang sama sekali tidak terkait dalam komit yang sama, dan pengembalian ini dapat menyentuh file selain file yang Anda lihat menyinggung perubahan, jadi Anda mungkin ingin memeriksa hasilnya dengan hati-hati setelah melakukan begitu.

Yang mengherankan, git checkout footidak akan berfungsi jika copy pekerjaan dalam direktori bernama foo; namun, keduanya git checkout HEAD foodan git checkout ./fooakan:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

Begini cara rebasekerjanya:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Anggaplah Anda memilikinya

---o----o----o----o  master
    \---A----B       <my branch>

Dua perintah pertama ... melakukan git checkout git rebase master

... periksa cabang perubahan yang ingin Anda terapkan ke mastercabang. The rebaseperintah mengambil komit dari <my branch>(yang tidak ditemukan di master) dan reapplies mereka ke kepala master. Dengan kata lain, orang tua dari komit pertama <my branch>tidak lagi komit sebelumnya dalam mastersejarah, tetapi kepala saat ini master. Kedua perintah itu sama dengan:

git rebase master <my branch>

Mungkin lebih mudah untuk mengingat perintah ini karena cabang "basis" dan "modifikasi" adalah eksplisit.

. Hasil sejarah terakhir adalah:

---o----o----o----o   master
                   \----A'----B'  <my branch>

Dua perintah terakhir ...

git checkout master
git merge <my branch>

... lakukan penggabungan maju-cepat untuk menerapkan semua <my branch>perubahan master. Tanpa langkah ini, komit rebase tidak akan ditambahkan master. Hasil akhirnya adalah:

---o----o----o----o----A'----B'  master, <my branch>

masterdan <my branch>keduanya referensi B'. Juga, dari titik ini aman untuk menghapus <my branch>referensi.

git branch -d <my branch>

Pada git v2.23.0 ada metode git restore baru yang seharusnya mengambil bagian dari apa git checkoutyang bertanggung jawab (bahkan jawaban yang diterima menyebutkan itu git checkoutcukup membingungkan). Lihat sorotan perubahan di blog github .

Perilaku default dari perintah ini adalah mengembalikan status pohon yang berfungsi dengan konten yang berasal dari sourceparameter (yang dalam kasus Anda akan menjadi hash komit).

Jadi berdasarkan jawaban Greg Hewgill (dengan asumsi hash adalah c5f567) perintah akan terlihat seperti ini:

git restore --source=c5f567 file1/to/restore file2/to/restore

Atau jika Anda ingin mengembalikan ke konten dari satu commit sebelum c5f567:

git restore --source=c5f567~1 file1/to/restore file2/to/restore

Atur Ulang Kepala Pertama Untuk File Target

git reset HEAD path_to_file

Checkout Kedua File Itu

git checkout -- path_to_file

git-alias, awk dan shell-functions untuk menyelamatkan!

git prevision <N> <filename>

di mana <N>jumlah revisi file untuk mengembalikan file <filename>.
Misalnya, untuk checkout revisi sebelumnya dari satu file x/y/z.c, jalankan

git prevision -1 x/y/z.c

Bagaimana cara kerja previsi git?

Tambahkan berikut ini ke gitconfig

[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

Perintah pada dasarnya

• melakukan git logpada file yang ditentukan dan
• mengambil komit-id yang sesuai dalam sejarah file dan
• mengeksekusi a git checkoutke komit-id untuk file yang ditentukan.

Pada dasarnya, semua yang akan dilakukan secara manual dalam situasi ini,
terbungkus dalam satu yang indah, efisien git-alias - git-prevision

Saya harus memasang EasyGit di sini, yang merupakan pembungkus untuk membuat git lebih mudah didekati oleh para pemula tanpa membingungkan pengguna berpengalaman. Salah satu hal yang dilakukannya adalah memberi lebih banyak maknagit revert . Dalam hal ini, Anda cukup mengatakan:

eg revert foo/bar foo/baz

Jika Anda ingin mengembalikan file ke komit sebelumnya (dan file yang ingin Anda kembalikan sudah komit), Anda dapat menggunakan

git checkout HEAD^1 path/to/file

atau

git checkout HEAD~1 path/to/file

Kemudian tinggal panggung dan komit versi "baru".

Berbekal pengetahuan bahwa komit dapat memiliki dua orang tua dalam kasus penggabungan, Anda harus tahu bahwa HEAD ^ 1 adalah orangtua pertama dan HEAD ~ 1 adalah orangtua kedua.

Entah akan bekerja jika hanya ada satu orangtua di pohon.

Banyak saran di sini, sebagian besar sejalan git checkout $revision -- $file. Beberapa alternatif yang tidak jelas:

git show $revision:$file > $file

Dan juga, saya sering menggunakan ini hanya untuk melihat versi tertentu sementara:

git show $revision:$file

atau

git show $revision:$file | vim -R -

(OBS: $fileperlu diawali dengan ./jika itu adalah jalur relatif untuk git show $revision:$filebekerja)

Dan yang lebih aneh:

git archive $revision $file | tar -x0 > $file

Perhatikan, bagaimanapun, itu git checkout ./foodan git checkout HEAD ./foo bukan hal yang persis sama; Inti masalah:

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

(Tahap kedua addfile dalam indeks, tetapi tidak mendapatkan komitmen.)

Git checkout ./fooberarti mengembalikan jalur ./foodari indeks ; menambahkan HEADmenginstruksikan Git untuk mengembalikan jalur itu dalam indeks ke HEADrevisi sebelum melakukannya.

Bagi saya tidak ada jawaban yang tampak sangat jelas dan karena itu saya ingin menambahkan milik saya yang tampaknya sangat mudah.

Saya memiliki komit abc1dan setelah itu saya telah melakukan beberapa (atau satu modifikasi) untuk sebuah file file.txt.

Sekarang katakan bahwa saya mengacaukan sesuatu dalam file file.txtdan saya ingin kembali ke komit sebelumnya abc1.

1 git checkout file.txt.: ini akan menghapus perubahan lokal, jika Anda tidak membutuhkannya

2 git checkout abc1 file.txt.: ini akan membawa file Anda ke versi yang Anda inginkan

3 git commit -m "Restored file.txt to version abc1".: ini akan melakukan pengembalian Anda.

4. git push : ini akan mendorong semuanya pada repositori jarak jauh

Antara langkah 2 dan 3 tentu saja bisa Anda lakukan git statusuntuk memahami apa yang sedang terjadi. Biasanya Anda harus melihat yang file.txtsudah ditambahkan dan itu sebabnya tidak perlu a git add.

1. Git kembalikan file ke komit tertentu

git checkout Last_Stable_commit_Number -- fileName

2.Git kembalikan file ke cabang tertentu

git checkout branchName_Which_Has_stable_Commit fileName

Untuk membuka versi komit file sebelumnya, dapatkan nomor komit, katakanlah eb917a1 lalu

git checkout eb917a1 YourFileName

Jika Anda hanya perlu kembali ke versi komit terakhir

git reset HEAD YourFileName
git checkout YourFileName

Ini hanya akan membawa Anda ke status file terakhir yang dikomit

git checkout ref | commitHash - filePath

misalnya

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

Banyak jawaban di sini mengklaim untuk menggunakan git reset ... <file>atau git checkout ... <file>tetapi dengan melakukannya, Anda akan kehilangan setiap modifikasi pada <file>komitmen setelah komit yang ingin Anda kembalikan.

Jika Anda ingin mengembalikan perubahan dari satu komit pada satu file saja, seperti yang git revertakan dilakukan tetapi hanya untuk satu file (atau mengatakan subset dari file komit), saya sarankan untuk menggunakan keduanya git diffdan git applyseperti itu (dengan <sha>= hash dari komit yang ingin Anda kembalikan):

git diff <sha>^ <sha> path/to/file.ext | git apply -R

Pada dasarnya, ini pertama-tama akan menghasilkan tambalan yang sesuai dengan perubahan yang ingin Anda kembalikan, dan kemudian balas menerapkan tambalan untuk menjatuhkan perubahan itu.

Tentu saja, itu tidak akan berfungsi jika garis yang dikembalikan telah dimodifikasi oleh komit antara <sha1>dan HEAD(konflik).

Gunakan git loguntuk mendapatkan kunci hash untuk versi tertentu dan kemudian gunakangit checkout <hashkey>

Catatan: Jangan lupa mengetik hash sebelum yang terakhir. Hash terakhir menunjukkan posisi Anda saat ini (KEPALA) dan tidak mengubah apa pun.

Jelas seseorang perlu menulis buku yang dapat dimengerti tentang git, atau git perlu dijelaskan dengan lebih baik dalam dokumentasi. Menghadapi masalah yang sama, saya rasa itu

cd <working copy>
git revert master

akan membatalkan komitmen terakhir yang tampaknya dilakukan.

Ian

Anda dapat melakukannya dalam 4 langkah:

1. kembalikan seluruh komit dengan file yang ingin Anda kembalikan secara spesifik - ini akan membuat komit baru di cabang Anda
2. reset lunak komit - menghapus komit dan memindahkan perubahan ke area kerja
3. pilih sendiri file untuk mengembalikan dan mengkomitnya
4. letakkan semua file lain di area kerja Anda

Apa yang perlu Anda ketik di terminal Anda :

1. git revert <commit_hash>
2. git reset HEAD~1
3. git add <file_i_want_to_revert> && git commit -m 'reverting file'
4. git checkout .

semoga berhasil

Ini adalah langkah yang sangat sederhana. Periksa file ke id komit yang kita inginkan, di sini satu komit id sebelumnya, dan kemudian git komit ubah dan kita selesai.

# git checkout <previous commit_id> <file_name>
# git commit --amend

Ini sangat berguna. Jika kita ingin membawa file apa pun ke id komit sebelumnya di bagian atas komit, kita dapat dengan mudah melakukannya.

git revert <hash>

Akan mengembalikan komit yang diberikan. Sepertinya menurut Anda git reverthanya mempengaruhi komit terbaru.

Itu tidak menyelesaikan masalah Anda, jika Anda ingin mengembalikan perubahan pada file tertentu dan komit berubah lebih dari file itu.

jika Anda melakukan file yang salah dalam komit terakhir Anda ikuti instruksi:

1. open source tree, ubah komit ini

2. ubah baris dan temukan komit Anda bahwa file yang salah terkirim sebagai komit

3. Anda dapat melihat daftar perubahan Anda di komit itu
4. pilih dan kemudian klik ... tombol sebelah kanan ... klik membalikkan file
5. maka Anda dapat melihatnya di tab status file di sisi kiri bawah lalu klik unstage:

6. buka kode studio visual Anda dan kembalikan dengan melakukan file yang dihapus
7. setelah semua itu, Anda dapat melihat hasil dalam komit terakhir di bagan sumber