Merging એક શાખાથી બીજી શાખામાં પરિવર્તનોને જોડે છે — સામાન્ય રીતે પૂર્ણ કરેલી feature branch ને મુખ્ય શાખામાં પાછું લાવે છે. Git મોટાભાગની merges આપોઆપ હેન્ડલ કરે છે, પરંતુ merge પ્રકારો અને conflicts ને સમજવું મહત્વપૂર્ણ છે.
git switch main # be on the branch you want to merge INTO
git merge feature-x # merge feature-x's changes into main
તમે branch (જે પરિવર્તનો પ્રાપ્ત કરે છે) પર સ્વિચ કરો અને branch ને તેમાં merge કરો.
FAST-FORWARD merge → if main hasn't changed since the branch was created, Git just
MOVES main's pointer forward to the branch's latest commit (no merge commit, linear)
MERGE COMMIT (three-way merge) → if BOTH branches have new commits, Git creates a new
"merge commit" combining them (has two parents) → preserves that a merge happened
→ git merge --no-ff forces a merge commit even when fast-forward is possible
Git જ્યારે શક્ય હોય ત્યારે fast-forward કરે છે (સરળતાથી pointer આગળ વધારે છે) અથવા merge commit બનાવે છે (બે parents સાથે) જ્યારે બંને branches અલગ થઈ ગયા હોય.
A CONFLICT happens when both branches changed the SAME lines differently — Git can't
auto-decide which to keep, so it asks YOU to resolve:
<<<<<<< HEAD
the version from the current branch (main)
=======
the version from the branch being merged (feature-x)
>>>>>>> feature-x
# resolve: edit the file to the desired result, remove the markers, then:
git add <file> # mark the conflict resolved
git commit # complete the merge
# git merge --abort # or cancel the merge entirely
Conflicts ત્યારે થાય છે જ્યારે બંને branches સમાન લીટીઓમાં ફેરફાર કરે છે — Git તેમને માર્ક કરે છે અને તમે મેનુয়ালી સાચું પરિણામ પસંદ કરો, પછી stage અને commit કરો.
Merging સમજવું આવશ્યક છે કારણ કે branch changes ને જોડવું એ સહયોગી Git workflows નો મૌલિક, સતત ભાગ છે, તેથી કેવી રીતે કામ કરે છે તે જાણવું (conflicts સહિત) રોજિંદું જરૂરી જ્ઞાન છે. Merging એ છે કે કેવી રીતે પૂર્ણ કર્યું કામ (સામાન્ય રીતે feature branches) મુખ્ય branch માં પાછું એકીભૂત થાય છે — પરિવર્તનોને એક સાથે લાવવાનું રૂટીન કાર્ય જે ટીમ ડેવલપમેન્ટમાં સતત થાય છે.
fast-forward merge (Git સરળતાથી pointer આગળ વધારે છે જ્યારે target અલગ થયું નથી, ઇતિહાસ રેખીય રાખે છે) અને merge commit (three-way merge જે નવો commit બે parents સાથે બનાવે છે જ્યારે બંને branches નો નવા commits હોય, રેકોર્ડ કરે છે કે merge થયું) વચ્ચેનો તફાવત સમજવું સ્પષ્ટ કરે છે કે Git કેવી રીતે changes એકીભૂત કરે છે અને પરિણામી ઇતિહાસ કેવો લાગે છે.
Most importantly, understanding merge conflicts — which occur when both branches change the same lines differently, so Git can't automatically decide and asks you to resolve — is crucial practical knowledge: conflicts are a normal, inevitable part of collaboration, and knowing how to recognize the conflict markers (<<<<<<<, =======, >>>>>>>), edit the file to the correct result, and complete the merge (stage and commit) is an essential skill that's often a source of anxiety for those who don't understand it.
Since integrating branch changes via merging is fundamental and constant in collaborative development, and since understanding merge types and especially resolving conflicts is necessary to combine work correctly (a routine, unavoidable task), understanding how merging works — basic merges, fast-forward vs merge commits, and conflict resolution — is essential, frequently-applied Git knowledge, a core skill for collaboration where conflict resolution in particular is a practical necessity every developer must handle confidently.