Kaip pasirinktinai sujungti ar pasirinkti pakeitimus iš kito „Git“ filialo?

Naudoju git naują projektą, kuriame yra dvi lygiagrečios, bet šiuo metu eksperimentinės plėtros šakos:

  • master : importuokite esamą kodo bazę ir keletą modų, kuriuos paprastai pasitikiu
  • exp1 : eksperimentinis filialas # 1
  • exp2 : eksperimentinis šakos numeris 2

exp1 ir exp2 yra du labai skirtingi architektūriniai metodai. Kol aš nepradėsiu eiti, aš negaliu žinoti, kuris (jei toks bus) veiks. Kadangi aš gerai seku viename skyriuje, kartais turiu pakeitimų, kurie būtų naudingi kitoje šakoje ir norėčiau sujungti tik tuos.

Koks yra geriausias būdas sujungti atrankinius pokyčius iš vienos šakos į kitą, paliekant viską kitam?

Mano požiūriai:

  1. git merge --no-commit po to rankiniu būdu nustatykite daug redagavimų, kurių nenoriu būti bendri filialams.

  2. Rankiniu būdu kopijuodami bendrai naudojamus failus į laikinąjį katalogą, po to git checkout kad pereitumėte į kitą filialą ir tada rankiniu būdu nukopijuotumėte iš laikino katalogo į darbo medį.

  3. Pokyčiai aukščiau. Dabar palikite „ exp filialus ir eksperimentams naudokite dvi papildomas vietines saugyklas. Tai leidžia rankiniu būdu kopijuoti daug lengviau.

Visi trys iš šių metodų atrodo nuobodūs ir klaidingi. Tikiuosi, kad yra geresnis požiūris; kažkas panašaus į filtro kelio parametrą, dėl kurio git-merge būtų selektyvesnis.

1222
16 янв. nustatė David Joyner , sausio 16 d 2009-01-16 07:55 '09 at 7:55 am 2009-01-16 07:55
@ 24 atsakymai

Jūs naudojate „ cherry-pick“ komandą, kad gautumėte individualius įsipareigojimus iš vieno filialo.

Jei pageidaujamas pakeitimas nėra įtrauktas į asmenį, naudokite čia pateiktą metodą, kad padalytumėte pataisą į atskiras fiksacijas . Apytiksliai kalbant, jūs naudojate „ git rebase -i kad gautumėte originalą, kad galėtumėte redaguoti, tada git reset HEAD^ kad pasirinktinai grįžtumėte į pakeitimus, o tada git commit įsipareigoti atlikti šį bitą kaip naują įvykį istorijoje.

„Red Hat Magazine“ turi dar vieną puikų metodą, kai jie naudoja „ git add --patch arba „ git add --interactive kurie leidžia jums pridėti tik dalis fragmento, jei norite atskirti įvairius pakeitimus atskirame faile. (ieškokite šio puslapio „skaldyti“).

Skirstydami pakeitimus, dabar galite pasirinkti norimus.

403
16 янв. Atsakymas pateiktas 1800 INFORMACIJA 16 sausis 2009-01-16 09:01 '09 at 9:01 am 2009-01-16 09:01

Turėjau tą pačią problemą, kaip minėjote anksčiau. Tačiau aiškiau paaiškinau atsakymą.

Santrauka:

border=0
  • Ištraukite kelią (-us) iš filialo, kurį norite sujungti,

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

    Patarimas: jis taip pat veikia be to, kaip matyti susijusiame pranešime.

  • arba pasirinktinai sujungti gabalus

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

    Arba naudokite iš naujo ir pridėkite pasirinktį -p ,

     $ git reset <paths>... $ git add -p <paths>... 
  • Galiausiai įsipareigokite

     $ git commit -m "'Merge' these changes" 
858
31 авг. Susheel Javadi rugpjūčio 31 d 2009-08-31 08:53 '09 8:53 am. 2009-08-31 08:53

Jei norite selektyviai sujungti failus iš vieno filialo į kitą, paleiskite

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

kur branchX yra filialas, kurį norite sujungti į dabartinį filialą.

Pasirinkus --no-commit apdoros failus, kurie buvo sujungti su „Git“, faktiškai nepadarius. Tai suteiks jums galimybę keisti susijungusius failus, tačiau norite juos atlikti ir tada juos atlikti.

Priklausomai nuo to, kaip norite sujungti failus, yra keturi atvejai:

1) Reikalingas tikras susijungimas.

Tokiu atveju sutinkate sujungti failai, nes „Git“ juos automatiškai sujungia ir taiso.

2) Yra failų, kurių nenorite sujungti.

Pvz., Norite išsaugoti versiją dabartiniame filiale ir ignoruoti to filialo versiją, iš kurios jūs išvykstate.

Jei norite pasirinkti dabartinės filialo versiją, paleiskite:

 git checkout HEAD file1 

Tai atkurs file1 versiją į esamą filialą ir perrašys file1 , atliktą su „Git“.

3) Jei norite, kad „xXX“ versija (o ne tikroji jungtis).

Vykdyti:

 git checkout branchX file1 

Tai susigrąžins branchX versiją branchX ir automatiškai perrašys branchX su „Git“ sujungimu.

4) Pastaruoju atveju norite pasirinkti tik konkrečius failų susiliejimus1.

Tokiu atveju galite redaguoti pakeistą file1 tiesiogiai, atnaujinti jį į tai, ką norite, kad file1 versija taptų, o tada taisykite.

Jei „Git“ negali sujungti failo automatiškai, ji praneš apie failą kaip „nesusijungus“ ir sukurs kopiją, kur jums reikės išspręsti konfliktus rankiniu būdu.



Norėdami toliau paaiškinti pavyzdį, tarkime, kad norite sujungti branchX į dabartinį filialą:

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

Tada paleisite git status komandą, kad peržiūrėtumėte pakeistų failų būseną.

Pavyzdžiui:

 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 # 

Kai file1 , file2 ir file3 yra sėkmingai sukompiliuoti Git failai.

Tai reiškia, kad visų šių trijų failų master ir branchX pakeitimai buvo sujungti be konfliktų.

Galite patikrinti, kaip sujungimas buvo atliktas vykdant git diff --cached ;

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

Jei radote nepageidaujamą susijungimą, galite

  • redaguokite failą tiesiogiai
  • išsaugoti
  • git commit

Jei nenorite sujungti file1 ir norite išsaugoti versiją dabartiniame filiale

Vykdyti

 git checkout HEAD file1 

Jei nenorite sujungti file2 ir norite tik versijosXX

Vykdyti

 git checkout branchX file2 

Jei norite, kad file3 būtų sujungtas automatiškai, nieko nedarykite.

Šiuo metu „Git“ jį sujungė.


file4 aukščiau - nepavyko sujungti į git. Tai reiškia, kad abiejose šakose yra pokyčių, kurie įvyksta vienoje eilutėje. Čia jums reikės išspręsti konfliktus rankiniu būdu. Galite atsisakyti sujungti, redaguodami failą tiesiogiai arba paleisdami patikrinimo komandą, skirtą versijai, kurią norite file4 .


Galiausiai, nepamirškite git commit .

265
03 сент. atsakymas duotas alvinabad 03 sep . 2011-09-03 11:48 '11, 11:48, 2011-09-03 11:48

Man nepatinka minėti metodai. Naudojant cherry-pick yra puiki galimybė pasirinkti vieną pakeitimą, tačiau tai skausmas, jei norite atlikti visus pakeitimus, išskyrus kai kuriuos blogus. Štai mano požiūris.

Nėra jokio --interactive argumento, kad galėtumėte pereiti prie gitų sujungimo.

Čia yra alternatyva:

Jūs turite tam tikrus „filialo“ funkcijos pakeitimus, ir norite, kad kai kurie iš jų, bet ne visi, persijungtų į „šeimininką“ atsitiktiniu būdu (t.y. nenorite, kad vyšnios būtų surenkamos ir nustatomos kiekvienas)

 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 

Taigi, tiesiog apvyniokite jį scenarijaus korpuse, pakeiskite pagrindinį į $ ir pakeiskite funkciją į $, ir jūs gerai einate:

 #! /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 
86
21 мая '09 в 6:00 2009-05-21 06:00 Atsakymas pateikiamas nosatalianų gegužės 21 d., 09:00 , 06:00 2009-05-21 06:00

Yra ir kitas būdas:

 git checkout -p 

Tai derinys tarp „ git checkout ir „ git add -p ir gali būti būtent tai, ko ieškote:

  -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. 
76
28 авг. atsakymas pateikiamas Chronial 28 rug . 2012-08-28 21:47 '12, 9:47 val. 2012-08-28 21:47

Nors kai kurie iš šių atsakymų yra gana geri, manau, kad niekas iš tikrųjų neatsakė į pradinį OP suvaržymą: pasirinkti tam tikrus failus iš tam tikrų filialų. Šis sprendimas tai daro, tačiau gali būti varginantis, jei yra daug failų.

Tarkime, kad turite master , exp1 ir exp2 . Jūs norite sujungti vieną failą iš kiekvienos eksperimentinės šakos į šeimininką. Norėčiau tai padaryti:

 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 

Tai suteiks jums skirtingus kiekvienos norimos rinkmenos skirtumus. Nieko daugiau. Ne mažiau. Naudinga, kad turėtumėte iš esmės skirtingus failų pakeitimus tarp versijų - mano atveju, keisdami taikymą iš Rails 2 į Rails 3.

EDIT : tai sujungs failus, bet sujungs protingai. Negalėjau išsiaiškinti, kaip naudoti šį metodą, kad gautumėte informaciją apie „diff“ failą (vis tiek gali kilti didelių skirtumų. Nedideli dalykai, pvz., Tarpas, vėl sujungiami, jei nenaudojate „ -s recursive -X ignore-all-space )

48
25 авг. atsakymas pateikiamas eric hu 25 rug. 2011-08-25 04:31 '11, 4:31 am 2011-08-25 04:31

1800 Informacinis atsakymas yra visiškai teisingas. Tačiau, kaip „git noob“, „naudojant git cherry-pick“ man nepakanka suprasti tai be nereikalingos paieškos internete, todėl maniau, kad paskelbsiu išsamesnį vadovą, jei kas nors yra tokiame laive .

Mano precedentas norėjo pasirinktinai patraukti pakeitimus iš kito github filialo į savo. Jei jau turite vietinį padalinį su pakeitimais, turite atlikti 2 ir 5-7 veiksmus.

  • Sukurkite (jei ne sukurta) vietinį padalinį su pakeitimais, kuriuos norite atlikti.

    $ git branch mybranch <base branch>

  • Įjunkite.

    $ git checkout mybranch

  • Atšaukite norimus pakeitimus iš kito asmens paskyros. Jei vis dar nenorite jų įtraukti kaip ištrintas.

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

  • Gaukite viską iš savo filialo.

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

  • Peržiūrėkite įsipareigojimų žurnalus, kad sužinotumėte, kokius pakeitimus norite:

    $ git log

  • Grįžkite į filialą, kurį norite pakeisti.

    $ git checkout originalbranch

  • Vyšnios išsirenka vieną po kito, naudodami maišus.

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

Hat Patarimas: http://www.sourcemage.org/Git_Guide

44
07 мая '09 в 14:38 2009-05-07 14:38 atsakymas pateikiamas Cory 07 May '09 at 14:38 2009-05-07 14:38

Štai kaip galite pakeisti Myclass.java failą master filiale su Myclass.java feature1 . Jis veiks, net jei Myclass.java neegzistuoja Myclass.java .

 git checkout master git checkout feature1 Myclass.java 

