Bagaimana saya bisa menyimpan hanya satu dari banyak file yang diubah di cabang saya?

Penafian : jawaban berikut untuk git sebelum git 2.13. Untuk git 2.13 dan lebih, periksa jawaban lain lebih jauh .

Peringatan

Seperti disebutkan dalam komentar, ini menempatkan semuanya ke simpanan, baik dipentaskan dan tidak dipentaskan. --Keep-index hanya meninggalkan indeks setelah simpanan selesai. Ini dapat menyebabkan penggabungan konflik saat nanti Anda menghapus simpanan.

Ini akan menyimpan semua yang belum Anda tambahkan sebelumnya. Hanya git addhal-hal yang ingin Anda simpan, kemudian jalankan.

git stash --keep-index

Misalnya, jika Anda ingin membagi komit lama menjadi lebih dari satu perubahan, Anda dapat menggunakan prosedur ini:

1. git rebase -i <last good commit>
2. Tandai beberapa perubahan sebagai edit.
3. git reset HEAD^
4. git add <files you want to keep in this change>
5. git stash --keep-index
6. Perbaiki semua yang diperlukan. Jangan lupa untuk git addperubahan apa pun.
7. git commit
8. git stash pop
9. Ulangi, dari # 5, sesuai kebutuhan.
10. git rebase --continue

Anda juga bisa menggunakan git stash save -p "my commit message" . Dengan cara ini Anda dapat memilih bakhil yang harus ditambahkan ke simpanan, seluruh file juga dapat dipilih.

Anda akan diminta dengan beberapa tindakan untuk setiap potongan:

   y - stash this hunk
   n - do not stash this hunk
   q - quit; do not stash this hunk or any of the remaining ones
   a - stash this hunk and all later hunks in the file
   d - do not stash this hunk or any of the later hunks in the file
   g - select a hunk to go to
   / - search for a hunk matching the given regex
   j - leave this hunk undecided, see next undecided hunk
   J - leave this hunk undecided, see next hunk
   k - leave this hunk undecided, see previous undecided hunk
   K - leave this hunk undecided, see previous hunk
   s - split the current hunk into smaller hunks
   e - manually edit the current hunk
   ? - print help

Karena git pada dasarnya tentang mengelola semua konten dan indeks penyimpanan (dan bukan satu atau beberapa file), git stashkesepakatan, tidak mengherankan,dengan semua direktori yang berfungsi.

Sebenarnya, sejak Git 2.13 (Q2 2017), Anda dapat menyimpan file individual, dengan git stash push:

git stash push [--] [<pathspec>...]

Ketika pathspecdiberikan ke ' git stash push', simpanan baru merekam status yang dimodifikasi hanya untuk file yang cocok dengan pathspec. Lihat " Menyimpan perubahan ke file tertentu " untuk informasi lebih lanjut.

Contoh sederhana:

 git stash push path/to/file

Kasing uji untuk fitur ini menunjukkan beberapa opsi lagi:

test_expect_success 'stash with multiple pathspec arguments' '
    >foo &&
    >bar &&
    >extra &&
    git add foo bar extra &&

    git stash push -- foo bar &&   

    test_path_is_missing bar &&
    test_path_is_missing foo &&
    test_path_is_file extra &&

    git stash pop &&
    test_path_is_file foo &&
    test_path_is_file bar &&
    test_path_is_file extra

Jawaban asli (di bawah, Juni 2010) adalah tentang memilih secara manual apa yang ingin Anda sembunyikan.

Komentar Casebash :

Ini ( stash --patchsolusi asli) bagus, tetapi sering saya sudah memodifikasi banyak file sehingga menggunakan tambalan mengganggu

bukzor 's jawaban (upvoted, November 2011) menyarankan solusi yang lebih praktis, berdasarkan
git add+git stash --keep-index .
Pergi dan lihat jawabannya, yang seharusnya jawaban resmi (bukan milik saya).

Tentang opsi itu, chhh menunjukkan alur kerja alternatif di komentar:

Anda harus " git reset --soft" setelah simpanan untuk mendapatkan pementasan yang jelas kembali:
Untuk sampai ke keadaan semula - yang merupakan area pementasan yang jelas dan hanya dengan beberapa modifikasi un-staged, seseorang dapat dengan lembut mengatur ulang indeks untuk mendapatkan (tanpa melakukan hal seperti Anda - bukzor - lakukan).

