Sto usando git su un nuovo progetto che ha due rami di sviluppo paralleli, ma attualmente sperimentali:

• master: importazione di codebase esistenti più alcune mod di cui sono generalmente sicuro
• exp1: ramo sperimentale n. 1
• exp2: ramo sperimentale n. 2

exp1e exp2rappresentano due approcci architettonici molto diversi. Fino a quando non andrò oltre non ho modo di sapere quale (se uno dei due) funzionerà. Mentre faccio progressi in un ramo a volte ho delle modifiche che potrebbero essere utili nell'altro ramo e vorrei unire solo quelle.

Qual è il modo migliore per unire i cambiamenti selettivi da un ramo di sviluppo all'altro lasciando tutto il resto?

Approcci che ho considerato:

1. git merge --no-commit seguito da unstaging manuale di un gran numero di modifiche che non voglio rendere comuni tra i rami.

2. Copia manuale dei file comuni in una directory temporanea seguita da git checkoutper spostarsi sull'altro ramo e quindi copia più manuale dalla directory temporanea nell'albero di lavoro.

3. Una variazione su quanto sopra. Abbandonare i exprami per ora e utilizzare due repository locali aggiuntivi per la sperimentazione. Ciò rende la copia manuale dei file molto più semplice.

Tutti e tre questi approcci sembrano noiosi e soggetti a errori. Spero che ci sia un approccio migliore; qualcosa di simile a un parametro del percorso del filtro che renderebbe git-mergepiù selettivo.

Utilizzare il comando cherry-pick per ottenere singoli commit da un ramo.

Se le modifiche desiderate non rientrano nei singoli commit, utilizzare il metodo mostrato qui per suddividere il commit in singoli commit . In parole povere, si utilizza git rebase -iper ottenere il commit originale da modificare, quindi git reset HEAD^per ripristinare selettivamente le modifiche, quindi git commitper eseguire il commit di quel bit come nuovo commit nella cronologia.

C'è un altro bel metodo qui in Red Hat Magazine, dove usano git add --patcho forse git add --interactiveti permette di aggiungere solo parti di un pezzo, se vuoi dividere diverse modifiche in un singolo file (cerca "diviso" in quella pagina).

Dopo aver diviso le modifiche, ora puoi scegliere solo quelle che desideri.

Ho avuto lo stesso identico problema menzionato sopra da te. Ma ho trovato questo più chiaro nel spiegare la risposta.

Sommario:

• Verifica i percorsi dal ramo che desideri unire,

  $ git checkout source_branch -- <paths>...
  

  Suggerimento: funziona anche senza --essere visto nel post collegato.

• o per unire selettivamente gli hunk

  $ git checkout -p source_branch -- <paths>...
  

  In alternativa, utilizzare reset e quindi aggiungere con l'opzione -p,

  $ git reset <paths>...
  $ git add -p <paths>...
  

• Finalmente impegno

  $ git commit -m "'Merge' these changes"
  

Per unire selettivamente i file da un ramo a un altro ramo, esegui

git merge --no-ff --no-commit branchX

dove si branchXtrova il ramo che si desidera unire nel ramo corrente.

L' --no-commitopzione metterà in scena i file che sono stati uniti da Git senza effettivamente eseguirne il commit. Questo ti darà l'opportunità di modificare i file uniti come desideri e poi di impegnarli da soli.

A seconda di come si desidera unire i file, ci sono quattro casi:

1) Vuoi una vera unione.

In questo caso, accetti i file uniti nel modo in cui Git li ha uniti automaticamente e poi li commetti.

2) Ci sono alcuni file che non vuoi unire.

Ad esempio, si desidera conservare la versione nel ramo corrente e ignorare la versione nel ramo da cui si sta unendo.

Per selezionare la versione nel ramo corrente, eseguire:

git checkout HEAD file1

Questo recupererà la versione di file1nel ramo corrente e sovrascriverà il file1comando automatico di Git.

3) Se vuoi la versione in branchX (e non una vera unione).

Correre:

git checkout branchX file1

Questo recupererà la versione di file1in branchXe sovrascriverà file1automaticamente unita da Git.

4) L'ultimo caso è se si desidera selezionare solo fusioni specifiche file1.

In questo caso, puoi modificare file1direttamente la modifica , aggiornarla a qualunque cosa tu voglia file1diventare la versione e quindi eseguire il commit.

Se Git non è possibile unire automaticamente un file, segnalerà il file come " unmerged " e produrre una copia in cui è necessario risolvere i conflitti manualmente.

