Comment cloner toutes les branches de Git?

J'ai un master et un development de la branche, à la fois poussé à GitHub. J'ai cloned, pulled, et fetched, mais je reste incapable d'obtenir autre chose que la master branche.

Je suis sûr que je suis absent quelque chose d'évident, mais j'ai lu le manuel et je me fais pas de joie à tous.

La accepté de répondre ici (git branch -a) vous montre les branches dans la distance, mais si vous essayez de vérifier un de ces, vous serez dans un " détaché de la TÊTE de l'état. La réponse suivante vers le bas (deuxième plus upvotes) les réponses à une autre question (pour l'esprit: comment tirer toutes les branches, et, encore une fois, cela ne fonctionne que pour ceux que vous effectuez le suivi localement). Plusieurs commentaires souligner que vous avez pu analyser la git branch -a résultats avec un script shell qui serait localement à suivre toutes les branches distantes. Résumé: Il n'y a pas de git natif de chemin à faire ce que vous voulez et il pourrait ne pas être une grande idée de toute façon.
Peut-être juste de copier l'intégralité du dossier à l'ancienne? scp [email protected]:/home/some_user/project_folder ~ Ne sais pas si cette solution fonctionne pour github si..
Plutôt que de dire "j'ai cloné, tiré, et les cheveux," beaucoup mieux pour nous montrer les commandes exécutées.
Ici Git 1.8.3.2, le checkouted branche ne pas être " détaché de la TÊTE de l'état, mais la checkouted tag sera.
Vous serez en mesure à la caisse toutes les branches (en chemin différent) après le clonage d'une opération de pension avec la nouvelle git checkout --to=<path> commande à venir dans Git 2.5+ (Q2 2015): qui aurait l'appui de plusieurs direction de la caisse. Voir stackoverflow.com/a/30185564/6309.
Elle toujours me croit rêver pourquoi "clone" n'est pas dans le sens d'une copie exacte. Si c'est un clone exact, ne devrait pas toutes les branches de la partie du dépôt local? Je veux dire n'est-ce pas l'un des point d'être distribués? Alors, quand quelque chose référentiel est parti, vous avez toujours une copie complète de tout. Ou est-ce le soi-disant "à distance" sont vraiment une partie du référentiel local déjà?
Voir toutes les upvotes, les réponses, les commentaires sur les réponses et le nombre sidérant de points de vue, je pense qu'il est temps git ajout d'une commande pour le faire. Et vous avez raison @huggie, mes pensées exactement.
est-il moins les données envoyées sur le fil pour seulement une branche spécifique? Si vous êtes le clonage le noyau Linux ou quelque autre bête, c'est peut-être préférable par défaut (si je suis d'accord que si vous le voulez tous, qui devrait être facile aussi)
stackoverflow.com/a/7216269/480982 devrait être la accepté de répondre à
Maintenant qu'il a été un moment depuis que j'ai appris plus sur git, j'ai réalisé ma confusion découle du nom de "branches distantes" et "suivi à distance des branches." Git stocke des trucs dans un arbre. Branches (que ce soit à distance, suivi à distance ou local) sont des "étiquettes" de l'arbre. Lors du clonage, tout dans l'arbre n'est cloné. Et chaque origin/XXXX (branches distantes) sont étiquetés. (Ils sont vraiment local les étiquettes que vous gardez). Un maître de la branche est généralement fait pour être une "distance de suivi de branche" (Remarquez le tableau de bord j'ai ajouté afin de préciser.) Mais vous pouvez créer d'autres sections locales qui portent la capacité de suivi.
Ainsi, les branches sont des étiquettes. Il y a vraiment tous les locaux pour vous. Une "distance" (origine/XXX) est un label local pour correspondre à la distance (comme les dernières que vous avez connu depuis le dernier fetch). Une "section locale" est un label local. Et une branche locale peut avoir la possibilité de "suivre" et devient une "distance de suivi" de la branche. La capacité de suivre vraiment simplement vous sauver un peu de touche de clavier, pas besoin de spécifier quelle distance vous êtes en tirant ou en poussant. C'est tout. Pas plus, pas moins. Et lorsque vous clonez, arbre n'est cloné, et le local origin/xxx sont étiquetés.

InformationsquelleAutor Peter Coulton | 2008-09-15

4311

D'abord, clone une distance Git référentiel et cd en elle:
```
$ git clone git://example.com/myproject
$ cd myproject
```
Ensuite, regardez les branches locales dans votre référentiel:
```
$ git branch
* master
```
Mais il y a d'autres branches se cacher dans votre référentiel! Vous pouvez les consulter à l'aide de la -a drapeau:
```
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
```
Si vous voulez juste prendre un coup d'oeil rapide à l'amont de la branche, vous pouvez le vérifier directement:
```
$ git checkout origin/experimental
```
Mais si vous souhaitez travailler sur cette branche, vous aurez besoin de créer un local de suivi de la branche qui est fait automatiquement par:
```
$ git checkout experimental
```
et vous verrez
```
Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'
```
Que la dernière ligne des lancers certaines personnes: "Nouvelle direction" - hein?
Ce que cela signifie vraiment, c'est que la direction générale est prise à partir de l'index et créés localement pour vous. Le précédente ligne est en fait plus instructif qu'il vous indique que la direction est en train d'être mis en place pour suivre la branche distante, ce qui signifie généralement l'origine/branch_name branche

Maintenant, si vous regardez vos branches locales, c'est ce que vous allez voir:
```
$ git branch
* experimental
  master
```
Vous pouvez suivre en fait plus d'un dépôt distant à 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 point, les choses deviennent assez fou, alors courez gitk pour voir ce qu'il se passe:
```
$ gitk --all &
```
- Comment quelqu'un peut-il créer automatiquement toutes les branches distantes, par exemple expérimentale de l'origine/expérimental?
- Cristian: j'ai l'habitude de toujours créer une branche " foo "pour chaque branche d'origine et de foo', mais cela a conduit à deux problèmes: (1) je me suis retrouvé avec beaucoup de vraiment obsolète de suivi des branches qui ont été beaucoup s'engage derrière le correspondant de la branche distante, et (2) dans les anciennes versions de git, de l'exécution "git push" serait tenter de pousser tous mes branches locales à une distance, même lorsque ces branches ont été vicié. Alors maintenant, je ne garde que des branches locales pour des choses que je suis activement le développement, et l'accès de l'origine/* branches directement si j'ai besoin d'informations à leur sujet. (Cela dit, vous pouvez utiliser un script shell pour analyser git branch-a'.)
- "git fetch <origine-name> <branche-name>" apporte la branche localement pour vous.
- Bonne réponse, mais manque un peu la question. Je cherchais un one-liner à la caisse toutes les branches distantes.
- La question a été sur le clonage toutes les branches distantes, pas de vérification de l'en sortir. Et, comme je l'ai mentionné ci-dessus, vous ne voulez vraiment pas faire plus local de suivi de branches que nécessaire, parce que quand ils obtiennent vraiment obsolète, ils peuvent causer des maux de tête.
- J'ai couru dans un problème où git a répondu avec: "fatal: git checkout: mise à jour des chemins est incompatible avec la commutation de branches". J'ai eu à émettre un "Git pull" d'abord, puis "git checkout -b <remote_branch> origine/<remote_branch>"
- Notez également que "git fetch" sans arguments chercher une nouvelle télécommande branches, qui est apparu après avoir initialement clonés il. Autrement ils ne pourraient pas s'afficher lorsque vous exécutez "git branch-a".
- comment est $ git checkout -b experimental origin/experimental différente de $ git branch --track experimental origin/experimental? Je me rends compte de la caisse vais aussi passer à la branche.
- réaliser son départ, il devra aussi passer à la branche": c'est là que réside la différence 🙂
- Avec le git checkout -b ... de commande, vous devez ajouter le paramètre de piste? À partir de la documentation d'aide pour git checkout [<branch] il semble que vous ne...If -b is given, a new branch is created as if git-branch(1) were called and then checked out; in this case you can use the --track or --no-track options, which will be passed to git branch. As a convenience, --track without -b implies branch creation; see the description of --track below.
- Vous pouvez avoir besoin de git remote update' avant 'git checkout -b expérimentale origine/expérimental" pour trouver une succursale à distance c'est plus récente que vos pensions.
- voir mon commentaire sur Luuk Paulussen la réponse ci-dessous. Vous pouvez sauter --track lorsque vous êtes à partir d'une branche à distance et utilisez le paramètre par défaut pour la branch.autosetupmerge config.
- comment se fait - git checkout experimental est différente de git checkout origin/experimental
- Il est utile d'ajouter le niveau de verbosité de la git branch -a de sortie, en faisant git branch -av ou même git branch -avv. Avec l'augmentation de la verbosité, vous verrez chaque branche du dernier commit ainsi.
- est à votre succursale locale, origin/experimental est la branche distante. Vous ne devriez pas faire les modifications directement dans la branche distante depuis quand vous git pull ou git fetch, la distance devrait être en mesure de mettre à jour proprement afin de refléter les changements en amont.
- Si vous avez cloné un dépôt nu, vous pouvez avoir besoin de regarder Dave réponse. Quand j'ai cloné un nu-repo, il n'a pas de clone de toutes les branches. Dave solution m'a permis de cloner toutes les branches.
- Au lieu de git checkout -b experimental origin/experimental, vous pouvez écrire tout git checkout experimental, il va créer de la direction générale et de définir les informations de suivi pour vous (sauf avec de très vieilles versions Git).
- Je trouve qu'il est plus facile d'ouvrir mon .git/refs dossier dans l'explorateur de fichiers et les déplacer ou les copier toutes les entrées dans .git/refs/remotes/origin/* à .git/refs/heads/; les choses sont un peu moins pratique lorsque les fichiers ont été déplacés dans .git/packed-refs, à ce point, le git en ligne de commande serait plus facile de multiplex
- Qu'entendez-vous par "d'autres branches se cacher dans votre référentiel!" Une raison pour laquelle ils sont cachés? Je ne comprends pas ce @emk
- "dissimuler" il voulait dire que git branch ne montre pas les branches distantes par défaut, vous devez utiliser git branch -a de montrer toutes les branches.
- git checkout expérimentale origine/experimental ici goutte d'eau "-b" et il va couvrir votre besoin en une seule étape
- idéalement, git clone serait vous invite à chaque branche o/n/, au lieu de 'cacher' et vous laisser savoir comment obtenir un particulier branche sur votre ordinateur local avec encore plus de commandes et les interrupteurs à déchiffrer. J'ai dit "clone" et lui a donné un à distance - pas de "clone master" - mais git n'a pas encore rattrapé le niveau de facilité / prévoyance nous avons eu dans le DOS de la fin des années 80.
- À propos de "Mais il y a d'autres branches se cacher dans votre référentiel!" Ce n'est pas exactement vrai. Les branches distantes ne sont PAS dans votre référentiel, mais seulement dans le dépôt distant. Supprimer origine afin de vérifier.
- Le remotes/origin/experimental tag souligne en fait une copie locale de origin experimental, mis à jour la dernière fois que vous avez exécuté git fetch. Si vous vous déconnectez du réseau, vous devez pouvoir accéder à ses données, à l'aide de git checkout origin/experimental. (Pour être précis, je n'ai pas vérifié ces derniers temps, mais c'est la façon dont il a toujours travaillé par le passé.)
- Pourquoi gitk --all & et pas gitk --all ?
InformationsquelleAutor emk
780

Si vous avez beaucoup de distance branches que vous souhaitez récupérer à la fois, n':
```
$ git pull --all
```
Maintenant, vous pouvez extraire n'importe quel branche que vous avez besoin, sans toucher le dépôt distant.
- Si je fais un git clone, j'ai la branche master localement et 10 branches "à distance". Si CETTE réponse par Gabe a été très utile et répond à la question.
- cette seule extraction à distance les branches qui ont été ajouté localement pas aucun branche à distance
- La première commande est redondante. Simplement git pull --all va faire la même chose – il ne peut pas extraire deux fois. Et infosec812 est juste que cela ne répond pas à la question de toute façon. Je me demande comment cela a beaucoup de upvotes.
- Ouais, je suis d'accord avec @infosec812... Cette réponse n'explique pas la réelle clonage / vérification de processus, qui est fait avec git checkout -b <localbranch> <remotebranch>, où remotebranch est le nom de la télécommande comme il apparaît dans git branch -r (ou aussi git branch -a).
- Après je n'ai git remote update, ensuite essayé git branch, je ne vois que des branches locales. Mais si je ne git branch -a je peux maintenant voir les branches distantes et je peux faire un git pull <branchname> pour obtenir la direction que je veux. -- J'ai atterri sur cette question à partir d'une recherche Google, et cette réponse résout mon problème.
- Ce n'est pas utile à tous, ne tirez pas sur toutes les branches autres que celui qui est existant.
- Git Pull --tout est correct. Cela m'a permis de tirer dans les branches distantes qui existait sur github, mais pas dans les locaux de pensions, que je ne puis déplacer la cette branche que la normale
- Attention @Jazzerus. Je pense que git pull <remotename>/<branchname> va fusionner la branche dans quelque branche que vous avez actuellement sélectionnée. Ce que vous voulez est git checkout --track <remotename>/<branchname>. Et c'est ce que l'OP veut, git checkout --track sur toutes distance (origine) des branches
- git pull --all ou git fetch --all ne vient tous les télécommandes, pas de branches.
- pull --tous;git push remoteUrl2-tous; cd newDir; git clone remoteUrl2; cd pensions; git branch -a montrera que la branche master, par conséquent, la question a pas été répondu que des dizaines de branches ont été supprimés.
- Merci de signaler cette réponse, il ne cherche pas à répondre à la question d'origine.
- Ce n'est pas la première fois lors d'une réponse qui est tout simplement mal parce qu'il ne répond pas à la question reçoit des centaines de upvotes de personnes qui soit n'ont pas compris les questions et/ou d'une réponse, ou débarquées par google pour la recherche de quelque chose d'autre que l'original OPs problème et que cette 'réponse' avez accidentellement répondu à leur problème. Malheureusement, il n'y a pas d'indicateur valide pour la réponse qui ne répond pas à la question, le seul moyen est downvoting, ce qui évidemment ne fonctionne pas dans certains cas, ce type de bruit est sur le point de rester pour toujours 🙁
InformationsquelleAutor Gabe Kopley
401

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 pour toutes les branches, à l'exception de master (que vous avez probablement obtenu à partir de l'original clone de commande). Je pense que vous pourriez encore besoin de faire un
```
git fetch --all
git pull --all
```
pour être sûr.

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

Crédits pour un seul-liner aller de l'utilisateur de la fci
- C'est vraiment très proche de étant une solution parfaite.. La seule chose qui le ferait mieux, c'est si cette fonctionnalité ont été intégré comme une option dans git.
- modifié: for branch in `git branch -a | sed -n '\=/HEAD$=d; \=/master$=d;s=<SPACE><SPACE>remotes/==p'`; do ...
- "One liner": git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs Comme d'habitude: test de votre installation avant de copier rm -rf universe as we know it
- Par ma lecture de la documentation, vous avez seulement besoin d'un git pull --all à la fin, car il implicitement le chercher?
- Cette commande crée les branches de la télécommande comme normal branches (pas de succursales) - comment résoudre ce problème?
- si vous rencontrez des problèmes avec le "/" dans les noms de branche il y a une solution ci-dessous à l'aide d'un alias git. voir la réponse par "personne" sur ", a répondu le 15 Mai '13 à 11:02"
- Vous devrez éditer le ${branche##*/} partie. Je viens de rognés l'avant à la place. (branche $ | cut-c 16-)
- Je coupe juste remotes/origin/ de préserver des espaces de noms: for BRANCH in $(git branch -a | grep remotes | grep -v HEAD | grep -v master); do git branch --track "${BRANCH#remotes/origin/}" "${BRANCH}"; done
- Je vois que ça dans la réponse et a été répété dans les commentaires plusieurs fois, donc j'ai oublier: git branch -a | grep remotes peut, au lieu d'être git branch -r (avec des astuces pour les parties plus tard, parce que le "remotes/" partie de la succursale nom n'est pas dans cette sortie)
- git pull --all ou git fetch --all ne vient tous les télécommandes, pas de branches. Votre bash script a fonctionné, cependant.
- Aussi, ne pas oublier de le pousser toute commande git push --all origin
InformationsquelleAutor bigfish
319

À l'aide de la --mirror option semble copier le remote suivi des branches correctement.
Cependant, il met en place le référentiel comme un dépôt nu, de sorte que vous avez à la remettre en normal référentiel 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 puis-je cloner un dépôt avec tous suivi à distance des branches?}
- Vous savez ce qui semble être une assez bonne réponse, même si elle n'a pas de voix. Existe-il des pièges à le faire de cette façon? J'avais explicitement commander une branche après l'exécution de ces commandes.
- D'accord avec @test - j'ai trouvé cette réponse très utile. J'ai eu des problèmes avec un référentiel dans lequel j'ai eu un remplacement qui a brisé l'histoire, mais il a travaillé avec cette méthode. Merci beaucoup pour la mention de cette méthode de Dave !
- Ceci, combiné avec la commande git push --miroir sont exactement ce dont j'avais besoin pour créer une copie exacte d'un repo git lors du déplacement de github.com pour un github enterprise installer. Merci!
- Ajouter une dernière git checkout comme dernière commande, enfin, l'extraction de la tête de la branche courante sur la cloné des pensions. C'est une excellente réponse, de loin le meilleur. Être courageux, éventuellement, nous allons vous faire le top 🙂
- Hm. Je suis à avoir des doutes: --miroir n'est plus que juste la configuration de toutes les branches de l'objet du suivi. Il copie toutes les refs de l'origine et suivantes git remote update va le faire à nouveau. Le comportement de tire changement. Je suis de retour à croire la version complète nécessite un script d'une ligne.
- git clone --mirror est très bon pour la sauvegarde de vos dépôts git ^_^
- Pour référence, git.wiki.kernel.org/index.php/...
- Si votre intention est de créer une sauvegarde (pas de miroir), je serais plutôt d'utiliser git-bundle
- Je voulais un repo qui est identique à la source avec son origine pointant vers le même endroit. J'ai donc ajouté: cp path/to/original/.git/config path/to/dest/.git/config Cela semble résoudre d'autres problèmes liés au démarrage avec un nu-pensions ainsi.
- Lors de l'utilisation de ces étapes, mon CLI changements de [master] à [GIT_DIR!], et de la finale de la caisse ne fonctionne pas. Mise à JOUR: j'ai fait une erreur. J'ai cloné dans /path/to/dest.git - il doit avoir été /path/to/dest/.git. Puis, quand je unconfig serais mode nu, mon CLI dit [master +0 ~0 -116 ~] mais sur git checkout master, il fait un tas de travail, mais est sorti de l'autre côté comme [master], de sorte qu'il ressemble le succès!
- Je suis confus par le path/to/dest/.git partie gauche et il. Dû mkdir x; mv x.git x/.git; cd x; git config --bool core.bare false à récupérer. Sinon, oui, c'est la solution. Merci.
- Cette option fonctionne sans la nécessité pour le script de magie ci-dessus.
- Avertissement, il n'a pas de clone fusionné les branches. Mais autre que cela, il ne le travail!
InformationsquelleAutor Dave
211

