J'ai créé une branche locale que je souhaite «pousser» en amont. Il y a une question similaire ici sur Stack Overflow sur la façon de suivre une branche distante nouvellement créée.

Cependant, mon flux de travail est légèrement différent. Tout d' abord , je veux créer une branche locale, et je ne le pousser l' amont quand je suis satisfait et je veux partager ma branche.

• Comment ferais-je ça? (mes recherches sur google ne semblaient aboutir à rien).
• Comment pourrais-je dire à mes collègues de le retirer du référentiel en amont?

MISE À JOUR Avec Git 2.0, il y a une réponse plus simple que j'ai écrite ci-dessous: https://stackoverflow.com/a/27185855/109305

Tout d'abord, vous créez votre succursale localement:

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

La branche distante est automatiquement créée lorsque vous la poussez sur le serveur distant. Ainsi, lorsque vous vous sentez prêt, vous pouvez simplement faire:

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

Où <remote-name>est généralement originle nom que git donne à la télécommande à partir de laquelle vous avez cloné. Vos collègues tireraient alors simplement cette branche, et elle est automatiquement créée localement.

Notez cependant que formellement, le format est:

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

Mais lorsque vous en omettez un, cela suppose que les deux noms de branche sont les mêmes. Cela dit, par prudence , ne faites pas l'erreur critique de ne spécifier que :<remote-branch-name>(avec les deux-points), sinon la branche distante sera supprimée!

Pour qu'un utilisateur ultérieur git pullsache quoi faire, vous pouvez plutôt utiliser:

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

Comme décrit ci-dessous, l' --set-upstreamoption met en place une branche en amont:

Pour chaque branche mise à jour ou correctement poussée, ajoutez une référence en amont (suivi), utilisée par git-pull (1) sans argument et d'autres commandes.

Tout d'abord, vous devez créer votre succursale localement

git checkout -b your_branch

Après cela, vous pouvez travailler localement dans votre branche, lorsque vous êtes prêt à partager la branche, appuyez dessus. La commande suivante pousse la branche vers l'origine du référentiel distant et la suit

git push -u origin your_branch

Les coéquipiers peuvent rejoindre votre branche en faisant:

git fetch
git checkout origin/your_branch

Vous pouvez continuer à travailler dans la branche et à pousser quand vous le souhaitez sans passer d'arguments à git push (git push sans argument poussera le maître vers le maître distant, votre local de votre_branche vers votre_branch distant, etc ...)

git push

Les coéquipiers peuvent pousser vers votre branche en faisant des commits, puis pousser explicitement

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

Ou suivre la branche pour éviter les arguments pour git push

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

Solution Git 2.0+ simple:

Depuis Git 2.0, le comportement est devenu plus simple :

Vous pouvez configurer git avec push.default = currentpour vous faciliter la vie:

J'ai ajouté cela maintenant je peux simplement pousser une nouvelle branche en amont avec

$ git push -u

-usuivra la branche distante du même nom. Maintenant, avec cette configuration, vous devinerez automatiquement la référence à distance à git push. Depuis la documentation de git.config :

push.default

Définit l'action que git push doit entreprendre si aucune spécification de référence n'est explicitement indiquée.

push.default = current- appuyez sur la branche actuelle pour mettre à jour une branche du même nom du côté de la réception. Fonctionne dans les workflows centraux et non centraux.

Pour moi, c'est une bonne simplification de mon flux de travail Git au quotidien. Le paramètre de configuration prend en charge le cas d'utilisation «habituel» dans lequel vous ajoutez une branche localement et souhaitez la créer à distance. En outre, je peux tout aussi facilement créer des branches locales à partir de télécommandes en faisant simplement git co remote_branch_name(par opposition à l'utilisation de --set-upstream-toflag).

Je connais cette question et les réponses acceptées sont plutôt anciennes, mais le comportement a changé de sorte que des options de configuration existent maintenant pour simplifier votre flux de travail.

Pour ajouter à votre configuration globale de Git, exécutez ceci sur la ligne de commande:

$ git config --global push.default current

Comme indiqué dans les réponses précédentes,

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

est suffisant pour pousser une branche locale.

Vos collègues peuvent extraire toutes les branches distantes (y compris les nouvelles) avec cette commande:

git remote update

Ensuite, pour effectuer des modifications sur la branche, le flux habituel:

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

Créez une nouvelle branche localement en fonction de la branche actuelle:

git checkout -b newbranch

Validez les modifications comme vous le feriez normalement. Ensuite, poussez-le en amont:

git push -u origin HEAD

Il s'agit d'un raccourci pour pousser la branche actuelle vers une branche du même nom originet la suivre afin que vous n'ayez pas besoin de la spécifier origin HEADà l'avenir.

Si vous souhaitez créer une branche à partir de la branche actuelle

git checkout -b {your_local_branch_name} 

vous voulez une branche d'une branche distante, vous pouvez essayer

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

Si vous avez terminé les modifications, vous pouvez ajouter le fichier.

git add -A or git add <each_file_names>

Faites ensuite un commit localement

git commit -m 'your commit message'

Lorsque vous souhaitez effectuer un repo à distance

git push -u origin <your_local_branch_name>

Tous ensemble seront

git checkout -b bug_fixes 

ou Si vous souhaitez créer une branche à partir d'une branche distante, dites développement

git checkout -b bug_fixes origine / développement

Vous pouvez pousser à la succursale pour le repo à distance en

git push -u origin bug_fixes

Chaque fois que vous souhaitez mettre à jour votre branche à partir d'une autre branche, dites master .

git pull origin master.

Si vous voulez simplement créer une branche distante sans avoir la branche locale, vous pouvez le faire comme ceci:

git push origin HEAD:refs/heads/foo

Il pousse tout ce qui est votre HEAD à branchement foo qui n'existait pas sur la télécommande.

Solution la plus simple ... Drumm Roll ... git version 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 - La branche que vous venez de créer dans votre environnement local, et la branche distante non existante où vous essayez de pousser, doivent avoir le même nom .

[Réponse rapide]

Vous pouvez le faire en 2 étapes:

1. Utilisez le checkoutpour créer la branche locale:

git checkout -b yourBranchName

2. Utilisez la pushcommande pour créer automatiquement la branche et envoyer le code au référentiel distant:

git push -u origin yourBanchName

Il existe plusieurs façons de procéder, mais je pense que cette méthode est vraiment simple.

Vous créez d'abord la branche localement:

git checkout -b your_branch

Et puis pour créer la branche à distance:

git push --set-upstream origin your_branch

Remarque: Cela fonctionne sur les dernières versions de git:

$ git --version
git version 2.3.0

À votre santé!

Créez la branche sur votre machine locale et basculez dans cette branche:

$ git checkout -b [name_of_your_new_branch]

Poussez la branche sur github:

$ git push origin [name_of_your_new_branch]

Lorsque vous souhaitez engager quelque chose dans votre branche, assurez-vous d'être dans votre branche.

Vous pouvez voir toutes les branches créées en utilisant:

$ git branch

Ce qui montrera:

* approval_messages
  master
  master_clean

Ajoutez une nouvelle télécommande pour votre branche:

$ git remote add [name_of_your_remote] 

Poussez les modifications de votre commit dans votre branche:

$ git push origin [name_of_your_remote]

Mettez à jour votre branche lorsque la branche d'origine du référentiel officiel a été mise à jour:

$ git fetch [name_of_your_remote]

Ensuite, vous devez appliquer pour fusionner les modifications, si votre branche est dérivée de develop, vous devez faire:

$ git merge [name_of_your_remote]/develop

Supprimez une branche sur votre système de fichiers local:

$ git branch -d [name_of_your_new_branch]

Pour forcer la suppression de la branche locale sur votre système de fichiers:

$ git branch -D [name_of_your_new_branch]

Supprimez la branche sur github:

$ git push origin :[name_of_your_new_branch]

Ici toutes les informations

Autre projet existant

Création d'une branche locale à partir d'une branche existante (peut être master / develop / any-other-branch).

git checkout -b nom_branche

Poussez ceci à distance

git push -u nom_de_local nom_de_branche_local: nom_de_branche_distant

Ici,

1. -u: définit la branche amont
2. remote_name: git définit le nom par défaut comme "origine" lors de la création du référentiel. Cela peut cependant être changé en un nom arbitraire différent.
3. local_branch_name: est le nom de la branche locale à pousser.
4. remote_branch_name: est le nom de la branche distante que nous voulons créer sur remote.

Si nous supprimons les noms de branche locale et distante, elle aura le format

git push -u nom_distant nom_branche

Cela poussera la branche locale à distance et avec le même nom que la branche locale nom_branche. La branche locale suivra également la branche distante.

Je sais que cette question est bien répondue, mais je voulais simplement énumérer les étapes que je prends pour créer une nouvelle branche "myNewBranch" et pousser à distance ("origine" dans mon cas) et configurer le suivi. Considérez ceci comme la version "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

Maintenant, avec git, vous pouvez simplement taper, lorsque vous êtes dans la bonne branche

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

et git créer pour vous la branche d'origine.

Je voulais juste ajouter cela pendant:

git checkout -b {branchName}

Crée une nouvelle branche, il vérifie également cette branche / en fait votre branche actuelle. Si, pour une raison quelconque, tout ce que vous voulez faire est de couper une branche mais pas d'en faire votre branche actuelle, vous utiliserez la commande suivante:

git branch {branchName}

Dans la première commande, "checkout" fait de cette branche votre branche actuelle, et le "-b" signifie: cette branche n'existe pas encore, alors faites-la pour moi.

Comment faire via l'arbre source

 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>ne fonctionne pas si la branche nouvellement créée n'est pas générée à partir du même référentiel, c'est-à-dire si vous n'avez pas créé la nouvelle branche en utilisant git checkout -b new_branch, alors cela ne fonctionnera pas.

Par exemple, j'avais cloné deux référentiels différents localement et je devais copier repo2 / branch1 vers repo1 / puis le pousser aussi.

Ce lien m'a aidé à transférer ma branche locale (clonée à partir d'un autre référentiel) vers mon référentiel distant:

Voici comment vous le faites en éclipse via Egit.

1) Accédez à la vue "Git Repository Exploring" et expliquez le projet git dans lequel vous souhaitez créer une branche. Sous Brances -> Local .. sélectionnez la branche pour laquelle vous souhaitez créer la branche (dans mon cas, j'ai sélectionné maître .. vous pouvez sélectionner une autre autre branche si vous le souhaitez) .. puis faites un clic droit et cliquez sur l'option Créer une branche .. et sélectionnez l'option d'extraction de ce projet, puis cliquez sur le bouton Terminer.

2) Maintenant, dans l'explorateur de projet, sélectionnez le projet .. cliquez avec le bouton droit puis sur Équipe -> Branche push.

Une nouvelle branche distante sera créée. Vous pouvez donner le nom de la branche à vos collègues afin qu'ils puissent la retirer.

J'ai utilisé deux façons de créer une branche

Si vous utilisez TortoiseGit, suivez ces étapes: -

1.Créez une branche à l'aide de TortoiseGit

Faites un clic droit sur votre projet >>> TortoiseGit >>> Créer une branche >>> écrivez le nom de la branche et sélectionnez la branche de base puis appuyez sur ok

2.Poussez la branche

Faites un clic droit sur votre projet >>> TortoiseGit >>> poussez >>> cliquez sur ok

Passer à une nouvelle succursale

Faites un clic droit sur votre projet >>> TortoiseGit >>> Switch / Checkout >>> sélectionnez la branche nouvellement créée et appuyez sur ok

Si vous utilisez l'invite de commande, procédez comme suit: -

1.Créer une branche à l'aide de l'invite de commande

$ git checkout -b nouveau_nom_branche

2.Poussez la branche

$ git push origin new_branch_name

3.Passez à la nouvelle branche, elle sera déjà commutée sur new_branch_name sinon vous pouvez utiliser

$ git checkout new_branch_name

J'utilise ceci et c'est assez pratique:

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

Utilisation: git mkdir NEW_BRANCH

Vous n'avez même pas besoin du statut git; peut-être, je veux juste m'assurer que tout se passe bien ...

Vous pouvez avoir les deux branches LOCAL et REMOTE avec une seule commande.