Ottieni modifiche da master a branch in Git

Nel mio repository ho un ramo chiamato a aqcui sto lavorando.

Ho quindi commesso nuovi lavori e bug master.

Qual è il modo migliore per ottenere quei commit nella aqfiliale? Creare un altro nuovo ramo da mastere unirlo con aq?

Dai un'occhiata al aqramo e rinnova da master.

git checkout aq
git rebase master

Dovresti essere in grado di farlo proprio git merge origin/masterquando sei nel tuo ramo aq.

git checkout aq
git merge origin/master

Primo check out per padroneggiare:

git checkout master

Apporta tutte le modifiche, hotfix e commit e spingi il tuo master.

Torna al tuo ramo, 'aq', e unisci master in esso:

git checkout aq
git merge master

La tua filiale sarà aggiornata con il master. Un buon esempio di base di unione è 3.2 Git Branching - Basic Branching and Merging .

Non vi è alcuna garanzia che le correzioni di bug principali non siano tra gli altri commit, quindi non si può semplicemente unire. Fare

git checkout aq
git cherry-pick commit1
git cherry-pick commit2
git cherry-pick commit3
...

supponendo che tali commit rappresentino le correzioni di bug.

D'ora in poi, mantieni le correzioni dei bug in un ramo separato. Sarai in grado di

git merge hotfixes

quando vuoi farli rotolare tutti nel ramo dev normale.

O cherry-pickil pertinente si impegna in succursale aqo unire succursale masterin succursale aq.

Uniscilo con aq

git checkout master
git pull
git checkout aq
git merge --no-ff master
git push

Modo semplice

# 1. Create a new remote branch A base on last master
# 2. Checkout A
# 3. Merge aq to A

Per me, avevo già apportato modifiche e volevo le ultime novità dal ramo di base. Non ero in grado di fare rebasee cherry-pickavrei impiegato un'eternità, quindi ho fatto quanto segue:

git fetch origin <base branch name>  
git merge FETCH_HEAD

quindi in questo caso:

git fetch origin master  
git merge FETCH_HEAD

Questo ( da qui ) ha funzionato per me:

git checkout aq
git pull origin master
...
git push

citando:

git pull origin masterrecupera e unisce il contenuto del ramo principale con il ramo e crea un commit di unione. In caso di conflitti di unione , ti verrà comunicato in questa fase e devi risolvere i commit di unione prima di procedere . Quando sei pronto a inviare i tuoi commit locali, incluso il nuovo commit di merge, sul server remoto, esegui git push.

Hai un paio di opzioni. git rebase master aqsul ramo che manterrà i nomi di commit, ma NON SOSTITUIRE se si tratta di un ramo remoto. Puoi git merge master aqfarlo se non ti interessa conservare i nomi di commit. Se si desidera mantenere i nomi di commit ed è un ramo remoto, git cherry-pick <commit hash>i commit sul proprio ramo.

Puoi anche farlo eseguendo una singola riga.
git merge aq master

Questo equivale a

git checkout aq
git merge master

MODIFICARE:

La mia risposta di seguito documenta un modo in cui unire , masterin aqcui se si visualizzano i dettagli della fusione, vengono elencate le modifiche apportate aqprima della fusione, non le modifiche apportate master. Ho capito che probabilmente non è quello che vuoi, anche se pensi che lo sia!

Appena:

git checkout aq
git merge master

è ok.

Sì, questa semplice unione mostrerà che le modifiche da mastersono state apportate aqa quel punto, non viceversa; ma va bene - dato che è quello che è successo! Più tardi, quando finalmente unisci il tuo ramo master, è allora che una fusione mostrerà finalmente tutte le modifiche apportate master(che è esattamente quello che vuoi, ed è l'impegno in cui le persone si aspetteranno di trovare comunque quelle informazioni).

Ho controllato e anche l'approccio seguente mostra esattamente le stesse modifiche (tutte le modifiche apportate aqdopo la divisione originale tra aqe master) dell'approccio normale sopra, quando alla fine si fondono nuovamente tutti gli elementi master. Quindi penso che il suo unico vero svantaggio (oltre ad essere troppo complesso e non standard ...: - /) è che se si riavvolgono n recenti cambiamenti git reset --hard HEAD~<n>e questo va oltre l'unione, allora la versione seguente torna indietro ramo "sbagliato", che devi correggere manualmente (ad es. con git reflog& git reset --hard [sha]).

[Quindi, quello che precedentemente pensavo fosse:]

Si è verificato un problema con:

git checkout aq
git merge master

perché le modifiche mostrate nel commit di merge (ad esempio se guardi ora o più tardi in Github, Bitbucket o il tuo visualizzatore di cronologia git locale preferito) sono le modifiche apportate sul master, che potrebbe non essere quello che desideri.

D'altro canto

git checkout master
git merge aq

mostra le modifiche apportate in aq, che probabilmente è quello che vuoi. (O almeno, è spesso quello che voglio!) Ma l'unione che mostra i cambiamenti giusti è nel ramo sbagliato!

Come far fronte ?!

Il processo completo, che termina con un commit di unione che mostra le modifiche apportate su aq (come per la seconda unione di cui sopra), ma con l'unione che influenza il ramo di aq, è:

git checkout master
git merge aq
git checkout aq
git merge master
git checkout master
git reset --hard HEAD~1
git checkout aq

Questo: fonde aq su master, fa avanzare rapidamente la stessa unione su aq, lo annulla su master e ti riporta di nuovo su aq!

Sento che mi sto perdendo qualcosa - questo sembra essere qualcosa che ovviamente vorresti, e qualcosa che è difficile da fare.

Inoltre, rebase NON è equivalente. Perde i timestamp e l'identità dei commit effettuati su aq, che non è anche quello che voglio.

Scenario :

• Ho creato un ramo dal master dire branch-1 e l'ho tirato sul mio locale.
• Il mio amico ha creato un ramo dal maestro dire ramo-2.
• Ha commesso alcune modifiche al codice da padroneggiare.
• Ora voglio portare quelle modifiche dal ramo principale al mio ramo locale.

Soluzione

git stash // to save all existing changes in local branch
git checkout master // Switch to master branch from branch-1
git pull // take changes from the master
git checkout branch-1 // switchback to your own branch
git rebase master // merge all the changes and move you git head  forward
git stash apply // reapply all you saved changes 

Puoi trovare conflitti sul tuo file dopo aver eseguito "git stash apply". Devi ripararlo manualmente e ora sei pronto per spingere.