come faccio a controllare un ramo Git remoto?

qualcuno ha inviato un ramo chiamato test con git push origin test a un repository condiviso. posso vedere il ramo con git branch -r.

ora sto cercando di controllare il ramo remoto test.

ho provato:

  • git checkout test che non fa nulla

  • git checkout origin/test* (no branch). che è fonte di confusione. come posso essere su "nessun ramo"?

come faccio a controllare un ramo Git remoto?


En title : How do I check out a remote Git branch?

114 Comments:

  1. aggiornamento aggiornamento aggiornamento aggiornamento

    la risposta di Jakub in realtà migliora su questo. con Git versions & ge; 1.6.6, con un solo telecomando, puoi semplicemente fare:

    git fetch
    git checkout test
    

    come utente masukomi sottolinea in un commento, git checkout test NON funzionerà con git moderno se hai telecomandi multipli. in questo caso l'uso

    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 un ramo remoto, devi prenderlo come indicato nelle risposte qui sotto.

    per recuperare un ramo, devi semplicemente:

    git fetch origin
    

    questo porterà tutti i rami remoti per voi. puoi vedere i rami disponibili per il checkout con:

    git branch -v -a
    

    con i rami remoti in mano, è ora necessario controllare il ramo che ti interessa, dandovi una copia locale di lavoro:

    git checkout -b test origin/test
    
    1. per espandere questo: Git non ti permette di lavorare sui rami di qualcun altro. si può lavorare solo da soli. quindi se vuoi aggiungere un ramo a qualcun altro, devi creare la tua "copia" di quel ramo, che è quello che fa il comando precedente (beh, crea il tuo ramo e lo controlla anche).
    1. se si tratta di un nuovo ramo remoto potrebbe essere necessario git fetch prima di farlo in modo che git sia a conoscenza di origin/test
    1. errore: "Git checkout: l'aggiornamento dei percorsi è incompatibile con la commutazione dei rami. hai intenzione di checkout origin/test che non può essere risolto come commit? "
    1. nel caso in cui questo aiuta chiunque - per questo a lavorare per me, ho dovuto eseguire prima
    1. come sottolineato da Jakub - si dovrebbe essere in grado di utilizzare un comando di checkout più breve e sicuro dal 1.6.6. si prega di considerare selezionando la sua risposta.
    1. questo non definisce "fetch" altro che dire che si può prendere con il comando fetch. un nuovo utente ovvio potrebbe apprezzare una parola o due su ciò che viene ottenuto da dove a dove.
    1. ha funzionato per me, ma dopo l'esecuzione git remote update prima git checkout -b test origin/test
    1. @AdriánSalgado il -b fa sì che un nuovo ramo venga creato come se avessi scritto "git branch test origin / test; git checkout test"
    1. @jordan-dea-mattson Non sono abbastanza sicuro di modificare la risposta ma ho provato questa versione più corta e funziona: Git fetch; git checkout test. imposta automaticamente il ramo di tracciamento remoto corretto.
    1. da dove git riceve le informazioni dell'URL? finirò per verificare un ramo all'interno dell'area di lavoro corrente?
    1. il commento precedente sembra che deve essere molto più importante - qualcuno può aggiungere questo alla risposta?
    1. mi dispiace dirvi, questo non funziona. creerà un ramo locale che non ha idea che il ramo remoto sia collegato ad esso
    1. avevo telecomandi multipli dove il ramo esisteva solo in uno, ma ancora non funzionava. quindi ho aggiornato la risposta per essere meno specifico.
    1. "git checkout test NON funzionerà in git moderno se hai telecomandi multipli" -- ho un singolo telecomando e devo ancora fare git checkout -b test origin/test...
    1. non includere origine / nella parte anteriore della mia specifica di ramo quando si verifica
    1. @BerislavLopac e @samethebest il git checkout test non funzionava per me né con telecomandi multipli ma solo con un ramo con il nome test... ma alla fine ho capito che il mio problema era che avevo una cartella chiamata test. quindi git stava semplicemente controllando quella cartella. così ho ancora bisogno di fare git checkout -b test origin/test
    1. Ciao @hallski, Voglio sapere qual è lo scopo di git fetch origin? grazie:)
    1. @KarenAnne preleva le ultime modifiche dal repository 'origin' (spesso il repository remoto, per esempio su Github).
    1. questa è una cattiva semantica da parte di git "git checkout -b test origin / test", dovrebbe essere questa invece "git checkout -b origin / test test", oh bene
  2. in questo caso, probabilmente si desidera creare un ramo locale test che segue il ramo remoto test:

    $ git branch test origin/test
    

    nelle versioni precedenti di git, si aveva bisogno di un'opzione esplicita --track, ma questo è il default ora quando si sta diramando un ramo remoto.

    1. anche se ho ottenuto fatale: nome oggetto ambiguo: 'origin / dev' - dove esiste sicuramente un ramo 'dev' su origin - ma ho accidentalmente creato un ramo chiamato "origin / dev" sulla mia macchina (nei miei stupidi tentativi precedenti di ottenere questo diritto, senza dubbio)... ouch
    1. questo mi ha dato l'errore: non è riuscito a spingere alcuni riferimenti a suggerimento: gli aggiornamenti sono stati respinti perché una punta del ramo spinto è dietro il suo suggerimento remoto: Counterpart. controlla questo ramo e unisci il suggerimento delle modifiche remote: (per esempio: 'git pull ') prima di spingere di nuovo. suggerimento: per i dettagli vedere 'Note sui fast-forward' in 'git push --help'.
  3. sidenote: con Git moderno (> = 1.6.6), puoi usare solo

    git checkout test
    

    (notate che è 'test' non 'origin / test') eseguire il magico DWIM -mery e creare il branch locale 'test' per voi, per il quale upstream sarebbe 'origin / test' del branch di tracciamento remoto.


    l'output * (no branch) in git branch significa che sei su un ramo senza nome, nello stato chiamato "separato HEAD" (HEAD punta direttamente al commit, e non è un riferimento simbolico ad un ramo locale). se hai fatto alcune commit su questo ramo senza nome, puoi sempre creare un ramo locale fuori dalla commit corrente:

    git checkout -b test HEAD
    
    1. non sorprende, ma questa versione è stata rilasciata negli ultimi anni - sapendo che questa sintassi può risparmiare un sacco di tempo dal momento che c'è ancora un sacco di vecchia documentazione e thread di commento che galleggiano intorno che suggeriscono il metodo più vecchio per farlo.
    1. @knite: Il git checkout test è più DWIM-my. non solo aggiunge l'opzione --track, ma quando si verifica un ramo inesistente nota che esiste un ramo di tracciamento remoto dello stesso nome e crea automaticamente un ramo locale per te che puoi fare il checkout (non puoi fare il checkout del ramo di tracciamento remoto, in quanto è controllato dal repository remoto esterno). HTH HTH
    1. avevo spinto un ramo nel repo e poi modificato il README tramite github. poi ho voluto aggiornare la mia copia locale. usare git checkout mybranch porta a git che mi suggerisce di usare git pull perché mybranch esisteva già. grazie per avermi guidato verso la soluzione!
    1. sono su git versione 1.7.10.2 (Apple Git-33) e git checkout test non ha funzionato per me. ha dovuto cadere di nuovo alla risposta accettata. probabilmente ho qualche strano config che interferisce da qualche parte.
    1. vedi la risposta di tcaswell qui sotto se il telecomando di interesse non è chiamato origin
    1. @aidan Se ottieni una risposta come error: pathspec 'branch_name' did not match any file(s) known to git. allora dovresti fare prima git fetch.
    1. usando git versione 1.8.3.msysgit.and questo non funziona per me - non corrisponde a nessun file conosciuto con git - Ho fatto molti git fetches
    1. @PandaWood Non ha funzionato neanche per me, usando 1.8.3.4 (Apple Git-47)
    1. @PandaWood @AdriánSalgado Nel repo, aprire .git/config e verificare che le specifiche di riferimento per il recupero dal telecomando (ad esempio origine) non solo recupera da un ramo specifico. per esempio, questo è cattivo: fetch = +refs/heads/master:refs/remotes/origin/master perché recupera solo master. dovrebbe apparire come fetch = +refs/heads/*:refs/remotes/origin/*. quindi utilizzare git fetch origin dopo. se hai successo, il ramo che ti interessa dovrebbe apparire nell'output fetch, e dovrebbe anche apparire nell'output di git branch -a come ramo remoto.
    1. @JakubNarębski Qual è la rilevanza della sezione inferiore della tua risposta sul ramo senza nome? con git v1.8.3.2 non sono su un ramo senza nome dopo aver controllato (e seguito) il ramo remoto.
    1. @Dennis: git checkout <non-branch>, per esempio git checkout origin/test produce un ramo separato HEAD / unnamed, mentre git checkout test o git checkout -b test origin/test produce un ramo locale test (con ramo di tracciamento remoto origin/test come upstream)
    1. utilizzando git checkout -B origin/branch si crea e checkout il ramo remoto desiderato in una riga. dove l'opzione -b crea solo il ramo e posiziona HEAD in stato staccato.
  4. questo comando esegue DWIM per una origine remota non chiamata (documentazione):

    $ git checkout -t remote_name/remote_branch
    

    per aggiungere un nuovo telecomando, è necessario fare il seguente primo:

    $ git remote add remote_name location_of_remote
    $ git fetch remote_name
    

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

  5. risposta accettata non funziona per voi?

    mentre la prima e selezionata risposta è tecnicamente corretta, c'è la possibilità che non hai ancora recuperato tutti gli oggetti e refs dal repository remoto. se questo è il caso, riceverai il seguente errore:

    $ git checkout -b remote_branch origin/remote_branch
    

    fatal: git checkout: updating paths is incompatible with switching branches.
    Did you intend to checkout 'origin/remote_branch' which can not be resolved as commit?

    soluzione soluzione soluzione soluzione

    se ricevi questo messaggio, devi prima fare un git fetch origin dove origin è il nome del repository remoto prima di eseguire 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 si può vedere, in esecuzione git fetch origin recuperato eventuali rami remoti non eravamo ancora la configurazione per tenere traccia sulla nostra macchina locale. da lì, dal momento che ora abbiamo un riferimento al ramo remoto, possiamo semplicemente eseguire git checkout remote_branch e avremo i vantaggi di monitoraggio remoto.

    1. aggiungerò una nota se hai un ramo separato localmente: assicurati di averlo associato al repo remoto usando 'git remote add origin [il percorso del tuo repo / repo _ name.git]'. poi usa 'git fetch origin' dove 'origin' indica il repository con cui hai fatto l'associazione.
    1. git checkout -b newbranch funziona benissimo anche per creare e controllare un nuovo ramo basato sul ramo corrente.
    1. penso che questo sia il più up-to-date (mantiene $@ #! ing cambiando!). Git 2.5.5 Ho trovato che l'unico modo per vedere i rami remoti era git ls-remote e l'unico modo per usarli è git checkout -b [branch] --track [remote/branch]... e questo è dopo che git pull [remote] [branch] ha funzionato. cioè, in realtà ha tirato l'intero ramo, ma ancora non la lista.
    1. solo per aggiungere, se si git fetch other_remote only_branch, si ottiene ancora l'errore fatal. devi git fetch other_remote senza il nome del ramo. design strano.
  6. per clonare un repository Git, fare:

    git clone <either ssh url /http url>
    

    il comando precedente controlla tutti i rami, ma solo il ramo master sarà inizializzato. 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 vuoi sovrascrivere il tuo nome locale al 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 documentazione documentazione documentazione documentazione

    1. sì, hai ragione. grazie per le vostre informazioni, lo aggiornerò molto presto @warvariuc
  7. se il ramo è su qualcosa di diverso dal telecomando origin mi piace fare quanto segue:

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

    questo farà il checkout del ramo next sul upstream remoto in un ramo locale chiamato second/next. il che significa che se hai già un ramo locale chiamato poi non sarà in conflitto.

    $ git branch -a
    * second/next
      remotes/origin/next
      remotes/upstream/next
    
  8. git branch -r dice che il nome dell'oggetto non è valido, perché quel nome del ramo non è nella lista dei branch locali di Git. aggiorna la tua lista locale di origine con:

    git remote update
    

    e poi provare a controllare il ramo remoto di nuovo.

    questo ha funzionato per me.

    credo che git fetch tira in tutti i rami remoti, che non è quello che il poster originale voleva.

  9. ho provato la soluzione di cui sopra, ma non ha funzionato. prova questo, funziona:

    git fetch origin 'remote_branch':'local_branch_name'
    

    questo recupera il ramo remoto e crea un nuovo ramo locale (se non esiste già) con nome local_branch_name e traccia quello remoto in esso.

    1. dipende dalla versione git, ma questo sembra essere reso possibile con la sua ultima release.
    1. questo era il modo più diretto per realizzare ciò di cui avevo bisogno, che era quello di usare un ramo remoto (non master) per creare un nuovo ramo.
    1. lavorato senza soluzione di continuità, soprattutto quando ha clonato un singolo ramo da un remoto con più rami.
    1. questo ha funzionato anche per me, dove le risposte accettate e altri votati non hanno. la mia versione git è 2.5.0
    1. questa è l'unica risposta che ha funzionato per me su mac OS Sierra, versione git 2.4.0
    1. questo è l'unico modo che ha funzionato per me sul repo clonato con bandiera git clone --single-branch
  10. @inger Ma non include la possibilità di rinominare il nuovo ramo locale (se si desidera --set-upstream in seguito e mantenere la consistenza dei nomi)
  11. si può provare

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

    o o o o o

    git fetch
    git checkout -b local_branch_name origin/branch_name
    
  12. penso che questo filetto sia inutile. niente sembra funzionare, la domanda originale sembra essere stata persa in molte delle risposte. ho letto ogni parola, provato tutto qui sotto, e non ho idea di come fare ciò che il OP vuole fare.
  13. seguire il comando per creare una cartella vuota. inserisci questo comando 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'
    
  14. i comandi Git non sono intuitivi per cominciare, aggiungi le modifiche introdotte con le versioni recenti al mix e hai questa pagina...
  15. uso: uso:

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

    altre risposte non funzionano con Git moderno nel mio caso benigno. potrebbe essere necessario tirare prima se il ramo remoto è nuovo, ma non ho controllato quel caso.

    1. Guardando ora, si sovrappongono. solo il mio è conciso e ti dice cosa fare piuttosto che raccontare una storia. suppongo che possa essere più utile quindi, soprattutto per le versioni git di oggi. si può retrocedere se si pensa che sia una brutta risposta.
    1. Git fetch è l'opzione sicura. provare a recuperare prima di utilizzare tirare. entrambi scaricare il contenuto remoto, ma mentre fetch non cambia lo stato locale, pull cambierà immediatamente lo stato locale.
  16. comandi comandi comandi comandi comandi

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

    sono uguali a

     git fetch --all
    

    e poi e poi

     git checkout -b fixes_for_dev origin/development
    

    entrambi creeranno un latest fixes_for_dev da development

  17. mi sento come sto prendendo pillole folli. sto cercando di acquistare un ramo da un upstream, non solo origin, e ogni risposta raccomandata non fa nulla di lontanamente utile (pun-intended). Edit - mi scusi, la moltitudine di suggerimenti contenuti nella top 2 risposte erano inutili; 3rd uno (git branch test origin/test) è ciò che funziona. sono contento che i primi 2 hanno 20x il numero di voti...
  18. in primo luogo, dovete fare:

    git fetch # Se non si conosce il nome del ramo

    git fetch origin branch_name
    

    in secondo luogo, è possibile controllare ramo remoto nel tuo locale da:

    git checkout -b branch_name origin/branch_name
    

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

    1. non capisco -b. se puoi fare "git checkout master" perché non puoi fare "git checkout origin / test"?
  19. altri ragazzi e ragazze danno le soluzioni, ma forse posso dirvi perché.

    git checkout test which does nothing

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

    se la risposta è 'sì', posso dirvi la causa.

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

    quando git checkout xxx analizzato,

    1. Git inizialmente considera xxx come un nome di ramo, ma non c'è nessun ramo chiamato test.
    2. poi Git pensa che xxx sia un percorso, e fortunatamente (o sfortunatamente), c'è un file chiamato test. quindi git checkout xxx significa scartare qualsiasi modifica nel file xxx.
    3. se non c'è neanche un file chiamato xxx, allora Git proverà a creare il xxx secondo alcune regole. una delle regole è creare un ramo chiamato xxx se remotes/origin/xxx esiste.
  20. forse hai un file chiamato 'test' nel tuo albero di lavoro, vedere https://stackoverflow.com/a/45006389/792416 per i dettagli.
  21. ecco cosa ha funzionato per me nel 2017. due passi:

    1) git fetch origin 2) git checkout -b origin /

  22. 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 single-line:

    git fetch --all; for branch in `git branch -r --format="%(refname:short)" | sed 's/origin\///'`; do git branch --track "$branch" "origin/$branch" ; done ;
    
  23. OK, la risposta è facile... Hai visto il ramo, ma non hai ancora una copia locale!...

    è necessario fetch il ramo...

    si può semplicemente recuperare e poi fare il checkout al ramo, usare il comando a 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 fetch e anche come è diverso da pull:

    git fetch

    1. @DmitriZaitsev sì, funzionerà, se il ramo remoto è lì, e si fa fetch, si otterrà il ramo localmente... git fetch & amp; & amp; git checkout test.. Così funziona, a meno che non ci sia nessun ramo remoto, ma la domanda dicendo che c'è già un ramo remoto lì...
    1. il modo in cui vedo la domanda, test sembra un nuovo ramo, quindi non è probabile che sia presente localmente. altrimenti si potrebbe tirare più facile con singolo git pull comando.
    1. @DmitriZaitsev, sì, è per questo che ho detto git fetch, che controlla i rami remoti che hai appena creato, pull può portare altri animali indesiderati in, ma fetch rende tutti i rami disponibili se hai già il repo localmente...
    1. non fetch senza pull lasciare modifiche nella copia recuperata, ma non nel ramo locale, portando al ramo locale non essere up-to-date?
    1. questa risposta sarebbe molto più utile se si spiega perché si sta utilizzando in questo modo. cioè vale a dire perché qualcuno dovrebbe usare '--track' e così via...
  24. il comando git remote show <origin name> elenca tutti i rami (compresi quelli non tracciati). poi puoi trovare il nome del ramo remoto che devi prendere.

    esempio: 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: esempio:

    $ git fetch origin test:test
    $ git checkout test
    
    1. @hallski ha risposto non lavorando 2.15.1 versioni ma ho ridotto .git file weigth clone solo 1 ramo e la cronologia dei filtri con --depth flag. per esempio $ git clone -b release --single-branch --depth 5 https://github.com/user/repo.git Wron 't information $ git remote show origin questo non elenca tutti i branch remoti con repository clonati da un singolo branch.
  25. per ottenere nuovi rami creati

    git fetch
    

    per passare in un altro ramo

    git checkout BranchName
    
  26. prendi dal telecomando e verifica il ramo.

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

    ad es. per esempio ::::

    git fetch origin && git checkout feature/XYZ-1234-Add-alerts

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

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

    1. grazie. mi chiedevo se dovessi usare il percorso completo (telecomandi / origin / feature / branch) che ho visto in git quando chiamo il comando git branch -a, ma non ero sicuro, così ho usato git checkout -b apps/FEATURE/branch origin/apps/FEATURE/branch e sembrava funzionare. messaggio: Branch 'apps/FEATURE/branch' set up to track remote branch 'apps/FEATURE/epicBranch' from 'origin'. Switched to a new branch 'apps/FEATURE/branch'
  28. basta eseguire git checkout con il nome del ramo remoto. Git creerà automaticamente un ramo locale che traccia quello remoto:

    git fetch
    git checkout test
    

    comunque, se quel nome di ramo è trovato in più di un remoto, questo non funzionerà poichè Git non sa quale usare. in questo caso è possibile utilizzare sia:

    git checkout --track origin/test
    

    o o o o o

    git checkout -b test origin/test
    

    nella 2.19, Git ha imparato la configurazione checkout.defaultRemote, che specifica un telecomando per default quando si risolve una tale ambiguità.

  29. ero bloccato in una situazione vedere error: pathspec 'desired-branch' did not match any file(s) known to git. per tutti i suggerimenti di cui sopra. sono su git versione 1.8.3.1.

    così questo ha funzionato per me:

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

    la spiegazione dietro è che ho notato che quando si recupera il ramo remoto, è stato recuperato in FETCH _ HEAD:

    $ git fetch origin desired-branch
    From github.com:MYTEAM/my-repo
        * branch            desired-branch -> FETCH_HEAD
    
  30. se il nome del ramo remoto inizia con caratteri speciali devi usare virgolette singole nel comando checkout, altrimenti git non saprà di quale ramo stai parlando.

    per esempio, ho provato a fare il checkout di un ramo remoto chiamato #9773 ma il comando non funzionava correttamente, come mostrato nella foto qui sotto:

    enter image description here

    per qualche ragione mi sono chiesto se il simbolo tagliente (#) 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 ha funzionato bene.

    $ git checkout -b '#9773' origin/'#9773'
    
    1. in molte shell unix il carattere # viene usato per i commenti, quindi qualsiasi cosa dopo il # verrà ignorata. questa è una cosa di shell e non qualcosa di specifico per git. usare le virgolette di un backslash prima del # dovrebbe essere sufficiente.
  31. utilizzare fetch per tirare tutto il telecomando

       git fetch
    

    per elencare tutti i tuoi rami

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

    per controllare / cambiare un ramo

       git checkout master
    

More similar articles:

  • Git: come controllare se il ramo locale è davanti al ramo remoto quando la directory di lavoro è modificata?
  • come creare il ramo git nel repository remoto senza controllare con jgit
  • Git gui: come spingere verso un ramo remoto?
  • come si rimuove un riferimento ramo remoto non valido da Git?
  • perché Git non mi permette di controllare un ramo da un remoto alternativo?
  • come fare il checkout di un ramo remoto, ribasarlo su master locale e poi fonderlo con master locale?
  • come posso fare il checkout di un ramo remoto?
  • come cancellare con forza un ramo remoto in GitHub?
  • come iniziare a lavorare da un ramo remoto, Github
  • come rimuovere automaticamente il ramo di tracciamento remoto quando il ramo locale corrispondente viene rimosso con git
  • come fare il checkout di un ramo remoto in Git?
  • come fare il checkout del ramo remoto git?
  • Git: come fare il checkout di un nuovo ramo remoto?
  • invia un ramo Git a remoto senza controllare il ramo
  • come fare git fetch e checkout senza creare un ramo remoto localmente?
  • come unire un ramo da un remoto all'origine/master
  • come fare il checkout di un ramo remoto senza sapere se esiste localmente in JGit?
  • come dire quale ramo svn remoto è un locale git branch tracking?
  • come provare una versione di un'app da un ramo dedicato su un server remoto?
  • controllare un ramo remoto esistente
  • come rimuovere il ramo remoto con JGit
  • scollegare ramo locale da remoto
  • c'è un modo per scaricare un ramo di un repository remoto senza clonazione prima?
  • non può inviare modifiche locali ad un ramo remoto esistente
  • differenza tra il ramo remoto checkout e il ramo remoto in git?
  • eliminare il ramo remoto in SAP Web IDE
  • come confrontare ramo locale con ramo remoto in Mercurio
  • rimuovere tutto il ramo locale chiuso dipende dal suo stato remoto
  • utilizzo dell'aggiornamento di un ramo di tracciamento remoto da parte di un ramo locale
  • Git: non può vedere un nuovo ramo remoto