Per spiegare ulteriormente con un esempio, supponiamo che tu voglia unirti branchXal ramo corrente:

git merge --no-ff --no-commit branchX

Quindi si esegue il git statuscomando per visualizzare lo stato dei file modificati.

Per esempio:

git status

# On branch master
# Changes to be committed:
#
#       modified:   file1
#       modified:   file2
#       modified:   file3
# Unmerged paths:
#   (use "git add/rm <file>..." as appropriate to mark resolution)
#
#       both modified:      file4
#

Where file1, file2e file3sono i file che git si sono uniti automaticamente con successo.

Ciò significa che i cambiamenti in mastere branchXper tutti e tre questi file sono stati combinati insieme senza alcun conflitto.

È possibile controllare come è stata eseguita l'unione eseguendo il git diff --cached;

git diff --cached file1
git diff --cached file2
git diff --cached file3

Se ritieni che alcune fusioni siano indesiderabili, puoi farlo

1. modifica direttamente il file
2. Salva
3. git commit

Se non si desidera unire file1e si desidera conservare la versione nel ramo corrente

Correre

git checkout HEAD file1

Se non si desidera unire file2e si desidera solo la versionebranchX

Correre

git checkout branchX file2

Se vuoi file3unirti automaticamente, non fare nulla.

Git lo ha già unito a questo punto.

file4sopra è una fusione fallita di Git. Ciò significa che ci sono cambiamenti in entrambi i rami che si verificano sulla stessa linea. Qui è dove dovrai risolvere i conflitti manualmente. Puoi scartare l'unione fatta modificando direttamente il file o eseguendo il comando di checkout per la versione nel ramo che vuoi file4diventare.

Infine, non dimenticare di git commit.

Non mi piacciono gli approcci di cui sopra. L'uso di cherry-pick è ottimo per scegliere una singola modifica, ma è una seccatura se si desidera apportare tutte le modifiche tranne alcune sbagliate. Ecco il mio approccio.

Non ci sono --interactiveargomenti che puoi passare per git merge.

Ecco l'alternativa:

Hai alcune modifiche alla "caratteristica" del ramo e vuoi portarne alcune, ma non tutte, al "padrone" in un modo non sciatto (cioè non vuoi scegliere e impegnare ognuna)

git checkout feature
git checkout -b temp
git rebase -i master

# Above will drop you in an editor and pick the changes you want ala:
pick 7266df7 First change
pick 1b3f7df Another change
pick 5bbf56f Last change

# Rebase b44c147..5bbf56f onto b44c147
#
# Commands:
# pick = use commit
# edit = use commit, but stop for amending
# squash = use commit, but meld into previous commit
#
# If you remove a line here THAT COMMIT WILL BE LOST.
# However, if you remove everything, the rebase will be aborted.
#

git checkout master
git pull . temp
git branch -d temp

Quindi basta avvolgerlo in uno script di shell, cambiare master in $ a e cambiare funzionalità in $ da e sei a posto:

#!/bin/bash
# git-interactive-merge
from=$1
to=$2
git checkout $from
git checkout -b ${from}_tmp
git rebase -i $to
# Above will drop you in an editor and pick the changes you want
git checkout $to
git pull . ${from}_tmp
git branch -d ${from}_tmp

C'è un altro modo di procedere:

git checkout -p

È un mix tra git checkoute git add -pe potrebbe essere esattamente quello che stai cercando:

   -p, --patch
       Interactively select hunks in the difference between the <tree-ish>
       (or the index, if unspecified) and the working tree. The chosen
       hunks are then applied in reverse to the working tree (and if a
       <tree-ish> was specified, the index).

       This means that you can use git checkout -p to selectively discard
       edits from your current working tree. See the “Interactive Mode”
       section of git-add(1) to learn how to operate the --patch mode.

Mentre alcune di queste risposte sono piuttosto buone, mi sembra che nessuna abbia effettivamente risposto al vincolo originale di OP: selezionare determinati file da determinati rami. Questa soluzione lo fa, ma può essere noiosa se ci sono molti file.

Diciamo che avere i master, exp1e exp2rami. Si desidera unire un file da ciascuno dei rami sperimentali in master. Vorrei fare qualcosa del genere:

git checkout master
git checkout exp1 path/to/file_a
git checkout exp2 path/to/file_b

# save these files as a stash
git stash
# merge stash with master
git merge stash

Questo ti darà differenze nel file per ciascuno dei file che desideri. Niente di più. Nientemeno. È utile avere cambiamenti di file radicalmente diversi tra le versioni - nel mio caso, cambiare un'app da Rails 2 a Rails 3.

