Comment cloner toutes les branches distantes dans Git?

Question

J'ai un maître et une branche development , tous deux poussés vers GitHub . J'ai clone d, pull ed, et fetch ed, mais je ne peux obtenir rien d'autre que le master branche arrière.

Je suis sûr qu'il me manque quelque chose d'évident, mais j'ai lu le manuel et je ne ressens aucune joie.

Answer 1

Commencez par cloner un référentiel Git distant et cd dans celui-ci:

$ git clone git://example.com/myproject
$ cd myproject

Ensuite, examinez les branches locales de votre référentiel:

$ git branch
* master

Mais il y a d'autres branches cachées dans votre référentiel! Vous pouvez les voir en utilisant le drapeau -a :

$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental

Si vous souhaitez simplement jeter un coup d'œil sur une branche en amont, vous pouvez le vérifier directement:

$ git checkout origin/experimental

Mais si vous souhaitez travailler sur cette branche, vous devez créer une branche de suivi locale automatiquement créée par:

$ git checkout experimental

et vous verrez

Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'

Cette dernière ligne renvoie certaines personnes: " Nouvelle branche " - hein? Cela signifie réellement que la branche est extraite de l'index et créée localement pour vous. La ligne précédente est en réalité plus informative, car elle indique que la branche est en train d'être configurée pour suivre la branche distante, ce qui signifie généralement la branche origine / nom de la branche

Maintenant, si vous regardez vos succursales locales, voici ce que vous verrez:

$ git branch
* experimental
  master

Vous pouvez réellement suivre plusieurs référentiels distants à l'aide de git remote .

$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
  remotes/win32/master
  remotes/win32/new-widgets

À ce stade, les choses deviennent assez folles. Lancez gitk pour voir ce qui se passe:

$ gitk --all &

Answer 2

Si vous souhaitez récupérer simultanément plusieurs branches distantes, procédez comme suit:

$ git pull --all

Vous pouvez maintenant extraire n'importe quelle branche à votre guise, sans toucher au référentiel distant.

Answer 3

Ce script Bash m'a aidé à sortir:

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

 Il créera des branches de suivi pour toutes les branches distantes, à l'exception de la branche principale (que vous avez probablement obtenue avec la commande de clonage d'origine). Je pense que vous pourriez encore avoir besoin de faire un 

git fetch --all
git pull --all


 pour en être sûr. 


  
  Un liner :  branche git -a | grep -v HEAD | perl -ne 'chomp ($ _); s | ^ \ *? \ s * ||; if (m | (. +) / (. +) | & amp; & amp; & amp; not $ d {$ 2}) {print qq (branche git - piste $ 2 $ 1 / $ 2 \ n)} sinon {$ d {$ _} = 1} '| csh -xfs  Comme d’habitude: testez dans votre configuration avant de copier l’univers rm -rf tel que nous le connaissons 
  
  
  Crédits pour one-liner aller à l'utilisateur cfi  
); do
    git branch --track "${branch##*/}" "$branch"
done

Il créera des branches de suivi pour toutes les branches distantes, à l'exception de la branche principale (que vous avez probablement obtenue avec la commande de clonage d'origine). Je pense que vous pourriez encore avoir besoin de faire un

<*>

pour en être sûr.

  

Un liner : branche git -a | grep -v HEAD | perl -ne 'chomp ($ _); s | ^ \ *? \ s * ||; if (m | (. +) / (. +) | & amp; & amp; & amp; not $ d {$ 2}) {print qq (branche git - piste $ 2 $ 1 / $ 2 \ n)} sinon {$ d {$ _} = 1} '| csh -xfs Comme d’habitude: testez dans votre configuration avant de copier l’univers rm -rf tel que nous le connaissons

     

Crédits pour one-liner aller à l'utilisateur cfi

Answer 4

L'utilisation de l'option - mirror semble copier correctement les branches de suivi à distance . Cependant, il configure le référentiel en tant que référentiel nu. Vous devez donc le reconvertir ensuite en référentiel normal.

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 puis-je cloner un référentiel? avec toutes les branches suivies à distance?}

Answer 5

Vous pouvez facilement basculer vers une branche sans utiliser les options fantaisistes "git checkout -b une origine / une branche". syntaxe. Vous pouvez juste faire:

git checkout somebranch

Git fera automatiquement ce qu'il faut:

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

Git vérifiera si une branche du même nom existe dans exactement une télécommande et si c'est le cas, il la suivra de la même manière que si vous aviez explicitement spécifié qu'il s'agissait d'une branche distante. Dans la page de manuel git-checkout de Git 1.8.2.1:

  

Si < branche > est introuvable mais il existe une branche de suivi dans   exactement une télécommande (appelez-la < remote >) avec un nom correspondant, traitez-la comme   équivalent à

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

Answer 6

En ce qui concerne,

  

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

en utilisant

$ git checkout -t origin/experimental

ou le plus bavard mais plus facile à retenir

$ git checkout --track origin/experimental

pourrait être meilleur, en termes de suivi d'un référentiel distant.

Answer 7

L'extraction que vous effectuez doit obtenir toutes les branches distantes, mais ne crée pas de branches locales pour elles. Si vous utilisez gitk, les branches distantes doivent être décrites comme suit: "télécommandes / origine / dev". ou quelque chose de similaire.

Pour créer une branche locale basée sur une branche distante, procédez comme suit:

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

Ce 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, lorsque vous êtes sur la branche dev, " git pull " mettra à jour votre dev local au même point que la branche dev distante. Notez que toutes les branches seront récupérées, mais ne tirez que celle que vous avez sur le haut de l'arbre.

Answer 8

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

Pour pouvoir travailler sur une branche distante spécifique, en supposant qu'il s'agisse de la télécommande d'origine:

git checkout -b branch origin/branchname

Answer 9

Utilisez des alias. Bien qu’il n’y ait pas de one-liners Git natifs, vous pouvez définir le vôtre comme

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

puis utilisez-le comme

git clone-branches

Answer 10

Pourquoi vous ne voyez que le "maître"

git clone télécharge toutes les branches distantes distantes mais les considère toujours comme "distantes", même si les fichiers se trouvent dans votre nouveau référentiel. Il existe une exception à cette règle: le processus de clonage crée une branche locale appelée "maître". de la branche distante appelée "maître". Par défaut, branche git affiche uniquement les branches locales. C’est pourquoi vous ne voyez que "maître".

branche git -a affiche toutes les branches, y compris les branches distantes .

Comment obtenir des branches locales

Si vous souhaitez réellement travailler sur une branche, vous souhaiterez probablement un "local". version de celui-ci. Pour créer simplement des branches locales à partir de branches distantes (sans les extraire et donc modifier le contenu de votre répertoire de travail) , procédez comme suit:

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 en fonction de origin / branchone ; Si vous souhaitez plutôt créer des branches locales avec des noms différents, procédez comme suit:

git branch localbranchname origin/branchone

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

Answer 11

Ce n’est pas trop compliqué, les étapes les plus simples et les plus simples sont les suivantes;

origine de l'extraction git Ceci amènera toutes les branches distantes chez votre local.

branche git -a Ceci vous montrera toutes les branches distantes.

git checkout - suivez le chemin / / branche que vous souhaitez commander >

Vérifiez si vous vous trouvez dans la branche souhaitée à l'aide de la commande suivante:

git branch

La sortie ressemblera à ceci;

*your current branch 
some branch2
some branch3 

Notez le signe * qui indique la branche actuelle.

Answer 12

Mieux vaut tard que jamais, mais voici le meilleur moyen de le faire:

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

À ce stade, vous avez une copie complète du référentiel distant avec toutes ses branches (vérifiez avec branche git ). Vous pouvez utiliser - mirror au lieu de - bare si votre référentiel distant a ses propres télécommandes.

Answer 13

Faites 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

Vous voyez, 'git clone git: //example.com/myprojectt' récupère tout, même les branches, il vous suffit de les commander, votre branche locale sera alors créée.

Answer 14

Vous devez uniquement utiliser " git clone " pour obtenir toutes les branches.

git clone <your_http_url>

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

git branch -a

Et vous pouvez passer à n’importe quelle branche que vous avez déjà.

git checkout <your_branch_name>

