branch branch - Come si crea un ramo Git remoto?




checkout commit (15)

Ho creato una filiale locale che voglio "spingere" a monte. C'è una domanda simile qui su su come tracciare un ramo remoto appena creato.

Tuttavia, il mio flusso di lavoro è leggermente diverso. Per prima cosa voglio creare un ramo locale, e lo spingerò a monte solo quando sono soddisfatto e voglio condividere il mio ramo.

  • Come potrei farlo? (le mie ricerche su google non sembravano venire fuori nulla).
  • Come direi ai miei colleghi di estrarlo dal repository upstream?

AGGIORNAMENTO Con Git 2.0 c'è una risposta più semplice che ho scritto qui sotto: https://.com/a/27185855/109305


Answers

Crea il ramo sul tuo computer locale e attiva questo ramo:

$ git checkout -b [name_of_your_new_branch]

Spingi il ramo su github:

$ git push origin [name_of_your_new_branch]

Quando vuoi commettere qualcosa nel tuo ramo, assicurati di essere nel tuo ramo.

Puoi vedere tutti i rami creati usando:

$ git branch

Che mostrerà:

* approval_messages
  master
  master_clean

Aggiungi un nuovo telecomando per il tuo ramo:

$ git remote add [name_of_your_remote] 

Spingi le modifiche dal tuo commit nel tuo ramo:

$ git push origin [name_of_your_remote]

Aggiorna il tuo ramo quando il ramo originale dal repository ufficiale è stato aggiornato:

$ git fetch [name_of_your_remote]

Quindi devi applicare per unire le modifiche, se il tuo ramo è derivato dallo sviluppo devi fare:

$ git merge [name_of_your_remote]/develop

Elimina un ramo sul tuo filesystem locale:

$ git branch -d [name_of_your_new_branch]

Per forzare la cancellazione del ramo locale sul tuo filesystem:

$ git branch -D [name_of_your_new_branch]

Elimina il ramo su github:

$ git push origin :[name_of_your_new_branch]

Qui tutte le informazioni

Altro progetto esistente


Innanzitutto, crei il tuo ramo localmente:

git checkout -b <branch-name> # Create a new branch and check it out

Il ramo remoto viene creato automaticamente quando lo si invia al server remoto. Quindi, quando ti senti pronto, puoi semplicemente fare:

git push <remote-name> <branch-name> 

Dove <remote-name> è in genere origin , il nome che git dà al telecomando da cui è stato clonato. I tuoi colleghi avrebbero quindi estratto quel ramo e automaticamente creato localmente.

Si noti tuttavia che formalmente, il formato è:

git push <remote-name> <local-branch-name>:<remote-branch-name>

Ma quando ne ometti uno, presuppone che entrambi i nomi dei rami siano uguali. Detto questo, come una parola di cautela , non fare l'errore critico di specificare solo :<remote-branch-name> (con i due punti), o il ramo remoto sarà cancellato!

In modo che un successivo git pull sappia cosa fare, potresti invece voler usare:

git push --set-upstream <remote-name> <local-branch-name> 

Come descritto di seguito, l'opzione --set-upstream imposta un ramo upstream:

Per ogni ramo aggiornato o inserito correttamente, aggiungi il riferimento di upstream (tracciamento), usato da git-pull (1) senza argomenti e altri comandi.


Come affermato nelle risposte precedenti,

git push <remote-name> <local-branch-name>:<remote-branch-name>

è sufficiente per spingere un ramo locale.

I tuoi colleghi, possono estrarre tutti i rami remoti (inclusi quelli nuovi) con questo comando:

git remote update

Quindi, per apportare modifiche sul ramo, il flusso usuale:

git checkout -b <local-branch-name> <remote-name>/<remote-branch-name>

Se vuoi creare un ramo remoto senza avere quello locale, puoi farlo in questo modo:

git push origin HEAD:refs/heads/foo

Spinge qualsiasi cosa il tuo TESTO a ramificarsi, che non esisteva sul telecomando.


Ora con git, puoi semplicemente digitare, quando sei nel ramo corretto

git push --set-upstream origin <remote-branch-name >

e crea per te il ramo d'origine.


Ecco come lo fai in eclissi attraverso Egit.

1) Vai alla vista "Esplorazione repository Git" e espandi il progetto git a cui desideri creare un ramo. Sotto Brances -> Local .. seleziona il ramo per il quale vuoi creare il ramo (Nel mio caso ho selezionato il master .. puoi selezionare un altro altro ramo se lo desideri) .. quindi fai clic destro e clicca su Crea opzione Branch .. e selezionare il checkout questa opzione di progetto e quindi fare clic sul pulsante Fine.

2) Ora dall'esploratore del progetto selezionare il progetto. Fare clic con il tasto destro del mouse su Team -> Push Branch.

Verrà creato un nuovo ramo remoto. Puoi dare il nome del ramo ai tuoi colleghi in modo che possano farlo.


Semplice soluzione Git 2.0+:

A partire da Git 2.0 il comportamento è diventato più semplice :

Puoi configurare git con push.default = current per semplificarti la vita:

Ho aggiunto questo così ora posso solo spingere un nuovo ramo a monte con

$ git push -u

-u il ramo remoto con lo stesso nome. No con questa configurazione indovinerete automaticamente il riferimento remoto a git push. Dalla documentazione di git.config :

push.default

Definisce l'azione che git push dovrebbe intraprendere se non viene fornito esplicitamente un refspec.

push.default = current - spinge il ramo corrente per aggiornare un ramo con lo stesso nome sul lato ricevente. Funziona sia in flussi di lavoro centrali che non centrali.

Per me, questa è una buona semplificazione del mio flusso di lavoro giornaliero Git. L'impostazione di configurazione si occupa del caso di utilizzo "normale" in cui si aggiunge un ramo localmente e si desidera crearlo da remoto. Inoltre, posso facilmente creare branch locali da remoti semplicemente facendo git co remote_branch_name (invece di usare --set-upstream-to flag).

Conosco questa domanda e le risposte accettate sono piuttosto vecchie, ma il comportamento è cambiato in modo che ora esistano opzioni di configurazione per semplificare il flusso di lavoro.

Per aggiungere alla tua configurazione Git globale, eseguilo sulla riga di comando:

$ git config --global push.default current

Se si desidera creare un ramo dal ramo corrente

git checkout -b {your_local_branch_name} 

vuoi un ramo da un ramo remoto, puoi provare

git checkout -b {your_local_branch_name} origin/<remote_branch_name>

Se hai finito con le modifiche puoi aggiungere il file.

git add -A or git add <each_file_names>

Quindi fai un commit localmente

git commit -m 'your commit message'

Quando si desidera passare al repository remoto

git push -u origin <your_local_branch_name>

Tutti insieme saranno

git checkout -b bug_fixes 

oppure Se si desidera creare un ramo da un ramo remoto, dire sviluppo

git checkout -b bug_fixes origine / sviluppo

È possibile passare al repository remoto tramite

git push -u origin **bug_fixes**

Ogni volta che si desidera aggiornare il ramo da qualsiasi altro ramo, dire master .

git pull origin master .


Volevo solo aggiungere che mentre:

git checkout -b {branchName}

Crea un nuovo ramo, controlla anche quel ramo / lo rende il tuo ramo corrente. Se, per qualche ragione, tutto ciò che vuoi fare è disconnettere un ramo ma non renderlo il tuo ramo attuale, allora dovresti usare il seguente comando:

git branch {branchName}

Nel primo comando, "checkout" rende detto ramo il tuo ramo attuale, e "-b" significa: questo ramo non esiste ancora, quindi fallo per me.


La soluzione più semplice ... Drumm Roll. git versione 2.10.1 (Apple Git-78)

1) git checkout -b localBranchNameThatDoesNotExistInRemote

2) Do your changes , and go a git commit 

3) git push origin localBranchNameThatDoesNotExistInRemote --force

NB: il ramo che hai appena creato nel tuo ambiente locale e il ramo remoto non esistente in cui stai provando a spingere, devono avere lo stesso nome .


Innanzitutto, devi creare il tuo ramo localmente

git checkout -b your_branch

Successivamente, puoi lavorare localmente nel tuo ramo, quando sei pronto a condividere il ramo, spingilo. Il comando successivo spinge il ramo all'origine del repository remoto e lo tiene traccia

git push -u origin your_branch

I compagni di squadra possono raggiungere il tuo ramo, facendo:

git fetch
git checkout origin/your_branch

Puoi continuare a lavorare nel ramo e premere quando vuoi senza passare argomenti a git push (il push git senza argomenti spinge il master al master remoto, your_branch local a remote your_branch, ecc ...)

git push

I compagni di squadra possono spingere al tuo ramo facendo commit e poi spingere esplicitamente

... work ...
git commit
... work ...
git commit
git push origin HEAD:refs/heads/your_branch

O rintracciare il ramo per evitare gli argomenti per git push

git checkout --track -b your_branch origin/your_branch
... work ...
git commit
... work ...
git commit
git push

So che questa domanda ha una buona risposta, ma volevo solo elencare i passi che ho compiuto per creare un nuovo ramo "myNewBranch" e passare al remoto ("origine" nel mio caso) e impostare il monitoraggio. Considera questa la versione "TL; DR" :)

# create new branch and checkout that branch
git checkout -b myNewBranch
# now push branch to remote 
git push origin myNewBranch
# set up the new branch to track remote branch from origin
git branch --set-upstream-to=origin/myNewBranch myNewBranch

Creazione di un ramo locale da un ramo esistente (può essere master / develop / any-other-branch).

git checkout -b branch_name

Spingilo sul telecomando

git push -u nome_remoto local_branch_name: remote_branch_name

Qui,

  1. -u: imposta il ramo upstream
  2. remote_name: git imposta il nome per impostazione predefinita come "origine" quando crea il repository. Questo può tuttavia essere cambiato con un nome arbitrario diverso.
  3. local_branch_name: è il nome del ramo locale da spingere.
  4. remote_branch_name: è il nome del ramo remoto che vogliamo creare sul remoto.

Se rimuoviamo i nomi dei rami locali e remoti, avrà il formato

git push -u nome_remoto nome_cartella

Questo spingerà il ramo locale a remoto e con lo stesso nome del ramo locale branch_name. Il ramo locale traccerà anche il ramo remoto.


Come fare attraverso il Source Tree

 1: Open SourceTree, click on Repository -> Checkout
 2 :Click on Create New Branch
 3: Select branch where from you want to get code for new branch 
 4: Give your branch name
 5: Push the branch  (by click on Push button)

git branch -r dice che il nome dell'oggetto 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.





git branch git-branch