web-dev-qa-db-fra.com

Comment aller chercher toutes les branches de Git

J'ai cloné un référentiel Git, qui contient environ cinq branches. Cependant, quand je fais git branch je ne vois qu’un d’eux:

$ git branch
* master

Je sais que je peux faire git branch -a pour voir toutes les branches, mais comment puis-je extraire toutes les branches localement afin que lorsque je fais git branch, il affiche ce qui suit?

$ git branch
* master
* staging
* etc...
gitbranchgit-branch
1277
David542

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

git fetch --all

C'est fondamentalement un mouvement de puissance .

fetch met à jour les copies locales des branches distantes afin que cela soit toujours sûr pour vos branches locales MAIS:

  1. fetch ne mettra pas à jour les branches locales (qui suivent à distance branches); si vous voulez mettre à jour vos branches locales, vous devez toujours tirer chaque branche.

  2. fetch ne créera pas branches locales (qui suivront à distance branches), 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 branches locales qui suivent les branches distantes. Pour suivre toutes les branches distantes, exécutez cette ligne AVANTgit 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 va chercher toutes les branches de toutes les télécommandes, mais je vais toujours chercher 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.

P.S. AFAIK git fetch --all et git remote update sont équivalents.

Kamil Szot's commentaire , que les gens ont trouvé utile.

Je devais 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/branchname et que je devenais "refname 'Origin/branchname" est ambigu à chaque fois que j'y faisais référence.

1723
Wookie88

Pour lister les branches distantes:
git branch -r

Vous pouvez les vérifier en tant qu’agences locales avec:
git checkout -b LocalName Origin/remotebranchname

607
Learath2

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 créera des branches locales pour toutes les opérations de suivi à distance:

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.

De plus, git pull --all mettra à jour vos branches de suivi locales, mais en fonction de vos validations locales et de la définition de l'option de configuration de "fusion", il pourrait en résulter une validation de fusion, une avance rapide ou un échec.

178
Michael Renner

Si tu fais:

git fetch Origin

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

git branch -a

vous les verrez listés comme télécommandes/origine/nom de branche. Comme ils sont là localement, vous pouvez faire 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
108
GoZoner
$ 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

Puis lancez la commande.

60
Johnno Nolan

La boucle Bash for ne fonctionnait pas pour moi, mais cela correspondait exactement à ce que je voulais. Toutes les branches de mon origine sont reflétées localement sous 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 faire cela sur un serveur Jenkins qui le laisse en mode tête détachée.

47
Tim Lum

Utilisez git fetch && git checkout RemoteBranchName.

Cela fonctionne très bien pour moi ...

45
Regis Zaleman

Lorsque vous clonez un référentiel, toutes les informations des branches sont effectivement téléchargées, mais les branches sont masquées. À 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 à la fois.

Cependant, il existe un moyen beaucoup plus propre et rapide, bien que ce soit un peu compliqué. Vous avez besoin de trois étapes pour y parvenir:

  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 référentiel local dans le dossier my_repo_folder est toujours vide, il ne reste plus qu'un dossier .git caché que vous pouvez voir avec une commande "ls -alt" depuis le terminal.

  2. Deuxième étape

    basculez ce référentiel d'un référentiel vide 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

    Prenez tout ce qui se trouve dans le dossier en cours et créez toutes les branches sur la machine locale, ce qui en fait un référentiel 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 le moyen rapide par lequel vous pouvez cloner un référentiel git avec toutes les branches en même temps, mais ce n'est pas quelque chose que vous voulez faire pour chaque projet de cette manière.

32
FedericoCapaldo

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

git fetch --all

ou:

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

Le paramètre --depth=10000 peut vous aider si vous avez un référentiel peu profond.

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/*'

en tant que remote.Origin.fetch ne peut prendre en charge qu'une branche spécifique lors de la récupération, en particulier lorsque vous clonez votre référentiel avec --single-branch. Vérifiez ceci par: git config remote.Origin.fetch.

Après cela, vous devriez pouvoir vérifier n'importe quelle branche.

Voir également:

Pour envoyer toutes les branches à la télécommande, utilisez:

git Push --all

éventuellement --mirror pour refléter toutes les références.

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

25
kenorb

D'habitude, je n'utilise rien d'autre que des commandes comme celle-ci:

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

Une petite version plus courte:

git fetch Origin
git checkout -t Origin/remote-branch
24
marioosh

Je crois 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 status, vous pouvez voir tous:

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

Pour voir tous les types de branches cachées:

 git branch -a

Il listera toutes les branches distantes.

Maintenant, si vous voulez utiliser une branche particulière, tapez:

git checkout -b localBranchName Origin/RemteBranchName
15
Abhinav bhardwaj

Si vous êtes ici à la recherche d'une solution pour obtenir toutes les branches, puis tout migrer vers un autre serveur Git, je mets ensemble le processus ci-dessous. Si vous souhaitez simplement que toutes les branches soient mises à jour 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>
14
ingyhere

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

git fetch && git checkout <branchname>
12
Davidacce

La boucle ne semble pas fonctionner pour moi et je voulais ignorer Origin/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
9
poxion

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 exploitable, même si vous essayez de faire git fetch --all rien ne se passera que si vous extrayez la branche production:

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

Cette ligne devrait être remplacée par:

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

Puis lancez git fetch etc ...

9
Ahmad

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
7
Izabela Skibinska

J'ai écrit un petit script pour gérer le clonage d'un nouveau dépôt et la création de 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 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.

4
tstone2077

Comment extraire toutes les branches Git en suivant une seule télécommande.

Cela a été testé et fonctionne sur Red Hat et Git Bash sous 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épertorie les branches de suivi à distance.

git branch -r

Ignorer HEAD.

grep -v ' -> '

Prenez le nom de la branche de la (des) télécommande (s).

cut -d"/" -f2

Commander toutes les branches qui suivent une seule télécommande.

git checkout $branch

Récupérer une branche extraite.

git fetch

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

Ceci peut être utilisé pour fetch ou pull branches qui sont à la fois nouvelles et dont les modifications ont été modifiées.

Assurez-vous simplement que vous ne tirez que si vous êtes prêt à fusionner.

Configuration du test

Extraire un référentiel avec une URL SSH.

git clone [email protected]

Avant

Vérifiez les branches dans les locaux.

$ git branch
* master

Execute Commandes

Exécutez la doublure.

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

Après

Vérifiez les branches locales incluent les branches distantes.

$ git branch
  cicd
  master
* preprod
3
Greg Weigner

Voici quelque chose que je considérerais robuste:

  • Ne met pas à jour le suivi à distance pour les branches existantes
  • N'essaie pas de mettre à jour HEAD pour suivre Origin/HEAD
  • Autorise les télécommandes nommées autres que Origin
  • Correctement cité
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 car le fait de passer -all à git pull passe cette option à la variable interne fetch.

Crédit à cette réponse .

3
Tom Hale

Voici une version Perl de la ligne unique 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 projet Stash par accident. Heureusement, quelqu'un avait créé une fourchette juste avant la perte accidentelle. J'ai cloné la fourche à mon local (omettra les détails de la façon dont j'ai fait cela). Une fois que j'ai eu la fourchette à fond dans ma section locale, j'ai utilisé une ligne. J'ai modifié l'URL de la télécommande (Origin dans mon cas) pour pointer vers le référentiel cible vers lequel nous étions en train de nous restaurer:

git remote set-url Origin <remote-url>

Et finalement poussé toutes les branches vers Origin comme suit:

git Push --all Origin

et nous étions de retour dans les affaires.

2
Jose Quijada

Pour les utilisateurs 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
2
kiewic

Nous pouvons mettre tous les noms de branches ou de tags dans un fichier temporaire, puis git pull pour chaque nom/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
1
anhlc

Pour éviter le message d'erreur 'irrécupérable: une branche nommée' Origine/maître 'existe déjà.', Vous en avez besoin:

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

Si vous avez des problèmes avec fetch --all, suivez votre succursale distante:

git checkout --track Origin/%branchname%
1
open-ecommerce.org

Pour les utilisateurs de Visual Studio, console On Package Manager:

branche git | % {git chercher en amont; fusionner en amont/maître}

0
Jose Ortega

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

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

Travaillé pour moi mais je ne peux pas savoir que ça fonctionnera pour vous. Faites attention.

0
erikano

J'ai essayé de nombreuses manières, 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
0
PageNotFound
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.

0
chhotu sardar