Comment récupérer toutes les branches Git

J'ai cloné un référentiel Git, qui contient environ cinq branches. Cependant, quand je le fais, git branchje n'en vois qu'un:

$ git branch
* master

Je sais que je peux faire git branch -apour voir toutes les branches, mais comment tirer toutes les branches localement, alors quand je le fais git branch, cela montre ce qui suit?

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

Vous pouvez récupérer toutes les branches de toutes les télécommandes comme ceci:

git fetch --all

C'est essentiellement un mouvement de puissance .

fetchmet à jour les copies locales des succursales distantes, ce qui est toujours sans danger pour vos succursales locales MAIS :

1. fetchne mettra pas à jour les succursales locales (qui suivent les succursales distantes); si vous souhaitez mettre à jour vos succursales locales, vous devez toujours tirer toutes les succursales.

2. fetchne créera pas de branches locales (qui suivent les branches distantes), vous devez le faire manuellement. Si vous souhaitez répertorier toutes les branches distantes: git branch -a

Pour mettre à jour les branches locales qui suivent les branches distantes:

git pull --all

Cependant, cela peut être encore insuffisant. Cela ne fonctionnera que pour vos succursales locales qui suivent les succursales distantes. Pour suivre toutes les branches distantes, exécutez cet oneliner AVANT git pull --all :

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

Version TL; DR

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

(Il semble que pull récupère toutes les branches de toutes les télécommandes, mais je cherche toujours en premier juste pour être sûr.)

Exécutez la première commande uniquement s'il existe des branches distantes sur le serveur qui ne sont pas suivies par vos branches locales.

PS AFAIK git fetch --allet git remote updatesont équivalents.

Commentaire de Kamil Szot , que les gens ont trouvé utile.

J'ai dû utiliser:

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

parce que votre code a créé des branches locales nommées origin/branchnameet que je recevais "refname 'origin / branchname' est ambigu chaque fois que j'y faisais référence.

Pour répertorier les succursales distantes:
git branch -r

Vous pouvez les consulter en tant que succursales locales avec:
git checkout -b LocalName origin/remotebranchname

Vous devrez créer des succursales locales pour suivre les succursales distantes.

En supposant que vous n'ayez qu'une seule télécommande appelée origin, cet extrait de code créera des branches locales pour toutes celles à distance:

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

Après cela, git fetch --allmettra à jour toutes les copies locales des branches distantes.

En outre, git pull --allmettra à jour vos branches de suivi locales, mais en fonction de vos validations locales et de la façon dont l'option de configuration «fusion» est définie, elle peut créer une validation de fusion, une avance rapide ou un échec.

Si tu fais:

git fetch origin

alors ils seront tous là sur place. Si vous effectuez ensuite:

git branch -a

vous les verrez répertoriés comme télécommandes / origine / nom de branche. Puisqu'ils sont là 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 branches sont suivies.

Si ce n'est pas le cas, vous pouvez déclencher ceci dans Bash:

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

Exécutez ensuite la commande.

La forboucle Bash ne fonctionnait pas pour moi, mais cela faisait exactement ce que je voulais. Toutes les branches de mon origine reflétaient localement le même nom.

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

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

Utilisez git fetch && git checkout RemoteBranchName.

Cela fonctionne très bien pour moi ...

Lorsque vous clonez un référentiel, toutes les informations des branches sont réellement téléchargées mais les branches sont masquées. Avec la commande

$ git branch -a

vous pouvez afficher toutes les branches du référentiel, et avec la commande

$ git checkout -b branchname origin/branchname

vous pouvez ensuite les "télécharger" manuellement un par un.

Cependant, il existe un moyen beaucoup plus propre et plus rapide, bien que ce soit un peu compliqué. Pour ce faire, vous avez besoin de trois étapes:

1. Premier pas

   créez un nouveau dossier vide sur votre ordinateur et clonez une copie miroir du dossier .git à partir du référentiel:

   $ 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 à l'intérieur du dossier my_repo_folder est toujours vide, il y a juste un dossier .git caché que vous pouvez voir avec une commande "ls -alt" du terminal.

