Bagaimana cara membatalkan komitmen terbaru di Git?

Membatalkan komit agak menakutkan jika Anda tidak tahu cara kerjanya. Tetapi sebenarnya sangat mudah jika Anda mengerti.

Katakan Anda memilikinya, di mana C adalah HEAD Anda dan (F) adalah status file Anda.

   (F)
A-B-C
    ↑
  master

Anda ingin nuke melakukan C dan tidak pernah melihatnya lagi. Anda melakukan ini:

git reset --hard HEAD~1

Hasilnya adalah:

 (F)
A-B
  ↑
master

Sekarang B adalah KEPALA. Karena Anda menggunakan --hard, file Anda disetel ulang ke statusnya di commit B.

Ah, tapi anggap komit C bukan bencana, tapi hanya sedikit. Anda ingin membatalkan komit tetapi simpan perubahan Anda untuk sedikit pengeditan sebelum Anda melakukan komit yang lebih baik. Mulai lagi dari sini, dengan C sebagai KEPALA Anda:

   (F)
A-B-C
    ↑
  master

Anda dapat melakukan ini, meninggalkan --hard:

git reset HEAD~1

Dalam hal ini hasilnya adalah:

   (F)
A-B-C
  ↑
master

Dalam kedua kasus, HEAD hanyalah sebuah penunjuk ke komit terbaru. Ketika Anda melakukan git reset HEAD~1, Anda memberi tahu Git untuk memindahkan pointer HEAD kembali satu komit. Tetapi (kecuali jika Anda menggunakan --hard), Anda meninggalkan file Anda seperti sebelumnya. Jadi sekarang git status menunjukkan perubahan yang telah Anda periksa di C. Anda tidak kehilangan apa-apa!

Untuk sentuhan paling ringan, Anda bahkan dapat membatalkan komit Anda tetapi meninggalkan file Anda dan indeks:

git reset --soft HEAD~1

Ini tidak hanya meninggalkan file Anda sendiri, bahkan meninggalkan indeks Anda sendiri. Ketika Anda melakukan git status, Anda akan melihat bahwa file yang sama ada dalam indeks seperti sebelumnya. Bahkan, tepat setelah perintah ini, Anda bisa melakukan git commit dan Anda akan mengulangi komit yang sama dengan yang baru saja Anda lakukan.

Satu hal lagi: Misalkan Anda menghancurkan komit seperti pada contoh pertama, tetapi kemudian ternyata Anda membutuhkannya? Keberuntungan yang berat, bukan?

Tidak, ada masih cara untuk mendapatkannya kembali. Ketik git reflog dan Anda akan melihat daftar (sebagian) komit shas (yaitu, hash) yang telah Anda gunakan. Cari komit yang Anda hancurkan, dan lakukan ini:

git checkout -b someNewBranchName shaYouDestroyed

Anda sekarang telah menghidupkan kembali komit itu. Komit tidak benar-benar dihancurkan di Git selama sekitar 90 hari, jadi Anda biasanya bisa kembali dan menyelamatkan yang tidak ingin Anda singkirkan.

Ini membutuhkan waktu beberapa saat untuk mencari tahu, jadi mungkin ini akan membantu seseorang ...

Ada dua cara untuk "membatalkan" komit terakhir Anda, tergantung pada apakah Anda sudah membuat komit Anda publik (didorong ke repositori jauh Anda):

Cara membatalkan komit lokal

Katakanlah saya berkomitmen secara lokal, tetapi sekarang ingin menghapus komitmen itu.

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

Untuk mengembalikan semuanya kembali seperti sebelum komit terakhir, kita perlu reset ke komit sebelum HEAD:

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

Sekarang git log akan menunjukkan bahwa komit terakhir kami telah dihapus.

Cara membatalkan komitmen publik

Jika Anda telah membuat komitmen Anda menjadi publik, Anda ingin membuat komit baru yang akan "mengembalikan" perubahan yang Anda buat pada komit sebelumnya (HEAD saat ini).

git revert HEAD

Perubahan Anda sekarang akan dikembalikan dan siap untuk Anda komit:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Untuk info lebih lanjut, lihat Dasar-Dasar Git - Undoing Things

Tambah/hapus file untuk mendapatkan hal-hal seperti yang Anda inginkan:

git rm classdir
git add sourcedir

Kemudian ubah komit:

git commit --amend

Komit yang salah dan sebelumnya akan diedit untuk mencerminkan status indeks baru - dengan kata lain, itu akan seperti Anda tidak pernah melakukan kesalahan sejak awal.

Perhatikan bahwa Anda hanya harus melakukan ini jika Anda belum mendorong. Jika Anda telah mendorong, maka Anda hanya perlu melakukan perbaikan secara normal.

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

atau

git reset --hard HEAD~1

Peringatan: Perintah di atas akan menghapus modifikasi secara permanen ke file .Java (dan file lainnya) yang ingin Anda komit.

hard reset ke HEAD-1 akan mengatur copy pekerjaan Anda ke status komit sebelum komit yang salah.

Untuk mengubah komit terakhir

Ganti file dalam indeks:

git rm --cached *.class
git add *.Java

Kemudian, jika itu adalah cabang pribadi, ubah komit:

git commit --amend

Atau, jika itu cabang bersama, buat komit baru:

git commit -m 'Replace .class files with .Java files'

(untuk mengubah komit sebelumnya, gunakan rebase yang mengagumkan interaktif )

ProTip ™: Tambahkan *.class ke gitignore untuk menghentikan ini terjadi lagi.

Untuk mengembalikan komit

Mengubah komit adalah solusi ideal jika Anda perlu mengubah komit terakhir, tetapi solusi yang lebih umum adalah reset.

Anda dapat mengatur ulang git ke komit apa pun dengan:

git reset @~N

Di mana N adalah jumlah komit sebelum HEAD, dan @~ direset ke komit sebelumnya.

Jadi, alih-alih mengubah komit, Anda dapat menggunakan:

git reset @~
git add *.Java
git commit -m "Add .Java files"

Lihatlah git help reset, khususnya bagian --soft--mixed dan --hard, untuk pemahaman yang lebih baik tentang apa yang dilakukannya.

