ນີ້ແມ່ນຄໍາສັ່ງ git-pull ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
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