Vous pouvez facilement passer à une branche sans l'aide de la fantaisie "git checkout -b somebranch origine/somebranch de syntaxe". Il vous suffit de faire:
```
git checkout somebranch
```
Git va automatiquement faire 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. Du git-caisse de la page de manuel de la commande Git 1.8.2.1:
Si <branch> n'est pas trouvé, mais il n'existe pas de suivi de la branche dans
exactement une distance (appeler <distance>) avec un nom correspondant, la traiter comme
équivalent à
```
$ git checkout -b <branch> --track <remote>/<branch>
```
- Donc, si le nom de la branche que vous checkout est la même que le nom de la branche distante, tout ce qui est après le "/", puis git va créer une branche du même nom, tout ce qui est après le "/", "suivi" à distance? Et par le suivi, nous entendons: git push, git pull, etc. sera fait sur cette distance? Si cela est correct, puis développez votre réponse à la question avec plus d'informations, car je aggree avec @Daniel, cette réponse mérite plus d'rep.
- la réponse à toutes vos questions semble être oui (je suis en utilisant git v1.7.7.4). Je suis d'accord ce comportement doit être mieux connu. (Il n'est pas dans le manuel pour cette version de git.) En fait je n'aime pas ce comportement, je préfère obtenir une erreur et je dois dire git checkout --track origin/somebranch explicitement.
- En fait, c'est dans le manuel. git-caisse(1) dit: "Si <branch> n'est pas trouvé, mais il n'existe pas de suivi de la branche dans exactement une distance (appeler <distance>) avec un nom correspondant, traiter comme l'équivalent de" git checkout -b <branch> --track <distance>/<branch>' " (Git V. 1.8.1.1).
- Ce dont nous avons besoin est de $ git pull * <distance>/* - où "*" est un joker, il tire toutes les branches, y compris ceux qui ne sont pas encore sur le système local. Comment faire cela? Sommes-nous vraiment censé checkout/tirer chaque branche juste pour obtenir le code tiré de notre système local?
- De toute évidence, cela doit être le top commentaire.
InformationsquelleAutor Nikos C.
92

Concernant,

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

à l'aide de
```
$ 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.

InformationsquelleAutor murphytalk
79

Le chercher ce que vous faites doit obtenir toutes les branches distantes, mais il ne crée pas des branches locales pour eux. Si vous utilisez gitk, vous devriez voir les branches distantes décrit 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 doit retourner quelque chose comme:
```
Branche dev mis en place pour suivre à distance direction des refs/remotes/origin/dev. 
Passé à une nouvelle branche "dev"
```
Maintenant, lorsque vous êtes sur la branche dev, "git pull" mise à jour de votre local dev au même point que la distance branche dev. Notez qu'il récupère toutes les branches, mais seulement tirer la une vous êtes sur le haut de l'arbre.
- Vous n'avez pas besoin de refs/remotes ici. git checkout -b dev origine/dev fonctionnera très bien.
- Ce sera toujours: git checkout -b newlocaldev --track origin/dev. Si vous voulez que la section locale a le même nom que la distance, et la distance n'est pas une délicate nom, vous pouvez omettre le -b newlocaldev. Avec la valeur par défaut branch.autosetupmerge paramètre de configuration, et en supposant que vous n'avez pas une branche locale nommée dev, ces deux commandes peuvent faire la même chose: git checkout -b dev origin/dev et simple git checkout dev. Enfin, git checkout origin/dev ne pas créer une nouvelle branche, mais juste vous met dans décollement de la TÊTE de l'état.
- Ce qui se passe quand la distance n'existe plus, mais Git est trop stupide pour faire reconnaître son été supprimé? Cela suppose que vous avez mis à jour et git branch -a continue de listes comme une branche distante.
- Et nous faisons cela pour des dizaines de branches?
InformationsquelleAutor Luuk Paulussen
57

Quand vous faites "git clone git://emplacement", toutes les branches et les tags sont récupérées.

Afin de travailler sur un distant spécifique de la branche, en supposant que c'est l'origine distance:
```
git checkout -b branch origin/branchname
```
- J'apprécie votre remarque "toutes les branches et les tags sont récupérés". Je vais commenter votre réponse à la question d'avoir tort, mais ensuite, j'ai vérifié et trouvé, vous avez parfaitement raison. Donc dans un sens, vous avez donné la réponse la plus courte - si vous avez cloné, vous l'avez déjà. Nice. On pourrait essayer d'ajouter: essayez $ git branch -a à apprendre, ce que les branches distantes sont déjà disponibles.
- Jetez un oeil à la réponse que j'ai posté aussi. Cela peut être utile si vous savez que vous aurez envie de travailler localement sur un grand nombre de branches distantes et ne pas avoir à les vérifier un par un.
InformationsquelleAutor elmarco

Utiliser des alias. Si il n'y a pas natif Git one-liners, 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 ensuite l'utiliser comme

git clone-branches

InformationsquelleAutor nobody

45

Pourquoi vous ne voyez que "maître"

git clone télécharge tous à distance de distance de branches, mais les considère encore "à distance", même si les fichiers sont situés dans le nouveau référentiel. Il y a une exception à cela, qui est que le processus de clonage crée une filiale locale appelé "maître" de la branche à distance appelé "maître". Par défaut, git branch ne montre que les branches locales, qui est pourquoi vous ne voyez que "maître".

git branch -a montre toutes les branches, y compris les branches distantes.

Comment obtenir des branches locales

Si vous avez réellement envie de travailler sur une branche, vous voudrez probablement un "local" version de celui-ci. Tout simplement la création de sections locales de branches distantes (sans vérification et, par conséquent, modifier le contenu de votre répertoire de travail), vous pouvez le 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, vous êtes en train de créer basée sur origin/branchone; si, au contraire, vous voulez créer des branches locales avec des noms différents, vous pouvez faire ceci:
```
git branch localbranchname origin/branchone
```
Une fois que vous avez créé une branche locale, vous pouvez le voir avec git branch (rappelez-vous, vous n'avez pas besoin -a pour voir les branches).
- Merci pour l'explication de pourquoi seul le maître est le seul visible de la branche
InformationsquelleAutor Cerran
44

Ce n'est pas trop compliqué, très simple et les étapes sont comme suit;

git fetch origin Cette apportera toutes les branches distantes de votre local.

git branch -a Cela va vous montrer toutes les branches distantes.

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 
```
Avis de l' * signe qui dénote de la branche courante.
- Grâce suraj. La raison parce que sa pas été voté beaucoup. Et le sna n'est pas acceptée par l'interlocuteur.
- Le "git fetch origin" n'est pas de porter un quelconque des branches distantes à mon local - ou sont-ils cachés quelque part? La lecture de toutes les réponses ci-dessus m'a donné un mal de tête. Nous sommes à la recherche de "git fetch toutes les branches locales". Il doit y avoir un chemin de côté de bash-scripts pour ce faire.
- Juste après l'exécution de "git fetch origin", il affiche la sortie comme ceci dans votre terminal - "* [branche] branch_name -> origine/branch_name", mais lorsque vous l'exécutez "git branch" il vous montrera vos branches locales au lieu de cela, de sorte à en voir de toutes les branches que vous pouvez faire "git branch -a" et puis de passer à la branche distante, vous devez exécuter " git checkout --piste origine/<direction que vous voulez extraire>". Espérons que cette aide. 🙂
- Suraj, parce que la question était, comment faire pour "cloner toutes les branches distantes" - pas comment mettre à jour manuellement un à un. Il semble y avoir pas de réponse à la question réelle - juste des façons de faire un tas de taper si vous avez un grand nombre de branches.
InformationsquelleAutor Sam
44

Mieux vaut tard que jamais, mais ici, c'est 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 stade, vous avez une copie complète de la télécommande repo avec toutes ses branches (à vérifier avec git branch). Vous pouvez utiliser --mirror au lieu de --bare si votre télécommande repo a télécommandes de sa propre.
- Quelque chose se passe mal lors de la modifications ici. Maintenant, cette réponse ne fait pas de sens. Le "--bare" mentionné à la dernière phrase n'existe pas dans la liste des commandes.
- la prise de Dave réponse ci-dessous. À l'aide de git config --bool de base.nu faux "au lieu de" git config unset de base.nu " semble faire le travail.
- J'ai le error: key does not contain a section: unset. Le Dave réponse fonctionne mieux.
- C'est git config --unset core.bare en fait... Pour moi, cela semble la solution la plus propre de tous présentés dans les réponses ici. Dommage que ça a si peu de upvotes...
- Il a travaillé pour moi ... @olibre essayer git config --bool core.bare false au lieu de git config --unset core.bare
- Merci @ChrisSim je suis d'accord pour git config --bool core.bare false. C'est pourquoi je conseille plutôt le Dave réponse. Que pensez-vous de la Dave réponse? Cheers
- C'est absolument la meilleure réponse sauf que @FedericoCapaldo ont donné une réponse qui va dans un peu plus de détails sur exactement ce que ces commandes sont en train de faire.
- Aussi, --bare fonctionne, mais --miroir qui pourrait fonctionner mieux.
InformationsquelleAutor Jacob Fike

Viens de le faire:

$ 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 voir, " git clone git://exemple.com/myprojectt' récupère tout, même les branches, vous avez juste à passer à la caisse, puis à votre succursale locale sera créé.

InformationsquelleAutor rapher

23

Vous avez seulement besoin d'utiliser le "git clone" pour obtenir toutes les branches.
```
git clone <your_http_url>
```
Même si vous ne voyez branche master, vous pouvez utilisez "git branch -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, après avoir "git clone", vous n'avez pas besoin de se connecter avec la télécommande du repo, "git branch-a" et "git checkout" peut être exécuté avec succès lorsque vous fermez votre connexion wifi. Il est prouvé que, quand vous faites "git clone", il a déjà copié toutes les branches de la distance des pensions. Après cela, vous n'avez pas besoin de la télécommande repo, votre local possède déjà toutes les branches codes.
- Très clair de réponse ici. Beaucoup de gens confus au sujet de ce sujet.
- J'aimerais seconde votre déclaration "peut être exécuté avec succès lorsque vous fermez votre wifi". "git clone" n'a vraiment raison dans une pension de contenant toutes les branches.
InformationsquelleAutor Haimei
20

Un git clone est censé copier l'intégralité du référentiel. Essayez de clonage, puis l'exécuter git branch -a. Elle devrait liste de toutes les branches. Si vous souhaitez ensuite passer à la branche "foo" au lieu de "maître", l'utilisation git checkout foo.
- Vous pouvez exécuter des commandes git avec ou sans le trait d'union. Les deux "git-branche" et "git branch" fonctionnera.
- Peut-être que cette réponse a été donnée il y a longtemps quand git travaillé différemment, mais je pense que c'est trompeur aujourd'hui. git clone ne télécharger toutes les branches distantes, mais il ne fait que la branche locale de maître. Depuis git branch ne montre que les branches locales, vous avez besoin git branch -a afin de consulter les branches, trop.
- Je vous remercie. C'est une sorte d'étrange comportement par défaut de l'OMI. Je vais juste la craie jusqu'à plus cryptique gitness. Si c'téléchargé les branches, pourquoi serait-il cacher lors de l'appel de branche git?
- merci; j'ai mis à jour ma réponse en conséquence.
- "ne télécharger toutes les branches distantes, mais il ne fait que la branche locale de maître". J'ai besoin d'aide pour comprendre le présent. Il semble git clone n'est PAS de cloner toutes les branches à l'exception de master, comme quand vous faites "git branch -a", il montre que la "développer" la branche est seulement à "remotes/origin/développer". Ce doit être dire que vous n'avez pas cette branche n'importe où, localement, il n'existe actuellement sur l'origine de la droite?
InformationsquelleAutor MattoxBeckman
19

Utiliser mon outil de git_remote_branch (vous avez besoin de Ruby installé sur votre machine). Il est construit spécifiquement pour faciliter le branche à distance manipulations mort facile.

À chaque fois qu'il effectue une opération sur votre compte, qu'il imprime en rouge dans la console. Au fil du temps, ils ont enfin coller dans votre cerveau 🙂

Si vous ne voulez pas de bsg pour exécuter des commandes sur votre compte, il suffit d'utiliser la "expliquer" caractéristique. Les commandes seront imprimées sur votre console plutôt que exécutée pour vous.

Enfin, toutes les commandes ont des alias, pour faire de la mémorisation plus facile.

Noter que c'est logiciel alpha 😉

Ici de l'aide lorsque vous exécutez la bsg aider:
```
git_remote_branch version 0.2.6 

Utilisation: 

la bsg créer branch_name [origin_server] 

la bsg publier branch_name [origin_server] 

la bsg renommer branch_name [origin_server] 

la bsg supprimer branch_name [origin_server] 

la bsg piste branch_name [origin_server] 



Notes: 
- Si origin_server n'est pas spécifié, le nom d '"origine" est supposé 
git (par défaut) 
- Le changement de nom de la fonctionnalité renomme la branche courante 

L'expliquer méta-commande: vous pouvez également ajouter n'importe quelle commande avec le 
mot-clé "expliquer". Au lieu de l'exécution de la commande, git_remote_branch 
va simplement afficher la liste des commandes que vous devez exécuter pour accomplir 
ce but. 

Exemple: 
la bsg expliquer créer 
la bsg expliquer créer my_branch github 

Toutes les commandes ont également alias: 
créer: créer de nouveaux 
supprimer: permet de supprimer, détruire, tuer, enlever, rm 
publier: publier, remotize 
renommer: renommer, rn, mv, déplacer 
piste: piste, suivre, saisir, aller chercher de l' 
```
- Mot pour le sage: Il semble que ce projet a été abandonné autour de l'heure à cette réponse a été publiée. Je ne trouve pas de mises à jour après 2008. Caveat emptor et tout ça. Si je me trompe, j'espère que quelqu'un va modifier et de fournir un pointeur courant, parce que j'aimerais bien avoir un outil comme celui-ci à portée de main.
- cochez cette réponse, il met en place un git alias: stackoverflow.com/a/16563327/151841
InformationsquelleAutor webmat
17

toutes les réponses que j'ai vu ici sont valables, mais il est beaucoup plus propre façon 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 à un.

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 à 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.
1. 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
```
1. 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 tapez 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.
- Je n'aime pas votre utilisation du mot "télécharger" en ... "télécharger" manuellement un à un moment. Toutes les infos est, en fait, déjà téléchargé après avoir cloné le repo. La seule chose que l'on doit faire, c'est de la création locale de suivi des branches (ce qui est également possible en mode hors ligne, ce qui prouve que toutes les informations sont dans le repo).
- c'est pourquoi il est dans les citations.
InformationsquelleAutor FedericoCapaldo
13

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

Si vous venez de le faire git branch, ils sont cachés...

Donc, si vous voulez voir toutes les branches de nom, tout simplement ajouter --all drapeau comme ceci:

git branch --all ou git branch -a

Si vous venez de passer à la direction générale, vous obtenez tout ce dont vous avez besoin.

Mais que diriez-vous si la branche créé par quelqu'un d'autre après vous clone?

Dans ce cas, il suffit de faire:

git fetch

et de vérifier toutes les branches de nouveau...

Si vous voulez récupérer la caisse et dans le même temps, vous pouvez faire:

git fetch && git checkout your_branch_name

Également créé l'image ci-dessous pour vous, afin de simplifier ce que j'ai dit:
- Il y a une différence entre "tu l'as" et "vous le voyez". git branch-ne serez PAS dans la liste de la télécommande branches plus lorsque vous retirez le dépôt distant.
InformationsquelleAutor Alireza
12

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é comme, par exemple, admin_master il ne sera pas téléchargé!

Grâce à bigfish pour l'idée originale
- Vous pouvez améliorer la regex, ou peut-être utiliser Awk au lieu de grep, pour améliorer le filtre pour éviter les faux positifs.
- toutes les branches sont d'origine\my_branch_name", ce qui n'est pas vraiment ce que je veux.
- Je n'ai pas vu la construction ${branche##*/} avant - ressemble vraiment utile - une idée où je peux en savoir plus sur qui? n'arrive pas à trouver sous bash n'importe où. Thx.
InformationsquelleAutor Tebe
12
```
#!/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 code va tirer toutes les branches distantes code local des pensions.
- réf. coderwall.com/p/0ypmka/git-clone-all-remote-branches-locally
InformationsquelleAutor Albert.Qing
12

Clonage à partir d'un local de pensions ne fonctionnera pas avec git clone & git fetch: un grand nombre de branches/tags restera unfetched.

Pour obtenir un clone avec toutes les branches et les tags.
```
git clone --mirror git://example.com/myproject myproject-local-bare-repo.git
```
Pour obtenir un clone avec toutes les branches et 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
```
InformationsquelleAutor raisercostin
10