Reflog

Jika Anda kacau, Anda selalu dapat menggunakan reflog untuk menemukan komitmen yang dijatuhkan:

$ git reset @~
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~
2c52489 [email protected]{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Gunakan git revert <commit-id>

Untuk mendapatkan ID komit, cukup gunakan git log

Jika Anda berencana untuk membatalkan komit lokal sepenuhnya, apa pun yang Anda ubah Anda lakukan pada komit, dan jika Anda tidak khawatir tentang hal itu, lakukan saja perintah berikut.

git reset --hard HEAD^1

(Perintah ini akan mengabaikan seluruh komit Anda dan perubahan Anda akan hilang sepenuhnya dari pohon kerja lokal Anda). Jika Anda ingin membatalkan komit, tetapi Anda ingin perubahan di area pementasan (sebelum komit seperti setelah git add), maka lakukan perintah berikut.

git reset --soft HEAD^1

Sekarang file berkomitmen Anda datang ke area pementasan. Misalkan jika Anda ingin meng-upgrade file, karena Anda perlu mengedit beberapa konten yang salah, maka lakukan perintah berikut

git reset HEAD

Sekarang file yang dikomit untuk datang dari area yang dipentaskan ke area yang tidak dipentaskan. Sekarang file siap diedit, jadi apa pun yang Anda ubah, Anda ingin pergi mengedit dan menambahkannya dan membuat komit baru/baru.

Lebih Banyak

Jika Anda memiliki Git Extras diinstal, Anda dapat menjalankan git undo untuk membatalkan komit terbaru. git undo 3 akan membatalkan 3 komitmen terakhir.

Saya ingin membatalkan 5 komitmen terbaru di repositori bersama kami. Saya mencari id revisi yang ingin saya kembalikan. Lalu saya mengetik berikut ini.

Prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
Prompt> git Push Origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>

Saya lebih suka menggunakan git rebase -i untuk pekerjaan ini, karena daftar Nice muncul di mana saya dapat memilih komitmen untuk dihilangkan. Mungkin tidak secara langsung seperti beberapa jawaban lain di sini, tetapi hanya terasa benar .

Pilih berapa banyak komit yang ingin Anda daftarkan, kemudian panggil seperti ini (untuk mendaftar tiga terakhir)

git rebase -i HEAD~3

Daftar sampel

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Kemudian Git akan menghapus komit untuk setiap baris yang Anda hapus.

Cara memperbaiki komit lokal sebelumnya

Gunakan git-gui (atau yang serupa) untuk melakukan git commit --amend. Dari GUI Anda dapat menambah atau menghapus file individual dari komit. Anda juga dapat mengubah pesan komit. 

Cara membatalkan komit lokal sebelumnya

Setel ulang cabang Anda ke lokasi sebelumnya (misalnya, menggunakan gitk atau git rebase). Kemudian gunakan kembali perubahan Anda dari salinan yang disimpan. Setelah pengumpulan sampah di repositori lokal Anda, itu akan seperti komit yang tidak diinginkan tidak pernah terjadi. Untuk melakukan semua itu dalam satu perintah, gunakan git reset HEAD~1.

Kata peringatan: Penggunaan git reset secara sembarangan adalah cara yang baik untuk membuat copy pekerjaan Anda dalam keadaan membingungkan. Saya menyarankan agar Git pemula menghindari ini jika mereka bisa.

Cara membatalkan komitmen publik

Lakukan reverse pick cherry ( git-revert ) untuk membatalkan perubahan.

Jika Anda belum menarik perubahan lain ke cabang Anda, Anda bisa melakukan ...

git revert --no-edit HEAD

Kemudian Dorong cabang Anda yang diperbarui ke repositori bersama.

Riwayat komit akan menampilkan kedua commit, secara terpisah.

Tingkat lanjut: Koreksi cabang pribadi di repositori publik

Ini bisa berbahaya - pastikan Anda memiliki salinan cabang setempat untuk diperbaiki.

Perhatikan juga: Anda tidak ingin melakukan ini jika orang lain bekerja di cabang.

git Push --delete (branch_name) ## remove public version of branch

Bersihkan cabang Anda secara lokal lalu ...

git Push Origin (branch_name)

Dalam kasus normal, Anda mungkin tidak perlu khawatir tentang riwayat komit cabang pribadi Anda masih asli. Tekan saja komit tindak lanjut (lihat 'Cara membatalkan komit publik' di atas), dan kemudian, lakukan squash -merge untuk menyembunyikan histori.

Jika Anda telah melakukan sampah tetapi tidak mendorong,

git reset --soft HEAD~1

KEPALA ~ 1 adalah singkatan untuk komit sebelum kepala. Atau Anda dapat merujuk ke SHA-1 dari hash jika Anda ingin mengatur ulang. Opsi --soft akan menghapus komit tetapi akan meninggalkan semua file Anda yang diubah "Perubahan untuk dikomit", seperti yang dikatakan status git.

Jika Anda ingin menyingkirkan perubahan apa pun untuk melacak file di pohon kerja sejak komit sebelum kepala gunakan " --hard " sebagai gantinya.

OR

Jika Anda sudah mendorong dan seseorang menarik yang biasanya merupakan kasus saya, Anda tidak dapat menggunakan git reset. Namun Anda dapat melakukan pengembalian git,

git revert HEAD

Ini akan membuat komit baru yang membalikkan semua yang diperkenalkan oleh komit tidak disengaja.

Jika Anda ingin membatalkannya secara permanen dan Anda telah mengkloning beberapa repositori 

ID komit dapat dilihat oleh 

git log 

Maka Anda bisa melakukan -

git reset --hard <commit_id>

git Push Origin <branch_name> -f

Pada SourceTree (GUI untuk GitHub), Anda dapat mengklik kanan komit dan melakukan 'Komit Balik' Ini harus membatalkan perubahan Anda.

Di terminal:

Anda dapat menggunakan:

git revert

Atau:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

Satu perintah:

git reset --soft 'HEAD^' 

Sangat bagus untuk membatalkan komit lokal terakhir!

Setel ulang dengan melakukan perintah di bawah ini menggunakan git:

git reset --soft HEAD~1

Jelaskan: apa yang git reset lakukan, itu pada dasarnya reset untuk komit yang ingin Anda kembalikan, maka jika Anda menggabungkannya dengan kunci --soft, itu akan kembali, tetapi simpan perubahan dalam file Anda, jadi Anda kembali ke tahap di mana file baru saja ditambahkan, HEAD adalah kepala cabang dan jika Anda bergabung dengan ~1 (dalam hal ini Anda juga menggunakan HEAD^), itu akan kembali hanya satu komit yang Anda inginkan .. .

Saya membuat langkah-langkah pada gambar di bawah ini secara lebih rinci untuk Anda, termasuk semua langkah yang mungkin terjadi dalam situasi nyata dan melakukan kode:

Bagaimana cara membatalkan komit Git terakhir?

Untuk mengembalikan semuanya ke cara sebelum komit terakhir, kita perlu mengatur ulang ke komit sebelum HEAD.

1. Jika Anda tidak ingin menyimpan perubahan yang Anda buat:

   git reset --hard HEAD^
   

2. Jika Anda ingin menyimpan perubahan Anda:

   git reset --soft HEAD^
   

Sekarang periksa git log Anda. Ini akan menunjukkan bahwa komit terakhir kami telah dihapus.

Gunakan reflog untuk menemukan kondisi yang benar

git reflog

REFLOG SEBELUM RESET

Pilih reflog yang benar (f3cb6e2 dalam kasus saya) dan ketik 

git reset --hard f3cb6e2

Setelah itu repo HEAD akan diatur ulang ke HEADid itu LOG SETELAH RESET

Akhirnya reflog terlihat seperti gambar di bawah ini

FINAL REFLOG

"Setel ulang pohon kerja ke komit terakhir"

git reset --hard HEAD^ 

"Bersihkan file yang tidak dikenal dari pohon yang bekerja"

git clean    

lihat - Referensi Cepat Git

CATATAN: Perintah ini akan menghapus komit Anda sebelumnya, jadi gunakan dengan hati-hati! git reset --hard lebih aman -

Lari pertama: 

git reflog

Ini akan menunjukkan kepada Anda semua tindakan yang mungkin telah Anda lakukan pada repositori Anda, misalnya, melakukan, menggabungkan, menarik, dll.

Kemudian lakukan:

git reset --hard ActionIdFromRefLog

Batalkan komit terakhir:

git reset --soft HEAD^ atau git reset --soft HEAD~

Ini akan membatalkan komit terakhir.

Di sini --soft berarti mengatur ulang ke pementasan.

HEAD~ atau HEAD^ artinya pindah ke komit sebelum HEAD.

Ganti komit terakhir ke komit baru:

git commit --amend -m "message"

Ini akan menggantikan komit terakhir dengan komit baru.

Cara lain:

Periksa cabang yang ingin Anda kembalikan, lalu setel ulang copy pekerjaan lokal Anda kembali ke komit yang Anda inginkan menjadi yang terbaru pada server jarak jauh (semuanya setelah itu akan berlalu-bye) Untuk melakukan ini, di SourceTree I klik kanan pada dan pilih "Reset BRANCHNAME ke komit ini".

Kemudian navigasikan ke direktori lokal repositori Anda dan jalankan perintah ini:

git -c diff.mnemonicprefix=false -c core.quotepath=false Push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

Ini akan menghapus semua komit setelah yang sekarang ada di repositori lokal Anda tetapi hanya untuk satu cabang itu.

Ketik git log dan temukan kode hash komit terakhir dan kemudian masukkan:

git reset <the previous co>

Dalam kasus saya, saya secara tidak sengaja melakukan beberapa file yang tidak saya inginkan. Jadi saya melakukan yang berikut dan berhasil:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Verifikasi hasil dengan gitk atau git log --stat

Gunakan SourceTree (alat grafis untuk Git) untuk melihat komit dan pohon Anda. Anda dapat mengatur ulang secara langsung dengan mengklik kanan.

Sederhana, jalankan ini di baris perintah Anda:

git reset --soft HEAD~ 

Untuk mengatur ulang ke revisi sebelumnya, hapus semua perubahan yang tidak dikomit secara permanen: 

git reset --hard HEAD~1

Ada dua skenario utama

Anda belum mendorong komit

Jika masalahnya adalah file tambahan yang Anda komit (dan Anda tidak ingin itu di repositori), Anda dapat menghapusnya menggunakan git rm dan kemudian melakukan dengan --amend

git rm <pathToFile>

Anda juga dapat menghapus seluruh direktori dengan -r, atau bahkan digabung dengan perintah Bash lainnya

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

Setelah menghapus file, Anda dapat melakukan, dengan opsi - ubah

git commit --amend -C HEAD # the -C option is to use the same commit message

Ini akan menulis ulang komit lokal Anda baru-baru ini menghapus file-file tambahan, jadi, file-file ini tidak akan pernah dikirim di Push dan juga akan dihapus dari repositori .git lokal Anda oleh GC.

Anda sudah mendorong komit

Anda dapat menerapkan solusi yang sama dari skenario lain dan kemudian melakukan git Push dengan opsi -f, tetapi ini tidak direkomendasikan karena ini menimpa sejarah jarak jauh dengan perubahan yang berbeda (dapat mengacaukan repositori Anda).

Sebagai gantinya, Anda harus melakukan komit tanpa --amend (ingat ini tentang -amend`: Opsi itu menulis ulang riwayat pada komit terakhir).

Ada banyak cara untuk melakukannya:

Perintah Git untuk membatalkan komit terakhir/komit sebelumnya:

Peringatan: Jangan gunakan --hard jika Anda tidak tahu apa yang Anda lakukan .-- sulit terlalu berbahaya , dan mungkin menghapus file Anda.

Perintah dasar untuk mengembalikan komit di Git adalah:

$ git reset --hard <COMMIT -ID>

atau

$ git reset --hard HEAD~<n>

KOMIT-ID : ID untuk komit

n: adalah jumlah komit terakhir yang ingin Anda kembalikan

Anda bisa mendapatkan id komit seperti yang ditunjukkan di bawah ini:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

di mana d81d3f1 dan be20eb8 adalah id komit.

Sekarang mari kita lihat beberapa kasus:

Misalkan Anda ingin mengembalikan komit terakhir 'd81d3f1'. Berikut adalah dua opsi:

$ git reset --hard d81d3f1

atau

$ git reset --hard HEAD~1

Misalkan Anda ingin mengembalikan komit 'be20eb8':

$ git reset --hard be20eb8

Untuk informasi lebih rinci, Anda dapat merujuk dan mencoba beberapa perintah lain juga untuk mengatur ulang kepala ke kondisi tertentu:

$ git reset --help

Untuk komit lokal

git reset --soft HEAD~1

atau jika Anda tidak ingat persis di mana komit itu, Anda dapat menggunakan

git rm --cached <file>

Untuk komit yang didorong

Cara yang tepat untuk menghapus file dari riwayat repositori menggunakan git filter-branch. Itu adalah,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

Tapi saya sarankan Anda menggunakan perintah ini dengan hati-hati. Baca lebih lanjut di git-filter-branch (1) Halaman Manual.

BAGAIMANA MENGGUNAKAN, reset --soft atau reset --hard?

Saya hanya menambahkan dua sen untuk jawaban @ Kyralessa:

Jika Anda tidak yakin apa yang harus digunakan gunakan --soft (saya menggunakan konvensi ini untuk mengingatnya - s sering aman).

Mengapa?

Jika Anda memilih --hard secara tidak sengaja, Anda akanKEHILANGANperubahan Anda karena bukan sebelumnya . Jika Anda memilih --soft secara tidak sengaja, Anda dapat mencapai hasil yang sama dari --hard dengan menerapkan perintah tambahan

git reset HEAD file.html
git checkout -- file.html

Contoh lengkap

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

Kredit diberikan ke @Kyralessa.

Kamu bisa memakai:

git reset [email protected]{1}

Perintah ini akan menghapus komit yang salah Anda tanpa log Git.

Mengira kami memiliki file code.txt . Kami membuat beberapa perubahan padanya dan melakukan .Kami dapat membatalkan komit ini dalam tiga cara, tetapi pertama-tama Anda harus membatalkannya tahu apa itu file yang dipentaskan ... File yang dipentaskan adalah file yang siap untuk dikomit dan jika Anda menjalankan git status file ini akan ditampilkan dengan warna hijau dan jika ini tidak dipentaskan untuk komit akan ditampilkan dengan warna merah:

Ini berarti jika Anda mengkomit perubahan Anda, perubahan Anda pada file ini tidak disimpan . Anda dapat menambahkan file ini di panggung Anda dengan git add code.txt dan kemudian melakukan perubahan Anda:

Undo komit terakhir:

1. Sekarang jika kita ingin membatalkan komit tanpa perubahan lain, kita dapat menggunakannya

   git reset --soft HEAD^ 

    

2. Jika kami ingin membatalkan komit dan perubahannya (INI IS BERBAHAYA, karena perubahan Anda akan hilang), kita dapat menggunakan

   git reset --hard HEAD^

    

3. Dan jika kita ingin membatalkan komit dan menghapus perubahan dari panggung, kita dapat menggunakan

   git reset --mixed HEAD^ atau dalam bentuk singkat git reset HEAD^

    

Biasanya, Anda ingin membatalkan melakukan karena Anda membuat kesalahan dan Anda ingin memperbaikinya - pada dasarnya apa yang dilakukan OP ketika dia mengajukan pertanyaan. Jadi sungguh, Anda benar-benar ingin mengulang komit.

Sebagian besar jawaban di sini fokus pada baris perintah. Sementara baris perintah adalah cara terbaik untuk menggunakan Git ketika Anda merasa nyaman dengan itu, itu mungkin agak asing bagi mereka yang datang dari sistem kontrol versi lain ke Git. 

Berikut cara melakukannya menggunakan GUI. Jika Anda telah menginstal Git, Anda sudah memiliki semua yang Anda butuhkan untuk mengikuti instruksi ini.

CATATAN: Saya akan berasumsi di sini bahwa Anda menyadari komit itu salah sebelum Anda mendorongnya. Jika Anda tidak tahu apa itu dorongan, Anda mungkin belum mendorong, jadi teruskan dengan instruksinya. Jika Anda telah mendorong komit yang salah, cara yang paling tidak berisiko adalah dengan menindaklanjuti komit yang salah dengan komit baru yang memperbaiki hal-hal, seperti yang Anda lakukan dalam sistem kontrol versi yang tidak memungkinkan Anda untuk menulis ulang sejarah. 

Yang mengatakan, inilah cara untuk memperbaiki komit kesalahan terbaru Anda menggunakan GUI:

1. Arahkan ke repositori Anda di baris perintah dan mulai gui dengan git gui
2. Pilih "Ubah komitmen terakhir". Anda akan melihat pesan komit terakhir Anda, file yang Anda tampilkan, dan file yang tidak Anda lakukan.
3. Sekarang ubah hal-hal sesuai keinginan Anda dan klik Komit. 

Batalkan komitmen terakhir: 

git reset --soft HEAD~

Atau membatalkan waktu sebelum komit terakhir kali: 

git reset --soft HEAD~2

Atau membatalkan komit sebelumnya: 

git reset --soft <commitID>

(Anda bisa mendapatkan komit menggunakan git reflog)

Saat Anda membatalkan komitmen sebelumnya, ingat untuk membersihkan tempat kerja dengannya

git clean

Rincian lebih lanjut dapat ditemukan di dokumen: git-reset

Jika Anda bekerja dengan SourceTree, ini akan membantu Anda.

Klik kanan pada komit kemudian pilih "Atur ulang (cabang saat ini)/master ke komit ini" dan terakhir pilih _ ​​"Soft" reset .

Batalkan Komit Terakhir

Ada banyak situasi di mana Anda benar-benar ingin membatalkan komit terakhir ke dalam kode Anda. Misalnya. karena Anda ingin merestrukturisasi secara luas - atau bahkan membuangnya sama sekali!

Dalam kasus ini, perintah "reset" adalah teman terbaik Anda:

$ git reset --soft HEAD~1

Perintah di atas (reset) akan memundurkan cabang HEAD Anda saat ini ke revisi yang ditentukan. Dalam contoh kami di atas, kami ingin kembali ke yang sebelum revisi saat ini - secara efektif membuat komit terakhir kami dibatalkan.

Perhatikan bendera --soft: ini memastikan bahwa perubahan dalam revisi yang dibatalkan dipertahankan. Setelah menjalankan perintah, Anda akan menemukan perubahan sebagai modifikasi lokal yang tidak dikomit di copy pekerjaan Anda.

Jika Anda tidak ingin menyimpan perubahan ini, cukup gunakan bendera --hard. Pastikan untuk hanya melakukan ini ketika Anda yakin Anda tidak membutuhkan perubahan ini lagi.

$ git reset --hard HEAD~1

Untuk membatalkan komit lokal Anda, Anda menggunakan git reset <commit>. Juga tutorial itu sangat membantu untuk menunjukkan kepada Anda cara kerjanya.

Atau, Anda dapat menggunakan git revert <commit>: reverting harus digunakan ketika Anda ingin menambahkan komit lain yang memutar kembali perubahan (tetapi menyimpannya dalam riwayat proyek).

Siklus Git Khas

Dalam berbicara tentang perintah terkait Git dalam jawaban sebelumnya, saya ingin berbagi siklus Git khas saya dengan semua pembaca yang mungkin membantu. Inilah cara saya bekerja dengan Git,

1. Kloning pertama kali dari server jauh

   git clone $project

2. Menarik dari jarak jauh (ketika saya tidak memiliki komit lokal yang tertunda untuk Push)

   git pull

3. Menambahkan file lokal1 baru ke $ to_be_committed_list (bayangkan $ to_be_committed_list berarti area staged)

   git add $file1

4. Menghapus file2 yang ditambahkan secara keliru dari $ to_be_committed_list (asumsikan file2 ditambahkan seperti langkah 3, yang tidak saya inginkan)

   git reset $file2

5. Mengkomit file1 yang ada di $ to_be_committed_list

   git commit -m "commit message description"

6. Menyinkronkan komit lokal dengan repositori jarak jauh sebelum mendorong

   git pull --rebase

7. Menyelesaikan ketika konflik terjadi prasyarat mengkonfigurasi mergetool

   git mergetool #resolve merging here, also can manually merge

8. Menambahkan file yang diselesaikan dengan konflik, katakanlah file1:

   git add $file1

9. Melanjutkan perintah rebase saya sebelumnya

   git rebase --continue

10. Mendorong komit lokal terakhir yang sudah siap dan sudah disinkronkan

    git Push Origin head:refs/for/$branch # branch = master, dev, etc.

Dalam kasus saya, saya berkomitmen dan mendorong ke cabang yang salah, jadi yang saya inginkan adalah mengembalikan semua perubahan saya sehingga saya dapat mengkomitnya ke cabang yang benar, jadi saya melakukan ini:

Pada cabang yang sama dengan yang Anda komit dan tekan, jika Anda mengetik "git status" Anda tidak akan melihat sesuatu yang baru karena Anda berkomitmen dan mendorong, sekarang ketik:

git reset --soft HEAD~1

Ini akan mendapatkan semua perubahan Anda (file) kembali di area panggung, sekarang untuk mendapatkannya kembali di direktori kerja (unstage) Anda cukup ketik:

git reset FILE

Di mana "File" adalah file yang ingin Anda komit lagi. Sekarang FILE ini harus berada di direktori kerja (tidak dipentaskan) dengan semua perubahan yang Anda lakukan. Sekarang Anda dapat mengubah ke cabang apa pun yang Anda inginkan dan melakukan perubahan di cabang itu. Semoga ini bisa membantu orang lain yang melakukan kesalahan yang sama saya lakukan. Tentu saja cabang awal yang Anda komit masih ada di sana dengan semua perubahan, tetapi dalam kasus saya itu ok, jika bukan untuk Anda, Anda dapat mencari cara untuk mengembalikan komitmen di cabang itu.

PENGGUNA VISUAL STUDIO (2015, dll)

Jika Anda tidak dapat menyinkronkan dalam Visual Studio karena Anda tidak diizinkan untuk Push ke cabang seperti "pengembangan" maka sebanyak yang saya coba, di Visual Studio TIDAK ADAKEMBALIKANNOR theRESET(keras atau lunak) akan berfungsi.

Per jawaban dengan BANYAK SUARA:

Gunakan ini pada perintah Prompt root dari proyek Anda untuk mem-nuke apa pun yang akan mencoba untuk didorong:

git reset --hard HEAD~1

Cadangkan atau Zip file Anda jika Anda tidak ingin kehilangan pekerjaan, dll ...

Saya mendapat ID komit dari bitbucket dan kemudian melakukan:

git checkout commitID .

Contoh:

git checkout 7991072 .

Dan itu mengembalikannya ke salinan komit yang berfungsi.

Misalkan Anda membuat komit yang salah secara lokal dan mendorongnya ke repositori jarak jauh. Anda dapat membatalkan kekacauan dengan dua perintah ini:

Pertama, kita perlu memperbaiki repositori lokal kita dengan kembali ke commit yang kita inginkan:

git reset --hard <previous good commit id where you want the local repository  to go>

Sekarang kita dengan paksa Dorong komit yang baik ini pada repositori jarak jauh dengan menggunakan perintah ini:

git Push --force-with-lease

Versi 'with-leasing' dari opsi gaya itu akan mencegah penghapusan komit baru yang tidak Anda ketahui (yaitu berasal dari sumber lain sejak tarikan terakhir).

Batalkan komit terakhir:

git reset --soft HEAD^ or git reset --soft HEAD~

Ini akan membatalkan komit terakhir.

Di sini --soft berarti mengatur ulang ke pementasan.

HEAD~ or HEAD^ artinya pindah ke komit sebelum HEAD.

Ganti komit terakhir ke komit baru:

git commit --amend -m "message"

Ini akan menggantikan komit terakhir dengan komit baru.

Anda perlu melakukan yang mudah dan cepat

    git commit --amend

apakah itu cabang pribadi atau

    git commit -m 'Replace .class files with .Java files'

apakah itu cabang bersama atau publik.

Anda memiliki beberapa opsi untuk membatalkan komit terakhir Anda. Berikut adalah beberapa opsi Anda meringkas menjadi satu jawaban dengan potongan kode

Pertama-tama Anda perlu mencari komit mana yang "salah" yang ingin Anda buang. Kami akan menggunakan git reflog untuk menemukannya.

git reflog

Anda selalu dapat menggunakan reflog juga.
git reflog akan menampilkan perubahan yang memperbarui HEAD dan memeriksa entri reflog yang diinginkan akan membuat HEAD kembali ke komit ini. 

Setiap kali HEAD diubah akan ada entri baru di reflog.
reflog mirip dengan perintah unix history dan disimpan secara lokal di mesin Anda.

git reflog
git checkout [email protected]{...}
# or
git checkout <sha-1>

Dengan menggunakan checkout Anda dapat kembali ke komit yang diinginkan dan Anda dapat membuat cabang atau opsi lain yang memungkinkan git checkout untuk Anda lakukan.

git reset HEAD --hard <commit_id>

"Pindahkan" kepala Anda kembali ke komit yang diinginkan.
Pengaturan ulang Git akan memeriksa konten komit yang diinginkan ke area pementasan Anda dan/atau ke direktori kerja Anda berdasarkan nilai --hard/--soft/--mixed yang Anda pilih. --hard akan memperbarui area panggung dan direktori kerja dengan konten yang diberikan dan akan "melepaskan" komit lain di luar titik ini di cabang lokal Anda. 

Jika komitmen itu bukan bagian dari cabang lain, mereka akan menjadi "menjuntai".
Konten "menjuntai" berarti bahwa ada konten yang tidak dapat dijangkau dalam repositori lokal Anda yang bukan bagian dari cabang lain dan dapat dihapus atau akan dihapus oleh gc.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

Skema ini menggambarkan perintah mana melakukan apa.
Seperti yang Anda lihat di sana reset && checkout ubah HEAD.

Gunakan perintah ini:

git checkout -b old-state number_commit

Gunakan perintah ini

git checkout -b old-state 0d1d7fc32

Hapus komit yang salah yang sudah didorong ke Github

git Push Origin +(previous good commit id):(branch name)

Silakan tentukan id komit bagus terakhir yang ingin Anda setel kembali di Github.

Sebagai contoh. Jika id komit terbaru salah maka tentukan id komit sebelumnya dalam perintah git di atas dengan nama cabang. 

Anda bisa mendapatkan id komit sebelumnya menggunakan git log

Untuk menyingkirkan (semua perubahan dalam) komit terakhir, 2 komit terakhir dan komit terakhir:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

Dan, untuk menyingkirkan apa pun setelah komit tertentu:

git reset --hard <commit sha>

misalnya., 

git reset --hard 0d12345

PS:
1- Hati-hati, karena opsi "keras", itu menghapus perubahan lokal di repo Anda juga dan kembali ke komit yang disebutkan sebelumnya. Kamu harus menjalankan ini jika Anda yakin Anda mengacaukan komit terakhir Anda dan ingin kembali ke masa lalu. 

2- Biasanya 7 huruf "komit sha" sudah cukup, tetapi lebih besar proyek, Anda mungkin perlu hingga 12 huruf untuk menjamin menjadi unik. Kamu juga bisa menyebutkan seluruh 40 huruf sha.

3- Perintah di atas juga berfungsi di Github untuk Windows.

Anda selalu dapat melakukan git checkout <SHA code> dari versi sebelumnya dan kemudian melakukan lagi dengan kode baru.

Anda dapat membatalkan komitmen Git Anda dengan dua cara: Pertama adalah Anda dapat menggunakan git revert, jika Anda ingin menyimpan riwayat komit Anda:

git revert HEAD~3
git revert <hashcode of commit>

Kedua adalah Anda dapat menggunakan git reset, yang akan menghapus semua riwayat komit Anda dan membawa kepala Anda untuk melakukan di mana Anda inginkan.

git reset <hashcode of commit>
git reset HEAD~3

Anda juga dapat menggunakan kata kunci --hard jika salah satunya mulai berlaku sebaliknya. Tapi, saya hanya akan merekomendasikannya sampai sangat diperlukan.

Referensi: Bagaimana cara membatalkan komit terakhir di Git?

Jika Anda telah menginstal Git Extensions Anda dapat dengan mudah membatalkan/mengembalikan komit (Anda dapat mengunduh ekstensi git dari sini ).

Buka Git Extensions, klik kanan pada komit yang ingin Anda kembalikan kemudian pilih "Kembalikan komit". 

Munculan akan dibuka (lihat tangkapan layar di bawah)

Pilih "Buat komit secara otomatis" jika Anda ingin langsung melakukan perubahan yang dikembalikan atau jika Anda ingin melakukan perubahan yang dikembalikan secara manual, biarkan kotak tidak dipilih dan klik tombol "Kembalikan komit ini".

Cukup gunakan git reset --hard <last good SHA> untuk mengatur ulang perubahan Anda dan berikan komit baru. Anda juga dapat menggunakan git checkout -- <bad filename>.

Saya telah menemukan ini situs yang menjelaskan cara membatalkan hal-hal yang telah Anda komit ke repositori.

Beberapa perintah:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

Inilah situsnya: Oh shit, git! .

Berikut adalah banyak resep cara membatalkan hal-hal di Git. Beberapa dari mereka:

Sial, saya perlu mengubah pesan pada komit terakhir saya!

git commit --amend
# follow prompts to change the commit message

Oh sial, aku sengaja melakukan sesuatu untuk dikuasai yang seharusnya ada di cabang baru!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

Anda dapat membatalkan komitmen Anda dari repositori lokal. Silakan ikuti skenario di bawah ini.

Pada gambar di bawah ini saya memeriksa cabang 'test' (menggunakan perintah Git git checkout -b test) sebagai lokal dan memeriksa status (menggunakan perintah Git git status) dari cabang lokal yang tidak memiliki komitmen.

Pada gambar gambar berikutnya Anda dapat melihat di sini saya membuat beberapa perubahan pada Filter1.txt dan menambahkan file itu ke area pementasan dan kemudian melakukan perubahan saya dengan beberapa pesan (menggunakan perintah Git git commit -m "Doing commit to test revert back").

"-m untuk pesan komit"

Pada gambar berikutnya Anda dapat melihat log komit Anda apa pun yang Anda buat komit (menggunakan perintah Git git log).

Jadi pada gambar di atas Anda dapat melihat komit id dengan komit masing-masing dan dengan pesan komit Anda sekarang komit apa pun yang ingin Anda kembalikan atau batalkan menyalin komit itu dan tekan perintah Git di bawah, git revert {"paste your commit id"}. Contoh:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

Saya telah mengembalikan kembali komit terakhir saya. Sekarang jika Anda memeriksa status Git Anda, Anda dapat melihat file yang dimodifikasi yaitu Filter1.txt dan belum melakukan.

Cara paling sederhana untuk membatalkan komit terakhir adalah

git reset HEAD^

Ini akan membawa status proyek sebelum Anda membuat komit.

Di IntelliJ IDEA Anda bisa membuka log repositori Git dengan menekan Alt+9, klik tombol kanan mouse di beberapa tag dari daftar commit, dan pilih: "Reset Cabang Saat Ini ke Sini ...".

KEPALA:

Sebelum mereset komit, kita harus tahu tentang HEAD ... HEAD tidak lain adalah kondisi Anda saat ini di direktori kerja Anda. Itu diwakili oleh angka komit.

Git melakukan:

Setiap perubahan yang diberikan di bawah komit yang diwakili oleh tag unik. Komit tidak dapat dihapus. Jadi jika Anda ingin komit terakhir Anda, Anda bisa langsung masuk menggunakan git reset.

Anda dapat terjun ke komit terakhir menggunakan dua metode:

Metode 1: (jika Anda tidak tahu nomor komit, tetapi ingin pindah ke yang pertama)

git reset HEAD~1  # It will move your head to last commit

Metode 2: (jika Anda tahu komit, Anda cukup mereset komit yang diketahui)

git reset 0xab3 # Nomor komit

Catatan: jika Anda ingin mengetahui komit baru-baru ini coba git log -p -1

Berikut ini adalah representasi grafisnya:

Perbedaan antara reset git --mixed, --soft dan --hard

Prasyarat: Saat modifikasi ke file yang ada di .__ Anda. repositori dibuat, perubahan ini awalnya dianggap sebagai tidak dipentaskan . Untuk melakukan perubahan, perlu dipentaskan yang berarti menambahkannya ke indeks menggunakan git add. Selama operasi komit, file yang dipentaskan akan ditambahkan ke indeks.

Mari kita ambil contoh: 

- A - B - C (master)

HEAD menunjuk ke C dan indeks cocok dengan C.

--lembut

• Ketika kita menjalankan git reset --soft B dengan maksud menghapus komit C dan menunjuk master/HEAD ke B. 
• Master/HEAD sekarang akan menunjuk ke B, tetapi indeks masih berubah dari C. 
• Saat menjalankan git status Anda bisa melihat file diindeks dalam commit C sebagai dipentaskan. 
• Menjalankan git commit pada titik ini akan membuat komit baru dengan perubahan yang sama seperti C

--campur aduk

• Jalankan git reset --mixed B. 
• Pada eksekusi, master/HEAD akan menunjuk ke B dan indeks juga dimodifikasi untuk mencocokkan B karena flag campuran yang digunakan. 
• Jika kita menjalankan git commit pada saat ini, tidak ada yang akan terjadi sejak index cocok dengan HEAD.
• Kami masih memiliki perubahan dalam direktori kerja, tetapi karena mereka tidak ada dalam indeks, status git menunjukkan mereka sebagai tidak bertahap. 
• Untuk mengkomitnya, Anda harus git add dan kemudian melakukan seperti biasa.

--keras

• Jalankan git reset --hard B
• Pada eksekusi, master/HEAD akan menunjuk ke B dan memodifikasi direktori kerja Anda
• Perubahan yang ditambahkan dalam C dan semua perubahan yang tidak dikomit akan dihapus.
• File dalam copy pekerjaan akan cocok dengan komit B, ini akan mengakibatkan kehilangan secara permanen semua perubahan yang dibuat di komit C ditambah perubahan yang tidak dikomit

Semoga perbandingan flag yang tersedia untuk digunakan dengan perintah git reset ini akan membantu seseorang untuk menggunakannya dengan bijak. Lihat ini untuk detail lebih lanjut link1 & link2

Komitmen rebasing dan jatuhkan adalah yang terbaik saat Anda ingin menjaga sejarah tetap bersih. Berguna saat mengajukan tambalan ke cabang publik dll.

Jika Anda harus menjatuhkan komit teratas maka one-liner berikut membantu

git rebase --onto HEAD~1 HEAD

Tetapi jika Anda ingin menjatuhkan 1 dari banyak komit yang Anda katakan

a -> b -> c -> d -> master

dan Anda ingin melepaskan komit 'c'

git rebase --onto b c

Ini akan menjadikan 'b' sebagai basis baru 'd' menghilangkan 'c'

Temukan kode hash komit terakhir dengan melihat log dengan:

git log

Kemudian

git reset <the previous co>

Demi kelengkapan, saya akan memberikan metode yang sangat jelas yang diabaikan oleh jawaban sebelumnya.

Karena komit tidak didorong, remote tidak berubah, jadi:

1. Hapus repositori lokal.
2. Kloning repositori jarak jauh.

Ini kadang-kadang diperlukan jika klien Git mewah Anda pergi by-bye. (mis. kesalahan non-fast-forward)

Jangan lupa komit ulang perubahan tersimpan Anda sejak Push terakhir.

Dengan asumsi Anda bekerja di Visual Studio, jika Anda masuk ke riwayat cabang Anda dan melihat semua komitmen Anda, cukup pilih acara sebelum komit yang ingin Anda batalkan, klik kanan, dan pilih Revert. Semudah itu.

Jika Anda ingin menghilangkan file yang salah, Anda harus melakukannya 

git reset --soft <your_last_good_commit_hash_here> Di sini, jika Anda melakukan git status, Anda akan melihat file di area pementasan. Anda dapat memilih file yang salah dan mengambilnya dari area pementasan.

Seperti berikut ini.

git reset wrongFile1 wrongFile2 wrongFile3

Anda sekarang dapat menambahkan file yang perlu Dorong,

git add goodFile1 goodFile2

komit mereka 

git commit -v atau git commit -am "Message"

dan Dorong

git Push Origin master

Namun, jika Anda tidak peduli dengan file yang diubah, Anda dapat mengatur ulang ke komit sebelumnya yang baik dan Dorong semuanya ke server.

oleh 

git reset --hard <your_last_good_commit_hash_here>

git Push Origin master

Jika Anda sudah mempublikasikan file yang salah ke server, Anda dapat menggunakan flag --force untuk Push ke server dan mengedit histori.

git Push --force Origin master

Coba ini, hard reset ke komit sebelumnya di mana file-file itu tidak ditambahkan, lalu:

git reset --hard <commit_hash>

Pastikan Anda memiliki cadangan perubahan untuk berjaga-jaga, karena ini adalah hard reset, yang berarti akan hilang (kecuali Anda disimpan sebelumnya)

git reset --soft HEAD~1

Reset akan memundurkan cabang HEAD Anda saat ini ke revisi yang ditentukan. Note the --soft flag: ini memastikan bahwa perubahan pada revisi yang dibatalkan dipertahankan. Setelah menjalankan perintah, Anda akan menemukan perubahan sebagai modifikasi lokal yang tidak dikomit di copy pekerjaan Anda.

Jika Anda tidak ingin menyimpan perubahan ini, cukup gunakan bendera --hard. Pastikan untuk hanya melakukan ini ketika Anda yakin Anda tidak membutuhkan perubahan ini lagi.

 git reset --hard HEAD~1

Membatalkan Banyak Komit

git reset --hard 0ad5a7a6

perlu diingat, bahwa menggunakan perintah reset membatalkan semua komit yang datang setelah Anda kembali ke:   

Apa yang saya lakukan setiap kali saya perlu membatalkan komitmen adalah:

1. git reset HEAD~<n> // jumlah komit terakhir yang harus saya batalkan

2. git status // opsional. Semua file sekarang berwarna merah (tidak dipentaskan).

3. Sekarang, saya dapat menambahkan & melakukan hanya file yang saya butuhkan:

   • git add <file names> & git commit -m "message" -m "details"
4. Opsional: Saya dapat mengembalikan perubahan file lainnya, jika perlu, ke kondisi sebelumnya, dengan checkout:
   • git checkout <filename>
5. jika saya sudah mendorongnya ke remote Origin, sebelumnya:
   • git Push Origin <branch name> -f // gunakan -f untuk memaksa Push.

Jika Anda ingin membatalkan komit pertama dalam repo Anda

Anda akan mengalami masalah ini:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

Kesalahan terjadi karena jika komit terakhir adalah komit awal (atau tidak ada orang tua) dari repositori, tidak ada HEAD ~.

Larutan

Jika Anda ingin mengatur ulang hanya komit di cabang "master"

$ git update-ref -d HEAD
$ git rm --cached -r .

Dapatkan ID komit terakhir dengan menggunakan perintah ini (dalam log di atas, ini adalah yang terbaru):

git log

Dapatkan id komit (GUID) dan jalankan perintah ini:

git revert <commit_id>

Bagaimana edit komit sebelumnya

Secara umum saya tidak ingin membatalkan banyak komitmen, tetapi mengedit komitmen sebelumnya tentang bagaimana saya berharap saya telah melakukan itu di tempat pertama.

Saya menemukan diri saya cukup sering melakukan commit di masa lalu sehingga saya menulis skrip untuk itu.

Inilah alur kerjanya:

1. git commit-edit <commit-hash>
   

   Ini akan menjatuhkan Anda pada komit yang ingin Anda edit.

   Perubahan komit akan un dipentaskan, siap dipentaskan seperti yang Anda inginkan pertama kali.

2. Perbaiki dan tampilkan komit sesuai keinginan Anda.

   (Anda mungkin ingin menggunakan git stash save --keep-index untuk membuang file yang tidak Anda lakukan)

3. Ulangi komit dengan --amend, misal:

   git commit --amend
   

4. Selesaikan rebase:

   git rebase --continue
   

Sebut ini git-commit-edit berikut dan masukkan ke dalam $PATH Anda:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "[email protected]"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

Jika Anda hanya ingin membuang semua perubahan/komitmen lokal Anda dan membuat cabang lokal Anda terlihat seperti cabang Origin Anda mulai dari ...

git reset --hard Origin/branch-name

git revert commit

Ini akan menghasilkan perubahan yang berlawanan dari komit yang ingin Anda kembalikan, dan kemudian komit perubahan itu. Saya pikir ini adalah cara paling sederhana.

https://git-scm.com/docs/git-revert

ganti versi lokal Anda termasuk perubahan Anda dengan versi server, dua baris kode ini akan memaksa git untuk menarik dan menimpa lokal. Buka perintah Prompt dan arahkan ke root proyek git. Jika Anda menggunakan VS, klik pada Team, Synch dan klik pada "Open Command Prompt" (lihat gambar) di bawah ini. 

Setelah di Cmd Prompt, lanjutkan dengan dua instruksi berikut. 

git fetch --all

maka Anda lakukan

git reset --hard Origin/master

ini akan menimpa versi lokal yang ada dengan yang ada di git server

git Push --delete (branch_name) //this will be removing the public version of your branch

git Push Origin (branch_name) //This will add the previous version back