Come posso controllare un ramo Git remoto?

Aggiornare

La risposta di Jakub in realtà migliora su questo. Con le versioni di Git ≥ 1.6.6, puoi semplicemente:

 git fetch git checkout test 

(L’utente masukomi sottolinea che il git checkout test non funzionerà nel git moderno se hai più telecomandi, in questo caso usa git checkout -b test /test ).

Vecchia risposta

Prima di poter iniziare a lavorare localmente su un ramo remoto, devi recuperarlo come indicato nelle risposte di seguito.

Per recuperare un ramo, devi semplicemente:

 git fetch origin 

Questo preleverà tutti i rami remoti per te. Puoi vedere i rami disponibili per il checkout con:

 git branch -v -a 

Con i rami remoti in mano, ora è necessario controllare la filiale che ti interessa, dandoti una copia di lavoro locale:

 git checkout -b test origin/test 

Sidenote: Con Git moderno (> = 1.6.6 ), puoi usare solo

 git checkout test 

(si noti che è ‘test’ non ‘origine / test’) per eseguire magici DWIM -mery e creare ‘test’ ramo locale per te, per il quale upstream sarebbe ‘origine / test’ ramo di tracciamento remoto.

Il * (no branch) nell’output di git branch indica che ci si trova su un ramo senza nome, nel cosiddetto stato “HEAD distaccato” (punti HEAD direttamente per il commit e non è un riferimento simbolico a qualche ramo locale). Se hai fatto qualche commit su questo branch senza nome, puoi sempre creare un branch locale fuori dal commit corrente:

 git checkout -b test HEAD 

In questo caso, probabilmente si desidera creare un ramo di test locale che stia tracciando il ramo di test remoto:

 $ git branch test origin/test 

Nelle versioni precedenti di git , era necessaria un’opzione --track esplicita, ma questa è l’impostazione predefinita ora quando si dirama un ramo remoto.

Risposta accettata non funziona per voi?

Sebbene la prima risposta selezionata sia tecnicamente corretta , esiste la possibilità che non siano stati ancora recuperati tutti gli oggetti e i riferimenti dal repository remoto. In questo caso, riceverai il seguente errore:

 $ git checkout -b remote_branch origin/remote_branch 

fatale: git checkout: i percorsi di aggiornamento non sono compatibili con i rami di commutazione.
Hai intenzione di eseguire il checkout di ‘origine / remote_branch’ che non può essere risolto come commit?

Soluzione

Se si riceve questo messaggio, è necessario prima eseguire un’origine di git fetch origin dove origin è il nome del repository remoto prima di eseguire git checkout remote_branch . Ecco un esempio completo di risposte:

 $ git fetch origin remote: Counting objects: 140, done. remote: Compressing objects: 100% (30/30), done. remote: Total 69 (delta 36), reused 66 (delta 33) Unpacking objects: 100% (69/69), done. From https://github.com/githubuser/repo-name e6ef1e0..5029161 develop -> origin/develop * [new branch] demo -> origin/demo d80f8d7..359eab0 master -> origin/master $ git checkout demo Branch demo set up to track remote branch demo from origin. Switched to a new branch 'demo' 

Come puoi vedere, l’esecuzione di git fetch origin recuperato tutti i rami remoti che non eravamo ancora stati configurati per tracciare sul nostro computer locale. Da lì, dato che ora abbiamo un riferimento al ramo remoto, possiamo semplicemente eseguire git checkout remote_branch e otterremo i vantaggi del monitoraggio remoto.

Ho provato la soluzione di cui sopra, ma non ha funzionato. Prova questo, funziona:

 git fetch origin 'remote_branch':'local_branch_name' 

Questo preleverà il ramo remoto e creerà un nuovo ramo locale (se non esiste già) con nome local_branch_name e ne local_branch_name traccia in remoto.

Questo sarà DWIM per un’origine remota non denominata ( documentazione ):

 $ git checkout -t remote_name/remote_branch 

Per aggiungere un nuovo telecomando, dovrai prima fare quanto segue:

 $ git remote add remote_name location_of_remote $ git fetch remote_name 

Il primo dice a Git che il telecomando esiste, il secondo ottiene il commit.

Uso:

 git checkout -b  / 

Altre risposte non funzionano con il Git moderno nel mio caso benigno. Potrebbe essere necessario eseguire prima il pull se il ramo remoto è nuovo, ma non l’ho verificato.

OK , la risposta è semplice … In pratica, vedi il ramo, ma non hai ancora una copia locale! …

Devi fetch il ramo …

Puoi semplicemente recuperare e quindi effettuare il checkout al ramo, utilizzare il comando di una riga qui sotto per farlo:

 git fetch && git checkout test 

Ho anche creato l’immagine qui sotto per condividere le differenze, guardare come funziona il fetch e anche come è diverso da pull :

Per clonare un repository Git, fare:

 git clone  

Il comando precedente controlla tutti i rami, ma verrà inizializzato solo il ramo master . Se vuoi controllare gli altri rami, fai:

 git checkout -t origin/future_branch (for example) 

Questo comando controlla il ramo remoto e il nome del ramo locale sarà lo stesso del ramo remoto.

Se desideri sovrascrivere il nome del tuo ramo locale al momento del checkout:

 git checkout -t -b enhancement origin/future_branch 

Ora il nome del ramo locale è enhancement , ma il nome del ramo remoto è future_branch .

Documentazione

Puoi provare

 git fetch remote git checkout --track -b local_branch_name origin/branch_name 

o

 git fetch git checkout -b local_branch_name origin/branch_name 

Innanzitutto, devi fare:

git fetch # Se non si conosce il nome del ramo

 git fetch origin branch_name 

In secondo luogo, puoi controllare il ramo remoto nel tuo locale:

 git checkout -b branch_name origin/branch_name 

-b creerà un nuovo ramo nel nome specificato dal ramo remoto selezionato.

comandi

 git fetch --all git checkout -b  origin/ 

sono uguali a

  git fetch --all 

e poi

  git checkout -b fixes_for_dev origin/development 

Entrambi creeranno le latest fixes_for_dev per lo development

Se il ramo è su qualcosa di diverso dal telecomando di origin mi piace fare quanto segue:

 $ git fetch $ git checkout -b second/next upstream/next 

Questo eseguirà il checkout del ramo next sul remoto upstream in un ramo locale chiamato second/next . Il che significa che se hai già una succursale locale chiamata accanto, non entrerà in conflitto.

 $ git branch -a * second/next remotes/origin/next remotes/upstream/next 

Io uso il seguente comando:

 git checkout --track origin/other_remote_branch 

git fetch && git checkout your-branch-name

git branch -r dice che il nome dell’object non è valido, perché quel nome di ramo non si trova nell’elenco dei rami locali di Git. Aggiorna il tuo elenco di filiali locali dall’origine con:

 git remote update 

E poi prova a controllare di nuovo il tuo ramo remoto.

Questo ha funzionato per me.

Credo che git fetch pull in tutte le filiali remote, che non è quello che voleva il poster originale.

Il git remote show elencherà tutti i rami (compresi i rami non tracciati). Quindi puoi trovare il nome del ramo remoto che devi recuperare.

Esempio:

 $ git remote show origin 

Utilizzare questa procedura per recuperare i rami remoti:

 git fetch  : git checkout  (local branch name should the name that you given fetching) 

Esempio:

 $ git fetch origin test:test $ git checkout test 

nessuna di queste risposte ha funzionato per me. questo ha funzionato:

git checkout -b feature/branch remotes/origin/feature/branch

Puoi iniziare a monitorare tutte le filiali remote con il seguente script Bash:

 #!/bin/bash git fetch --all for branch in `git branch -r --format="%(refname:short)" | sed 's/origin\///'` do git branch -f --track "$branch" "origin/$branch" done 

Ecco anche una versione a linea singola:

 git fetch --all; for branch in `git branch -r --format="%(refname:short)" | sed 's/origin\///'`; do git branch --track "$branch" "origin/$branch" ; done ; 

Altri ragazzi e ragazze danno le soluzioni, ma forse posso dirti perché.

test di git checkout che non fa nulla

Does nothing fa Does nothing doesn't work , quindi suppongo che quando digiti “git checkout test” nel tuo terminale e premi il tasto invio, non compaia nessun messaggio e non si verifichi alcun errore. Ho ragione?

Se la risposta è “sì”, posso dirvi la causa.

La causa è che nel tuo albero di lavoro c’è un file (o una cartella) chiamato ‘test’.

Quando git checkout xxx analizzato,

1. Git considera inizialmente xxx come nome di un ramo, ma non esiste alcun ramo chiamato test.
2. Quindi Git pensa che xxx sia un percorso e, fortunatamente (o sfortunatamente), c’è un file chiamato test. Quindi git checkout xxx significa eliminare qualsiasi modifica nel file xxx .
3. Se non c’è nemmeno il file xxx , Git proverà a creare il xxx secondo alcune regole. Una delle regole è creare un ramo chiamato xxx se esistono remotes/origin/xxx .

Si prega di seguire il comando per creare una cartella vuota. Immettilo e usa questo comando:

 saifurs-Mini:YO-iOS saifurrahman$ git clone your_project_url Cloning into 'iPhoneV1'... remote: Counting objects: 34230, done. remote: Compressing objects: 100% (24028/24028), done. remote: Total 34230 (delta 22212), reused 15340 (delta 9324) Receiving objects: 100% (34230/34230), 202.53 MiB | 294.00 KiB/s, done. Resolving deltas: 100% (22212/22212), done. Checking connectivity... done. saifurs-Mini:YO-iOS saifurrahman$ cd iPhoneV1/ saifurs-Mini:iPhoneV1 saifurrahman$ git checkout 1_4_0_content_discovery Branch 1_4_0_content_discovery set up to track remote branch 1_4_0_content_discovery from origin. Switched to a new branch '1_4_0_content_discovery' 

Recupera l’origine e controlla il ramo.

 git fetch origin && git checkout branch_name 

Per ottenere rami appena creati

 git fetch 

Per passare a un altro ramo

 git checkout BranchName