Saya ingin dapat melakukan hal berikut:

1. Buat cabang lokal berdasarkan beberapa cabang lain (jarak jauh atau lokal) (via git branchatau git checkout -b)

2. Dorong cabang lokal ke repositori jarak jauh (publikasikan), tetapi membuatnya bisa dilacak jadi git pulldan git pushakan segera bekerja.

Bagaimana aku melakukan itu?

Saya tahu tentang --set-upstreamGit 1.7, tapi itu adalah tindakan pasca-penciptaan. Saya ingin menemukan cara untuk membuat perubahan serupa ketika mendorong cabang ke repositori jarak jauh.

Di Git 1.7.0 dan yang lebih baru, Anda dapat checkout cabang baru:

git checkout -b <branch>

Edit file, tambahkan dan komit. Kemudian dorong dengan -u(kependekan dari --set-upstream) :

git push -u origin <branch>

Git akan mengatur informasi pelacakan selama push.

Jika Anda tidak membagikan repo Anda dengan orang lain, ini berguna untuk mendorong semua cabang Anda ke kendali jarak jauh, dan --set-upstreammelacak dengan benar untuk Anda:

git push --all -u

(Tidak persis apa yang diminta OP, tapi liner satu ini cukup populer)

Jika Anda membagikan repo kepada orang lain, ini bukan bentuk yang baik karena Anda akan menyumbat repo dengan semua cabang eksperimental Anda yang cerdik.

Sebelum pengenalan git push -u, tidak adagit push pilihan untuk mendapatkan apa yang Anda inginkan. Anda harus menambahkan pernyataan konfigurasi baru.

Jika Anda membuat cabang baru menggunakan:

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

Anda dapat menggunakan git configperintah untuk menghindari pengeditan .git/configfile secara langsung .

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

Atau Anda dapat mengedit .git/configfile secara manual untuk mendapatkan informasi pelacakan ke cabang ini.

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

Sederhananya, untuk membuat cabang lokal baru , lakukan:

git branch <branch-name>

Untuk mendorongnya ke repositori jarak jauh , lakukan:

git push -u origin <branch-name>

Sedikit variasi dari solusi yang sudah diberikan di sini:

1. Buat cabang lokal berdasarkan beberapa cabang lain (jarak jauh atau lokal):

   git checkout -b branchname
   

2. Dorong cabang lokal ke repositori jarak jauh (publikasikan), tetapi membuatnya bisa dilacak jadi git pulldan git pushakan segera bekerja

   git push -u origin HEAD
   

   Menggunakan HEADadalah "cara praktis untuk mendorong cabang saat ini ke nama yang sama di remote". Sumber: https://git-scm.com/docs/git-push Dalam istilah Git, HEAD (dalam huruf besar) adalah referensi ke atas cabang saat ini (pohon).

   The -upilihan adalah hanya singkat untuk --set-upstream. Ini akan menambahkan referensi pelacakan hulu untuk cabang saat ini. Anda dapat memverifikasi ini dengan melihat file .git / config Anda:

   

Saya hanya melakukannya

git push -u origin localBranch:remoteBranchToBeCreated

lebih dari proyek yang sudah dikloning.

Git membuat cabang baru bernama di remoteBranchToBeCreatedbawah komit saya yang saya lakukan di localBranch.

Sunting : ini mengubah localBranchhulu cabang lokal Anda (mungkin bernama ) menjadi origin/remoteBranchToBeCreated. Untuk memperbaikinya, cukup ketik:

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

Jadi cabang lokal Anda sekarang melacak origin/localBranchkembali.

Saya kira Anda sudah mengkloning proyek seperti:

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

1. Kemudian di salinan lokal Anda, buat cabang baru dan periksa:

   git checkout -b <newbranch>
   

2. Andaikan Anda membuat "git bare --init" di server Anda dan membuat myapp.git, Anda harus:

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

3. Setelah itu, pengguna harus bisa

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

CATATAN: Saya berasumsi bahwa server Anda sudah aktif dan berjalan. Jika tidak, itu tidak akan berhasil. Cara yang baik ada di sini .

TAMBAH

Tambahkan cabang jarak jauh:

git push origin master:new_feature_name

Periksa apakah semuanya baik (ambil asal dan daftar cabang jarak jauh):

git fetch origin
git branch -r

Buat cabang lokal dan lacak cabang jarak jauh:

git checkout -tb new_feature_name origin/new_feature_name

Perbarui semuanya:

git pull

sunting usang, cukup gunakangit push -u origin $BRANCHNAME

Gunakan git publish-branchdari alat Git lain-lain William ( repo dan klon gitorious ).

OK, tidak ada Ruby, jadi - abaikan pengamanan! - mengambil tiga baris terakhir dari naskah dan membuat script 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}

Kemudian jalankan git-publish-branch REMOTENAME BRANCHNAME, tempat REMOTENAME biasanya asal (Anda dapat memodifikasi skrip untuk mengambil asal sebagai default, dll ...)

Untuk membuat cabang baru dengan bercabang dari cabang yang ada

git checkout -b <new_branch>

dan kemudian dorong cabang baru ini ke repositori menggunakan

git push -u origin <new_branch>

Ini membuat dan mendorong semua komit lokal ke cabang jarak jauh yang baru dibuat origin/<new_branch>

Untuk versi GitLab sebelum 1.7, gunakan:

git checkout -b name_branch

(name_branch, ex: master)

Untuk mendorongnya ke repositori jarak jauh, lakukan:

git push -u origin name_new_branch

(name_new_branch, misalnya: feature)

Saya membuat alias sehingga setiap kali saya membuat cabang baru, itu akan mendorong dan melacak cabang jarak jauh sesuai. Saya memasukkan potongan berikut ke dalam .bash_profilefile:

# 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

Penggunaan : ketikkan saja gcb thuy/do-sth-kooldengan thuy/do-sth-koolnama cabang baru saya.

Membangun sedikit jawaban di sini, saya telah membungkus proses ini sebagai skrip Bash sederhana, yang tentu saja dapat digunakan sebagai alias Git juga.

Tambahan penting bagi saya adalah bahwa ini meminta saya untuk menjalankan tes unit sebelum melakukan dan meneruskan nama cabang saat ini secara default.

$ 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

Anda dapat melakukannya dalam 2 curam:

1. Gunakan checkoutuntuk buat cabang lokal:

git checkout -b yourBranchName

Bekerja dengan Cabang Anda seperti yang Anda inginkan.

2. Gunakan pushperintah untuk membuat cabang secara otomatis dan mengirim kode ke repositori jarak jauh:

git push -u origin yourBanchName

Ada banyak cara untuk melakukan ini tetapi saya pikir cara ini sangat sederhana.

Untuk fleksibilitas terbaik, Anda bisa menggunakan perintah custom Git . Misalnya, buat skrip Python berikut di suatu tempat di $PATHbawah nama Anda git-publishdan buat agar dapat dieksekusi:

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

Maka git publish -hakan muncul informasi penggunaan:

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)