Mon collègue et moi travaillons sur le même référentiel. Nous l'avons divisé en deux branches, chacune techniquement pour des projets différents, mais elles ont des similitudes, nous voudrons donc parfois nous engager à nouveau dans le * à masterpartir du branch.

Cependant, j'ai le branch. Comment mon collègue peut-il tirer cette branche en particulier?

Un git clonedu référentiel ne semble pas créer les branches localement pour lui, bien que je puisse les voir en direct après un coup de pouce de ma part.

Aussi, quand j'ai fait la branche à l'origine, je l'ai fait -b checkout. Cela fait-il une grande différence?

$ git branch -r
origin/HEAD -> origin/master
origin/daves_branch
origin/discover
origin/master

$ git fetch origin discover
$ git checkout discover

Ce sont les commandes que j'ai exécutées. Mais cela ne fonctionne définitivement pas.

Je veux pouvoir vérifier cette branche, puis repousser et valider uniquement les modifications de branches de divers collaborateurs ou postes de travail .

Vous devez créer une branche locale qui suit une branche distante. La commande suivante créera une branche locale nommée daves_branch , suivant l' origine de la branche distante / daves_branch . Lorsque vous appuyez sur vos modifications, la branche distante est mise à jour.

Pour les versions les plus récentes de Git:

git checkout --track origin/daves_branch

--trackest un raccourci pour git checkout -b [branch] [remotename]/[branch]indiquer où [nom distant] est l' origine dans ce cas et [branche] est deux fois la même, daves_branch dans ce cas.

Pour Git 1.5.6.5, vous en aviez besoin:

git checkout --track -b daves_branch origin/daves_branch

Pour Git 1.7.2.3 et supérieur, cela suffit (cela aurait pu commencer plus tôt, mais c'est la première confirmation que j'ai pu trouver rapidement):

git checkout daves_branch

Notez qu'avec les versions récentes de Git, cette commande ne créera pas de branche locale et vous mettra dans un état 'HEAD détaché'. Si vous voulez une succursale locale, utilisez l' --trackoption.

Tous les détails sont ici: 3.5 Git Branching - Remote Branches, Tracking Branches

J'ai utilisé fetchsuivi de checkout...

git fetch <remote> <rbranch>:<lbranch>
git checkout <lbranch>

... où <rbranch>est la branche distante ou la référence source et <lbranch>est la branche locale ou référence de destination encore inexistante que vous souhaitez suivre et que vous souhaitez probablement nommer de la même manière que la branche distante ou la référence source. Ceci est expliqué dans les options de l'explication de .<refspec>

Git est tellement intelligent qu'il termine automatiquement la première commande si je tabule après les premières lettres de la branche distante. Autrement dit, je n'ai même pas besoin de nommer la branche locale, Git copie automatiquement le nom de la branche distante pour moi. Merci Git!

De même, comme le montre la réponse de ce post similaire sur le débordement de pile , si vous ne nommez pas la branche locale fetch, vous pouvez toujours la créer lorsque vous la retirez en utilisant l' -bindicateur. Autrement dit, git fetch <remote> <branch> suivi de git checkout -b <branch> <remote>/<branch>fait exactement la même chose que ma réponse initiale. Et évidemment, si votre référentiel n'a qu'une seule télécommande, alors vous pouvez le faire git checkout <branch>après fetchet il créera une branche locale pour vous. Par exemple, vous venez de cloner un référentiel et souhaitez extraire des branches supplémentaires de la télécommande.

Je pense qu'une partie de la documentation de fetchpeut avoir été copiée textuellement pull. En particulier , la section <refspec>dans les options est le même. Cependant, je ne crois pas que cela fetcharrivera jamais merge, de sorte que si vous laissez le côté destination du côlon vide, fetch ne faites rien .

REMARQUE: git fetch <remote> <refspec>est un raccourci pour git fetch <remote> <refspec>:lequel ne ferait donc rien, mais git fetch <remote> <tag>est le même que celui git fetch <remote> <tag>:<tag>qui doit copier la télécommande <tag>localement.

Je suppose que cela n'est utile que si vous souhaitez copier une branche distante localement, mais pas nécessairement la vérifier immédiatement. Sinon, j'utiliserais maintenant la réponse acceptée , qui est expliquée en détail dans la première section de la description de la commande et plus tard dans la section des options sous l'explication de --track, car il s'agit d'une ligne unique. Eh bien ... une sorte de monoplace, car il faudrait toujours courir en git fetch <remote>premier.

FYI: L'ordre de la <refspecs>(source: destination) explique la méthode bizarre pré Git 1.7 pour supprimer les branches distantes . Autrement dit, ne rien insérer dans la spécification de destination.

Si vous essayez de "retirer" une nouvelle branche distante (qui n'existe que sur la télécommande, mais pas localement), voici ce dont vous aurez besoin:

git fetch origin
git checkout --track origin/<remote_branch_name>

Cela suppose que vous souhaitez récupérer l' origine . Sinon, remplacez origine par votre nom de télécommande .

Pour vérifier myBranch qui existe à distance et non localement - Cela a fonctionné pour moi:

git fetch --all
git checkout myBranch

J'ai reçu ce message:

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

Utilisez git branch -a(branches locales et distantes) ou git branch -r(uniquement les branches distantes) pour voir toutes les télécommandes et leurs branches. Vous pouvez ensuite faire un git checkout -t remotes/repo/branchà la télécommande et créer une branche locale.

Il existe également une commande git-ls-remote pour voir toutes les références et balises de cette télécommande.

Le titre et la question sont confus:

• Branche distante git fetch
• comment mon collègue peut-il tirer cette branche en particulier.

Si la question est, comment puis-je obtenir une branche distante pour travailler avec, ou comment puis-je Git checkout une branche distante? , une solution plus simple est:

Avec Git (> = 1.6.6), vous pouvez utiliser:

git checkout <branch_name>

Si local <branch_name>n'est pas trouvé, mais qu'il existe une branche de suivi dans exactement une télécommande avec un nom correspondant, traitez-la comme équivalente à:

git checkout -b <branch_name> --track <remote>/<branch_name>

Voir la documentation de Git checkout

Pour votre ami:

$ git checkout discover
Branch discover set up to track remote branch discover
Switched to a new branch 'discover'

La façon la plus simple de le faire, du moins pour moi:

git fetch origin <branchName> # Will fetch the branch locally
git checkout <branchName> # To move to that branch

Utilisation:

git checkout -b serverfix origin/serverfix

Il s'agit d'une opération suffisamment courante pour que Git fournisse le --trackraccourci:

git checkout --track origin/serverfix

En fait, c'est tellement courant qu'il y a même un raccourci pour ce raccourci. Si le nom de la branche que vous essayez de vérifier (a) n'existe pas et (b) correspond exactement à un nom sur une seule télécommande, Git créera une branche de suivi pour vous:

git checkout serverfix

Pour configurer une branche locale avec un nom différent de la branche distante, vous pouvez facilement utiliser la première version avec un nom de branche locale différent:

git checkout -b sf origin/serverfix

Maintenant, votre succursale locale sftirera automatiquement de origin/serverfix.

Source: Pro Git, 2e édition , écrit par Scott Chacon et Ben Straub (coupé pour la lisibilité)

Avec cette simple commande:

git checkout -b 'your_branch' origin/'remote branch'

Pour récupérer une branche qui existe à distance, la manière la plus simple est:

git fetch origin branchName
git checkout branchName

Vous pouvez voir s'il existe déjà sur une télécommande avec:

git branch -r

Cela ramènera la branche distante à votre section locale et suivra automatiquement la branche distante.

Ce qui m'a aidé, c'est

1) Pour afficher toutes les branches distantes disponibles (par exemple, "nom de la branche distante")

git branch -r

2) Créez une branche locale en utilisant le nom de la branche distante

git fetch && git checkout 'remote-branch-name'

Vous pouvez également récupérer et extraire la branche distante en une seule fois:

git fetch && git checkout the-branch-name

git fetch

git branch -r

git checkout <branch_name>

j'ai tapé $

git checkout <branch_name>

et j'ai

Branch <branch_name> set up to track remote branch <branch_name> from origin.
Switched to a new branch '<branch_name>'

Parfois, on vous demande de ne pas jouer avec la branche principale et de travailler uniquement avec la branche distante (comme on me l'a demandé). Vous n'avez donc besoin que de la succursale distante.

Donc, pour cloner la branche distante seule (sans le maître), faites ceci

git clone url --branch remote_branch_name

où remote_branch_name est le nom de la branche distante

Par exemple,

git clone git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git --branch v3.15

Cela vous permettra de cloner la branche distante vers votre branche locale avec le nom de la branche distante.

Maintenant, si vous validez votre code et que vous le poussez, le code sera soumis à cette seule branche.

[Réponse rapide]

Il existe de nombreuses alternatives, et mes préférées sont:

- Alternative 1:

git fetch --all
git checkout YourBranch

Utiliser cette alternative en utilisant une branche qui existe à distance, mais pas dans votre section locale.

- Alternative 2:

git checkout -b 'YourBranch' origin/'YourRemote'

C'est probablement le moyen le plus simple.

Disons que votre télécommande est git@xyz.git et que vous voulez sa branche random_branch. Le processus devrait être le suivant:

1. Vérifiez d'abord la liste de vos télécommandes par

   git remote -v

2. Si vous n'avez pas la télécommande git@xyz.git dans la sortie de la commande ci-dessus, vous l'ajouteriez en

   git remote add xyz git@xyz.git

3. Vous pouvez maintenant récupérer le contenu de cette télécommande en

   git fetch xyz

4. Maintenant, vérifiez la branche de cette télécommande par

   git checkout -b my_copy_random_branch xyz/random_branch

5. Vérifiez la liste des succursales en

   git branch -a

La branche locale my_copy_random_branch suivrait la branche random_branch de votre télécommande.

git fetch --all & git checkout <branch name>

git fetch && git checkout <your friend's branch name> devrait faire l'affaire

Je veux vous donner une commande à une ligne pour récupérer toutes les branches distantes dans votre section locale et passer à la branche locale que vous venez de créer:

git fetch && git checkout discover

Après avoir exécuté la commande ci-dessus, vous obtiendrez le message ci-dessous:

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

La première ligne indique que vous êtes passé à une nouvelle succursale - pourquoi de nouvelles? Il est déjà là en télécommande!

Mais en fait, vous devez également le créer localement. La branche est extraite de l'index distant et créée localement pour vous.

Voici discoverune nouvelle branche qui a été créée à partir de la branche distante de votre référentieldiscover .

Mais la deuxième ligne donne plus d'informations que la première qui nous dit que:

Notre succursale est configurée pour suivre les succursales distantes du même nom.

Bien qu'il git fetch récupère toutes les branches au niveau local. Mais si vous l'exécutez git branch, vous ne verrez que la masterbranche en local. Pourquoi ?

Parce que pour chaque branche que vous avez à distance, vous devez également la créer localement, pour la suivre comme git checkout <branchname> comme nous l'avons fait dans l'exemple ci-dessus.

Après avoir exécuté la git checkoutcommande, vous pouvez exécuter git branch, et maintenant vous pouvez voir à la fois la branche:

1. maître et 2. découvrir dans votre liste locale.

Si vous souhaitez récupérer toutes les branches distantes, veuillez taper juste:

git fetch --all

Essayez simplement:

git pull origin your_branch_name

Si vous avez un référentiel cloné, la --depth 1plupart des commandes répertoriées ne fonctionneront pas. Par exemple, voir ici

% git clone --depth 1 https://github.com/repo/code
Cloning into 'code'...
cd code
remote: Counting objects: 1778, done.
remote: Compressing objects: 100% (1105/1105), done.
remote: Total 1778 (delta 87), reused 1390 (delta 58), pack-reused 0
Receiving objects: 100% (1778/1778), 5.54 MiB | 4.33 MiB/s, done.
Resolving deltas: 100% (87/87), done.
Checking connectivity... done.
Checking out files: 100% (1215/1215), done.
% cd code
% git checkout other_branch
error: pathspec 'other_branch' did not match any file(s) known to git.
% git fetch origin other_branch
remote: Counting objects: 47289, done.
remote: Compressing objects: 100% (15906/15906), done.
remote: Total 47289 (delta 30151), reused 46699 (delta 29570), pack-reused 0
Receiving objects: 100% (47289/47289), 31.03 MiB | 5.70 MiB/s, done.
Resolving deltas: 100% (30151/30151), completed with 362 local objects.
From https://github.com/repo/code
 * branch            other_branch-> FETCH_HEAD
% git checkout other_branch
error: pathspec 'other_branch' did not match any file(s) known to git.
%

Dans ce cas, je reclonerais le référentiel, mais il existe peut-être d'autres techniques, par exemple git shallow clone (clone --depth) manque des branches distantes

Si vous connaissez déjà votre succursale distante comme ça ...

git remote
=> One
=> Two

et vous connaissez le nom de la branche que vous souhaitez extraire , par exemple, br1.2.3.4 , puis faites

git fetch One
=> returns all meta data of remote, that is, the branch name in question.

Il ne reste plus qu'à commander la succursale

git checkout br.1.2.3.4

Faites-en ensuite de nouvelles branches.

Les étapes sont les suivantes;

1. git fetch originou git fetch --all, cela va chercher toutes les branches distantes dans votre section locale, puis c'est la deuxième option avec laquelle vous pouvez procéder.

2. git checkout --track origin/<The_remote_branch you want to switch over>

Ensuite, travaillez sur cette branche et vous pouvez vérifier si vous êtes sur cette branche ou non en tapant

git branch

Il affiche la branche dans laquelle vous vous trouvez actuellement.

git branch <name> --track origin/<name>

Vérifiez votre .git/configfichier, en particulier le suivi présent lors de la récupération pour cette télécommande.

[remote "randomRemote"]
    url = git@github.com:someUser/someRepo.git
    fetch = +refs/heads/*:refs/remotes/randomRemote/*

Si elle heads/*pointe vers randomRemote/*, lorsque vous exécutezgit fetch randomRemote , il récupérera toutes les branches.

Ensuite, vous pouvez simplement vérifier cette branche.

Autrement,

1. Vous devez ajouter des branches distantes au suivi à l'aide de ceci. Vérifiez votre .git/configaprès avoir exécuté cela. Tu comprendras.

   git remote set-branches --add randomRemote randomBranch
   

2. Courez git fetch randomRemote. Cela va récupérer la branche distante.

3. Vous pouvez maintenant courir git checkout randomBranch.

Vous utilisez «git pull» pour séparer vos branches. J'utiliserai les noms de référentiel et de branche pour vous aider, car «lbranch» et «rbranch» sont difficiles à déchiffrer.

Utilisons:

git init
git pull git@myteam.unfuddle.com:myteam/tlc daves_branch:refs/remotes/origin/daves_branch

Une simple commande git checkout remote_branch_namevous aidera à créer une branche locale qui aura toutes les modifications dans la branche distante.

git checkout -b branch_name
git pull remote_name branch_name