branch branch - Come recuperare tutti i rami Git




create list (21)

Possiamo mettere tutti i nomi di branch o tag in un file temporaneo, quindi fare git pull per ogni nome / tag:

git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done

Ho clonato un repository Git, che contiene circa cinque rami. Tuttavia, quando faccio git branch ne vedo solo uno:

$ git branch
* master

So che posso fare git branch -a per vedere tutti i rami, ma come faccio a tirare tutti i rami localmente quindi quando faccio git branch , mostra quanto segue?

$ git branch
* master
* staging
* etc...

Basato sulla risposta di Learath2, ecco cosa ho fatto dopo aver fatto git clone [...] e cd -ing nella directory creata:

git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

Ha funzionato per me ma non posso sapere che funzionerà per te. Stai attento.


Puoi prelevare un ramo da tutti i telecomandi come questo:

git fetch --all

fetch aggiornamenti copie locali di filiali remote, quindi questo è sempre sicuro per le filiali locali MA :

  1. fetch non aggiornerà i rami locali (che tracciano i rami remoti); Se si desidera aggiornare le filiali locali, è comunque necessario prelevare tutte le filiali.

  2. fetch non creerà rami locali (che tracciano rami remoti), devi farlo manualmente. Se si desidera elencare tutti i rami remoti: git branch -a

Per aggiornare i rami locali che tengono traccia dei rami remoti:

git pull --all

Tuttavia, questo può essere ancora insufficiente. Funzionerà solo per le filiali locali che monitorano i rami remoti. Per tenere traccia di tutti i rami remoti, esegui questo oneliner PRIMA di git pull --all :

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

TL, versione DR

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

(sembra che pull recuperi tutti i rami da tutti i telecomandi, ma prendo sempre il primo per essere sicuro)

Esegui il primo comando solo se sul server sono presenti rami remoti non tracciati dalle filiali locali.

PS AFAIK git fetch --all e git remote update sono equivalenti.

Il comment Kamil Szot, che 74 (almeno) persone hanno trovato utile.

Ho dovuto usare:

for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done

perché il tuo codice ha creato rami locali di nome origin/branchname nome origin/branchname e stavo ottenendo "refname" origine / nome-ramo "è ambiguo ogni volta che ho fatto riferimento ad esso.


Ho scritto un piccolo script per gestire la clonazione di un nuovo repository e creare filiali locali per tutte le filiali remote.

Puoi trovare l'ultima versione here :

#!/bin/bash

# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)

clone_output=$((git clone "[email protected]" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
    exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1
this_branch=$(git branch | sed 's/^..//')
for i in $(git branch -r | grep -v HEAD); do
  branch=$(echo $i | perl -pe 's/^.*?\///')
  # this doesn't have to be done for each branch, but that's how I did it.
  remote=$(echo $i | sed 's/\/.*//')
  if [[ "$this_branch" != "$branch" ]]; then
      git branch -t $branch $remote/$branch
  fi
done
popd > /dev/null 2>&1

Per usarlo, copialo nella tua directory git bin (per me, questo è C:\Program Files (x86)\Git\bin\git-cloneall ), quindi, sulla riga di comando:

git cloneall [standard-clone-options] <url>

Clona come al solito, ma crea rami di localizzazione locali per tutte le filiali remote.


Ecco qualcosa che considererei robusto:

  • Non aggiorna il tracciamento remoto per i rami esistenti
  • Non tenta di aggiornare HEAD per tracciare l' origin/HEAD
  • Consente telecomandi denominati diversi origin
  • Correttamente shell quotata
for b in $(git branch -r --format='%(refname:short)'); do
  [[ "${b#*/}" = HEAD ]] && continue
  git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all

Non è necessario git fetch --all come passaggio -all a git pull passa questa opzione al fetch interno.

Credito a questa risposta


Il bash for loop non funzionava per me, ma questo ha fatto esattamente quello che volevo. Tutti i rami dalla mia origine sono stati replicati come lo stesso nome localmente.

git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'

Modificato: vedi il commento di Mike DuPont sotto. Penso che stavo cercando di farlo su un server Jenkins che lo lascia in modalità staccata.


Credo che tu abbia clonato il repository di

git clone https://github.com/pathOfrepository

ora vai in quella cartella usando cd

cd pathOfrepository

se si digita git status

puoi vedere tutto

   On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean

per vedere tutto il tipo di ramo nascosto

 git branch -a

elencherà tutto il ramo remoto

ora se vuoi effettuare il checkout su un particolare ramo, digita semplicemente

git checkout -b localBranchName origin/RemteBranchName

Dovrai creare filiali locali per il monitoraggio dei rami remoti.

Supponendo di avere una sola origin chiamata remota, questo snippet creerà rami locali per tutti quelli di monitoraggio remoto:

for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done

Dopodiché, git fetch --all aggiornerà tutte le copie locali dei rami remoti.

Inoltre, git pull --all aggiornerà i tuoi rami di localizzazione locali, ma a seconda dei commit locali e di come è impostata l'opzione di configurazione 'unione' potrebbe creare un merge commit, fast forward o fail.


Looping non sembrava funzionare per me e volevo ignorare origin / master. Ecco cosa ha funzionato per me.

git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track

Dopo di che:

git fetch --all
git pull --all

Per gli utenti Windows che utilizzano PowerShell:

git branch -r | ForEach-Object {
    # Skip default branch, this script assumes
    # you already checked-out that branch when cloned the repo
    if (-not ($_ -match " -> ")) {
        $localBranch = ($_ -replace "^.*/", "")
        $remoteBranch = $_.Trim()
        git branch --track "$localBranch" "$remoteBranch"
    }
}
git fetch --all
git pull --all

Puoi recuperare tutti i rami per:

git fetch --all

o:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

Il parametro --depth=10000 può essere d'aiuto se hai un repository non --depth=10000 .

Per tirare tutti i rami, usa:

git pull --all

Se sopra non funzionerà, quindi precedere il comando precedente con:

git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

come remote.origin.fetch potrebbe supportare solo un ramo specifico durante il recupero, specialmente quando hai clonato il tuo repository con --single-branch . Controlla questo: git config remote.origin.fetch .

Dopodiché dovresti essere in grado di effettuare il checkout di qualsiasi filiale.

Guarda anche:

  • Come recuperare tutti i rami remoti?
  • Come clonare tutte le filiali remote in Git?

Per spostare tutti i rami sul telecomando, utilizzare:

git push --all

alla fine --mirror per rispecchiare tutti i ref.

Se il tuo obiettivo è duplicare un repository, consulta: Duplicazione di un articolo di repository su GitHub.


Se hai problemi con il recupero --all

quindi traccia il tuo ramo remoto

git checkout --track origine /% branchname%


Dopo aver clonato il repository principale, puoi eseguirlo

git fetch && git checkout <branchname>

Se fate:

git fetch origin

allora saranno tutti lì a livello locale. Se poi esegui:

git branch -a

li vedrai elencati come telecomandi / origine / nome-ramo. Dal momento che sono lì localmente puoi fare quello che vuoi con loro. Per esempio:

git diff origin/branch-name 

o

git merge origin/branch-name

o

git checkout -b some-branch origin/branch-name

Per elencare i rami remoti:
git branch -r

Puoi verificarli come filiali locali con:
git checkout -b LocalName origin/remotebranchname


Assicurati che tutte le diramazioni remote siano raggiungibili nel file .git/config .

In questo esempio, solo il ramo di origin/production è raggiungibile, anche se si prova a fare git fetch --all non succederà nulla, ma recuperando il ramo di production :

[origin]
fetch = +refs/heads/production:refs/remotes/origin/production

Questa riga deve essere sostituita da:

[origin]
fetch = +refs/heads/*:refs/remotes/origin/*

Quindi esegui git fetch ecc ...


$ git remote update
$ git pull --all

Questo presuppone che tutti i rami siano tracciati.

Se non lo sono, puoi farlo in Bash:

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

Quindi esegui il comando.


Quando cloni un repository tutte le informazioni dei rami vengono effettivamente scaricate ma i rami sono nascosti. Con il comando

$ git branch -a

puoi mostrare tutti i rami del repository e con il comando

$ git checkout -b branchname origin/branchname

è quindi possibile "scaricarli" manualmente uno alla volta.

Tuttavia, c'è un modo molto più pulito e veloce, anche se è un po 'complicato. Hai bisogno di tre passaggi per realizzare questo:

  1. Primo passo

    crea una nuova cartella vuota sul tuo computer e clona una copia speculare della cartella .git dal repository:

    $ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
    $ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git
    

    il repository locale all'interno della cartella my_repo_folder è ancora vuoto, c'è solo una cartella .git nascosta ora che puoi vedere con un comando "ls -alt" dal terminale.

  2. Secondo passo

    commuta questo repository da un repository vuoto (nudo) ad un repository regolare cambiando il valore booleano "bare" delle configurazioni git su false:

    $ git config --bool core.bare false
    
  3. Terzo passo

    Prendi tutto ciò che è all'interno della cartella corrente e crea tutti i rami sulla macchina locale, quindi rendilo un normale repo.

    $ git reset --hard
    

Quindi ora puoi semplicemente digitare il comando git branch e puoi vedere che tutti i rami sono stati scaricati.

Questo è il modo rapido in cui è possibile clonare un repository git con tutti i rami contemporaneamente, ma non è qualcosa che si vuole fare per ogni singolo progetto in questo modo.


git remote add origin https://yourBitbucketLink

git fetch origin

git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

Ora localmente il yourNewLocalBranchName è il yourNewLocalBranchName requiredRemoteBranch .


Usa git fetch && git checkout RemoteBranchName .

Funziona molto bene per me ...


git pull = git fetch + git merge 




git branch git-branch