සමාන්තර - නමුත් දැනට පර්යේෂණාත්මක - සංවර්ධන ශාඛා දෙකක් ඇති නව ව්‍යාපෘතියක් සඳහා මම Git භාවිතා කරමි:

• master: පවතින කේත පදනම ආනයනය කිරීම සහ මා සාමාන්‍යයෙන් විශ්වාස කරන වෙනස් කිරීම් කිහිපයක්
• exp1: පර්යේෂණාත්මක ශාඛාව # 1
• exp2: පර්යේෂණාත්මක ශාඛාව # 2

exp1සහ exp2වෙනස් වාස්තු විද්‍යාත්මක ප්‍රවේශයන් දෙකක් නියෝජනය කරයි. මම තව දුරටත් ඉදිරියට යන තුරු කුමන එකක් (හෝ තිබේ නම්) වැඩ කරන්නේ දැයි දැන ගැනීමට මට හැකියාවක් නැත. මම එක් ශාඛාවක ප්‍රගතියක් ලබන විට සමහර විට සංස්කරණයන් අනෙක් ශාඛාවට ප්‍රයෝජනවත් වන අතර ඒවා ඒකාබද්ධ කිරීමට කැමැත්තෙමි.

අනෙක් සියල්ල අතහැර දමා එක් සංවර්ධන ශාඛාවක සිට තවත් සංවර්ධන ශාඛාවකට තෝරාගත් වෙනස්කම් ඒකාබද්ධ කිරීමට හොඳම ක්‍රමය කුමක්ද?

මා සලකා බැලූ ප්‍රවේශයන්:

1. git merge --no-commit ශාඛා අතර පොදු වීමට මා අකමැති සංස්කරණ විශාල සංඛ්‍යාවක් අතින් අස්ථාපනය කිරීමෙන් පසුව.

2. පොදු ලිපිගොනු තාවකාලික නාමාවලියකට git checkoutඅතින් පිටපත් කිරීම, ඉන්පසු අනෙක් ශාඛාවට මාරුවීම සහ තාවකාලික නාමාවලියෙන් වැඩ කරන ගස තුළට තවත් අතින් පිටපත් කිරීම.

3. ඉහත සඳහන් වෙනස්කම්. දැනට expශාඛා අතහැර දමා අත්හදා බැලීම සඳහා අතිරේක දේශීය ගබඩාවන් දෙකක් භාවිතා කරන්න. මෙමඟින් අතින් ගොනු පිටපත් කිරීම වඩාත් සරල කරයි.

මෙම ප්‍රවේශයන් තුනම වෙහෙසකාරී හා දෝෂ සහිත බව පෙනේ. වඩා හොඳ ප්‍රවේශයක් ඇතැයි මම බලාපොරොත්තු වෙමි; git-mergeවඩා තෝරා බේරා ගත හැකි පෙරහන් මාර්ග පරාමිතියකට සමාන දෙයක් .

එක් ශාඛාවකින් තනි කොමිස් ලබා ගැනීම සඳහා ඔබ චෙරි-පික් විධානය භාවිතා කරයි.

ඔබට අවශ්‍ය වෙනස (ය) තනි කොමිස්වල නොමැති නම්, මෙහි දක්වා ඇති ක්‍රමය භාවිතා කර බැඳීම තනි කොමිස් වලට බෙදන්න . දළ වශයෙන් කිවහොත්, ඔබ git rebase -iසංස්කරණය සඳහා මුල් කැපවීම ලබා ගැනීමටත්, පසුව git reset HEAD^වෙනස්කම් තෝරා බේරා ගැනීමටත්, පසුව git commitඉතිහාසයේ නව කැපවීමක් ලෙස එම කැපවීම සිදු කිරීමටත් භාවිතා කරයි.

Red Hat සඟරාවේ තවත් හොඳ ක්‍රමයක් තිබේ , එහිදී ඔවුන් භාවිතා කරන git add --patchහෝ සමහර විට git add --interactiveඔබට තනි ගොනුවකට වෙනස් වෙනස්කම් බෙදීමට අවශ්‍ය නම්, හක්කක කොටස් පමණක් එකතු කිරීමට ඉඩ ලබා දේ (එම පිටුවෙහි “භේදය” සඳහා සොයන්න).

