Ik heb een Git-repository gekloond, die ongeveer vijf branches bevat. Als ik echter git branch
doe, zie ik er maar één van:
$ git branch
* master
Ik weet dat ik git branch -a
kan doen om alle de branches te zien, maar hoe kan ik alle branches lokaal ophalen, dus als ik git branch
, toont het het volgende?
$ git branch
* master
* staging
* etc...
Antwoord 1, autoriteit 100%
Je kunt als volgt alle vertakkingen van alle afstandsbedieningen ophalen:
git fetch --all
Het is eigenlijk een krachtbeweging.
fetch
werkt lokale kopieën van externe vestigingen bij, zodat dit altijd veilig is voor uw lokale vestigingen MAAR:
-
fetch
zal geen lokale vertakkingen bijwerken (die externe vertakkingen volgen); als je je lokale filialen wilt updaten, moet je nog steeds elke tak eruit halen. -
fetch
zal geen lokale vertakkingen maken (die externe vertakkingen tracken), u moet dit handmatig doen. Als u alle externe vestigingen wilt weergeven:
git branch -a
Om lokale vestigingen te bijwerken die externe vestigingen volgen:
git pull --all
Dit kan echter nog steeds onvoldoende zijn. Het werkt alleen voor uw lokale vestigingen die externe vestigingen volgen. Om alle remote branches te volgen, voer je deze oneliner uit VOOR git pull --all
:
git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
TL;DR-versie
git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all
(Het lijkt erop dat pull alle takken van alle afstandsbedieningen ophaalt, maar ik haal altijd eerst op voor de zekerheid.)
Voer het eerste commando alleen uit als er vertakkingen op de server zijn die niet worden gevolgd door uw lokale vertakkingen.
P.S. AFAIK git fetch --all
en git remote update
zijn equivalent.
Kamil Szot’s commentaar, wat mensen nuttig vonden.
Ik moest gebruiken:
for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done
omdat je code lokale filialen heeft gemaakt met de naam
origin/branchname
en
Ik kreeg de melding “refname ‘origin/branchname’ is dubbelzinnig wanneer ik
ernaar verwezen.
Antwoord 2, autoriteit 36%
Om externe vestigingen weer te geven:
git branch -r
Je kunt ze als lokale vestigingen bekijken met:
git checkout -b LocalName origin/remotebranchname
Antwoord 3, autoriteit 8%
Je moet lokale filialen maken die externe filialen volgen.
Ervan uitgaande dat je maar één afstandsbediening hebt met de naam origin
, zal dit fragment lokale vertakkingen maken voor alle vertakkingen op afstand:
for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done
Daarna zal git fetch --all
alle lokale kopieën van remote branches updaten.
Ook git pull --all
zal je lokale tracking branches updaten, maar afhankelijk van je lokale commits en hoe de ‘merge’ configuratie optie is ingesteld kan het een merge commit maken, snel vooruit of mislukken.
Antwoord 4, autoriteit 5%
Als je dat doet:
git fetch origin
dan zijn ze er allemaal lokaal. Als je dan uitvoert:
git branch -a
je ziet ze vermeld als afstandsbedieningen/oorsprong/taknaam. Omdat ze er lokaal zijn, kun je ermee doen wat je wilt. Bijvoorbeeld:
git diff origin/branch-name
of
git merge origin/branch-name
of
git checkout -b some-branch origin/branch-name
Antwoord 5, autoriteit 3%
$ git remote update
$ git pull --all
Hierbij wordt ervan uitgegaan dat alle vertakkingen worden gevolgd.
Als dat niet het geval is, kun je dit in Bash afvuren:
for remote in `git branch -r `; do git branch --track $remote; done
Voer vervolgens de opdracht uit.
Antwoord 6, autoriteit 3%
De Bash for
-lus werkte niet voor mij, maar dit deed precies wat ik wilde. Alle takken van mijn oorsprong gespiegeld als dezelfde naam lokaal.
git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'
Zie Mike DuPont‘s opmerking hieronder. Ik denk dat ik dit probeerde te doen op een Jenkins-server die het in de modus voor losse kop laat.
Antwoord 7, autoriteit 2%
Gebruik git fetch && git checkout RemoteBranchName
.
Het werkt heel goed voor mij…
Antwoord 8, autoriteit 2%
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”.
Er is echter een veel schonere en snellere manier, hoewel het een beetje ingewikkeld is. Je hebt drie stappen nodig om dit te bereiken:
-
Eerste stap
maak een nieuwe lege map op je computer en kloon 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 nu alleen een verborgen .git-map die je kunt zien met een “ls -alt”-opdracht vanaf de terminal.
-
Tweede stap
schakel deze repository van een lege (kale) repository naar een gewone repository door de booleaanse waarde “bare” van de git-configuraties te veranderen in false:
$ git config --bool core.bare false
-
Derde stap
Pak alles wat in de huidige map staat en maak alle branches op de lokale machine, waardoor dit een normale repo wordt.
$ git reset --hard
Dus nu kun je gewoon het commando git branch
typen en je kunt zien dat alle branches zijn gedownload.
Dit is de snelle manier waarop je een git-repository met alle branches tegelijk kunt klonen, maar het is niet iets dat je op deze manier voor elk afzonderlijk project wilt doen.
Antwoord 9
Je kunt alle takken ophalen door:
git fetch --all
of:
git fetch origin --depth=10000 $(git ls-remote -h -t origin)
De parameter --depth=10000
kan helpen als je de repository ondieper hebt gemaakt.
Om alle takken te trekken, gebruik je:
git pull --all
Als bovenstaande niet werkt, laat dan de bovenstaande opdracht voorafgaan met:
git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'
omdat de remote.origin.fetch
alleen een specifieke branch kon ondersteunen tijdens het ophalen, vooral wanneer je je repo kloonde met --single-branch
. Controleer dit door: git config remote.origin.fetch
.
Daarna zou u elk filiaal moeten kunnen afrekenen.
Zie ook:
Om alle takken naar de afstandsbediening te duwen, gebruik:
git push --all
uiteindelijk --mirror
om alle referenties te spiegelen.
Als het uw doel is om een repository te dupliceren, zie: Een repository dupliceren artikel op GitHub.
Antwoord 10
Ik gebruik meestal niets anders dan commando’s als deze:
git fetch origin
git checkout --track origin/remote-branch
Een iets kortere versie:
git fetch origin
git checkout -t origin/remote-branch
Antwoord 11
Je ziet de vertakkingen niet omdat je ze niet volgt.
- Zorg ervoor dat u alle vertakkingen op afstand volgt (of welke u ook wilt volgen).
- Update uw lokale vestigingen om de externe vestigingen weer te geven.
Alle afgelegen vertakkingen volgen:
Volg alle vertakkingen die in de externe repo bestaan.
Handmatig doen:
Je zou <branch>
vervangen door een branch die wordt weergegeven uit de uitvoer van git branch -r
.
git branch -r
git branch --track <branch>
Doe het met een bash-script:
for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done
Luie manier (dit kan een puinhoop veroorzaken door samenvoegconflicten, wees voorzichtig):
git checkout master
git pull
Update informatie over de vertakkingen op uw lokale computer:
Hiermee worden updates opgehaald over branches van de externe repo die u bijhoudt in uw lokale repo. Dit verandert niets aan uw lokale vestigingen. Je lokale git-repo is nu op de hoogte van dingen die zijn gebeurd op de externe repo-takken. Een voorbeeld zou zijn dat er een nieuwe commit naar de remote master is gepusht. Als je een fetch doet, wordt je nu gewaarschuwd dat je lokale master 1 commit achterloopt.
git fetch --all
Update informatie over de externe vertakkingen op uw lokale computer en werk lokale vertakkingen bij:
Voert een fetch uit gevolgd door een merge voor alle branches van de remote naar de lokale branch. Een voorbeeld zou zijn dat een nieuwe commit naar de remote master is gepusht, het doen van een pull zal je lokale repo updaten over de veranderingen in de remote branch en dan zal het die veranderingen mergen in je lokale branch. Dit kan een behoorlijke rommel veroorzaken door samenvoegconflicten.
git pull --all
Antwoord 12
Ik geloof dat je de repository hebt gekloond door:
git clone https://github.com/pathOfrepository
Ga nu naar die map met cd:
cd pathOfrepository
Als je git status
typt, kun je alles zien:
On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean
Om alle verborgen vertakkingstypes te zien:
git branch -a
Het geeft een lijst van alle vertakkingen op afstand.
Als je nu wilt afrekenen in een bepaald filiaal, typ dan gewoon:
git checkout -b localBranchName origin/RemteBranchName
Antwoord 13
Als je hier een oplossing zoekt om alle branches te krijgen en vervolgens alles naar een andere Git-server te migreren, heb ik het onderstaande proces samengesteld. Als je alle vestigingen lokaal wilt bijwerken, stop dan bij de eerste lege regel.
git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F'origin/' '!/HEAD|master/{print $2 " " $1"origin/"$2}' | xargs -L 1 git branch -f --track
git fetch --all --prune --tags
git pull --all
git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>
Antwoord 14
Zorg ervoor dat alle vertakkingen op afstand kunnen worden opgehaald in het bestand .git/config
.
In dit voorbeeld is alleen de branch origin/production
ophaalbaar, zelfs als je git fetch --all
probeert te doen, gebeurt er niets behalve het ophalen van de production
tak:
[origin]
fetch = +refs/heads/production:refs/remotes/origin/production
Deze regel moet worden vervangen door:
[origin]
fetch = +refs/heads/*:refs/remotes/origin/*
Voer vervolgens git fetch
enz. uit…
Antwoord 15
Nadat je de hoofdrepository hebt gekloond, kun je het gewoon uitvoeren
git fetch && git checkout <branchname>
Antwoord 16
Alleen deze drie commando’s zullen alle branches krijgen:
git clone --mirror repo.git .git (gets just .git - bare repository)
git config --bool core.bare false
git reset --hard
Antwoord 17
Alle Git-takken ophalen die één afstandsbediening volgen.
Dit is getest en werkt op Red Hat en Git Bash op Windows 10.
TLDR:
for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;
Uitleg:
De oneliner checkt uit en haalt vervolgens alle takken op behalve HEAD.
Maak een lijst van de vertakkingen die op afstand worden gevolgd.
git branch -r
Negeer HEAD.
grep -v ' -> '
Vertakkingsnaam van afstandsbediening(en) halen.
cut -d"/" -f2
Bekijk alle vestigingen die een enkele afstandsbediening volgen.
git checkout $branch
Ophalen voor uitgecheckte vestiging.
git fetch
Technisch gezien is het ophalen niet nodig voor nieuwe lokale vestigingen.
Dit kan worden gebruikt om vertakkingen fetch
of pull
die beide nieuw zijn en wijzigingen hebben in afstandsbediening(en).
Zorg er wel voor dat je alleen pullt als je klaar bent om samen te voegen.
Testopstelling
Bekijk een repository met SSH-URL.
git clone [email protected]
Vóór
Controleer lokale vestigingen.
$ git branch
* master
Opdrachten uitvoeren
Voer de oneliner uit.
for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;
Na
Controleer of lokale vestigingen ook externe(n) vestigingen bevatten.
$ git branch
cicd
master
* preprod
Antwoord 18
Looping leek niet te werken voor mij en ik wilde origin/master negeren.
Dit is wat voor mij werkte.
git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track
Daarna:
git fetch --all
git pull --all
Antwoord 19
Ik heb een klein script geschreven om het klonen van een nieuwe repo te beheren en lokale vertakkingen te maken voor alle vertakkingen op afstand.
Je kunt de nieuwste versie hier vinden:
#!/bin/bash
# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)
clone_output=$((git clone "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1
this_branch=$(git branch | sed 's/^..//')
for i in $(git branch -r | grep -v HEAD); do
branch=$(echo $i | perl -pe 's/^.*?\///')
# this doesn't have to be done for each branch, but that's how I did it.
remote=$(echo $i | sed 's/\/.*//')
if [[ "$this_branch" != "$branch" ]]; then
git branch -t $branch $remote/$branch
fi
done
popd > /dev/null 2>&1
Om het te gebruiken, kopieer je het gewoon naar je git bin directory (voor mij is dat C:\Program Files (x86)\Git\bin\git-cloneall
), en dan op de opdrachtregel:
git cloneall [standard-clone-options] <url>
Het kloont zoals gewoonlijk, maar creëert lokale volgvertakkingen voor alle vertakkingen op afstand.
Antwoord 20
Dit is iets dat ik als robuust zou beschouwen:
- Werkt tracking op afstand voor bestaande filialen niet bij
- Probeer
HEAD
niet bij te werken omorigin/HEAD
- Laat afstandsbedieningen toe met een andere naam dan
origin
- Correct geciteerd
te volgen
for b in $(git branch -r --format='%(refname:short)'); do
[[ "${b#*/}" = HEAD ]] && continue
git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all
Het is niet nodig om git fetch --all
te gebruiken omdat het doorgeven van -all
aan git pull
deze optie doorgeeft aan de interne fetch
.
Met dank aan dit antwoord.
Antwoord 21
Alias instellen: (gebaseerd op het bovenste antwoord)
git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'
Nu alle takken volgen:
git track-all-branches
Antwoord 22
Voor Windows-gebruikers die PowerShell gebruiken:
git branch -r | ForEach-Object {
# Skip default branch, this script assumes
# you already checked-out that branch when cloned the repo
if (-not ($_ -match " -> ")) {
$localBranch = ($_ -replace "^.*?/", "")
$remoteBranch = $_.Trim()
git branch --track "$localBranch" "$remoteBranch"
}
}; git fetch --all; git pull --all
Antwoord 23
Als je problemen hebt met fetch --all
volg dan je remote branch:
git checkout --track origin/%branchname%
Antwoord 24
|?????????????fetch/clone????????????v |????????????checkout??????????v
|???????????????????????????????????pull????????????????????????????????v
Remote repository (`origin`) <=> Local repository <=> Index <=> Workspace
^_________________push_______________| ^____commit____| ^____add_____|
# ???????????? > ????
# fetch all remote repository branch meta > local repository
git remote set-branches origin '*'
git fetch -v
# ?????????????
# fetch all remote repository branch data > local repository
git branch -r | grep -v '\->' | while read remote; do git branch "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all
Antwoord 25
u kunt alle braches als volgt ophalen met dit commando van één regel:
git fetch --all && git pull --all && git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
Antwoord 26
We kunnen alle namen van vertakkingen of tags in een tijdelijk bestand plaatsen, en dan git pull doen voor elke naam/tag:
git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done
Antwoord 27
Hier is een Perl-versie van de one-liner in het geaccepteerde antwoord:
git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file
Je kunt het uitvoerbestand als een Shell-script uitvoeren als je wilt.
We hebben onze Stash-projectrepository per ongeluk verwijderd. Gelukkig had iemand vlak voor het onopzettelijke verlies een vork gemaakt. Ik heb de vork gekloond naar mijn lokale (zal de details weglaten van hoe ik dat deed). Toen ik de vork eenmaal volledig in mijn lokaal had, liep ik een one-liner. Ik heb de URL van de afstandsbediening gewijzigd (oorsprong in mijn geval) om te verwijzen naar de doelrepository waarnaar we aan het herstellen waren:
git remote set-url origin <remote-url>
En tenslotte duwden alle takken naar de oorsprong, zoals zo:
git push --all origin
en we waren weer aan het werk.
Antwoord 28
Ik heb veel manieren geprobeerd, alleen deze is eenvoudig en werkt voor mij.
for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
git checkout "$branch"
git pull
done
Antwoord 29
Om de foutmelding ‘fatal: Er bestaat al een branch met de naam ‘origin/master’ te vermijden.’, kun je mijn oplossing proberen:
git branch -r | grep -v '\->' | grep -v `git branch | awk '/\*/ { print $2; }'`| while read remote; do git branch --track "${remote#origin/}" "$remote"; done
Antwoord 30
Op basis van het antwoord van Learath2 is dit wat ik deed nadat ik git clone [...]
en cd
-ing in de aangemaakte directory deed:
git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b
Werkte voor mij, maar ik weet niet of het voor jou zal werken. Wees voorzichtig.