ผสานอัปเดตและดึงกิ่ง Git โดยไม่ต้องใช้การชำระเงิน

ฉันทำงานในโครงการที่มี 2 สาขาคือ A และ B โดยปกติฉันทำงานในสาขา A และรวมสิ่งต่าง ๆ จากสาขา B สำหรับการรวมฉันมักจะทำ:

git merge origin/branchB

อย่างไรก็ตามฉันต้องการเก็บสำเนา B สาขาในท้องที่ด้วยเนื่องจากฉันอาจตรวจสอบสาขาเป็นครั้งคราวโดยไม่รวมกับสาขา A ของฉันก่อนสำหรับสิ่งนี้ฉันจะทำ:

git checkout branchB
git pull
git checkout branchA

มีวิธีการข้างต้นในคำสั่งเดียวและโดยไม่ต้องสลับสาขาไปมา? ฉันควรจะใช้git update-refเพื่อสิ่งนั้นหรือไม่? อย่างไร?

คำตอบสั้น ๆ

ตราบใดที่คุณทำการผสานอย่างรวดเร็วจากนั้นคุณก็สามารถใช้

git fetch <remote> <sourceBranch>:<destinationBranch>

ตัวอย่าง:

# Merge local branch foo into local branch master,
# without having to checkout master first.
# Here `.` means to use the local repository as the "remote":
git fetch . foo:master

# Merge remote branch origin/foo into local branch foo,
# without having to checkout foo first:
git fetch origin foo:foo

ในขณะที่คำตอบของแอมเบอร์จะทำงานในกรณีที่ส่งต่ออย่างรวดเร็วด้วยการใช้git fetchวิธีนี้แทนที่จะปลอดภัยกว่าการบังคับให้ย้ายการอ้างอิงสาขาเพียงเล็กน้อยเนื่องจากgit fetchจะป้องกันการไม่ส่งต่อโดยไม่ตั้งใจโดยอัตโนมัติตราบใดที่คุณไม่ได้ใช้งานโดยอัตโนมัติ+ใน refspec

คำตอบยาว ๆ

คุณไม่สามารถรวมสาขา B เข้ากับสาขา A โดยไม่ต้องเช็คเอาท์ A ก่อนหากว่าจะส่งผลให้เกิดการรวมกันที่ไม่ใช่แบบส่งต่ออย่างรวดเร็ว นี่เป็นเพราะจำเป็นต้องใช้สำเนาการทำงานเพื่อแก้ไขข้อขัดแย้งที่อาจเกิดขึ้น

อย่างไรก็ตามในกรณีของการผสานการกรอไปข้างหน้านี่เป็นไปได้เพราะการผสานดังกล่าวจะไม่ส่งผลให้เกิดข้อขัดแย้งตามคำจำกัดความ ในการทำเช่นนี้โดยไม่ต้องเช็คสาขาก่อนคุณสามารถgit fetchกับ refspec

นี่คือตัวอย่างของการอัปเดตmaster(ไม่อนุญาตการเปลี่ยนแปลงที่ไม่ใช่การกรอไปข้างหน้า) หากคุณมีสาขาอื่นfeatureเช็คเอาต์:

git fetch upstream master:master

กรณีการใช้งานนี้เป็นเรื่องธรรมดามากที่คุณอาจต้องการสร้างนามแฝงในไฟล์กำหนดค่า git ของคุณเช่นนี้

[alias]
    sync = !sh -c 'git checkout --quiet HEAD; git fetch upstream master:master; git checkout --quiet -'

นามแฝงนี้ทำอะไรได้บ้างดังต่อไปนี้:

1. git checkout HEAD: สิ่งนี้ทำให้สำเนาการทำงานของคุณเข้าสู่สถานะแยกหัว สิ่งนี้มีประโยชน์หากคุณต้องการอัปเดตmasterในขณะที่คุณเช็คเอาต์ ฉันคิดว่ามันจำเป็นที่จะต้องทำด้วยเพราะไม่เช่นนั้นการอ้างอิงสาขาmasterจะไม่ย้าย แต่ฉันจำไม่ได้ว่าเป็นสิ่งที่ถูกต้องหรือไม่

2. git fetch upstream master:master: สิ่งนี้จะส่งต่อไปmasterยังท้องถิ่นของคุณไปยังสถานที่เดียวกันอย่างupstream/masterรวดเร็ว

3. git checkout -ตรวจสอบสาขาที่เช็คเอาท์ก่อนหน้าของคุณ (เป็นสิ่งที่-ทำในกรณีนี้)

ไวยากรณ์ของgit fetchการผสานอย่างรวดเร็ว (ไม่ใช่ -)

หากคุณต้องการให้fetchคำสั่งล้มเหลวหากการอัปเดตไม่ใช่การส่งต่ออย่างรวดเร็วคุณเพียงแค่ใช้ refspec ของแบบฟอร์ม

git fetch <remote> <remoteBranch>:<localBranch>

หากคุณต้องการอนุญาตการอัปเดตที่ไม่ใช่การส่งต่อคุณต้องเพิ่ม a +ที่ด้านหน้าของ refspec:

git fetch <remote> +<remoteBranch>:<localBranch>

โปรดทราบว่าคุณสามารถส่งผ่าน repo ท้องถิ่นของคุณเป็นพารามิเตอร์ "ระยะไกล" โดยใช้.:

git fetch . <sourceBranch>:<destinationBranch>

เอกสารประกอบ

จากgit fetchเอกสารที่อธิบายเกี่ยวกับไวยากรณ์นี้ (การเน้นของฉัน):

<refspec>

รูปแบบของ<refspec>พารามิเตอร์เป็นบวกตัวเลือก+ตามด้วยเตะแหล่งที่มา<src>, ตามด้วยเครื่องหมายตามด้วยเตะปลายทาง:<dst>

ได้รับเตะแมตช์ระยะไกลที่<src>เป็นความจริงและถ้า<dst>ไม่ได้เป็นสตริงที่ว่างเปล่า, <src>ได้รับเตะท้องถิ่นที่ตรงกับมันเป็นอย่างรวดเร็วส่งต่อโดยใช้ หากใช้เครื่องหมายบวก+เป็นทางเลือกการอ้างอิงในท้องถิ่นจะได้รับการอัปเดตแม้ว่าจะไม่ส่งผลให้มีการอัปเดตอย่างรวดเร็ว

ดูสิ่งนี้ด้วย

1. ชำระเงิน Git และผสานโดยไม่ต้องสัมผัสต้นไม้ทำงาน

2. ผสานโดยไม่ต้องเปลี่ยนไดเรกทอรีทำงาน

ไม่ไม่มี การชำระเงินของสาขาเป้าหมายจำเป็นเพื่อให้คุณสามารถแก้ไขข้อขัดแย้งเหนือสิ่งอื่นใด (หาก Git ไม่สามารถผสานได้โดยอัตโนมัติ)

อย่างไรก็ตามหากการผสานเป็นสิ่งที่จะต้องกรอไปข้างหน้าคุณไม่จำเป็นต้องตรวจสอบสาขาเป้าหมายเพราะคุณไม่จำเป็นต้องผสานอะไรเลย - สิ่งที่คุณต้องทำคืออัพเดทสาขาให้ชี้ไปที่ อ้างอิงหัวใหม่ คุณสามารถทำได้ด้วยgit branch -f:

git branch -f branch-b branch-a

จะอัปเดตbranch-bให้ชี้ไปที่ส่วนหัวของbranch-aไปยังจุดที่หัวของ

-fตัวเลือกที่ย่อมา--forceซึ่งหมายความว่าคุณจะต้องระมัดระวังเมื่อใช้มัน

อย่าใช้มันหากคุณไม่แน่ใจว่าการผสานจะเป็นไปอย่างรวดเร็ว

แอมเบอร์กล่าวว่าการรวมกันอย่างรวดเร็วเป็นกรณีเดียวที่คุณอาจทำเช่นนี้ได้ การผสานอื่นใดที่เป็นไปได้ต้องผ่านการผสานสามทางทั้งการใช้แพทช์การแก้ไขข้อตกลงความขัดแย้ง - และนั่นหมายความว่าจำเป็นต้องมีไฟล์อยู่รอบ ๆ

ฉันบังเอิญมีสคริปต์อยู่รอบตัวฉันสำหรับสิ่งนี้: ทำการผสานอย่างรวดเร็วโดยไม่ต้องแตะที่แผนผังการทำงาน (เว้นแต่คุณจะรวมเข้ากับ HEAD) มันยาวไปหน่อยเพราะอย่างน้อยก็มีความทนทาน - มันตรวจสอบเพื่อให้แน่ใจว่าการผสานนั้นจะเป็นไปข้างหน้าอย่างรวดเร็วจากนั้นทำการดำเนินการโดยไม่ต้องตรวจสอบสาขา แต่ให้ผลลัพธ์เหมือนคุณได้เห็นdiff --statสรุปการเปลี่ยนแปลงและรายการใน reflog เป็นเหมือนกับการผสานไปข้างหน้าอย่างรวดเร็วแทนการ "ตั้งค่า" branch -fหนึ่งคุณจะได้รับถ้าคุณใช้ ถ้าคุณชื่อมันและวางไว้ในไดเรกทอรีถังของคุณคุณสามารถเรียกว่าเป็นคำสั่งคอมไพล์:git-merge-ffgit merge-ff

