git-pull - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

git-pull - ດຶງຂໍ້ມູນຈາກແລະປະສົມປະສານກັບ repository ອື່ນຫຼືສາຂາທ້ອງຖິ່ນ

ສະຫຼຸບສັງລວມ

ໄປ ດຶງ [ທາງ​ເລືອກ​] [ [ ...]]

ລາຍລະອຽດ

ລວມເອົາການປ່ຽນແປງຈາກ repository ຫ່າງໄກສອກຫຼີກເຂົ້າໄປໃນສາຂາປະຈຸບັນ. ໃນຄ່າເລີ່ມຕົ້ນຂອງມັນ
ໂໝດ, git pull ແມ່ນຫຍໍ້ມາຈາກ git fetch ຕາມດ້ວຍ git merge FETCH_HEAD.

ພິເສດກ່ວາ, ໄປ ດຶງ ແລ່ນ ໄປ ດຶງ ກັບຕົວກໍານົດການແລະການໂທ ໄປ ລວມ to
ຮວມຫົວສາຂາທີ່ເອົາມາເຂົ້າໄປໃນສາຂາປະຈຸບັນ. ດ້ວຍ --rebase, ມັນແລ່ນ ໄປ
ປະຕິເສດ ແທນ​ທີ່ ໄປ ລວມ.

ຄວນເປັນຊື່ຂອງ repository ຫ່າງໄກສອກຫຼີກທີ່ສົ່ງໄປ git-fetch(1).
ສາ​ມາດ​ຕັ້ງ​ຊື່​ການ​ອ້າງ​ອີງ​ທາງ​ໄກ​ໂດຍ​ຕົນ​ເອງ (ເຊັ່ນ​: ຊື່​ຂອງ​ໂຄດ​ຄໍາ​ສັ່ງ​) ຫຼື​ແມ້​ກະ​ທັ້ງ a
ການ​ເກັບ​ກໍາ​ຂໍ້​ມູນ​ກັບ​ສາ​ຂາ​ການ​ຕິດ​ຕາມ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​ທີ່​ສອດ​ຄ້ອງ​ກັນ (ເຊັ່ນ​:
refs/heads/*:refs/remotes/origin/*), ແຕ່ໂດຍປົກກະຕິແລ້ວມັນເປັນຊື່ຂອງສາຂາຢູ່ໃນທາງໄກ.
repository

ຄ່າເລີ່ມຕົ້ນສໍາລັບ ແລະ ຖືກອ່ານຈາກ "ໄລຍະໄກ" ແລະ "ລວມ"
ການຕັ້ງຄ່າສາຂາປະຈຸບັນຕາມທີ່ກຳນົດໄວ້ git-ສາຂາ(1) --ຕິດຕາມ.

ສົມມຸດວ່າມີປະຫວັດສາດຕໍ່ໄປນີ້ແລະສາຂາປະຈຸບັນແມ່ນ "ນາຍ":

A---B---C ຕົ້ນສະບັບກ່ຽວກັບຕົ້ນກໍາເນີດ
/
D---E---F---G ແມ່ບົດ
^
ຕົ້ນກໍາເນີດ / ຕົ້ນສະບັບໃນ repository ຂອງທ່ານ

ຫຼັງຈາກນັ້ນ, "git pull" ຈະດຶງແລະ replay ການປ່ຽນແປງຈາກສາຂາແມ່ແບບຫ່າງໄກສອກຫຼີກນັບຕັ້ງແຕ່ມັນ
diverged ຈາກຕົ້ນສະບັບທ້ອງຖິ່ນ (ie, E) ຈົນກ່ວາຄໍາຫມັ້ນສັນຍາໃນປະຈຸບັນຂອງຕົນ (C) ເທິງຂອງຕົ້ນສະບັບແລະ
ບັນທຶກຜົນໄດ້ຮັບໃນຄໍາຫມັ້ນສັນຍາໃຫມ່ພ້ອມກັບຊື່ຂອງສອງພໍ່ແມ່ຄໍາຫມັ້ນສັນຍາແລະບັນທຶກ
ຂໍ້ຄວາມຈາກຜູ້ໃຊ້ອະທິບາຍການປ່ຽນແປງ.

A---B---C ຕົ້ນກຳເນີດ/ແມ່ບົດ
/
D---E---F---G---H ແມ່ບົດ

ເບິ່ງ git-merge(1) ສໍາລັບລາຍລະອຽດ, ລວມທັງວິທີການຂັດແຍ້ງໄດ້ຖືກນໍາສະເຫນີແລະຈັດການ.

ໃນ Git 1.7.0 ຫຼືຫຼັງຈາກນັ້ນ, ເພື່ອຍົກເລີກການລວມທີ່ຂັດແຍ້ງ, ໃຊ້ git reset --merge. ການ​ເຕືອນ​ໄພ: ໃນ
ຮຸ່ນເກົ່າຂອງ Git, ແລ່ນ ໄປ ດຶງ ກັບການປ່ຽນແປງທີ່ບໍ່ໄດ້ຕັ້ງໃຈແມ່ນທໍ້ຖອຍໃຈ: ໃນຂະນະທີ່
ເປັນໄປໄດ້, ມັນເຮັດໃຫ້ເຈົ້າຢູ່ໃນສະພາບທີ່ອາດຈະຍາກທີ່ຈະກັບຄືນອອກຈາກກໍລະນີ
ການຂັດແຍ້ງ.

ຖ້າການປ່ຽນແປງຫ່າງໄກສອກຫຼີກໃດໆທັບຊ້ອນກັບການປ່ຽນແປງທີ່ບໍ່ສອດຄ່ອງໃນທ້ອງຖິ່ນ, ການລວມຕົວຈະເປັນ
ຍົກເລີກອັດຕະໂນມັດແລະຕົ້ນໄມ້ເຮັດວຽກ untouched. ໂດຍທົ່ວໄປແລ້ວມັນດີທີ່ສຸດທີ່ຈະໄດ້ຮັບທ້ອງຖິ່ນໃດໆ
ການ​ປ່ຽນ​ແປງ​ໃນ​ຄໍາ​ສັ່ງ​ຂອງ​ການ​ເຮັດ​ວຽກ​ກ່ອນ​ທີ່​ຈະ​ດຶງ​ຫຼື​ເກັບ​ໄວ້​ໃຫ້​ເຂົາ​ເຈົ້າ​ອອກ​ຈາກ​ git-stash(1).

OPTIONS

-q, --ງຽບ
ນີ້ແມ່ນສົ່ງຕໍ່ທັງສອງ git-fetch ພື້ນຖານກັບ squelch ລາຍງານໃນລະຫວ່າງການໂອນ,
ແລະພື້ນຖານ git-merge ກັບ squelch ຜົນຜະລິດໃນລະຫວ່າງການລວມເຂົ້າກັນ.

-v, --verbose
ຜ່ານ --verbose ກັບ git-fetch ແລະ git-merge.

--[no-]recurse-submodules[=yes|on-demand|no]
ຕົວເລືອກນີ້ຄວບຄຸມຖ້າ commits ໃຫມ່ຂອງ submodules ທີ່ມີປະຊາກອນທັງຫມົດຄວນໄດ້ຮັບການດຶງມາເຊັ່ນດຽວກັນ
(ເບິ່ງ git-config(1) ແລະ gitmodules(5)). ນັ້ນອາດຈະມີຄວາມຈໍາເປັນເພື່ອໃຫ້ໄດ້ຂໍ້ມູນທີ່ຈໍາເປັນ
ສໍາລັບການລວມຕົວ submodule commits, ຄຸນນະສົມບັດທີ່ Git ໄດ້ຮຽນຮູ້ໃນ 1.7.3. ສັງເກດເຫັນວ່າຜົນໄດ້ຮັບ
ຂອງການລວມກັນຈະບໍ່ຖືກກວດສອບຢູ່ໃນໂມດູນຍ່ອຍ, "git submodule update" ຈະຕ້ອງເປັນ
ຮຽກຮ້ອງໃຫ້ຕໍ່ມາເພື່ອໃຫ້ຕົ້ນໄມ້ການເຮັດວຽກເຖິງວັນທີທີ່ມີຜົນລວມ.

ທາງເລືອກໃນການ ທີ່ກ່ຽວຂ້ອງ to ການໂຮມເຂົ້າກັນ
--commit, --no-commit
ປະຕິບັດ merge ແລະຄໍາຫມັ້ນສັນຍາຜົນໄດ້ຮັບ. ທາງເລືອກນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອ override
--no-commit.

ດ້ວຍ --no-commit ປະຕິບັດການລວມກັນ ແຕ່ສົມມຸດວ່າການລວມລົ້ມເຫລວ ແລະຢ່າເຮັດອັດຕະໂນມັດ,
ເພື່ອໃຫ້ຜູ້ໃຊ້ໂອກາດໃນການກວດສອບແລະປັບປ່ຽນຜົນການລວມກັນຕື່ມອີກກ່ອນ
ຄໍາຫມັ້ນສັນຍາ.

--edit, -e, --no-edit
ຮຽກ​ຮ້ອງ​ບັນ​ນາ​ທິ​ການ​ກ່ອນ​ທີ່​ຈະ​ປະ​ຕິ​ບັດ​ການ​ຜະ​ສົມ​ກົນ​ຈັກ​ສົບ​ຜົນ​ສໍາ​ເລັດ​ເພື່ອ​ແກ້​ໄຂ​ຕື່ມ​ອີກ​
ຂໍ້​ຄວາມ​ທີ່​ສ້າງ​ອັດ​ຕະ​ໂນ​ມັດ​ການ​ລວມ​ເຂົ້າ​ກັນ​, ດັ່ງ​ນັ້ນ​ຜູ້​ໃຊ້​ສາ​ມາດ​ອະ​ທິ​ບາຍ​ແລະ justify ການ​ລວມ​. ໄດ້
--no-edit option ສາມາດໃຊ້ເພື່ອຮັບເອົາຂໍ້ຄວາມທີ່ສ້າງຂຶ້ນໂດຍອັດຕະໂນມັດ (ໂດຍທົ່ວໄປແລ້ວ
ທໍ້).

ສະຄຣິບເກົ່າອາດຈະຂຶ້ນກັບພຶດຕິກໍາປະຫວັດສາດທີ່ບໍ່ອະນຸຍາດໃຫ້ຜູ້ໃຊ້ແກ້ໄຂ
ຂໍ້ຄວາມບັນທຶກການລວມ. ພວກເຂົາຈະເຫັນບັນນາທິການເປີດຂຶ້ນເມື່ອພວກເຂົາແລ່ນ git merge. ເພື່ອເຮັດໃຫ້
ມັນງ່າຍຕໍ່ການປັບຕົວສະຄິບດັ່ງກ່າວໃຫ້ກັບພຶດຕິກໍາທີ່ປັບປຸງ, ການປ່ຽນແປງສະພາບແວດລ້ອມ
GIT_MERGE_AUTOEDIT ສາມາດຖືກຕັ້ງເປັນບໍ່ຢູ່ໃນຕອນຕົ້ນຂອງມັນ.

--ff
ໃນ​ເວ​ລາ​ທີ່​ການ​ລວມ​ເຂົ້າ​ກັນ​ໄດ້​ຮັບ​ການ​ແກ້​ໄຂ​ເປັນ​ໄປ​ຫນ້າ​ໄວ​, ພຽງ​ແຕ່​ປັບ​ປຸງ​ຕົວ​ຊີ້​ສາ​ຂາ​, ໂດຍ​ບໍ່​ມີ​ການ​
ສ້າງ​ຄໍາ​ຫມັ້ນ​ສັນ​ຍາ​ການ​ລວມ​. ນີ້ແມ່ນພຶດຕິກໍາເລີ່ມຕົ້ນ.

--no-ff
ສ້າງຄໍາຫມັ້ນສັນຍາລວມເຖິງແມ່ນວ່າໃນເວລາທີ່ການຜະສົມຜະສານແກ້ໄຂບັນຫາເປັນການໄປຂ້າງຫນ້າໄວ. ນີ້​ແມ່ນ
ພຶດຕິກຳເລີ່ມຕົ້ນເມື່ອຮວມປ້າຍປະກອບຄຳບັນຍາຍ (ແລະອາດຈະຖືກເຊັນ).

--ff-ເທົ່ານັ້ນ
ປະຕິເສດທີ່ຈະລວມເຂົ້າກັນ ແລະອອກດ້ວຍສະຖານະທີ່ບໍ່ແມ່ນສູນ ເວັ້ນເສຍແຕ່ວ່າ HEAD ປະຈຸບັນຢູ່ແລ້ວ
up-to-date ຫຼືການລວມຕົວສາມາດແກ້ໄຂໄດ້ໄວ.

--log[= ], --no-log
ນອກເໜືອໄປຈາກຊື່ສາຂາ, ຕື່ມຂໍ້ມູນບັນທຶກດ້ວຍຄຳອະທິບາຍແຖວໜຶ່ງຈາກ
ຫຼາຍທີ່ສຸດ ຄໍາຫມັ້ນສັນຍາຕົວຈິງທີ່ກໍາລັງຖືກລວມເຂົ້າກັນ. ເບິ່ງນຳ git-fmt-merge-msg(1).

ດ້ວຍ --no-log ບໍ່ເຮັດລາຍການຄໍາອະທິບາຍແຖວດຽວຈາກຄໍາຫມັ້ນສັນຍາຕົວຈິງທີ່ຖືກລວມເຂົ້າກັນ.

--stat, -n, --no-stat
ສະແດງ diffstat ໃນຕອນທ້າຍຂອງການລວມ. Diffstat ຍັງຖືກຄວບຄຸມໂດຍ
ຕົວເລືອກການຕັ້ງຄ່າ merge.stat.

ດ້ວຍ -n ຫຼື --no-stat ບໍ່ສະແດງ diffstat ໃນຕອນທ້າຍຂອງການລວມ.

--squash, --no-squash
ຜະລິດຕົ້ນໄມ້ທີ່ເຮັດວຽກແລະສະພາບດັດສະນີຄືກັບວ່າການລວມຕົວທີ່ແທ້ຈິງເກີດຂຶ້ນ (ຍົກເວັ້ນ
merge ຂໍ້​ມູນ​)​, ແຕ່​ຕົວ​ຈິງ​ແລ້ວ​ບໍ່​ໄດ້​ເຮັດ​ໃຫ້​ຄໍາ​ຫມັ້ນ​ສັນ​ຍາ​, ຍ້າຍ HEAD​, ຫຼື​ບັນ​ທຶກ​
$GIT_DIR/MERGE_HEAD (ເພື່ອເຮັດໃຫ້ຄໍາສັ່ງ git commit ຕໍ່ໄປເພື່ອສ້າງ merge commit).
ນີ້ອະນຸຍາດໃຫ້ທ່ານສ້າງຄໍາຫມັ້ນສັນຍາດຽວຢູ່ເທິງສຸດຂອງສາຂາໃນປະຈຸບັນທີ່ມີຜົນກະທົບ
ຄືກັນກັບການລວມສາຂາອື່ນ (ຫຼືຫຼາຍກວ່ານັ້ນໃນກໍລະນີຂອງ octopus).

ດ້ວຍ --no-squash ປະຕິບັດການລວມແລະຄໍາຫມັ້ນສັນຍາຜົນໄດ້ຮັບ. ທາງເລືອກນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອ
override --squash.

-s , --ຍຸດທະສາດ=
ນໍາໃຊ້ຍຸດທະສາດການລວມເອົາ; ສາມາດໄດ້ຮັບການສະຫນອງຫຼາຍກ່ວາຫນຶ່ງຄັ້ງເພື່ອກໍານົດໃຫ້ເຂົາເຈົ້າຢູ່ໃນ
ສັ່ງ​ໃຫ້​ເຂົາ​ເຈົ້າ​ໄດ້​ຮັບ​ການ​ພະ​ຍາ​ຍາມ​. ຖ້າບໍ່ມີທາງເລືອກ -s, ບັນຊີລາຍຊື່ຍຸດທະສາດທີ່ສ້າງຂຶ້ນ
ໃຊ້ແທນ (ໄປ merge-recursive ເມື່ອລວມຫົວດຽວ, ໄປ merge-octopus
ຖ້າບໍ່ດັ່ງນັ້ນ).

-X , --strategy-option=
ຜ່ານຍຸດທະສາດການລວມເອົາທາງເລືອກສະເພາະໄປສູ່ຍຸດທະສາດການລວມ.

--verify-signatures, --no-verify-signatures
ກວດ​ສອບ​ວ່າ​ຄໍາ​ຫມັ້ນ​ສັນ​ຍາ​ທີ່​ຖືກ​ລວມ​ມີ​ລາຍ​ເຊັນ GPG ທີ່​ດີ​ແລະ​ເຊື່ອ​ຖື​ໄດ້​ແລະ​ການ​ເອົາ​ລູກ​ອອກ​
merge ໃນ​ກໍ​ລະ​ນີ​ທີ່​ເຂົາ​ເຈົ້າ​ບໍ່​ໄດ້​.

--summary, --no-summary
ຄໍາສັບຄ້າຍຄື --stat ແລະ --no-stat; ສິ່ງເຫຼົ່ານີ້ຖືກປະຕິເສດ ແລະຈະຖືກລຶບອອກໃນ
ໃນອະນາຄົດ.

-r, --rebase[=false|true|ຮັກສາ]
ເມື່ອເປັນຈິງ, ນຳໃຊ້ສາຂາປະຈຸບັນຄືນໃໝ່ຢູ່ເທິງສຸດຂອງສາຂາຕົ້ນນ້ຳຫຼັງຈາກດຶງເອົາ. ຖ້າ
ມີສາຂາຕິດຕາມໄລຍະໄກທີ່ສອດຄ້ອງກັບສາຂາຕົ້ນນໍ້າ ແລະສາຂາ
ສາຂາຕົ້ນນ້ໍາໄດ້ຖືກອີງໃສ່ຄືນໃຫມ່ນັບຕັ້ງແຕ່ການດຶງເອົາຄັ້ງສຸດທ້າຍ, rebase ໃຊ້ຂໍ້ມູນນັ້ນເພື່ອ
ຫຼີກ​ລ້ຽງ​ການ​ປ່ຽນ​ແປງ​ທີ່​ບໍ່​ແມ່ນ​ທ້ອງ​ຖິ່ນ​.

ເມື່ອຕັ້ງເພື່ອເກັບຮັກສາ, rebase ດ້ວຍຕົວເລືອກ --preserve-merges ຜ່ານໄປ git rebase ດັ່ງນັ້ນ
ສັນຍາລວມທີ່ສ້າງຂຶ້ນໃນທ້ອງຖິ່ນຈະບໍ່ຖືກແປລົງ.

ເມື່ອເປັນຜິດ, ຮວມສາຂາປັດຈຸບັນເຂົ້າໄປໃນສາຂາຕົ້ນນ້ຳ.

ເບິ່ງ pull.rebase, ສາຂາ. .rebase ແລະ branch.autoSetupRebase ໃນ git-config(1) ຖ້າ
ທ່ານຕ້ອງການເຮັດໃຫ້ git pull ສະເຫມີໃຊ້ --rebase ແທນການລວມເຂົ້າກັນ.

ຫມາຍ​ເຫດ​
ນີ້ແມ່ນທ່າແຮງ ເປັນອັນຕະລາຍ ຮູບ​ແບບ​ການ​ດໍາ​ເນີນ​ງານ​. ມັນ rewrites ປະຫວັດສາດ, ເຊິ່ງ
ບໍ່ດີເມື່ອທ່ານເຜີຍແຜ່ປະຫວັດສາດນັ້ນແລ້ວ. ເຮັດ ບໍ່ ໃຊ້ທາງເລືອກນີ້
ເວັ້ນເສຍແຕ່ວ່າທ່ານໄດ້ອ່ານ git-rebase(1) ລະມັດລະວັງ.

--no-rebase
ລົບລ້າງກ່ອນໜ້ານີ້ --rebase.

ທາງເລືອກໃນການ ທີ່ກ່ຽວຂ້ອງ to ການດຶງຂໍ້ມູນ
--ທັງໝົດ
ເອົາຣີໂມດທັງໝົດ.

-a, --append
ຕື່ມໃສ່ຊື່ອ້າງອີງ ແລະຊື່ວັດຖຸຂອງການອ້າງອີງທີ່ດຶງມາກັບເນື້ອຫາທີ່ມີຢູ່ແລ້ວຂອງ
.git/FETCH_HEAD. ຖ້າບໍ່ມີທາງເລືອກນີ້ ຂໍ້ມູນເກົ່າໃນ .git/FETCH_HEAD ຈະຖືກຂຽນທັບ.

--ຄວາມ​ເລິກ=
ຈໍາ​ກັດ​ການ​ດຶງ​ເອົາ​ຈໍາ​ນວນ​ທີ່​ກໍາ​ນົດ​ໄວ້​ຂອງ commits ຈາກ​ປາຍ​ຂອງ​ແຕ່​ລະ​ສາ​ຂາ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​
ປະຫວັດສາດ. ຖ້າດຶງໄປຫາ ກ ຕື້ນ repository ສ້າງໂດຍ git clone ກັບ --depth=
ທາງເລືອກ (ເບິ່ງ git-clone(1​)​) ເລິກ​ຫຼື​ຫຍໍ້​ປະ​ຫວັດ​ສາດ​ກັບ​ຈໍາ​ນວນ​ທີ່​ກໍາ​ນົດ​ໄວ້​ຂອງ​
ຄໍາຫມັ້ນສັນຍາ. Tags ສໍາລັບຄໍາຫມັ້ນສັນຍາທີ່ເລິກເຊິ່ງບໍ່ໄດ້ຖືກດຶງມາ.

--ບໍ່ຕື້ນ
ຖ້າບ່ອນເກັບມ້ຽນແຫຼ່ງທີ່ສົມບູນ, ປ່ຽນບ່ອນເກັບຂໍ້ມູນຕື້ນໃຫ້ເປັນທີ່ສົມບູນ,
ລົບ​ຂໍ້​ຈໍາ​ກັດ​ທັງ​ຫມົດ​ທີ່​ກໍາ​ນົດ​ໄວ້​ໂດຍ​ການ​ເກັບ​ກໍາ​ຕື້ນ​.

ຖ້າບ່ອນເກັບມ້ຽນແຫຼ່ງແມ່ນຕື້ນ, ເອົາຫຼາຍເທົ່າທີ່ເປັນໄປໄດ້ເພື່ອໃຫ້ກະແສໄຟຟ້າ
repository ມີປະຫວັດດຽວກັນກັບ repository ແຫຼ່ງ.

--update-ຕື້ນ
ໂດຍຄ່າເລີ່ມຕົ້ນເມື່ອດຶງຂໍ້ມູນຈາກບ່ອນເກັບຂໍ້ມູນຕື້ນ, git fetch ປະຕິເສດການອ້າງອີງນັ້ນ
ຮຽກຮ້ອງໃຫ້ມີການປັບປຸງ .git/shallow. ຕົວເລືອກນີ້ປັບປຸງ .git/shallow ແລະຍອມຮັບການອ້າງອີງດັ່ງກ່າວ.

-f, --force
ເມື່ອ​ໃດ​ ໄປ ດຶງ ຖືກນໍາໃຊ້ກັບ : refspec, ມັນປະຕິເສດທີ່ຈະປັບປຸງ
ສາຂາທ້ອງຖິ່ນ ເວັ້ນເສຍແຕ່ວ່າສາຂາຫ່າງໄກສອກຫຼີກ ມັນ fetches ເປັນລູກຫລານ
ຂອງ . ຕົວເລືອກນີ້ລົບລ້າງການກວດສອບນັ້ນ.

-k, --keep
ຮັກສາຊຸດທີ່ດາວໂຫຼດໄວ້.

--no-tags
ໂດຍຄ່າເລີ່ມຕົ້ນ, ແທັກທີ່ຊີ້ໃສ່ວັດຖຸທີ່ຖືກດາວໂຫຼດຈາກບ່ອນເກັບມ້ຽນທາງໄກ
ຖືກ​ດຶງ​ດູດ​ແລະ​ເກັບ​ຮັກ​ສາ​ໄວ້​ໃນ​ທ້ອງ​ຖິ່ນ​. ຕົວເລືອກນີ້ປິດການໃຊ້ງານແທັກອັດຕະໂນມັດຕໍ່ໄປນີ້. ໄດ້
ພຶດຕິກຳເລີ່ມຕົ້ນສຳລັບຣີໂໝດອາດຈະຖືກລະບຸດ້ວຍຣີໂໝດ. ການຕັ້ງຄ່າ .tagOpt.
ເບິ່ງ git-config(1).

-u, --update-head-ok
ໂດຍຄ່າເລີ່ມຕົ້ນ ໄປ ດຶງ ປະຕິເສດການປັບປຸງຫົວທີ່ກົງກັບປະຈຸບັນ
ສາຂາ. ທຸງນີ້ປິດການກວດສອບ. ນີ້ແມ່ນຢ່າງດຽວສໍາລັບການນໍາໃຊ້ພາຍໃນສໍາລັບ ໄປ ດຶງ
ຕິດຕໍ່ສື່ສານກັບ ໄປ ດຶງ, ແລະເວັ້ນເສຍແຕ່ວ່າທ່ານກໍາລັງປະຕິບັດ Porcelain ຂອງທ່ານເອງ
ບໍ່ຄວນໃຊ້ມັນ.

--upload-pack
ເມື່ອຖືກມອບໃຫ້, ແລະບ່ອນເກັບມ້ຽນທີ່ຈະເອົາມາຈາກແມ່ນຈັດການໂດຍ ໄປ fetch-pack,
--exec= ຖືກສົ່ງໄປຫາຄໍາສັ່ງເພື່ອກໍານົດເສັ້ນທາງທີ່ບໍ່ແມ່ນຄ່າເລີ່ມຕົ້ນສໍາລັບ
ຄໍາສັ່ງດໍາເນີນການໃນທ້າຍອື່ນໆ.

- ແມ່ຍິງ
ສະຖານະຄວາມຄືບໜ້າຖືກລາຍງານຢູ່ໃນສະຕຣີມຄວາມຜິດພາດມາດຕະຖານຕາມຄ່າເລີ່ມຕົ້ນເມື່ອມັນຢູ່
ຕິດກັບ terminal, ເວັ້ນເສຍແຕ່ -q ຖືກກໍານົດ. ທຸງນີ້ບັງຄັບສະຖານະຄວາມຄືບຫນ້າເຖິງແມ່ນວ່າ
ຖ້າ​ຫາກ​ວ່າ​ການ​ສະ​ຕ​ຣີມ​ຄວາມ​ຜິດ​ພາດ​ມາດ​ຕະ​ຖານ​ແມ່ນ​ບໍ່​ໄດ້​ຖືກ​ນໍາ​ໄປ​ຫາ​ສະ​ຖານ​ທີ່​.


ບ່ອນເກັບມ້ຽນ "ໄລຍະໄກ" ທີ່ເປັນແຫຼ່ງຂອງການດຶງຂໍ້ມູນຫຼືການດຶງ. ນີ້
ພາລາມິເຕີສາມາດເປັນ URL (ເບິ່ງພາກ GIT URLS ຂ້າງລຸ່ມນີ້) ຫຼືຊື່ຂອງຫ່າງໄກສອກຫຼີກ
(ເບິ່ງພາກ REMOTES ຂ້າງລຸ່ມນີ້).


ລະບຸການອ້າງອີງທີ່ຈະດຶງຂໍ້ມູນ ແລະອ້າງອີງທ້ອງຖິ່ນໃດທີ່ຈະອັບເດດ. ເມື່ອບໍ່ມີ s
ປາກົດຢູ່ໃນເສັ້ນຄໍາສັ່ງ, refs ກັບ fetch ແມ່ນອ່ານຈາກໄລຍະໄກ. .ດຶງຂໍ້ມູນ
ຕົວແປແທນ (ເບິ່ງ git-fetch(1)).

ຮູບແບບຂອງ ກ ພາລາມິເຕີເປັນທາງເລືອກບວກ +, ຕາມດ້ວຍແຫຼ່ງອ້າງອີງ
, ຕາມດ້ວຍຈໍ້າສອງເມັດ :, ຕາມດ້ວຍຈຸດຫມາຍປາຍທາງ ref . ຈໍ້າສອງເມັດສາມາດເປັນ
ຖືກລະເວັ້ນເມື່ອ ຫວ່າງເປົ່າ.

ແທັກ ຫມາຍຄວາມວ່າຄືກັນກັບ refs/tags/ :refs/tags/ ; ມັນຮ້ອງຂໍເອົາ
ທຸກຢ່າງຂຶ້ນກັບແທັກທີ່ໃຫ້.

ການອ້າງອີງທາງໄກທີ່ກົງກັນ ຖືກດຶງມາ, ແລະຖ້າ ບໍ່ແມ່ນສະຕຣິງຫວ່າງເປົ່າ, ໄດ້
ອ້າງອີງໃນທ້ອງຖິ່ນທີ່ກົງກັບມັນໄດ້ຖືກສົ່ງຕໍ່ຢ່າງໄວວາໂດຍໃຊ້ . ຖ້າທາງເລືອກບວກ + ແມ່ນ
ຖືກນໍາໃຊ້, ການອ້າງອີງທ້ອງຖິ່ນຈະຖືກປັບປຸງເຖິງແມ່ນວ່າມັນບໍ່ມີຜົນໃນການປັບປຸງຢ່າງໄວວາ.

ຫມາຍ​ເຫດ​
ເມື່ອສາຂາຫ່າງໄກສອກຫຼີກທີ່ເຈົ້າຕ້ອງການດຶງມາແມ່ນເປັນທີ່ຮູ້ຈັກກັນວ່າຖືກເຮັດໃໝ່ ແລະ ອີງໃສ່ຄືນໃໝ່
ເປັນປົກກະຕິ, ຄາດວ່າປາຍໃຫມ່ຂອງມັນຈະບໍ່ມີລູກຫລານຂອງມັນກ່ອນຫນ້ານີ້
tip (ດັ່ງ​ທີ່​ເກັບ​ໄວ້​ໃນ​ສາ​ຂາ​ການ​ຕິດ​ຕາມ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​ຂອງ​ທ່ານ​ໃນ​ຄັ້ງ​ສຸດ​ທ້າຍ​ທີ່​ທ່ານ​ໄດ້​ດຶງ​ຂໍ້​ມູນ​)​. ເຈົ້າ
ຕ້ອງການໃຊ້ເຄື່ອງໝາຍ + ເພື່ອຊີ້ບອກເຖິງການອັບເດດທີ່ບໍ່ໄວຕໍ່ຫນ້າ
ສໍາລັບສາຂາດັ່ງກ່າວ. ບໍ່ມີທາງທີ່ຈະກໍານົດຫຼືປະກາດວ່າສາຂາຈະເປັນ
ມີຢູ່ໃນບ່ອນເກັບມ້ຽນທີ່ມີພຶດຕິກໍານີ້; ຜູ້ໃຊ້ດຶງພຽງແຕ່ຕ້ອງ
ຮູ້ວ່ານີ້ແມ່ນຮູບແບບການນໍາໃຊ້ທີ່ຄາດໄວ້ສໍາລັບສາຂາ.

ຫມາຍ​ເຫດ​
ມີຄວາມແຕກຕ່າງກັນລະຫວ່າງລາຍຊື່ຫຼາຍ ໂດຍກົງ ໄປ ດຶງ
ເສັ້ນຄໍາສັ່ງແລະມີໄລຍະໄກຫຼາຍ. .fetch entries ຢູ່ໃນຂອງທ່ານ
ການ​ຕັ້ງ​ຄ່າ​ສໍາ​ລັບ​ການ a ແລະແລ່ນ a ໄປ ດຶງ ຄໍາສັ່ງໂດຍບໍ່ມີການໃດໆ
ຈະແຈ້ງ ຕົວກໍານົດການ. s ໄດ້ລະບຸໄວ້ຢ່າງຊັດເຈນຢູ່ໃນເສັ້ນຄໍາສັ່ງ
ຖືກລວມເຂົ້າກັບສາຂາປະຈຸບັນຢູ່ສະເໝີຫຼັງຈາກການດຶງຂໍ້ມູນ. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ຖ້າທ່ານ
ລາຍຊື່ຫຼາຍກວ່າໜຶ່ງການອ້າງອີງທາງໄກ, ໄປ ດຶງ ຈະສ້າງການລວມ Octopus. ອີກດ້ານນຶ່ງ
ມື, ຖ້າເຈົ້າບໍ່ບອກຢ່າງຈະແຈ້ງ ພາລາມິເຕີໃນເສັ້ນຄໍາສັ່ງ, ໄປ
ດຶງ ຈະ​ດຶງ​ເອົາ​ທັງ​ຫມົດ​ ມັນພົບເຫັນຢູ່ໃນຫ່າງໄກສອກຫຼີກ. .ດຶງຂໍ້ມູນ
configuration ແລະ merge ພຽງແຕ່ທໍາອິດ ພົບເຫັນຢູ່ໃນສາຂາປະຈຸບັນ.
ນີ້ແມ່ນຍ້ອນວ່າການເຮັດ Octopus ຈາກ refs ຫ່າງໄກສອກຫຼີກແມ່ນບໍ່ຄ່ອຍເຮັດ, ໃນຂະນະທີ່ຮັກສາ
ການ​ຕິດ​ຕາມ​ຂອງ​ຫຼາຍ​ຫົວ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​ໃນ​ການ​ໄປ​ດຽວ​ໂດຍ​ການ​ດຶງ​ເອົາ​ຫຼາຍ​ກວ່າ​ຫນຶ່ງ​ແມ່ນ​ມັກ​ຈະ​
ເປັນປະໂຫຍດ.

GIT urls

ໂດຍທົ່ວໄປ, URLs ມີຂໍ້ມູນກ່ຽວກັບໂປໂຕຄອນການຂົນສົ່ງ, ທີ່ຢູ່ຂອງ
ເຊີບເວີທາງໄກ, ແລະເສັ້ນທາງໄປຫາບ່ອນເກັບມ້ຽນ. ຂຶ້ນຢູ່ກັບອະນຸສັນຍາການຂົນສົ່ງ, ບາງ
ຂໍ້ມູນນີ້ອາດຈະບໍ່ມີ.

Git ສະຫນັບສະຫນູນ ssh, git, http, ແລະ https protocols (ນອກຈາກນັ້ນ, ftp, ແລະ ftps ສາມາດນໍາໃຊ້ໄດ້.
ສໍາລັບ fetching ແລະ rsync ສາມາດຖືກນໍາໃຊ້ສໍາລັບການດຶງແລະການຊຸກຍູ້, ແຕ່ເຫຼົ່ານີ້ແມ່ນບໍ່ມີປະສິດທິພາບແລະ
ເຊົາສະໜັບສະໜູນ; ຢ່າໃຊ້ພວກມັນ).

ການຂົນສົ່ງພື້ນເມືອງ (ເຊັ່ນ: git: // URL) ບໍ່ມີການພິສູດຢືນຢັນແລະຄວນຈະຖືກນໍາໃຊ້ກັບ
ລະມັດລະວັງກ່ຽວກັບເຄືອຂ່າຍທີ່ບໍ່ປອດໄພ.

syntax ຕໍ່ໄປນີ້ອາດຈະຖືກໃຊ້ກັບພວກມັນ:

· ssh://[user@]host.xz[:port]/path/to/repo.git/

· git://host.xz[:port]/path/to/repo.git/

· http[s]://host.xz[:port]/path/to/repo.git/

· ftp[s]://host.xz[:port]/path/to/repo.git/

· rsync://host.xz/path/to/repo.git/

syntax ຄ້າຍຄື scp ທາງເລືອກອາດຈະຖືກນໍາໃຊ້ກັບໂປໂຕຄອນ ssh:

· [user@]host.xz:path/to/repo.git/

syntax ນີ້ຖືກຮັບຮູ້ພຽງແຕ່ຖ້າບໍ່ມີຕົວຫຍໍ້ກ່ອນຈໍ້າສອງເມັດທໍາອິດ. ນີ້ຊ່ວຍ
ແຍກເສັ້ນທາງທ້ອງຖິ່ນທີ່ປະກອບດ້ວຍຈໍ້າສອງເມັດ. ຕົວຢ່າງເສັ້ນທາງທ້ອງຖິ່ນ foo:bar ສາມາດ
ຖືກລະບຸເປັນເສັ້ນທາງຢ່າງແທ້ຈິງ ຫຼື ./foo:bar ເພື່ອຫຼີກເວັ້ນການຖືກຕີຄວາມຜິດເປັນ ssh url.

ໂປໂຕຄອນ ssh ແລະ git ຍັງສະຫນັບສະຫນູນ ~ ການຂະຫຍາຍຊື່ຜູ້ໃຊ້:

· ssh://[user@]host.xz[:port]/~[user]/path/to/repo.git/

· git://host.xz[:port]/~[user]/path/to/repo.git/

· [user@]host.xz:/~[user]/path/to/repo.git/

ສໍາລັບ repositories ທ້ອງຖິ່ນ, ຍັງສະຫນັບສະຫນູນໂດຍ Git natively, syntax ດັ່ງຕໍ່ໄປນີ້ອາດຈະເປັນ
ໃຊ້:

· /path/to/repo.git/

· file:///path/to/repo.git/

ສອງ syntax ເຫຼົ່ານີ້ສ່ວນຫຼາຍແມ່ນທຽບເທົ່າ, ຍົກເວັ້ນໃນເວລາທີ່ cloning, ເມື່ອອະດີດຫມາຍເຖິງ
-- ທາງ​ເລືອກ​ໃນ​ທ້ອງ​ຖິ່ນ​. ເບິ່ງ git-clone(1) ສໍາລັບລາຍລະອຽດ.

ເມື່ອ Git ບໍ່ຮູ້ວິທີການຈັດການກັບໂປໂຕຄອນການຂົນສົ່ງທີ່ແນ່ນອນ, ມັນພະຍາຍາມໃຊ້
ຫ່າງ​ໄກ​ສອກ​ຫຼີກ- ຜູ້ຊ່ວຍຫ່າງໄກສອກຫຼີກ, ຖ້າມີຢູ່. ເພື່ອຮ້ອງຂໍໃຫ້ຜູ້ຊ່ວຍຫ່າງໄກສອກຫຼີກຢ່າງຊັດເຈນ,
syntax ຕໍ່ໄປນີ້ອາດຈະຖືກນໍາໃຊ້:

· ::

ຢູ່ໃສ ອາດຈະເປັນເສັ້ນທາງ, ເຊີບເວີແລະເສັ້ນທາງ, ຫຼືສະຕຣິງທີ່ຄ້າຍຄືກັບ URL ທີ່ມັກ
ຮັບຮູ້ໂດຍຜູ້ຊ່ວຍຫ່າງໄກສອກຫຼີກສະເພາະທີ່ຖືກຮຽກຮ້ອງ. ເບິ່ງ gitremote-helpers(1) ສໍາລັບ
ລາຍລະອຽດ.

ຖ້າມີຈໍານວນຫລາຍຂອງ repositories ຫ່າງໄກສອກຫຼີກທີ່ມີຊື່ຄ້າຍຄືກັນແລະທ່ານຕ້ອງການໃຊ້ a
ຮູບແບບທີ່ແຕກຕ່າງກັນສໍາລັບພວກເຂົາ (ເຊັ່ນວ່າ URL ທີ່ເຈົ້າໃຊ້ຈະຖືກຂຽນຄືນໃຫມ່ໃນ URLs ທີ່
ເຮັດວຽກ), ທ່ານສາມາດສ້າງພາກສ່ວນການຕັ້ງຄ່າຂອງແບບຟອມ:

[url " "]
ແທນທີ່ =

ສໍາລັບຕົວຢ່າງ, ດ້ວຍນີ້:

[url "git://git.host.xz/"]
ແທນທີ່ = host.xz:/path/to/
ແທນທີ່ = ວຽກ:

URL ເຊັ່ນ "work:repo.git" ຫຼືເຊັ່ນ "host.xz:/path/to/repo.git" ຈະຖືກຂຽນຄືນໃນອັນໃດນຶ່ງ.
ສະພາບການທີ່ເອົາ URL ເປັນ "git://git.host.xz/repo.git".

ຖ້າທ່ານຕ້ອງການຂຽນຄືນ URLs ສໍາລັບການຊຸກຍູ້ເທົ່ານັ້ນ, ທ່ານສາມາດສ້າງສ່ວນການຕັ້ງຄ່າຂອງ
ແບບຟອມ:

[url " "]
pushInsteadOf =

ສໍາລັບຕົວຢ່າງ, ດ້ວຍນີ້:

[url "ssh://example.org/"]
pushInsteadOf = git://example.org/

URL ເຊັ່ນ "git://example.org/path/to/repo.git" ຈະຖືກຂຽນຄືນໃສ່.
"ssh://example.org/path/to/repo.git" ສໍາລັບການ pushes, ແຕ່ pulls ຈະຍັງໃຊ້ຕົ້ນສະບັບ.
Url.

ສິ່ງທີ່ຄວນຮູ້

ຊື່ຂອງຫນຶ່ງໃນຕໍ່ໄປນີ້ສາມາດຖືກນໍາໃຊ້ແທນ URL ເປັນ ການໂຕ້ຖຽງ:

· ຣີໂໝດຢູ່ໃນໄຟລ໌ການຕັ້ງຄ່າ Git: $GIT_DIR/config,

· ໄຟລ໌ໃນບັນຊີ $GIT_DIR/ໄລຍະໄກ, ຫຼື

· ໄຟລ໌ໃນບັນຊີ $GIT_DIR/ສາຂາ.

ທັງຫມົດເຫຼົ່ານີ້ຍັງອະນຸຍາດໃຫ້ທ່ານເພື່ອຍົກເວັ້ນ refspec ຈາກເສັ້ນຄໍາສັ່ງເນື່ອງຈາກວ່າພວກເຂົາເຈົ້າແຕ່ລະຄົນ
ມີ refspec ທີ່ git ຈະໃຊ້ໂດຍຄ່າເລີ່ມຕົ້ນ.

ຊື່ ໄລຍະໄກ in configuration ເອກະສານ
ທ່ານ​ສາ​ມາດ​ເລືອກ​ທີ່​ຈະ​ສະ​ຫນອງ​ຊື່​ຂອງ​ທາງ​ໄກ​ທີ່​ທ່ານ​ໄດ້​ກໍາ​ນົດ​ຄ່າ​ໃນ​ເມື່ອ​ກ່ອນ​ການ​ນໍາ​ໃຊ້​
git-remote(1) git-config(1) ຫຼື​ແມ້​ກະ​ທັ້ງ​ໂດຍ​ການ​ແກ້​ໄຂ​ຄູ່​ມື​ກັບ​ໄຟລ​໌ $GIT_DIR/config. URL
ຣີໂໝດນີ້ຈະຖືກໃຊ້ເພື່ອເຂົ້າເຖິງບ່ອນເກັບມ້ຽນ. Refspec ຂອງຣີໂມດນີ້ຈະເປັນ
ຖືກໃຊ້ໂດຍຄ່າເລີ່ມຕົ້ນເມື່ອທ່ານບໍ່ໃຫ້ refspec ໃນແຖວຄໍາສັ່ງ. ການ​ເຂົ້າ​ມາ​ໃນ​
config ໄຟລ໌ຈະປາກົດແບບນີ້:

[ທາງ​ໄກ​" "]
url =
pushurl =
ຍູ້ =
fetch =

ໄດ້ ຖືກນໍາໃຊ້ສໍາລັບການຊຸກຍູ້ເທົ່ານັ້ນ. ມັນເປັນທາງເລືອກແລະຄ່າເລີ່ມຕົ້ນທີ່ຈະ .

ຊື່ ເອກະສານ in $GIT_DIR/ໄລຍະໄກ
ທ່ານສາມາດເລືອກໃຫ້ຊື່ຂອງໄຟລ໌ໃນ $GIT_DIR/ໄລຍະໄກ. URL ໃນໄຟລ໌ນີ້
ຈະຖືກນໍາໃຊ້ເພື່ອເຂົ້າເຖິງ repository. refspec ໃນໄຟລ໌ນີ້ຈະຖືກໃຊ້ເປັນຄ່າເລີ່ມຕົ້ນ
ໃນເວລາທີ່ທ່ານບໍ່ໃຫ້ refspec ໃນເສັ້ນຄໍາສັ່ງ. ໄຟລ໌ນີ້ຄວນຈະມີດັ່ງຕໍ່ໄປນີ້
ຮູບແບບ:

URL: ຫນຶ່ງໃນຮູບແບບ URL ຂ້າງເທິງ
ຍູ້:
ດຶງ:

Push: ສາຍຖືກນໍາໃຊ້ໂດຍ ໄປ ການຊຸກຍູ້ ແລະດຶງ: ເສັ້ນຖືກນໍາໃຊ້ໂດຍ ໄປ ດຶງ ແລະ ໄປ ດຶງ.
Multiple Push: ແລະ Pull: ສາຍອາດຈະຖືກລະບຸໄວ້ສໍາລັບການສ້າງແຜນທີ່ສາຂາເພີ່ມເຕີມ.

ຊື່ ເອກະສານ in $GIT_DIR/ສາຂາ
ທ່ານສາມາດເລືອກໃຫ້ຊື່ໄຟລ໌ໃນ $GIT_DIR/ສາຂາ. URL ໃນໄຟລ໌ນີ້
ຈະຖືກນໍາໃຊ້ເພື່ອເຂົ້າເຖິງ repository. ໄຟລ໌ນີ້ຄວນຈະມີຮູບແບບດັ່ງຕໍ່ໄປນີ້:

#

ຈໍາ​ເປັນ; # ເປັນທາງເລືອກ.

ອີງຕາມການດໍາເນີນງານ, git ຈະໃຊ້ຫນຶ່ງໃນ refspec ຕໍ່ໄປນີ້, ຖ້າທ່ານບໍ່ເຮັດ
ສະໜອງອັນໜຶ່ງໃນແຖວຄຳສັ່ງ. ແມ່ນຊື່ຂອງໄຟລ໌ນີ້ໃນ $GIT_DIR/ສາຂາ
ແລະ ເລີ່ມຕົ້ນເປັນຕົ້ນສະບັບ.

git fetch ໃຊ້:

ອ້າງອີງ/ຫົວ/ :refs/heads/

git push ໃຊ້:

HEAD:refs/heads/

ລວມ ໂຄງຮ່າງ

ກົນໄກການລວມ (git merge ແລະ git pull commands) ອະນຸຍາດໃຫ້ backend ລວມ ແຜນຍຸດທະສາດ
ຈະຖືກເລືອກດ້ວຍທາງເລືອກ -s. ບາງຍຸດທະສາດຍັງສາມາດເອົາທາງເລືອກຂອງຕົນເອງ, ຊຶ່ງສາມາດເປັນ
ຜ່ານໂດຍການໃຫ້ -X arguments ເພື່ອ git merge ແລະ / ຫຼື git ດຶງ.

ແກ້ໄຂ
ນີ້ສາມາດແກ້ໄຂພຽງແຕ່ສອງຫົວ (ເຊັ່ນ: ສາຂາປະຈຸບັນແລະສາຂາອື່ນທີ່ທ່ານດຶງ
ຈາກ) ການ​ນໍາ​ໃຊ້​ວິ​ທີ​ການ​ລວມ 3 ທາງ​. ມັນພະຍາຍາມກວດຫາການລວມເຂົ້າກັນຢ່າງລະມັດລະວັງ
ຄວາມບໍ່ແນ່ນອນ ແລະຖືວ່າໂດຍທົ່ວໄປແລ້ວປອດໄພ ແລະໄວ.

ຮຽກຮ້ອງ
ນີ້ສາມາດແກ້ໄຂພຽງແຕ່ສອງຫົວໂດຍໃຊ້ສູດການຄິດໄລ່ 3-way merge. ໃນເວລາທີ່ມີຫຼາຍກ່ວາ
ບັນພະບຸລຸດ ທຳ ມະດາອັນ ໜຶ່ງ ທີ່ສາມາດໃຊ້ ສຳ ລັບການລວມ 3 ທາງ, ມັນສ້າງຕົ້ນໄມ້ທີ່ປະສົມປະສານຂອງ
ບັນພະບຸລຸດທົ່ວໄປແລະໃຊ້ວ່າເປັນຕົ້ນໄມ້ອ້າງອີງສໍາລັບການລວມ 3 ທາງ. ນີ້ມີ
ໄດ້ຖືກລາຍງານວ່າສົ່ງຜົນໃຫ້ຂໍ້ຂັດແຍ່ງການຜະສົມຜະສານຫນ້ອຍລົງໂດຍບໍ່ມີການເຮັດໃຫ້ເກີດຄວາມຜິດພາດໂດຍການທົດສອບ
ເຮັດຕາມຄໍາຫມັ້ນສັນຍາລວມຕົວຈິງທີ່ເອົາມາຈາກປະຫວັດການພັດທະນາຂອງ Linux 2.6 kernel.
ນອກຈາກນັ້ນ, ນີ້ສາມາດກວດຫາແລະຈັດການກັບການລວມຕົວທີ່ກ່ຽວຂ້ອງກັບການປ່ຽນຊື່. ນີ້ແມ່ນຄ່າເລີ່ມຕົ້ນ
merge ແຜນຍຸດທະສາດໃນເວລາທີ່ດຶງຫຼືລວມສາຂາຫນຶ່ງ.

ໄດ້ ຮຽກຮ້ອງ ຍຸດທະສາດສາມາດເອົາທາງເລືອກຕໍ່ໄປນີ້:

ຮັບຜິດຊອບ
ທາງ​ເລືອກ​ນີ້​ບັງ​ຄັບ​ໃຫ້ hunks ທີ່​ຂັດ​ແຍ່ງ​ກັນ​ໃຫ້​ໄດ້​ຮັບ​ການ​ແກ້​ໄຂ​ອັດ​ຕະ​ໂນ​ມັດ​ຢ່າງ​ສະ​ອາດ​ໂດຍ​ການ​ເອື້ອ​ອໍາ​ນວຍ​ ຂອງພວກເຮົາ
ສະບັບ. ການປ່ຽນແປງຈາກຕົ້ນໄມ້ອື່ນໆທີ່ບໍ່ຂັດແຍ້ງກັບຝ່າຍຂອງພວກເຮົາແມ່ນ
ສະທ້ອນໃຫ້ເຫັນເຖິງຜົນໄດ້ຮັບລວມ. ສໍາລັບໄຟລ໌ຖານສອງ, ເນື້ອໃນທັງຫມົດແມ່ນປະຕິບັດ
ຈາກ​ຝ່າຍ​ພວກ​ເຮົາ.

ນີ້ບໍ່ຄວນສັບສົນກັບ ຮັບຜິດຊອບ merge ຍຸດທະສາດ, ເຊິ່ງບໍ່ໄດ້ເບິ່ງ
ຢູ່ໃນສິ່ງທີ່ຕົ້ນໄມ້ອື່ນບັນຈຸຢູ່ໃນທັງຫມົດ. ມັນຖິ້ມທຸກສິ່ງທຸກຢ່າງທີ່ຕົ້ນໄມ້ອື່ນເຮັດ,
ປະກາດ ຂອງພວກເຮົາ ປະ​ຫວັດ​ສາດ​ມີ​ທັງ​ຫມົດ​ທີ່​ເກີດ​ຂຶ້ນ​ໃນ​ມັນ​.

ຂອງພວກເຂົາ
ນີ້ແມ່ນກົງກັນຂ້າມຂອງ ຮັບຜິດຊອບ.

ຄວາມອົດທົນ
ດ້ວຍຕົວເລືອກນີ້, merge-recursive ໃຊ້ເວລາເພີ່ມເຕີມເລັກນ້ອຍເພື່ອຫຼີກເວັ້ນການຜິດພາດ
ທີ່ບາງຄັ້ງເກີດຂຶ້ນເນື່ອງຈາກສາຍທີ່ກົງກັນທີ່ບໍ່ສໍາຄັນ (ຕົວຢ່າງ: ວົງເລັບຈາກຄວາມແຕກຕ່າງ
ຫນ້າທີ່). ໃຊ້ນີ້ເມື່ອງ່າທີ່ຈະລວມເຂົ້າກັນໄດ້ແຕກແຍກກັນຢ່າງເປັນທໍາມະຊາດ. ເບິ່ງນຳ
git-diff(1) -- ຄວາມອົດທົນ.

diff-algorithm=[ຄວາມອົດທົນ|ໜ້ອຍສຸດ|ຮີສໂຕແກຣມ|myers]
ບອກ merge-recursive ເພື່ອໃຊ້ວິທີຄວາມແຕກຕ່າງທີ່ແຕກຕ່າງກັນ, ເຊິ່ງສາມາດຊ່ວຍຫຼີກເວັ້ນໄດ້
mismerges ທີ່​ເກີດ​ຂຶ້ນ​ເນື່ອງ​ຈາກ​ວ່າ​ເສັ້ນ​ທີ່​ກົງ​ກັນ​ບໍ່​ສໍາ​ຄັນ (ເຊັ່ນ​: ວົງ​ເລັບ​ຈາກ
ຫນ້າ​ທີ່​ທີ່​ແຕກ​ຕ່າງ​ກັນ​)​. ເບິ່ງນຳ git-diff(1) --diff-algorithm.

ignore-space-change, ignore-all-space, ignore-space-at-eol
ປະຕິບັດຕໍ່ສາຍທີ່ມີປະເພດຂອງການປ່ຽນຊ່ອງຫວ່າງທີ່ລະບຸໄວ້ບໍ່ປ່ຽນແປງ
sake ຂອງການລວມສາມທາງ. ການປ່ຽນແປງພື້ນທີ່ຂາວປະສົມກັບການປ່ຽນແປງອື່ນໆຕໍ່ກັບເສັ້ນ
ບໍ່ໄດ້ຖືກລະເລີຍ. ເບິ່ງນຳ git-diff(1) -b, -w, ແລະ --ignore-space-at-eol.

· ຖ້າ ຂອງເຂົາເຈົ້າ ສະບັບພຽງແຕ່ແນະນໍາການປ່ຽນແປງຊ່ອງຫວ່າງເປັນແຖວ, ຂອງພວກເຮົາ ສະບັບແມ່ນ
ໃຊ້;

· ຖ້າ ຂອງພວກເຮົາ ສະບັບແນະນໍາການປ່ຽນແປງຊ່ອງຫວ່າງແຕ່ ຂອງເຂົາເຈົ້າ ສະ​ບັບ​ປະ​ກອບ​ມີ a
ການ​ປ່ຽນ​ແປງ​ທີ່​ສໍາ​ຄັນ​, ຂອງເຂົາເຈົ້າ ສະ​ບັບ​ໄດ້​ຖືກ​ນໍາ​ໃຊ້​;

· ຖ້າບໍ່ດັ່ງນັ້ນ, ການລວມຕົວດຳເນີນໄປໃນທາງປົກກະຕິ.

ປັບໃຫ້ເປັນປົກກະຕິ
ນີ້ດໍາເນີນການເປັນ virtual check-out ແລະ check-in ຂອງທັງສາມຂັ້ນຕອນຂອງໄຟລ໌ໃນເວລາທີ່
ການ​ແກ້​ໄຂ​ການ​ລວມ​ສາມ​ທາງ​. ທາງເລືອກນີ້ຫມາຍເຖິງການນໍາໃຊ້ໃນເວລາທີ່ການລວມສາຂາ
ດ້ວຍການກັ່ນຕອງທີ່ສະອາດທີ່ແຕກຕ່າງກັນຫຼືກົດລະບຽບການປົກກະຕິຂອງເສັ້ນ. ເບິ່ງ "ການລວມເຂົ້າກັນ
ສາຂາທີ່ມີຄຸນລັກສະນະເຊັກອິນ/ເຊັກເອົາທີ່ຕ່າງກັນ" ໃນ gitattributes(5) ສໍາລັບ
ລາຍລະອຽດ.

no-renormalize
ປິດໃຊ້ງານຕົວເລືອກ renormalize. ອັນນີ້ overrides merge.renormalize
ຕົວແປການຕັ້ງຄ່າ.

rename-threshold=
ຄວບຄຸມເກນຄວາມຄ້າຍຄືກັນທີ່ໃຊ້ເພື່ອກວດຫາການປ່ຽນຊື່. ເບິ່ງນຳ git-diff(1​)
- ມ.

ຕົ້ນໄມ້ຍ່ອຍ[= ]
ທາງເລືອກນີ້ແມ່ນຮູບແບບທີ່ກ້າວຫນ້າທາງດ້ານຫຼາຍ ຕົ້ນໄມ້ຍ່ອຍ ຍຸດທະສາດ, ບ່ອນທີ່ຍຸດທະສາດເຮັດໃຫ້
ການຄາດເດົາວ່າຕ້ອງປ່ຽນຕົ້ນໄມ້ສອງຕົ້ນແນວໃດເພື່ອໃຫ້ເຂົ້າກັນໄດ້ເມື່ອລວມເຂົ້າກັນ.
ແທນທີ່ຈະ, ເສັ້ນທາງທີ່ລະບຸໄວ້ແມ່ນ prefixed (ຫຼື stripped ໃນຕອນເລີ່ມຕົ້ນ) ເພື່ອເຮັດໃຫ້
ຮູບຮ່າງຂອງສອງຕົ້ນໄມ້ໃຫ້ກົງກັນ.

octopus
ນີ້ແກ້ໄຂກໍລະນີທີ່ມີຫຼາຍກວ່າສອງຫົວ, ແຕ່ປະຕິເສດທີ່ຈະເຮັດການລວມທີ່ສັບສົນ
ຕ້ອງການການແກ້ໄຂຄູ່ມື. ມັນຕົ້ນຕໍແມ່ນຫມາຍຄວາມວ່າຈະຖືກນໍາໃຊ້ສໍາລັບການມັດສາຂາຫົວຂໍ້
ຫົວຮ່ວມກັນ. ນີ້ແມ່ນຍຸດທະສາດການລວມກັນໃນຕອນຕົ້ນໃນເວລາທີ່ດຶງຫຼືການລວມກັນຫຼາຍກ່ວາ
ຫນຶ່ງສາຂາ.

ຮັບຜິດຊອບ
ນີ້ແກ້ໄຂຈໍານວນຫົວໃດໆ, ແຕ່ຜົນໄດ້ຮັບຂອງຕົ້ນໄມ້ທີ່ປະສົມປະສານແມ່ນສະເຫມີໄປ
ຂອງ​ຫົວ​ໜ້າ​ສາ​ຂາ​ໃນ​ປະ​ຈຸ​ບັນ, ບໍ່​ປະ​ຕິ​ບັດ​ການ​ປ່ຽນ​ແປງ​ທັງ​ໝົດ​ຈາກ​ສາ​ຂາ​ອື່ນ​ຢ່າງ​ມີ​ປະ​ສິດ​ທິ​ຜົນ.
ມັນຫມາຍຄວາມວ່າຈະຖືກນໍາໃຊ້ເພື່ອທົດແທນປະຫວັດສາດການພັດທະນາເກົ່າຂອງສາຂາຂ້າງ. ຫມາຍ​ເຫດ​
ວ່ານີ້ແຕກຕ່າງຈາກທາງເລືອກ -Xours ກັບ ຮຽກຮ້ອງ ຍຸດ​ທະ​ສາດ​ລວມ​.

ຕົ້ນໄມ້ຍ່ອຍ
ນີ້ແມ່ນຍຸດທະສາດ recursive ດັດແກ້. ເມື່ອລວມຕົ້ນໄມ້ A ແລະ B, ຖ້າ B ກົງກັບ
a subtree ຂອງ A, B ຖືກປັບຄັ້ງທໍາອິດເພື່ອໃຫ້ກົງກັບໂຄງສ້າງຕົ້ນໄມ້ຂອງ A, ແທນທີ່ຈະເປັນ
ການອ່ານຕົ້ນໄມ້ໃນລະດັບດຽວກັນ. ການປັບຕົວນີ້ແມ່ນຍັງເຮັດໄດ້ທົ່ວໄປ
ຕົ້ນໄມ້ບັນພະບຸລຸດ.

ດ້ວຍ​ຍຸດ​ທະ​ສາດ​ທີ່​ນໍາ​ໃຊ້​ການ​ລວມ 3 ທາງ (ລວມ​ທັງ​ຄ່າ​ເລີ່ມ​ຕົ້ນ​, ຮຽກຮ້ອງ), ຖ້າ​ຫາກ​ວ່າ​ການ​ປ່ຽນ​ແປງ​
ແມ່ນເຮັດຢູ່ໃນສາຂາທັງສອງ, ແຕ່ຕໍ່ມາໄດ້ກັບຄືນມາໃນຫນຶ່ງຂອງສາຂາ, ການປ່ຽນແປງນັ້ນຈະເປັນ
ປະກົດຢູ່ໃນຜົນໄດ້ຮັບລວມ; ບາງຄົນພົບວ່າພຶດຕິກໍານີ້ສັບສົນ. ມັນເກີດຂື້ນຍ້ອນ
ພຽງແຕ່ຫົວແລະຖານ merge ໄດ້ຖືກພິຈາລະນາໃນເວລາທີ່ປະຕິບັດ merge, ບໍ່ແມ່ນ
ຄໍາຫມັ້ນສັນຍາສ່ວນບຸກຄົນ. ສູດການຄິດໄລ່ການລວມ ດັ່ງນັ້ນຈຶ່ງພິຈາລະນາການປ່ຽນແປງທີ່ກັບຄືນມາເປັນບໍ່
ປ່ຽນແປງທັງໝົດ, ແລະປ່ຽນສະບັບທີ່ປ່ຽນແທນ.

ຄ່າເລີ່ມຕົ້ນ ຄວາມງາມ

ເລື້ອຍໆຄົນໃຊ້ git pull ໂດຍບໍ່ມີການໃຫ້ພາລາມິເຕີໃດໆ. ຕາມປະເພນີ, ນີ້ແມ່ນ
ເທົ່າກັບເວົ້າວ່າ git pull origin. ຢ່າງໃດກໍຕາມ, ໃນເວລາທີ່ສາຂາການຕັ້ງຄ່າ. .ໄລຍະໄກແມ່ນ
ປະຈຸບັນຢູ່ໃນສາຂາ , ຄ່ານັ້ນຖືກໃຊ້ແທນຕົ້ນກໍາເນີດ.

ເພື່ອກໍານົດວ່າ URL ໃດທີ່ຈະໃຊ້ເພື່ອເອົາມາຈາກ, ມູນຄ່າຂອງການຕັ້ງຄ່າ
ໄລຍະໄກ. .url ແມ່ນປຶກສາຫາລືແລະຖ້າບໍ່ມີຕົວແປດັ່ງກ່າວ, ມູນຄ່າໃນ URL:
` ແຖວໃນ `$GIT_DIR/ໄລຍະໄກ/ ໄຟລ໌ຖືກນໍາໃຊ້.

ເພື່ອກໍານົດສິ່ງທີ່ສາຂາຫ່າງໄກສອກຫຼີກທີ່ຈະເອົາ (ແລະທາງເລືອກໃນການເກັບຮັກສາໃນ
remote-tracking branch) ເມື່ອຄຳສັ່ງຖືກແລ່ນໂດຍບໍ່ມີພາລາມິເຕີ refspec ຢູ່ເທິງ
ເສັ້ນຄໍາສັ່ງ, ຄ່າຂອງໄລຍະໄກຕົວແປການຕັ້ງຄ່າ. .fetch ແມ່ນປຶກສາຫາລື,
ແລະຖ້າບໍ່ມີ, $GIT_DIR/ໄລຍະໄກ/ ໄຟລ໌ໄດ້ຖືກປຶກສາຫາລືແລະ "ດຶງ: `
ສາຍຖືກນໍາໃຊ້. ນອກເໜືອໄປຈາກຮູບແບບ refspec ທີ່ອະທິບາຍໄວ້ໃນພາກ OPTIONS, ທ່ານ
ສາມາດມີ refspec globbing ທີ່ມີລັກສະນະນີ້:

refs/heads/*:refs/remotes/origin/*

refspec ທີ່ມີ globbing ຕ້ອງມີ RHS ທີ່ບໍ່ຫວ່າງເປົ່າ (ເຊັ່ນ: ຕ້ອງເກັບຮັກສາສິ່ງທີ່ໄດ້ດຶງມາໃນ.
ສາຂາການຕິດຕາມໄລຍະໄກ), ແລະ LHS ແລະ RHS ຂອງມັນຕ້ອງສິ້ນສຸດດ້ວຍ /*. ຂ້າງເທິງນີ້ລະບຸວ່າ
ສາ​ຂາ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​ທັງ​ຫມົດ​ແມ່ນ​ຕິດ​ຕາມ​ໂດຍ​ນໍາ​ໃຊ້​ສາ​ຂາ​ການ​ຕິດ​ຕາມ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​ໃນ refs/remotes/origin/
ລໍາດັບຊັ້ນພາຍໃຕ້ຊື່ດຽວກັນ.

ກົດ​ລະ​ບຽບ​ການ​ທີ່​ຈະ​ກໍາ​ນົດ​ທີ່​ສາ​ຂາ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​ທີ່​ຈະ​ລວມ​ຫຼັງ​ຈາກ​ການ​ດຶງ​ຂໍ້​ມູນ​ແມ່ນ​ກ່ຽວ​ຂ້ອງ​ເລັກ​ນ້ອຍ​, ໃນ​
ເພື່ອບໍ່ໃຫ້ທໍາລາຍຄວາມເຂົ້າກັນໄດ້ກັບຫລັງ.

ຖ້າ refspec ຊັດເຈນໄດ້ຖືກມອບໃຫ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງຂອງ git pull, ພວກມັນທັງຫມົດຈະຖືກລວມເຂົ້າກັນ.

ເມື່ອບໍ່ມີ refspec ຢູ່ໃນເສັ້ນຄໍາສັ່ງ, ຫຼັງຈາກນັ້ນ git pull ໃຊ້ refspec ຈາກ
ການຕັ້ງຄ່າ ຫຼື $GIT_DIR/ໄລຍະໄກ/ . ໃນກໍລະນີດັ່ງກ່າວ, ກົດລະບຽບດັ່ງຕໍ່ໄປນີ້ນໍາໃຊ້:

1. ຖ້າສາຂາ. .merge ການຕັ້ງຄ່າສໍາລັບສາຂາປະຈຸບັນ ມີຢູ່, ນັ້ນແມ່ນ
ຊື່ຂອງສາຂາຢູ່ສະຖານທີ່ຫ່າງໄກສອກຫຼີກທີ່ຖືກລວມເຂົ້າກັນ.

2. ຖ້າຫາກວ່າ refspec ເປັນຫນຶ່ງ globbing, ບໍ່ມີຫຍັງຖືກລວມເຂົ້າກັນ.

3. ຖ້າບໍ່ດັ່ງນັ້ນສາຂາຫ່າງໄກສອກຫຼີກຂອງ refspec ທໍາອິດຖືກລວມເຂົ້າກັນ.

ຕົວຢ່າງ

· ອັບເດດສາຂາການຕິດຕາມໄລຍະໄກສຳລັບບ່ອນເກັບມ້ຽນທີ່ທ່ານໂຄນຈາກ, ຈາກນັ້ນຮວມອັນໜຶ່ງ
ຂອງພວກມັນເຂົ້າໄປໃນສາຂາປະຈຸບັນຂອງເຈົ້າ:

$ git pull, git pull origin

ປົກກະຕິແລ້ວສາຂາທີ່ຖືກລວມເຂົ້າແມ່ນ HEAD ຂອງ repository ຫ່າງໄກສອກຫຼີກ, ແຕ່ທາງເລືອກແມ່ນ
ກໍານົດໂດຍສາຂາ. .ໄລຍະໄກ ແລະສາຂາ. .merge ທາງເລືອກ; ເບິ່ງ git-
config(1) ສໍາລັບລາຍລະອຽດ.

· ເຊື່ອມ​ຕໍ່​ກັບ​ສາ​ຂາ​ປະ​ຈຸ​ບັນ​, ສາ​ຂາ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​ຕໍ່​ໄປ​:

$ git ດຶງຕົ້ນກໍາເນີດຕໍ່ໄປ

ອັນນີ້ເຮັດໃຫ້ສຳເນົາຕໍ່ໄປຊົ່ວຄາວໃນ FETCH_HEAD, ແຕ່ບໍ່ໄດ້ອັບເດດອັນໃດ
ສາຂາການຕິດຕາມໄລຍະໄກ. ການນໍາໃຊ້ສາຂາການຕິດຕາມຫ່າງໄກສອກຫຼີກ, ດຽວກັນສາມາດເຮັດໄດ້ໂດຍ
ຮຽກ​ຮ້ອງ​ເອົາ​ແລະ​ການ​ລວມ​:

$ git ຕົ້ນ ກຳ ເນີດ
$ git merge ຕົ້ນກໍາເນີດ / ຕໍ່ໄປ

ຖ້າທ່ານພະຍາຍາມດຶງເຊິ່ງເຮັດໃຫ້ເກີດຄວາມຂັດແຍ້ງທີ່ສັບສົນແລະຕ້ອງການເລີ່ມຕົ້ນໃຫມ່, ທ່ານ
ສາມາດຟື້ນຕົວດ້ວຍ ໄປ reset.

ໃຊ້ git-pull ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net