2. Deuxième étape

   basculez ce référentiel d'un référentiel vide (nu) vers un référentiel normal en basculant la valeur booléenne "bare" des configurations git sur false:

   $ git config --bool core.bare false
   

3. Troisième étape

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

   $ git reset --hard
   

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

C'est la manière rapide dont vous pouvez cloner un référentiel 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.

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

git fetch --all

ou:

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

^{Le --depth=10000paramètre peut aider si vous avez un référentiel superficiel.}

Pour tirer toutes les branches, utilisez:

git pull --all

Si ci-dessus ne fonctionne pas, faites précéder la commande ci-dessus par:

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

car le remote.origin.fetchne pouvait prendre en charge qu'une branche spécifique lors de la récupération, en particulier lorsque vous cloniez votre dépôt avec --single-branch. Vérifiez cela par:git config remote.origin.fetch .

Après cela, vous devriez pouvoir commander n'importe quelle succursale.

Voir également:

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

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

git push --all

éventuellement --mirrorpour refléter toutes les références.

Si votre objectif est de dupliquer un référentiel, voir: Dupliquer un article de référentiel sur GitHub.

J'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

Je pense que vous avez cloné le référentiel en:

git clone https://github.com/pathOfrepository

Maintenant, allez dans ce dossier en utilisant cd:

cd pathOfrepository

Si vous tapez, git statusvous pouvez tout voir:

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

Pour voir tous les types de branche cachés:

 git branch -a

Il répertorie toutes les branches distantes.

Maintenant, si vous souhaitez commander sur une branche particulière, tapez simplement:

git checkout -b localBranchName origin/RemteBranchName

Si vous cherchez ici une solution pour obtenir toutes les branches puis migrer le tout vers un autre serveur Git, j'ai mis en place le processus ci-dessous. Si vous souhaitez 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 $2 " " $1"origin/"$2}' | 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>

Après avoir cloné le référentiel maître, vous pouvez simplement exécuter

git fetch && git checkout <branchname>

Assurez-vous que toutes les branches distantes sont récupérables dans un .git/configfichier.

Dans cet exemple, seule la origin/productionbranche est récupérable, même si vous essayez de ne git fetch --allrien faire, mais récupérer la productionbranche:

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

Cette ligne doit être remplacée par:

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

Exécutez ensuite git fetchetc ...

Le bouclage ne semblait pas fonctionner pour moi et je voulais ignorer origine / master. Voici ce qui a fonctionné pour moi.

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

Après ça:

git fetch --all
git pull --all

Juste ces trois 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

Pourquoi personne ne répond à la question des gars et explique ce qui se passe?

1. Assurez-vous de suivre toutes les branches distantes (ou celles que vous souhaitez suivre) .
2. Mettez à jour vos succursales locales pour refléter les succursales distantes.

Suivez toutes les succursales distantes:

Suivez toutes les branches qui existent dans le référentiel distant.

Faites-le manuellement:

Vous devez remplacer <branch>par une branche qui est affichée à partir de la sortie de git branch -r.

git branch -r
git branch --track <branch>

Faites-le avec un script bash

for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done

Mettez à jour les informations sur les succursales distantes sur votre ordinateur local:

Cela récupère les mises à jour sur les branches du référentiel distant que vous suivez dans votre référentiel local. Cela ne modifie pas vos succursales locales. Votre dépôt git local est maintenant au courant des événements qui se sont produits sur les succursales de dépôt distantes. Un exemple serait qu'un nouveau commit a été poussé vers le maître distant, faire une extraction vous avertira maintenant que votre maître local est en retard de 1 commit.

git fetch --all

Mettez à jour les informations sur les succursales distantes sur votre ordinateur local et mettez à jour les succursales locales:

Effectue une extraction suivie d'une fusion pour toutes les branches de la branche distante vers la branche locale. Un exemple serait qu'un nouveau commit a été poussé vers le maître distant, faire un pull mettra à jour votre référentiel local sur les changements dans la branche distante puis il fusionnera ces changements dans votre branche locale. Cela peut créer beaucoup de dégâts en raison de conflits de fusion.

