Bisakah "git pull --all" memperbarui semua cabang lokal saya?

Saya sering memiliki setidaknya 3 cabang terpencil: master, pementasan dan produksi. Saya memiliki 3 cabang lokal yang melacak cabang-cabang terpencil itu.

Memperbarui semua cabang lokal saya membosankan:

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

Saya ingin bisa melakukan "git pull -all", tapi saya belum bisa membuatnya bekerja. Tampaknya melakukan "fetch - all", kemudian memperbarui (memajukan atau menggabungkan) cabang yang sedang bekerja, tetapi bukan cabang lokal lainnya.

Saya masih terjebak secara manual beralih ke setiap cabang lokal dan memperbarui.

Perilaku yang Anda jelaskan pull --allpersis seperti yang diharapkan, meskipun tidak selalu berguna. Opsi ini diteruskan ke git fetch, yang kemudian mengambil semua referensi dari semua remote, bukan hanya yang dibutuhkan; pullkemudian menggabungkan (atau dalam kasus Anda, rebases) cabang tunggal yang sesuai.

Jika Anda ingin memeriksa cabang lain, Anda harus memeriksanya. Dan ya, penggabungan (dan rebasing) benar - benar membutuhkan pohon kerja, sehingga mereka tidak dapat dilakukan tanpa memeriksa cabang lainnya. Anda dapat membungkus langkah-langkah yang dijelaskan ke dalam skrip / alias jika Anda mau, meskipun saya sarankan untuk bergabung dengan perintah &&sehingga jika salah satu dari mereka gagal, itu tidak akan mencoba untuk membajak.

Saya menggunakan syncsubcommand dari hub untuk mengotomatisasi ini. Saya miliki alias git=hubdi saya .bash_profile, jadi perintah yang saya ketik adalah:

git sync

Ini memperbarui semua cabang lokal yang memiliki cabang upstream yang cocok. Dari halaman manual:

• Jika cabang lokal sudah usang, maju cepat;
• Jika cabang lokal berisi pekerjaan yang tidak dicuci, peringatkan tentang hal itu;
• Jika cabang tampaknya digabung dan cabang hulu telah dihapus, hapuslah.

Ini juga menangani stashing / unstashing perubahan yang tidak dikomit pada cabang saat ini.

Saya dulu menggunakan alat serupa yang disebut git-up , tetapi tidak lagi dipertahankan, dan git syncmelakukan hal yang persis sama.

Saya tahu pertanyaan ini hampir 3 tahun, tetapi saya bertanya pada diri sendiri pertanyaan yang sama dan tidak menemukan solusi yang sudah jadi. Jadi, saya membuat skrip shell perintah git kustom sendiri.

Ini dia, git-ffwd-updateskrip melakukan yang berikut ...

1. itu mengeluarkan git remote updateuntuk mengambil revs akhir
2. lalu gunakan git remote showuntuk mendapatkan daftar cabang lokal yang melacak cabang jarak jauh (mis. cabang yang dapat digunakan dengan git pull)
3. kemudian memeriksa dengan git rev-list --count <REMOTE_BRANCH>..<LOCAL_BRANCH>berapa banyak komit cabang lokal di belakang remote (dan di depan sebaliknya)
4. jika cabang lokal adalah 1 atau lebih berkomitmen di depan, itu TIDAK dapat diteruskan dan perlu digabung atau diubah kembali dengan tangan
5. jika cabang lokal 0 berkomitmen di depan dan 1 atau lebih berkomitmen di belakang, itu dapat diteruskan dengan cepat git branch -f <LOCAL_BRANCH> -t <REMOTE_BRANCH>

skrip dapat disebut seperti:

$ 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

Naskah lengkap, harus disimpan sebagai git-ffwd-updatedan harus di 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 $@

Tidak terlalu sulit untuk mengotomatisasi:

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

Ini masih tidak otomatis, karena saya berharap ada opsi untuk - dan harus ada pengecekan untuk memastikan bahwa ini hanya dapat terjadi untuk pembaruan fast-forward (yang mengapa melakukan penarikan secara manual jauh lebih aman !!), tetapi selain peringatan Anda dapat:

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

untuk memperbarui posisi cabang lokal Anda tanpa harus memeriksanya.

Catatan: Anda akan kehilangan posisi cabang saat ini dan memindahkannya ke tempat asal cabang itu, yang berarti bahwa jika Anda perlu menggabungkan Anda akan kehilangan data!

Ada banyak jawaban di sini tetapi tidak ada yang digunakan git-fetchuntuk memperbarui referensi lokal secara langsung, yang jauh lebih sederhana daripada memeriksa cabang, dan lebih aman daripada git-update-ref.

Di sini kami gunakan git-fetchuntuk memperbarui cabang tidak lancar dan git pull --ff-onlyuntuk cabang saat ini. Itu:

• Tidak perlu memeriksa cabang
• Memperbarui cabang hanya jika mereka dapat diteruskan dengan cepat
• Akan melaporkan ketika tidak bisa maju cepat

dan ini dia:

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

Dari halaman manual untuk 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.

Dengan menentukan git fetch <remote> <ref>:<ref>(tanpa ada +) kami mendapatkan pengambilan yang memperbarui referensi lokal hanya ketika itu dapat diteruskan dengan cepat.

Catatan : ini mengasumsikan cabang lokal dan jauh dinamai sama (dan bahwa Anda ingin melacak semua cabang), itu harus benar-benar menggunakan informasi tentang cabang lokal yang Anda miliki dan apa yang diatur untuk dilacak.

Masalah ini belum terpecahkan (belum), setidaknya tidak mudah / tanpa skrip: lihat posting ini di milis git oleh Junio ​​C Hamano yang menjelaskan situasi dan memberikan panggilan untuk solusi sederhana.

Alasan utamanya adalah Anda tidak perlu ini:

Dengan git yang tidak kuno (yaitu v1.5.0 atau lebih baru), tidak ada alasan untuk memiliki "dev" lokal yang murni melacak remote lagi. Jika Anda hanya ingin melihat dan melihat, Anda dapat memeriksa cabang pelacakan jarak jauh langsung pada KEPALA yang terpisah dengan " git checkout origin/dev".

Yang berarti bahwa satu-satunya kasus yang kami butuhkan agar nyaman bagi pengguna adalah menangani cabang lokal yang "melacak" cabang jarak jauh ketika Anda memang memiliki perubahan lokal, atau ketika Anda berencana untuk memilikinya.

Jika Anda memiliki perubahan lokal pada "dev" yang ditandai untuk melacak penghapusan "dev", dan jika Anda berada di cabang yang berbeda dari "dev", maka kita tidak boleh melakukan apa pun setelah " git fetch" memperbarui pelacakan jarak jauh "dev" . Lagipula itu tidak akan maju cepat

Panggilan untuk solusi adalah untuk opsi atau skrip eksternal untuk memangkas cabang-cabang lokal yang mengikuti cabang-cabang pelacakan jarak jauh, daripada membuat mereka tetap up-to-date dengan penerusan cepat, seperti poster asli yang diminta.

Jadi bagaimana " git branch --prune --remote=<upstream>" yang beralih ke cabang lokal, dan jika

(1) itu bukan cabang saat ini; dan
(2) ditandai untuk melacak beberapa cabang yang diambil dari <upstream>; dan
(3) tidak memiliki komitmen sendiri;

lalu hapus cabang itu? " git remote --prune-local-forks <upstream>" juga baik-baik saja; Saya tidak peduli perintah mana yang mengimplementasikan fitur sebanyak itu.

Catatan: pada git 2.10 tidak ada solusi seperti itu. Perhatikan bahwagit remote prunesub-perintah, dangit fetch --prunetentang menghapus cabang pelacakan jarak jauh untuk cabang yang tidak lagi ada di jarak jauh, bukan tentang menghapus cabang lokal yang melacak cabang pelacakan jarak jauh (yang cabang pelacakan jarak jauh adalah cabang hulu).

Ada banyak jawaban yang bisa diterima di sini, tetapi beberapa pipa ledeng mungkin agak buram bagi yang belum tahu. Berikut adalah contoh yang jauh lebih sederhana yang dapat dengan mudah disesuaikan:

$ 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 "$@"

Jika Anda menambahkan ~/bin/gitke Anda PATH(dengan asumsi file tersebut ~/bin/git/git-update-all), Anda bisa menjalankan:

$ git update-all

Tambahkan skrip ini ke .profiledi 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};
};

Inilah jawaban yang bagus: Cara mengambil semua cabang git

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

Sebuah skrip yang saya tulis untuk GitBash saya . Selesaikan hal-hal berikut:

• Secara default tarikan dari asal untuk semua cabang yang diatur untuk melacak asal, memungkinkan Anda untuk menentukan jarak jauh yang berbeda jika diinginkan.
• Jika cabang Anda saat ini dalam keadaan kotor maka simpanan perubahan Anda dan akan mencoba untuk mengembalikan perubahan ini di akhir.
• Untuk setiap cabang lokal yang diatur untuk melacak cabang jarak jauh akan:
  • git checkout branch
  • git pull origin
• Akhirnya, akan mengembalikan Anda ke cabang semula dan mengembalikan status.

** Saya menggunakan ini tetapi belum diuji secara menyeluruh, gunakan dengan risiko sendiri. Lihat contoh skrip ini dalam file .bash_alias di sini .

    # 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
    }

Jika Anda menggunakan Windows, Anda dapat menggunakan PyGitUp yang merupakan tiruan dari git-upuntuk Python. Anda dapat menginstalnya menggunakan pip dengan pip install --user git-upatau melalui Scoop menggunakanscoop install git-up

[

Hanya memposting jawaban yang diperbarui. git-uptidak lagi dipertahankan dan jika Anda membaca dokumentasinya, mereka menyebutkan bahwa fungsinya sekarang tersedia di git .

Pada Git 2.9, git pull --rebase --autostash pada dasarnya melakukan hal yang sama.

Karenanya, jika Anda memperbarui ke Git 2.9 atau lebih baru, Anda dapat menggunakan alias ini daripada menginstal git-up:

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

Anda juga dapat mengatur ini untuk setiap git pullper Git 2.9 (terima kasih @VonC silakan lihat jawabannya di sini )

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

Saya menemukan masalah yang sama dari pertanyaan ini ...

Bingung sendiri tentang hal itu, saya melakukan fungsi alias kecil di dalam .bashrcfile saya :

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

Bekerja untuk saya (:

Jika ref / head / master dapat diteruskan dengan cepat ke ref / remote / foo / master , output dari

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

harus mengembalikan id SHA1 yang merujuk ke / kepala / master poin. Dengan ini, Anda dapat menyusun skrip yang secara otomatis memperbarui semua cabang lokal yang tidak memiliki komitmen pengalihan yang diterapkan padanya.

Script shell kecil ini (saya menyebutnya git-can-ff ) menggambarkan bagaimana hal itu dapat dilakukan.

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

Untuk menyelesaikan jawaban oleh Matt Connolly, ini adalah cara yang lebih aman untuk memperbarui referensi cabang lokal yang dapat diteruskan dengan cepat, tanpa memeriksa cabang. Itu tidak memperbarui cabang yang tidak dapat diteruskan dengan cepat (yaitu yang telah menyimpang), dan itu tidak memperbarui cabang yang saat ini diperiksa (karena itu copy pekerjaan harus diperbarui juga).

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

Skrip yang sedikit berbeda yang hanya memajukan cabang yang namanya cocok dengan cabang hulu mereka. Ini juga memperbarui cabang saat ini jika fast-forward dimungkinkan.

Pastikan semua cabang hulu cabang Anda disetel dengan benar dengan menjalankan git branch -vv. Atur cabang hulu dengangit branch -u origin/yourbanchname

Salin-tempel ke file dan 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;

Jalur cepat berikut meneruskan semua cabang yang memiliki cabang hulu jika mungkin, dan mencetak kesalahan jika tidak:

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

Bagaimana cara kerjanya?

Ini menggunakan format khusus dengan git branchperintah. Untuk setiap cabang yang memiliki cabang hulu, ia mencetak garis dengan pola berikut:

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

Ini dapat disalurkan langsung ke sh(dengan asumsi bahwa nama-nama cabang terbentuk dengan baik). Abaikan| sh untuk melihat apa yang dilakukannya.

Peringatan

One-liner tidak akan menghubungi remote Anda. Terbitkan git fetchatau git fetch --allsebelum menjalankannya.

Cabang yang keluar saat ini tidak akan diperbarui dengan pesan seperti

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

Untuk ini, Anda bisa menggunakan cara biasa git pull --ff-only.

Alias

Tambahkan berikut ini ke Anda .gitconfigsehingga git fftmelakukan perintah ini:

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

Lihat juga .gitconfig. Alias ​​adalah singkatan untuk "pelacakan maju cepat (cabang)".

Script dari @ larsmans, sedikit membaik:

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

Ini, setelah selesai, membuat copy pekerjaan diperiksa dari cabang yang sama seperti sebelum script dipanggil.

The git pullVersi:

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

Sepertinya banyak orang lain yang menyumbangkan solusi serupa, tetapi saya pikir saya akan membagikan apa yang saya hasilkan dan mengundang orang lain untuk berkontribusi. Solusi ini memiliki keluaran penuh warna yang bagus, dengan anggun menangani direktori kerja Anda saat ini, dan cepat karena tidak melakukan checkout, dan membiarkan direktori kerja Anda tetap aktif. Juga, ini hanyalah skrip shell tanpa dependensi selain git. (hanya diuji pada OSX sejauh ini)

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

Maaf saya juga tampaknya telah datang dengan nama yang sama dengan alat lain di atas.

Ini dapat dilakukan menggunakan skrip di bawah ini ... Pertama-tama akan mengambil semua cabang dan checkout satu per satu dan memperbarui dengan sendirinya.

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

Anda tidak dapat melakukannya dengan hanya satu perintah git tetapi Anda dapat mengotomatiskannya dengan satu garis bash.

Untuk memperbarui semua cabang dengan satu baris dengan aman, inilah yang saya lakukan:

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

• Jika tidak bisa memajukan satu cabang atau menemukan kesalahan, itu akan berhenti dan meninggalkan Anda di cabang itu sehingga Anda dapat mengambil kembali kontrol dan menggabungkan secara manual.

• Jika semua cabang dapat diteruskan dengan cepat, cabang itu akan berakhir dengan cabang tempat Anda berada saat ini, membuat Anda tetap berada di tempat sebelum memperbarui.

Penjelasan:

Untuk keterbacaan yang lebih baik, dapat dibagi menjadi beberapa baris:

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 && ... => Mengambil semua referensi dari semua remote dan melanjutkan dengan perintah berikutnya jika tidak ada kesalahan.

2. git branch | sed '/*/{$q;h;d};$G' | tr -d '*'=> Dari output git branch, sedambil baris dengan a *dan pindahkan ke akhir (sehingga cabang saat ini akan diperbarui terakhir). Kemudian trcukup hapus *.

3. for branch in $(...) ; do git checkout $branch && git merge --ff-only || break ; done=> Untuk setiap nama cabang yang diperoleh dari perintah sebelumnya, checkout cabang ini dan cobalah untuk bergabung dengan fast-forward. Jika gagal, breakdipanggil dan perintah berhenti di sini.

Tentu saja, Anda dapat menggantinya git merge --ff-onlydengan git rebaseapa yang Anda inginkan.

Akhirnya, Anda bisa memasukkannya ke bashrc Anda sebagai alias:

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'

Atau jika Anda takut mengacaukan 'dan ", atau Anda lebih memilih untuk menjaga keterbacaan sintaksis di editor Anda, Anda dapat mendeklarasikannya sebagai fungsi:

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
}

Bonus:

Bagi yang ingin penjelasan pada sed '/*/{$q;h;d};$G'bagian:

• /*/=> Cari baris dengan a *.

• {$q => Jika ada di baris terakhir, keluar (kita tidak perlu melakukan apa-apa karena cabang saat ini sudah yang terakhir dalam daftar).

• ;h;d} => Kalau tidak, simpan baris di buffer terus dan hapus di posisi daftar saat ini.

• ;$G => Ketika mencapai baris terakhir, tambahkan konten buffer penahan.

Bisakah "git pull --all" memperbarui semua cabang lokal saya?

Tidak, tidak bisa. Untuk fast-forwarding, saya hanya menulis alat kecil untuk melakukannya. https://github.com/changyuheng/git-fast-forward-all

Keuntungan alat ini:

1. Mendukung banyak remote dalam satu repositori. (saat hub syncini tidak mendukung beberapa remote.)
2. Mendukung memiliki nama yang berbeda di cabang lokal dan branche pelacakan jarak jauh yang sesuai.
3. Jauh lebih cepat daripada skrip lain yang mengambil remote untuk setiap cabang tunggal.
4. Tidak ada penguraian / pengeditan regex yang rawan kesalahan.

Mulai git 2.9:

git pull --rebase --autostash

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

Secara otomatis membuat simpanan sementara sebelum operasi dimulai, dan menerapkannya setelah operasi berakhir. Ini berarti Anda dapat menjalankan rebase di atas meja kerja yang kotor. Namun, gunakan dengan hati-hati: aplikasi simpanan terakhir setelah rebase yang berhasil dapat mengakibatkan konflik non-sepele.

Bahkan, dengan git version 1.8.3.1, ia berfungsi:

[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

Di cabang utama, Anda dapat memperbarui semua cabang lainnya. @Cascabel

Saya tidak tahu versi mana yang memecah / memperbaikinya, pada 2.17 (yang saya gunakan), ia bisa bekerja.