EDIT : questo unirà i file, ma farà una fusione intelligente. Non sono riuscito a capire come usare questo metodo per ottenere informazioni diff nel file (forse lo faranno ancora per differenze estreme. Piccole cose fastidiose come gli spazi bianchi vengono ricongiunte a meno che tu non usi l' -s recursive -X ignore-all-spaceopzione)

1800 La risposta di INFORMAZIONI è completamente corretta. Come git noob, però, "usa git cherry-pick" non mi è bastato per capirlo senza scavare un po 'di più su Internet, quindi ho pensato di pubblicare una guida più dettagliata nel caso in cui ci fosse qualcuno barca simile.

Il mio caso d'uso era voler selezionare selettivamente le modifiche dal ramo github di qualcun altro nel mio. Se disponi già di una filiale locale con le modifiche, devi solo eseguire i passaggi 2 e 5-7.

1. Crea (se non creato) una filiale locale con le modifiche che desideri apportare.

   $ git branch mybranch <base branch>

2. Passaci dentro.

   $ git checkout mybranch

3. Elimina le modifiche desiderate dall'account dell'altra persona. Se non l'hai già fatto, ti consigliamo di aggiungerli come telecomando.

   $ git remote add repos-w-changes <git url>

4. Abbassa tutto dal loro ramo.

   $ git pull repos-w-changes branch-i-want

5. Visualizza i registri di commit per vedere quali modifiche desideri:

   $ git log

6. Tornare al ramo in cui si desidera eseguire il pull delle modifiche.

   $ git checkout originalbranch

7. Cherry raccoglie i tuoi impegni, uno per uno, con gli hash.

   $ git cherry-pick -x hash-of-commit

Suggerimento per il cappello: http://www.sourcemage.org/Git_Guide

Ecco come è possibile sostituire il Myclass.javafile nel masterramo con Myclass.javanel feature1ramo. Funzionerà anche se Myclass.javanon esiste master.

git checkout master
git checkout feature1 Myclass.java

Nota che questo sovrascriverà - non unirà - e ignorerà piuttosto le modifiche locali nel ramo principale.

Il modo semplice, per unire effettivamente file specifici da due rami, non solo sostituire file specifici con quelli di un altro ramo.

Fase 1: diff. I rami

git diff branch_b > my_patch_file.patch

Crea un file patch della differenza tra il ramo corrente e branch_b

Passaggio 2: applicare la patch sui file corrispondenti a un motivo

git apply -p1 --include=pattern/matching/the/path/to/file/or/folder my_patch_file.patch

note utili sulle opzioni

È possibile utilizzare *come carattere jolly nel modello di inclusione.

Non è necessario sfuggire alle barre.

Inoltre, potresti usare --exclude invece e applicarlo a tutto tranne i file che corrispondono allo schema, o invertire la patch con -R

L'opzione -p1 è un blocco dal comando * unix patch e il fatto che il contenuto del file patch anteponga ogni nome di file con a/o b/(o più a seconda di come è stato generato il file patch) che è necessario rimuovere in modo che possa capire il file reale al percorso del file a cui deve essere applicata la patch.

Controlla la pagina man per git-apply per ulteriori opzioni.

Step tre: non c'è step tre

Ovviamente vorresti impegnare le tue modifiche, ma chi può dire che non hai altre modifiche correlate che vuoi fare prima di effettuare il commit.

Ecco come puoi fare in modo che la cronologia segua solo un paio di file da un altro ramo con un minimo sforzo, anche se una fusione più "semplice" avrebbe portato molte più modifiche che non desideri.

Innanzitutto, prenderai il passo insolito di dichiarare in anticipo che ciò che stai per commettere è un'unione, senza che git faccia nulla ai file nella tua directory di lavoro:

git merge --no-ff --no-commit -s ours branchname1

. . . dove "branchname" è qualunque cosa tu pretenda di fondere. Se dovessi impegnarti subito, non farebbe alcun cambiamento ma mostrerebbe comunque origini da parte dell'altro ramo. È possibile aggiungere più rami / tag / ecc. alla riga di comando, se necessario, anche. A questo punto, tuttavia, non ci sono modifiche da eseguire, quindi procurati i file dalle altre revisioni.

git checkout branchname1 -- file1 file2 etc

Se ti stai unendo da più di un altro ramo, ripeti se necessario.

git checkout branchname2 -- file3 file4 etc

Ora i file dell'altro ramo sono nell'indice, pronti per il commit, con cronologia.

git commit

e avrai molte spiegazioni da fare in quel messaggio di commit.

Si prega di notare, tuttavia, nel caso in cui non fosse chiaro, che è una cosa sbagliata da fare. Non è nello spirito a cosa serve un "ramo", e la scelta della ciliegia è un modo più onesto per fare ciò che faresti, qui. Se vuoi fare un'altra "unione" per altri file sullo stesso ramo che non hai portato l'ultima volta, ti fermerà con un messaggio "già aggiornato". È un sintomo di non ramificarsi quando dovremmo avere, nel ramo "da" dovrebbe esserci più di un ramo diverso.

So di essere un po 'in ritardo, ma questo è il mio flusso di lavoro per unire file selettivi.

#make a new branch ( this will be temporary)
git checkout -b newbranch
# grab the changes 
git merge --no-commit  featurebranch
# unstage those changes
git reset HEAD
(you can now see the files from the merge are unstaged)
# now you can chose which files are to be merged.
git add -p
# remember to "git add" any new files you wish to keep
git commit

Il modo più semplice è impostare il repository sul ramo con cui si desidera unire, quindi eseguire,

git checkout [branch with file] [path to file you would like to merge]

Se corri

git status

vedrai il file già in scena ...

Quindi corri

git commit -m "Merge changes on '[branch]' to [file]"

Semplice.

Ho trovato questo post per contenere la risposta più semplice. Fai semplicemente:

$ #git checkout <branch from which you want files> <file paths>

Esempio:

$ #pulling .gitignore file from branchB into current branch
$ git checkout branchB .gitignore

Vedi il post per maggiori informazioni.

È strano che Git non abbia ancora uno strumento così conveniente "pronto all'uso". Lo uso pesantemente quando aggiorno un ramo della vecchia versione (che ha ancora molti utenti software) solo con alcune correzioni del ramo della versione corrente. In questo caso è spesso necessario ottenere rapidamente solo alcune righe di codice dal file nel trunk, ignorando molte altre modifiche (che non dovrebbero andare nella vecchia versione) ... E ovviamente l' unione interattiva a tre vie è necessario in questo caso, git checkout --patch <branch> <file path>non è utilizzabile per questo scopo di unione selettiva.

Puoi farlo facilmente:

Aggiungi questa riga alla [alias]sezione del tuo file globale .gitconfigo locale .git/config:

[alias]
    mergetool-file = "!sh -c 'git show $1:$2 > $2.theirs; git show $(git merge-base $1 $(git rev-parse HEAD)):$2 > $2.base; /C/BCompare3/BCompare.exe $2.theirs $2 $2.base $2; rm -f $2.theirs; rm -f $2.base;' -"

Implica che usi Beyond Compare. Passa al software che preferisci, se necessario. Oppure puoi cambiarlo in unione automatica a tre vie se non hai bisogno della fusione selettiva interattiva:

[alias]
    mergetool-file = "!sh -c 'git show $1:$2 > $2.theirs; git show $(git merge-base $1 $(git rev-parse HEAD)):$2 > $2.base; git merge-file $2 $2.base $2.theirs; rm -f $2.theirs; rm -f $2.base;' -"

Quindi utilizzare in questo modo:

git mergetool-file <source branch> <file path>

Questo ti darà la vera opportunità di unione selettiva per alberi di qualsiasi file in un altro ramo.

Non è esattamente quello che stavi cercando, ma mi è stato utile:

git checkout -p <branch> -- <paths> ...

È un mix di alcune risposte.

Vorrei fare un

git diff commit1..commit2 filepattern | git-apply --index && git commit

In questo modo è possibile limitare l'intervallo di commit per un filepattern da un ramo.

Rubato da: http://www.gelato.unsw.edu.au/archives/git/0701/37964.html

Ho avuto lo stesso identico problema menzionato sopra da te. Ma ho trovato questo blog git più chiaro nello spiegare la risposta.

Comando dal link sopra:

#You are in the branch you want to merge to
git checkout <branch_you_want_to_merge_from> <file_paths...>

Mi piace la risposta "git-interactive-merge", sopra, ma ce n'è una più semplice. Lascia che git faccia questo per te usando una combinazione rebase di interattivo e su:

      A---C1---o---C2---o---o feature
     /
----o---o---o---o master

Quindi il caso è che tu voglia C1 e C2 dal ramo 'feature' (punto di diramazione 'A'), ma per il momento niente del resto.

# git branch temp feature
# git checkout master
# git rebase -i --onto HEAD A temp

Che, come sopra, ti porta all'editor interattivo in cui selezioni le righe 'pick' per C1 e C2 (come sopra). Salva ed esci, e poi procederà con il rebase e ti darà il ramo 'temp' e anche HEAD al master + C1 + C2:

      A---C1---o---C2---o---o feature
     /
----o---o---o---o-master--C1---C2 [HEAD, temp]

Quindi puoi semplicemente aggiornare master su HEAD ed eliminare il ramo temporaneo e sei a posto:

# git branch -f master HEAD
# git branch -d temp

Che dire git reset --soft branch? Sono sorpreso che nessuno lo abbia ancora menzionato.

Per me, è il modo più semplice per selezionare selettivamente le modifiche da un altro ramo, poiché questo comando inserisce nel mio albero di lavoro tutte le modifiche alla diff e posso facilmente selezionare o ripristinare quella di cui ho bisogno. In questo modo, ho il pieno controllo dei file impegnati.

So che questa domanda è vecchia e ci sono molte altre risposte, ma ho scritto il mio script chiamato 'pmerge' per unire parzialmente le directory. È un work in progress e sto ancora imparando sia script git che bash.

Questo comando utilizza git merge --no-commite quindi non applica le modifiche che non corrispondono al percorso fornito.

Utilizzo: git pmerge branch path
Esempio:git merge develop src/

Non l'ho testato ampiamente. La directory di lavoro deve essere libera da qualsiasi modifica senza commit e file non tracciati.

#!/bin/bash

E_BADARGS=65

if [ $# -ne 2 ]
then
    echo "Usage: `basename $0` branch path"
    exit $E_BADARGS
fi

git merge $1 --no-commit
IFS=$'\n'
# list of changes due to merge | replace nulls w newlines | strip lines to just filenames | ensure lines are unique
for f in $(git status --porcelain -z -uno | tr '\000' '\n' | sed -e 's/^[[:graph:]][[:space:]]\{1,\}//' | uniq); do
    [[ $f == $2* ]] && continue
    if git reset $f >/dev/null 2>&1; then
        # reset failed... file was previously unversioned
        echo Deleting $f
        rm $f
    else
        echo Reverting $f
        git checkout -- $f >/dev/null 2>&1
    fi
done
unset IFS

È possibile utilizzare read-treeper leggere o unire l'albero remoto specificato nell'indice corrente, ad esempio:

git remote add foo git@example.com/foo.git
git fetch foo
git read-tree --prefix=my-folder/ -u foo/master:trunk/their-folder

Per eseguire l'unione, utilizzare -minvece.

Vedi anche: Come unire una sottodirectory in git?

Un approccio semplice per fusione / commit selettivi per file:

git checkout dstBranch git merge srcBranch // make changes, including resolving conflicts to single files git add singleFile1 singleFile2 git commit -m "message specific to a few files" git reset --hard # blow away uncommitted changes

Se non hai troppi file che sono stati modificati, questo ti lascerà senza ulteriori commit.

1. Ramo duplicato temporaneamente
$ git checkout -b temp_branch

2. Ripristina l'ultimo commit desiderato
$ git reset --hard HEAD~n , dove si ntrova il numero di commit necessari per tornare indietro

3. Controlla ogni file dal ramo originale
$ git checkout origin/original_branch filename.ext

Ora puoi eseguire il commit e forzare il push (per sovrascrivere il telecomando), se necessario.

Se avete solo bisogno di unire una directory e congedo particolare tutto il resto intatto e tuttavia conservare la storia, si potrebbe forse provare questo ... creare una nuova target-branchvia della masterprima di sperimentare.

I passaggi seguenti presuppongono che tu abbia due rami target-branche source-branchche la directory dir-to-mergeche desideri unire sia in source-branch. Supponi anche di avere altre directory come dir-to-retainnel target che non desideri modificare e conservare la cronologia. Inoltre, presuppone che ci siano conflitti di unione nel file dir-to-merge.

git checkout target-branch
git merge --no-ff --no-commit -X theirs source-branch
# the option "-X theirs", will pick theirs when there is a conflict. 
# the options "--no--ff --no-commit" prevent a commit after a merge, and give you an opportunity to fix other directories you want to retain, before you commit this merge.

# the above, would have messed up the other directories that you want to retain.
# so you need to reset them for every directory that you want to retain.
git reset HEAD dir-to-retain
# verify everything and commit.

Quando sono cambiati solo pochi file tra i commit correnti dei due rami, unisco manualmente le modifiche passando attraverso i diversi file.

git difftoll <branch-1>..<branch-2>