Pour copier-coller de 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
```
Ce sera:
1. découvrez 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 dans toutes les branches de la distance à l'exception de master et de la TÊTE
  1. supprimer branche locale (afin que nous puissions vérifier la force-mise à jour des rameaux)
  2. découvrez branche à partir de la télécommande
4. découvrez maître (pour l'amour d'elle)
Basé sur réponse de VonC.

InformationsquelleAutor ikaruss

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

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

Voir la réponse que j'ai posté plus bas, pour éviter d'avoir à exécuter ce script à tous.

InformationsquelleAutor user43685

J'ai écrit ce petit Powershell fonctions pour être en mesure à la caisse tous mes branches git, qui sont à l'origine de la télécommande.

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>' #>
}

Plus git fonctions peuvent être trouvés sur mon git paramètres de repo

InformationsquelleAutor gringo_dave

7

Aucune de ces réponses couper, à l'exception de l'utilisateur, personne n'est sur la bonne voie.

J'ai eu du mal avec le déplacement des pensions de titres à partir d'un serveur/système à l'autre. Quand j'ai cloné le dépôt, il créé une succursale locale pour le master, donc quand j'ai poussé à la nouvelle télécommande, seul maître de la branche a été poussé.

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
```
- Vraiment utile merci!!
InformationsquelleAutor Gaui
7

Git généralement (lorsqu'il n'est pas spécifié) récupère toutes les branches et/ou des balises (refs, voir: git ls-refs) à partir d'un ou de plusieurs autres référentiels avec les objets nécessaires pour remplir 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: Ce n' 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 de les récupérer manuellement par la connaissance de la ref noms.

Donc à récupérer tous les, essayez:
```
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.}

Puis vérifiez l'ensemble des branches:
```
git branch -avv
```
Si ci-dessus ne vous aide pas, vous devez ajouter manquant branches manuellement à la liste de suivi (comme ils se sont perdus en quelque sorte):
```
$ git remote -v show origin
...
  Remote branches:
    master      tracked
```
par git remote set-branches comme:
```
git remote set-branches --add origin missing_branch
```
ainsi, 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
```
De dépannage

Si vous ne pouvez toujours pas obtenir quoi que ce soit d'autre que la branche master, 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érifier si origin points à droite de l'URL via: git remote show origin (voir ce post).
InformationsquelleAutor kenorb
6

Utiliser les commandes que vous pouvez vous souvenir de

Je suis en utilisant Bitbucket, un Référentiel de Service d'Hébergement de Atlassian. J'ai donc essayer de suivre leurs docs. Et qui fonctionne parfaitement pour moi. Avec le suivant, facile et court commandes vous pouvez payer votre branche distante.

Au premier cloner votre dépôt, puis sur modifier dans le dossier de destination. Et le dernier mais non le moins, d'extraction et de départ:
```
git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>
```
Que c'est. Ici un litte plus l'exemple du monde réel:
```
git clone https://[email protected]/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, Commande Checkout

InformationsquelleAutor Phil
6

Dès le début de 2017, la réponse dans ce commentaire travaux:

git fetch <origin-name> <branch-name> apporte la branche vers le bas pour vous. Alors que ce n'est pas tirer toutes les branches à la fois, vous pouvez singulièrement de signer la présente par branche.
- Cela exige que vous chercher chaque branche à la fois. Pas très bon si vous avez un grand nombre de branches.
InformationsquelleAutor ashes999
5

Voici un autre court une ligne de commande 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
```
Il fonctionne aussi correctement si le suivi de branches locales sont déjà créés.
Vous pouvez appeler après la première git clone ou à tout moment ultérieurement.

Si vous n'avez pas besoin d'avoir master branche vérifié après le clonage, l'utilisation
```
git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout
```
InformationsquelleAutor jofel
5

git clone --mirror sur l'origine des pensions de 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
```
InformationsquelleAutor Bernd Jungblut
3

Cette variation permet de cloner une distance repo avec toutes les branches disponible sur place sans avoir à commander chaque branche, un par un. Pas de fantaisie, les scripts nécessaires.

Faire un dossier avec le même nom de l'opération que vous souhaitez cloner et cd en par exemple:
```
mkdir somerepo
cd somerepo
```
Maintenant faire ces commandes, mais avec une réelle repo usersname/reponame
```
git clone --bare [email protected]:someuser/somerepo.git .git
git config --bool core.bare false
git reset --hard
git branch
```
Voiala! vous disposez de tous les branches il y!
- C'est la méthode qui a fonctionné pour moi. Il est Simple et rapide.
- git rev-parse --abbrev-ref --symbolic-full-name '@{u}' montre fatal: no upstream configured for branch 'master'. Devrait être origin/master.
InformationsquelleAutor lacostenycoder
2

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 le mien, et je ne voulais pas passer par les tracas de re-clonage tout

Cela a fonctionné pour moi:

en supposant que vous avez besoin de 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 j'ai forké gituser/maître de sjp et puis ramifiée à sjp/mynewbranch il devrait ressembler à 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
```
InformationsquelleAutor Camwyn
2

Voici une réponse qui utilise awk. Cette méthode devrait suffire si elle est utilisée sur un nouveau repo.
```
git branch -r | awk -F/'{ system("git checkout " $NF) }'
```
Branches existantes aurez simplement à être vérifié, ou déclarées comme déjà en elle, mais les filtres peuvent être ajoutés afin d'éviter les conflits.

Il peut également être modifiée de sorte qu'il appelle explicitement git checkout -b <branch> -t <remote>/<branch> commande.

Cette réponse suit Nikos C.'s idée.

Sinon, nous pouvons spécifier la distance de la branche à la place. Ceci est basé sur murphytalk's réponse.
```
git branch -r | awk '{ system("git checkout -t " $NF) }'
```
Il jette erreur fatale messages sur les conflits, mais je les vois inoffensif.

Les deux commandes peuvent être lissés.

À l'aide de personne ne's réponse comme référence, on peut avoir les commandes suivantes pour créer les alias:
```
git config --global alias.clone-branches '! git branch -r | awk -F/"{ system(\"git checkout \" $NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" $NF) }"'
```
Personnellement j'utiliserais track-all ou track-all-branches.

InformationsquelleAutor konsolebox
0

Un peu en retard à la fête, mais je pense que cela fait l'affaire:
```
mkdir YourRepo
cd YourRepo
git init --bare .git                       # create a bare repo
git remote add origin REMOTE_URL           # add a remote
git fetch origin refs/heads/*:refs/heads/* # fetch heads
git fetch origin refs/tags/*:refs/tags/*   # fetch tags
git init                                   # reinit work tree
git checkout master                        # checkout a branch
```
Si ce n'est quelque chose d'indésirable, j'aimerais savoir. Cependant, jusqu'à présent, cela fonctionne pour moi.
- Conformément à la Note n ° 2 en vertu de la refspec section de git fetch (kernel.org/pub/software/scm/git/docs/git-fetch.html), c'est probablement ce qui doit être ajusté.
- Entendez-vous la note début, "Vous ne faites jamais de votre propre développement sur les branches qui apparaissent sur le côté droit de l'un <refspec> colon"? Et, ajusté, pour quelle raison?
- pas sûr de ce que je voulais dire en arrière, puis.. pour être honnête.
InformationsquelleAutor Andy
0

Voici un script bash pour la récupération de toutes les branches et les tags d'un projet git comme des instantanés dans des dossiers séparés.

https://gist.github.com/hfossli/7562257

Peut-être pas ce qui a été demandé directement, mais certaines personnes pourraient venir ici à la recherche de cette solution.

InformationsquelleAutor hfossli
-2

Si vous utilisez BitBucket,

vous pouvez utiliser importation Référentiel, cela va importer tous les historique de git ( toutes les branches et s'engage)

InformationsquelleAutor M. Dhaouadi

Vous devez vous connecter pour publier un commentaire.

Pourquoi vous ne voyez que "maître"

Comment obtenir des branches locales

De dépannage

Utiliser les commandes que vous pouvez vous souvenir de