Có thể kéo git kéo - tất cả cập nhật tất cả các chi nhánh địa phương của tôi?

Tôi thường có ít nhất 3 chi nhánh từ xa: bậc thầy, dàn dựng và sản xuất. Tôi có 3 chi nhánh địa phương theo dõi những chi nhánh từ xa.

Cập nhật tất cả các chi nhánh địa phương của tôi là tẻ nhạt:

git fetch --all
git rebase origin/master
git checkout staging
git rebase origin/staging
git checkout production
git rebase origin/production

Tôi rất thích có thể thực hiện một "git pull -all", nhưng tôi đã không thể làm cho nó hoạt động. Nó dường như thực hiện một "tìm nạp - tất cả", sau đó cập nhật (chuyển tiếp nhanh hoặc sáp nhập) nhánh làm việc hiện tại, nhưng không phải là các nhánh cục bộ khác.

Tôi vẫn bị mắc kẹt khi chuyển đổi thủ công đến từng chi nhánh địa phương và cập nhật.

Hành vi bạn mô tả pull --allchính xác như mong đợi, mặc dù không nhất thiết phải hữu ích. Tùy chọn được truyền cùng với git fetch, sau đó tìm nạp tất cả các ref từ tất cả các điều khiển từ xa, thay vì chỉ một cái cần thiết; pullsau đó hợp nhất (hoặc trong trường hợp của bạn, khởi động lại) nhánh đơn thích hợp.

Nếu bạn muốn kiểm tra các chi nhánh khác, bạn sẽ phải kiểm tra chúng. Và đúng vậy, việc hợp nhất (và nổi loạn) hoàn toàn đòi hỏi một cây công việc, vì vậy chúng không thể được thực hiện mà không kiểm tra các nhánh khác. Bạn có thể kết thúc các bước được mô tả của mình thành một tập lệnh / bí danh nếu bạn muốn, mặc dù tôi khuyên bạn nên tham gia các lệnh &&để một trong số chúng thất bại, nó sẽ không cố gắng tiếp tục.

Tôi sử dụng synctiểu ban của trung tâm để tự động hóa việc này. Tôi có alias git=hubtrong tôi .bash_profile, vì vậy lệnh tôi gõ là:

git sync

Điều này cập nhật tất cả các chi nhánh địa phương có một chi nhánh ngược dòng phù hợp. Từ trang người đàn ông:

• Nếu chi nhánh địa phương đã lỗi thời, hãy nhanh chóng chuyển tiếp nó;
• Nếu chi nhánh địa phương chứa công việc không được đánh giá cao, hãy cảnh báo về nó;
• Nếu nhánh có vẻ hợp nhất và nhánh ngược dòng của nó bị xóa, hãy xóa nó.

Nó cũng xử lý stashing / unstashing những thay đổi không được cam kết trên nhánh hiện tại.

Tôi đã từng sử dụng một công cụ tương tự gọi là git-up , nhưng nó không còn được duy trì và git syncthực hiện gần như chính xác điều tương tự.

Tôi biết câu hỏi này đã gần 3 tuổi, nhưng tôi đã tự hỏi mình câu hỏi tương tự và không tìm thấy bất kỳ giải pháp làm sẵn nào. Vì vậy, tôi đã tự tạo một tập lệnh shell git tùy chỉnh.

Nó đây rồi, git-ffwd-updatekịch bản thực hiện như sau ...

1. nó phát hành a git remote updateđể lấy số vòng quay
2. sau đó sử dụng git remote showđể có được danh sách các nhánh cục bộ theo dõi một nhánh từ xa (ví dụ: các nhánh có thể được sử dụng với git pull)
3. sau đó nó kiểm tra xem có git rev-list --count <REMOTE_BRANCH>..<LOCAL_BRANCH>bao nhiêu cam kết chi nhánh địa phương đằng sau điều khiển từ xa (và ngược lại)
4. nếu chi nhánh địa phương là 1 hoặc nhiều cam kết phía trước, nó KHÔNG thể được chuyển tiếp nhanh và cần được sáp nhập hoặc từ chối bằng tay
5. nếu chi nhánh địa phương là 0 cam kết phía trước và 1 hoặc nhiều cam kết phía sau, nó có thể được chuyển tiếp nhanh bằng git branch -f <LOCAL_BRANCH> -t <REMOTE_BRANCH>

