Comment récupérer toutes les branches Git

J'ai cloné un dépôt Git, qui contient environ cinq branches. Cependant, quand je git branch je ne vois que l'un d'entre eux:

$ git branch
* master

Je sais que je peux faire git branch -a à voir tous les branches, mais comment pourrais-je tirer toutes les branches localement donc quand je fais des git branch, il montre la suite?

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

Également discuté lors de stackoverflow.com/questions/67699/...
Cette question montre comment obtenir toutes les branches après l'utilisation de la --single-branch réglage lorsque le clonage: stackoverflow.com/questions/17714159/... (git fetch --all ne fonctionnera jamais si vous avez spécifié une seule branche!)
Vous ne verrez pas que la sortie jamais, car l'astérisque représente la branche qui est actuellement à la caisse de sortie. Puisque vous ne pouvez avoir qu'une seule branche vérifié à la fois, vous pouvez avoir un seul astérisque sur la gauche de votre branche d'inscription.
Le meilleur classement de réponse ci-dessous rate l'OP de l'intention. Je recommande que vous regardez stackoverflow.com/a/72156/342839 à la place. git checkout -b <branch> semble la réponse la plus probable.
J'ai vu beaucoup de réponses, mais aucun d'entre eux a mentionné, je pense que ce est probablement la façon la plus simple pour faire ce que vous voulez: git clone --bare <repo url> .git (notez que vous devez ajouter "--bare" et ".git" à la fin de cloner le repo comme un "nu" repo), puis git config --bool core.bare false () définit le "nu" drapeau de faux), puis git reset --hard (mouvements de la TÊTE à l'actuel CHEF sur le repo). Maintenant, si vous git branch vous devriez voir toutes les branches de l'opération vous cloné.
Double Possible de Comment cloner toutes les branches distantes dans Git?
Pourquoi ne pas vous écrire cela comme une réponse?
Je pourrais, mais il y a déjà accepté de répondre à 912 upvotes, plus un autre de 20 réponses. Je pense qu'il est plus probable que quelqu'un aurait lu mon commentaire de réponse tout le chemin sur le bas de ce fil. Si vous aimez le commentaire vous pouvez upvote afin que d'autres personnes seraient plus susceptibles de le lire.
Ensuite, vous abusez de la fonctionnalité de commentaires sur un Débordement de Pile. Les utilisateurs peuvent upvote votre commentaire, mais pas downvote.
git fetch origin fera.

InformationsquelleAutor David542 | 2012-04-25

1854

Vous pouvez récupérer toutes les branches de toutes les télécommandes comme ceci:
```
git fetch --all
```
C'est essentiellement un pouvoir se déplacer.

fetch mises à jour des copies locales des branches distantes donc, c'est toujours plus sûr pour vos branches locales MAIS:
1. fetch ne mise à jour branches locales (qui piste branches distantes); si vous souhaitez mettre à jour vos branches locales vous avez encore besoin de tirer sur chaque branche.
2. fetch ne créer branches locales (qui piste branches distantes), vous devez le faire manuellement. Si vous voulez la liste de toutes les branches distantes:
  git branch -a
À mise à jour branches locales qui permettent de suivre à distance des branches:
```
git pull --all
```
Cependant, cela peut être encore insuffisante. Cela ne fonctionne que pour vos branches locales qui permettent de suivre à distance les branches. Pour suivre toutes les branches distantes exécuter cette oneliner AVANT git pull --all:
```
git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
```
TL;DR version
```
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 tirer récupère toutes les branches de toutes les télécommandes, mais j'ai toujours chercher d'abord juste pour être sûr.)

Exécution de la première commande uniquement si il y a des branches distantes sur le serveur qui ne sont pas suivis par vos branches locales.

P. S. autant que je sache git fetch --all et git remote update sont équivalentes.

Kamil Szot de commentaire, qui les gens ont trouvé utile.
J'ai eu à utiliser:
```
for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done
```
parce que votre code créé des branches locales nommé origin/branchname et
J'ai été faire "refname" origine/branchname " est ambigu chaque fois que je
visée à elle.
- Désolé. Je ne peux pas imaginer que c'est ce que l'OP veut réellement. "L'attraction" de la commande est " fetch+de fusion et la fusion une partie sera la superposition de toutes les branches sur le dessus de l'un à l'autre en laissant un énorme gâchis.
- qui extraire ne serait pas de créer une nouvelle branche à distance, vous devez toujours vérifier avec git checkout -b localname remotename/remotebranch
- ne git fetch, extrait des changements de toutes les branches d'un suivi ? ou j'ai besoin d'être sur cette branche que je veux extraire à partir de, et d'autres changements ne seront pas récupérées pour d'autres suivis des branches ? (si cela fait sens)
- J'ai eu à utiliser for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done parce que votre code créé des branches locales nommé d'origine/branchname et je commençais à "refname" origine/branchname " est ambigu chaque fois que j'y ai fait allusion.
- Je ne sais pas si je suis en utilisant une autre version de GIT, mais j'ai dû modifier le script pour git pull --all; for remote in `git branch -r | grep -v \>`; do git branch --track ${remote#origin/} $remote; done. Le changement des bandes de hors de la TÊTE.
- Pour les gens de Windows: for /F %remote in ('git branch -r') do ( git branch --track %remote) && git fetch --all && git pull --all
- Cela ne fonctionne pas pour ma version de git: 1.8.1.2 L'effet a été de créer une dizaine de branches nommé "origine/$x" qui ont tous le suivi de la branche locale de "maître".
- Il y a une légère différence entre git fetch --all et git remote update Première est que git fetch --tout a été ajoutée dans la v1.6.6. Deuxième fetch --tout va tirer de tous à distance de repos. voir le commit 9c4a036b3 sur github. github.com/git/git/commit/...
- La solution de @kim3er a fonctionné pour moi. Le problème avec tous les extraits, c'est qu'ils ne fonctionnent pas lorsque vous avez des barres obliques ou des espaces dans les noms de branche. Lorsque vous devez écrire à l'épreuve des balles scripts bash, vous devez utiliser le while read truc comme cela git branch -r | while read remote; do git branch --track "${remote#origin/}" "$remote"; d et devis de la variable extensions!
- eu à faire un petit tweak for /F %r in ('git branch -r') do ( git branch --track %r) && git fetch --all && git pull --all
- Il crée des branches avec 'origine/'
- Veuillez mettre à jour votre réponse avec les commentaires. Il est trompeur et crée des branches avec origin/
- J'ai eu un problème avec la sortie de la couleur dans mon terminal pour les différents git branch -r commandes pour trouver toutes les différentes branches. Utilisation git branch -r --no-color d'empêcher non valide les noms de branche sur les bornes de soutenir des codes de couleur.
- git pull --all juste ne fait rien: "Vous a demandé de se retirer de la distance '--tous", mais ne précise pas une branche"
- Stupide pour exécuter la commande avant de vérifier les commentaires, j'ai cru à l'accepter marque et les upvotes ... stupide. Maintenant supprimer les pensions de titres et de cloner à partir de zéro.
- J'ai corrigé la réponse que par les commentaires, comme je l'ai été gravement brûlé par cela aussi. Nous allons voir comment il va.
- n'est-ce pas fetch --all destiné à extraire toutes les télécommandes? au moins, il ne fonctionne pas pour moi (ne pas chercher de nouvelles branches distantes)
- git pull seulement se fondre dans la branche courante, même avec --all. Afin de ne pas mettre à jour d'autres le suivi des branches à côté.
- récupérer toutes les télécommandes n'est pas la même que la récupération de toutes les branches. La plupart des gens n'ont qu'une seule télécommande (origine), afin de fetch --tous fait rarement quelque chose de différent.
- exactement pourquoi j' demande, puisque la question était d'aller chercher toutes les branches, pas toutes les télécommandes!
- mon script Powershell pour la mise à jour de toutes les nouvelles sans traces branches et en les tirant: git branch -r | grep -v "\->" | foreach {git branch --track $_.Substring($_.IndexOf("/") + 1)}; git pull --all
- Quant à "il semble que tirer récupère toutes les branches...". C'est pratiquement sur la couverture de tout git manuel de tirer un fetch/fusion. Pourquoi ne pas vous le confirmer et supprimer les parenthèses deviner? Pourriez jeter dans un mentionnez que vous pouvez configurer "pull" à "récupérer rebase".
- La question était très claire: pour rapporter les cinq branches d'une distance, de ne pas chercher une branche de cinq télécommandes. Je ne comprends pas comment cette réponse a été acceptée.
- Cette variation exclut suivi branches et branche master : for remote in $(git branch -r | grep -v -e "\->" -e master); do git branch --track ${remote#origin/} $remote; done
- Encore une fois va vous montrer comment hostiles Git en ligne de commande interface est à l'égard de ses utilisateurs. Et il va montrer que Git n'a jamais été conçu avec la croix-plate-forme à l'esprit, comme en témoigne le ridicule utilisation des commandes shell, qui va bien sûr varier par shell. Étant à l'origine un mélange de exécutables binaires et des scripts shell, le public cible est claire et n'a jamais changé. Même près de 13 ans depuis leur publication initiale.
- Lisez ce qui suit et ne jamais les écrire et de proposer d'autres git fetch suivie par git pull " stackoverflow.com/a/292359/1114926
- git fetch --all et git remote update sont presque les mêmes. Cependant, git remote update par défaut récupère la distance spécifiée par remotes.default. Si ce n'est pas définie (qui, je crois, par défaut, il n'est pas), alors il va chercher tous les. Préférable d'utiliser git fetch --all que son comportement est cohérent.
- Est-il possible d'avoir un git alias pour un liner? Si je l'ai mis dans mon .gitconfig fichier j'obtiens un "fatal: mauvaise config de la ligne X"
- Je suis en train de faire la même chose, git config --global alias.fa 'branch -r | grep -v ">" | while read remote; do git branch --track "${remote#origin/}" "$remote"; done' ne suffit d'afficher git branch définition de commande
- À titre occasionnel les utilisateurs de Git, cette réponse était juste un peu trop avancé pour moi. J'ai vraiment apprécié la distinction de son auteur essayait de faire, mais les détails ont été perdus sur moi. Pour une personne comme moi, le Atlassian Git Tutoriel sur la git fetch, explique l'arrière-plan de l'information vraiment très bien, alors maintenant, cette réponse fait sens pour moi. +1!
- Pas de traction est nécessaire de mettre à jour suivi branches. Il pourrait être fait par le biais de l'indice de mise à jour. Au moins nous parvenir par git fetch origin master:master, par exemple. Cela permet de mettre à jour l'index, sans vérification de branches.
InformationsquelleAutor Wookie88
646

À la liste des branches distantes:

git branch -r

Vous pouvez vérifier que les sections locales avec:

git checkout -b LocalName origin/remotebranchname
- C'est exactement ce que je cherchais quand j'ai trouvé la question ci-dessus. Je pense que beaucoup de gens cherchent la façon de tirer une branche distante ne voulez certainement pas à la fusion de la direction de dans leur de la copie de travail, mais ils ne veulent d'une branche locale identique à la distance.
- Même si la branche n'est pas visible en local, je peux faire git checkout remotebranchnameet il fonctionne. quelle est la différence avec votre solution?
- Son comportement par défaut maintenant. N'était pas le cas sur les anciennes versions git. À l'aide de git checkout remotebranchname utilisé pour créer un nouveau sans rapport avec branche qui est nommé remotebranchname.
- c'est la réponse correcte. La accepté de répondre ne fonctionne pas
- La accepté de répondre à n'quelque chose de fondamentalement différent et pour être franc, je ne comprends même pas pourquoi le son a accepté de répondre à
- L'OP a demandé pour toutes les branches. Cette réponse ne fait qu'une seule.
- C'est parfait pour une branche à la fois. Juste si quelqu'un peut le modifier avec la commande nouveau (mais le vieux est encore à travailler 😉
- Cela ne répond pas à la question de départ: "Comment pourrais-je tirer toutes les branches au niveau local?" C'est en tirant un par un, ce qui n'est pas évolutive.
- Un co-travailleur créé une branche et fait une PR. J'ai été chargé de la mise à jour de la PR et d'avoir des problèmes de vérification de la branche à distance avec son travail sur ma machine locale. Cette solution a fonctionné pour moi. Merci!!!!
- simple et sobre
- fatal: Cannot update paths and switch to branch 'develop' at the same time. Did you intend to checkout 'origin/temp' which can not be resolved as commit?.C'est le résultat quand je lance réponse script, quel est le problème?
- Pas mon script, idk. Laisser un commentaire sous la réponse?
- Que faire si je veux fusionner, de ne pas valider la commande? git checkout -b LocalName origin/remotebranchname
- Fusion de quoi? Une branche distante?
- Je pense que la question principale est écrit comment récupérer toutes les branches git, pas un seul, un par un, peut-être, par conséquent, ce n'est pas la réponse sélectionnée
InformationsquelleAutor Learath2
185

Vous aurez besoin pour créer des branches locales de suivi à distance des branches.

En supposant que vous avez un seul distant appelé origin, cet extrait de code va créer des branches pour tous à distance de suivi:
```
for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done
```
Après, git fetch --all sera mise à jour toutes les copies locales des branches distantes.

Aussi, git pull --all mise à jour de votre local de suivi des branches, mais en fonction de votre région s'engage et comment les "fusionner" option de configuration est défini, il pourrait créer une fusion de commettre, l'avance rapide ou échouer.
- Cette robustifies la solution contre les noms de branche contenant shell métacaractères (comme par pinkeen commentaire sur l'autre réponse), et évite les parasites de l'erreur de sortie: git branch-r | grep -v -- '-> " | while read distance; ne git branch --piste "${distance#origine/}" "$distance" 2>,&1 | grep -v 'existe déjà'; done
- Êtes-vous sûr que git pull --all sera mise à jour tous les locaux de suivi des branches? Aussi loin que je peux dire c'uniquement les mises à jour de la branche courante de toutes les télécommandes.
- Fait cela. Les branches locales de correspondance à distance les branches n'ont pas été créés. Qu'est-ce que la commande git qui dit simplement "tirer toutes les branches distantes de la création locale, et si elles n'existent pas?"
- peut-être que votre télécommande n'est pas appelé origin? Voir cette réponse qui fonctionne sur tous les noms distants.
- Il a été "origine", mais merci pour votre réponse - si fou que la quantité est nécessaire de faire ce qui devrait être un ou peut-être deux drapeaux. Je suis maintenant essayer gitless, pour essayer d'éviter la folie de certains aspects de git.
InformationsquelleAutor Michael Renner
112

Si vous n':
```
git fetch origin
```
ils seront tous là, à l'échelle locale. Si vous effectuez ensuite:
```
git branch -a
```
vous verrez répertorié comme remotes/origin/branche-nom. Depuis qu'ils y sont, localement, vous pouvez faire ce que vous s'il vous plaît avec eux. Par exemple:
```
git diff origin/branch-name 
```
ou
```
git merge origin/branch-name
```
ou
```
git checkout -b some-branch origin/branch-name
```
- Viens de trouver cette page sur google... c'est le genre de réponse que je cherchais. J'ai essayé la première commande, mais reçu un message d'erreur: [$ git fetch --toutes origines fatale: fetch --tous ne prenez pas un référentiel argument] --- à l'Aide de "git fetch --tous" semble faire l'affaire. Merci pour la conduire!
- Fixe (éliminé --all)
- git fetch -all récupère toutes les branches de toutes les télécommandes. git fetch origin récupère toutes les branches de la télécommande origin. Le plus tard est ce que l'OP a été demandé.
- --all signifie "toutes les télécommandes", pas "toutes les branches de l'un à distance". Ce dernier est sous-entendu par toute extraction à partir d'une télécommande.
- OP demandé de trouver une solution permettant de "branche", pas de "branch-un".
- Ce n'est pas la façon de tirer toutes les branches locales de pensions, de distance repo.
- En fait, j'ai un cas où l'un des clones référentiel manquait un peu (non fusionné) les branches, et votre solution de ne pas ajouter le manque de branches. git branch -r affiche, cependant.
InformationsquelleAutor GoZoner
65
```
$ git remote update
$ git pull --all
```
Cela suppose que toutes les branches sont suivis.

Si ils ne sont pas vous pouvez mettre le feu à cette Bash:
```
for remote in `git branch -r `; do git branch --track $remote; done
```
Puis exécuter la commande.
- Quand j'ai essayer ce que j'ai toujours obtenir le même résultat que ci-dessus.
- Même chose que @JacobLowe, j'ai obtenu l'erreur, mais il a travaillé de toute façon; fatale: Une branche nommée 'origin/master' existe déjà.'
- C'est laid comme il va essayer de créer une branche pour -> qui existent dans la sortie de git branch -r comme " origine/TÊTE -> origin/master`
- En outre, il ne fonctionne pas. Je reçois de sortie: Branch 'origin/quote-filenames' set up to track local branch 'master'. La sortie désirée est: Branch 'quote-filenames' set up to track remote branch 'quote-filenames' from 'origin'. C'est arrière, la définition de l'origine de la piste de la télécommande. Voir cette réponse pour un correctif.
- juste ce dont j'avais besoin. Depuis j'ai changé de Mac, même après que j'ai cloné le repo je n'ai pas pu commander d'autres branches distantes et git fetch ne fonctionnerait pas. Donc la leçon ici est que vous avez besoin pour le suivi à distance des branches. Gracias!
InformationsquelleAutor Johnno Nolan
53

Le Bash for boucle ne fonctionnait pas pour moi, mais ce n'est exactement ce que je voulais. Toutes les branches de mon origine en miroir le même nom localement.
```
git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'
```
Voir Mike DuPonts'commentaire ci-dessous. Je pense que j'essayais de le faire sur un Serveur Jenkins qui laisse dans décollement de la mode.
- Qui produit fatal: Refusing to fetch into current branch refs/heads/master of non-bare repository après un simple clone. Ont pour détacher la tête la première. Je l'ai fait avec git checkout <SHA>
- Ma Solution à l'aide c'est git checkout --detach # detach the head et puis git fetch origin \'+refs/heads/*:refs/heads/*
- Cette une a fonctionné pour moi, sauf que moi j'ai utiliser l'option --tags paramètre. Je souhaite qu'il y ait un standard, simple frontal pour git, le nombre de choses simples dans git qui ont besoin de 10-plus d'un débordement de pile réponses, c'est ridicule!
- Avez-vous vérifié Ungit ou GitKraken?
- J'ai été en utilisant SourceTree pour un git GUI, mais j'ai été vraiment parler d'une simple ligne de commande pour des tâches de script.
- ahh, je reçois de vous. Vous pourriez regarder quelque chose comme easygit, people.gnome.org/~newren/eg
- Vous pouvez aussi probablement faire un git clone <repo_URI> .git juste l'installation d'un nu-pensions sans contenu. Ensuite, exécutez l'OPs de commande: git fetch origin '+refs/heads/*:refs/heads/*.
- peut-être essayer ungit - la philosophie est exactement ce que vous avez mentionné!
- C'est la seule réponse qui fonctionne même lorsque remote.<remote>.fetch est un paramètre restrictive.
InformationsquelleAutor Tim Lum
49

Utilisation git fetch && git checkout RemoteBranchName.

Il fonctionne très bien pour moi...
- C'est la nouvelle meilleure réponse, y'all. Je ne sais pas si peut-être que ce n'était pas possible avant, mais les dernières versions de Git au moins remarquerez que vous essayez de commander une branche à distance et de configurer automatiquement les locaux de suivi de la branche pour vous (et vous n'avez pas besoin de spécifier origin/branch; il suffit de dire seulement branch).
- Cela ne répond pas à la question de départ: "Comment pourrais-je tirer toutes les branches au niveau local?" C'est en tirant un par un, ce qui n'est pas évolutive.
- C'était la seule réponse qui m'a permis de tirer à distance des succursales dans toutes les situations que j'ai rencontrées
InformationsquelleAutor Regis Zaleman
34

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 est beaucoup plus propre et plus rapide, mais c'est un peu compliqué. Vous avez besoin de trois étapes à suivre:
1. Première étape
  
  créer un nouveau dossier vide sur votre machine et de cloner une copie miroir de l' .git dossier à 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 à l'intérieur du dossier my_repo_folder est toujours vide, il est juste caché .git dossier maintenant que vous pouvez le voir avec un "ls -alt" commande dans le terminal.
2. Deuxième étape
  
  commutateur de ce référentiel à partir d'un vide (nu) dépôt régulier de dépôt par la commutation de la valeur booléenne "nu" de la git configurations de faux:
```
$ git config --bool core.bare false
```
3. Troisième Étape
  
  Saisir tout ce qui à l'intérieur du dossier et de créer toutes les branches sur la machine locale, donc ce qui en fait un normal des pensions.
```
$ 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és.

C'est le moyen rapide dans 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 pour chaque projet de cette manière.
- Upvoted pour la mention de caché branches. m'a aidé à comprendre la branche locale de suivi immensément.
- Ses une bonne réponse, mais la question implique quelque chose pour chaque utilisation de jour. Ses pas pratique pour cloner le dépôt à chaque fois.
- Pourquoi la réinitialisation crée toutes les branches localement?
- ce n'est pas le reset qui crée toutes les branches, mais le clone --miroir. Malheureusement pour nous, qui crée également un nu-repo, qui est ce que les étapes 2 et 3 de changement.
InformationsquelleAutor FedericoCapaldo
26

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 --depth=10000 paramètre peut aider si vous avez shallowed référentiel.}

De tirer toutes les branches, à l'utilisation:
```
git pull --all
```
Si ci-dessus ne fonctionne pas, alors précéder la commande ci-dessus avec:
```
git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'
```
comme le remote.origin.fetch pourrait soutenir qu'une seule branche lors de l'extraction, en particulier lorsque vous cloné votre repo avec --single-branch. Cochez cette par: git config remote.origin.fetch.

Après cela, vous devriez être en mesure d'extraire n'importe quel branche.

Voir aussi:
- Comment récupérer toutes les branches distantes?
- Comment cloner toutes les branches de Git?
À pousser toutes les branches de la télécommande, utilisez:
```
git push --all
```
finalement --mirror à miroir de tous les refs.

Si votre but est de reproduire un référentiel, voir: La duplication d'un référentiel article sur GitHub.
- Génial...j'ai essayé tout le reste avant que votre solution dans cette page. Merci beaucoup!
- J'ai utilisé peu profonde clonage (depth=1) et la config aussi spécifié d'une branche spécifique pour fetch - le depth=1000 paramètre a été le correctif qui m'a aidé à passer à la caisse un distant spécifique de la branche
- pull --all ne tirez pas sur toutes les branches, mais toutes les télécommandes
- Tour de Nice avec la config, si! Allait chercher tous, tout le temps
- J'ai vérifié la config comme vous l'avez écrit, encore ne fonctionne qu'avec la branche courante. Ressemble à toutes les réponses ici ne fonctionnent pas pour moi...
InformationsquelleAutor kenorb
24

J'ai l'habitude de l'utiliser rien d'autre que des commandes comme ceci:
```
git fetch origin
git checkout --track origin/remote-branch
```
Un peu plus courte version:
```
git fetch origin
git checkout -t origin/remote-branch
```
InformationsquelleAutor marioosh
16

Je crois que vous avez cloné le dépôt par:
```
git clone https://github.com/pathOfrepository
```
Maintenant, allez dans ce dossier à l'aide de 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 types:
```
 git branch -a
```
Il fournira la liste de tous les à distance des branches.

Maintenant, si vous voulez à la caisse sur une branche particulière, tapez simplement:
```
git checkout -b localBranchName origin/RemteBranchName
```
InformationsquelleAutor Abhinav bhardwaj
14

Si vous êtes ici à la recherche d'une solution pour obtenir toutes les branches et puis tout migrer vers un autre serveur Git, j'ai mis en place les étapes ci-dessous. Si vous voulez juste pour obtenir toutes les branches de mise à jour localement, s'arrêter à 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>
```
- Très utile; exactement ce dont j'avais besoin. La seule chose que j'ai eu de changement est dans la deuxième ligne, ajouté des guillemets simples autour de la "TÊTE" et "maître"; sans doute parce que j'utilise zsh. Merci!
- C'est essentiellement faire ce qui suit: (1) Obtenir les noms réels des branches distantes [pas de tête, pas de master]; (2) tout à fait dire à Git pour la piste [pas toutes les solutions de ce]; (3) la récupération et en tirant à tout de ces branches [y compris les balises]; (4) la fixation d'un nouveau point d'origine et la marche à travers poussant absolument tout. Encore une fois, la plupart des autres solutions de ne pas déplacer toutes les pièces. De ce fait tout.
- J'ai enlevé le antipattern de l'exécution de la commande grep puis awk et condensé de l'grep commandes dans la commande awk. Merci tripleee!
- Lisez ce qui suit et ne jamais écrire git fetch git pull stackoverflow.com/a/292359/1114926
- Git pull, en effet, faire un fetch d'abord, mais il est plus facile de dire si le problème est à partir de la fetch partie de pull ou de la merge partie de pull quand fetch est exécutée indépendamment.
InformationsquelleAutor ingyhere
12

Après le clonage de l'référentiel maître, vous ne pouvez exécuter
```
git fetch && git checkout <branchname>
```
- simple. et travaillé pour obtenir une succursale de la télécommande d'origine
- Cela ne répond pas à la question de départ: "Comment pourrais-je tirer toutes les branches au niveau local?" C'est en tirant un par un, ce qui n'est pas évolutive. Prenons le cas de 100 succursales.
InformationsquelleAutor Davidacce
10

Assurez-vous que toutes les branches distantes sont fetchable dans .git/config fichier.

Dans cet exemple, seul le origin/production branche est fetchable, même si vous essayez de faire git fetch --all rien ne se passera, mais l'extraction de l' production branche:
```
[origin]
fetch = +refs/heads/production:refs/remotes/origin/production
```
Cette ligne doit être remplacé par:
```
[origin]
fetch = +refs/heads/*:refs/remotes/origin/*
```
Puis exécutez git fetch etc...
- Inspecter: git config --get remote.origin.fetch et ensuite (destructive) mis: git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'
- ou modifier le fichier texte de configuration dans .répertoire git, a fonctionné pour moi
InformationsquelleAutor Ahmad
9

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 que:
```
git fetch --all
git pull --all
```
- Une variante de cette réponse est la bonne, mais celui-ci ne fonctionne pas dans tous les cas de bord. Aussi, les noms de branche peut être funky. J'ai donc fait la suivante: git branch-r | grep -v de la TÊTE | grep –v maître | awk -F'origin/' '{print $2 ""$1"origine/"$2}' | xargs -L 1 git branch-f --piste ; git fetch --tous ; git pull --tous ; ET QUI a FAIT LE tour!
- Un style d'amélioration pour éviter la grep | awk antipattern: git branch -r | awk -F 'origin/' '!/HEAD|master/{ ...
InformationsquelleAutor poxion
6

Seulement ces trois commandes permet d'obtenir 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 de l'OP du problème. Si cloné à droite, il n'aurait pas besoin de faire un pull --all. Mais si encore nécessaire, puis l'autre réponse ci-dessous, par @Johnno Nola, en supposant que toutes les branches sont suivis, mélangé avec cette réponse, c'est la manière d'aller.
InformationsquelleAutor Izabela Skibinska

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

À utiliser, il suffit de le copier dans votre git répertoire 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>

Elle clones comme d'habitude, mais crée local de suivi des branches pour toutes les branches distantes.

InformationsquelleAutor tstone2077

3

Voici quelque chose que je voudrais examiner robuste:
- N'a pas de mise à jour de suivi à distance pour les branches
- N'essayez pas de mettre à jour HEAD pour suivre origin/HEAD
- Permet télécommandes nommée autres que origin
- Correctement shell 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 en passant -all à git pull passe cette option à l'intérieur de la fetch.

De crédit à cette réponse.

InformationsquelleAutor Tom Hale
3

Comment Récupérer Toutes les Branches Git Suivi 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:

L'un liner vérifie et extrait toutes les branches, sauf la TÊTE.

Liste la distance de suivi des branches.
```
git branch -r
```
Ignorer la TÊTE.
```
grep -v ' -> '
```
Prendre le nom de la branche off de la télécommande(s).
```
cut -d"/" -f2
```
Checkout toutes les branches de suivi d'une seule télécommande.
```
git checkout $branch
```
Chercher pour l'extrait de la branche.
```
git fetch
```
Techniquement, l'extraction n'est pas nécessaire pour de nouvelles branches locales.

Ce peut être utilisée soit pour fetch ou pull les branches qui sont à la fois nouveaux et des changements de distance(s).

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

Configuration De Test

Découvrez un référentiel avec SSH URL.
```
git clone [email protected]
```
Avant

Vérifier branches locales.
```
$ git branch
* master
```
Exécuter Des Commandes

Exécuter le un paquebot.
```
for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;
```
Après

Vérifier les branches d'activité à distance(s) branches.
```
$ git branch
  cicd
  master
* preprod
```
InformationsquelleAutor Greg Weigner
2

Pour les utilisateurs de Windows à l'aide de 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" } }
InformationsquelleAutor kiewic
2

Voici un Perl version de la one-liner fourni dans l'acceptation réponse:

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 comme un script Shell si vous le souhaitez.

Nous avons supprimé de notre Cachette de dépôt de projet par accident. Heureusement que quelqu'un avait créé une fourchette juste avant la perte accidentelle. J'ai cloné la fourche à mon local (va omettre les détails de la façon dont je l'ai fait). Une fois que j'ai eu la fourche entièrement dans mon local, j'ai couru un one-liner. J'ai modifié la distance de l'URL (l'origine dans mon cas) pour pointer vers le référentiel cible, nous avons été récupérer à:

git remote set-url origin <remote-url>

Et enfin poussé toutes les branches à l'origine de la sorte:

git push --all origin

et nous étions de retour dans les affaires.

InformationsquelleAutor Jose Quijada

Nous pouvons mettre de la succursale ou de noms de balise dans un fichier temporaire, puis faire la commande 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

InformationsquelleAutor anhlc

1

Si vous avez des problèmes avec fetch --all puis le suivi de votre branche distante:
```
git checkout --track origin/%branchname%
```
InformationsquelleAutor open-ecommerce.org

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

InformationsquelleAutor HaxtraZ

0

En fonction de la réponse par 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

Travaillé pour moi, mais je ne peux pas savoir, il va travailler pour vous. Être prudent.

InformationsquelleAutor erikano

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.

InformationsquelleAutor chhotu sardar

0

Pour aux Utilisateurs de Visual Studio, Sur la console du Gestionnaire de Package:

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

InformationsquelleAutor

Ont essayé de nombreuses façons, que 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

InformationsquelleAutor PageNotFound

0

git fetch --all

En utilisant ce commentaire vous pouvez récupérer le code de toutes les branches d'activité qui vous ont ajouté à distance référentiel

InformationsquelleAutor Ananth Kumar

Vous devez vous connecter pour publier un commentaire.

TL;DR version

Comment Récupérer Toutes les Branches Git Suivi Seule Télécommande.

Configuration De Test