Ne vous inquiétez pas après avoir cliqué sur "git clone", vous n'avez pas besoin de vous connecter au référentiel distant, "git branch -a". et " git checkout " peut être exécuté avec succès lorsque vous fermez votre wifi. Il est donc prouvé que lorsque vous faites "git clone", il a déjà copié toutes les branches du référentiel distant. Après cela, vous n'avez plus besoin du référentiel distant, votre section locale possède déjà tous les codes des branches.

Answer 15

Un git clone est censé copier le référentiel entier. Essayez de le cloner, puis exécutez git branch -a . Il devrait énumérer toutes les branches. Si vous souhaitez alors basculer vers la branche " foo " au lieu de "maître", utilisez git checkout foo .

Answer 16

Utiliser mon outil git_remote_branch ( vous avez besoin de Ruby installé sur votre machine). Il a été spécialement conçu pour faciliter la manipulation des branches distantes.

Chaque fois qu’il effectue une opération pour vous, il l’imprime en rouge sur la console. Au fil du temps, ils restent 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’être exécutées pour vous.

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

Notez qu'il s'agit du logiciel alpha ; -)

Voici l'aide lorsque vous exécutez 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

Answer 17

Toutes les réponses que j'ai vues ici sont valables, mais il existe un moyen beaucoup plus simple de cloner un référentiel et de tirer toutes les branches à la fois.

Lorsque vous clonez un référentiel, toutes les informations des branches sont effectivement 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 alors " télécharger " manuellement les un à la fois.

Cependant, lorsque vous souhaitez cloner un repo avec beaucoup de branches, toutes les manières illustrées ci-dessus sont longues et fastidieuses en ce qui concerne une manière beaucoup plus propre et plus rapide que je vais montrer, bien que ce soit un peu compliqué. Vous avez besoin de trois étapes pour y parvenir:

1. Première étape

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 à l'intérieur du dossier my_repo_folder est toujours vide, il ne reste plus qu'un dossier .git caché, que vous pouvez voir avec un " ls -al " commande du terminal.

2. Deuxième étape

changez ce référentiel d’un référentiel vide à un référentiel normal en basculant la valeur booléenne " nue " des configurations git à false:

$ git config --bool core.bare false

3. troisième étape

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

$ git reset --hard

Vous pouvez donc maintenant 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 à la fois, mais ce n’est pas quelque chose que vous voulez faire de la sorte pour chaque projet.

Answer 18

En regardant l'une des réponses à la question, j'ai remarqué qu'il était possible de la 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, il ne sera pas téléchargé!

Merci à bigfish pour son idée originale

Answer 19

Le clonage à partir d'un dépôt local ne fonctionnera pas avec git clone & amp; git fetch: beaucoup de branches / tags resteront non-récupérés.

Pour obtenir un clone avec toutes les branches et tous les tags.

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

Pour obtenir un clone avec toutes les branches et tous les tags, 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

Answer 20

OK, lorsque vous clonez votre référentiel, vous y avez toutes les branches ...

Si vous ne faites que git branch , ils sont en quelque sorte cachés ...

Donc, si vous souhaitez voir le nom de toutes les branches, ajoutez simplement - tout comme ceci:

branche git - tout ou branche git -a

Si vous ne faites que passer à la succursale, vous aurez tout ce dont vous avez besoin.

Mais qu'en est-il de la branche créée par quelqu'un d'autre après votre clonage?

Dans ce cas, il suffit de faire:

git fetch

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

Si vous souhaitez aller chercher et commander en même temps, vous pouvez faire:

git fetch & amp; & amp; git checkout your_branch_name

Vous avez également créé l'image ci-dessous pour simplifier ce que j'ai dit:

Answer 21

#!/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

Ces codes vont extraire tous les codes de branches distantes vers le dépôt local.

Answer 22

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(/^[^\/]+\//,"",$1); print $1}'`; 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(/^[^\/]+\//,"",$1); print $1}'
`; do
    git branch -D $brname ;
    git checkout -b $brname $remote/$brname ;
done ;
git checkout master

---

Cela va:

1. consultez le maître (afin que nous puissions supprimer la branche sur laquelle nous nous trouvons)
2. sélectionnez la télécommande pour passer à la caisse (remplacez-la par votre télécommande)
3. parcourez toutes les branches de la télécommande, sauf maître et HEAD.
   1. supprimer une succursale locale (afin que nous puissions consulter les branches mises à jour de force)
   2. vérifier la branche de la télécommande
4. consultez maître (pour le plaisir de le lire)

Basé sur la réponse sur VonC .

Answer 23

Je devais 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]

Answer 24

J'ai écrit cette petite Powershell pour pouvoir extraire toutes mes branches git qui se trouvent sur la télécommande d'origine.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { 
 J'ai écrit cette petite  Powershell  pour pouvoir extraire toutes mes branches git qui se trouvent sur la télécommande d'origine. 

<*>

 Vous trouverez d'autres fonctions git à l'adresse  mes paramètres git. repo  
 -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 
 J'ai écrit cette petite  Powershell  pour pouvoir extraire toutes mes branches git qui se trouvent sur la télécommande d'origine. 

<*>

 Vous trouverez d'autres fonctions git à l'adresse  mes paramètres git. repo  
" }          <# execute ' git checkout <branch>' #>
}

Vous trouverez d'autres fonctions git à l'adresse mes paramètres git. repo

Answer 25

Généralement, quand Git (non spécifié) récupère toutes les branches et / ou balises (réfs, voir: git ls-refs ) dans un ou plusieurs autres référentiels ainsi que les objets nécessaires pour compléter leur historique. En d'autres termes, il récupère les objets accessibles par les objets déjà téléchargés. Voir: Que fait vraiment git fetch ?

Parfois, vous pouvez avoir des branches / balises qui ne sont pas directement connectées à l'actuel. Ainsi, git pull --all / git fetch --all ne le fera pas. aider dans ce cas, mais vous pouvez les lister par:

git ls-remote -h -t origin

et récupérez-les manuellement en connaissant les noms des références.

Pour les récupérer tous , essayez:

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

Vérifiez à nouveau toutes vos branches:

git branch -avv

Si ce qui précède ne vous aide pas, vous devez ajouter manuellement les branches manquantes à la liste suivie (car elles se sont en quelque sorte égarées):

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

par git set-branches distants comme:

git remote set-branches --add origin missing_branch

afin qu'il puisse apparaître sous télécommandes / origine après la récupération:

$ 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 obtenir rien d'autre que la branche principale, vérifiez les éléments suivants:

• Vérifiez vos télécommandes ( git remote -v ), par exemple.
  • Vérifiez que git config branch.master.remote est origine .
  • Vérifiez si origine pointe vers la bonne URL via: origine de l'émission distante git (voir ceci message ).

Answer 26

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

J'avais du mal à déplacer un dépôt d'un serveur / système à un autre. Lorsque j'ai cloné le référentiel, il n'a créé qu'une branche locale pour le maître. Ainsi, lorsque j'ai poussé vers la nouvelle télécommande, seule la branche maître a été poussée.

J'ai donc trouvé ces deux méthodes TRÈS utiles. J'espère qu'ils aident 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

Answer 27

Utilisez des commandes dont vous vous souviendrez

J'utilise Bitbucket, un service d'hébergement de référentiel d'Atlassian. Alors j'essaie de suivre leurs docs. Et cela fonctionne parfaitement pour moi. Avec les commandes simples et courtes suivantes, vous pouvez vérifier votre succursale distante.

Commencez par cloner votre référentiel, puis accédez au dossier de destination. Et le dernier mais non le moindre, aller chercher et commander:

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

C'est ça. Voici un petit exemple plus réaliste:

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 la documentation: Commande de clonage , Commande Fetch , Commande Checkout

Answer 28

À partir de début 2017, la réponse dans ce commentaire fonctionne:

git chercher > < branch-name > désactive la branche. Bien que cela ne tire pas toutes les branches à la fois, vous pouvez exécuter cette opération individuellement par branche.

Answer 29

Voici une autre commande courte à une ligne qui crée des branches locales pour toutes les branches distantes:

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

Cela fonctionne également correctement si le suivi des branches locales est déjà créé. Vous pouvez l’appeler après le premier git clone ou à tout moment ultérieurement.

Si vous n'avez pas besoin d'avoir la branche master extraite après le clonage, utilisez

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

Answer 30

git clone --mirror sur le référentiel d'origine fonctionne bien pour cela.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin