Karar vermeden önce 'git add' nasıl geri alınır?

İstediğiniz:

git rm --cached <added_file_to_undo>

Akıl Yürütme:

Bu konuda yeniyken ilk denedim

git reset .

(ilk eklentimin tamamını geri almak için), yalnızca bu (çok) yararlı mesaj almak için:

fatal: Failed to resolve 'HEAD' as a valid ref.

Bunun, HEAD ref (dallanma?) İlk işlemeden sonraya kadar var olmadığından ortaya çıktı. Yani, benim gibi aynı aceminin sorunuyla karşılaşacaksınız, iş akışınız da benimki gibi:

1. git, yeni sıcaklık denemek için benim büyük yeni proje dizini cd
2. git init
3. git add .

4. git status

   ... bir sürü bok kaydırır ...

   => Kahretsin, hepsini eklemek istemedim.

5. google "git addo geri al"

   => Yığın Taşmasını Bul - yay

6. git reset .

   => ölümcül: 'HEAD' öğesi geçerli bir ref olarak çözülemedi.

Ayrıca, günlüğe kaydedilen bir hata bunun posta listesindeki yararsızlığa karşı) olduğu ortaya çıktı.

Ve doğru çözümün Git durum çıktısının tam ordaydı (ki, evet, 'saçma olarak' yazdım)

...
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
...

Ve çözüm gerçekten git rm --cached FILE kullanmaktır.

Burada başka bir yerdeki uyarıları not edin - git rm, dosyanın yerel çalışma kopyanızı siler, ancak --cached kullanırsanız değil. İşte git help rm'nin sonucu:

--cached Yolları yalnızca dizinden ayırmak ve kaldırmak için bu seçeneği kullanın. Çalışan ağaç dosyaları (değiştirilmiş olsun olmasın) bırakılacaktır.

Kullanmaya devam ediyorum

git rm --cached .

her şeyi kaldırmak ve tekrar başlatmak için. Yine de işe yaramadı, çünkü add . özyinelemeli iken, rm'nin tekrar etmesi için -r gerektiriyor. İç çekmek.

git rm -r --cached .

Tamam, şimdi başladığım yere döndüm. Bir dahaki sefere ben kuru bir çalışma yapmak ve ne ekleneceğini görmek için -n kullanacağım:

git add -n .

Hiçbir şeyi yok etmeyecek (ve eğer yanlış yazmışsam) git help rm hakkında --cached 'a güvenmeden önce her şeyi güvenli bir yere koydum.

Eğer yazarsanız:

git status

git, nasıl sabitleneceğine dair talimatlar da dahil olmak üzere, sahnelenenleri vb.

use "git reset HEAD <file>..." to unstage

Git, böyle durumlarda doğru şeyi yapmam için beni dürtmek konusunda oldukça iyi bir iş çıkarıyor.

Not: Son git sürümleri (1.8.4.x) bu mesajı değiştirdi:

(use "git rm --cached <file>..." to unstage)

Açıklığa kavuşturmak için: git add, geçerli çalışma dizininden evreleme alanına (dizine) yapılan değişiklikleri taşır.

Bu sürece evreleme denir. Bu yüzden stage değişikliklerine (değiştirilmiş dosyalar) yapılan en doğal komut açıktır:

git stage

git add, git stage için takma ad yazmak daha kolaydır.

Yazık ki git unstage ya da git unadd komutları yok. İlgili olanı tahmin etmek veya hatırlamak zordur, ancak oldukça açıktır:

git reset HEAD --

Bunun için kolayca bir takma ad oluşturabiliriz:

git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'

Sonunda yeni komutlarımız var:

git add file1
git stage file2
git unadd file2
git unstage file1

Şahsen ben daha kısa takma adları kullanıyorum:

git a #for staging
git u #for unstaging

Kabul edilen cevaba ek olarak, yanlışlıkla eklenen dosyanız çok büyükse, muhtemelen 'git reset' olan bir dizinden çıkardıktan sonra bile, hala .git dizininde yer kapladığını göreceksiniz. Bu endişe edilecek bir şey değil, dosya gerçekten hala depoda, ancak yalnızca "gevşek bir nesne" olarak, diğer havuzlara (klonlama, Push yoluyla) kopyalanmayacak ve sonunda geri kazanılacak - belki de çok yakında değil. Endişeli iseniz, koşabilirsiniz:

git gc --Prune=now

Güncelleme (en çok oy alan cevaplardan kaynaklanabilecek karışıklığı gidermeye çalışmam).

Öyleyse, git add adresinin gerçek geri al değeri nedir?

git reset HEAD <file>?

veya

git rm --cached <file>?

Kesinlikle konuşuyorum ve yanılmıyorsam: none.

git addgeri alınamaz - genel olarak güvenle.

Önce git add <file> dosyasının gerçekte ne yaptığını hatırlayalım:

1. <file>, daha önce izlenmedi ise, git addbunu önbelleğe ekler, geçerli içeriğiyle birlikte.

2. <file>, zaten izlendi ise, git addgeçerli içeriği kaydeder (anlık görüntü, sürüm) önbelleğe. GIT'de, bu eylem hala add, (sadece update it değil) olarak adlandırılır, çünkü bir dosyanın iki farklı sürümü (anlık görüntü) iki farklı öğe olarak kabul edilir: Gerçekten de, daha sonra görevlendirilmek üzere önbelleğe yeni bir öğe eklemek.

Bunun ışığında, soru biraz belirsizdir:

Yanlışlıkla bu komutu kullanarak dosya ekledim ...

OP'nin senaryosu ilk (takip edilmeyen dosya) gibi gözüküyor, izlenen öğelerden "geri al" ın (yalnızca geçerli içeriği değil) dosyayı kaldırmasını istiyoruz. If bu durumda, o zaman git rm --cached <file> komutunu çalıştırabilirsiniz.

Ve ayrıca git reset HEAD <file> komutunu çalıştırabiliriz. Bu genel olarak tercih edilir, çünkü her iki senaryoda da işe yarar: zaten izlenen bir öğenin yanlış bir sürümünü eklediğimizde geri alma işlemini de yapar.

Fakat iki uyarı var.

Birincisi: (cevabında işaret edildiği gibi) git reset HEAD 'nin çalışmadığı sadece bir senaryo var, ancak git rm --cached' nin yaptığı: yeni bir depo (taahhüt yok). Ancak, gerçekten, bu pratik olarak alakasız bir durum.

İkincisi: git reset HEAD dosyasının önceden önbelleğe alınmış dosya içeriğini sihirli bir şekilde kurtaramayacağının farkında olun, sadece HEAD'den yeniden senkronize olur. Eğer yanlış yönlendirilmiş git add bir önceki aşamalı kaydedilmemiş sürümün üzerine yazarsa, onu kurtaramayız. Bu yüzden, kesinlikle konuşursak, geri alamayız [*].

Örnek:

$ git init
$ echo "version 1" > file.txt
$ git add file.txt   # first add  of file.txt
$ git commit -m 'first commit'
$ echo "version 2" > file.txt
$ git add  file.txt   # stage (don't commit) "version 2" of file.txt
$ git diff --cached file.txt
-version 1
+version 2
$ echo "version 3" > file.txt   
$ git diff  file.txt
-version 2
+version 3
$ git add  file.txt    # oops we didn't mean this
$ git reset HEAD file.txt  # undo ?
$ git diff --cached file.txt  # no dif, of course. stage == HEAD
$ git diff file.txt   # we have lost irrevocably "version 2"
-version 1
+version 3

Elbette, sadece yeni dosyalar eklemek için 'git add' işleminin normal tembel iş akışını izlersek (vaka 1) ve yeni içerikler, commit, git commit -a komutu ile güncellersek, bu çok kritik değildir.

^{* (Düzenleme: yukarıdakiler pratik olarak doğrudur, ancak yine de aşamalı fakat taahhüt edilmemiş ve üzerine yazılan değişiklikleri geri almak için hafifçe dolaştırılmış/kıvrımlı yollar olabilir - Johannes Matokic ve iolsmit'in yorumlarına bakın)}

git rm --cached . -r

geçerli dizinden eklediğiniz her şeyi tekrar tekrar "ekleyecektir"

Koşmak

git gui

ve tüm dosyaları manuel olarak veya hepsini seçip unstage commit düğmesine tıklayarak kaldırın.

Undo önceden eklenmiş bir dosya, git kullanarak önceden eklenmiş olan myfile.txt 'u sıfırlamak için oldukça kolaydır:

git reset HEAD myfile.txt

Açıkla:

İstenmeyen dosya (ları) düzenledikten sonra geri almak için git reset işlevini yapabilirsiniz, Head yerel olarak dosyanızın başıdır ve son parametre dosyanızın adıdır.

Aşağıdaki durumlarda, bu durumlarda olabilecek tüm adımlar da dahil olmak üzere, sizin için daha ayrıntılı olarak aşağıdaki adımları oluşturuyorum:

Git, akla gelebilecek her eylem için komutlara sahiptir, ancak işleri düzeltmek için kapsamlı bilgiye ihtiyaç duyar ve bu nedenle en iyi ihtimalle karşı sezgiseldir ...

Daha önce ne yaptınız:

• Bir dosyayı değiştirdi ve git add . veya git add <file> kullandı.

Ne istiyorsunuz:

• Dosyayı dizinden kaldırın, ancak çalışma kopyasında kaydedilmemiş değişikliklerle birlikte sürümlü ve solda tutun:

  git reset head <file>
  

• Dosyayı son durumuna HEAD'den sıfırlayın, değişiklikleri geri alın ve dizinden çıkartın:

  # Think `svn revert <file>` IIRC.
  git reset HEAD <file>
  git checkout <file>
  
  # If you have a `<branch>` named like `<file>`, use:
  git checkout -- <file>
  

  Bu gereklidir çünkü git reset --hard HEAD tek dosyalarla çalışmaz.

• Versiyon ve versiyonlamadan <file> dosyasını kaldırın, sürümlendirilmemiş dosyayı çalışma kopyasındaki değişikliklerle birlikte tutun:

  git rm --cached <file>
  

• <file> dosyasını çalışma kopyasından ve sürümlendirmeden tamamen kaldırın:

  git rm <file>
  

Soru açıkça ifade edilmedi. Sebep, git add 'nin iki anlamı vardır:

1. hazırlama alanına yeni dosya ekleyin, ardından git rm --cached file ile geri alın.
2. hazırlama alanına değiştirilmiş dosya ekleyerek, sonra git reset HEAD file ile geri alın.

şüpheniz varsa, kullanın

git reset HEAD file

Çünkü her iki durumda da beklenen şeyi yapıyor.

Uyarı:değiştirilmiş (önceden depoda bulunan bir dosya) dosyasında git rm --cached file yaparsanız, dosya git commit! Halen dosya sisteminizde mevcut olacaktır, ancak herhangi biri sizin taahhüdünüzü yerine getirirse, dosya çalışma ağacından silinir.

git status, dosyanın yeni dosya veya değiştirilmiş olup olmadığını size söyleyecektir:

On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   my_new_file.txt
    modified:   my_modified_file.txt

Eğer ilk taahhüdün içindeyseniz ve git reset kullanamıyorsanız, sadece "Git iflasını" bildirin ve .git klasörünü silin ve baştan başlayın

Diğer cevapların çoğuna göre git reset kullanabilirsiniz.

BUT:

Aslında gerçekten git unadd için Git komutunu ekleyen küçük bir yazı buldum: Ayrıntılar için git unadd veya.

Basitçe,

git config --global alias.unadd "reset HEAD"

Şimdi yapabilirsin

git unadd foo.txt bar.txt

git remove veya git rm, --cached bayrağıyla birlikte bunun için kullanılabilir. Deneyin:

git help rm

Yeni eklenen dosyaları gelecek taahhüdünüzden kaldırmak için git add -i kullanın. Örnek:

İstemediğiniz dosyayı eklemek:

$ git add foo
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   foo
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]#

Eklentinizi geri almak için etkileşimli eklentiye girme (git buraya yazılan komutlar "r" (geri döndürme), "1" (geri döndürme listesindeki ilk giriş gösterilir), geri döndürme modundan çıkmak için 'geri dön' ve "q" (çıkmak):

$ git add -i
           staged     unstaged path
  1:        +1/-0      nothing foo

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> r
           staged     unstaged path
  1:        +1/-0      nothing [f]oo
Revert>> 1
           staged     unstaged path
* 1:        +1/-0      nothing [f]oo
Revert>> 
note: foo is untracked now.
reverted one path

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> q
Bye.
$

Bu kadar! İşte "foo" nun takip edilmeyen listesine geri döndüğünü gösteren kanıtınız:

$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]
#       foo
nothing added to commit but untracked files present (use "git add" to track)
$

Yeni bir projeye başladığınızda, bu rahatsız edici sorunu önlemek için bir yol:

• Yeni projeniz için ana dizini oluşturun.
• git init dosyasını çalıştırın.
• Şimdi bir .gitignore dosyası oluşturun (boş olsa bile).
• .Gitignore dosyanızı tamamlayın.

Git, herhangi bir taahhüdünüz yoksa git reset yapmak gerçekten zor. Eğer küçük bir ilke yaratırsanız, sadece birinin sahip olması uğruna bir taahhütte bulunursanız, bundan sonra her şeyi doğru yapmak için git add -A ve git reset komutlarını istediğiniz kadar yapabilirsiniz.

Bu yöntemin bir başka avantajı, daha sonra satır sonu sıkıntılarıyla karşılaşırsanız ve tüm dosyalarınızı yenilemeniz gerekirse, kolay:

• İlk taahhüdünüzü kontrol edin. Bu, tüm dosyalarınızı kaldıracak.
• O zaman en son taahhüdünüzü tekrar kontrol edin. Bu, geçerli satır sonu ayarlarınızı kullanarak dosyalarınızın yeni kopyalarını alır.

Belki de sorunuzu yayınladığınızdan beri Git gelişti.

$> git --version
git version 1.6.2.1

Şimdi deneyebilirsiniz:

git reset HEAD .

Aradığın şey bu olmalı.

Bir revizyon belirtemezseniz, bir ayırıcı dahil etmeniz gerektiğini unutmayın. Konsolumdan örnek:

git reset <path_to_file>
fatal: ambiguous argument '<path_to_file>': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions

git reset -- <path_to_file>
Unstaged changes after reset:
M   <path_to_file>

(git sürüm 1.7.5.4)

Yeni dosyaları hazırlama alanından kaldırmak için (ve yalnızca yeni bir dosya olması durumunda), yukarıda belirtildiği gibi:

git rm --cached FILE

Sadece yanlışlıkla eklenen yeni dosyalar için rm --cached kullanın.

Belirli bir klasördeki (ve alt klasörlerindeki) her dosyayı sıfırlamak için aşağıdaki komutu kullanabilirsiniz:

git reset *

bir kerede birden fazla dosyayı işlemek için * komutunu kullanın

git reset HEAD *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*

vb

Sadece git reset yazın, geri dönecektir ve son işleminizden bu yana asla git add . yazmamış gibisiniz. Daha önce taahhüt ettiğinizden emin olun.

Farz edelim ki yeni bir dosya oluşturun: newFile.txt.

Diyelim ki dosyayı yanlışlıkla ekledim, git add newFile.txt

Şimdi bu eklentiyi geri almak istiyorum, taahhüt etmeden önce, git reset newFile.txt

Belirli bir dosya için:

• git sıfırla my_file.txt
• git ödeme my_file.txt

Tüm eklenen dosyalar için:

• git sıfırla.
• git ödeme.

Not: checkout , dosyalardaki kodu değiştirir ve en son güncellenen (kabul edilen) duruma geçer. reset kodları değiştirmez; sadece başlığı sıfırlar.

Git eklemek geri almak için kullanımı

git reset filename

Bu komut değişikliklerinizi kaldıracaktır:

git reset HEAD filename.txt

Ayrıca kullanabilirsiniz

git add -p 

dosyaların parçalarını eklemek için.

Kimsenin etkileşimli moddan bahsetmemesine şaşırdım:

git add -i

dosya eklemek için seçenek 3'ü seçin. Benim durumumda genellikle birden fazla dosya eklemek istiyorum, etkileşimli modda dosya eklemek için bu sayıları kullanabilirsiniz. Bu 4: 1,2,3,5 dışında hepsini alacak

Bir dizi seçmek için, 1'den 5'e kadar hepsini almak için sadece 1-5 yazın.

Git aşamalandırma dosyaları

git add myfile.txt # bu, dosyanızı taahhüt altına alınmış bir listeye ekler

Bu komutun tam tersi,

git reset HEAD myfile.txt  # this will undo it. 

öyleyse, önceki durumda olacaksın. belirtilen takip edilmemiş listede tekrar olacaktır (önceki durum).

kafanızı belirtilen dosya ile sıfırlar. bu nedenle, eğer kafanızda bulunmuyorsa, basitçe sıfırlayacaktır

git reset filename.txt

Dosya adı.txt adlı bir dosyayı geçerli dizinden, "işlem yapılacak" alanından başka bir şey değiştirmeden kaldıracak.

SourceTree'de bunu kolayca gui üzerinden yapabilirsiniz. Sourcetree'nin bir dosyayı ayırmak için hangi komutu kullandığını kontrol edebilirsiniz.

Yeni bir dosya oluşturdum ve git'e ekledim. Sonra onu SourceTree gui kullanarak etiketledim. Sonuç bu:

Sabitlenmemiş dosyalar [08/12/15 10:43]
git -c diff.mnemonicprefix = false-c core.quotepath = false -c credential.helper = sourcetree reset -q - yol/dosya/dosya/dosyaadı.Java

SourceTree, yeni dosyaları ayırmak için reset öğesini kullanır.

git reset filename.txt  

Dosya adı.txt adlı bir dosyayı geçerli dizinden, "işlem yapılacak" alanından başka bir şey değiştirmeden kaldıracak.

En sezgisel çözümlerden biri, SourceTree komutunu kullanmaktır.

Sadece aşamalı ve derecelendirilmemiş dosyaları sürükleyip bırakabilirsiniz  

git reset komutu, hazırlama alanını veya hazırlama alanını ve çalışma ağacını değiştirmenize yardımcı olur. Git'in istediğiniz gibi iş yapma yeteneği, bazen git add ile düzenlediğiniz değişikliklerde yapılan değişiklikleri geri almanız gerektiği anlamına gelir.

Bunu git reset HEAD <file to change>'yi arayarak yapabilirsiniz. Değişikliklerden tamamen kurtulmak için iki seçeneğiniz var. git checkout HEAD <file(s) or path(s)>, hazırlama alanınızdaki ve çalışan ağacınızdaki değişiklikleri geri almanın hızlı bir yoludur. Ancak bu komuta dikkat edin, çünkü çalışma ağacınızdaki tüm değişiklikleri kaldırır. Git, hiç bir zaman taahhüt edilmediğinden bu değişiklikleri bilmiyor. Bu komutu çalıştırdıktan sonra bu değişiklikleri geri almanın bir yolu yoktur.

Emrinde başka bir komut git reset --hard. Çalışma ağacınıza eşit derecede zarar verir - herhangi bir tamamlanmamış değişiklik veya ayarlanan değişiklikler çalıştırıldıktan sonra kaybolur. git reset -hard HEAD çalıştırmak, git checkout HEAD ile aynı şeyi yapar. Sadece çalışması için bir dosya veya yol gerektirmez.

--soft ile git reset kullanabilirsiniz. Depoyu belirttiğiniz taahhüdüne sıfırlar ve bu değişikliklerin tümünü aşamalandırır. Önceden düzenlediğiniz hiçbir değişiklik etkilenmez ve çalışma ağacınızdaki değişiklikler de etkilenmez.

Son olarak, çalışma ağacını herhangi bir değişiklik yapmadan sıfırlamak için --mixed öğesini kullanabilirsiniz. Bu aynı zamanda yapılan değişiklikleri de engeller.