Atkreipkite dėmesį, kad tai perrašys, o ne sujungs, ir ignoruos pagrindinius šakos pokyčius.

39
29 июля '13 в 11:37 2013-07-29 11:37 atsakymas pateikiamas maestr0 liepos 29 d., 13 val. 11:37 2013-07-29 11:37

Lengvas būdas faktiškai sujungti tam tikrus failus iš dviejų filialų, o ne tik pakeisti tam tikrus failus su kitais filialais.

Pirmas žingsnis: Išskleisti filialus

git diff branch_b > my_patch_file.patch

Sukuria pataisos failą skirtumui tarp dabartinio filialo ir filialo_b

Antras žingsnis: pritaikykite pleistrą failams, kurie atitinka modelį.

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

naudingų parametrų pastabų

Galite naudoti * kaip šabloną įtraukimo šablone.

„Slash“ nereikia pabėgti.

Be to, galite naudoti -exclude vietoj ir taikyti ją visam, išskyrus failus, atitinkančius modelį, arba atšaukti pleistrą su -R

Parametras -p1 yra uždelsimas su * unix patch komanda ir tai, kad pleistro failo turinys prideda kiekvieną failo pavadinimą su a/ arba b/ (arba daugiau, priklausomai nuo to, kaip buvo sukurtas pataisos failas) kad jis galėtų atpažinti tikrąjį failą keliu į failą, kuriam pleistras turėtų būti taikomas.

Daugiau parinkčių rasite „git -apply man“ puslapyje.

Trečias žingsnis

Akivaizdu, kad norėsite padaryti savo pakeitimus, bet kas pasakys, kad neturite kitų susijusių nustatymų, kuriuos norite padaryti prieš įsipareigodami.

23
28 февр. Atsakymas pateikiamas masukomi 28 vasaris. 2012-02-28 01:42 '12 at 1:42 2012-02-28 01:42

Čia jūs galite gauti istoriją, kad galėtumėte sekti kelis failus iš kito filialo su minimaliu triukšmu, net jei „paprastesnis“ sujungimas atneštų daug daugiau pakeitimų, kurių jums nereikia.

Pirma, iš anksto nesiimsite neįprasto pranešimo žingsnio, kad tai, ką ketinate atlikti, yra sujungimas, be jokio darbo su jokiais failais, esančiais jūsų darbiniame kataloge:

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

., kur „filialo pavadinimas“ - tai jūs teigiate eiti. Jei iš karto nuspręsite sudaryti sandorį, jis nepasikeis, bet iš kitos šakos giminingos kilmės linija vis dar bus rodoma. Galite pridėti daugiau filialų / žymių / ir tt jei reikia, komandų eilutę. Tačiau šiuo metu įsipareigojimo pakeitimų nėra, todėl pirmiausia gaukite failus iš kitų versijų.

 git checkout branchname1 -- file1 file2 etc 

Jei susijungėte su keliais filialais, pakartokite, jei reikia.

 git checkout branchname2 -- file3 file4 etc 

Dabar failai iš kitos šakos yra rodyklėje, pasiruošę būti įvykdyti, su istorija.

 git commit 

ir jūs turite daug paaiškinti, ką daryti šiame įsipareigojimo pranešime.

Atkreipkite dėmesį, kad jei neaišku, ar tai yra sugadintas dalykas. Tai neatitinka to, ką reiškia „filialas“, tačiau vyšnių rinkimas yra sąžiningesnis būdas tai padaryti, ką darysite čia. Jei norite atlikti kitą „sujungimą“ kitiems failams tame pačiame gijoje, kurią nepadarėte, tai sustabdys jus su „jau atnaujinta“ pranešimu. Tai yra nešakojimo požymis, kai turėjome, „nuo“ filialo turėtų būti daugiau nei vienas atskiras filialas.