kịch bản có thể được gọi như:

$ git ffwd-update
Fetching origin
 branch bigcouch was 10 commit(s) behind of origin/bigcouch. resetting local branch to remote
 branch develop was 3 commit(s) behind of origin/develop. resetting local branch to remote
 branch master is 6 commit(s) behind and 1 commit(s) ahead of origin/master. could not be fast-forwarded

Kịch bản đầy đủ, nên được lưu dưới dạng git-ffwd-updatevà cần phải có trên PATH.

#!/bin/bash

main() {
  REMOTES="$@";
  if [ -z "$REMOTES" ]; then
    REMOTES=$(git remote);
  fi
  REMOTES=$(echo "$REMOTES" | xargs -n1 echo)
  CLB=$(git rev-parse --abbrev-ref HEAD);
  echo "$REMOTES" | while read REMOTE; do
    git remote update $REMOTE
    git remote show $REMOTE -n \
    | awk '/merges with remote/{print $5" "$1}' \
    | while read RB LB; do
      ARB="refs/remotes/$REMOTE/$RB";
      ALB="refs/heads/$LB";
      NBEHIND=$(( $(git rev-list --count $ALB..$ARB 2>/dev/null) +0));
      NAHEAD=$(( $(git rev-list --count $ARB..$ALB 2>/dev/null) +0));
      if [ "$NBEHIND" -gt 0 ]; then
        if [ "$NAHEAD" -gt 0 ]; then
          echo " branch $LB is $NBEHIND commit(s) behind and $NAHEAD commit(s) ahead of $REMOTE/$RB. could not be fast-forwarded";
        elif [ "$LB" = "$CLB" ]; then
          echo " branch $LB was $NBEHIND commit(s) behind of $REMOTE/$RB. fast-forward merge";
          git merge -q $ARB;
        else
          echo " branch $LB was $NBEHIND commit(s) behind of $REMOTE/$RB. resetting local branch to remote";
          git branch -f $LB -t $ARB >/dev/null;
        fi
      fi
    done
  done
}

main $@

Không quá khó để tự động hóa:

#!/bin/sh
# Usage: fetchall.sh branch ...

set -x
git fetch --all
for branch in "$@"; do
    git checkout "$branch"      || exit 1
    git rebase "origin/$branch" || exit 1
done

Điều này vẫn không tự động, vì tôi muốn có một tùy chọn cho - và cần có một số kiểm tra để đảm bảo rằng điều này chỉ có thể xảy ra đối với các cập nhật chuyển tiếp nhanh (đó là lý do tại sao thực hiện thao tác kéo an toàn hơn rất nhiều !!), nhưng hãy cẩn thận, bạn có thể:

git fetch origin
git update-ref refs/heads/other-branch origin/other-branch

để cập nhật vị trí của chi nhánh địa phương của bạn mà không cần phải kiểm tra nó.

Lưu ý: bạn sẽ mất vị trí chi nhánh hiện tại của mình và di chuyển nó đến vị trí của chi nhánh gốc, điều đó có nghĩa là nếu bạn cần hợp nhất, bạn sẽ mất dữ liệu!

Có rất nhiều câu trả lời ở đây nhưng không có câu trả lời nào được sử dụng git-fetchđể cập nhật trực tiếp các ref cục bộ, điều này đơn giản hơn nhiều so với việc kiểm tra các chi nhánh và an toàn hơn git-update-ref.

Ở đây chúng tôi sử dụng git-fetchđể cập nhật các chi nhánh không hiện tại và git pull --ff-onlycho các chi nhánh hiện tại. Nó:

• Không yêu cầu kiểm tra chi nhánh
• Chỉ cập nhật các chi nhánh nếu chúng có thể được chuyển tiếp nhanh
• Sẽ báo cáo khi không thể chuyển tiếp nhanh

và đây là:

