J’ai un master
et une twig de development
, tous deux poussés vers GitHub . J’ai clone
, pull
, et fetch
, mais je rest incapable de récupérer autre chose que la twig master
.
Je suis sûr que je manque quelque chose d’évident, mais j’ai lu le manuel et je ne ressens aucune joie.
D’abord, clonez un repository Git distant et placez -y un CD :
$ git clone git://example.com/myproject $ cd myproject
Ensuite, regardez les twigs locales dans votre référentiel:
$ git branch * master
Mais il y a d’autres twigs cachées dans votre repository! 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 voulez simplement jeter un coup d’œil à une twig en amont, vous pouvez la consulter directement:
$ git checkout origin/experimental
Mais si vous voulez travailler sur cette twig, vous devez créer une twig de suivi locale qui se fait automatiquement par:
$ git checkout experimental
et vous allez voir
Branch experimental set up to track remote branch experimental from origin. Switched to a new branch 'experimental'
Cette dernière ligne jette des personnes: “Nouvelle twig” – hein? Ce que cela signifie vraiment, c’est que la twig est extraite de l’index et créée localement pour vous. La ligne précédente est en fait plus informative car elle vous indique que la twig est configurée pour suivre la twig distante, ce qui signifie généralement la twig origine / branch_name.
Maintenant, si vous regardez vos twigs locales, voici ce que vous verrez:
$ git branch * experimental master
Vous pouvez en fait 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 folles, alors lancez gitk
pour voir ce qui se passe:
$ gitk --all &
Si vous souhaitez récupérer plusieurs twigs distantes, procédez comme suit:
$ git pull --all
Maintenant, vous pouvez extraire n’importe quelle twig comme vous le souhaitez, sans toucher au référentiel distant.
Ce script Bash m’a aidé à sortir:
#!/bin/bash for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do git branch --track "${branch##*/}" "$branch" done
Il créera des twigs de suivi pour toutes les twigs distantes, à l’exception de master (que vous avez probablement obtenu avec la commande clone d’origine). Je pense que vous pourriez encore avoir besoin de faire un
git fetch --all git pull --all
pour être sûr
Un paquebot :
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
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
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: testez votre configuration avant de copier l’univers rm -rf tel que nous le connaissonsCrédits pour one-liner aller à l’utilisateur cfi
L’utilisation de l’option --mirror
semble copier correctement les twigs de suivi à remote
. Cependant, il configure le référentiel comme un repository nu, vous devez donc le reconvertir dans un référentiel 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: FAQ Git: Comment puis-je cloner un référentiel avec toutes les twigs suivies à distance?
Vous pouvez facilement passer à une twig sans utiliser la syntaxe sophistiquée “git checkout -b somebranch origine / somebranch”. Vous pouvez juste 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 twig avec le même nom existe dans une seule télécommande, et si c’est le cas, elle le suit de la même manière que si vous aviez explicitement spécifié qu’il s’agissait d’une twig distante. À partir de la page de manuel git-checkout de Git 1.8.2.1:
Si
n’est pas trouvé mais qu’il existe une twig de suivi dans exactement une seule télécommande (appelez-la ) avec un nom correspondant, traitez comme équivalent à $ git checkout -b
--track /
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 mieux, en termes de suivi d’un référentiel distant.
La récupération que vous effectuez devrait obtenir toutes les twigs distantes, mais elle ne créera pas de twigs locales pour celles-ci. Si vous utilisez gitk, vous devriez voir les twigs distantes décrites comme “remotes / origin / dev” ou quelque chose de similaire.
Pour créer une twig locale basée sur une twig distante, faites comme:
git checkout -b ref refs / télécommandes / origine / dev
Qui devrait retourner quelque chose comme:
Déviation de la twig configurée pour suivre les refs / télécommandes / origines / dev distants. Passé à une nouvelle twig "dev"
Maintenant, quand vous êtes sur la twig dev, “git pull” mettra à jour votre dev local au même point que la twig dev distante. Notez qu’il ira chercher toutes les twigs, mais ne tirera que celle qui se trouve au sumt de l’arbre.
Lorsque vous faites “git clone git: // location”, toutes les twigs et les balises sont récupérées.
Pour travailler sur une twig distante spécifique, en supposant que ce soit la télécommande d’origine:
git checkout -b branch origin/branchname
Utilisez des alias. Bien qu’il n’existe pas de one-liners Git natif, vous pouvez définir votre propre
git config --global alias.clone-twigs '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
et ensuite l’utiliser comme
git clone-twigs
Ce n’est pas trop compliqué, les étapes très simples et simples sont les suivantes:
git fetch origin
Ceci amènera toutes les twigs distantes à votre local.
git branch -a
Ceci vous montrera toutes les twigs distantes.
git checkout --track origin/
Vérifiez si vous êtes dans la twig souhaitée par la commande suivante:
git branch
La sortie va aimer ça;
*your current branch some branch2 some branch3
Notez le signe * qui indique la twig en cours.
git clone
télécharge toutes les twigs distantes distantes mais les considère toujours comme “distantes”, même si les fichiers se trouvent dans votre nouveau référentiel. Il y a une exception à cela, à savoir que le processus de clonage crée une twig locale appelée “master” à partir de la twig distante appelée “master”. Par défaut, git branch
ne montre que les twigs locales, c’est pourquoi vous ne voyez que “master”.
git branch -a
affiche toutes les twigs, y compris les twigs distantes .
Si vous voulez réellement travailler sur une twig, vous voudrez probablement en avoir une version “locale”. Pour créer simplement des twigs locales à partir de twigs distantes (sans les vérifier et modifier ainsi 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, la branchone
est le nom d’une twig locale que vous créez en fonction de l’ origin/branchone
; Si vous souhaitez créer des twigs locales avec des noms différents, vous pouvez le faire:
git branch localbranchname origin/branchone
Une fois que vous avez créé une twig locale, vous pouvez la voir avec la git branch
(rappelez-vous, vous n’avez pas besoin de -a
pour voir les twigs 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 stade, vous avez une copie complète du repo distant avec toutes ses twigs (vérifiez avec la git branch
). Vous pouvez utiliser --mirror
au lieu de --bare
si votre repo à distance possède ses propres télécommandes.
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 twigs, il vous suffit de les extraire, puis votre twig locale sera créée.
Un git clone
est supposé copier l’intégralité du référentiel. Essayez de le cloner, puis lancez git branch -a
. Il devrait lister toutes les twigs. Si alors vous voulez passer à la twig “foo” au lieu de “master”, utilisez git checkout foo
.
Vous devez uniquement utiliser “git clone” pour obtenir toutes les twigs.
git clone
Même si vous ne voyez que la twig principale, vous pouvez utiliser “git branch -a” pour voir toutes les twigs.
git branch -a
Et vous pouvez passer à n’importe quelle twig que vous avez déjà.
git checkout
Ne vous inquiétez pas après avoir “git clone”, vous n’avez pas besoin de vous connecter avec le repo distant, “git branch -a” et “git checkout” peuvent être exécutés avec succès lorsque vous fermez votre wifi. Donc, il est prouvé que lorsque vous faites “git clone”, il a déjà copié toutes les twigs du repo distant. Après cela, vous n’avez pas besoin du repo distant, votre local a déjà tous les codes de twigs.
Utilisez mon outil git_remote_branch (vous devez avoir installé Ruby sur votre machine). Il est spécialement conçu pour faciliter les manipulations de twig distante.
Chaque fois qu’il effectue une opération en votre nom, il l’imprime en rouge sur la console. Au fil du temps, ils sont finalement restés dans votre cerveau 🙂
Si vous ne voulez pas que grb exécute les 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 que c’est un logiciel alpha 😉
Voici l’aide lorsque vous lancez l’aide de grb:
git_remote_branch version 0.2.6 Usage: grb créer nom_twig [serveur_origine] grb publish nom_twig [serveur_origine] grb renomme nom_twig [serveur_origine] grb delete nom_twig [serveur_origine] grb track branch_name [serveur_origine] Remarques: - Si le serveur d'origine n'est pas spécifié, le nom "origine" est supposé (défaut de git) - La fonctionnalité de renommage renomme la twig actuelle La méta-commande d’explication: vous pouvez également append une commande au mot clé "expliquer". Au lieu d'exécuter la commande, git_remote_branch va simplement sortir la liste des commandes que vous devez exécuter pour accomplir cet objective. Exemple: grb expliquer créer grb expliquer créer my_branch github Toutes les commandes ont également des alias: créer: créer, nouveau supprimer: supprimer, détruire, tuer, supprimer, rm publier: publier, distancer renommer: renommer, rn, mv, déplacer piste: suivre, suivre, saisir, chercher
Toutes les réponses que j’ai vues ici sont valables, mais il existe une méthode beaucoup plus propre pour cloner un référentiel et extraire toutes les twigs à la fois.
Lorsque vous clonez un référentiel, toutes les informations des twigs sont réellement téléchargées, mais les twigs sont masquées. Avec la commande
$ git branch -a
vous pouvez afficher toutes les twigs du référentiel, et avec la commande
$ git checkout -b branchname origin/branchname
vous pouvez ensuite les “télécharger” manuellement un par un.
Cependant, lorsque vous voulez cloner un repository avec beaucoup de twigs, toutes les manières illustrées ci-dessus sont longues et fastidieuses en ce qui concerne un moyen 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 y parvenir:
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 repository local dans le dossier my_repo_folder est toujours vide, il y a juste un dossier caché .git maintenant que vous pouvez voir avec une commande “ls -alt” depuis le terminal.
basculer ce référentiel d’un référentiel vide (nu) vers un référentiel régulier en basculant la valeur booléenne “bare” des configurations git sur false:
$ git config --bool core.bare false
Prenez tout ce qui se trouve dans le dossier actuel et créez toutes les twigs sur la machine locale, ce qui en fait un repository normal.
$ git reset --hard
Alors maintenant, vous pouvez simplement taper la commande “twig git” et vous pouvez voir que toutes les twigs sont téléchargées.
C’est le moyen le plus rapide de cloner un repository git avec toutes les twigs à la fois, mais ce n’est pas quelque chose que vous voulez faire pour chaque projet de cette manière.
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 twigs 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 repo, vous avez toutes les twigs là-bas …
Si vous ne faites que git branch
, elles sont en quelque sorte cachées …
Donc, si vous souhaitez voir le nom de toutes les twigs, ajoutez simplement --all
flag comme ceci:
git branch --all
ou git branch -a
Si vous venez de passer à la succursale, vous obtenez tout ce dont vous avez besoin.
Mais que diriez-vous si la twig créée par quelqu’un d’autre après avoir cloné?
Dans ce cas, il suffit de faire:
git fetch
et vérifiez toutes les twigs à nouveau …
Si vous souhaitez récupérer et commander en même temps, vous pouvez faire:
git fetch && git checkout your_branch_name
J’ai également créé l’image ci-dessous pour vous simplifier ce que j’ai dit:
Pour copier-coller en 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
Cette volonté:
Basé sur la 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
Ces codes extrairont tous les codes des twigs distantes au repo local.
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.ssortingp! 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]
Le clonage à partir d’un repo local ne fonctionnera pas avec git clone & git fetch: beaucoup de twigs / tags restront non récupérés.
Pour obtenir un clone avec toutes les twigs et les balises.
git clone --mirror git://example.com/myproject myproject-local-bare-repo.git
Pour obtenir un clone avec toutes les twigs et les balises, 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’ai écrit ces petites fonctions Powershell pour pouvoir extraire toutes mes twigs git, qui sont à distance d’origine.
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 ' #> }
Plus de fonctions git peuvent être trouvées sur mon repository git settings
J’utilise Bitbucket, un service d’hébergement de référentiel d’Atlassian. So I try to follow their docs. And that works perfectly for me. With the following easy and short commands you can checkout your remote branch.
At first clone your repository, then change into the destination folder. And last but not least fetch and checkout:
git clone cd git fetch && git checkout
C’est tout. Here a litte more real world example:
git clone https://[email protected]/team/repository.git project_folder cd project_folder git fetch && git checkout develop
You will find detail information about the commands in the docs: Clone Command , Fetch Command , Checkout Command
Git usually (when not specified) fetches all twigs and/or tags (refs, see: git ls-refs
) from one or more other repositories along with the objects necessary to complete their histories. In other words it fetches the objects which are reachable by the objects that are already downloaded. See: What does git fetch
really do?
Sometimes you may have twigs/tags which aren’t directly connected to the current one, so git pull --all
/ git fetch --all
won’t help in that case, but you can list them by:
git ls-remote -h -t origin
and fetch them manually by knowing the ref names.
So to fetch them all , try:
git fetch origin --depth=10000 $(git ls-remote -h -t origin)
The --depth=10000
parameter may help if you’ve shallowed repository.
Then check all your twigs again:
git branch -avv
If above won’t help, you need to add missing twigs manually to the tracked list (as they got lost somehow):
$ git remote -v show origin ... Remote twigs: master tracked
by git remote set-twigs
like:
git remote set-twigs --add origin missing_branch
so it may appear under remotes/origin
after fetch:
$ git remote -v show origin ... Remote twigs: missing_branch new (next fetch will store in remotes/origin) $ git fetch From github.com:Foo/Bar * [new branch] missing_branch -> origin/missing_branch
If you still cannot get anything other than the master branch, check the followings:
git remote -v
), eg
git config branch.master.remote
is origin
. origin
points to the right URL via: git remote show origin
(see this post ). As of early 2017, the answer in this comment works:
git fetch
brings the branch down for you. While this doesn’t pull all twigs at once, you can singularly execute this per-branch.
None of these answers cut it, except user nobody is on the right track.
I was having trouble with moving a repo from one server/system to another. When I cloned the repo, it only created a local branch for master so when I pushed to the new remote, only master branch was pushed.
So I found these two methods VERY useful. Hope they help someone else.
Method 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
Method 2:
git config --global alias.clone-twigs '! 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-twigs git remote add newrepo NEW_REPO_URL git push --all newrepo git push --tags newrepo
Here is another short one-liner command which creates local twigs for all remote twigs:
(git branch -r | sed -n '/->/!s#^ origin/##p' && echo master) | xargs -L1 git checkout
It works also properly if tracking local twigs are already created. You can call it after the first git clone
or any time later.
If you do not need to have master
branch checked out after cloning, use
git branch -r | sed -n '/->/!s#^ origin/##p'| xargs -L1 git checkout
I’m going to add my 2 cents here because I got here trying to find out how to pull down a remote branch I had deleted locally. Origin was not mine, and I didn’t want to go through the hassle of re-cloning everything
Cela a fonctionné pour moi:
assuming you need to recreate the branch locally:
git checkout -b recreated-branch-name git branch -a (to list remote twigs) git rebase remotes/remote-origin/recreated-branch-name
So if I forked from gituser/master to sjp and then twigd it to sjp/mynewbranch it would look like this:
$ 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