#!/bin/bash

_usage() {
    echo "Usage: git merge-ff <branch> <committish-to-merge>" 1>&2
    exit 1
}

_merge_ff() {
    branch="$1"
    commit="$2"

    branch_orig_hash="$(git show-ref -s --verify refs/heads/$branch 2> /dev/null)"
    if [ $? -ne 0 ]; then
        echo "Error: unknown branch $branch" 1>&2
        _usage
    fi

    commit_orig_hash="$(git rev-parse --verify $commit 2> /dev/null)"
    if [ $? -ne 0 ]; then
        echo "Error: unknown revision $commit" 1>&2
        _usage
    fi

    if [ "$(git symbolic-ref HEAD)" = "refs/heads/$branch" ]; then
        git merge $quiet --ff-only "$commit"
    else
        if [ "$(git merge-base $branch_orig_hash $commit_orig_hash)" != "$branch_orig_hash" ]; then
            echo "Error: merging $commit into $branch would not be a fast-forward" 1>&2
            exit 1
        fi
        echo "Updating ${branch_orig_hash:0:7}..${commit_orig_hash:0:7}"
        if git update-ref -m "merge $commit: Fast forward" "refs/heads/$branch" "$commit_orig_hash" "$branch_orig_hash"; then
            if [ -z $quiet ]; then
                echo "Fast forward"
                git diff --stat "$branch@{1}" "$branch"
            fi
        else
            echo "Error: fast forward using update-ref failed" 1>&2
        fi
    fi
}

while getopts "q" opt; do
    case $opt in
        q ) quiet="-q";;
        * ) ;;
    esac
done
shift $((OPTIND-1))

case $# in
    2 ) _merge_ff "$1" "$2";;
    * ) _usage
esac

ป.ล. หากใครเห็นปัญหาเกี่ยวกับสคริปต์นี้โปรดแสดงความคิดเห็น! มันเป็นเขียนและลืมงาน แต่ฉันมีความสุขที่จะปรับปรุงมัน

คุณสามารถทำได้หากการผสานเป็นการส่งต่อที่รวดเร็ว หากไม่เป็นเช่นนั้น git จะต้องทำการตรวจสอบไฟล์เพื่อให้สามารถรวมมันได้!

หากต้องการทำเพื่อการกรอไปข้างหน้าเท่านั้น :

git fetch <branch that would be pulled for branchB>
git update-ref -m "merge <commit>: Fast forward" refs/heads/<branch> <commit>

ที่<commit>เป็นความจริงกระทำการอย่างใดอย่างหนึ่งที่คุณต้องการได้อย่างรวดเร็วไปข้างหน้าเพื่อ นี่คือการใช้โดยทั่วไปgit branch -fจะเพื่อย้ายสาขายกเว้นว่าจะบันทึกใน reflog เหมือนว่าคุณได้ทำการผสาน

ได้โปรดได้โปรดอย่าทำสิ่งนี้เพื่อสิ่งที่ไม่ใช่การก้าวไปข้างหน้าไม่อย่างนั้นคุณจะทำการรีเซ็ตสาขาของคุณให้เป็นหน้าที่อื่น (ในการตรวจสอบดูว่าgit merge-base <branch> <commit>ให้ SHA1 ของสาขาหรือไม่)

ในกรณีของคุณคุณสามารถใช้

git fetch origin branchB:branchB

ซึ่งทำในสิ่งที่คุณต้องการ (สมมติว่าการผสานนั้นเป็นกรอไปข้างหน้า) หากไม่สามารถอัปเดตสาขาได้เนื่องจากต้องการการผสานที่ไม่ใช่กรอเดินหน้าจะทำให้ข้อความล้มเหลวอย่างปลอดภัย

การดึงข้อมูลรูปแบบนี้มีตัวเลือกที่มีประโยชน์มากกว่านี้ด้วยเช่นกัน:

git fetch <remote> <sourceBranch>:<destinationBranch>