#!/bin/bash
currentbranchref="$(git symbolic-ref HEAD 2>&-)"
git branch -r | grep -v ' -> ' | while read remotebranch
do
    # Split <remote>/<branch> into remote and branchref parts
    remote="${remotebranch%%/*}"
    branchref="refs/heads/${remotebranch#*/}"

    if [ "$branchref" == "$currentbranchref" ]
    then
        echo "Updating current branch $branchref from $remote..."
        git pull --ff-only
    else
        echo "Updating non-current ref $branchref from $remote..."
        git fetch "$remote" "$branchref:$branchref"
    fi
done

Từ trang hướng dẫn cho git-fetch:

   <refspec>
       The format of a <refspec> parameter is an optional plus +, followed by the source ref <src>,
       followed by a colon :, followed by the destination ref <dst>.

       The remote ref that matches <src> is fetched, and if <dst> is not empty string, the local ref
       that matches it is fast-forwarded using <src>. If the optional plus + is used, the local ref is
       updated even if it does not result in a fast-forward update.

Bằng cách chỉ định git fetch <remote> <ref>:<ref>(không có bất kỳ +), chúng tôi nhận được một bản cập nhật chỉ cập nhật các tham chiếu cục bộ khi nó có thể được chuyển tiếp nhanh.

Lưu ý : điều này giả sử các nhánh cục bộ và từ xa được đặt tên giống nhau (và bạn muốn theo dõi tất cả các nhánh), nó thực sự nên sử dụng thông tin về những nhánh địa phương nào bạn có và những gì chúng được thiết lập để theo dõi.

Vấn đề này chưa được giải quyết (chưa), ít nhất là không dễ dàng / không có kịch bản: xem bài đăng này trên danh sách gửi thư git của Junio ​​C Hamano giải thích tình huống và cung cấp cuộc gọi cho một giải pháp đơn giản.

Lý do chính là bạn không cần điều này:

Với git không cổ (tức là v1.5.0 hoặc mới hơn), không có lý do gì để có "dev" cục bộ mà hoàn toàn theo dõi điều khiển từ xa nữa. Nếu bạn chỉ muốn đi tìm và xem, bạn có thể kiểm tra chi nhánh theo dõi từ xa trực tiếp trên một ĐẦU tách rời với " git checkout origin/dev".

Điều đó có nghĩa là các trường hợp duy nhất chúng tôi cần để thuận tiện cho người dùng là xử lý các nhánh cục bộ này "theo dõi" các chi nhánh từ xa khi bạn có thay đổi cục bộ hoặc khi bạn dự định có một số.

Nếu bạn có các thay đổi cục bộ trên "dev" được đánh dấu để theo dõi "dev" và nếu bạn ở một nhánh khác với "dev", thì chúng ta không nên làm gì sau khi " git fetch" cập nhật "dev" theo dõi từ xa . Nó sẽ không nhanh chóng chuyển tiếp

Lời kêu gọi giải pháp là một tùy chọn hoặc tập lệnh bên ngoài để cắt tỉa các nhánh cục bộ theo sau các nhánh theo dõi từ xa, thay vì giữ cho chúng được cập nhật bằng cách chuyển tiếp nhanh, như áp phích ban đầu được yêu cầu.

Vậy làm thế nào về " git branch --prune --remote=<upstream>" lặp đi lặp lại trên các chi nhánh địa phương, và nếu

(1) nó không phải là chi nhánh hiện tại; và
(2) nó được đánh dấu để theo dõi một số nhánh được lấy từ <thượng nguồn>; và
(3) nó không có bất kỳ cam kết nào;

Sau đó loại bỏ chi nhánh đó? " git remote --prune-local-forks <upstream>" cũng tốt; Tôi không quan tâm đến lệnh nào thực hiện tính năng đó nhiều.

Lưu ý: kể từ git 2.10, không có giải pháp nào như vậy tồn tại. Lưu ý rằnggit remote prunetiểu ban vàgit fetch --prunevề việc loại bỏ nhánh theo dõi từ xa cho nhánh không còn tồn tại trên remote, không phải về việc loại bỏ nhánh cục bộ theo dõi nhánh theo dõi từ xa (mà nhánh theo dõi từ xa là nhánh ngược dòng).

