Ik wil het volgende kunnen:

1. Maak een lokale branch op basis van een andere (externe of lokale) branch (via git branch of git checkout -b)

2. Druk op de lokale vestiging
   naar de externe repository (publiceren), maar maak het
   traceerbaar zodat git pull en git push onmiddellijk werken.

Hoe doe ik dat?

Ik weet van --set-upstream in Git 1.7, maar dat is een actie na het maken. Ik wil een manier vinden om een ​​soortgelijke wijziging aan te brengen wanneer ik de branch naar de externe repository push.

Antwoord 1, autoriteit 100%

In Git 1.7.0 en hoger kun je een nieuwe branch afrekenen:

git checkout -b <branch>

Bewerk bestanden, voeg toe en bevestig. Dan duwen met de -u (afkorting van --set-upstream) optie:

git push -u origin <branch>

Git zal de trackinginformatie instellen tijdens de push.

Antwoord 2, autoriteit 7%

Als je je repo niet met anderen deelt, is dit handig om al je branches naar de remote te pushen, en --set-upstream correct voor je te volgen:

git push --all -u

(Niet precies waar de OP om vroeg, maar deze oneliner is behoorlijk populair)

Als je je repo met anderen deelt, is dit niet echt een goede vorm, omdat je de repo verstopt met al je onbetrouwbare experimentele branches.

Antwoord 3, autoriteit 2%

Voor de introductie van git push -u was er geen git push optie om te verkrijgen wat je wenst. U moest nieuwe configuratie-instructies toevoegen.

Als je een nieuwe branch aanmaakt met:

$ git checkout -b branchB
$ git push origin branchB:branchB

Je kunt het git config commando gebruiken om te voorkomen dat je het .git/config bestand rechtstreeks bewerkt:

$ git config branch.branchB.remote origin
$ git config branch.branchB.merge refs/heads/branchB

Of je kunt het bestand .git/config handmatig bewerken om trackinginformatie aan deze tak toe te voegen:

[branch "branchB"]
    remote = origin
    merge = refs/heads/branchB

Antwoord 4, autoriteit 2%

Simpel gezegd, om een ​​nieuwe lokale branch te maken, doe je:

git branch <branch-name>

Om het naar de externe repository te pushen, doe je:

git push -u origin <branch-name>

Antwoord 5, autoriteit 2%

Een kleine variatie op de oplossingen die hier al gegeven zijn:

1. Maak een lokale vestiging op basis van een andere (externe of lokale) vestiging:

   git checkout -b branchname
   

2. Push de lokale branch naar de externe repository (publiceren), maar maak het traceerbaar zodat git pull en git push onmiddellijk zullen werken

   git push -u origin HEAD
   

   Het gebruik van HEAD is een “handige manier om de huidige branch naar dezelfde naam op de afstandsbediening te pushen”. Bron: https://git-scm.com/docs/git-push
   In Git-termen is HEAD (in hoofdletters) een verwijzing naar de bovenkant van de huidige branch (boom).

   De optie -u is een afkorting voor --set-upstream. Hiermee wordt een upstream-trackingreferentie toegevoegd voor de huidige tak. je kunt dit verifiëren door in je .git/config-bestand te kijken:

   

Antwoord 6

Ik doe gewoon

git push -u origin localBranch:remoteBranchToBeCreated

over een reeds gekloond project.

Git maakt een nieuwe branch aan met de naam remoteBranchToBeCreated onder mijn commits die ik deed in localBranch.

Bewerken: dit verandert uw huidige lokale vestiging (mogelijk met de naam localBranch) upstream naar origin/remoteBranchToBeCreated. Om dat op te lossen, typt u gewoon:

git branch --set-upstream-to=origin/localBranch

of

git branch -u origin/localBranch

Dus je huidige lokale vestiging volgt nu origin/localBranch terug.

Antwoord 7

Ik veronderstel dat je al een project hebt gekloond zoals:

git clone http://github.com/myproject.git

1. Maak vervolgens in uw lokale kopie een nieuwe branch en bekijk deze:

   git checkout -b <newbranch>
   

2. Stel dat je een “git bare –init” op je server hebt gemaakt en de myapp.git hebt gemaakt, dan zou je:

   git remote add origin ssh://example.com/var/git/myapp.git
   git push origin master
   

3. Daarna zouden gebruikers in staat moeten zijn om

   git clone http://example.com/var/git/myapp.git
   

OPMERKING: ik ga ervan uit dat je server actief is. Als dat niet zo is, werkt het niet. Een goede how-to is hier.

TOEGEVOEGD

Voeg een externe tak toe:

git push origin master:new_feature_name

Controleer of alles goed is (haal de oorsprong op en geef een lijst van afgelegen takken):

git fetch origin
git branch -r

Maak een lokale branch en volg de remote branch:

git checkout -tb new_feature_name origin/new_feature_name

Alles bijwerken:

git pull

Antwoord 8

bewerken Verouderd, gebruik gewoon git push -u origin $BRANCHNAME

Gebruik git publish-branch van William’s diverse Git-tools.

OK, geen Ruby, dus – negeer de beveiligingen! – neem de laatste drie regels van het script en maak een bash-script, git-publish-branch:

#!/bin/bash
REMOTE=$1 # Rewrite this to make it optional...
BRANCH=$2
# Uncomment the following line to create BRANCH locally first
#git checkout -b ${BRANCH}
git push ${ORIGIN} ${BRANCH}:refs/heads/${BRANCH} &&
git config branch.${BRANCH}.remote ${REMOTE} &&
git config branch.${BRANCH}.merge refs/heads/${BRANCH}

Voer vervolgens git-publish-branch REMOTENAME BRANCHNAME uit, waarbij REMOTENAME gewoonlijk de oorsprong is (u kunt het script wijzigen om oorsprong als standaard te nemen, enz…)

Antwoord 9

Een nieuwe vertakking maken door af te takken van een bestaande vertakking

git checkout -b <new_branch>

en push dan deze nieuwe branch naar de repository met

git push -u origin <new_branch>

Dit creëert en pusht alle lokale commits naar een nieuw aangemaakte remote branch origin/<new_branch>

Antwoord 10

Gebruik voor GitLab-versie ouder dan 1.7:

git checkout -b name_branch

(name_branch, ex: master)

Om het naar de externe repository te pushen, doe je:

git push -u origin name_new_branch

(name_new_branch, voorbeeld: feature)

Antwoord 11

Ik heb een alias gemaakt zodat wanneer ik een nieuwe branch maak, deze de remote branch dienovereenkomstig zal pushen en volgen. Ik heb het volgende stuk in het bestand .bash_profile geplaatst:

# Create a new branch, push to origin and track that remote branch
publishBranch() {
  git checkout -b $1
  git push -u origin $1
}
alias gcb=publishBranch

Gebruik: typ gewoon gcb thuy/do-sth-kool met thuy/do-sth-kool is mijn nieuwe branchnaam.

Antwoord 12

Je kunt het in 2 steile hellingen doen:

1. Gebruik de checkout om de lokale vestiging aan te maken:

git checkout -b yourBranchName

Werk met je filiaal zoals je wilt.

2. Gebruik de opdracht push om de vertakking automatisch aan te maken en de code naar de externe repository te sturen:

git push -u origin yourBanchName

Er zijn meerdere manieren om dit te doen, maar ik denk dat deze manier heel eenvoudig is.

Antwoord 13

Voortbouwend op de antwoorden hier, heb ik dit proces ingepakt als een eenvoudig Bash-script, dat natuurlijk ook als Git-alias kan worden gebruikt.

De belangrijke toevoeging voor mij is dat dit me ertoe aanzet unit-tests uit te voeren voordat ik commit en standaard de huidige branch-naam doorgeeft.

$ git_push_new_branch.sh
  Have you run your unit tests yet? If so, pass OK or a branch name, and try again
  usage: git_push_new_branch {OK|BRANCH_NAME}
  e.g.
  git_push_new_branch           -> Displays prompt reminding you to run unit tests
  git_push_new_branch OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

git_push_new_branch.sh

function show_help()
{
  IT=$(cat <<EOF
  Have you run your unit tests yet? If so, pass OK or a branch name, and try again
  usage: git_push_new_branch {OK|BRANCH_NAME}
  e.g.
  git_push_new_branch.sh           -> Displays prompt reminding you to run unit tests
  git_push_new_branch.sh OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch.sh MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin
  )
  echo "$IT"
  exit
}
if [ -z "$1" ]
then
  show_help
fi
CURR_BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$1" == "OK" ]
then
  BRANCH=$CURR_BRANCH
else
  BRANCH=${1:-$CURR_BRANCH}
fi
git push -u origin $BRANCH

Antwoord 14

Voor de grootste flexibiliteit zou je een aangepaste Git-opdracht kunnen gebruiken. Maak bijvoorbeeld het volgende Python-script ergens in uw $PATH onder de naam git-publish en maak het uitvoerbaar:

#!/usr/bin/env python3
import argparse
import subprocess
import sys
def publish(args):
    return subprocess.run(['git', 'push', '--set-upstream', args.remote, args.branch]).returncode
def parse_args():
    parser = argparse.ArgumentParser(description='Push and set upstream for a branch')
    parser.add_argument('-r', '--remote', default='origin',
                        help="The remote name (default is 'origin')")
    parser.add_argument('-b', '--branch', help='The branch name (default is whatever HEAD is pointing to)',
                        default='HEAD')
    return parser.parse_args()
def main():
    args = parse_args()
    return publish(args)
if __name__ == '__main__':
    sys.exit(main())

Dan zal git publish -h je gebruiksinformatie tonen:

usage: git-publish [-h] [-r REMOTE] [-b BRANCH]
Push and set upstream for a branch
optional arguments:
  -h, --help            show this help message and exit
  -r REMOTE, --remote REMOTE
                        The remote name (default is 'origin')
  -b BRANCH, --branch BRANCH
                        The branch name (default is whatever HEAD is pointing to)

Antwoord 15

Ik denk dat dit de eenvoudigste alias is, voeg toe aan je ~/.gitconfig

[alias]
  publish-branch = !git push -u origin $(git rev-parse --abbrev-ref HEAD)

Je rent gewoon

git publish-branch

en… het publiceert het filiaal