වෙනස්කම් බෙදීමෙන් පසුව, ඔබට අවශ්‍ය දේ පමණක් චෙරි-තෝරා ගත හැකිය.

ඉහත සඳහන් කළ ආකාරයටම මටද ගැටලුවක් තිබුණි. නමුත් පිළිතුර පැහැදිලි කිරීමේදී මට මෙය වඩාත් පැහැදිලි විය.

සාරාංශය:

• ඔබට ඒකාබද්ධ කිරීමට අවශ්‍ය ශාඛාවෙන් මාර්ගය (ය) පරීක්ෂා කරන්න,

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

  ඉඟිය: --සම්බන්ධිත පෝස්ට් එකෙහි දක්නට නොලැබෙන පරිදි එය ද ක්‍රියා කරයි .

• හෝ තෝරාගත් හන්ක් ඒකාබද්ධ කිරීම

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

  විකල්පයක් ලෙස, යළි පිහිටුවීම භාවිතා කර විකල්පය සමඟ එක් කරන්න -p,

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

• අවසාන වශයෙන් කැප වන්න

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

එක් ශාඛාවක සිට තවත් ශාඛාවකට ගොනු වර්‍ගිකව ඒකාබද්ධ කිරීමට, ධාවනය කරන්න

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

branchXවත්මන් ශාඛාවට ඒකාබද්ධ කිරීමට ඔබට අවශ්‍ය ශාඛාව කොහිද ?

මෙම --no-commitවිකල්පය මඟින් Git විසින් ඒකාබද්ධ කරන ලද ගොනු සත්‍ය වශයෙන්ම සිදු නොකර ඒවා වේදිකා ගත කරනු ඇත. ඒකාබද්ධ කළ ලිපිගොනු ඔබට අවශ්‍ය පරිදි වෙනස් කිරීමට සහ ඒවා ඔබම කැප කිරීමට මෙය ඔබට අවස්ථාව ලබා දෙයි.

ඔබට ගොනු ඒකාබද්ධ කිරීමට අවශ්‍ය ආකාරය අනුව, අවස්ථා හතරක් ඇත:

1) ඔබට සැබෑ ඒකාබද්ධ කිරීමක් අවශ්‍යයි.

මෙම අවස්ථාවෙහිදී, ඒකාබද්ධ කරන ලද ලිපිගොනු Git ස්වයංක්‍රීයව ඒකාබද්ධ කළ ආකාරයට ඔබ පිළිගෙන ඒවා සිදු කරයි.

2) ඔබට ඒකාබද්ධ කිරීමට අවශ්‍ය නැති සමහර ගොනු තිබේ.

උදාහරණයක් ලෙස, වත්මන් ශාඛාවේ අනුවාදය රඳවා ගැනීමට සහ ඔබ ඒකාබද්ධ වන ශාඛාවේ අනුවාදය නොසලකා හැරීමට ඔබට අවශ්‍යය.

වත්මන් ශාඛාවේ අනුවාදය තේරීමට, ධාවනය කරන්න:

git checkout HEAD file1

මෙය file1වත්මන් ශාඛාවේ අනුවාදය ලබා ගන්නා අතර file1Git විසින් ස්වයංක්‍රීයකරණය නැවත ලියයි.

3) ඔබට ශාඛා X හි අනුවාදය අවශ්‍ය නම් (සත්‍ය ඒකාබද්ධ කිරීමක් නොවේ).

ධාවනය:

git checkout branchX file1

මෙම අනුවාදය ලබා ඇත file1තුල branchXහා ලියන්නට file1Git විසින් ස්වයංක්රීය-ඒකාබද්ධ.

4) අවසාන අවස්ථාව නම් ඔබට නිශ්චිත ඒකාබද්ධ කිරීම් පමණක් තෝරා ගැනීමට අවශ්‍ය නම් file1.

මෙම අවස්ථාවෙහිදී, ඔබට නවීකරණය කරන ලද file1කෙලින්ම සංස්කරණය කළ හැකිය , අනුවාදය file1බවට පත්වීමට අවශ්‍ය ඕනෑම දෙයකට එය යාවත්කාලීන කරන්න, ඉන්පසු කැප වන්න.

Git ට ස්වයංක්‍රීයව ගොනුවක් ඒකාබද්ධ කිරීමට නොහැකි නම්, එය ගොනුව " ගිලී නැති " ලෙස වාර්තා කර පිටපතක් නිෂ්පාදනය කරනු ඇත, එහිදී ඔබට ගැටුම් අතින් විසඳා ගත යුතුය.

උදාහරණයක් සමඟ වැඩිදුර විස්තර කිරීම සඳහා, ඔබට branchXවර්තමාන ශාඛාවට ඒකාබද්ධ වීමට අවශ්‍ය යැයි කියමු :

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

git statusනවීකරණය කරන ලද ලිපිගොනු වල තත්වය බැලීමට ඔබ විධානය ක්‍රියාත්මක කරයි .

උදාහරණයක් වශයෙන්:

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
#

කොහේද file1, file2සහ file3ගොනු git ස්වයංක්‍රීයව ස්වයංක්‍රීයව ඒකාබද්ධ වී තිබේද?

මෙයින් අදහස් කරන්නේ masterසහ branchXඑම ලිපිගොනු තුනේම වෙනස්කම් කිසිදු ගැටුමකින් තොරව එකට එකතු වී ඇති බවයි.

ධාවනය කිරීමෙන් ඒකාබද්ධ කිරීම සිදු වූයේ කෙසේදැයි ඔබට පරීක්ෂා කළ හැකිය git diff --cached;

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

ඔබට යම් ඒකාබද්ධ කිරීමක් නුසුදුසු යැයි හැඟේ නම් ඔබට හැකිය

1. ගොනුව කෙලින්ම සංස්කරණය කරන්න
2. සුරකින්න
3. git commit

ඔබට ඒකාබද්ධ වීමට අවශ්‍ය නැතිනම් file1සහ වර්තමාන ශාඛාවේ අනුවාදය රඳවා ගැනීමට අවශ්‍ය නම්

දුවන්න

git checkout HEAD file1

ඔබට ඒකාබද්ධ වීමට අවශ්‍ය නැතිනම් file2අනුවාදය පමණක් අවශ්‍ය නම්branchX

දුවන්න

git checkout branchX file2

ඔබට file3ස්වයංක්‍රීයව ඒකාබද්ධ වීමට අවශ්‍ය නම් කිසිවක් නොකරන්න.

Git දැනටමත් මෙම අවස්ථාවෙහිදී එය ඒකාබද්ධ කර ඇත.

file4ඉහත දැක්වෙන්නේ Git විසින් ඒකාබද්ධ කිරීම අසාර්ථක වීමයි. මෙයින් අදහස් කරන්නේ එකම රේඛාවකින් සිදුවන ශාඛා දෙකෙහිම වෙනස්කම් ඇති බවයි. ගැටුම් අතින් විසඳීමට ඔබට අවශ්‍ය වන්නේ මෙතැනදීය. ගොනුව කෙලින්ම සංස්කරණය කිරීමෙන් හෝ ඔබට වීමට අවශ්‍ය ශාඛාවේ අනුවාදය සඳහා පිටවීමේ විධානය ක්‍රියාත්මක කිරීමෙන් ඔබට ඒකාබද්ධ කිරීම ඉවත දැමිය හැකිය file4.

අවසාන වශයෙන්, අමතක නොකරන්න git commit.

ඉහත ප්‍රවේශයන්ට මම කැමති නැත. තනි වෙනසක් තෝරා ගැනීම සඳහා චෙරි-පික් භාවිතා කිරීම විශිෂ්ටයි, නමුත් සමහර නරක ඒවා හැර අනෙක් සියලුම වෙනස්කම් ගෙන ඒමට ඔබට අවශ්‍ය නම් එය වේදනාවකි. මෙන්න මගේ ප්රවේශය.

--interactiveGit ඒකාබද්ධ කිරීම සඳහා ඔබට ඉදිරිපත් කළ හැකි තර්කයක් නොමැත .

මෙන්න විකල්පය:

ශාඛා 'විශේෂාංගයේ' ඔබට යම් යම් වෙනස්කම් ඇති අතර, ඒවායින් සමහරක් නමුත් සියල්ලම 'මාස්ටර්' වෙත නොපැහැදිලි ආකාරයකින් ගෙන ඒමට ඔබට අවශ්‍යය (එනම් ඔබට චෙරි තෝරා ගැනීමට හා කැපවීමට අවශ්‍ය නැත)

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

එබැවින් එය ෂෙල් ස්ක්‍රිප්ට් එකකින් ඔතා, මාස්ටර් $ ට වෙනස් කර විශේෂාංගය $ සිට වෙනස් කරන්න, එවිට ඔබ යන්න හොඳයි:

#!/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

යා යුතු තවත් ක්‍රමයක් තිබේ:

git checkout -p

එය අතර මිශ්ර git checkoutහා git add -pසහ තරමක් ඔබ සොයන දේ හරියටම වෙන්න පුළුවන්:

   -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.

මෙම සමහර පිළිතුරු ඉතා හොඳ වුවත්, කිසිවෙකු ඇත්ත වශයෙන්ම OP හි මුල් අවහිරයට පිළිතුරු නොදුන් බවක් මට හැඟේ: විශේෂිත ශාඛා වලින් විශේෂිත ගොනු තෝරා ගැනීම. මෙම විසඳුම එය කරයි, නමුත් බොහෝ ලිපිගොනු තිබේ නම් එය වෙහෙසකාරී විය හැකිය.

ඔබ කියන්නෙ ඉඩ දෙනවා master, exp1හා exp2ශාඛා. එක් එක් පර්යේෂණාත්මක ශාඛා වලින් එක් ගොනුවක් මාස්ටර් සමඟ ඒකාබද්ධ කිරීමට ඔබට අවශ්‍යය. මම මේ වගේ දෙයක් කරනවා:

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

මෙය ඔබට අවශ්‍ය සෑම ලිපිගොනුවකටම ලිපිගොනු වෙනස් වේ. ඊට වඩා දෙයක් නැත. අඩු කිසිවක් නැත. අනුවාද අතර රැඩිකල් ලෙස වෙනස් ගොනු වෙනස්වීම් තිබීම ප්‍රයෝජනවත් වේ - මගේ නඩුවේදී, යෙදුමක් රේල්ස් 2 සිට රේල්ස් 3 දක්වා වෙනස් කිරීම.

සංස්කරණය කරන්න : මෙය ලිපිගොනු ඒකාබද්ධ කරයි, නමුත් ස්මාර්ට් ඒකාබද්ධ කිරීමක් කරයි. ලිපිගොනු වෙනස් තොරතුරු ලබා ගැනීම සඳහා මෙම ක්‍රමය භාවිතා කරන්නේ කෙසේදැයි මට සිතා ගැනීමට නොහැකි විය (සමහර විට එය තවමත් අතිශය වෙනස්කම් සඳහා හේතු වනු ඇත. ඔබ -s recursive -X ignore-all-spaceවිකල්පය භාවිතා නොකරන්නේ නම් සුදු අවකාශය වැනි කරදරකාරී කුඩා දේවල් නැවත ඒකාබද්ධ වේ )

1800 තොරතුරු වල පිළිතුර සම්පූර්ණයෙන්ම නිවැරදි ය. Git noob ලෙස, අන්තර්ජාලය තුළ තව ටිකක් හෑරීමකින් තොරව මෙය වටහා ගැනීමට "git cherry-pick භාවිතා කිරීම" මට ප්‍රමාණවත් නොවීය, එබැවින් වෙනත් අයෙකු සිටී නම් වඩාත් සවිස්තරාත්මක මාර්ගෝපදේශයක් පළ කිරීමට මම සිතුවෙමි. සමාන බෝට්ටුවක්.

මගේ භාවිත නඩුව වූයේ වෙනත් කෙනෙකුගේ ගිතබ් ශාඛාවේ වෙනස්කම් තෝරා බේරා ගැනීමටයි. ඔබට දැනටමත් වෙනස්කම් සහිත දේශීය ශාඛාවක් තිබේ නම් ඔබට කළ යුත්තේ පියවර 2 සහ 5-7 පමණි.

1. ඔබට ගෙන ඒමට අවශ්‍ය වෙනස්කම් සහිත දේශීය ශාඛාවක් සාදන්න (නිර්මාණය කර නොමැති නම්).

   $ git branch mybranch <base branch>

2. එයට මාරු වන්න.

   $ git checkout mybranch

3. අනෙක් පුද්ගලයාගේ ගිණුමෙන් ඔබට අවශ්‍ය වෙනස්කම් අදින්න. ඔබ දැනටමත් නොමැති නම් ඒවා දුරස්ථයක් ලෙස එක් කිරීමට ඔබට අවශ්‍ය වනු ඇත.

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

4. ඔවුන්ගේ ශාඛාවෙන් සියල්ල අදින්න.

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

5. ඔබට අවශ්‍ය වෙනස්කම් බැලීමට බැඳීම් ලොග් බලන්න:

   $ git log

6. ඔබට වෙනස්කම් ඇද ගැනීමට අවශ්‍ය ශාඛාව වෙත ආපසු යන්න.

   $ git checkout originalbranch

7. චෙරි හැෂ් සමඟ ඔබේ කොමිස් එකින් එක ගන්න.

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

තොප්පි ඉඟිය: http://www.sourcemage.org/Git_Guide

මෙහිදී ඔබට විස්ථාපනය කල හැකි ආකාරය වේ Myclass.javaගොනුව masterශාඛාව Myclass.javaතුළ feature1ශාඛා. Myclass.javaනොපවතින නමුත් එය ක්‍රියාත්මක වේ master.

git checkout master
git checkout feature1 Myclass.java

මෙය නැවත ලියනු ඇත - ඒකාබද්ධ නොවේ - සහ ප්‍රධාන ශාඛාවේ දේශීය වෙනස්කම් නොසලකා හරිනු ඇත.

සරලම ක්‍රමය, ඇත්ත වශයෙන්ම ඒකාබද්ධ කිරීම විශේෂිත ලිපිගොනු ශාඛා දෙකකින් මිස විශේෂිත ලිපිගොනු වෙනත් ශාඛාවකින් ආදේශ කිරීම නොවේ.

පළමු පියවර: අතු වෙනස් කරන්න

git diff branch_b > my_patch_file.patch

වත්මන් ශාඛාව සහ ශාඛා_බී අතර වෙනස පැච් ගොනුවක් සාදයි

පියවර දෙක: රටාවකට ගැලපෙන ලිපිගොනු වල පැච් යොදන්න

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

විකල්ප පිළිබඳ ප්‍රයෝජනවත් සටහන්

ඔයාට පාවිච්චි කරන්න පුළුවන් *ඇතුළත් කිරීමේ රටාව තුළ ඔබට ආදේශක කාඩ්පතක් ලෙස .

කප්පාදුවෙන් ගැලවීමට අවශ්‍ය නැත.

එසේම, ඔබට ඒ වෙනුවට --exclude භාවිතා කර රටාවට ගැලපෙන ලිපිගොනු හැර අනෙක් සියල්ලටම එය යෙදිය හැකිය, නැතහොත් -R සමඟ පැච් එක ආපසු හරවන්න.

-P1 විකල්පය යනු * යුනික්ස් පැච් විධානයෙන් රඳවා තබා ගැනීමක් වන අතර පැච් ගොනුවේ අන්තර්ගතය එක් එක් ගොනු නාමය සමඟ a/හෝb/ (හෝ වැඩි ගණනක් පැච් ගොනුව ජනනය කළ ආකාරය අනුව) පෙර සූදානමකින් යුක්ත වන අතර එමඟින් ඔබට එය ඉවත් කළ යුතුය. පැච් එකට යෙදිය යුතු ගොනුව වෙත යන සත්‍ය ගොනුව.

වැඩි විකල්ප සඳහා git-apply සඳහා man පිටුව බලන්න.

තුන්වන පියවර: තුන්වන පියවර නොමැත

නිසැකවම ඔබට ඔබගේ වෙනස්කම් කිරීමට අවශ්‍ය වනු ඇත, නමුත් ඔබේ කැපවීම සිදු කිරීමට පෙර ඔබට කිරීමට අවශ්‍ය වෙනත් සම්බන්ධක කිහිපයක් නොමැති බව කවුරුන් කියන්නේද?

තවත් "සරල" ඒකාබද්ධ කිරීමක් ඔබට අවශ්‍ය නොවන තවත් බොහෝ වෙනස්කම් ගෙන එනු ලැබුවද, අවම වශයෙන් කරදරයකින් තොරව වෙනත් ශාඛාවකින් ලිපිගොනු කිහිපයක් අනුගමනය කිරීමට ඔබට ඉතිහාසය ලබා ගත හැකි ආකාරය මෙන්න.

පළමුවෙන්ම, ඔබ වැඩ කරන නාමාවලියෙහි ඇති ලිපිගොනු වලට කිසිසේත් කිසිවක් නොකර, ඔබ කිරීමට සූදානම් වන්නේ ඒකාබද්ධ කිරීමක් බව කල්තියා ප්‍රකාශ කිරීමේ අසාමාන්‍ය පියවර ගනු ඇත:

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

. . . “ශාඛා නාමය” යනු ඔබ ඒකාබද්ධ වන බව පවසන ඕනෑම දෙයකි. ඔබ ඒ මොහොතේම කැපවී සිටින්නේ නම්, එයින් කිසිදු වෙනසක් සිදු නොවනු ඇත, නමුත් එය තවමත් අනෙක් ශාඛාවෙන් පරම්පරාව පෙන්වනු ඇත. ඔබට තවත් ශාඛා / ටැග් / ආදිය එකතු කළ හැකිය. ඔබට අවශ්‍ය නම් විධාන රේඛාවට. මෙම අවස්ථාවෙහිදී, කැපවීමට කිසිදු වෙනසක් නොමැත, එබැවින් ඊළඟ සංශෝධන වලින් ලිපිගොනු ලබා ගන්න.

git checkout branchname1 -- file1 file2 etc

ඔබ වෙනත් ශාඛා එකකට වඩා ඒකාබද්ධ කරන්නේ නම්, අවශ්‍ය පරිදි නැවත කරන්න.

git checkout branchname2 -- file3 file4 etc

දැන් අනෙක් ශාඛාවේ ලිපිගොනු දර්ශකය තුළ ඇත, කැපවීමට සූදානම්, ඉතිහාසය සමඟ.

git commit

එම කැපවීමේ පණිවිඩයේ ඔබට පැහැදිලි කිරීම් රාශියක් ඇත.

කෙසේ වෙතත්, එය පැහැදිලි නැති නම්, මෙය කළ යුතු දෙයක් අවුල් වී ඇති බව කරුණාවෙන් සලකන්න. එය "ශාඛාවක්" යනු කුමක් සඳහාද යන්න පිළිබඳව නොවේ. චෙරි-පික් යනු ඔබ කරන දේ කිරීමට වඩා අවංක ක්‍රමයකි. ඔබ අවසන් වරට ගෙනා එම ශාඛාවේම වෙනත් ලිපිගොනු සඳහා තවත් "ඒකාබද්ධ කිරීමක්" කිරීමට ඔබට අවශ්‍ය නම්, එය "දැනටමත් යාවත්කාලීන" පණිවිඩයකින් ඔබව නවත්වනු ඇත. එය අපට තිබිය යුතු විට අතු නොගැසීමේ රෝග ලක්ෂණයකි, “සිට” ශාඛාව තුළ විවිධ ශාඛා එකකට වඩා තිබිය යුතුය.

මම ටිකක් පරක්කු බව මම දනිමි නමුත් තෝරාගත් ලිපිගොනු ඒකාබද්ධ කිරීම සඳහා මෙය මගේ කාර්ය ප්‍රවාහයයි.

#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

පහසුම ක්‍රමය නම්, ඔබ සමඟ ඒකාබද්ධ කිරීමට අවශ්‍ය ශාඛාවට ඔබේ ගබඩාව සැකසීම, පසුව ධාවනය කිරීම,

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

ඔබ දුවන්නේ නම්

git status

ගොනුව දැනටමත් වේදිකා ගත කර ඇති ආකාරය ඔබට පෙනෙනු ඇත ...

ඉන්පසු දුවන්න

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

සරල.

මෙම ලිපියේ සරලම පිළිතුර අඩංගු බව මට පෙනී ගියේය. කරන්න:

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

උදාහරණයක්:

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

වැඩි විස්තර සඳහා ලිපිය බලන්න.

Git තවමත් එවැනි පහසු මෙවලමක් "කොටුවෙන් පිටත" නොමැති වීම පුදුමයකි. වර්තමාන අනුවාද ශාඛාවේ සමහර දෝෂ නිවැරදි කිරීම් මගින් පැරණි අනුවාද ශාඛාවක් (තවමත් බොහෝ මෘදුකාංග භාවිතා කරන්නන් ඇත) යාවත්කාලීන කිරීමේදී මම එය දැඩි ලෙස භාවිතා කරමි . මෙම අවස්ථාවෙහිදී , බොහෝ වෙනස් කිරීම් නොසලකා හරිමින් (පැරණි අනුවාදයට නොයැවිය යුතු) ගොනුවේ කේත පේළි කිහිපයක් කඳට ඉක්මනින් ලබා ගැනීම බොහෝ විට අවශ්‍ය වේ ... ඇත්ත වශයෙන්ම අන්තර්ක්‍රියාකාරී ත්‍රි-මාර්ග ඒකාබද්ධ කිරීම මෙම අවස්ථාවෙහිදී අවශ්‍ය වේ, git checkout --patch <branch> <file path>මෙම වරණීය ඒකාබද්ධ කිරීමේ අරමුණු සඳහා භාවිතා කළ නොහැක.

ඔබට එය පහසුවෙන් කළ හැකිය:

[alias]ඔබගේ ගෝලීය .gitconfigහෝ දේශීය .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;' -"

එයින් ගම්‍ය වන්නේ ඔබ සැසඳීමෙන් ඔබ්බට භාවිතා කරන බවයි. අවශ්‍ය නම් ඔබ කැමති මෘදුකාංගයකට වෙනස් කරන්න. ඔබට අන්තර්ක්‍රියාකාරී වරණීය ඒකාබද්ධ කිරීම අවශ්‍ය නොවන්නේ නම් ඔබට එය තුන් ආකාරයකින් ස්වයංක්‍රීයව ඒකාබද්ධ කළ හැකිය:

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

ඉන්පසු මේ ආකාරයට භාවිතා කරන්න:

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

වෙනත් ශාඛාවක ඇති ඕනෑම ගොනුවක සත්‍ය තෝරාගත් ගස්-මාර්ග ඒකාබද්ධ කිරීමේ අවස්ථාව මෙය ඔබට ලබා දෙනු ඇත .

එය ඔබ සොයන දේ හරියටම නොවේ, නමුත් එය මට ප්‍රයෝජනවත් විය:

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

එය සමහර පිළිතුරු වල සංකලනයකි.

මම කරන්නම්

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

මේ ආකාරයෙන් ඔබට ශාඛාවකින් ගොනු පිටපතක් සඳහා වන කොමිස් පරාසය සීමා කළ හැකිය.

සොරකම් කළේ: http://www.gelato.unsw.edu.au/archives/git/0701/37964.html

ඉහත සඳහන් කළ ආකාරයටම මටද ගැටලුවක් තිබුණි. නමුත් පිළිතුර පැහැදිලි කිරීමේදී මෙම git බ්ලොග් අඩවිය වඩාත් පැහැදිලි බව මට පෙනී ගියේය.

ඉහත සබැඳියෙන් විධානය:

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

මම ඉහත 'git-interactive-merge' පිළිතුරට කැමතියි, නමුත් ඊට වඩා පහසු එකක් තිබේ. අන්තර්ක්‍රියාකාරී සහ නැවත සංයෝජන සංයෝජනයක් භාවිතා කරමින් ඔබට මෙය කිරීමට git ට ඉඩ දෙන්න:

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

එබැවින් නඩුව ඔබට අවශ්‍ය වන්නේ 'විශේෂාංග' ශාඛාවෙන් (ශාඛා ලක්ෂ්‍යය 'ඒ') සී 1 සහ සී 2 ය, නමුත් දැනට ඉතිරි කිසිවක් නැත.

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

ඉහත පරිදි, ඔබ C1 සහ C2 සඳහා 'පික්' රේඛා තෝරා ගන්නා අන්තර්ක්‍රියාකාරී සංස්කාරකය වෙත ඔබව ඇද දමයි (ඉහත පරිදි). සුරකින්න සහ ඉවත්ව යන්න, එවිට එය ප්‍රතිප්‍රහාරය සමඟ ඉදිරියට ගොස් ඔබට 'තාවකාලික' ශාඛාවක් ලබා දෙන අතර මාස්ටර් + සී 1 + සී 2 හි හෙඩ්:

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

එවිට ඔබට මාස්ටර් HEAD වෙත යාවත්කාලීන කර තාවකාලික ශාඛාව මකා දැමිය හැකි අතර ඔබට යාමට හොඳය:

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

