Comment récupérer toutes les branches Git


1508

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...

1
Également discuté sur stackoverflow.com/questions/67699/…
gliptak

2
Cette question montre comment obtenir toutes les branches après avoir utilisé le --single-branchparamètre lors du clonage: stackoverflow.com/questions/17714159/… ( git fetch --allne fonctionnera jamais si vous n'avez spécifié qu'une seule branche!)
Matthew Wilcoxson

2
Vous ne verrez jamais cette sortie car l'astérisque représente la branche en cours d'extraction. Étant donné que vous ne pouvez extraire qu'une seule succursale à la fois, vous ne pouvez avoir qu'un seul astérisque à gauche de votre liste de succursales.
Robino

5
J'ai vu beaucoup de réponses, mais aucune d'entre elles n'a mentionné ce que je pense être probablement le moyen le plus simple de faire ce que vous voulez: git clone --bare <repo url> .git (remarquez que vous devez ajouter "--bare" et ".git" à la fin pour cloner le dépôt en tant que "nu" repo), puis git config --bool core.bare false(positionne le drapeau "nu" sur false), puis git reset --hard(déplace le HEAD sur le HEAD actuel du repo). Maintenant, si vous git branchvoyez toutes les branches du dépôt que vous avez cloné.
Gabriel Ferraz

4
@GabrielFerraz Ensuite, vous abusez de la fonctionnalité de commentaire sur Stack Overflow. Les utilisateurs peuvent voter pour votre commentaire mais pas pour le faire.
pipe

Réponses:


2052

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.


42
Désolé. Je ne peux pas imaginer que c'est ce que le PO souhaite réellement. La commande «pull» est «fetch + merge» et la partie de fusion superposera toutes les branches les unes sur les autres - laissant un désordre géant.
GoZoner

10
cette extraction ne créerait pas une nouvelle branche distante, vous devez toujours la vérifier avecgit checkout -b localname remotename/remotebranch
Learath2

125
Je devais l'utiliser for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done parce que votre code créait des branches locales nommées origine / nom de branche et que je recevais "refname 'origine / nom de branche" est ambigu chaque fois que j'y faisais référence.
Kamil Szot