(Jawaban asli Juni 2010: simpanan manual)

Namun, git stash save --patchdapat memungkinkan Anda untuk mencapai simpanan parsial yang Anda kejar:

Dengan --patch, Anda dapat secara interaktif memilih bakhil dari dalam perbedaan antara KEPALA dan pohon yang akan disimpan.
Entri simpanan dikonstruksi sedemikian sehingga status indeksnya sama dengan status indeks repositori Anda, dan tabel kerjanya hanya berisi perubahan yang Anda pilih secara interaktif. Perubahan yang dipilih kemudian dibatalkan dari meja kerja Anda.

Namun itu akan menyimpan indeks penuh (yang mungkin bukan yang Anda inginkan karena mungkin termasuk file lain yang sudah diindeks), dan sebagian worktree (yang bisa terlihat seperti yang Anda ingin menyimpan).

git stash --patch --no-keep-index

mungkin lebih cocok.

Jika --patchtidak berhasil, proses manual mungkin:

Untuk satu atau beberapa file, solusi perantara adalah dengan:

• salin di luar repo Git
  (Sebenarnya, eleotlecram mengusulkan alternatif yang menarik )
• git stash
• salin kembali
• git stash # kali ini, hanya file yang Anda inginkan yang disimpan
• git stash pop stash@{1} # Terapkan ulang semua modifikasi file Anda
• git checkout -- afile # reset file ke konten KEPALA, sebelum ada modifikasi lokal

Pada akhir proses yang agak rumit itu, Anda hanya akan memiliki satu atau beberapa file yang disimpan.

Ketika git stash -p(atau git add -pdengan stash --keep-index) terlalu rumit, saya merasa lebih mudah digunakan diff, checkoutdan apply:

Untuk "menyimpan" file / dir tertentu saja:

git diff path/to/dir > stashed.diff
git checkout path/to/dir

Lalu sesudahnya

git apply stashed.diff

Gunakan git stash push, seperti ini:

git stash push [--] [<pathspec>...]

Sebagai contoh:

git stash push -- my/file.sh

Ini tersedia sejak Git 2.13, dirilis pada musim semi 2017.

Katakanlah Anda memiliki 3 file

a.rb
b.rb
c.rb

dan Anda ingin menyimpan hanya b.rb dan c.rb tetapi tidak a.rb

Anda dapat melakukan sesuatu seperti ini

# commit the files temporarily you don't want to stash
git add a.rb
git commit -m "temp" 

# then stash the other files
git stash save "stash message"

# then undo the previous temp commit
git reset --soft HEAD^
git reset

Dan Anda selesai! HTH.

Cara lain untuk melakukan ini:

# Save everything
git stash 

# Re-apply everything, but keep the stash
git stash apply

git checkout <"files you don't want in your stash">

# Save only the things you wanted saved
git stash

# Re-apply the original state and drop it from your stash
git stash apply stash@{1}
git stash drop stash@{1}

git checkout <"files you put in your stash">

Saya datang dengan ini setelah saya (sekali lagi) datang ke halaman ini dan tidak suka dua jawaban pertama (jawaban pertama tidak menjawab pertanyaan dan saya tidak suka bekerja dengan -pmode interaktif).

Idenya sama dengan apa yang disarankan @VonC menggunakan file di luar repositori, Anda menyimpan perubahan yang Anda inginkan di suatu tempat, menghapus perubahan yang tidak Anda inginkan di simpanan Anda, dan kemudian menerapkan kembali perubahan yang Anda pindah dari jalan. Namun, saya menggunakan simpanan git sebagai "suatu tempat" (dan sebagai hasilnya, ada satu langkah ekstra di akhir: menghapus cahnges yang Anda masukkan ke simpanan, karena Anda juga memindahkannya).

Pembaruan (14/02/2015) - Saya telah menulis ulang skrip sedikit, untuk menangani kasus konflik dengan lebih baik, yang sekarang harus disajikan sebagai konflik yang tidak dihapus daripada file .rej.

Saya sering merasa lebih intuitif untuk melakukan kebalikan dari pendekatan @ bukzor. Yaitu, untuk melakukan beberapa perubahan, dan kemudian menyimpan hanya perubahan yang dipentaskan itu.

Sayangnya, git tidak menawarkan simpanan git - hanya indeks atau sejenisnya, jadi saya membuat skrip untuk melakukan ini.

#!/bin/sh

# first, go to the root of the git repo
cd `git rev-parse --show-toplevel`

# create a commit with only the stuff in staging
INDEXTREE=`git write-tree`
INDEXCOMMIT=`echo "" | git commit-tree $INDEXTREE -p HEAD`

# create a child commit with the changes in the working tree
git add -A
WORKINGTREE=`git write-tree`
WORKINGCOMMIT=`echo "" | git commit-tree $WORKINGTREE -p $INDEXCOMMIT`

# get back to a clean state with no changes, staged or otherwise
git reset -q --hard

# Cherry-pick the index changes back to the index, and stash.
# This cherry-pick is guaranteed to succeed
git cherry-pick -n $INDEXCOMMIT
git stash

# Now cherry-pick the working tree changes. This cherry-pick may fail
# due to conflicts
git cherry-pick -n $WORKINGCOMMIT

CONFLICTS=`git ls-files -u`
if test -z "$CONFLICTS"; then
    # If there are no conflicts, it's safe to reset, so that
    # any previously unstaged changes remain unstaged
    #
    # However, if there are conflicts, then we don't want to reset the files
    # and lose the merge/conflict info.
    git reset -q
fi

Anda dapat menyimpan skrip di atas sebagai git-stash-indexsuatu tempat di jalur Anda, dan kemudian dapat memanggilnya sebagai git stash-index

# <hack hack hack>
git add <files that you want to stash>
git stash-index

Sekarang simpanan berisi entri baru yang hanya berisi perubahan yang telah Anda lakukan, dan pohon kerja Anda masih mengandung perubahan yang tidak bertahap.

Dalam beberapa kasus, perubahan pohon kerja mungkin tergantung pada perubahan indeks, jadi ketika Anda menyimpan indeks perubahan, perubahan pohon kerja memiliki konflik. Dalam hal ini, Anda akan mendapatkan konflik tidak terputus yang biasa Anda dapat atasi dengan git merge / git mergetool / etc.

Jika Anda tidak ingin menentukan pesan dengan perubahan simpanan Anda, berikan nama file setelah tanda hubung ganda.

$ git stash -- filename.ext

Jika ini file yang tidak dilacak / baru, Anda harus mengaturnya terlebih dahulu.

Metode ini bekerja di git versi 2.13+

Karena membuat cabang di Git sepele, Anda bisa membuat cabang sementara dan memeriksa masing-masing file di dalamnya.

Anda cukup melakukan ini:

git stash push "filename"

atau dengan pesan opsional

git stash push -m "Some message" "filename"

Simpan kode berikut ke file, misalnya, dinamai stash. Penggunaan adalah stash <filename_regex>. Argumennya adalah ekspresi reguler untuk path lengkap file. Misalnya, untuk menyembunyikan a / b / c.txt, stash a/b/c.txtatau stash .*/c.txt, dll.

$ chmod +x stash
$ stash .*.xml
$ stash xyz.xml

Kode untuk disalin ke file:

#! /usr/bin/expect --
log_user 0
set filename_regexp [lindex $argv 0]

spawn git stash -p

for {} 1 {} {
  expect {
    -re "diff --git a/($filename_regexp) " {
      set filename $expect_out(1,string)
    }
    "diff --git a/" {
      set filename ""
    }
    "Stash this hunk " {
      if {$filename == ""} {
        send "n\n"
      } else {
        send "a\n"
        send_user "$filename\n"
      }
    }
    "Stash deletion " {
      send "n\n"
    }
    eof {
      exit
    }
  }
}

Kalau-kalau Anda benar-benar bermaksud membuang perubahan setiap kali Anda menggunakan git stash(dan tidak benar-benar menggunakan simpanan git untuk menyembunyikannya sementara), dalam hal ini Anda dapat menggunakan

git checkout -- <file>

[ CATATAN ]

Itu git stashhanya alternatif yang lebih cepat dan sederhana untuk bercabang dan melakukan hal-hal.

Masalah dengan solusi `perantara 'VonC untuk menyalin file ke luar repo Git adalah bahwa Anda kehilangan informasi path, yang membuat menyalin banyak file di kemudian hari dengan sedikit kerumitan.

A merasa lebih mudah menggunakan tar (alat serupa mungkin akan melakukannya) daripada menyalin:

• tar cvf /tmp/stash.tar path / ke / some / path file / ke / some / other / file (... etc.)
• git checkout path / ke / some / path file / ke / some / other / file
• simpanan git
• tar xvf /tmp/stash.tar
• dll. (lihat saran `perantara 'VonC)

Kadang-kadang saya membuat perubahan yang tidak terkait pada cabang saya sebelum saya melakukan itu, dan saya ingin memindahkannya ke cabang lain dan melakukan itu secara terpisah (seperti master). Saya melakukan ini:

git stash
git checkout master
git stash pop
git add <files that you want to commit>
git commit -m 'Minor feature'
git stash
git checkout topic1
git stash pop
...<resume work>...

Catatan yang pertama stash& stash popdapat dihilangkan, Anda dapat membawa semua perubahan Anda kemaster cabang saat Anda checkout, tetapi hanya jika tidak ada konflik. Juga jika Anda membuat cabang baru untuk perubahan parsial Anda akan membutuhkan simpanan.

Anda dapat menyederhanakannya dengan asumsi tidak ada konflik dan tidak ada cabang baru:

git checkout master
git add <files that you want to commit>
git commit -m 'Minor feature'
git checkout topic1
...<resume work>...

Stash bahkan tidak diperlukan ...

Ini dapat dilakukan dengan mudah dalam 3 langkah menggunakan SourceTree.

1. Lakukan sementara semua yang tidak Anda inginkan disimpan.
2. Git menambahkan yang lainnya, lalu menyimpannya.
3. Pop komit sementara Anda dengan menjalankan git reset, menargetkan komit sebelum Anda sementara.

Ini semua bisa dilakukan dalam hitungan detik di SourceTree, di mana Anda bisa mengklik file (atau bahkan setiap baris) yang ingin Anda tambahkan. Setelah ditambahkan, cukup komit ke komit sementara. Selanjutnya, klik kotak centang untuk menambahkan semua perubahan, lalu klik simpanan untuk menyembunyikan semuanya. Dengan perubahan yang disembunyikan, lihat daftar komit Anda dan catat hash untuk komit sebelum komit sementara Anda, kemudian jalankan 'git reset hash_b4_temp_commit', yang pada dasarnya seperti "membuka" komit dengan menyetel ulang cabang Anda ke ulang komit lakukan tepat sebelum itu. Sekarang, Anda hanya memiliki barang-barang yang tidak ingin disimpan.

Saya akan menggunakan git stash save --patch. Saya tidak menemukan interaktivitas yang mengganggu karena ada opsi selama itu untuk menerapkan operasi yang diinginkan ke seluruh file.

Setiap jawaban di sini sangat rumit ...

Bagaimana dengan ini untuk "menyembunyikan":

git diff /dir/to/file/file_to_stash > /tmp/stash.patch
git checkout -- /dir/to/file/file_to_stash

Ini untuk memunculkan perubahan file kembali:

git apply /tmp/stash.patch

Perilaku yang sama persis seperti menyimpan satu file dan memasukkannya kembali.

Saya telah meninjau jawaban dan komentar untuk ini dan sejumlah utas serupa. Perlu diketahui bahwa tidak ada dari perintah berikut ini yang benar untuk tujuan dapat menyimpan file terlacak / tidak terlacak tertentu :

• git stash -p (--patch): pilih bakhil secara manual, tidak termasuk file yang tidak dilacak
• git stash -k (--keep-index): sembunyikan semua file yang dilacak / tidak dilacak dan simpan di direktori kerja
• git stash -u (--include-untracked): simpanan semua file yang dilacak / tidak terlacak
• git stash -p (--patch) -u (--include-untracked): perintah tidak valid

Saat ini, metode paling masuk akal untuk dapat menyimpan file terlacak / tidak terlacak spesifik adalah dengan:

• Komit sementara file yang Anda tidak ingin simpanan
• Tambahkan dan simpan
• Pop komit sementara

Saya menulis skrip sederhana untuk prosedur ini sebagai jawaban atas pertanyaan lain , dan ada langkah - langkah untuk melakukan prosedur di SourceTree di sini .

Larutan

Perubahan lokal:

• file_A (dimodifikasi) tidak dipentaskan
• file_B (dimodifikasi) tidak dipentaskan
• file_C (dimodifikasi) tidak dipentaskan

Untuk membuat simpanan "my_stash" hanya dengan perubahan pada file_C :

1. git add file_C
2. git stash save --keep-index temp_stash
3. git stash save my_stash
4. git stash pop stash@#{1}

Selesai

Penjelasan

1. tambahkan file_C ke area pementasan
2. buat simpanan sementara bernama "temp_stash" dan pertahankan perubahan pada file_C
3. buat simpanan yang diinginkan ("my_stash") hanya dengan perubahan pada file_C
4. terapkan perubahan pada "temp_stash" (file_A dan file_B) pada kode lokal Anda dan hapus simpanan

Anda dapat menggunakan status git di antara langkah-langkah untuk melihat apa yang sedang terjadi.

Ketika Anda mencoba untuk beralih di antara dua cabang, situasi ini terjadi.

Coba tambahkan file menggunakan " git add filepath".

Kemudian jalankan baris ini

git stash --keep-index

Untuk menyimpan satu file digunakan git stash --patch [file].

Ini akan cepat: Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]? ?. Cukup ketik a(simpel bingkah ini dan semua bakhil nanti dalam file) dan Anda baik-baik saja.

Situasi serupa. Melakukan dan menyadari itu tidak baik.

git commit -a -m "message"
git log -p

Berdasarkan jawaban ini membantu saya.

# revert to previous state, keeping the files changed
git reset HEAD~
#make sure it's ok
git diff
git status
#revert the file we don't want to be within the commit
git checkout specs/nagios/nagios.spec
#make sure it's ok
git status
git diff
#now go ahead with commit
git commit -a -m "same|new message"
#eventually push tu remote
git push

Dalam situasi ini saya git add -p(interaktif), git commit -m blahdan kemudian menyembunyikan apa yang tersisa jika perlu.

Saya tidak tahu bagaimana melakukannya di command line, hanya menggunakan SourceTree. Katakanlah Anda telah mengubah file A, dan memiliki dua perubahan bakhil di file B. Jika Anda ingin menyembunyikan hanya bingkah kedua di file B dan membiarkan yang lainnya tidak tersentuh, lakukan ini:

1. Panggung segalanya
2. Lakukan perubahan pada copy pekerjaan Anda yang membatalkan semua perubahan dalam file A. (mis. Meluncurkan alat diff eksternal dan membuat file cocok.)
3. Jadikan file B terlihat seolah hanya perubahan kedua yang diterapkan. (mis. luncurkan alat diff eksternal dan batalkan perubahan pertama.)
4. Buat simpanan menggunakan "Simpan perubahan bertahap".
5. Unstage segalanya
6. Selesai!

git add .                           //stage all the files
git reset <pathToFileWillBeStashed> //unstage file which will be stashed
git stash                           //stash the file(s)
git reset .                         // unstage all staged files
git stash pop                       // unstash file(s)

Satu cara rumit adalah dengan pertama-tama melakukan segalanya:

git add -u
git commit // creates commit with sha-1 A

Setel ulang kembali ke komit asli tetapi checkout the_one_file dari komit baru:

git reset --hard HEAD^
git checkout A path/to/the_one_file

Sekarang Anda dapat menyimpan the_one_file:

git stash

Bersihkan dengan menyimpan konten yang dikomit dalam sistem file Anda sambil mengatur ulang ke komit asli:

git reset --hard A
git reset --soft HEAD^

Ya, agak canggung ...

Saya tidak menemukan jawaban untuk apa yang saya butuhkan dan itu semudah:

git add -A
git reset HEAD fileThatYouWantToStash
git commit -m "committing all but one file"
git stash

Menyimpan tepat satu file.

Jawaban cepat

Untuk mengembalikan file yang diubah spesifik di git, Anda dapat melakukan baris berikut:

git checkout <branch-name> -- <file-path>

Ini adalah contoh aktual:

git checkout master -- battery_monitoring/msg_passing.py

Jika Anda ingin menyimpan beberapa file yang diubah, cukup hanya

Tambahkan file yang tidak ingin Anda sembunyikan, di Panggung , Kemudian jalankangit stash save --keep-index

Ini akan menyimpan semua file yang diubah tidak bertahap