මට පහත සඳහන් දේ කිරීමට හැකි වීමට අවශ්‍යයි:

1. වෙනත් (දුරස්ථ හෝ දේශීය) ශාඛාවක් මත පදනම්ව දේශීය ශාඛාවක් සාදන්න (හරහා git branchහෝ හරහා git checkout -b)

2. ප්‍රාදේශීය ශාඛාව දුරස්ථ ගබඩාවට තල්ලු කරන්න (ප්‍රකාශයට පත් කරන්න), නමුත් එය ලුහුබැඳිය හැකි වන git pullඅතර git pushඑය වහාම ක්‍රියාත්මක වේ.

මම කොහොමද ඒක කරන්නේ?

--set-upstreamGit 1.7 හි මම දනිමි , නමුත් එය පශ්චාත්-නිර්මාණ ක්‍රියාවකි. දුරස්ථ ගබඩාවට ශාඛාව තල්ලු කිරීමේදී සමාන වෙනසක් කිරීමට ක්‍රමයක් සොයා ගැනීමට මට අවශ්‍යය.

Git 1.7.0 සහ පසුව, ඔබට නව ශාඛාවක් පරීක්ෂා කළ හැකිය:

git checkout -b <branch>

ලිපිගොනු සංස්කරණය කරන්න, එකතු කරන්න සහ කැපවන්න. එවිට සමග තල්ලු -u(කෙටි සඳහා --set-upstream) විකල්පය:

git push -u origin <branch>

තල්ලු කිරීමේදී Git විසින් ලුහුබැඳීමේ තොරතුරු සකස් කරනු ඇත.

ඔබ ඔබේ ගබඩාව අන් අය සමඟ බෙදා නොගන්නේ නම්, මෙය ඔබගේ සියලුම ශාඛා දුරස්ථයට තල්ලු කිරීමට ප්‍රයෝජනවත් වන --set-upstreamඅතර ඔබ වෙනුවෙන් නිවැරදිව නිරීක්ෂණය කිරීම:

git push --all -u

(OP ඉල්ලා සිටියේ හරියටම නොවේ, නමුත් මෙම එක් ලයිනර් ඉතා ජනප්‍රියයි)

ඔබ ඔබේ repo එක අන් අය සමඟ බෙදා ගන්නවා නම් මෙය ඇත්තෙන්ම හොඳ ස්වරූපයක් නොවේ.

හඳුන්වාදීමට පෙර git push -u, git pushඔබ කැමති දේ ලබා ගැනීමට විකල්පයක් නොතිබුණි . ඔබට නව වින්‍යාස ප්‍රකාශ එකතු කිරීමට සිදු විය.

ඔබ මෙය භාවිතා කරමින් නව ශාඛාවක් නිර්මාණය කරන්නේ නම්:

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

ගොනුව git configකෙලින්ම සංස්කරණය කිරීමෙන් වළක්වා ගැනීමට ඔබට විධානය භාවිතා කළ හැකිය .git/config.

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

නැතහොත් ඔබට .git/configමෙම ශාඛාවට තොරතුරු සොයා ගැනීම සඳහා ගොනුව අතින් සංස්කරණය කළ හැකිය .

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

සරලව කිවහොත්, නව දේශීය ශාඛාවක් නිර්මාණය කිරීම සඳහා , කරන්න:

git branch <branch-name>

එය දුරස්ථ ගබඩාවට තල්ලු කිරීම සඳහා , කරන්න:

git push -u origin <branch-name>

දැනටමත් මෙහි දී ඇති විසඳුම්වල සුළු වෙනසක්:

1. වෙනත් (දුරස්ථ හෝ දේශීය) ශාඛාවක් මත පදනම්ව දේශීය ශාඛාවක් සාදන්න:

   git checkout -b branchname
   

2. ප්‍රාදේශීය ශාඛාව දුරස්ථ ගබඩාවට තල්ලු කරන්න (ප්‍රකාශයට පත් කරන්න), නමුත් එය ලුහුබැඳිය හැකි වන git pullඅතර git pushඑය වහාම ක්‍රියාත්මක වේ

   git push -u origin HEAD
   

   භාවිතා කිරීම HEADයනු "වත්මන් ශාඛාව දුරස්ථයේ එකම නමට තල්ලු කිරීමට පහසු ක්‍රමයකි". මුලාශ්‍රය: https://git-scm.com/docs/git-push Git අනුව, HEAD (ලොකු අකුරින්) යනු වර්තමාන ශාඛාවේ (ගස) මුදුනට යොමු දැක්වීමකි.

   මෙම -uවිකල්පය සඳහා පමණක් කෙටි --set-upstream. මෙය වත්මන් ශාඛාව සඳහා උඩුගං ලුහුබැඳීමේ යොමු කිරීමක් එක් කරනු ඇත. ඔබගේ .git / config ගොනුව බැලීමෙන් ඔබට මෙය සත්‍යාපනය කළ හැකිය:

   

මම සරලවම කරනවා

git push -u origin localBranch:remoteBranchToBeCreated

දැනටමත් ක්ලෝන කරන ලද ව්‍යාපෘතියක් හරහා.

Git remoteBranchToBeCreatedවිසින් මා කළ කැපවීම යටතේ නව ශාඛාවක් නිර්මාණය කරයි localBranch.

සංස්කරණය කරන්න : මෙය ඔබගේ වර්තමාන ප්‍රාදේශීය ශාඛාවේ (සමහරවිට නම් කර ඇති localBranch) උඩුමහලට වෙනස් කරයි origin/remoteBranchToBeCreated. එය නිවැරදි කිරීම සඳහා සරලව ටයිප් කරන්න:

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

එබැවින් ඔබගේ වර්තමාන ප්‍රාදේශීය ශාඛාව දැන් origin/localBranchආපසු හැරී යයි.

ඔබ දැනටමත් එවැනි ව්‍යාපෘතියක් ක්ලෝන කර ඇතැයි මම සිතමි:

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

1. ඔබගේ දේශීය පිටපතෙහි, නව ශාඛාවක් සාදා එය පරීක්ෂා කරන්න:

   git checkout -b <newbranch>
   

2. ඔබ ඔබේ සේවාදායකයේ "git හිස් --init" එකක් සාදා myapp.git නිර්මාණය කළා යැයි සිතමු, ඔබ කළ යුත්තේ:

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

3. ඊට පසු, පරිශීලකයින්ට හැකි විය යුතුය

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

සටහන: මම හිතන්නේ ඔබ සතුව ඔබේ සේවාදායකය ක්‍රියාත්මක වී ඇති බවයි. එය එසේ නොවේ නම්, එය ක්‍රියා නොකරනු ඇත. හොඳ කොහොමද මෙතන .

එකතු කරන ලදි

දුරස්ථ ශාඛාවක් එක් කරන්න:

git push origin master:new_feature_name

සෑම දෙයක්ම හොඳ දැයි පරීක්ෂා කරන්න (සම්භවය ලබාගෙන දුරස්ථ ශාඛා ලැයිස්තුගත කරන්න):

git fetch origin
git branch -r

දේශීය ශාඛාවක් සාදා දුරස්ථ ශාඛාව නිරීක්ෂණය කරන්න:

git checkout -tb new_feature_name origin/new_feature_name

සියල්ල යාවත්කාලීන කරන්න:

git pull

සංස්කරණය කරන්න යල් පැන ගිය, භාවිතා කරන්නgit push -u origin $BRANCHNAME

විලියම්ගේ විවිධ Git මෙවලම් ( ගිටීරියස් රෙපෝ සහ ක්ලෝන ) git publish-branchවලින් භාවිතා කරන්න .

හරි, රූබි නැත, එබැවින් - ආරක්ෂක විධිවිධාන නොසලකා හැරීම! - විධානාවලිය අවසන් රේඛා තුනක් ගත සහ bash තිර රචනය නිර්මාණය, 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}

git-publish-branch REMOTENAME BRANCHNAMEREMOTENAME සාමාන්‍යයෙන් සම්භවයක් ඇති තැන ධාවනය කරන්න (පෙරනිමියෙන් ආරම්භය ලබා ගැනීම සඳහා ඔබට ස්ක්‍රිප්ට් වෙනස් කළ හැකිය ...)

පවත්නා ශාඛාවකින් අතු බෙදී නව ශාඛාවක් නිර්මාණය කිරීම

git checkout -b <new_branch>

ඉන්පසු මෙම නව ශාඛාව භාවිතා කරමින් ගබඩාවට තල්ලු කරන්න

git push -u origin <new_branch>

මෙය සියලු දේශීය කොමිස් අලුතින් සාදන ලද දුරස්ථ ශාඛාවකට තල්ලු කරයි origin/<new_branch>

1.7 ට පෙර GitLab අනුවාදය සඳහා, භාවිතා කරන්න:

git checkout -b name_branch

(name_branch, උදා: master)

එය දුරස්ථ ගබඩාවට තල්ලු කිරීම සඳහා, කරන්න:

git push -u origin name_new_branch

(name_new_branch, උදාහරණයක් ලෙස: feature)

මම අන්වර්ථයක් සෑදූ නිසා මම නව ශාඛාවක් නිර්මාණය කරන සෑම විටම එය දුරස්ථ ශාඛාව තල්ලු කර ඒ අනුව නිරීක්ෂණය කරනු ඇත. මම පහත සඳහන් කැබැල්ල .bash_profileගොනුවට දැමුවෙමි :

# 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

භාවිතය : මගේ නව ශාඛා නම gcb thuy/do-sth-koolසමඟ ටයිප් කරන්න thuy/do-sth-kool.

මෙහි ඇති පිළිතුරු මත තරමක් දුරට, මම මෙම ක්‍රියාවලිය සරල බාෂ් පිටපතක් ලෙස ඔතා ඇති අතර, එය ඇත්ත වශයෙන්ම Git අන්වර්ථයක් ලෙසද භාවිතා කළ හැකිය.

මට ඇති වැදගත් එකතු කිරීම නම්, මෙය සිදු කිරීමට පෙර ඒකක පරීක්ෂණ පැවැත්වීමට මා පොළඹවන අතර පෙරනිමියෙන් වර්තමාන ශාඛා නාමයෙන් සමත් වීමයි.

$ 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

ඔබට එය පඩි 2 කින් කළ හැකිය:

1.checkout දේශීය ශාඛාව නිර්මාණය කිරීම සඳහා භාවිතා කරන්න :

git checkout -b yourBranchName

ඔබට අවශ්‍ය පරිදි ඔබේ ශාඛාව සමඟ වැඩ කරන්න.

2.push ශාඛාව ස්වයංක්‍රීයව නිර්මාණය කිරීමට විධානය භාවිතා කර කේතය දුරස්ථ ගබඩාවට යවන්න:

git push -u origin yourBanchName

මෙය කිරීමට විකෘති ක්‍රම තිබේ නමුත් මෙම ක්‍රමය සැබවින්ම සරල යැයි මම සිතමි.

විශාලතම නම්යතාවය සඳහා, ඔබට අභිරුචි Git විධානයක් භාවිතා කළ හැකිය . උදාහරණයක් ලෙස, ඔබගේ $PATHනමින් කොතැනක හෝ පහත දැක්වෙන පයිතන් පිටපත git-publishසාදා එය ක්‍රියාත්මක කළ හැකි කරන්න:

#!/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())

එවිට git publish -hඔබට භාවිත තොරතුරු පෙන්වනු ඇත:

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)