si vous avez beaucoup de branches éloignées que vous voulez récupérer à la fois, faites:

$ git pull --all

Maintenant vous pouvez vérifier n'importe quelle branche comme vous le DEVEZ, sans frapper le dépôt distant.

Ce Bash script m'a aidé:

#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"
done

il va créer des branches de suivi pour toutes les branches distantes, sauf master (que vous avez probablement obtenu de la commande originale clone). Je pense que vous pourriez encore avoir besoin de faire un

git fetch --all
git pull --all

pour être sûr.

One liner : git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{}) {print qq(git branch --track /\n)} else {$d{$_}=1}' | csh -xfs Comme d'habitude: test de votre installation avant de copier rm-rf univers tel que nous le le savoir

crédits pour monocouche aller à l'utilisateur cfi

utilisant l'option --mirror semble copier correctement les branches de suivi remote . Cependant, il configure le dépôt comme un dépôt nu, vous devez donc le transformer en un dépôt normal par la suite.

git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch

^{référence: git FAQ: comment cloner un dépôt avec toutes les branches suivies à distance?}

vous pouvez facilement passer à une branche sans utiliser la syntaxe fantaisiste" git checkout-b somebranch origin/somebranch". Vous pouvez simplement faire:

git checkout somebranch

git fera automatiquement la bonne chose:

$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'

Git va vérifier si une branche avec le même nom existe dans exactement une distance, et si il ne, il suit de la même manière que si vous aviez spécifié explicitement que c'est une branche distante. De la page de manuel git-checkout de Git 1.8.2.1:

si n'est pas trouvé mais qu'il existe une branche de suivi dans exactement une télécommande (l'appeler < remote>) avec un nom correspondant, traiter comme équivalent à

$ git checkout -b <branch> --track <remote>/<branch>

concernant,

$ git checkout -b expérimentale origine/expérimental

utilisant

$ git checkout -t origin/experimental

ou le plus verbeux, mais plus facile à retenir

$ git checkout --track origin/experimental

peut-être mieux, en termes de suivi d'un dépôt distant.

le fetch que vous faites devrait obtenir toutes les branches éloignées, mais il ne créera pas de branches locales pour eux. Si vous utilisez gitk, vous devriez voir les branches distantes décrites comme "remotes/origin/dev" ou quelque chose de similaire.

De créer une branche locale basée sur une branche distante, faire quelque chose comme:

git checkout -b dev refs/remotes/origin/dev

qui devrait retourner quelque chose comme:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "dev"

maintenant, quand vous êtes sur la branche dev, " git pull" mettra à jour votre dev local au même point que la branche dev distante. Notez qu'il récupère toutes les branches, mais seulement tirer la une vous êtes sur le haut de l'arbre.

quand vous faites "git clone git: / / location", toutes les branches et étiquettes sont récupérées.

afin de travailler au-dessus d'une branche distante spécifique, en supposant que c'est l'origine distante:

git checkout -b branch origin/branchname

utiliser des alias. Bien qu'il n'y ait pas de Git one-liners natifs, vous pouvez définir votre propre comme

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'

et l'utiliser comme

git clone-branches

ce n'est pas trop compliqué, très simple et les étapes simples sont les suivantes;

git fetch origin cela amènera toutes les branches éloignées à votre local.

git branch -a cela vous montrera toutes les branches éloignées.

git checkout --track origin/<branch you want to checkout>

Vérifier si vous êtes dans la branche désirée par la commande suivante;

git branch

, La sortie sera comme ceci;

*your current branch 
some branch2
some branch3 

Notez le signe * qui indique la succursale actuelle.

Pourquoi vous ne voyez que "maître",

git clone télécharge toutes les branches distantes mais les considère toujours comme" distantes", même si les fichiers se trouvent dans votre nouveau dépôt. Il y a une exception à cela, qui est que le processus de Clonage crée une branche locale appelée "master" à partir de la branche distante appelée "master". Par défaut, git branch affiche uniquement les branches locales, c'est pourquoi vous ne voyez que "maître".

git branch -a montre tous branches, , y compris les branches éloignées .

Comment obtenir des succursales locales

si vous voulez réellement travailler sur une branche, vous voudrez probablement une version" locale " de celle-ci. Pour créer simplement des branches locales à partir des branches distantes (sans les vérifier et donc changer le contenu de votre répertoire de travail) , vous pouvez faire comme ceci:

git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree

dans cet exemple, branchone est le nom d'une branche locale que vous créez à partir de origin/branchone ; si vous voulez créer des branches locales avec des noms différents, vous pouvez le faire:

git branch localbranchname origin/branchone

une fois que vous avez créé une branche locale, vous pouvez la voir avec git branch (rappelez-vous, vous n'avez pas besoin de -a pour voir les branches locales).

mieux vaut tard que jamais, Mais voici la meilleure façon de le faire:

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

à ce point vous avez une copie complète de la prise en pension à distance avec toutes ses branches (vérifier avec git branch ). Vous pouvez utiliser --mirror au lieu de --bare si votre système de mise à distance dispose de ses propres télécommandes.

faites Simplement ceci:

$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
  master
$ git branch -a
* branchxyz
  master
  remotes/origin/HEAD -> origin/master
  remotes/origin/branchxyz
  remotes/origin/branch123

You see, 'git clone git://example.com / myprojectt ' récupère tout, même les branches, il suffit de les vérifier, puis votre branche locale sera créée.

il suffit d'utiliser" git clone " pour obtenir toutes les branches.

git clone <your_http_url>

même si vous ne voyez que la branche principale, vous pouvez utiliser" branche git-a " pour voir toutes les branches.

git branch -a

Et vous pouvez changer la direction que vous avez déjà.

git checkout <your_branch_name>

ne vous inquiétez pas qu'après vous "git clone", vous n'avez pas besoin de se connecter avec le repo à distance, "git branch-A" et "git checkout" peut être exécuté avec succès lorsque vous fermer votre connexion wifi. Il est donc prouvé que lorsque vous faites "git clone", il a déjà copié toutes les branches à partir du repo distant. Après cela, vous n'avez plus besoin du repo distant, votre local a déjà tous les codes des branches.

A git clone est supposé copier le dépôt entier. Essayez de le cloner, puis lancez git branch -a . Il devrait énumérer toutes les branches. Si vous voulez alors passer à la branche "foo" au lieu de "master", utilisez git checkout foo .

Utiliser mon outil git_remote_branch (vous avez besoin de Ruby installé sur votre machine). Il est spécialement conçu pour faciliter les manipulations de branches.

chaque fois qu'il effectue une opération pour vous, il l'imprime en rouge à la console. Au fil du temps, ils s'enfoncent finalement dans votre cerveau: -)

si vous ne voulez pas que grb exécute des commandes en votre nom, utilisez simplement la fonction "expliquer". Les commandes seront imprimées sur votre console au lieu d'Exécuter pour vous.

Enfin, toutes les commandes ont des alias, pour faciliter la mémorisation.

notez qu'il s'agit de alpha software ; -)

voici de l'aide lorsque vous lancez GRB help:

git_remote_branch version 0.2.6

  Usage:

  grb create branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb rename branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Notes:
  - If origin_server is not specified, the name 'origin' is assumed 
    (git's default)
  - The rename functionality renames the current branch

  The explain meta-command: you can also prepend any command with the 
keyword 'explain'. Instead of executing the command, git_remote_branch 
will simply output the list of commands you need to run to accomplish 
that goal.

  Example: 
    grb explain create
    grb explain create my_branch github

  All commands also have aliases:
  create: create, new
  delete: delete, destroy, kill, remove, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch

toutes les réponses que j'ai vues ici sont valables mais il y a une façon beaucoup plus propre de cloner un dépôt et de tirer toutes les branches à la fois.

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 à la fois.

Toutefois, lorsque vous voulez cloner un repo avec beaucoup de branches, tous les moyens sont illustrés ci-dessus sont longs et fastidieux à l'égard de beaucoup plus propre et plus rapide que je vais vous montrer, même si c'est un peu compliqué. Vous avez besoin de trois étapes pour accomplir ceci:

1. premier pas

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

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

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

2. Deuxième étape

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

$ git config --bool core.bare false

3. Troisième Étape

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

$ git reset --hard

donc maintenant vous pouvez simplement taper la commande" branche git " et vous pouvez voir que toutes les branches sont téléchargées.

C'est le moyen rapide dans lequel vous pouvez cloner un dépôt git avec tous les les branches à la fois, mais ce n'est pas quelque chose que vous voulez pour chaque projet de cette manière.

en Regardant l'une des réponses à la question, j'ai remarqué qu'il est possible de le raccourcir:

for branch in  `git branch -r | grep -v 'HEAD\|master'`; do  
 git branch --track ${branch##*/} $branch;
done

mais attention, si l'une des branches distantes est nommée par exemple admin_master, elle ne sera pas téléchargée!

merci à bigfish pour l'idée originale

OK, quand vous clonez votre pension, vous avez toutes les branches là...

si vous faites juste git branch , ils sont en quelque sorte cachés...

donc si vous voulez voir le nom de toutes les branches, il suffit d'ajouter --all drapeau comme ceci:

git branch --all ou git branch -a

si vous venez de la caisse à la branche, vous obtenez tout ce dont vous avez besoin.

mais qu'en est-il si la branche créé par quelqu'un d'autre après vous clone?

dans ce cas, il suffit de faire:

git fetch

et vérifiez à nouveau toutes les branches...

si vous aimez aller chercher et sortir en même temps, vous pouvez faire:

git fetch && git checkout your_branch_name

a aussi créé l'image ci-dessous pour vous simplifier ce que j'ai dit:

pour copier-coller dans la ligne de commande:

git checkout master ; remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",); print }'`; do git branch -D $brname ; git checkout -b $brname $remote/$brname ; done ; git checkout master

pour plus de lisibilité:

git checkout master ;
remote=origin ;
for brname in `
    git branch -r | grep $remote | grep -v master | grep -v HEAD 
    | awk '{gsub(/^[^\/]+\//,"",); print }'
`; do
    git branch -D $brname ;
    git checkout -b $brname $remote/$brname ;
done ;
git checkout master

1. check out maître, afin que nous puissions supprimer de la branche, nous sommes sur)
2. sélectionnez remote à la caisse (le changer à quelque distance que vous avez)
3. boucle à travers toutes les branches la télécommande, sauf le maître et la tête
   1. supprimer branche locale (afin que nous puissions vérifier les branches en vigueur)
   2. check out de la branche à partir de la télécommande
4. check out master (pour l'amour d'elle)

Basé sur réponse de VonC .

#!/bin/bash
for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; do
   git branch --track ${branch#remotes/origin/} $branch
done

ce code va extraire toutes les branches distantes du code de la mise en pension locale.

le clonage à partir d'un repo local ne fonctionnera pas avec git clone & git fetch: un grand nombre de branches/tags resteront libres.

pour obtenir un clone avec toutes les branches et étiquettes.

git clone --mirror git://example.com/myproject myproject-local-bare-repo.git

pour obtenir un clone avec toutes les branches et étiquettes mais aussi avec une copie de travail:

git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master

j'avais besoin de faire exactement la même chose. Voici mon script Ruby .

#!/usr/bin/env ruby

local = []
remote = {}

# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
  line.strip!
  if /origin\//.match(line)
     remote[line.gsub(/origin\//, '')] = line
   else
     local << line
   end
end
# Update 
remote.each_pair do |loc, rem|
  next if local.include?(loc)
  %x[git checkout --track -b #{loc} #{rem}]
end
%x[git fetch]

j'ai écrit ce petit Powershell fonctions pour être en mesure de vérifier toutes mes branches git, qui sont sur l'origine à distance.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { $_ -Match "origin\/(?'name'\S+)" }  <# select only names of the branches #> `
     | % { Out-Null; $matches['name'] }        <# write does names #>
}


Function git-CheckoutAllBranches {
    git-GetAllRemoteBranches `
        | % { iex "git checkout $_" }          <# execute ' git checkout <branch>' #>
}

D'autres fonctions git peuvent être trouvées sur mes paramètres git repo

utilisez les commandes dont vous vous souvenez""

J'utilise Bitbucket, un service D'Hébergement de dépôt D'Atlassian. Donc j'essaie de suivre leurs docs. Et qui fonctionne parfaitement pour moi. Avec les commandes faciles et courtes suivantes, vous pouvez vérifier votre branche distante.

clonez d'abord votre dépôt, puis changez dans le dossier de destination. Et le dernier mais non des moindres aller et retour:

git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>

C'est ça. Ici un litte plus exemple du monde réel:

git clone https://username@bitbucket.org/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

, Vous trouverez des informations détaillées sur les commandes dans les docs: Clone De Commande , Commande Fetch , Validation De Commande

git habituellement (lorsqu'il n'est pas spécifié) récupère toutes les branches et/ou étiquettes (réf, voir: git ls-refs ) d'un ou de plusieurs autres dépôts avec les objets nécessaires pour compléter leurs histoires. En d'autres termes, il récupère les objets qui sont accessibles par les objets qui sont déjà téléchargé. Voir: Quoi git fetch vraiment?

parfois, vous pouvez avoir des branches / tags qui ne sont pas directement connectés à l'actuel, donc git pull --all / git fetch --all ne va pas aider dans ce cas, mais vous pouvez en faire la liste par:

git ls-remote -h -t origin

et les récupérer manuellement en connaissant les noms des réf.

pour extraire tout , essayez:

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

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

puis vérifiez à nouveau toutes vos branches:

git branch -avv

Si ci-dessus ne sert à rien, vous devez ajouter manuellement les branches manquantes à la liste de suivi (car elles se sont perdues d'une manière ou d'une autre):

$ git remote -v show origin
...
  Remote branches:
    master      tracked

par git remote set-branches like:

git remote set-branches --add origin missing_branch

donc il peut apparaître sous remotes/origin après fetch:

$ git remote -v show origin
...
  Remote branches:
    missing_branch new (next fetch will store in remotes/origin)
$ git fetch
From github.com:Foo/Bar
 * [new branch]      missing_branch -> origin/missing_branch

dépannage

si vous ne pouvez toujours rien obtenir d'autre que la branche principale, vérifier les points suivants:

• vérifiez vos télécommandes ( git remote -v ), par exemple
  • valider que git config branch.master.remote est origin .
  • Vérifiez si origin points à droite de l'URL par l'intermédiaire de: git remote show origin (voir cette post ).

à partir de début 2017, la réponse dans ce commentaire travaux:

git fetch <origin-name> <branch-name> apporte la branche vers le bas pour vous. Bien que cela ne tire pas toutes les branches à la fois, vous pouvez exécuter singulièrement ce par-branche.

aucune de ces réponses ne le coupe, sauf l'utilisateur personne n'est sur la bonne voie.

j'ai eu des problèmes avec le déplacement d'un repo d'un serveur/système à un autre. Quand j'ai cloné le repo, il n'a créé qu'une branche locale pour master, donc quand j'ai poussé vers la nouvelle télécommande, seule la branche master a été poussée.

donc j'ai trouvé ces deux méthodes très utiles. Espérons qu'ils aider quelqu'un d'autre.

Méthode 1:

git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Méthode 2:

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Voici une autre courte commande à une doublure qui crée des branches locales pour toutes les branches éloignées:

(git branch -r | sed -n '/->/!s#^  origin/##p' && echo master) | xargs -L1 git checkout

cela fonctionne aussi correctement si le suivi des branches locales est déjà créé. Vous pouvez l'appeler après le premier git clone ou à tout moment plus tard.

si vous n'avez pas besoin de vérifier la branche master après le clonage, utilisez

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout

je vais ajouter mes 2 cents ici parce que je suis ici pour essayer de trouver comment tirer vers le bas une branche distante j'avais supprimé localement. L'origine n'était pas la mienne, Et je ne voulais pas passer à travers les tracas de tout re-cloner

cela a fonctionné pour moi:

en supposant que vous devez recréer la branche localement:

git checkout -b recreated-branch-name
git branch -a (to list remote branches)
git rebase remotes/remote-origin/recreated-branch-name

donc si je bifurquais de gituser / master à sjp et puis ramifié à sjp / mynewbranch il semblerait que ceci:

$ git checkout -b mynewbranch
$ git branch -a
  master
  remotes/sjp/master
  remotes/sjp/mynewbranch
$ git fetch (habit to always do before)
$ git rebase remotes/sjp/mynewbranch