โปรดทราบว่า<remote> สามารถเป็นพื้นที่เก็บข้อมูลในท้องถิ่นและ<sourceBranch>สามารถเป็นสาขาการติดตาม ดังนั้นคุณสามารถอัปเดตสาขาในท้องที่แม้ว่าจะไม่ได้ชำระเงินโดยไม่ต้องเข้าถึงเครือข่ายได้โดยไม่ต้องเข้าถึงเครือข่าย

ขณะนี้การเข้าถึงเซิร์ฟเวอร์ upstream ของฉันผ่าน VPN ที่ช้าดังนั้นฉันจึงเชื่อมต่อเป็นระยะgit fetchเพื่ออัปเดตรีโมททั้งหมดแล้วตัดการเชื่อมต่อ จากนั้นถ้าพูดว่าเจ้านายระยะไกลมีการเปลี่ยนแปลงฉันสามารถทำได้

git fetch . remotes/origin/master:master

เพื่อนำอาจารย์ท้องถิ่นของฉันไปยังที่ปลอดภัยอย่างปลอดภัยแม้ว่าในปัจจุบันฉันจะมีสาขาอื่นที่ตรวจสอบอยู่ ไม่จำเป็นต้องเข้าถึงเครือข่าย

วิธีอื่นที่เป็นที่ยอมรับกันโดยทั่วไปคือการสร้างสาขาขึ้นใหม่:

git fetch remote
git branch -f localbranch remote/remotebranch

สิ่งนี้จะละทิ้งสาขาที่ล้าสมัยในท้องถิ่นและสร้างใหม่อีกครั้งด้วยชื่อเดียวกันดังนั้นใช้ด้วยความระมัดระวัง ...

คุณสามารถโคลน repo และทำการรวมใน repo ใหม่ ในระบบไฟล์เดียวกันสิ่งนี้จะฮาร์ดลิงก์แทนที่จะคัดลอกข้อมูลส่วนใหญ่ เสร็จสิ้นโดยดึงผลลัพธ์ลงใน repo ดั้งเดิม

ป้อนgit-forward-merge :

โดยไม่จำเป็นต้องเช็คเอาต์ปลายทางgit-forward-merge <source> <destination>รวมแหล่งข้อมูลเข้ากับสาขาปลายทาง

https://github.com/schuyler1d/git-forward-merge

ใช้งานได้สำหรับการผสานอัตโนมัติเท่านั้นหากมีข้อขัดแย้งที่คุณต้องใช้ในการผสานปกติ

สำหรับหลายกรณี (เช่นการรวม) คุณสามารถใช้สาขาระยะไกลได้โดยไม่ต้องอัปเดตสาขาการติดตามโลคัล การเพิ่มข้อความใน reflog เสียงเหมือน overkill และจะหยุดมันเร็วกว่า เพื่อให้ง่ายต่อการกู้คืนเพิ่มสิ่งต่อไปนี้ในการกำหนดค่า git ของคุณ

[core]
    logallrefupdates=true

จากนั้นพิมพ์

git reflog show mybranch

เพื่อดูประวัติล่าสุดสำหรับสาขาของคุณ

ฉันเขียนฟังก์ชันเชลล์สำหรับกรณีการใช้งานที่คล้ายกันซึ่งฉันพบทุกวันในโครงการ นี่เป็นทางลัดในการทำให้สาขาท้องถิ่นทันสมัยด้วยสาขาทั่วไปเช่นการพัฒนาก่อนที่จะเปิดการประชาสัมพันธ์ ฯลฯ

การโพสต์สิ่งนี้แม้ว่าคุณไม่ต้องการใช้checkoutในกรณีที่คนอื่นไม่สนใจข้อ จำกัด นั้น

glmh( "ดึงคอมไพล์และผสานนี่") โดยอัตโนมัติจะcheckout branchB, pullล่าสุดอีกครั้งcheckout branchAและmerge branchBและ

ไม่ตอบสนองความต้องการในการเก็บสำเนา BranchA ในเครื่อง แต่สามารถแก้ไขได้ง่าย ๆ โดยเพิ่มขั้นตอนก่อนเช็คเอาท์ BranchB สิ่งที่ต้องการ...

git branch ${branchA}-no-branchB ${branchA}

สำหรับการผสานการกรอไปข้างหน้าอย่างง่ายนี้จะข้ามไปยังข้อความแจ้งเตือนการกระทำ

สำหรับการรวมที่ไม่ใช่การส่งต่ออย่างรวดเร็วสาขาของคุณจะอยู่ในสถานะการแก้ไขข้อขัดแย้ง (คุณอาจต้องเข้าไปแทรกแซง)

หากต้องการตั้งค่าเพิ่ม.bashrcหรือ.zshrcฯลฯ :

glmh() {
    branchB=$1
    [ $# -eq 0 ] && { branchB="develop" }
    branchA="$(git branch | grep '*' | sed 's/* //g')"
    git checkout ${branchB} && git pull
    git checkout ${branchA} && git merge ${branchB} 
}

การใช้งาน:

# No argument given, will assume "develop"
> glmh

# Pass an argument to pull and merge a specific branch
> glmh your-other-branch

หมายเหตุ: สิ่งนี้ไม่แข็งแรงพอที่จะส่งมอบ args นอกเหนือจากชื่อสาขาไปgit merge

อีกวิธีในการทำสิ่งนี้อย่างมีประสิทธิภาพคือ:

git fetch
git branch -d branchB
git branch -t branchB origin/branchB

เนื่องจากเป็นตัวพิมพ์เล็ก-dจึงจะลบได้ก็ต่อเมื่อข้อมูลยังคงอยู่ที่ใดที่หนึ่ง มันคล้ายกับคำตอบของ @ kkoehne ยกเว้นว่าไม่ได้บังคับ เนื่องจากว่า-tว่ามันจะทำการตั้งค่ารีโมตอีกครั้ง

ฉันมีความต้องการแตกต่างจาก OP เล็กน้อยซึ่งก็คือการสร้างฟีเจอร์ใหม่ที่จะปิดสาขาdevelop(หรือmaster) หลังจากรวมคำขอดึงเข้า ที่สามารถทำได้ในหนึ่งซับโดยไม่ต้องบังคับ แต่มันไม่ได้ปรับปรุงdevelopสาขาในท้องถิ่น เป็นเพียงเรื่องของการตรวจสอบสาขาใหม่และให้เป็นไปตามorigin/develop:

git checkout -b new-feature origin/develop

เพียงแค่ดึงต้นแบบโดยไม่ต้องตรวจสอบต้นแบบที่ฉันใช้

git fetch origin master:master

มันเป็นไปได้อย่างยิ่งที่จะทำผสานใด ๆ git checkoutแม้จะไม่ใช่อย่างรวดเร็วผสานไปข้างหน้าโดยไม่ต้อง worktreeคำตอบโดย @grego เป็นคำแนะนำที่ดี หากต้องการขยาย:

cd local_repo
git worktree add _master_wt master
cd _master_wt
git pull origin master:master
git merge --no-ff -m "merging workbranch" my_work_branch
cd ..
git worktree remove _master_wt

ตอนนี้คุณได้รวมสาขางานในท้องถิ่นเป็นmasterสาขาท้องถิ่นโดยไม่ต้องเปลี่ยนเช็คเอาต์

หากคุณต้องการให้ต้นไม้เดียวกันกับสาขาใดสาขาหนึ่งที่คุณต้องการผสาน (เช่นไม่ใช่ "การรวม" จริง) คุณสามารถทำเช่นนี้ได้

# Check if you can fast-forward
if git merge-base --is-ancestor a b; then
    git update-ref refs/heads/a refs/heads/b
    exit
fi

# Else, create a "merge" commit
commit="$(git commit-tree -p a -p b -m "merge b into a" "$(git show -s --pretty=format:%T b)")"
# And update the branch to point to that commit
git update-ref refs/heads/a "$commit"

git worktree add [-f] [--detach] [--checkout] [--lock] [-b <new-branch>] <path> [<commit-ish>]

คุณสามารถลอง git worktreeเปิดสาขาสองข้างได้เสียงนี้อาจเป็นสิ่งที่คุณต้องการ แต่แตกต่างจากคำตอบอื่น ๆ ที่ฉันเคยเห็นที่นี่

ด้วยวิธีนี้คุณสามารถมีสองสาขาแยกกันติดตามใน repo git เดียวกันดังนั้นคุณต้องดึงเพียงครั้งเดียวเพื่อรับการอัพเดตในต้นไม้ทำงานทั้งสอง (แทนที่จะต้องคอมไพล์โคลนสองครั้งและดึง git แต่ละครั้ง)

Worktree จะสร้างไดเรกทอรีการทำงานใหม่สำหรับรหัสของคุณซึ่งคุณสามารถมีสาขาที่แตกต่างกันตรวจสอบพร้อมกันแทนการแลกเปลี่ยนสาขาในสถานที่

เมื่อคุณต้องการลบคุณสามารถทำความสะอาดด้วย

git worktree remove [-f] <worktree>