Comment récupérer toutes les branches Git

pour lister les branches distantes:

git branch -r

vous pouvez les vérifier en tant que succursales locales avec:

git checkout -b LocalName origin/remotebranchname

vous aurez besoin de créer des branches locales en traçant les branches distantes.

en supposant que vous n'avez qu'une seule télécommande appelée origin , cet extrait va créer des branches locales pour toutes les télécommandes de suivi:

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

après cela, git fetch --all mettra à jour toutes les copies locales des branches distantes.

aussi, git pull --all mettra à jour vos branches de suivi locales, mais en fonction de votre l'option configure' merge ' est définie.elle peut créer une propagation de la fusion, une progression rapide ou un échec.

si vous le faites:

git fetch origin

alors ils seront tous là-bas localement. Si vous exécutez alors:

git branch -a

vous les verrez listés comme remotes/origin/branch-name. Puisqu'ils sont là-bas localement, vous pouvez faire tout ce que vous voulez avec eux. Par exemple:

git diff origin/branch-name 

ou

git merge origin/branch-name

ou

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

$ git remote update
$ git pull --all

cela suppose que toutes les succursales sont suivies.

si ce n'est pas le cas, vous pouvez tirer à Bash:

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

lancez la commande.

utiliser git fetch && git checkout RemoteBranchName .

ça marche très bien pour moi...

le bash pour loop ne marchait pas pour moi, mais ça a fait exactement ce que je voulais. Toutes les branches de mon origine mirrored comme le même nom localement.

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

Édité: Voir Mike DuPont commentaire ci-dessous. Je pense que j'essayais de faire ça sur un serveur Jenkins qui le laisse en mode tête détachée.

Lorsque vous clonez un dépôt, toutes les informations de branches est effectivement téléchargé mais les branches sont cachés. Avec la commande

$ git branch -a

, vous pouvez afficher toutes les branches du dépôt, et avec la commande

$ git checkout -b branchname origin/branchname

vous pouvez ensuite "télécharger" manuellement un à un.

cependant, il y a un moyen beaucoup plus propre et plus rapide, bien que ce soit un peu compliqué. Vous il faut trois étapes pour y parvenir:

1. premier pas

   créez un nouveau dossier vide sur votre machine et clonez une copie miroir du .dossier git du dépôt:

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

   le dépôt local dans le dossier my_repo_folder est toujours vide, il n'y a qu'un dépôt caché .dossier git maintenant que vous pouvez voir avec une commande "ls-alt" depuis le terminal.

2. Deuxième étape

   basculer ce dépôt d'un dépôt vide (nu) vers un dépôt régulier en changeant la valeur booléenne "bare" des configurations git en false:

   $ git config --bool core.bare false
   

3. Troisième Étape

   saisissez tout ce qui se trouve dans le dossier courant et créez toutes les branches de la machine locale, ce qui en fait un repo normal.

   $ git reset --hard
   

Alors maintenant, vous pouvez tapez la commande git branch et vous pouvez voir que toutes les branches sont téléchargés.

C'est le moyen rapide par lequel vous pouvez cloner un dépôt git avec toutes les branches à la fois, mais ce n'est pas quelque chose que vous voulez faire pour chaque projet de cette façon.

Je n'utilise habituellement rien d'autre que des commandes comme celle-ci:

git fetch origin
git checkout --track origin/remote-branch

une version un peu plus courte:

git fetch origin
git checkout -t origin/remote-branch

, Vous pouvez récupérer toutes les branches:

git fetch --all

ou:

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

^{le paramètre --depth=10000 peut vous être utile si vous avez un dépôt peu profond.}

pour tirer toutes les branches, utilisez:

git pull --all

Si ci-dessus ne fonctionne pas, alors précédez la commande ci-dessus avec:

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

comme le remote.origin.fetch pourrait soutenir seulement une branche spécifique tout en fetching, surtout quand vous cloné votre pension avec --single-branch . Vérifier cela par: git config remote.origin.fetch .

après cela, vous devriez être en mesure de vérifier n'importe quelle succursale.

voir aussi:

• Comment récupérer toutes les branches distantes?
• comment cloner toutes les branches distantes en Git?

pour pousser toutes les branches vers la télécommande, utilisez:

git push --all

finalement --mirror miroir de tous les refs.

si votre but est de dupliquer un dépôt, voir: duplication d'un dépôt article sur GitHub.

si vous êtes ici à la recherche d'une solution pour obtenir toutes les branches et ensuite tout migrer vers un autre serveur Git, j'ai mis en place le processus ci-dessous. Si vous voulez simplement mettre à jour toutes les branches localement, arrêtez-vous à la première ligne vide.

git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F'origin/' '!/HEAD|master/{print  " " "origin/"}' | xargs -L 1 git branch -f --track 
git fetch --all --prune --tags
git pull --all

git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>

je crois que vous avez cloner le dépôt par

git clone https://github.com/pathOfrepository

maintenant, allez dans ce dossier en utilisant cd

cd pathOfrepository

si vous tapez git status

vous pouvez voir tous les

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

pour voir tous cachés de la branche de type

 git branch -a

il énumérera toute la branche distante

maintenant si vous voulez vérifier sur une branche particulière tapez juste

git checkout -b localBranchName origin/RemteBranchName

après avoir cloné le dépôt principal, vous pouvez juste exécuter

git fetch && git checkout <branchname>

assurez-vous que toutes les branches distantes sont récupérables dans le fichier .git/config .

dans cet exemple, seule la branche origin/production est récupérable, même si vous essayez de faire git fetch --all il ne se passera rien d'autre que de récupérer la branche production :

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

cette ligne doit être remplacée par:

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

puis exécuter git fetch etc...

Looping ne semblait pas fonctionner pour moi et je voulais ignorer origine/maître. Voici ce qui a fonctionné pour moi.

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

après cela:

git fetch --all
git pull --all

juste ces 3 commandes obtiendront toutes les branches

git clone --mirror repo.git  .git     (gets just .git  - bare repository)

git config --bool core.bare false         

git reset --hard                  

j'ai écrit un petit script pour gérer le clonage d'un nouveau repo et les branches pour toutes les branches distantes.

vous pouvez trouver la dernière version ici :

#!/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 "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
    exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\.//') > /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

pour l'utiliser, Copiez-le dans votre répertoire git bin (pour moi, c'est C:\Program Files (x86)\Git\bin\git-cloneall ), puis, sur la ligne de commande:

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

il clone comme d'habitude, mais crée des branches locales de suivi pour toutes les branches distantes.

pour les utilisateurs de Windows utilisant 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

nous pouvons mettre tous les noms de branche ou d'étiquette dans un fichier temporaire, puis faire git pull pour chaque nom / étiquette:

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

voici quelque chose que je considérerais comme robuste:

• N'a pas de mise à jour de suivi à distance pour les branches
• N'essaie pas de mettre à jour HEAD pour suivre origin/HEAD
• permet les télécommandes nommées autrement que origin
• coque correctement Citée

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

il n'est pas nécessaire de git fetch --all comme passer -all à git pull passes cette option à l'interne fetch .

Crédit cette réponse .

basé sur la réponse de Learath2, voici ce que j'ai fait après avoir fait git clone [...] et cd - ing dans le répertoire créé:

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

a marché pour moi, mais je ne sais pas si ça marchera pour toi. Être prudent.

git remote add origin https://yourBitbucketLink

git fetch origin

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

Maintenant localement votre yourNewLocalBranchName est votre requiredRemoteBranch .