git pull --all

J'ai écrit un petit script pour gérer le clonage d'un nouveau dépôt et créer des branches locales 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 .\(.*\).\.\.\./\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

Pour l'utiliser, copiez-le simplement 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 de suivi locales pour toutes les branches distantes.

Comment récupérer toutes les branches Git en suivant une seule télécommande.

Cela a été testé et fonctionne sur Red Hat et Git Bash sur Windows 10.

TLDR:

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Explication:

La doublure vérifie puis récupère toutes les branches sauf HEAD.

Répertoriez les branches de suivi à distance.

git branch -r

Ignorez HEAD.

grep -v ' -> '

Retirez le nom de la branche de la ou des télécommandes.

cut -d"/" -f2

Vérifiez toutes les succursales qui suivent une seule télécommande.

git checkout $branch

Récupérer pour la branche extraite.

git fetch

Techniquement, l'extraction n'est pas nécessaire pour les nouvelles succursales locales.

Cela peut être utilisé soit pour fetchoupull succursales qui sont toutes les deux nouvelles et qui ont des changements dans les télécommandes.

Assurez-vous de ne tirer que si vous êtes prêt à fusionner.

Configuration du test

Découvrez un référentiel avec l'URL SSH.

git clone git@repository.git

Avant

Vérifiez les succursales locales.

$ git branch
* master

Exécuter des commandes

Exécutez le liner.

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Après

Vérifiez que les succursales locales incluent les succursales distantes.

$ git branch
  cicd
  master
* preprod

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

Voici quelque chose que je considérerais comme robuste:

• Ne met pas à jour le suivi à distance pour les succursales existantes
• N'essaye pas de mettre HEADà jour pour suivreorigin/HEAD
• Autorise les télécommandes nommées autrement que origin
• Coquille 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 --allpasser à -allpour git pullpasser cette option à l'interne fetch.

Merci à cette réponse .

Voici une version Perl du one-liner fournie dans la réponse acceptée:

git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file

Vous pouvez exécuter le fichier de sortie en tant que script Shell si vous le souhaitez.

Nous avons supprimé notre référentiel de projets Stash par accident. Heureusement, quelqu'un avait créé une fourchette juste avant la perte accidentelle. J'ai cloné la fourchette à mon local (j'oublierai les détails de la façon dont j'ai fait ça). Une fois que j'ai eu la fourche complètement dans mon local, j'ai couru un one-liner. J'ai modifié l'URL de la télécommande (origine dans mon cas) pour pointer vers le référentiel cible vers lequel nous récupérons:

git remote set-url origin <remote-url>

Et finalement poussé toutes les branches à l'origine comme ceci:

git push --all origin

et nous étions de retour dans les affaires.

Nous pouvons mettre tous les noms de branches ou de balises dans un fichier temporaire, puis faire git pull pour chaque nom / balise:

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

Si vous avez des problèmes avec fetch --allalors suivez votre branche distante:

git checkout --track origin/%branchname%

Pour éviter le message d'erreur 'fatal: une branche nommée' origin / master 'existe déjà.', Vous avez besoin de ceci:

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

Sur la base de 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\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

A fonctionné pour moi mais je ne peux pas savoir que cela fonctionnera pour vous. Faites attention.

git remote add origin https://yourBitbucketLink

git fetch origin

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

Maintenant, localement, votre yourNewLocalBranchNameest votre requiredRemoteBranch.

Pour les utilisateurs de Visual Studio, sur la console du gestionnaire de packages:

branche git | % {git fetch en amont; git merge upstream / master}

J'ai essayé de nombreuses façons, seule celle-ci est simple et fonctionne pour moi.

for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
  git checkout "$branch"
  git pull
done

Définir l'alias: (basé sur la première réponse)

git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'

Maintenant, pour suivre toutes les branches:

git track-all-branches