Hoe alle Git-takken op te halen

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:

  1. 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.

  2. 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:

  1. 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.

  2. 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
    
  3. 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.

  1. Zorg ervoor dat u alle vertakkingen op afstand volgt (of welke u ook wilt volgen).
  2. 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 "[email protected]" ) 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 om origin/HEAD
  • te volgen

  • Laat afstandsbedieningen toe met een andere naam dan origin
  • Correct geciteerd
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 [email protected]<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.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes