Io e il mio collega stiamo lavorando allo stesso repository. L'abbiamo ramificato in due rami, ognuno tecnicamente per progetti diversi, ma hanno somiglianze, quindi a volte vorremmo impegnarci di nuovo con il * masterda branch.

Tuttavia, ho il branch. Come può il mio collega tirare quel ramo in particolare?

A git clonedel repository non sembra creare i rami localmente per lui, anche se riesco a vederli dal vivo srotolati dopo una spinta sulla mia estremità.

Inoltre, quando ho originariamente creato il ramo, l'ho fatto -b checkout. Fa molta differenza?

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

$ git fetch origin discover
$ git checkout discover

Questi sono i comandi che ho eseguito. Ma sicuramente non funziona.

Voglio essere in grado di controllare quel ramo e quindi spingere e impegnare solo i cambiamenti dei rami da vari collaboratori o stazioni di lavoro .

È necessario creare un ramo locale che tiene traccia di un ramo remoto. Il comando seguente creerà un ramo locale chiamato daves_branch , tenendo traccia dell'origine del ramo remoto / daves_branch . Quando si spingono le modifiche, il ramo remoto verrà aggiornato.

Per le versioni più recenti di Git:

git checkout --track origin/daves_branch

--trackè una scorciatoia per git checkout -b [branch] [remotename]/[branch]cui [remotename] è origine in questo caso e [branch] è il doppio dello stesso, daves_branch in questo caso.

Per Git 1.5.6.5 avevi bisogno di questo:

git checkout --track -b daves_branch origin/daves_branch

Per Git 1.7.2.3 e versioni successive, questo è sufficiente (potrebbe essere iniziato prima, ma questa è la prima conferma che ho trovato rapidamente):

git checkout daves_branch

Nota che con le recenti versioni di Git, questo comando non creerà un ramo locale e ti metterà in uno stato di "HEAD distaccato". Se si desidera un ramo locale, utilizzare l' --trackopzione.

I dettagli completi sono qui: 3.5 Git Branching - Branch remoti, Tracking Branches

Ho usato fetchseguito da checkout...

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

... dove si <rbranch>trova il ramo remoto o riferimento sorgente ed <lbranch>è il ramo locale ancora inesistente o riferimento destinazione che si desidera tracciare e che probabilmente si desidera denominare lo stesso ramo remoto o riferimento sorgente. Questo è spiegato sotto le opzioni nella spiegazione di <refspec>.

Git è così intelligente che auto completa il primo comando se scheda dopo le prime lettere del ramo remoto. Cioè, non devo nemmeno nominare il ramo locale, Git copia automaticamente il nome del ramo remoto per me. Grazie Git!

Inoltre, come mostra la risposta in questo post Stack Overflow simile , se non fetchassegni un nome al ramo locale , puoi comunque crearlo quando lo controlli usando il -bflag. Cioè, git fetch <remote> <branch> seguito da git checkout -b <branch> <remote>/<branch>fa esattamente lo stesso della mia risposta iniziale. Ed evidentemente, se il repository ha un solo telecomando, allora si può solo fare git checkout <branch>dopo fetche creerà una filiale locale per voi. Ad esempio, hai appena clonato un repository e vuoi controllare rami aggiuntivi dal telecomando.

Credo che parte della documentazione per fetchpotrebbe essere stata copiata alla lettera pull. In particolare la sezione relativa <refspec>a opzioni è lo stesso. Tuttavia, non credo che lo fetchfarà mai merge, quindi se si lascia vuoto il lato di destinazione del colon, fetch non si dovrebbe fare nulla .

NOTA: git fetch <remote> <refspec>è l'abbreviazione per git fetch <remote> <refspec>:cui quindi non farebbe nulla, ma git fetch <remote> <tag>è lo stesso git fetch <remote> <tag>:<tag>che dovrebbe copiare il telecomando <tag>localmente.

Immagino che ciò sia utile solo se si desidera copiare un ramo remoto localmente, ma non è necessario verificarlo immediatamente. Altrimenti, ora userei la risposta accettata , che è spiegata in dettaglio nella prima sezione della descrizione del checkout e successivamente nella sezione delle opzioni sotto la spiegazione di --track, dal momento che è una riga. Beh ... una specie di one-liner, perché dovresti comunque correre per git fetch <remote>primo.

Cordiali saluti: L'ordine del <refspecs>(fonte: destinazione) spiega il bizzarro metodo pre-Git 1.7 per cancellare i rami remoti . Cioè, non inserire nulla nel refspec di destinazione.

Se stai cercando di "estrarre" un nuovo ramo remoto (che esiste solo sul telecomando, ma non localmente), ecco cosa ti servirà:

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

Ciò presuppone che si desideri recuperare dall'origine . In caso contrario, sostituire l' origine con il nome remoto .

Per verificare myBranch che esiste in remoto e non localmente - Questo ha funzionato per me:

git fetch --all
git checkout myBranch

Ho ricevuto questo messaggio:

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

Utilizzare git branch -a(filiali locali e remote) o git branch -r(solo filiali remote) per vedere tutti i telecomandi e i loro rami. È quindi possibile eseguire una operazione git checkout -t remotes/repo/branchsul telecomando e creare un ramo locale.

C'è anche un comando git-ls-remote per vedere tutti i ref e i tag per quel telecomando.

Il titolo e la domanda sono confusi:

• Git recupera ramo remoto
• come può il mio collega tirare quel ramo in particolare.

Se la domanda è: come posso ottenere un ramo remoto con cui lavorare o come posso fare il checkout di un ramo remoto? , una soluzione più semplice è:

Con Git (> = 1.6.6) puoi usare:

git checkout <branch_name>

Se local <branch_name>non viene trovato, ma esiste un ramo di tracciamento esattamente in un telecomando con un nome corrispondente, trattalo come equivalente a:

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

Vedi la documentazione per il checkout di Git

Per il tuo amico:

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

Il modo più semplice per farlo, almeno per me:

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

Uso:

git checkout -b serverfix origin/serverfix

Questa è un'operazione abbastanza comune che Git fornisce la --trackscorciatoia:

git checkout --track origin/serverfix

In effetti, questo è così comune che esiste anche una scorciatoia per quella scorciatoia. Se il nome del ramo che stai provando a verificare (a) non esiste e (b) corrisponde esattamente a un nome su un solo telecomando, Git creerà un ramo di monitoraggio per te:

git checkout serverfix

Per impostare un ramo locale con un nome diverso rispetto al ramo remoto, è possibile utilizzare facilmente la prima versione con un nome di ramo locale diverso:

git checkout -b sf origin/serverfix

Ora, il tuo ramo locale sfverrà automaticamente estratto da origin/serverfix.

Fonte: Pro Git, 2nd Edition , scritto da Scott Chacon e Ben Straub (tagliato per leggibilità)

Con questo semplice comando:

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

Per recuperare un ramo esistente sul telecomando, il modo più semplice è:

git fetch origin branchName
git checkout branchName

Puoi vedere se esiste già sul telecomando con:

git branch -r

Questo porterà il ramo remoto al tuo locale e seguirà automaticamente quello remoto.

Ciò che mi ha aiutato è stato

1) Per visualizzare tutti i rami remoti disponibili (ad es. "Nome ramo remoto")

git branch -r

2) Creare una filiale locale usando il nome della filiale remota

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

Puoi anche recuperare ed estrarre il ramo remoto in un colpo solo:

git fetch && git checkout the-branch-name

git fetch

git branch -r

git checkout <branch_name>

Ho scritto

git checkout <branch_name>

e ottenuto

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

A volte ti viene chiesto di non giocherellare con il ramo principale e lavorare solo il ramo remoto (come mi è stato chiesto). Quindi tutto ciò che serve è il ramo remoto.

Quindi, per clonare il ramo remoto da solo (senza il master), fai questo

git clone url --branch remote_branch_name

dove, remote_branch_name è il nome del ramo remoto

Per esempio,

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

Ciò assicurerà di clonare il ramo remoto sul ramo locale con il nome del ramo remoto.

Ora, se si commette il codice e si invia, il codice verrà inviato solo a quel ramo.

[Risposta rapida]

Esistono molte alternative e i miei preferiti sono:

- Alternativa 1:

git fetch --all
git checkout YourBranch

Usando questa alternativa usando un ramo che esiste in remoto, ma non nel tuo locale.

- Alternativa 2:

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

Probabilmente, questo è il modo più semplice.

Supponiamo che il tuo telecomando sia git@xyz.git e desideri il suo ramo random_branch. Il processo dovrebbe essere il seguente:

1. Prima controlla l'elenco dei telecomandi di

   git remote -v

2. Se non hai il telecomando git@xyz.git nell'output del comando sopra, lo aggiungerai per

   git remote add xyz git@xyz.git

3. Ora puoi recuperare il contenuto di quel telecomando da

   git fetch xyz

4. Ora controlla il ramo di quel telecomando da

   git checkout -b my_copy_random_branch xyz/random_branch

5. Controlla l'elenco delle filiali per

   git branch -a

La filiale locale my_copy_random_branch sta seguendo il ramo random_branch del tuo telecomando.

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

git fetch && git checkout <your friend's branch name> dovrebbe fare il trucco

Voglio darti il ​​comando one-liner per recuperare tutti i rami remoti sul tuo locale e passare al ramo locale appena creato desiderato:

git fetch && git checkout discover

Dopo aver eseguito il comando sopra otterrai il seguente messaggio:

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

La prima riga afferma che è passato a un nuovo ramo : perché nuovo? È già lì in remoto!

Ma in realtà devi crearlo anche localmente. Il ramo viene preso dall'indice remoto e creato localmente per te.

Ecco discoverun nuovo ramo creato dal ramo remoto del tuo repository discover.

Ma la seconda riga fornisce più informazioni della prima che ci dicono che:

La nostra filiale è impostata per tracciare la filiale remota con lo stesso nome.

Sebbene git fetch recupera tutti i rami in locale. Ma se lo insegui git branch, vedrai solo il masterramo in locale. Perché ?

Perché per ogni filiale che hai in remoto devi crearla anche localmente, per rintracciarla git checkout <branchname>come abbiamo fatto nell'esempio sopra.

Dopo aver eseguito il git checkoutcomando puoi eseguire git branch, e ora puoi vedere sia il ramo:

1. master e 2. scopri nella tua scheda locale.

Se desideri recuperare tutti i rami remoti, digita solo:

git fetch --all

Prova semplicemente:

git pull origin your_branch_name

Se si dispone di un repository con cui è stato clonato, --depth 1molti dei comandi elencati non funzioneranno. Ad esempio, vedi qui

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

In questo caso vorrei richiudere il repository, ma forse ci sono altre tecniche, ad esempio git shallow clone (clone --depth) manca rami remoti

Se conosci già il tuo ramo remoto in questo modo ...

git remote
=> One
=> Two

e conosci il nome della filiale che desideri verificare, ad esempio br1.2.3.4 , quindi fai

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

Non resta che verificare il ramo

git checkout br.1.2.3.4

Quindi crea nuovi rami da esso.

I passi sono come segue;

1. git fetch originoppure git fetch --all, questo porterà tutti i rami remoti al tuo locale e quindi questa la seconda opzione con cui puoi procedere.

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

Quindi lavora su questo ramo e puoi verificare se sei su quel ramo o meno digitando

git branch

Visualizza il ramo in cui ti trovi attualmente.

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

Controlla il tuo .git/configfile, in particolare quale traccia è presente sul recupero per quel telecomando.

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

Se ha heads/*puntato a randomRemote/*, quando corrigit fetch randomRemote , prenderà tutti i rami.

Quindi puoi semplicemente controllare quel ramo.

Altrimenti,

1. È necessario aggiungere diramazioni remote al tracciamento usando questo. Controlla il tuo .git/configdopo aver eseguito questo. Capirai.

   git remote set-branches --add randomRemote randomBranch
   

2. Corri git fetch randomRemote. Questo recupererà il ramo remoto.

3. Adesso puoi correre git checkout randomBranch.

Usa 'git pull' per tenere separati i tuoi rami. Userò l'archivio reale e i nomi delle filiali per aiutare poiché "lbranch" e "rbranch" sono difficili da decifrare.

Usiamo:

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

Un semplice comando git checkout remote_branch_nameti aiuterà a creare un ramo locale che ha tutte le modifiche nel ramo remoto.

git checkout -b branch_name
git pull remote_name branch_name