22
Je ne sais pas si j'utilise une version différente de GIT, mais j'ai dû modifier le script en git pull --all; for remote in `git branch -r | grep -v \>`; do git branch --track ${remote#origin/} $remote; done. Le changement supprime HEAD.
kim3er

16
Pour les gens de Windows:for /F %remote in ('git branch -r') do ( git branch --track %remote) && git fetch --all && git pull --all
Max

719

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


88
C'est exactement ce que je cherchais lorsque j'ai trouvé la question ci-dessus. Je soupçonne que beaucoup de gens qui cherchent à extraire une branche distante ne veulent certainement pas fusionner la branche dans leur copie de travail actuelle, mais ils veulent une branche locale identique à la distante.
Frug

12
Même si la branche n'est pas visible localement, je peux le faire git checkout remotebranchnameet ça marche. quelle est la différence avec votre solution?
François Romain

12
Son comportement par défaut maintenant. Ce n'était pas le cas sur les anciennes versions de git. L' utilisation git checkout remotebranchnameutilisé pour simplement créer une nouvelle sans rapport avec la branche qui est nommé remotebranchname .
Learath2

12
La réponse acceptée fait quelque chose de fondamentalement différent et pour être franc, je ne comprends même pas pourquoi c'est la réponse acceptée
Learath2

8
Le PO a demandé toutes les succursales. Cette réponse ne fait qu'un.
Ted Bigham

193

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.


5
Cela renforce la solution contre les noms de branche contenant des métacaractères shell (comme le commentaire de pinkeen sur l'autre réponse), et évite la sortie d'erreur parasite: git branch -r | grep -v - '->' | pendant la lecture à distance; do git branch --track "$ {remote # origin /}" "$ remote" 2> & 1 | grep -v 'existe déjà'; fait
Daira Hopwood

6
Voulez-vous vraiment git pull --allmettre à jour toutes les succursales de suivi locales? Pour autant que je sache, il ne met à jour que la branche actuelle de toutes les télécommandes.
Andy

3
A fait ça. Aucune branche locale correspondant à une branche distante n'a été créée. Quelle est la commande git qui dit simplement "tirer toutes les branches distantes en créant des branches locales si elles n'existent pas?"
JosephK

@JosephK votre télécommande n'est peut-être pas appelée origin? Voir cette réponse qui fonctionnera sur tous les noms distants.
Tom Hale

@TomHale C'était "origine", mais merci pour votre réponse - bien que fou, il en faut beaucoup pour faire ce qui devrait être un ou peut-être deux drapeaux. J'essaye maintenant de gitless, pour essayer d'éviter la folie de certains aspects de git.
JosephK

116

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

5
Je viens de trouver cette page sur google ... c'était le type de réponse que je cherchais. J'ai essayé la première commande mais j'ai reçu une erreur: [$ git fetch --all origin fatal: fetch --all ne prend pas d'argument de référentiel] --- L'utilisation de "git fetch --all" semble faire l'affaire. Merci pour l'exemple!
longda

1
Corrigé (éliminé --all)
GoZoner

12
git fetch -allrécupère toutes les branches de toutes les télécommandes. git fetch originrécupère toutes les branches de la télécommande origin. Le dernier est ce que le PO demandait.
GoZoner

3
--allsignifie "toutes les télécommandes", pas "toutes les branches d'une télécommande donnée". Cette dernière est impliquée par toute extraction depuis une télécommande.
spacediver

2
Ce n'est pas la façon de tirer toutes les branches dans le référentiel local, à partir du référentiel distant.
Vladimir Despotovic

69
$ 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.


3
Lorsque j'essaie, j'obtiens toujours le même résultat que ci-dessus.
David542

4
Identique à @JacobLowe, j'ai eu l'erreur, mais cela a quand même fonctionné; 'fatal: une branche nommée' origin / master 'existe déjà.'
AnneTheAgile

C'est moche car il essaiera de créer une branche pour ->laquelle existera probablement dans la sortie de git branch -r`origin / HEAD -> origin / master`
Tom Hale

De plus, cela ne fonctionne pas. J'obtiens la sortie: Branch 'origin/quote-filenames' set up to track local branch 'master'. La sortie souhaitée est: Branch 'quote-filenames' set up to track remote branch 'quote-filenames' from 'origin'. C'est à l' envers , en définissant l'origine pour suivre la télécommande. Voir cette réponse pour un correctif.
Tom Hale du

juste ce dont j'avais besoin. Depuis que j'ai changé de Mac, même après avoir cloné le dépôt, je n'ai pas pu vérifier les autres succursales distantes et git fetchne fonctionnerais pas. Donc, la leçon ici est que vous devez suivre les branches distantes. Gracias!
Victor Ramos

58

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.


6
Cela produit fatal: Refusing to fetch into current branch refs/heads/master of non-bare repositoryaprès un simple clone. Doit détacher la tête en premier. Je l'ai fait avecgit checkout <SHA>
brannerchinese

6
Ma solution en utilisant c'est git checkout --detach # detach the headet ensuitegit fetch origin \'+refs/heads/*:refs/heads/*
Mike DuPont

1
Celui-ci a fonctionné pour moi, sauf que j'utilise également le paramètre --tags. Je souhaite qu'il y ait un frontal simple et standard pour git, le nombre de choses simples dans git qui ont besoin de plus de 10 réponses de débordement de pile est ridicule!
kristianp

1
@kristianp Avez-vous vérifié Ungit ou GitKraken?
dragon788

@ dragon788 J'utilise SourceTree pour une interface graphique git, mais je parlais vraiment d'une ligne de commande plus simple pour les tâches de script.
kristianp

51

Utilisez git fetch && git checkout RemoteBranchName.

Cela fonctionne très bien pour moi ...


6
C'est la nouvelle meilleure réponse, vous tous. Je ne sais pas si cela n'était pas possible auparavant, mais les versions récentes de Git au moins remarqueront que vous essayez de retirer une branche distante et configurera automatiquement la branche de suivi locale pour vous (et vous n'avez pas besoin préciser origin/branch; il suffit de dire seulement branch).
Neil Traft

9
Cela ne répond pas à la question d'origine: "Comment tirer toutes les branches localement?" Il les tire un par un, ce qui n'est pas évolutif.
ingyhere

Ce fut la seule réponse qui m'a permis de tirer des succursales à distance dans toutes les situations que j'ai rencontrées
Emmanuel Buckshi

38

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.


1
A voté pour la mention des branches cachées. m'a beaucoup aidé à comprendre le suivi des succursales locales.
mburke05

C'est une bonne réponse, mais la question implique quelque chose pour une utilisation quotidienne. Ce n'est pas pratique de cloner le référentiel à chaque fois.
Z. Khullah

Pourquoi la réinitialisation crée toutes les branches localement?
Z. Khullah

@ Z.Khullah ce n'est pas la réinitialisation qui crée toutes les branches, mais le clone --mirror. Malheureusement pour nous, cela crée également un repo nu, ce qui change les étapes 2 et 3.
ScottJ

29

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:


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.


1
Génial ... J'ai essayé tout le reste avant votre solution dans cette page. Merci beaucoup!
Sujoy

2
J'ai utilisé le clonage peu profond ( depth=1) et la configuration a également spécifié une branche spécifique pour fetch- le depth=1000paramètre était le correctif qui m'a aidé à extraire une branche distante spécifique
Sandra

2
pull --allne tire pas toutes les branches, mais toutes les télécommandes
Z. Khullah

Belle astuce avec la config! Je les chercherais tous, tout le temps
Z. Khullah

J'ai vérifié la configuration comme vous l'avez écrit, ne fonctionne toujours qu'avec la branche actuelle. On dirait que toutes les réponses ici ne fonctionnent pas pour moi ...
Alexei Martianov

25

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

17

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

16

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>

3
Très utile; exactement ce dont j'avais besoin. La seule chose que j'ai dû changer était dans la deuxième ligne, a ajouté des guillemets simples autour de «HEAD» et «master»; probablement parce que j'utilise zsh. Merci!
sockmonk

Cela consiste essentiellement à: (1) obtenir les noms réels des branches distantes [pas tête, pas maître]; (2) Dire complètement à Git de les suivre [toutes les solutions ne le font pas]; (3) Récupérer et extraire tout de ces branches [y compris les balises]; (4) Fixer une nouvelle origine et marcher en poussant absolument tout. Encore une fois, la plupart des autres solutions ne parviennent pas à déplacer toutes les pièces. Cela fait tout.
ingyhere

1
J'ai supprimé l'antipattern de l'exécution de grep puis awk et condensé les commandes grep dans la commande awk. Merci tripleee !
ingyhere

Lisez ceci et n'écrivez jamais git fetch git pull stackoverflow.com/a/292359/1114926
Vert

Git pullfait en effet une fetchpremière mais il est plus facile de dire si le problème vient de la fetchpartie pullou de la mergepartie suivante de pullquand fetchest exécuté indépendamment.
ingyhere

12

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

git fetch && git checkout <branchname>

1
Facile. et travaillé pour obtenir une succursale d'origine éloignée
sirvon

3
Cela ne répond pas à la question d'origine: "Comment tirer toutes les branches localement?" Il les tire un par un, ce qui n'est pas évolutif. Prenons le cas de 100 succursales.
ingyhere

10

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 ...


3
Pour inspecter: git config --get remote.origin.fetchpuis pour (destructivement) le régler:git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'
qneill

ou modifier le fichier texte de configuration dans le répertoire .git, a fonctionné pour moi
FDIM

9

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

1
Une variation de ceci est la bonne réponse, mais celle-ci ne fonctionne pas dans tous les cas extrêmes. De plus, les noms de branche peuvent être géniaux. J'ai donc fait ce qui suit: git branch -r | grep -v HEAD | grep –v master | awk -F'origin / '' {print $ 2 "" $ 1 "origin /" $ 2} '| xargs -L 1 git branch -f --track; git fetch --all; git pull --all; ET C'EST FAIT LE TRUC!
ingyhere

3
Une amélioration stylistique pour éviter la grep | awk antimodèle : git branch -r | awk -F 'origin/' '!/HEAD|master/{...
tripleee

7

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

C'est en fait la racine du problème d'OP. S'il était bien cloné, il n'aurait pas besoin d'en faire un pull --all. Mais si toujours nécessaire, l'autre réponse ci-dessous, par @Johnno Nola, en supposant que toutes les branches sont suivies, mélangées à cette réponse, est la voie à suivre.
Dr Beco

7

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

4

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.


4

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

4

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

Cela fonctionne avec des branches avec / dans le nom: 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" } }
Markus

3

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 .


2

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.


1

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

1

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

git checkout --track origin/%branchname%

1

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

0

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.


0
git remote add origin https://yourBitbucketLink

git fetch origin

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

Maintenant, localement, votre yourNewLocalBranchNameest votre requiredRemoteBranch.


0

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

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


0

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

0

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.