git - Hoe klonen alle externe takken in Git?

Ik heb een masteren een developmentBranch, beide naar Github . Ik heb cloneD, pullED, en fetchED, maar ik blijf niet in staat om iets anders te krijgen dan de masterTak terug.

Ik weet zeker dat ik iets duidelijk mis, maar ik heb de handleiding gelezen en ik krijg helemaal geen vreugde.

1, Autoriteit 100%

eerst, klonen een afstandsbediening git repository en CD erin:

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

Bekijk de lokale takken in uw repository:

$ git branch
* master

Maar er zijn andere takken die zich in uw repository verstopt! U kunt deze zien met behulp van de -avlag:

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

Als u gewoon een snelle kijkje wilt nemen bij een stroomopwaartse tak, kunt u het rechtstreeks bekijken:

$ git checkout origin/experimental

Maar als u aan die tak wilt werken, moet u een lokale trackingtak maken die automatisch wordt uitgevoerd door:

$ git checkout experimental

en u ziet

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

Hier betekent “nieuwe vertakking” eenvoudig dat de vertakking uit de index wordt gehaald en lokaal voor u wordt gemaakt. Zoals de vorigeregel je vertelt, wordt de vertakking ingesteld om de vertakking op afstand te volgen, wat meestal de vertakking origin/branch_name betekent.

Als je nu naar je lokale vestigingen kijkt, zie je dit:

$ git branch
* experimental
  master

Je kunt meer dan één externe repository volgen met 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

Op dit moment worden de dingen behoorlijk gek, dus voer gitkuit om te zien wat er aan de hand is:

$ gitk --all &

Antwoord 2, autoriteit 18%

Als je veel remote branches hebt die je in één keer wilt ophalen, doe dan:

$ git pull --all

Je kunt nu elke branch afrekenen als dat nodig is, zonder naar de externe repository te gaan.

Opmerking:dit zal geen werkkopieën maken van niet-uitgecheckte branches, wat de vraag was. Zie daarvoor

Antwoord 3, autoriteit 10%

Dit Bash-script heeft me geholpen:

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

Het maakt trackingtakken voor alle externe filialen, behalve Master (die je waarschijnlijk van de oorspronkelijke kloonopdracht hebt). Ik denk dat je nog steeds een

nodig hebt

git fetch --all
git pull --all

om zeker te zijn.

één voering : 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
Zoals gewoonlijk: test in uw setup voordat u RM -RF-universum kopieert zoals wij het kennen

Credits voor one-liner Ga naar gebruiker CFI

4, Autoriteit 8%

Gebruik van de --mirrorOptie lijkt de remoteTakken naar behoren te kopiëren.
Het bevat echter de repository als een blote repository, dus u moet het daarna teruggaan naar een normale repository.

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

^{Referentie: git FAQ: Hoe kan ik een repository klonen Met alle op afstand gevolgde takken?}

5, Autoriteit 5%

U kunt eenvoudig overschakelen naar een filiaal zonder de fancy “Git Checkout -B Sybranch Origin / Sybranch” -syntaxis te gebruiken. U kunt doen:

git checkout somebranch

Git doet automatisch het juiste ding:

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

Git zal controleren of een branch met dezelfde naam in precies één remote bestaat, en als dat zo is, volgt het het op dezelfde manier alsof je expliciet had gespecificeerd dat het een remote branch is. Van de git-checkout man-pagina van Git 1.8.2.1:

Als <tak> wordt niet gevonden, maar er bestaat wel een tracking-branch in
precies één afstandsbediening (noem het <remote>) met een overeenkomende naam, behandel als
gelijk aan
$ git checkout -b <branch> --track <remote>/<branch>

Antwoord 6, autoriteit 2%

Met betrekking tot,

$ git checkout -b experimentele oorsprong/experimenteel

met

$ git checkout -t origin/experimental

of de meer uitgebreide maar gemakkelijker te onthouden

$ git checkout --track origin/experimental

misschien beter, in termen van het volgen van een externe repository.

Antwoord 7, autoriteit 2%

De fetch die je aan het doen bent, zou alle remote branches moeten krijgen, maar er worden geen lokale branches voor gemaakt. Als je gitk gebruikt, zou je de remote branches moeten zien die worden beschreven als “remotes/origin/dev” of iets dergelijks.

Als u een lokale vertakking wilt maken op basis van een vertakking op afstand, doet u zoiets als:

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

Dat zou iets moeten opleveren als:

Branch dev ingesteld om remote branch refs/remotes/origin/dev te volgen.
Overgeschakeld naar een nieuwe tak "dev"

Als je nu in de dev branch bent, zal “git pull” je lokale dev updaten naar hetzelfde punt als de remote dev branch. Merk op dat het alle takken zal halen, maar alleen degene waar je op zit naar de top van de boom zal trekken.

Antwoord 8

Gebruik aliassen. Hoewel er geen native Git-oneliners zijn, kun je die van jezelf definiëren als

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

en gebruik het dan als

git clone-branches

Antwoord 9

Als je “git clone git://location” doet, worden alle branches en tags opgehaald.

Om bovenop een specifieke remote branch te werken, aangenomen dat dit de origin remote is:

git checkout -b branch origin/branchname

Antwoord 10

Beter laat dan nooit, maar dit is de beste manier om dit te doen:

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

Op dit punt heb je een volledige kopie van de externe repo met al zijn vertakkingen (verifieer met git branch). U kunt --mirrorgebruiken in plaats van --bareals uw externe opslagplaats eigen afstandsbedieningen heeft.

Antwoord 11

Waarom je alleen “master” ziet

git clonedownloadt alle remote branches maar beschouwt ze nog steeds als “remote”, ook al bevinden de bestanden zich in je nieuwe repository. Er is één uitzondering hierop, en dat is dat het kloonproces een lokale branch genaamd “master” creëert van de remote branch genaamd “master”. Standaard toont git branchalleen lokale branches, daarom zie je alleen “master”.

git branch -atoont alle branches, inclusief remote branches.

Hoe krijg je lokale vestigingen

Als je echt aan een branch wilt werken, wil je waarschijnlijk een “lokale” versie ervan. Om eenvoudig lokale branches te maken van remote branches (zonder ze uit te checken en daardoor de inhoud van je werkdirectory te veranderen), kun je dat als volgt doen:

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

In dit voorbeeld is branchonede naam van een lokale branch die u aanmaakt op basis van origin/branchone; als u in plaats daarvan lokale vestigingen met verschillende namen wilt maken, kunt u dit doen:

git branch localbranchname origin/branchone

Als je eenmaal een lokale branch hebt gemaakt, kun je deze zien met git branch(onthoud dat je geen -anodig hebt om lokale branches te zien).

Antwoord 12

Dit is niet al te ingewikkeld, heel eenvoudige en ongecompliceerde stappen zijn als volgt;

git fetch originDit zal alle remote branches naar je local brengen.

git branch -aDit zal je alle remote branches tonen.

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

Controleer of u zich in de gewenste branch bevindt met het volgende commando;

git branch

De uitvoer zal dit leuk vinden;

*your current branch 
some branch2
some branch3

Let op het *-teken dat de huidige tak aangeeft.

Antwoord 13

Doe dit gewoon:

$ 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

Zie je, ‘git clone git://example.com/myprojectt’ haalt alles op, zelfs de branches, je hoeft ze alleen maar af te rekenen, dan wordt je lokale branch gemaakt.

Antwoord 14

Je hoeft alleen “git clone” te gebruiken om alle branches te krijgen.

git clone <your_http_url>

Ook al zie je alleen de master branch, je kunt “git branch -a” gebruiken om alle branches te zien.

git branch -a

En je kunt overschakelen naar elke tak die je al hebt.

git checkout <your_branch_name>

Maak je geen zorgen dat nadat je “git clone” hebt gebruikt, je geen verbinding hoeft te maken met de externe repo, “git branch -a” en “git checkout” succesvol kunnen worden uitgevoerd wanneer je je wifi sluit. Het is dus bewezen dat wanneer je “git clone” doet, het al alle branches van de externe repo heeft gekopieerd. Daarna heb je de externe repo niet meer nodig, je local heeft al de codes van alle filialen.

Antwoord 15

Een git clonewordt verondersteld de hele repository te kopiëren. Probeer het te klonen en voer dan git branch -auit. Het zou alle takken moeten vermelden. Als je wilt overschakelen naar branch “foo” in plaats van “master”, gebruik dan git checkout foo.

Antwoord 16

alle antwoorden die ik hier heb gezien zijn geldig, maar er is een veel schonere manier om een repository te klonen en alle takken tegelijk te verwijderen.

Als je een repository kloont, wordt alle informatie van de vertakkingen daadwerkelijk gedownload, maar de vertakkingen worden verborgen. Met het commando

$ git branch -a

je kunt alle takken van de repository tonen, en met het commando

$ git checkout -b branchname origin/branchname

je kunt ze dan een voor een handmatig “downloaden”.

Als je echter een repo met veel takken wilt klonen, zijn alle hierboven geïllustreerde manieren lang en vervelend met betrekking tot een veel schonere en snellere manier die ik ga laten zien, hoewel het een beetje ingewikkeld is. Je hebt drie stappen nodig om dit te bereiken:

eerste stap

Maak een nieuwe lege map op uw machine en klonen een spiegelkopie van de .git-map uit de repository:

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

De lokale repository in de map My_repo_Folder is nog steeds leeg, er is slechts een verborgen map nu dat u kunt zien met een “LS -ALT” -opdracht uit de terminal.

tweede stap

Schakel deze repository van een lege (bloot) opslagplaats naar een reguliere repository door de Booleaanse waarde “Bare” van de GIT-configuraties naar False te schakelen:

$ git config --bool core.bare false

derde stap

Grijp alles wat in de huidige map en maak alle takken op de lokale machine en maak daarom dit een normale repo.

$ git reset --hard

Dus nu kunt u de opdracht “Git Branch” gewoon typen en u kunt zien dat alle takken worden gedownload.

Dit is de snelle manier waarop je een git-repository met alle takken tegelijk kunt klonen, maar het is niet iets dat je op deze manier voor elk project wilt doen.

17

Gebruik mijn gereedschap git_remote_branch ( U hebt Ruby op uw machine geïnstalleerd nodig). Het is speciaal gebouwd om afgelegen filiaalmanipulaties dood te maken.

Elke keer dat het namens u een bewerking doet, drukt het in rood op de console. In de loop van de tijd blijven ze eindelijk in je hersenen: -)

Als u geen GRB wilt uitvoeren opdracht namens u, gebruik dan gewoon de functie ‘Uitleg’. De opdrachten worden op uw console afgedrukt in plaats van uitgevoerd voor u.

Ten slotte hebben alle opdrachten aliassen, om memorisatie gemakkelijker te maken.

Merk op dat dit Alpha Software ; -)

Hier is de hulp wanneer u GRB-hulp uitvoert:

git_remote_branch versie 0.2.6
 Gebruik:
 GRB Create Branch_Name [Origin_Server]
 GRB Publish Branch_Name [Origin_Server]
 GRB Hernoemen Branch_Name [Origin_Server]
 GRB Delete Branch_Name [Origin_Server]
 GRB Track Branch_Name [Origin_Server]
 Notities:
 - Als Origin_Server niet is opgegeven, wordt de naam 'Origin' verondersteld
  (Git's standaard)
 - de hernoemingsfunctionaliteit hernoemt de huidige tak
 Het uitleg meta-opdracht: u kunt ook een opdracht met de
trefwoord 'uitleg'. In plaats van het uitvoeren van de opdracht, git_remote_branch
wordt eenvoudig de lijst met opdrachten uitgevoerd die u moet uitvoeren om te bereiken
dat doel.
 Voorbeeld:
  GRB verklaren
  Grb verklarend My_Branch Github
 Alle opdrachten hebben ook aliassen:
 CREATE: CREËER, NIEUW
 Verwijderen: Verwijderen, vernietigen, doden, verwijderen, rm
 Publiceren: Publiceren, Remotize
 Hernoemen: Hernoemen, RN, MV, Move
 TRACK: TRACK, VOLG, GRAKEN, FETCH

Antwoord 18

Klonen vanuit een lokale repo werkt niet met git clone & git fetch: veel branches/tags blijven niet opgehaald.

Om een kloon te krijgen met alle branches en tags.

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

Om een kloon te krijgen met alle branches en tags maar ook met een werkkopie:

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

Antwoord 19

Als ik naar een van de antwoorden op de vraag kijk, zie ik dat het mogelijk is om deze in te korten:

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

Maar pas op, als een van de afgelegen takken wordt genoemd als b.v. admin_master het wordt niet gedownload!

Met dank aan bigfish voor origineel idee

Antwoord 20

OK,als je je repo kloont, heb je daar alle takken…

Als je gewoon git branchdoet, zijn ze een beetje verborgen…

Dus als je de naam van alle takken wilt zien, voeg dan gewoon de vlag --allals volgt toe:

git branch --allof git branch -a

Als je gewoon naar het filiaal afrekent, krijg je alles wat je nodig hebt.

Maar hoe zit het als de branch die door iemand anders is gemaakt nadat je hebt gekloond?

Doe in dit geval gewoon:

git fetch

en controleer alle takken opnieuw…

Als u tegelijkertijd wilt ophalen en afrekenen, kunt u het volgende doen:

git fetch && git checkout your_branch_name

Ik heb ook de onderstaande afbeelding voor je gemaakt om te vereenvoudigen wat ik zei:

Antwoord 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

Deze code haalt alle externe filialencode naar de lokale repo.

Antwoord 22

Voor kopiëren en plakken naar de opdrachtregel:

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

Voor meer leesbaarheid:

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

Dit zal:

check master uit (zodat we de branch kunnen verwijderen waarop we ons bevinden)
selecteer afstandsbedieningom af te rekenen (verander het in welke afstandsbediening je ook hebt)
loop door alle takkenvan de afstandsbediening behalve master en HEAD
1. verwijderlokale vestiging (zodat we geforceerde bijgewerkte vestigingen kunnen bekijken)
2. bekijkbranch vanaf de afstandsbediening
kijk eens naar meester (ter wille van het)

Gebaseerd op antwoordvan VonC.

Antwoord 23

Geen van deze antwoorden volstaat, behalve dat de gebruiker niemand op de goede weg is.

I had problemen met het verplaatsen van een repository van de ene server / naar het andere. Toen ik de repo gekloond, het alleen creëerde een lokale vestiging voor master dus toen ik naar de nieuwe afstandsbediening geduwd werd slechts master branch geduwd.

Zo vond ik deze twee methoden zeer nuttig. Hoop dat ze hulp van iemand anders.

Methode 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

Methode 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

24

Ik schreef dit kleine Powershell functies in staat zijn om al mijn git takken, die op herkomst remote kassa.

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

Meer git functies is te vinden op mijn git instellingen repo

25

Hier is een antwoord dat gebruik awk. Deze methode zou voldoende moeten zijn als het gebruikt wordt op een nieuwe repo.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

Bestaande takken worden eenvoudigweg uitgecheckt of gedeclareerd, maar filters kunnen worden toegevoegd om de conflicten te voorkomen.

Het kan ook worden gewijzigd, dus het noemt een expliciete git checkout -b <branch> -t <remote>/<branch>opdracht.

Dit antwoord volgt nikos c. ‘s IDEE .

U kunt in plaats daarvan de afstandsbediening opgeven. Dit is gebaseerd op Murphytalk ‘s Antwoord .

git branch -r | awk '{ system("git checkout -t " $NF) }'

Het gooit fatale foutmeldingen op conflicten, maar ik zie ze onschadelijk.

Beide opdrachten kunnen aliased zijn.

niemand ‘s Antwoord als referentie, we kunnen de volgende opdrachten hebben om de aliassen te maken:

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) }"'

Persoonlijk gebruik ik track-allof track-all-branches.

26

git clone --mirrorOp de originele Repo werkt hier goed voor.

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

27

Ik moest precies hetzelfde doen. Hier is mijn 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]

28

Hier is nog een opdracht voor korte one-liner die
Creëert lokale takken voor alle afgelegen filialen:

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

Het werkt ook correct als het volgen van lokale filialen al zijn gemaakt.
U kunt het na de eerste git cloneof op elk gewenst moment later noemen.

Als u niet hoeft te hebben masterBTIK GECONTROLEERD NA CLONING, GEBRUIKT

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

29

Git meestal (wanneer niet opgegeven) haalt alle takken en / of tags (refs, zie: git ls-refs) van de ene of meer andere repositories samen met de objecten die nodig zijn om hun geschiedenis te voltooien. Met andere woorden, het haalt de objecten die bereikbaar zijn door de objecten die al zijn gedownload. Zie: Wat doet git fetchecht doen?

Soms heeft u mogelijk filialen / tags die niet rechtstreeks verbonden zijn met de huidige, dus git pull --all/ git fetch --allHulp in dat geval, maar u kunt ze vermelden op:

git ls-remote -h -t origin

Haal ze handmatig op door de ref-namen te kennen.

Dus naar haal ze allemaal , probeer:

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

^{De --depth=10000Parameter kan helpen als u onjuist bent geworden.}

Controleer vervolgens al uw branches:

git branch -avv

Als hierboven zal niet helpen, moet u missing takken handmatig toevoegen aan de gevolgde lijst (zoals ze op de een of andere manier zijn verdwenen):

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

door git remote set-branchesLike:

git remote set-branches --add origin missing_branch

Dus het kan verschijnen onder remotes/originna 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

Problemen oplossen

Als u nog steeds niets anders dan de hoofdtak kunt krijgen, controleert u de volgende:

Controleer uw afstandsbedieningen (git remote -v), b.v.
- valideren dat git config branch.master.remoteis origin.
- Controleer of originPunten naar de juiste URL Via: git remote show origin(zie deze Post ).

Hoe klonen alle externe takken in Git?