Git ile en son taahhütleri yeni bir şubeye taşıyın


4985

Üstlenmeyi taahhüt ettiğim son birkaç taahhüdü yeni bir şubeye taşımak ve bu taahhütler yapılmadan önce master'ı geri almak istiyorum. Ne yazık ki, Git-fu'm henüz yeterince güçlü değil, herhangi bir yardım?

Yani bundan nasıl gidebilirim

master A - B - C - D - E

buna?

newbranch     C - D - E
             /
master A - B 

114
Not: Burada
Benjol


7
Buradaki yorumlar tasfiye edildi mi? Soruyorum çünkü bu soruya iki ayda bir yaptığım ziyarette, daima bu yoruma göre ilerlerim.
Tejas Kale

Yanıtlar:


6452

Mevcut bir şubeye geçme

Taahhütlerinizi mevcut bir şubeye taşımak istiyorsanız , şuna benzer:

git checkout existingbranch
git merge master         # Bring the commits here
git checkout master
git reset --keep HEAD~3  # Move master back by 3 commits.
git checkout existingbranch

Bu --keepseçenek, alakasız dosyalarda olabilecek taahhüt edilmemiş değişiklikleri korur veya bu değişikliklerin üzerine yazılması gerekeceği takdirde iptal eder - ne yaparsanız yapın git checkout. İptal edilirse, git stashdeğişikliklerinizi tekrar deneyin veya --harddeğişiklikleri kaybetmek için kullanın (taahhütler arasında değişmeyen dosyalardan bile!)

Yeni bir şubeye geçme

Bu yöntem, first command ( git branch newbranch) ile yeni bir dal oluşturarak ancak ona geçmeden çalışır. Ardından mevcut dalı (master) geri alır ve çalışmaya devam etmek için yeni şubeye geçeriz.

git branch newbranch      # Create a new branch, containing all current commits
git reset --keep HEAD~3   # Move master back by 3 commits (Make sure you know how many commits you need to go back)
git checkout newbranch    # Go to the new branch that still has the desired commits
# Warning: after this it's not safe to do a rebase in newbranch without extra care.

Ama kaç tane geri döneceğinden emin ol. Alternatif olarak, geri dönmek istediğiniz HEAD~3taahhüdü (veya referansı gibi origin/master) karma olarak sağlayabilirsiniz , örneğin:

git reset --keep a1b2c3d4

UYARI: Git sürüm 2.0 ve sonraki sürümlerinde, daha sonra git rebaseorijinal ( master) dalına yeni dal --no-fork-pointeklerseniz, ana daldan taşıdığınız taahhütleri kaybetmemek için yeniden başlatma sırasında açık bir seçeneğe ihtiyacınız olabilir . Having branch.autosetuprebase alwaysseti bu daha olası hale getirir. Ayrıntılar için John Mellor'un cevabına bakınız.


249
Ve özellikle de, yok son başkası çekmiş olabilir başka deposuna hareketin itilmiş noktadan daha geri ileri gitmek deneyin.
Greg Hewgill

107
NEDEN bunun işe yaradığını açıklayabilir misiniz merak ediyorum. Bana göre, yeni bir şube oluşturuyorsunuz, hâlâ üzerinde bulunduğunuz eski şubeden 3 taahhüt kaldırıyor ve daha sonra yaptığınız dalı kontrol ediyorsunuz. Peki sihirli bir şekilde kaldırdığınız taahhütler yeni dalda nasıl ortaya çıkıyor?
Jonathan Dumaine

142
@Jonathan Dumaine: Çünkü taahhütleri eski şubeden kaldırmadan önce yeni şubeyi oluşturdum. Hala yeni daldalar.
sykora

86
git şubeleri sadece tarihte taahhütleri gösteren işaretçilerdir, klonlanacak, yaratılacak veya silinecek hiçbir şey yoktur (işaretçiler hariç)
knittl

218
Ayrıca not: Bunu çalışma kopyanızdaki taahhüt edilmemiş değişikliklerle yapmayın! Bu beni biraz ısırdı! :(
Adam Tuttle

1038

Neden çalıştığını merak edenler için (ilk başta olduğu gibi):

C'ye geri dönmek ve D ve E'yi yeni şubeye taşımak istiyorsunuz. İlk başta şöyle görünüyor:

A-B-C-D-E (HEAD)
        ↑
      master

Sonra git branch newBranch:

    newBranch
        ↓
A-B-C-D-E (HEAD)
        ↑
      master

Sonra git reset --hard HEAD~2:

    newBranch
        ↓
A-B-C-D-E (HEAD)
    ↑
  master

Bir dal sadece bir işaretçi olduğundan, usta son taahhüdü işaret etti. Yaptığınız zaman newBranch son işlemeye, sadece yeni bir işaretçi yaptı. Sonra kullanarak ana işaretçiyi geri iki satır git resettaşıdı . Ancak newBranch'ı hareket ettirmediğiniz için , hala başlangıçta yaptığı taahhüdü işaret ediyor.


56
git push origin master --forceDeğişikliğin ana depoda görünmesi için bir de yapmam gerekiyordu .
Ocak

9
Bu cevap, taahhütlerin kaybolmasına neden olur: bir dahaki sefere git rebase, 3 komisyon sessizce atılır newbranch. Bkz Cevabımı detayları ve daha güvenli alternatiflere.
John Mellor

14
@John, bu saçmalık. Ne yaptığınızı bilmeden yeniden inşa etmek, taahhütlerin kaybolmasına neden olur. Taahhütleri kaybettiyseniz, sizin için üzgünüm, ama bu cevap taahhütlerinizi kaybetmedi. origin/masterYukarıdaki şemada görünmediğini unutmayın . origin/masterYukarıdaki değişiklikleri uyguladıysanız ve daha sonra yaptıysanız , her şey komik olacaktı. Ama bu bir "Doktor, bunu yaptığımda acıyor" gibi bir sorun. Ve orijinal sorunun sorduğu kapsamın dışında. Bu soruyu ele geçirmek yerine senaryonuzu keşfetmek için kendi sorunuzu yazmanızı öneririm.
Ryan Lundy

1
@John, cevabında "Bunu yapma! git branch -t newbranch" Dedin . Geri dön ve cevapları tekrar oku. Kimse bunu yapmayı önermedi.
Ryan Lundy

1
@Kyralessa, elbette, ancak sorudaki şemaya bakarsanız, newbranchmevcut yerel masterşubelerini temel almak istedikleri açıktır . Kullanıcı çalıştıran etrafında aldığında kabul cevabı gerçekleştirdikten sonra git rebaseiçinde newbranch, git Yayınlanmaları edeceğiz böylece, memba şube kurmayı unuttuğu onları hatırlatacaktır git branch --set-upstream-to=mastersonra git rebaseve aynı sorun var. git branch -t newbranchİlk etapta da kullanabilirler .
John Mellor

455

Genel olarak...

Sykora'nın maruz kaldığı yöntem bu durumda en iyi seçenektir. Ancak bazen en kolay değildir ve genel bir yöntem değildir. Genel bir yöntem için git cherry-pick kullanın :

OP'nin istediklerini elde etmek için, bu 2 adımlı bir işlemdir:

Adım 1 - İstediğiniz master'dan hangisinin bir newbranch

gerçekleştirmek

git checkout master
git log

İstediğiniz (3 diyelim) karmaları not edin newbranch. Burada kullanacağım:
C taahhüt: 9aa1233
D taahhüt: 453ac3d
E taahhüt:612ecb3

Not: İlk yedi karakteri veya tamamlama karmasını kullanabilirsiniz

Adım 2 - Onları newbranch

git checkout newbranch
git cherry-pick 612ecb3
git cherry-pick 453ac3d
git cherry-pick 9aa1233

VEYA (Git 1.7.2+ sürümünde, kullanım aralıkları)

git checkout newbranch
git cherry-pick 612ecb3~1..9aa1233

git cherry-pick bu üç taahhüdü yenidoğana uygular.


13
OP taşımaya çalışıyor muydu gelen usta için newbranch? Ustadayken kiraz seçerseniz, ana şubeye eklersiniz - aslında zaten sahip olduğu taahhütleri eklersiniz. Ve her iki şube kafasını B'ye geri taşımaz ya da alamadığım ince ve havalı bir şey var mı?
RaveTheTadpole

6
Yanlışlıkla, ana olmayan bir dalı yeni bir özellik dalı oluşturduğunuzda yanlışlıkla taahhüt ederseniz bu çok işe yarar.
julianc

5
Bazı durumlarda yararlı bir yaklaşım için +1. Bu sadece kendi taahhütlerinizi (başkalarıyla serpiştirilmiş olan) yeni bir şubeye çekmek istiyorsanız iyidir.
Tyler V.

8
Cevap daha iyi. Bu şekilde taahhütleri herhangi bir şubeye taşıyabilirsiniz.
skywinder

8
Kiraz toplama sırası önemli mi?
kon psych

328

Bunu yapmanın başka bir yolu, sadece 2 komut kullanarak. Ayrıca mevcut çalışma ağacınızı olduğu gibi tutar.

git checkout -b newbranch # switch to a new branch
git branch -f master HEAD~3 # make master point to some older commit

Eski sürüm - öğrenmeden öncegit branch -f

git checkout -b newbranch # switch to a new branch
git push . +HEAD~3:master # make master point to some older commit 

Edememek pushiçin .bilmek güzel hile.


1
Geçerli dizin. Sanırım bu sadece bir üst dizinde iseniz çalışır.
aragaer

1
Yerel itme sırıtmaya neden olur, ancak yansıma üzerine, git branch -fburada nasıl farklıdır ?
jthill

2
@GerardSexton .şu anki yönetmen. git UZAKLAR veya GIT URL'lerine zorlayabilir. path to local directory, Git URL'lerin sözdizimini destekliyor. İçindeki GIT URL'leri bölümüne bakın git help clone.
1414'te zayıf

31
Bunun neden daha yüksek derecelendirilmediğini bilmiyorum. Ölü basit ve küçük ama potansiyel git sıfırlama tehlikesi olmadan --hard.
Godsmith

4
@Godsmith Benim tahminim insanlar biraz daha belirsiz iki komuta üç basit komutu tercih ediyor. Ayrıca, en çok oy alan cevaplar, ilk önce gösterilme doğası gereği daha fazla oy alır.
JS_Riddler

323

Önceki cevapların çoğu tehlikeli bir şekilde yanlıştır!

Bunu yapma:

git branch -t newbranch
git reset --hard HEAD~3
git checkout newbranch

Bir dahaki sefere koştuğunuzda git rebase(veya git pull --rebase) bu 3 taahhüt sessizce atılacaktır newbranch! (aşağıdaki açıklamaya bakınız)

Bunun yerine şunu yapın:

git reset --keep HEAD~3
git checkout -t -b newbranch
git cherry-pick ..HEAD@{2}
  • Önce 3 En son kaydedilmesini atar ( --keepgibidir --hard, ancak daha güvenli olarak atmak uzakta kararsız değişiklikler ziyade başarısız).
  • Sonra çatallanır newbranch.
  • Sonra bu 3 taahhüdü tekrar yerine getirir newbranch. Artık bir şube tarafından başvurulan konum nedeniyle, seyahatseverlerin Git en kullanarak bunu yapmaz reflog : HEAD@{2}o taahhüt olduğunu HEADbiz 1. teslim önce 2 operasyon öncesine yani ifade etmek için kullanılır newbranchve 2. kullanılan git reset3 kaydedilmesini atmak.

Uyarı: reflog varsayılan olarak etkindir, ancak manuel olarak devre dışı bıraktıysanız (örn. "Çıplak" git deposu kullanarak), çalıştırdıktan sonra 3 işlemi geri alamazsınız git reset --keep HEAD~3.

Reflog'a güvenmeyen bir alternatif:

# newbranch will omit the 3 most recent commits.
git checkout -b newbranch HEAD~3
git branch --set-upstream-to=oldbranch
# Cherry-picks the extra commits from oldbranch.
git cherry-pick ..oldbranch
# Discards the 3 most recent commits from oldbranch.
git branch --force oldbranch oldbranch~3

(tercih ederseniz @{-1}- daha önce teslim alınmış dal - yerine yazabilirsiniz oldbranch).


Teknik açıklama

git rebaseİlk örnekten sonra neden 3 taahhüdü iptal edesiniz? Çünkü git rebasehiçbir argüman, --fork-pointvarsayılan olarak, yerel itme kuvvetini zorlanan yukarı akış dalına karşı sağlam olmaya çalışmak için kullanır seçeneği etkinleştirir .

Diyelim ki M1, M2, M3 taahhütlerini aldığında orijin / master dallı, sonra üç taahhütte bulundun:

M1--M2--M3  <-- origin/master
         \
          T1--T2--T3  <-- topic

ama sonra birisi M2'yi çıkarmak için başlangıç ​​noktasını / ustayı zorlayarak tarihi yeniden yazar:

M1--M3'  <-- origin/master
 \
  M2--M3--T1--T2--T3  <-- topic

Yerel refleksinizi kullanarak git rebase, başlangıç ​​/ ana dalın daha önceki bir enkarnasyonundan çatallandığınızı ve dolayısıyla M2 ve M3 taahhütlerinin gerçekten konu dalınızın bir parçası olmadığını görebilirsiniz. Bu nedenle, M2, akış yukarı daldan kaldırıldığından, konu dalı yeniden oluşturulduktan sonra artık konu dalınızda istemediğinizi varsayar:

M1--M3'  <-- origin/master
     \
      T1'--T2'--T3'  <-- topic (rebased)

Bu davranış mantıklıdır ve genellikle yeniden basarken yapılacak doğru şeydir.

Bu yüzden aşağıdaki komutların başarısız olmasının nedeni:

git branch -t newbranch
git reset --hard HEAD~3
git checkout newbranch

çünkü reflogları yanlış durumda bırakırlar. Git newbranch, 3 komutu içeren bir revizyonda yukarı akış dalını çatalladığını görür , daha sonra reset --hardtaahhütleri kaldırmak için yukarı akış tarihini yeniden yazar ve böylece bir daha çalıştırdığınızda git rebasebunları yukarı akıştan kaldırılan diğer herhangi bir taahhüt gibi atar.

Ancak bu özel durumda, bu 3 taahhüdün konu dalının bir parçası olarak değerlendirilmesini istiyoruz. Bunu başarmak için, 3 taahhüdü içermeyen daha önceki revizyonda yukarı akış yönünü kesmemiz gerekir. Benim önerdiğim çözümler bunu yapıyor, bu yüzden ikisi de reflog'u doğru durumda bırakıyor.

Daha fazla ayrıntı --fork-pointiçin git rebase ve git merge-base docs içindeki tanımına bakın .


15
Bu cevap "Bunu YAPMAYIN!" kimsenin önermediği bir şeyin üstünde.
Ryan Lundy

4
Çoğu insan, özellikle tarihinde yayınlanan tarihi yeniden yazmaz master. Yani hayır, tehlikeli bir şekilde yanlış değiller.
Walf

4
@Kyralessa, -tbahsettiğiniz git branchşey, siz git config --global branch.autosetuprebase alwaysbelirlediyseniz örtük olarak gerçekleşir . Yapmasanız bile , OP'nin bu soruları vermeyi planlaması muhtemel olduğundan, bu komutları gerçekleştirdikten sonra izlemeyi ayarlarsanız aynı sorunun oluştuğunu zaten açıklamıştım .
John Mellor

2
@RockLee, evet, bu tür durumları düzeltmenin genel yolu, güvenli bir başlangıç ​​noktasından yeni bir dal (newbranch2) oluşturmak ve ardından tutmak istediğiniz tüm taahhütleri (badnewbranch'tan newbranch2'ye) kiraz almaktır. Kiraz toplama, taahhütlere yeni karmalar verecektir, böylece newbranch2'yi güvenle yeniden tabanca edebileceksiniz (ve şimdi badnewbranch'ı silebilirsiniz).
John Mellor

2
@Walf, yanlış anladınız: git rebase , geçmişleri yeniden yazılan yukarı akışlara karşı sağlam olacak şekilde tasarlanmıştır. Ne yazık ki, bu sağlamlığın yan etkileri, ne onlar ne de yukarı akımları geçmişi yeniden yazmasa bile herkesi etkiler.
John Mellor

150

Git stash kullanarak çok daha basit çözüm

Yanlış şubeyi taahhüt etmek için çok daha basit bir çözüm. masterÜç yanlış taahhüt içeren şubeden başlayarak :

git reset HEAD~3
git stash
git checkout newbranch
git stash pop

Ne zaman kullanılır?

  • Birincil amacınız geri dönmekse master
  • Dosya değişikliklerini tutmak istiyorsunuz
  • Yanlış taahhütlerdeki mesajlar umrumda değil
  • Henüz itmedin
  • Bunu ezberlemenin kolay olmasını istiyorsun
  • Geçici / yeni dallar, taahhüt karmaları bulma ve kopyalama ve diğer baş ağrıları gibi komplikasyonlar istemezsiniz

Bunun satır numarasına göre ne yaptığı

  1. Son üç taahhüdü (ve mesajlarını) geri alır master, ancak tüm çalışan dosyaları olduğu gibi bırakır
  2. Tüm çalışma dosyası değişikliklerini saklar, böylece masterçalışma ağacı HEAD ~ 3 durumuna tam olarak eşit olur
  3. Mevcut bir şubeye geçer newbranch
  4. Stashed değişikliklerini çalışma dizininize uygular ve stash'ı temizler

Artık kullanabilir git addve git commither zamanki gibi. Tüm yeni taahhütler eklenecektir newbranch.

Bu ne yapmaz

  • Ağacınızı karmaşıklaştıran rastgele geçici dallar bırakmaz
  • Yanlış taahhüt mesajlarını korumaz, bu nedenle bu yeni taahhüde yeni bir taahhüt mesajı eklemeniz gerekir
  • Güncelleme! Taahhüt iletisiyle önceki taahhüdü yeniden uygulamak için komut arabelleğinizde ilerlemek için yukarı oku kullanın (teşekkürler @ARK)

Hedefler

OP, amacın değişiklikleri kaybetmeden "bu taahhütler yapılmadan önce ustayı geri almak" olduğunu belirtti ve bu çözüm bunu yapıyor.

Bunu haftada en az bir kez, masteryerine yanlışlıkla yeni taahhütler yaptığımda yaparım develop. Genellikle geri alma için yalnızca bir taahhüdüm var, bu durumda git reset HEAD^1 satırını kullanmak yalnızca bir taahhüdü geri almanın daha basit bir yoludur.

Efendinin değişikliklerini yukarı doğru ittiyseniz bunu yapmayın

Başka biri bu değişiklikleri yapmış olabilir. Sadece yerel ustanızı yeniden yazıyorsanız, yukarı doğru itildiğinde herhangi bir etkisi yoktur, ancak yeniden yazılmış bir geçmişi ortak çalışanlara iletmek baş ağrısına neden olabilir.


4
Teşekkürler, geçmişe / buraya gelmek için çok fazla okuduğum için çok mutluyum, çünkü benim için de oldukça yaygın bir kullanım örneği. Çok atipik miyiz?
Jim Mack

6
Bence tamamen tipikiz ve "yanlışlıkla ustalaşmayı taahhüt ettiğim ayy", bir avuç ya da daha az sayıda taahhüdü geri almanın en yaygın kullanım şeklidir. Şanslı bu çözüm o kadar basit şimdi ezberlemek var.
Slam

9
Bu kabul edilen cevap olmalı. Anlaşılır, anlaşılması kolay ve hatırlaması kolay
Sina Madani

1
Saklamanın gerekli olduğunu düşünmüyorum. Sadece onsuz yaptım ve iyi çalıştım.
Bir Campos

1
Teslim mesajlarınızı da CLI (komut satırı) geçmişinizde varsa kolayca geri alabilirsiniz. Ben sahip oldu hem git addve git committüm ı yukarı ok vurmak ve birkaç kez ve boom bir girmek edildi yapmak zorunda bu yüzden kullanılan komutları! Her şey geri döndü, ama şimdi doğru dalda.
Luke Gedeon

30

Bu, onları teknik anlamda "taşımıyor" ama aynı etkiye sahip:

A--B--C  (branch-foo)
 \    ^-- I wanted them here!
  \
   D--E--F--G  (branch-bar)
      ^--^--^-- Opps wrong branch!

While on branch-bar:
$ git reset --hard D # remember the SHAs for E, F, G (or E and G for a range)

A--B--C  (branch-foo)
 \
  \
   D-(E--F--G) detached
   ^-- (branch-bar)

Switch to branch-foo
$ git cherry-pick E..G

A--B--C--E'--F'--G' (branch-foo)
 \   E--F--G detached (This can be ignored)
  \ /
   D--H--I (branch-bar)

Now you won't need to worry about the detached branch because it is basically
like they are in the trash can waiting for the day it gets garbage collected.
Eventually some time in the far future it will look like:

A--B--C--E'--F'--G'--L--M--N--... (branch-foo)
 \
  \
   D--H--I--J--K--.... (branch-bar)

1
rebaseAynı şey için kullanamaz mısın?
Bergi

Evet, alternatif olarak rebaseyukarıdaki senaryoda müstakil şubede kullanabilirsiniz .
Sukima

24

Bunu geçmişi yeniden yazmadan yapmak için (örneğin, taahhütleri zaten ittiyseniz):

git checkout master
git revert <commitID(s)>
git checkout -b new-branch
git cherry-pick <commitID(s)>

Daha sonra her iki dal da zorlanmadan itilebilir!


Ama sonra, durumunuza bağlı olarak çok daha karmaşık olabilen geri alma senaryosuyla uğraşmak zorundasınız. Şube üzerinde bir taahhüdü geri alırsanız, Git yine de bu taahhütleri gerçekleşmiş olarak görecektir, bu yüzden geri almak için geri döndürmek zorundasınız. Bu, çok az insanı yakar, özellikle de bir birleşmeyi geri döndürdüklerinde ve şubeyi birleştirmeye çalıştıklarında, yalnızca Git'in o şubeyi zaten birleştirdiğine inandığını (tamamen doğrudur) bulmak için.
Makoto

1
Bu yüzden sonunda taahhütleri yeni bir şubeye seçiyorum. Bu şekilde git onları yeni taahhütler olarak görür, bu da sorununuzu çözer.
teh_senaus

Bu, ilk göründüğünden daha tehlikelidir, çünkü bu devletin sonuçlarını gerçekten anlamadan havuzun tarihinin durumunu değiştirirsiniz.
Makoto

5
Argümanınızı takip etmiyorum - bu cevabın amacı, tarihi değiştirmemeniz, sadece yeni taahhütler eklemenizdir (bu, değişiklikleri tekrar yapmayı etkili bir şekilde geri alır). Bu yeni taahhütler normal şekilde itilebilir ve birleştirilebilir.
teh_senaus

13

Sadece bu durum vardı:

Branch one: A B C D E F     J   L M  
                       \ (Merge)
Branch two:             G I   K     N

Yaptım:

git branch newbranch 
git reset --hard HEAD~8 
git checkout newbranch

Taahhüt etmenin KAFA olacağımı umuyordum, ama şimdi L emri ...

Tarihte doğru noktaya geldiğinizden emin olmak için taahhütlerin hash ile çalışmak daha kolay

git branch newbranch 
git reset --hard #########
git checkout newbranch

7

Bundan nasıl gidebilirim

A - B - C - D - E 
                |
                master

buna?

A - B - C - D - E 
    |           |
    master      newbranch

İki komutla

  • git branch -m master yeni başlayan

vererek

A - B - C - D - E 
                |
                newbranch

ve

  • git şube yöneticisi B

vererek

A - B - C - D - E
    |           |
    master      newbranch

Evet, bu işe yarıyor ve oldukça kolay. Sourcetree GUI, git kabuğunda yapılan değişiklikler hakkında biraz karışık, ancak bir getirmeden sonra tekrar tamam.
lars k.

Evet, sorudaki gibidirler. İlk iki diyagram, sorudakilere eşdeğerdir, sadece cevaptaki gösterim amacıyla istediğim şekilde yeniden çizilmiştir. Temel olarak ana dalı newbranch olarak yeniden adlandırın ve istediğiniz yerde yeni bir ana dal oluşturun.
Ivan

4

Eğer tüm unpushed taahhütlerinizi yeni bir şubeye taşımanız gerekiyorsa,

  1. oluşturmak bir yeni bir şube akım birinden:git branch new-branch-name

  2. itmek için yeni şube :git push origin new-branch-name

  3. dönmek için eski (mevcut) dalını son itilmiş / stabil duruma:git reset --hard origin/old-branch-name

Bazı insanlar da diğer sahip upstreamsziyade origin, bunlar uygun düzgün kullanmalıdırupstream


3

1) Tüm değişikliklerinizi new_branch'a taşıyan yeni bir şube oluşturun.

git checkout -b new_branch

2) Sonra eski şubeye geri dönün.

git checkout master

3) Git Rebase yapın

git rebase -i <short-hash-of-B-commit>

4) Daha sonra açılan editör son 3 taahhüt bilgisini içerir.

...
pick <C's hash> C
pick <D's hash> D
pick <E's hash> E
...

5) Değişim pickiçin dropo 3 kaydedilmesini tüm. Ardından düzenleyiciyi kaydedin ve kapatın.

...
drop <C's hash> C
drop <D's hash> D
drop <E's hash> E
...

6) Şimdi son 3 işlem geçerli şubeden ( master) kaldırılmıştır . Şimdi şubeyi, +şube adından önce işareti ile zorla itin .

git push origin +master

2

Bunu yapabileceğim sadece 3 basit adım.

1) son güncellemeyi yapmak istediğiniz yere yeni şube yapın.

git branch <branch name>

2) Yeni branşta taahhüt için Son İşlem Kimliği'ni bulun.

git log

3) En Son kesinleştirme listesinin üstte yer aldığı kesin kimlik notunu kopyalayın. böylece taahhüdünüzü bulabilirsiniz. bunu mesaj yoluyla da bulabilirsiniz.

git cherry-pick d34bcef232f6c...

ayrıca bir taahhüt kimliği çaldı.

git cherry-pick d34bcef...86d2aec

Şimdi işin bitti. Doğru kimliği ve doğru dalı seçtiyseniz, o zaman başarı elde edersiniz. Bu yüzden daha önce dikkatli olun. aksi takdirde başka bir sorun ortaya çıkabilir.

Şimdi kodunuzu zorlayabilirsiniz

git push


0

Bunu yapmanın başka bir yolu:

[1] Şubenizi yeniden adlandırın ( masterşubede olduğunuzu newbranchvarsayarak master):

git branch -m newbranch

[2]master İstediğiniz taahhütten şube oluşturun :

git checkout -b master <seven_char_commit_id>

örneğin git checkout -b master a34bc22

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.