Qualcuno ha spinto un ramo chiamato testcon git push origin testun repository condiviso. Riesco a vedere il ramo con git branch -r.

Ora sto provando a controllare il testramo remoto .

Ho provato:

• git checkout test che non fa nulla

• git checkout origin/testdà * (no branch). Il che è confuso. Come posso essere su "nessuna filiale"?

Come controllo un ramo Git remoto?

Aggiornare

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

git fetch
git checkout test

Come sottolinea l'utente Masukomi in un commento, git checkout testNON funzionerà con git moderno se si dispone di più telecomandi. In questo caso utilizzare

git checkout -b test <name of remote>/test

o la stenografia

git checkout -t <name of remote>/test

Vecchia risposta

Prima di poter iniziare a lavorare localmente su una filiale remota, è necessario recuperarlo come indicato nelle risposte di seguito.

Per recuperare un ramo, devi semplicemente:

git fetch origin

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

git branch -v -a

Con le filiali remote 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

(nota che è 'test' non 'origin / test') eseguire magiche DWIM -mery e creare il ramo locale 'test' per te, per il quale a monte sarebbe il ramo di tracciamento remoto 'origin / test'.

La * (no branch)in git branchmezzi di uscita che sono sul ramo senza nome, nel cosiddetto stato "HEAD singola" (punti HEAD direttamente a commettere, e non è simbolico come base un ramo locale). Se hai effettuato alcuni commit su questo ramo senza nome, puoi sempre creare un ramo locale dal commit corrente:

git checkout -b test HEAD

** EDIT (per editore non autore) **

Ho trovato un commento sepolto di seguito che sembra modernizzare questa risposta:

@Dennis: git checkout, ad esempio git checkout origine / risultati del test in HEAD / ramo senza nome distaccato, mentre git checkout test o git checkout -b test origine / risultati del test nel ramo locale test (con origine / test ramo di localizzazione remota come upstream ) - Jakub Narębski il 9 gennaio 14 alle 8:17

enfasi su git checkout origin/test

In questo caso, probabilmente si desidera creare un testramo locale che sta monitorando il testramo remoto :

$ git branch test origin/test

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

La risposta accettata non funziona per te?

Mentre la prima e la risposta selezionata è tecnicamente corretta , esiste la possibilità di non aver ancora recuperato tutti gli oggetti e i riferimenti dal repository remoto. In tal caso, riceverai il seguente errore:

$ git checkout -b remote_branch origin/remote_branch

fatal: checkout git: l'aggiornamento dei percorsi non è compatibile con la commutazione dei rami.
Hai intenzione di fare il checkout 'origin / remote_branch' che non può essere risolto come commit?

Soluzione

Se ricevi questo messaggio, devi prima fare un git fetch origindove originè il nome del repository remoto prima dell'esecuzione git checkout remote_branch. Ecco un esempio completo con le 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 ha git fetch originrecuperato tutti i rami remoti che non eravamo ancora configurati per tracciare sul nostro computer locale. Da lì, poiché ora abbiamo un riferimento alla filiale remota, possiamo semplicemente eseguire git checkout remote_branche otterremo i vantaggi del monitoraggio remoto.

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

git fetch origin 'remote_branch':'local_branch_name'

Questo recupererà il ramo remoto e creerà un nuovo ramo locale (se non esiste già) con nome local_branch_namee seguirà quello remoto in esso.

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

$ git checkout -t remote_name/remote_branch

Per aggiungere un nuovo telecomando, devi prima effettuare le seguenti operazioni:

$ git remote add remote_name location_of_remote
$ git fetch remote_name

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

Uso:

git checkout -b <BRANCH-NAME> <REMOTE-NAME>/<BRANCH-NAME>

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

ok , la risposta è semplice ... In pratica vedi la filiale, ma non hai ancora una copia locale! ...

Hai bisogno fetchdel ramo ...

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

git fetch && git checkout test

Ho anche creato l'immagine qui sotto per condividere le differenze, guardare come fetchfunziona e anche come è diverso da pull:

Per clonare un repository Git, eseguire:

git clone <either ssh url /http url>

Il comando sopra verifica tutti i rami, ma masterverrà inizializzato solo il ramo. Se vuoi controllare gli altri rami, fai:

git checkout -t origin/future_branch (for example)

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

Se desideri sostituire il nome della tua filiale locale al momento del pagamento:

git checkout -t -b enhancement origin/future_branch

Ora il nome della tua filiale locale è enhancement, ma lo è il nome della tua filiale remota 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 conosci il nome della filiale

git fetch origin branch_name

In secondo luogo, puoi controllare la filiale remota nel tuo locale:

git checkout -b branch_name origin/branch_name

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

Uso il seguente comando:

git checkout --track origin/other_remote_branch

comandi

git fetch --all
git checkout -b <ur_new_local_branch_name> origin/<Remote_Branch_Name>

sono uguali a

 git fetch --all

e poi

 git checkout -b fixes_for_dev origin/development

Entrambi creeranno un latest fixes_for_devdadevelopment

Se il ramo si trova su qualcosa di diverso dal origintelecomando, mi piace fare quanto segue:

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

Questo verificherà il nextramo sul upstreamtelecomando in un ramo locale chiamato second/next. Ciò significa che se si dispone già di una filiale locale denominata next, non sarà in conflitto.

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

git fetch && git checkout your-branch-name

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

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

Ero bloccato in una situazione a error: pathspec 'desired-branch' did not match any file(s) known to git.causa di tutti i suggerimenti di cui sopra. Sono su git versione 1.8.3.1.

Quindi questo ha funzionato per me :

git fetch origin desired-branch
git checkout -b desired-branch FETCH_HEAD

La spiegazione dietro è che ho notato che durante il recupero del ramo remoto, è stato portato a FETCH_HEAD:

$ git fetch origin desired-branch
From github.com:MYTEAM/my-repo
    * branch            desired-branch -> FETCH_HEAD

Basta eseguire git checkoutcon il nome del ramo remoto. Git creerà automaticamente un ramo locale che traccia quello remoto:

git fetch
git checkout test

Tuttavia, se il nome di quel ramo viene trovato in più di un telecomando, questo non funzionerà poiché Git non sa quale usare. In tal caso puoi usare:

git checkout --track origin/test

o

git checkout -b test origin/test

In 2.19 , Git ha appreso la checkout.defaultRemoteconfigurazione, che specifica un telecomando predefinito in caso di risoluzione di tale ambiguità.

git branch -rdice che il nome dell'oggetto non è valido, perché il nome di quel ramo non è nella lista dei rami locale di Git. Aggiorna l'elenco delle filiali locali dall'origine con:

git remote update

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

Questo ha funzionato per me.

Credo che git fetchattiri tutti i rami remoti, che non è quello che voleva il poster originale.

Il git remote show <origin name>comando 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 questi passaggi per recuperare i rami remoti:

git fetch <origin name> <remote branch name>:<local branch name>
git checkout <local branch name > (local branch name should the name that you given fetching)

Esempio:

$ git fetch origin test:test
$ git checkout test

Recupera dal telecomando e verifica il ramo.

git fetch <remote_name> && git checkout <branch_name> 

Per esempio:

git fetch origin && git checkout feature / XYZ-1234-Aggiungi-avvisi

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

git test di verifica che non fa nulla

Does nothing non è uguale doesn't work , quindi immagino che quando digiti 'git checkout test' nel tuo terminale e premi il tasto Invio, non appare alcun messaggio e non si verifica alcun errore. Ho ragione?

Se la risposta è "sì", posso dirti la causa.

La causa è che c'è un file (o cartella) chiamato 'test' nella tua struttura di lavoro.

Quando git checkout xxxanalizzato,

1. Inizialmente Git considera il xxxnome di un ramo, ma non esiste alcun ramo chiamato test.
2. Quindi Git pensa che xxxsia un percorso e fortunatamente (o sfortunatamente), esiste un file chiamato test. Quindi git checkout xxxsignifica scartare qualsiasi modifica nel xxxfile.
3. Se non è presente neanche un file xxx, Git proverà a creare il file in xxxbase ad alcune regole. Una delle regole è creare un ramo chiamato xxxse remotes/origin/xxxesiste.

Per ottenere filiali appena create

git fetch

Per passare a un altro ramo

git checkout BranchName

Puoi iniziare a tracciare tutti i rami remoti 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 ;

git checkout -b "Branch_name" [B significa Crea ramo locale]

ramo git - tutti

git checkout -b "Il nome della tua filiale"

ramo git

checkout riuscito dal ramo master al ramo dev

per ottenere tutti i rami remoti usa questo:

git fetch --all

quindi vai alla filiale:

git checkout test

Utilizzare fetchper estrarre tutto il telecomando

   git fetch --all

Per elencare le filiali remote:

   git branch -r

Per elencare tutti i tuoi rami

   git branch -l
   >>outpots like-
     * develop
       test
       master

Per effettuare il checkout / modificare un ramo

   git checkout master

Per noi, sembra che la remote.origin.fetchconfigurazione abbia dato un problema. Pertanto, non abbiamo potuto vedere altri rami remoti di master, quindi git fetch [--all]non ha aiutato. Né git checkout mybranchné git checkout -b mybranch --track origin/mybranchha funzionato, anche se sicuramente era a distanza.

È stato masterpossibile recuperare solo la configurazione precedente :

$ git config --list | grep fetch
remote.origin.fetch=+refs/heads/master:refs/remotes/origin/master

Risolvilo utilizzando *e recupera le nuove informazioni dall'origine:

$ git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

$ git fetch
...
 * [new branch] ...
...

Ora potremmo git checkoutlocalizzare la filiale remota.

Non ho idea di come sia finita questa configurazione nel nostro repository locale.

Se il nome del ramo remoto inizia con caratteri speciali, devi usare virgolette singole attorno al comando di checkout, altrimenti git non saprà di quale ramo stai parlando.

Ad esempio, ho provato a fare il checkout di un ramo remoto chiamato come #9773ma il comando non ha funzionato correttamente, come mostrato nell'immagine seguente:

Per qualche motivo mi chiedevo se il simbolo affilato (#) potesse avere qualcosa a che fare con esso, e poi ho provato a circondare il nome del ramo con virgolette singole, come '#9773'rathen che solo #9773, e fortunatamente ha funzionato bene.

$ git checkout -b '#9773' origin/'#9773'

Seguire il comando per creare una cartella vuota. Immettere quello e utilizzare 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'