20
27 сент. atsakymas duotas jejese 27 sep . 2012-09-27 05:55 '12 at 5:55 2012-09-27 05:55

Radau šį įrašą , kuriame yra paprasčiausias atsakymas. Tiesiog sekite:

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

Pavyzdys:

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

Daugiau informacijos rasite įraše.

14
04 нояб. atsakymą pateikė Stunner, lapkričio 4 d. 2013-11-04 13:51 '13, 13:51, 2013-11-04 13:51

Žinau, kad aš šiek tiek vėlu, tačiau tai yra mano darbo eiga, skirta sujungti mėginių failus.

 #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 
14
18 февр. Atsakymas pateikiamas Felix 18 vas. 2010-02-18 07:28 '10, 7:28, 2010-02-18 07:28

Paprasčiausias būdas yra nustatyti savo atpirkimą filialui, kurį norite sujungti, tada paleiskite

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

Jei paleisite

 git status 

Pamatysite, kad failas jau buvo pristatytas ...

Tada paleiskite

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

Paprasta

13
29 окт. atsakymas dsieczko 29 okt. 2013-10-29 23:54 '13, 23:54, 2013-10-29 23:54

Keista, kad git vis dar neturi tokio patogaus įrankio iš dėžutės. Aš jį daug naudoju, atnaujindamas senosios versijos filialą (kuris vis dar turi daug programinės įrangos naudotojų) su tik keliomis pataisomis iš dabartinės versijos šakos. Tokiu atveju dažnai reikia greitai gauti tik keletą kodų eilutės iš failo į kamieną, ignoruojant daugelį kitų pakeitimų (kurie neturėtų būti įtraukti į senąją versiją) ... Ir, žinoma, šiuo atveju reikia interaktyvios trijų pakopų , git checkout --patch <branch> <file path> netaikomas šiam selektyviam sujungimui.

Tai galite padaryti lengvai:

Tiesiog pridėkite šią eilutę prie pasaulinio .gitconfig arba vietinio .git/config failo dalies [alias] :

 [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;' -" 

Tai reiškia, kad naudojate „Beyond Compare“. Jei reikia, tiesiog pakeiskite pasirinktą programinę įrangą. Arba galite pakeisti jį į trijų krypčių automatinį sujungimą, jei jums nereikia interaktyvaus pasirinktinio sujungimo:

 [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;' -" 

Tada naudokite:

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

Tai suteiks jums tikrą selektyvų medžio sugebėjimą sujungti bet kurį kitą filialą.

10
03 июля '14 в 7:29 2014-07-03 07:29 atsakymą JimStar pateikė liepos 14 d. 14 d. 7:29 val. 2014-07-03 07:29

Tai nėra būtent tai, ko ieškojote, bet man buvo naudinga:

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

Tai yra kai kurių atsakymų mišinys.

7
09 февр. Atsakymas pateiktas Felipe 09 vasario mėn. 2016-02-09 04:02 '16 at 4:02 2016-02-09 04:02

Turėjau tą pačią problemą, kaip minėjote anksčiau. Bet aš paaiškėjau, kad šis „Git“ tinklaraštis aiškiau paaiškina atsakymą.

Komanda pirmiau minėta nuoroda:

 #You are in the branch you want to merge to git checkout <branch_you_want_to_merge_from> <file_paths...> 
7
19 июня '12 в 13:15 2012-06-19 13:15 atsakymas buvo duotas Susheel Javadi birželio 19 d., 12 val. 15.15 val. 2012-06-19 13:15

Aš norėčiau daryti

git diff exec1..citit2 filepattern | git -apply -index git įsipareigoti

Taigi, galite apriboti filialo failų perdavimo įsipareigojimų diapazoną.

Pavogta iš: http://www.gelato.unsw.edu.au/archives/git/0701/37964.html

6
26 янв. atsakymas pateikiamas lumpidu 26 jan. 2011-01-26 13:50 '11, 13:50, 2011-01-26 13:50

Man patinka atsakymas „git -interactive“, bet tai lengviau. Leiskite „git“ tai padaryti už jus, naudodamiesi interaktyviosios versijos kombinacija ir:

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

Taigi, jūs norite, kad C1 ir C2 iš "funkcija" šakos (filialo taškas "A"), bet kol kas nieko liko.

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

Kuris, kaip minėta aukščiau, jus įtraukia į interaktyvųjį redaktorių, kur pasirinksite linijas „pasirinkti“ C1 ir C2 (kaip nurodyta pirmiau). Išsaugoti ir išeiti, tada jis tęs perskaičiavimą ir suteiks jums „temp“ atšaką, taip pat HEAD į pagrindinį + C1 + C2:

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

Tada galite tiesiog atnaujinti pagrindinį valdiklį į HEAD ir ištrinti temp šaką, ir jums bus naudinga:

 # git branch -f master HEAD # git branch -d temp 
6
09 дек. atsakymas pateikiamas Wade 09 dec. 2011-12-09 22:46 '11 at 22:46 PM 2011-12-09 22:46

Žinau, kad šis klausimas yra senas, ir yra daug kitų atsakymų, bet parašiau savo scenarijų, vadinamą „pmerge“, kad iš dalies sujungtumėte katalogus. Tai yra darbas, kuris vyksta, ir aš vis dar dalyvauju git ir bash scenarijuose.

Ši komanda naudoja git merge --no-commit , o tada nenaudoja pakeitimų, kurie neatitinka pateikto kelio.

Naudojimas: git pmerge branch path
Pavyzdys: git merge develop src/

Aš ne išbandžiau. Darbo aplanke neturėtų būti jokių neprisiimtų pakeitimų ir neišjungtų failų.

 #!/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> then # reset failed... file was previously unversioned echo Deleting $f rm $f else echo Reverting $f git checkout -- $f >/dev/null 2> fi done unset IFS 
5
27 мая '11 в 4:33 2011-05-27 04:33 atsakymą pateikė Andy , gegužės 27 d. 11 d., 4:33 2011-05-27 04:33

Galite naudoti read-tree kad skaitytumėte arba sujungtumėte nuotolinį medį į esamą indeksą, pavyzdžiui:

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

Norėdami sujungti, naudokite -m .

Taip pat žiūrėkite: Kaip sujungti „git“ katalogą?

2
25 февр. atsakymas pateikiamas kenorb 25 vasario mėn 2016-02-25 21:25 '16 at 21:25 2016-02-25 21:25

Paprastas požiūris į selektyvų failo sujungimą / fiksavimą:

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

1
22 нояб. Atsakymą pateikė Dave C 22 lapkričio. 2017-11-22 20:25 '17, 8:25 pm 2017-11-22 20:25

Kai tarp dviejų filialų esamų įrašų pasikeitė tik keletas failų, pakeitimus rankiniu būdu sujungsiu per skirtingus failus.

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

1
07 окт. atsakymas raratiru 07 Oct 2017-10-07 22:49 '17, 10:49 PM 2017-10-07 22:49

Jei reikia tik sujungti tam tikrą katalogą ir palikti visą kitą nepakeistą, bet išlaikyti istoriją, galite pabandyti tai ... sukurti naują master target-branch prieš pradedant eksperimentuoti.

Toliau išvardyti veiksmai leidžia manyti, kad turite dvi šakas: target-branch ir source-branch , o dir-to-merge katalogą, kurį norite sujungti, yra source-branch . Taip pat darykite prielaidą, kad turite kitų katalogų, pvz., dir-to-retain , kuriuos norite dir-to-retain į kuriuos nenorite keisti ir išsaugoti istoriją. Be to, daroma prielaida, kad yra sujungimo konfliktai 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. 
0
06 нояб. Atsakymas pateikiamas kodas4kix 06 lapkričio. '18 в 19:35 2018-11-06 19:35