Ho creato un ramo locale che voglio "spingere" a monte. C'è una domanda simile qui su Stack Overflow 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 fornire nulla).
• Come direi ai miei colleghi di estrarlo dal repository upstream?

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

Innanzitutto, crei la tua filiale localmente:

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

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

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

Dov'è in <remote-name>genere origin, il nome che git dà al telecomando da cui hai clonato. I tuoi colleghi dovrebbero semplicemente estrarre quel ramo ed è 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, si assume che entrambi i nomi dei rami siano uguali. Detto questo, come avvertimento , non commettere l'errore critico di specificare solo :<remote-branch-name>(con i due punti), altrimenti il ​​ramo remoto verrà eliminato!

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

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

Come descritto di seguito, l' --set-upstreamopzione imposta un ramo a monte:

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

Innanzitutto, devi creare la tua filiale 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 verso l'origine del repository remoto e lo traccia

git push -u origin your_branch

I compagni di squadra possono raggiungere la tua filiale facendo:

git fetch
git checkout origin/your_branch

Puoi continuare a lavorare nel ramo e spingere ogni volta che vuoi senza passare argomenti a git push (senza argomenti git push spingerà il master a master remoto, your_branch local a remoto your_branch, ecc ...)

git push

I compagni di squadra possono spingere verso la tua filiale facendo commit e quindi spingendo 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

Soluzione Git 2.0+ semplice:

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

Puoi configurare git con push.default = currentper semplificare la vita:

Ho aggiunto questo, quindi ora posso semplicemente spingere un nuovo ramo a monte con

$ git push -u

-useguirà il ramo remoto con lo stesso nome. Ora con questa configurazione indovinerai automaticamente il riferimento remoto di git push. Dalla documentazione di git.config :

push.default

Definisce l'azione che git push dovrebbe intraprendere se nessuna refspec viene esplicitamente fornita.

push.default = current- premere il ramo corrente per aggiornare un ramo con lo stesso nome sull'estremità ricevente. Funziona con flussi di lavoro sia centrali che non centrali.

Per me, questa è una buona semplificazione del mio flusso di lavoro Git quotidiano. L'impostazione di configurazione si occupa del caso d'uso 'normale' in cui si aggiunge un ramo localmente e si desidera crearlo in remoto. Inoltre, posso altrettanto facilmente creare filiali locali dai telecomandi semplicemente git co remote_branch_name(invece di usare --set-upstream-toflag).

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

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

$ git config --global push.default current

Come indicato nelle risposte precedenti,

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

è sufficiente per spingere una filiale locale.

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

git remote update

Quindi, per apportare modifiche al ramo, il solito flusso:

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

Crea un nuovo ramo localmente in base al ramo corrente:

git checkout -b newbranch

Effettua le modifiche come faresti normalmente. Quindi, spingilo a monte:

git push -u origin HEAD

Questa è una scorciatoia per spingere il ramo corrente su un ramo con lo stesso nome origine tracciarlo in modo da non doverlo specificare origin HEADin futuro.

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 esegui un commit a livello locale

git commit -m 'your commit message'

Quando si desidera passare al repository remoto

git push -u origin <your_local_branch_name>

Lo saranno tutti insieme

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 ramo al repository remoto da

git push -u origin bug_fixes

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

git pull origin master.

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

git push origin HEAD:refs/heads/foo

Spinge qualunque sia la tua TESTA a diramare un foo che non esisteva sul telecomando.

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

1) git checkout -b localBranchNameThatDoesNotExistInRemote

2) Do your changes, and do a git commit 

3) git push origin localBranchNameThatDoesNotExistInRemote --force

NB: il ramo appena creato nel proprio ambiente locale e il ramo remoto inesistente in cui si sta tentando di eseguire il push devono avere lo stesso nome .

[Risposta rapida]

Puoi farlo in 2 scatti:

1. Utilizzare checkoutper per creare il ramo locale:

git checkout -b yourBranchName

2. Utilizzare il pushcomando per creare automaticamente il ramo e inviare il codice al repository remoto:

git push -u origin yourBanchName

Ci sono molti modi per farlo ma penso che questo sia davvero semplice.

Per prima cosa crei il ramo localmente:

git checkout -b your_branch

E quindi per creare il ramo in remoto:

git push --set-upstream origin your_branch

Nota: funziona con le versioni più latenti di git:

$ git --version
git version 2.3.0

Saluti!

Crea il ramo sul tuo computer locale e passa a 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 impegnare 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 la tua filiale:

$ git remote add [name_of_your_remote] 

Inserisci le modifiche dal tuo commit nella tua filiale:

$ git push origin [name_of_your_remote]

Aggiorna la tua filiale quando la filiale originale dal repository ufficiale è stata aggiornata:

$ git fetch [name_of_your_remote]

Quindi devi fare domanda 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 della filiale 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

Creazione di un ramo locale da un ramo esistente (può essere master / sviluppo / qualsiasi altro ramo).

git checkout -b branch_name

Spingilo sul telecomando

git push -u remote_name local_branch_name: remote_branch_name

Qui,

1. -u: imposta il ramo a monte
2. remote_name: git imposta il nome di default su "origine" quando crea il repository. Questo può tuttavia essere modificato con un nome arbitrario diverso.
3. local_branch_name: è il nome del ramo locale da inviare.
4. remote_branch_name: è il nome del ramo remoto che vogliamo creare sul telecomando.

Se rimuoviamo i nomi delle filiali locali e remote, avrà il formato

git push -u remote_name branch_name

Ciò spingerà il ramo locale in remoto e con lo stesso nome del ramo locale nome_ramo. Il ramo locale seguirà anche il ramo remoto.

So che questa domanda ha una buona risposta, ma volevo solo elencare i passi che faccio per creare un nuovo ramo "myNewBranch" e spingere in remoto ("origine" nel mio caso) e impostare il monitoraggio. Considera questa 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

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

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

e git crea per te il ramo di origine.

Volevo solo aggiungerlo mentre:

git checkout -b {branchName}

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

git branch {branchName}

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

Come eseguire tramite l'albero dei sorgenti

 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 push -u <remote-name> <branch-name>non funziona se il ramo appena creato non viene generato dallo stesso repository, ovvero se non si è creato il nuovo ramo utilizzando git checkout -b new_branch, questo non funzionerà.

Ad esempio, avevo clonato localmente due diversi repository e ho dovuto copiare repo2 / branch1 in repo1 / e quindi spingerlo anch'io.

Questo link mi ha aiutato a spingere il mio ramo locale (clonato da un altro repository) al mio repository remoto:

Ecco come lo fai in eclissi attraverso Egit.

1) Vai alla vista "Esplorazione del repository Git" ed espandi il progetto git in cui vuoi creare un ramo. In Brances -> Local .. seleziona il ramo per cui vuoi creare il branch (nel mio caso ho selezionato master .. puoi selezionare un altro branch se vuoi) .. quindi fai clic destro e fai clic sull'opzione Crea Branch .. e seleziona l'opzione Verifica questo progetto, quindi fai clic sul pulsante Fine.

2) Ora da Esplora progetti selezionare il progetto. Fare clic con il tasto destro del mouse, quindi Team -> Push Branch.

Verrà creato un nuovo ramo remoto. Puoi dare il nome della filiale ai tuoi colleghi in modo che possano estrarla.

Ho usato due modi per creare un ramo

Se stai usando TortoiseGit segui questi passaggi: -

1.Creare Branch usando TortoiseGit

Fai clic con il tasto destro del mouse sul tuo progetto >>> TortoiseGit >>> Crea ramo >>> scrivi il nome del ramo e seleziona il ramo base quindi premi ok

2.Spingere il ramo

Fai clic destro sul tuo progetto >>> TortoiseGit >>> premi >>> fai clic su OK

3. Passa alla nuova filiale

Fai clic con il tasto destro del mouse sul tuo progetto >>> TortoiseGit >>> Cambia / Acquista >>> seleziona il ramo appena creato e premi ok

Se si utilizza il prompt dei comandi, attenersi alla seguente procedura:

1.Creare il ramo usando il prompt dei comandi

$ git checkout -b new_branch_name

2.Spingere il ramo

$ git push origin new_branch_name

3. Passa al nuovo ramo, passerà già a nome_nuovo_branch altrimenti puoi usare

$ git verifica new_branch_name

Lo uso ed è abbastanza utile:

git config --global alias.mkdir '!git checkout -b $1; git status; git push -u origin $1; exit;'

Utilizzo: git mkdir NEW_BRANCH

Non hai nemmeno bisogno dello stato git; forse, voglio solo assicurarmi che tutto vada bene ...

Puoi avere ENTRAMBE il ramo LOCALE e REMOTO con un solo comando.