Qualcuno ha spinto un ramo chiamato test
con il git push origin test
su un repository condiviso. Posso vedere il ramo con git branch -r
.
Ora sto provando a controllare il ramo di test
remoto.
Ho provato:
git checkout test
che non fa nulla
git checkout origin/test
dà * (no branch)
. Che è fonte di confusione Come posso essere su “nessun ramo”?
Come posso controllare un ramo Git remoto?
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
).
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.
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?
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,
xxx
come nome di un ramo, ma non esiste alcun ramo chiamato test. xxx
sia un percorso e, fortunatamente (o sfortunatamente), c’è un file chiamato test. Quindi git checkout xxx
significa eliminare qualsiasi modifica nel file xxx
. 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