Có rất nhiều câu trả lời chấp nhận được ở đây, nhưng một số hệ thống ống nước có thể hơi mờ đối với người không quen. Đây là một ví dụ đơn giản hơn nhiều có thể dễ dàng được tùy chỉnh:

$ cat ~/bin/git/git-update-all
#!/bin/bash
# Update all local branches, checking out each branch in succession.
# Eventually returns to the original branch. Use "-n" for dry-run.
git_update_all() {
  local run br
  br=$(git name-rev --name-only HEAD 2>/dev/null)
  [ "$1" = "-n" ] && shift && run=echo

  for x in $( git branch | cut -c3- ) ; do
     $run git checkout $x && $run git pull --ff-only || return 2
  done

  [ ${#br} -gt 0 ] && $run git checkout "$br"
}

git_update_all "$@"

Nếu bạn thêm ~/bin/gitvào PATH(giả sử tệp là ~/bin/git/git-update-all), bạn có thể chạy:

$ git update-all

Thêm kịch bản này để .profiletrên Mac OS X:

# Usage:
#   `git-pull-all` to pull all your local branches from origin
#   `git-pull-all remote` to pull all your local branches from a named remote

function git-pull-all() {
    START=$(git symbolic-ref --short -q HEAD);
    for branch in $(git branch | sed 's/^.//'); do
        git checkout $branch;
        git pull ${1:-origin} $branch || break;
    done;
    git checkout $START;
};

function git-push-all() {
    git push --all ${1:-origin};
};

Đây là một câu trả lời hay: Làm thế nào để lấy tất cả các nhánh git

for remote in `git branch -r`; do git branch --track $remote; done
git pull --all

Một kịch bản tôi đã viết cho GitBash của tôi . Hoàn thành những điều sau:

• Theo mặc định, kéo từ gốc cho tất cả các nhánh được thiết lập để theo dõi nguồn gốc, cho phép bạn chỉ định một điều khiển từ xa khác nếu muốn.
• Nếu chi nhánh hiện tại của bạn ở trạng thái bẩn thì nó sẽ thay đổi các thay đổi của bạn và sẽ cố gắng khôi phục các thay đổi này vào cuối.
• Đối với mỗi nhánh cục bộ được thiết lập để theo dõi một nhánh từ xa sẽ:
  • git checkout branch
  • git pull origin
• Cuối cùng, sẽ đưa bạn trở lại chi nhánh ban đầu và khôi phục trạng thái.

** Tôi sử dụng cái này nhưng chưa kiểm tra kỹ, sử dụng có nguy cơ. Xem ví dụ về tập lệnh này trong tệp .bash_alias tại đây .

    # Do a pull on all branches that are tracking a remote branches, will from origin by default.
    # If current branch is dirty, will stash changes and reply after pull.
    # Usage: pullall [remoteName]
    alias pullall=pullAll
    function pullAll (){
     # if -h then show help
     if [[ $1 == '-h' ]]
    then
      echo "Description: Pulls new changes from upstream on all branches that are tracking remotes."
      echo 
      echo "Usage: "
      echo "- Default: pullall"
      echo "- Specify upstream to pull from: pullall [upstreamName]"
      echo "- Help: pull-all -h"
    else

     # default remote to origin
     remote="origin"
     if [ $1 != "" ]
     then
       remote=$1
     fi

     # list all branches that are tracking remote
     # git branch -vv : list branches with their upstreams
     # grep origin : keep only items that have upstream of origin
     # sed "s/^.."... : remove leading *
     # sed "s/^"..... : remove leading white spaces
     # cut -d" "..... : cut on spaces, take first item
     # cut -d splits on space, -f1 grabs first item
     branches=($(git branch -vv | grep $remote | sed "s/^[ *]*//" | sed "s/^[ /t]*//" | cut -d" " -f1))

     # get starting branch name
     startingBranch=$(git rev-parse --abbrev-ref HEAD)

     # get starting stash size
     startingStashSize=$(git stash list | wc -l)

     echo "Saving starting branch state: $startingBranch"
     git stash

     # get the new stash size
     newStashSize=$(git stash list | wc -l)

     # for each branch in the array of remote tracking branches
     for branch in ${branches[*]}
     do
       echo "Switching to $branch"
       git checkout $branch

       echo "Pulling $remote"
       git pull $remote

     done

     echo "Switching back to $startingBranch"
     git checkout $startingBranch

     # compare before and after stash size to see if anything was stashed
     if [ "$startingStashSize" -lt "$newStashSize" ]
     then
       echo "Restoring branch state"
       git stash pop
     fi
    fi
    }

Nếu bạn đang dùng Windows, bạn có thể sử dụng PyGitUp , một bản sao của git-upPython. Bạn có thể cài đặt nó bằng pip với pip install --user git-uphoặc thông qua Scoop bằngscoop install git-up

[

Chỉ cần đăng một câu trả lời cập nhật. git-upkhông còn được duy trì và nếu bạn đọc tài liệu, họ đề cập đến chức năng hiện có sẵn trong git .

Kể từ Git 2.9, git pull --rebase --autostash về cơ bản cũng tương tự như vậy.

Theo đó, nếu bạn cập nhật lên Git 2.9 trở lên, bạn có thể sử dụng bí danh này thay vì cài đặt git-up:

git config --global alias.up 'pull --rebase --autostash'

Bạn cũng có thể đặt cái này cho mọi thứ git pullkể từ Git 2.9 (cảm ơn @VonC vui lòng xem câu trả lời của anh ấy ở đây )

git config --global pull.rebase true
git config --global rebase.autoStash true

Tôi đã gặp vấn đề tương tự của câu hỏi này ...

Tự hỏi về nó, tôi đã thực hiện một chức năng bí danh nhỏ trong .bashrctệp của mình :

gitPullAll() {
    for branch in `git branch | sed -E 's/^\*/ /' | awk '{print $1}'`; do
        git checkout $branch
        git pull -p
        printf "\n"
    done
    echo "Done"
}

Đã làm cho tôi (:

Nếu refs / Heads / master có thể được chuyển nhanh sang refs / remote / foo / master , thì đầu ra của

git merge-base refs/heads/master refs/remotes/foo/master

nên trả về id SHA1 mà refs / Heads / master trỏ tới. Với điều này, bạn có thể tập hợp một tập lệnh tự động cập nhật tất cả các nhánh cục bộ không có cam kết chuyển hướng được áp dụng cho chúng.

Kịch bản shell nhỏ này (tôi gọi nó là git-can-ff ) minh họa cách nó có thể được thực hiện.

#!/bin/sh

set -x

usage() {
    echo "usage: $(basename $0) <from-ref> <to-ref>" >&2
    exit 2
}

[ $# -ne 2 ] && usage

FROM_REF=$1
TO_REF=$2

FROM_HASH=$(git show-ref --hash $FROM_REF)
TO_HASH=$(git show-ref --hash $TO_REF)
BASE_HASH=$(git merge-base $FROM_REF $TO_REF)

if [ "$BASE_HASH" = "$FROM_HASH" -o \
     "$BASE_HASH" = "$FROM_REF" ]; then
    exit 0
else
    exit 1
fi

Để hoàn thành câu trả lời của Matt Connolly, đây là cách an toàn hơn để cập nhật các tham chiếu chi nhánh địa phương có thể được chuyển tiếp nhanh mà không cần kiểm tra chi nhánh. Nó không cập nhật các nhánh không thể chuyển tiếp nhanh (nghĩa là đã chuyển hướng) và nó không cập nhật các nhánh hiện đang được kiểm tra (vì sau đó cũng nên cập nhật bản sao làm việc).

git fetch

head="$(git symbolic-ref HEAD)"
git for-each-ref --format="%(refname) %(upstream)" refs/heads | while read ref up; do
    if [ -n "$up" -a "$ref" != "$head" ]; then
        mine="$(git rev-parse "$ref")"
        theirs="$(git rev-parse "$up")"
        base="$(git merge-base "$ref" "$up")"
        if [ "$mine" != "$theirs" -a "$mine" == "$base" ]; then
            git update-ref "$ref" "$theirs"
        fi
    fi
done

Một tập lệnh hơi khác chỉ các nhánh chuyển tiếp nhanh, tên của chúng khớp với nhánh ngược dòng của chúng. Nó cũng cập nhật chi nhánh hiện tại nếu có thể chuyển tiếp nhanh.

Đảm bảo rằng tất cả các nhánh ngược dòng của chi nhánh của bạn được đặt chính xác bằng cách chạy git branch -vv. Đặt nhánh ngược dòng vớigit branch -u origin/yourbanchname

Sao chép-dán vào một tập tin và chmod 755:

#!/bin/sh

curbranch=$(git rev-parse --abbrev-ref HEAD)

for branch in $(git for-each-ref refs/heads --format="%(refname:short)"); do
        upbranch=$(git config --get branch.$branch.merge | sed 's:refs/heads/::');
        if [ "$branch" = "$upbranch" ]; then
                if [ "$branch" = "$curbranch" ]; then
                        echo Fast forwarding current branch $curbranch
                        git merge --ff-only origin/$upbranch
                else
                        echo Fast forwarding $branch with origin/$upbranch
                        git fetch . origin/$upbranch:$branch
                fi
        fi
done;

Một lớp lót sau nhanh chóng chuyển tiếp tất cả các nhánh có nhánh ngược dòng nếu có thể và in lỗi khác:

git branch \
  --format "%(if)%(upstream:short)%(then)git push . %(upstream:short):%(refname:short)%(end)" |
  sh

Làm thế nào nó hoạt động?

Nó sử dụng một định dạng tùy chỉnh với git branchlệnh. Đối với mỗi nhánh có một nhánh ngược dòng, nó sẽ in một dòng với mẫu sau:

git push . <remote-ref>:<branch>

Điều này có thể được dẫn trực tiếp vào sh(giả sử rằng tên chi nhánh được hình thành tốt). Bỏ qua | shđể xem những gì nó đang làm.

Hãy cẩn thận

Một lớp lót sẽ không liên lạc với điều khiển từ xa của bạn. Phát hành một git fetchhoặc git fetch --alltrước khi chạy nó.

Chi nhánh thanh toán hiện tại sẽ không được cập nhật với một thông báo như

! [remote rejected] origin/master -> master (branch is currently checked out)

Đối với điều này, bạn có thể dùng đến thường xuyên git pull --ff-only.

Bí danh

Thêm phần sau vào của bạn .gitconfigđể git fftthực hiện lệnh này:

[alias]
        fft = !sh -c 'git branch --format \"%(if)%(upstream:short)%(then)git push . %(upstream:short):%(refname:short)%(end)\" | sh' -

Xem thêm của tôi .gitconfig. Bí danh là một cách viết tắt của "theo dõi chuyển tiếp nhanh (các nhánh)".

Kịch bản từ @larsmans, một chút được cải thiện:

#!/bin/sh

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
for branch in "$@"; do
  if ["$branch" -ne "$CURRENT"]; then
    git checkout "$branch" || exit 1
    git rebase "origin/$branch" || exit 1
  fi
done
git checkout "$CURRENT" || exit 1
git rebase "origin/$CURRENT" || exit 1

Điều này, sau khi nó kết thúc, để lại bản sao làm việc được kiểm tra từ cùng một nhánh như trước khi tập lệnh được gọi.

Các git pullphiên bản:

#!/bin/sh

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
for branch in "$@"; do
  if ["$branch" -ne "$CURRENT"]; then
    git checkout "$branch" || exit 1
    git pull || exit 1
  fi
done
git checkout "$CURRENT" || exit 1
git pull || exit 1

Có vẻ như nhiều người khác đã đóng góp các giải pháp tương tự, nhưng tôi nghĩ tôi sẽ chia sẻ những gì tôi đã đưa ra và mời những người khác đóng góp. Giải pháp này có đầu ra đầy màu sắc đẹp mắt, xử lý duyên dáng thư mục làm việc hiện tại của bạn và nhanh chóng vì nó không thực hiện bất kỳ kiểm tra nào và để lại thư mục làm việc của bạn một cách khéo léo. Ngoài ra, nó chỉ là một kịch bản shell không có phụ thuộc nào ngoài git. (chỉ được thử nghiệm trên OSX cho đến nay)

#!/usr/bin/env bash

gitup(){    
RED='\033[33;31m'
YELLO='\033[33;33m'
GREEN='\033[33;32m'
NC='\033[0m' # No Color

HEAD=$(git rev-parse HEAD)
CHANGED=$(git status --porcelain | wc -l)

echo "Fetching..."
git fetch --all --prune &>/dev/null
for branch in `git for-each-ref --format='%(refname:short)' refs/heads`; do

    LOCAL=$(git rev-parse --quiet --verify $branch)
    if [ "$HEAD" = "$LOCAL" ] && [ $CHANGED -gt 0 ]; then
        echo -e "${YELLO}WORKING${NC}\t\t$branch"
    elif git rev-parse --verify --quiet $branch@{u}&>/dev/null; then
        REMOTE=$(git rev-parse --quiet --verify $branch@{u})
        BASE=$(git merge-base $branch $branch@{u})

        if [ "$LOCAL" = "$REMOTE" ]; then
           echo -e "${GREEN}OK${NC}\t\t$branch" 
        elif [ "$LOCAL" = "$BASE" ]; then
            if [ "$HEAD" = "$LOCAL" ]; then
                git merge $REMOTE&>/dev/null
            else
                git branch -f $branch $REMOTE
            fi
            echo -e "${GREEN}UPDATED${NC}\t\t$branch"
        elif [ "$REMOTE" = "$BASE" ]; then
            echo -e "${RED}AHEAD${NC}\t\t$branch"
        else
            echo -e "${RED}DIVERGED${NC}\t\t$branch"
        fi
    else
        echo -e "${RED}NO REMOTE${NC}\t$branch"
    fi
done
}

https://github.com/davestimpert/gitup

Xin lỗi tôi dường như cũng đã đưa ra cùng tên với các công cụ khác ở trên.

Nó có thể được thực hiện bằng cách sử dụng tập lệnh bên dưới ... Đầu tiên, nó sẽ tìm nạp tất cả các nhánh và kiểm tra từng cái một và tự cập nhật.

#!/bin/bash
git branch -r | grep -v '\->' | while read remote; do git branch --track 
"${remote#origin/}" "$remote"; done

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
branch_name=$(git branch | awk '{print $1" "}' | grep -v '*' | xargs)
for branch in $branch_name; do
   git checkout "$branch" || exit 1
   git rebase "origin/$branch" || exit 1
   git pull origin $branch|| exit 1
done
git checkout "$CURRENT" || exit 1
git pull || exit 1

Bạn không thể làm điều đó chỉ với một lệnh git nhưng bạn có thể tự động hóa nó bằng một dòng bash.

Để cập nhật an toàn tất cả các chi nhánh với một dòng, đây là những gì tôi làm:

git fetch --all && for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*') ; do git checkout $branch && git merge --ff-only || break ; done

• Nếu nó không thể chuyển tiếp nhanh một nhánh hoặc gặp lỗi, nó sẽ dừng và để bạn ở nhánh đó để bạn có thể lấy lại quyền kiểm soát và hợp nhất thủ công.

• Nếu tất cả các chi nhánh có thể được chuyển tiếp nhanh, nó sẽ kết thúc với chi nhánh bạn hiện đang ở, để lại cho bạn vị trí trước khi cập nhật.

Giải thích:

Để dễ đọc hơn, nó có thể được chia thành nhiều dòng:

git fetch --all && \
for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*')
    do git checkout $branch && \
    git merge --ff-only || break
done

1. git fetch --all && ... => Lấy tất cả các ref từ tất cả các điều khiển từ xa và tiếp tục với lệnh tiếp theo nếu không có lỗi.

2. git branch | sed '/*/{$q;h;d};$G' | tr -d '*'=> Từ đầu ra của git branch, sedlấy dòng bằng a *và di chuyển đến cuối (để nhánh hiện tại sẽ được cập nhật lần cuối). Sau đó, trchỉ cần loại bỏ *.

3. for branch in $(...) ; do git checkout $branch && git merge --ff-only || break ; done=> Đối với mỗi tên nhánh thu được từ lệnh trước, hãy kiểm tra nhánh này và thử hợp nhất với chuyển tiếp nhanh. Nếu thất bại, breakđược gọi và lệnh dừng ở đây.

Tất nhiên, bạn có thể thay thế git merge --ff-onlybằng git rebasenếu đó là những gì bạn muốn.

Cuối cùng, bạn có thể đặt nó trong bashrc dưới dạng bí danh:

alias git-pull-all='git fetch --all && for branch in $(git branch | sed '\''/*/{$q;h;d};$G'\'' | tr -d "*") ; do git checkout $branch && git merge --ff-only || break ; done'

Hoặc nếu bạn sợ làm phiền với 'và ", hoặc đơn giản là bạn muốn giữ khả năng đọc cú pháp trong trình chỉnh sửa của mình, bạn có thể khai báo nó như một hàm:

git-pull-all()
{
    git fetch --all && for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*') ; do git checkout $branch && git merge --ff-only || break ; done
}

Tặng kem:

Đối với những người muốn giải thích về sed '/*/{$q;h;d};$G'phần này:

• /*/=> Tìm kiếm dòng có a *.

• {$q => Nếu nó ở dòng cuối cùng, hãy thoát (chúng tôi không cần làm gì cả vì chi nhánh hiện tại đã là chi nhánh cuối cùng trong danh sách).

• ;h;d} => Nếu không, lưu dòng trong bộ đệm giữ và xóa nó trong vị trí danh sách hiện tại.

• ;$G => Khi đến dòng cuối cùng, nối thêm nội dung của bộ đệm giữ.

Có thể kéo git kéo - tất cả cập nhật tất cả các chi nhánh địa phương của tôi?

Không, nó không thể. Để chuyển tiếp nhanh, tôi chỉ cần viết một công cụ nhỏ để làm như vậy. https://github.com/changyuheng/git-fast-forward-all

Ưu điểm của công cụ này:

1. Hỗ trợ nhiều điều khiển từ xa trong một kho lưu trữ. ( hub synckhông hỗ trợ nhiều điều khiển từ xa tại thời điểm này.)
2. Hỗ trợ có các tên khác nhau trên nhánh cục bộ và nhánh theo dõi từ xa tương ứng.
3. Nhanh hơn nhiều so với các tập lệnh khác tìm nạp từ xa cho mỗi nhánh.
4. Không có phân tích / chỉnh sửa regex dễ bị lỗi.

Kể từ git 2.9:

git pull --rebase --autostash

Xem https://git-scm.com/docs/git-rebase

Tự động tạo một ngăn tạm thời trước khi hoạt động bắt đầu và áp dụng nó sau khi hoạt động kết thúc. Điều này có nghĩa là bạn có thể chạy rebase trên một bàn làm việc bẩn. Tuy nhiên, sử dụng cẩn thận: ứng dụng stash cuối cùng sau khi rebase thành công có thể dẫn đến xung đột không hề nhỏ.

Trong thực tế, với git version 1.8.3.1, nó hoạt động:

[root@test test]# git br
* master
  release/0.1
  update
[root@test test]# git pull --rebase
remote: Enumerating objects: 9, done.
remote: Counting objects: 100% (9/9), done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 9 (delta 2), reused 0 (delta 0)
Unpacking objects: 100% (9/9), done.
From http://xxx/scm/csdx/test-git
   d32ca6d..2caa393  release/0.1 -> origin/release/0.1
Current branch master is up to date.
[root@test test]# git --version
git version 1.8.3.1

Trong nhánh chính, bạn có thể cập nhật tất cả các nhánh khác. @ Nhãn

Tôi không biết phiên bản nào phá vỡ / sửa chữa nó, trong 2.17 (mà tôi sử dụng), nó có thể hoạt động.