ນີ້ແມ່ນຄໍາສັ່ງ git-merge ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
git-merge - ເຂົ້າຮ່ວມສອງຫຼືຫຼາຍກວ່າປະຫວັດສາດການພັດທະນາຮ່ວມກັນ
ສະຫຼຸບສັງລວມ
ໄປ ລວມ [-n] [--stat] [--no-commit] [--squash] [--[no-]edit]
[-ສ ] [-X ] [-S[ ]]
[--[ບໍ່-]rerere-autoupdate] [-m ] [ ...]
ໄປ ລວມ ຫົວ ...
ໄປ ລວມ --ເອົາລູກອອກ
ລາຍລະອຽດ
ລວມເອົາການປ່ຽນແປງຈາກຄໍາຫມັ້ນສັນຍາທີ່ມີຊື່ (ນັບຕັ້ງແຕ່ເວລາທີ່ປະຫວັດສາດຂອງພວກເຂົາແຕກແຍກຈາກ
ສາຂາປະຈຸບັນ) ເຂົ້າໄປໃນສາຂາປະຈຸບັນ. ຄໍາສັ່ງນີ້ຖືກນໍາໃຊ້ໂດຍ ໄປ ດຶງ to
ລວມເອົາການປ່ຽນແປງຈາກບ່ອນເກັບມ້ຽນອື່ນແລະສາມາດນໍາໃຊ້ດ້ວຍມືເພື່ອລວມການປ່ຽນແປງຈາກ
ຫນຶ່ງສາຂາເຂົ້າໄປໃນອີກ.
ສົມມຸດວ່າມີປະຫວັດສາດຕໍ່ໄປນີ້ແລະສາຂາປະຈຸບັນແມ່ນ "ນາຍ":
A---B---C ຫົວຂໍ້
/
D---E---F---G ແມ່ບົດ
ຫຼັງຈາກນັ້ນ, "git merge topic" ຈະ replay ການປ່ຽນແປງທີ່ເຮັດຢູ່ໃນສາຂາຫົວຂໍ້ນັບຕັ້ງແຕ່ມັນ diverged
ຈາກຕົ້ນສະບັບ (ie, E) ຈົນກ່ວາຄໍາຫມັ້ນສັນຍາໃນປະຈຸບັນຂອງຕົນ (C) ເທິງຂອງຕົ້ນສະບັບ, ແລະບັນທຶກຜົນໄດ້ຮັບ
ໃນຄໍາຫມັ້ນສັນຍາໃຫມ່ພ້ອມກັບຊື່ຂອງສອງພໍ່ແມ່ commits ແລະຂໍ້ຄວາມບັນທຶກຈາກ
ຜູ້ໃຊ້ອະທິບາຍການປ່ຽນແປງ.
A---B---C ຫົວຂໍ້
/ \
D---E---F---G---H ແມ່ບົດ
syntax ທີສອງ ( ຫົວ ... ) ໄດ້ຮັບການສະຫນັບສະຫນູນສໍາລັບເຫດຜົນປະຫວັດສາດ. ຢ່າໃຊ້
ມັນມາຈາກເສັ້ນຄໍາສັ່ງຫຼືໃນສະຄິບໃຫມ່. ມັນຄືກັນກັບ git merge -m
....
syntax ທີສາມ ("git merge --abort") ສາມາດດໍາເນີນການໄດ້ພຽງແຕ່ຫຼັງຈາກການລວມກັນໄດ້ສົ່ງຜົນໃຫ້.
ຂໍ້ຂັດແຍ່ງ. ໄປ ລວມ --ເອົາລູກອອກ ຈະຍົກເລີກຂະບວນການລວມແລະພະຍາຍາມສ້າງໃຫມ່
pre-merge ລັດ. ຢ່າງໃດກໍຕາມ, ຖ້າມີການປ່ຽນແປງທີ່ບໍ່ສອດຄ່ອງໃນເວລາທີ່ການລວມເຂົ້າກັນໄດ້ເລີ່ມຕົ້ນ (ແລະ
ໂດຍສະເພາະແມ່ນຖ້າຫາກວ່າການປ່ຽນແປງເຫຼົ່ານັ້ນໄດ້ຮັບການປັບປຸງເພີ່ມເຕີມຫຼັງຈາກການລວມໄດ້ເລີ່ມຕົ້ນ). ໄປ ລວມ
--ເອົາລູກອອກ ໃນບາງກໍລະນີທີ່ຈະບໍ່ສາມາດສ້າງການປ່ຽນແປງຕົ້ນສະບັບ (pre-merge) ໄດ້.
ດັ່ງນັ້ນ:
ການເຕືອນໄພ: ແລ່ນ ໄປ ລວມ ກັບການປ່ຽນແປງທີ່ບໍ່ໄດ້ຕັ້ງໃຈທີ່ບໍ່ສໍາຄັນແມ່ນທໍ້ຖອຍໃຈ: ໃນຂະນະທີ່
ເປັນໄປໄດ້, ມັນອາດຈະເຮັດໃຫ້ເຈົ້າຢູ່ໃນສະຖານະທີ່ຍາກທີ່ຈະກັບຄືນອອກຈາກກໍລະນີຂອງ a
ການຂັດແຍ້ງ.
OPTIONS
--commit, --no-commit
ປະຕິບັດ merge ແລະຄໍາຫມັ້ນສັນຍາຜົນໄດ້ຮັບ. ທາງເລືອກນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອ override
--no-commit.
ດ້ວຍ --no-commit ປະຕິບັດການລວມກັນ ແຕ່ສົມມຸດວ່າການລວມລົ້ມເຫລວ ແລະຢ່າເຮັດອັດຕະໂນມັດ,
ເພື່ອໃຫ້ຜູ້ໃຊ້ໂອກາດໃນການກວດສອບແລະປັບປ່ຽນຜົນການລວມກັນຕື່ມອີກກ່ອນ
ຄໍາຫມັ້ນສັນຍາ.
--edit, -e, --no-edit
ຮຽກຮ້ອງບັນນາທິການກ່ອນທີ່ຈະປະຕິບັດການຜະສົມກົນຈັກສົບຜົນສໍາເລັດເພື່ອແກ້ໄຂຕື່ມອີກ
ຂໍ້ຄວາມທີ່ສ້າງອັດຕະໂນມັດການລວມເຂົ້າກັນ, ດັ່ງນັ້ນຜູ້ໃຊ້ສາມາດອະທິບາຍແລະ justify ການລວມ. ໄດ້
--no-edit option ສາມາດໃຊ້ເພື່ອຮັບເອົາຂໍ້ຄວາມທີ່ສ້າງຂຶ້ນໂດຍອັດຕະໂນມັດ (ໂດຍທົ່ວໄປແລ້ວ
ທໍ້). ທາງເລືອກ --edit (ຫຼື -e) ແມ່ນຍັງເປັນປະໂຫຍດຖ້າຫາກວ່າທ່ານກໍາລັງໃຫ້ສະບັບຮ່າງ
ຂໍ້ຄວາມທີ່ມີຕົວເລືອກ -m ຈາກເສັ້ນຄໍາສັ່ງແລະຕ້ອງການແກ້ໄຂມັນໃນບັນນາທິການ.
ສະຄຣິບເກົ່າອາດຈະຂຶ້ນກັບພຶດຕິກໍາປະຫວັດສາດທີ່ບໍ່ອະນຸຍາດໃຫ້ຜູ້ໃຊ້ແກ້ໄຂ
ຂໍ້ຄວາມບັນທຶກການລວມ. ພວກເຂົາຈະເຫັນບັນນາທິການເປີດຂຶ້ນເມື່ອພວກເຂົາແລ່ນ 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; ສິ່ງເຫຼົ່ານີ້ຖືກປະຕິເສດ ແລະຈະຖືກລຶບອອກໃນ
ໃນອະນາຄົດ.
-q, --ງຽບ
ດໍາເນີນການຢ່າງງຽບໆ. ໝາຍຄວາມວ່າ --ບໍ່ຄືບໜ້າ.
-v, --verbose
ເປັນຄຳເວົ້າ.
--ຄວາມຄືບໜ້າ, --ບໍ່ຄືບໜ້າ
ເປີດ/ປິດຄວາມຄືບໜ້າຢ່າງຈະແຈ້ງ. ຖ້າທັງສອງບໍ່ໄດ້ລະບຸ, ຄວາມຄືບຫນ້າຈະສະແດງຖ້າ
ຄວາມຜິດພາດມາດຕະຖານແມ່ນເຊື່ອມຕໍ່ກັບ terminal. ໃຫ້ສັງເກດວ່າບໍ່ແມ່ນຍຸດທະສາດການລວມທັງຫມົດອາດຈະ
ສະຫນັບສະຫນູນການລາຍງານຄວາມຄືບຫນ້າ.
-S[ ], --gpg-sign[= ]
GPG-ເຊັນສັນຍາການຮວມຜົນ. ການໂຕ້ຖຽງ keyid ແມ່ນທາງເລືອກແລະເປັນຄ່າເລີ່ມຕົ້ນ
ຕົວຕົນຂອງຄະນະກໍາມະ; ຖ້າລະບຸ, ມັນຕ້ອງຕິດຢູ່ກັບທາງເລືອກທີ່ບໍ່ມີຊ່ອງຫວ່າງ.
- ມ
ກໍານົດຂໍ້ຄວາມຄໍາຫມັ້ນສັນຍາທີ່ຈະຖືກນໍາໃຊ້ສໍາລັບການ merge commit (ໃນກໍລະນີທີ່ມີການສ້າງຫນຶ່ງ).
ຖ້າ --log ຖືກລະບຸ, shortlog ຂອງ commits ທີ່ຖືກລວມເຂົ້າຈະຖືກຕໍ່ທ້າຍ
ຂໍ້ຄວາມທີ່ລະບຸໄວ້.
ໄດ້ ໄປ fmt-merge-msg ຄໍາສັ່ງສາມາດຖືກນໍາໃຊ້ເພື່ອໃຫ້ຄ່າເລີ່ມຕົ້ນທີ່ດີສໍາລັບອັດຕະໂນມັດ ໄປ
ລວມ ຄຳຮຽກຮ້ອງ. ຂໍ້ຄວາມອັດຕະໂນມັດສາມາດປະກອບມີຄໍາອະທິບາຍສາຂາ.
--[ບໍ່-]rerere-autoupdate
ອະນຸຍາດໃຫ້ກົນໄກການ rerere ປັບປຸງດັດສະນີທີ່ມີຜົນມາຈາກການຂັດແຍ້ງອັດຕະໂນມັດ
ການແກ້ໄຂຖ້າເປັນໄປໄດ້.
--ເອົາລູກອອກ
ຍົກເລີກຂະບວນການແກ້ໄຂຂໍ້ຂັດແຍ່ງໃນປະຈຸບັນ, ແລະພະຍາຍາມສ້າງການລວມເຂົ້າກັນຄືນໃຫມ່
ລັດ.
ຖ້າຫາກວ່າມີການປ່ຽນແປງ worktree ທີ່ບໍ່ມີການປະຕິບັດໃນເວລາທີ່ການລວມໄດ້ເລີ່ມຕົ້ນ, ໄປ ລວມ
--ເອົາລູກອອກ ໃນບາງກໍລະນີຈະບໍ່ສາມາດສ້າງການປ່ຽນແປງເຫຼົ່ານີ້ໄດ້. ມັນເປັນເພາະສະນັ້ນ
ແນະນໍາໃຫ້ສະເຫມີຄໍາຫມັ້ນສັນຍາຫຼືເກັບຮັກສາການປ່ຽນແປງຂອງທ່ານກ່ອນທີ່ຈະແລ່ນ ໄປ ລວມ.
ໄປ ລວມ --ເອົາລູກອອກ ເທົ່າກັບ ໄປ reset --ລວມເຂົ້າກັນ ເມື່ອ MERGE_HEAD ຢູ່.
...
ຄໍາຫມັ້ນສັນຍາ, ປົກກະຕິແລ້ວຫົວຫນ້າສາຂາອື່ນໆ, ເພື່ອລວມເຂົ້າໄປໃນສາຂາຂອງພວກເຮົາ. ກໍານົດຫຼາຍກ່ວາ
ຫນຶ່ງຄໍາຫມັ້ນສັນຍາຈະສ້າງ merge ກັບພໍ່ແມ່ຫຼາຍກ່ວາສອງ (ເອີ້ນວ່າຮັກແພງ
Octopus merge).
ຖ້າບໍ່ມີຄໍາຫມັ້ນສັນຍາຈາກເສັ້ນຄໍາສັ່ງ, merge ສາຂາການຕິດຕາມຫ່າງໄກສອກຫຼີກທີ່
ສາຂາປະຈຸບັນຖືກຕັ້ງຄ່າໃຫ້ໃຊ້ເປັນສາຍນ້ຳເທິງຂອງມັນ. ເບິ່ງການຕັ້ງຄ່ານຳ
ພາກສ່ວນຂອງໜ້າຄູ່ມືນີ້.
ເມື່ອ FETCH_HEAD (ແລະບໍ່ມີຄໍາຫມັ້ນສັນຍາອື່ນໆ) ຖືກລະບຸ, ສາຂາທີ່ບັນທຶກໄວ້ໃນ
ໄຟລ໌ .git/FETCH_HEAD ໂດຍການຮຽກຮ້ອງຜ່ານມາຂອງ git fetch ສໍາລັບການລວມເຂົ້າກັນໄດ້ຖືກລວມເຂົ້າກັບ
ສາຂາປະຈຸບັນ.
ກ່ອນລວມ ກວດເບິ່ງ
ກ່ອນທີ່ຈະນໍາໃຊ້ການປ່ຽນແປງພາຍນອກ, ທ່ານຄວນຈະໄດ້ຮັບການເຮັດວຽກຂອງຕົນເອງໃນຮູບຮ່າງທີ່ດີແລະຄໍາຫມັ້ນສັນຍາ
ຢູ່ໃນທ້ອງຖິ່ນ, ສະນັ້ນມັນຈະບໍ່ຖືກ clobber ຖ້າມີຂໍ້ຂັດແຍ່ງ. ເບິ່ງນຳ git-stash(1). ໄປ
ດຶງ ແລະ ໄປ ລວມ ຈະຢຸດເຊົາໂດຍບໍ່ມີການເຮັດຫຍັງເມື່ອການປ່ຽນແປງທີ່ບໍ່ສອດຄ່ອງໃນທ້ອງຖິ່ນທັບຊ້ອນກັນ
ກັບໄຟລ໌ທີ່ ໄປ ດຶງ/ໄປ ລວມ ອາດຈະຕ້ອງອັບເດດ.
ເພື່ອຫຼີກເວັ້ນການບັນທຶກການປ່ຽນແປງທີ່ບໍ່ກ່ຽວຂ້ອງໃນຄໍາຫມັ້ນສັນຍາລວມ, ໄປ ດຶງ ແລະ ໄປ ລວມ ຍັງຈະ
ຍົກເລີກຖ້າມີການປ່ຽນແປງໃດໆທີ່ລົງທະບຽນຢູ່ໃນດັດຊະນີທີ່ກ່ຽວຂ້ອງກັບ HEAD commit. (ຫນຶ່ງ
ຂໍ້ຍົກເວັ້ນແມ່ນເມື່ອລາຍການດັດສະນີທີ່ມີການປ່ຽນແປງຢູ່ໃນສະຖານະທີ່ຈະເປັນຜົນມາຈາກ
ລວມແລ້ວ.)
ຖ້າຄໍາຫມັ້ນສັນຍາທີ່ມີຊື່ທັງຫມົດແມ່ນບັນພະບຸລຸດຂອງ HEAD ແລ້ວ, ໄປ ລວມ ຈະອອກຈາກໄວ
ຂໍ້ຄວາມ "ອັບເດດແລ້ວ."
ເລັ່ງດ່ວນ ລວມ
ສ່ວນຫຼາຍມັກ, ຫົວຫນ້າສາຂາໃນປະຈຸບັນແມ່ນບັນພະບຸລຸດຂອງຄໍາຫມັ້ນສັນຍາທີ່ມີຊື່. ນີ້ແມ່ນທົ່ວໄປທີ່ສຸດ
ກໍລະນີໂດຍສະເພາະໃນເວລາທີ່ invoked ຈາກ ໄປ ດຶງ: ທ່ານກໍາລັງຕິດຕາມ repository ເທິງນ້ໍາ, ທ່ານ
ບໍ່ໄດ້ໃຫ້ຄໍາໝັ້ນສັນຍາວ່າບໍ່ມີການປ່ຽນແປງໃນທ້ອງຖິ່ນ, ແລະຕອນນີ້ທ່ານຕ້ອງການອັບເດດເປັນການປັບປຸງສະບັບໃໝ່ກວ່າ.
ໃນກໍລະນີນີ້, ຄໍາຫມັ້ນສັນຍາໃຫມ່ແມ່ນບໍ່ຈໍາເປັນເພື່ອເກັບຮັກສາປະຫວັດສາດລວມ; ແທນທີ່ຈະ, HEAD
(ພ້ອມກັບດັດຊະນີ) ຖືກປັບປຸງເພື່ອຊີ້ໃຫ້ເຫັນເຖິງຄໍາຫມັ້ນສັນຍາທີ່ມີຊື່, ໂດຍບໍ່ມີການສ້າງພິເສດ
ລວມຄໍາຫມັ້ນສັນຍາ.
ພຶດຕິກໍານີ້ສາມາດຖືກສະກັດກັ້ນດ້ວຍທາງເລືອກ --no-ff.
TRUE ລວມ
ຍົກເວັ້ນໃນການເຊື່ອມຕໍ່ຢ່າງວ່ອງໄວ (ເບິ່ງຂ້າງເທິງ), ກິ່ງງ່າທີ່ຈະຖືກລວມຕ້ອງໄດ້ຮັບການຜູກມັດ
ຮ່ວມກັນໂດຍການຜູກມັດທີ່ມີທັງສອງຂອງເຂົາເຈົ້າເປັນພໍ່ແມ່ຂອງຕົນ.
ສະບັບລວມການ reconciling ການປ່ຽນແປງຈາກທຸກສາຂາທີ່ຈະລວມແມ່ນຫມັ້ນສັນຍາ, ແລະ
HEAD, ດັດຊະນີ, ແລະຕົ້ນໄມ້ເຮັດວຽກຂອງທ່ານຖືກປັບປຸງໃຫ້ມັນ. ມັນເປັນໄປໄດ້ທີ່ຈະມີການດັດແປງ
ໃນຕົ້ນໄມ້ທີ່ເຮັດວຽກຕາບໃດທີ່ພວກມັນບໍ່ທັບຊ້ອນກັນ; ການອັບເດດຈະຮັກສາພວກມັນໄວ້.
ໃນເວລາທີ່ມັນບໍ່ຈະແຈ້ງວິທີການຄືນດີການປ່ຽນແປງ, ດັ່ງຕໍ່ໄປນີ້ເກີດຂຶ້ນ:
1. ຕົວຊີ້ HEAD ຢູ່ຄືກັນ.
2. ການອ້າງອີງ MERGE_HEAD ຖືກຕັ້ງໃຫ້ຊີ້ໄປຫາຫົວສາຂາອື່ນ.
3. ເສັ້ນທາງທີ່ປະສົມປະສານຢ່າງສະອາດໄດ້ຖືກປັບປຸງທັງໃນໄຟລ໌ດັດສະນີແລະໃນຕົ້ນໄມ້ທີ່ເຮັດວຽກຂອງທ່ານ.
4. ສໍາລັບເສັ້ນທາງທີ່ຂັດແຍ້ງກັນ, ໄຟລ໌ດັດສະນີບັນທຶກເຖິງສາມສະບັບ: ຂັ້ນຕອນທີ 1 ເກັບຮັກສາ
ຮຸ່ນຈາກບັນພະບຸລຸດທົ່ວໄປ, ໄລຍະ 2 ຈາກ HEAD, ແລະຂັ້ນຕອນທີ 3 ຈາກ MERGE_HEAD (ເຈົ້າ
ສາມາດກວດສອບຂັ້ນຕອນດ້ວຍ git ls-files -u). ໄຟລ໌ຕົ້ນໄມ້ທີ່ເຮັດວຽກປະກອບດ້ວຍ
ຜົນໄດ້ຮັບຈາກໂຄງການ "ລວມ"; ie ຜົນໄດ້ຮັບການລວມ 3 ທາງກັບເຄື່ອງຫມາຍການຂັດແຍ້ງທີ່ຄຸ້ນເຄີຍ
<<< ===>>>.
5. ບໍ່ມີການປ່ຽນແປງອື່ນໆ. ໂດຍສະເພາະ, ການດັດແກ້ທ້ອງຖິ່ນທີ່ທ່ານມີກ່ອນທ່ານ
ການລວມເຂົ້າກັນທີ່ເລີ່ມຕົ້ນຈະຢູ່ຄືກັນແລະລາຍການດັດສະນີສໍາລັບພວກເຂົາຍັງຄົງຢູ່,
ie ການຈັບຄູ່ HEAD.
ຖ້າທ່ານພະຍາຍາມປະສົມປະສານເຊິ່ງເຮັດໃຫ້ເກີດຄວາມຂັດແຍ້ງທີ່ສັບສົນແລະຕ້ອງການເລີ່ມຕົ້ນໃຫມ່, ທ່ານສາມາດເຮັດໄດ້
ຟື້ນຕົວດ້ວຍ git merge --abort.
ການລວມຕົວ TAG
ເມື່ອລວມເອົາແທັກທີ່ລະບຸໄວ້ (ແລະອາດຈະເປັນການລົງນາມ), Git ສະເຫມີສ້າງຄໍາຫມັ້ນສັນຍາລວມ.
ເຖິງແມ່ນວ່າການລວມຕົວໄວແມ່ນເປັນໄປໄດ້, ແລະແມ່ແບບຂໍ້ຄວາມຄໍາຫມັ້ນສັນຍາໄດ້ຖືກກະກຽມດ້ວຍ
ຂໍ້ຄວາມແທັກ. ນອກຈາກນັ້ນ, ຖ້າແທັກຖືກເຊັນ, ການກວດສອບລາຍເຊັນຖືກລາຍງານເປັນ a
ຄໍາເຫັນໃນແມ່ແບບຂໍ້ຄວາມ. ເບິ່ງນຳ git-tag(1).
ໃນເວລາທີ່ທ່ານຕ້ອງການທີ່ຈະພຽງແຕ່ປະສົມປະສານກັບການເຮັດວຽກທີ່ນໍາໄປສູ່ຄໍາຫມັ້ນສັນຍາທີ່ຈະເກີດຂຶ້ນ
tagged, e.g. synchronizing ກັບຈຸດປ່ອຍນ້ໍາ, ທ່ານອາດຈະບໍ່ຕ້ອງການທີ່ຈະເຮັດໃຫ້ເປັນ
ຄໍາຫມັ້ນສັນຍາລວມທີ່ບໍ່ຈໍາເປັນ.
ໃນກໍລະນີດັ່ງກ່າວ, ທ່ານສາມາດ "unwrap" tag ຕົວທ່ານເອງກ່ອນທີ່ຈະໃຫ້ອາຫານມັນ git merge, ຫຼືຜ່ານ
--ff-only ໃນເວລາທີ່ທ່ານບໍ່ມີການເຮັດວຽກຂອງຕົນເອງ. ຕົວຢ່າງ
git fetch ຕົ້ນກໍາເນີດ
git merge v1.2.3^0
git merge --ff-only v1.2.3
ວິທີການ ຂໍ້ຂັດແຍ່ງ ARE ນຳສະເໜີ
ໃນລະຫວ່າງການລວມ, ໄຟລ໌ເປັນໄມ້ຢືນຕົ້ນທີ່ເຮັດວຽກໄດ້ຖືກປັບປຸງເພື່ອສະທ້ອນໃຫ້ເຫັນຜົນໄດ້ຮັບຂອງການລວມ.
ໃນບັນດາການປ່ຽນແປງທີ່ເຮັດໃຫ້ກັບສະບັບບັນພະບຸລຸດທົ່ວໄປ, ບໍ່ແມ່ນການທັບຊ້ອນ (ນັ້ນແມ່ນ.
ທ່ານປ່ຽນພື້ນທີ່ຂອງໄຟລ໌ໃນຂະນະທີ່ອີກດ້ານຫນຶ່ງອອກຈາກພື້ນທີ່ນັ້ນ intact, ຫຼືໃນທາງກັບກັນ)
ຖືກລວມເຂົ້າໃນຜົນສຸດທ້າຍ verbatim. ເມື່ອທັງສອງຝ່າຍໄດ້ເຮັດການປ່ຽນແປງອັນດຽວກັນ
ພື້ນທີ່, ຢ່າງໃດກໍຕາມ, Git ບໍ່ສາມາດສຸ່ມເລືອກຂ້າງຫນຶ່ງໃນໄລຍະອື່ນໆ, ແລະຂໍໃຫ້ທ່ານແກ້ໄຂ
ມັນໂດຍການປະຖິ້ມສິ່ງທີ່ທັງສອງຝ່າຍໄດ້ເຮັດໃຫ້ເຂດນັ້ນ.
ໂດຍຄ່າເລີ່ມຕົ້ນ, Git ໃຊ້ແບບດຽວກັນກັບແບບທີ່ໃຊ້ໂດຍໂຄງການ "merge" ຈາກ RCS
ເຫມາະສົມທີ່ຈະນໍາສະເຫນີການຂັດແຍ່ງກັນເຊັ່ນນີ້:
ນີ້ແມ່ນສາຍທີ່ບໍ່ປ່ຽນແປງຈາກທົ່ວໄປ
ບັນພະບຸລຸດ, ຫຼືແກ້ໄຂຢ່າງສະອາດເພາະວ່າພຽງແຕ່ຂ້າງຫນຶ່ງມີການປ່ຽນແປງ.
<<<<<<< yours:sample.txt
ການແກ້ໄຂຂໍ້ຂັດແຍ່ງແມ່ນຍາກ;
ໄປຊື້ເຄື່ອງ.
=======
Git ເຮັດໃຫ້ການແກ້ໄຂຂໍ້ຂັດແຍ່ງງ່າຍ.
>>>>>>> ຂອງເຂົາເຈົ້າ:sample.txt
ແລະນີ້ແມ່ນອີກເສັ້ນຫນຶ່ງທີ່ຖືກແກ້ໄຂຢ່າງສະອາດຫຼືບໍ່ໄດ້ຮັບການແກ້ໄຂ.
ພື້ນທີ່ທີ່ຄູ່ຂອງການປ່ຽນແປງທີ່ຂັດແຍ້ງເກີດຂຶ້ນແມ່ນຫມາຍດ້ວຍເຄື່ອງຫມາຍ <<<<<<<,
=======, ແລະ >>>>>>>. ສ່ວນກ່ອນ ======= ປົກກະຕິແລ້ວແມ່ນຂ້າງຂອງເຈົ້າ, ແລະສ່ວນ
ຫຼັງຈາກນັ້ນ, ໂດຍປົກກະຕິແມ່ນຂ້າງຂອງເຂົາເຈົ້າ.
ຮູບແບບເລີ່ມຕົ້ນບໍ່ໄດ້ສະແດງສິ່ງທີ່ຕົ້ນສະບັບເວົ້າຢູ່ໃນພື້ນທີ່ຂັດແຍ້ງ. ເຈົ້າ
ບໍ່ສາມາດບອກໄດ້ຈໍານວນຫຼາຍເສັ້ນທີ່ຖືກລົບແລະທົດແທນທີ່ມີຂໍ້ສັງເກດ Barbie ຢູ່ຂ້າງຂອງທ່ານ. ໄດ້
ສິ່ງດຽວທີ່ທ່ານສາມາດບອກໄດ້ແມ່ນວ່າຝ່າຍຂອງເຈົ້າຕ້ອງການເວົ້າວ່າມັນຍາກແລະເຈົ້າຢາກໄປ
ການຄ້າ, ໃນຂະນະທີ່ອີກຝ່າຍຕ້ອງການທີ່ຈະອ້າງວ່າມັນງ່າຍ.
ຮູບແບບທາງເລືອກສາມາດຖືກນໍາໃຊ້ໂດຍການຕັ້ງຄ່າ "merge.conflictStyle".
ຕົວແປເປັນ "diff3". ໃນແບບ "diff3", ຂໍ້ຂັດແຍ່ງຂ້າງເທິງນີ້ອາດຈະມີລັກສະນະນີ້:
ນີ້ແມ່ນສາຍທີ່ບໍ່ປ່ຽນແປງຈາກທົ່ວໄປ
ບັນພະບຸລຸດ, ຫຼືແກ້ໄຂຢ່າງສະອາດເພາະວ່າພຽງແຕ່ຂ້າງຫນຶ່ງມີການປ່ຽນແປງ.
<<<<<<< yours:sample.txt
ການແກ້ໄຂຂໍ້ຂັດແຍ່ງແມ່ນຍາກ;
ໄປຊື້ເຄື່ອງ.
||||||||
ການແກ້ໄຂຂໍ້ຂັດແຍ່ງແມ່ນຍາກ.
=======
Git ເຮັດໃຫ້ການແກ້ໄຂຂໍ້ຂັດແຍ່ງງ່າຍ.
>>>>>>> ຂອງເຂົາເຈົ້າ:sample.txt
ແລະນີ້ແມ່ນອີກເສັ້ນຫນຶ່ງທີ່ຖືກແກ້ໄຂຢ່າງສະອາດຫຼືບໍ່ໄດ້ຮັບການແກ້ໄຂ.
ນອກເໜືອໄປຈາກເຄື່ອງໝາຍ <<<<<<<, =======, ແລະ >>>>>>> ມັນໃຊ້ອີກ |||||||| ເຄື່ອງໝາຍ
ທີ່ຕິດຕາມດ້ວຍຂໍ້ຄວາມຕົ້ນສະບັບ. ເຈົ້າສາມາດບອກໄດ້ວ່າຕົ້ນສະບັບພຽງແຕ່ໄດ້ລະບຸຄວາມຈິງ,
ແລະຝ່າຍຂອງເຈົ້າພຽງແຕ່ໃຫ້ຄໍາຖະແຫຼງນັ້ນແລະຍອມແພ້, ໃນຂະນະທີ່ອີກຝ່າຍພະຍາຍາມ
ມີທັດສະນະຄະຕິໃນທາງບວກຫຼາຍ. ບາງຄັ້ງທ່ານສາມາດມາເຖິງມີການແກ້ໄຂທີ່ດີກວ່າໂດຍ
ເບິ່ງຕົ້ນສະບັບ.
ວິທີການ ເຖິງ ແກ້ໄຂ ຂໍ້ຂັດແຍ່ງ
ຫຼັງຈາກທີ່ເຫັນຄວາມຂັດແຍ້ງ, ທ່ານສາມາດເຮັດສອງຢ່າງ:
· ຕັດສິນໃຈບໍ່ລວມເຂົ້າກັນ. ການທໍາຄວາມສະອາດພຽງແຕ່ທ່ານຕ້ອງການແມ່ນເພື່ອປັບໄຟລ໌ດັດສະນີເປັນ
HEAD ມຸ່ງຫມັ້ນທີ່ຈະປີ້ນກັບ 2. ແລະເຮັດຄວາມສະອາດການປ່ຽນແປງຕົ້ນໄມ້ທີ່ເຮັດໂດຍ 2. ແລະ 3.; git
merge --abort ສາມາດໃຊ້ສໍາລັບການນີ້.
·ແກ້ໄຂຂໍ້ຂັດແຍ່ງ. Git ຈະຫມາຍຄວາມຂັດແຍ້ງໃນຕົ້ນໄມ້ທີ່ເຮັດວຽກ. ແກ້ໄຂໄຟລ໌
ເຂົ້າໄປໃນຮູບຮ່າງແລະ ໄປ ເພີ່ມ ໃຫ້ເຂົາເຈົ້າກັບດັດຊະນີ. ໃຊ້ ໄປ ຄໍາຫມັ້ນສັນຍາ ເພື່ອປະທັບຕາຂໍ້ຕົກລົງ.
ທ່ານສາມາດເຮັດວຽກໂດຍຜ່ານການຂັດແຍ່ງກັບຈໍານວນຂອງເຄື່ອງມື:
· ໃຊ້ເຄື່ອງມືລວມ. git mergetool ເພື່ອເປີດຕົວເຄື່ອງມືກຣາຟິກທີ່ເຮັດວຽກຮ່ວມກັນ
ຜ່ານການລວມ.
·ເບິ່ງຄວາມແຕກຕ່າງ. git diff ຈະສະແດງຄວາມແຕກຕ່າງສາມທາງ, ເນັ້ນໃສ່ການປ່ຽນແປງຈາກ
ທັງລຸ້ນ HEAD ແລະ MERGE_HEAD.
· ເບິ່ງຄວາມແຕກຕ່າງຂອງແຕ່ລະສາຂາ. git log --merge -p ຈະສະແດງຄວາມແຕກຕ່າງກ່ອນ
ສຳລັບລຸ້ນ HEAD ແລະຈາກນັ້ນແມ່ນລຸ້ນ MERGE_HEAD.
·ເບິ່ງຕົ້ນສະບັບ. git show :1:filename ສະແດງໃຫ້ເຫັນເຖິງບັນພະບຸລຸດທົ່ວໄປ, git ສະແດງ
:2:ຊື່ໄຟລ໌ສະແດງໃຫ້ເຫັນເວີຊັນ HEAD, ແລະການສະແດງ git :3:ຊື່ໄຟລ໌ສະແດງໃຫ້ເຫັນ MERGE_HEAD
ສະບັບ.
ຕົວຢ່າງ
· ການເຊື່ອມຕໍ່ການແກ້ໄຂຂອງກິ່ງງ່າແລະການປັບປຸງຢູ່ເທິງຂອງສາຂາໃນປັດຈຸບັນ, ເຮັດໃຫ້ເປັນ octopus
ຮວມ:
$ git merge ແກ້ໄຂການປັບປຸງ
·ລວມສາຂາທີ່ລ້າສະໄຫມເຂົ້າໄປໃນສາຂາປະຈຸບັນ, ໂດຍໃຊ້ຍຸດທະສາດການລວມຂອງພວກເຮົາ:
$ git merge -s ຂອງພວກເຮົາລ້າສະໄຫມ
· ລວມສາຂາຫຼັກເຂົ້າໄປໃນສາຂາປະຈຸບັນ, ແຕ່ຢ່າເຮັດສັນຍາໃໝ່
ອັດຕະໂນມັດ:
$ git merge --no-commit maint
ນີ້ສາມາດຖືກນໍາໃຊ້ໃນເວລາທີ່ທ່ານຕ້ອງການທີ່ຈະລວມເອົາການປ່ຽນແປງເພີ່ມເຕີມຕໍ່ກັບການລວມ, ຫຼືຕ້ອງການ
ຂຽນຂໍ້ຄວາມການຜະສົມຜະສານຂອງທ່ານເອງ.
ທ່ານຄວນລະເວັ້ນຈາກການລ່ວງລະເມີດທາງເລືອກນີ້ເພື່ອ sneak ການປ່ຽນແປງຢ່າງຫຼວງຫຼາຍເຂົ້າໄປໃນການຜະສົມຜະສານ
ຄໍາຫມັ້ນສັນຍາ. ການແກ້ໄຂຂະໜາດນ້ອຍເຊັ່ນ: ຊື່ລຸ້ນ/ລຸ້ນທີ່ແຕກຫັກຈະຍອມຮັບໄດ້.
ລວມ ໂຄງຮ່າງ
ກົນໄກການລວມ (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, ບໍ່ແມ່ນ
ຄໍາຫມັ້ນສັນຍາສ່ວນບຸກຄົນ. ສູດການຄິດໄລ່ການລວມ ດັ່ງນັ້ນຈຶ່ງພິຈາລະນາການປ່ຽນແປງທີ່ກັບຄືນມາເປັນບໍ່
ປ່ຽນແປງທັງໝົດ, ແລະປ່ຽນສະບັບທີ່ປ່ຽນແທນ.
CONFIGURATION
merge.conflictStyle
ລະບຸຮູບແບບທີ່ hunks ຂັດກັນຖືກຂຽນອອກໄປຫາໄຟລ໌ຕົ້ນໄມ້ທີ່ເຮັດວຽກ
ຮວມ. ຄ່າເລີ່ມຕົ້ນແມ່ນ "merge", ເຊິ່ງສະແດງໃຫ້ເຫັນເຄື່ອງຫມາຍການຂັດແຍ້ງ <<<<<<, ການປ່ຽນແປງທີ່ເຮັດໂດຍ
ຂ້າງຫນຶ່ງ, ເຄື່ອງຫມາຍ =======, ການປ່ຽນແປງທີ່ເຮັດໂດຍອີກດ້ານຫນຶ່ງ, ແລະຫຼັງຈາກນັ້ນເປັນເຄື່ອງຫມາຍ >>>>>>>.
ຮູບແບບສະຫຼັບ, "diff3", ເພີ່ມ |||||||| ເຄື່ອງໝາຍ ແລະ ຂໍ້ຄວາມຕົ້ນສະບັບກ່ອນໜ້າ
======= ເຄື່ອງໝາຍ.
merge.defaultToUpstream
ຖ້າການຜະສົມຜະສານຖືກເອີ້ນໂດຍບໍ່ມີການໂຕ້ຖຽງໃດໆ, ການລວມສາຂາຂອງຕົ້ນນ້ໍາທີ່ໄດ້ກໍານົດໄວ້
ສໍາລັບສາຂາປະຈຸບັນໂດຍການນໍາໃຊ້ມູນຄ່າທີ່ສັງເກດເຫັນສຸດທ້າຍຂອງພວກເຂົາທີ່ເກັບໄວ້ໃນພວກມັນ
ສາຂາການຕິດຕາມໄລຍະໄກ. ຄຸນຄ່າຂອງສາຂາ. .ລວມຊື່ນັ້ນ
ສາຂາຢູ່ຫ່າງໄກສອກຫຼີກທີ່ມີຊື່ຕາມສາຂາ. .remote ແມ່ນປຶກສາຫາລື, ແລະ
ຫຼັງຈາກນັ້ນ, ພວກເຂົາເຈົ້າໄດ້ຖືກແຜນທີ່ຜ່ານທາງໄກ. .fetch ກັບການຕິດຕາມໄລຍະໄກທີ່ສອດຄ້ອງກັນຂອງພວກເຂົາ
ສາຂາ, ແລະຄໍາແນະນໍາຂອງສາຂາການຕິດຕາມເຫຼົ່ານີ້ຖືກລວມເຂົ້າກັນ.
merge.ff
ໂດຍຄ່າເລີ່ມຕົ້ນ, Git ບໍ່ໄດ້ສ້າງຄໍາຫມັ້ນສັນຍາການຜະສົມຜະສານພິເສດໃນເວລາລວມຄໍາຫມັ້ນສັນຍາທີ່ເປັນ a
ເຊື້ອສາຍຂອງຄໍາຫມັ້ນສັນຍາໃນປະຈຸບັນ. ແທນທີ່ຈະ, ປາຍຂອງສາຂາໃນປະຈຸບັນແມ່ນ
ໄວຕໍ່ຫນ້າ. ເມື່ອຕັ້ງເປັນຜິດ, ຕົວແປນີ້ບອກ Git ເພື່ອສ້າງການລວມເພີ່ມເຕີມ
commit ໃນກໍລະນີດັ່ງກ່າວ (ເທົ່າກັບການໃຫ້ທາງເລືອກ --no-ff ຈາກເສັ້ນຄໍາສັ່ງ).
ເມື່ອຕັ້ງເປັນພຽງແຕ່, ພຽງແຕ່ການລວມຕົວໄວດັ່ງກ່າວໄດ້ຖືກອະນຸຍາດໃຫ້ (ເທົ່າກັບການໃຫ້
--ff-ພຽງແຕ່ທາງເລືອກຈາກເສັ້ນຄໍາສັ່ງ).
merge.branchdesc
ນອກເໜືອໄປຈາກຊື່ສາຂາ, ຕື່ມຂໍ້ຄວາມບັນທຶກດ້ວຍຂໍ້ຄວາມລາຍລະອຽດສາຂາ
ທີ່ກ່ຽວຂ້ອງກັບເຂົາເຈົ້າ. ຄ່າເລີ່ມຕົ້ນເປັນຜິດ.
merge.log
ນອກເໜືອໄປຈາກຊື່ສາຂາ, ຕື່ມຂໍ້ມູນບັນທຶກດ້ວຍຂໍ້ຄວາມທີ່ລະບຸໄວ້ຫຼາຍທີ່ສຸດ
ຈໍານວນຄໍາອະທິບາຍຫນຶ່ງແຖວຈາກຄໍາຫມັ້ນສັນຍາຕົວຈິງທີ່ກໍາລັງຖືກລວມເຂົ້າກັນ.
ຄ່າເລີ່ມຕົ້ນເປັນ false, ແລະ true ແມ່ນຄໍາສັບຄ້າຍຄືສໍາລັບ 20.
merge.renameLimit
ຈໍານວນຂອງໄຟລ໌ທີ່ຈະພິຈາລະນາໃນເວລາທີ່ປະຕິບັດການຊອກຫາການປ່ຽນຊື່ໃນລະຫວ່າງການລວມ; ຖ້າ
ບໍ່ໄດ້ລະບຸໄວ້, ຄ່າເລີ່ມຕົ້ນເປັນຄ່າຂອງ diff.renameLimit.
merge.renormalize
ບອກ Git ວ່າການເປັນຕົວແທນ canonical ຂອງໄຟລ໌ໃນ repository ໄດ້ມີການປ່ຽນແປງ
ເວລາ (ເຊັ່ນ: ກ່ອນຫນ້ານີ້ commits ບັນທຶກໄຟລ໌ທີ່ມີ CRLF line endings, ແຕ່ບໍ່ດົນມານີ້
ໃຊ້ LF line endings). ໃນບ່ອນເກັບມ້ຽນດັ່ງກ່າວ, Git ສາມາດປ່ຽນຂໍ້ມູນທີ່ບັນທຶກໄວ້ໃນ
ຄໍາຫມັ້ນສັນຍາກັບຮູບແບບ canonical ກ່ອນທີ່ຈະປະຕິບັດການຜະສົມຜະສານເພື່ອຫຼຸດຜ່ອນຄວາມຂັດແຍ້ງທີ່ບໍ່ຈໍາເປັນ.
ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ, ເບິ່ງພາກສ່ວນ "ການລວມສາຂາທີ່ແຕກຕ່າງກັນ checkin/checkout
ຄຸນລັກສະນະ" ໃນ gitattributes(5).
merge.stat
ວ່າຈະພິມ diffstat ລະຫວ່າງ ORIG_HEAD ແລະຜົນການລວມຢູ່ໃນຕອນທ້າຍຂອງ
ຮວມ. ຖືກຕ້ອງຕາມຄ່າເລີ່ມຕົ້ນ.
merge.ເຄື່ອງມື
ຄວບຄຸມວ່າຈະໃຊ້ເຄື່ອງມືການຮວມຕົວໃດ git-mergetool(1). ບັນຊີລາຍຊື່ຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນທີ່ຖືກຕ້ອງ
ຄຸນຄ່າໃນຕົວ. ຄ່າອື່ນໃດຖືກຖືວ່າເປັນເຄື່ອງມືການຮວມແບບກຳນົດເອງ ແລະຮຽກຮ້ອງໃຫ້ a
mergetool ທີ່ສອດຄ້ອງກັນ. ຕົວແປ .cmd ຖືກກໍານົດ.
· araaxis
· bc
· bc3
· codecompare
· deltawalker
· diffmerge
· ກະຈາຍ
· ລຸກຂຶ້ນ
· ອອກມາ
· gvimdiff
· gvimdiff2
· gvimdiff3
· kdiff3
· ຮ້ອນ
· opendiff
· p4 ລວມ
· tkdiff
· ເຕົ່າ
· vimdiff
· vimdiff2
· vimdiff3
· winmerge
· xxdiff
merge.verbosity
ຄວບຄຸມປະລິມານຜົນຜະລິດທີ່ສະແດງໂດຍຍຸດທະສາດການລວມກັນ recursive. ລະດັບ 0 ຜົນໄດ້ຮັບ
ບໍ່ມີຫຍັງຍົກເວັ້ນຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດສຸດທ້າຍຖ້າຂໍ້ຂັດແຍ່ງຖືກກວດພົບ. ລະດັບ 1 ຜົນໄດ້ຮັບເທົ່ານັ້ນ
ຂໍ້ຂັດແຍ່ງ, 2 ຜົນໄດ້ຮັບຂໍ້ຂັດແຍ່ງແລະການປ່ຽນແປງໄຟລ໌. ລະດັບ 5 ແລະສູງກວ່າອອກການດີບັກ
ຂໍ້ມູນ. ຄ່າເລີ່ມຕົ້ນແມ່ນລະດັບ 2. ສາມາດ overridden ໂດຍ GIT_MERGE_VERBOSITY
environment variable
ຮວມ. .ຊື່
ກຳນົດຊື່ທີ່ມະນຸດສາມາດອ່ານໄດ້ສຳລັບຕົວຂັບຮວມລະດັບຕໍ່າແບບກຳນົດເອງ. ເບິ່ງ
gitattributes(5) ສໍາລັບລາຍລະອຽດ.
ຮວມ. .ຄົນຂັບລົດ
ກໍານົດຄໍາສັ່ງທີ່ປະຕິບັດໄດເວີການລວມລະດັບຕ່ໍາທີ່ກໍາຫນົດເອງ. ເບິ່ງ
gitattributes(5) ສໍາລັບລາຍລະອຽດ.
ຮວມ. .ຊ້ຳ
ຕັ້ງຊື່ໄດເວີການຜະສົມລະດັບຕໍ່າເພື່ອໃຊ້ໃນເວລາທີ່ດໍາເນີນການປະສົມປະສານພາຍໃນລະຫວ່າງ
ບັນພະບຸລຸດທົ່ວໄປ. ເບິ່ງ gitattributes(5) ສໍາລັບລາຍລະອຽດ.
ສາຂາ. .mergeOptions
ກໍານົດທາງເລືອກເລີ່ມຕົ້ນສໍາລັບການລວມເຂົ້າເປັນສາຂາ . syntax ແລະທາງເລືອກທີ່ສະຫນັບສະຫນູນ
ແມ່ນຄືກັນກັບຂອງ ໄປ ລວມ, ແຕ່ຄ່າທາງເລືອກທີ່ປະກອບດ້ວຍຕົວອັກສອນຊ່ອງຫວ່າງ
ປະຈຸບັນບໍ່ຮອງຮັບ.
ໃຊ້ git-merge ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