මට නම්, git reset --soft branchවෙනත් ශාඛාවකින් වෙනස්කම් තෝරා ගැනීමට ඇති පහසුම ක්‍රමය මෙයයි, මන්ද, මෙම විධානය මගේ වැඩ කරන ගසෙහි, සියලු වෙනස්කම් වෙනස් වන අතර, මට අවශ්‍ය ඕනෑම එකක් පහසුවෙන් තෝරා ගැනීමට හෝ ආපසු හැරවීමට මට හැකිය.

මේ ආකාරයෙන්, කැපවූ ලිපිගොනු පිළිබඳ මට පූර්ණ පාලනයක් ඇත.

මෙම ප්‍රශ්නය පැරණි බවත් තවත් බොහෝ පිළිතුරු ඇති බවත් මම දනිමි, නමුත් ඩිරෙක්ටරි අර්ධ වශයෙන් ඒකාබද්ධ කිරීම සඳහා මම මගේම පිටපතක් 'pmerge' නමින් ලිවීය. එය ක්‍රියාත්මක වෙමින් පවතින අතර මම තවමත් git සහ bash ස්ක්‍රිප්ටින් ඉගෙන ගන්නවා.

මෙම විධානය මඟින් git merge --no-commitසපයන ලද මාර්ගයට නොගැලපෙන වෙනස්කම් භාවිතා කරයි .

භාවිතය: git pmerge branch path
උදාහරණය:git merge develop src/

මම එය පුළුල් ලෙස අත්හදා බලා නැත. වැඩ කරන නාමාවලිය කිසිදු වෙනස් නොකළ වෙනස් කිරීම් සහ හඳුනා නොගත් ලිපිගොනු වලින් තොර විය යුතුය.

#!/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

read-treeලබා දී ඇති දුරස්ථ ගස වත්මන් දර්ශකයට කියවීමට හෝ ඒකාබද්ධ කිරීමට ඔබට භාවිතා කළ හැකිය , උදාහරණයක් ලෙස:

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

ඒකාබද්ධ කිරීම සිදු කිරීමට, -mඒ වෙනුවට භාවිතා කරන්න.

මෙයද බලන්න: උප නාමාවලියක් git සමඟ ඒකාබද්ධ කරන්නේ කෙසේද?

තෝරාගත් ඒකාබද්ධ කිරීම / ගොනුව මගින් කැපවීම සඳහා සරල ප්‍රවේශයක්:

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. තාවකාලිකව ශාඛා අනුපිටපත් කරන්න
$ git checkout -b temp_branch

2. අවසන් වරට කළ යුතු කැපවීම වෙත නැවත සකසන්න
$ git reset --hard HEAD~n , nඔබ ආපසු යා යුතු කොමිස් ගණන කොහේද ?

3. එක් එක් ගොනුව මුල් ශාඛාවෙන් පරීක්ෂා කරන්න
$ git checkout origin/original_branch filename.ext

දැන් ඔබට අවශ්‍ය නම් තල්ලු කිරීම (දුරස්ථය නැවත ලිවීමට) බල කළ හැකිය.

ඔබ පමණක් එලෙසම වෙන යම් නාමාවලිය සහ නිවාඩු සියල්ල ඒකාබද්ධ එහෙත් ඉතිහාසය සංරක්ෂණය කිරීමට අවශ්ය නම්, ඔබ සමහරවිට මෙය කරන්න උත්සාහ කරන්න පුළුවන් ... නව නිර්මාණය target-branchවන කපා masterඔබ අත්හදා බැලීම් කලින්.

පහත දැක්වෙන පියවර ඔබට ශාඛා දෙකක් උපකල්පනය target-branchහා source-branch, හා බහලුම dir-to-mergeඔබ ඒකාබද්ධ කිරීමට අවශ්ය බව ය source-branch. dir-to-retainඉතිහාසය වෙනස් කිරීමට හා රඳවා ගැනීමට ඔබට අවශ්‍ය නැති ඉලක්කය වැනි වෙනත් නාමාවලි ඔබ සතුව ඇතැයි උපකල්පනය කරන්න . එසේම, ඒකාබද්ධ කිරීමේ ගැටුම් පවතින බව උපකල්පනය කරයි 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.

ශාඛා දෙකේ වර්තමාන කොමිස් අතර ලිපිගොනු කිහිපයක් පමණක් වෙනස් වී ඇති විට, විවිධ ගොනු හරහා ගොස් වෙනස්කම් මම අතින් ඒකාබද්ධ කරමි.

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