Merging ఒక శాఖ నుండి మరొక శాఖకు మార్పులను కలుపుతుంది — సాధారణంగా పూర్తయిన feature branch ను main branch లోకి తిరిగి తెస్తుంది. Git చాలా మార్జ్లను స్వయంచాలకంగా నిర్వహిస్తుంది, కానీ merge types మరియు 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 ను ముందుకు సరిపోతుంది) లేదా రెండు branches విభేదించినప్పుడు merge commit సృష్టిస్తుంది (రెండు parents తో).
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 వాటిని గుర్తించి మరియు మీరు సరైన ఫలితాన్ని manually ఎంచుకుంటారు, ఆపై stage చేసి commit చేస్తారు.
Merging ను అర్థం చేసుకోవడం అవసరం ఎందుకంటే branch మార్పులను కలపడం సహకార Git workflows యొక్క ఒక ప్రాథమిక, నిరంతర భాగం, కాబట్టి ఇది ఎలా పనిచేస్తుందో (conflicts సహా) తెలుసుకోవడం అవసరమైన రోజువారీ జ్ఞానం. Merging ఎలా పూర్తయిన పనిని (సాధారణంగా feature branches) main branch లోకి విలీనం చేయడం — చదువుకున్న పరిస్థితులు కలపడానికి సాధారణ చర్య ఇది team development లో నిరంతరం జరుగుతుంది.
fast-forward merge (Git simply target ను ఎటువంటి విభేదం లేనప్పుడు ఆगే చేస్తుంది, చరిత్ర లను సరళంగా ఉంచుతుంది) మరియు merge commit (రెండు branches కు new commits ఉన్నప్పుడు three-way merge సృష్టిస్తుంది, merge జరిగిందని రికార్డ్ చేస్తుంది) మధ్య వ్యత్యాసం అర్థం చేసుకోవడం Git ఎలా మార్పులను విలీనం చేస్తుందో మరియు ఫలితంగా చరిత్ర ఎలా కనిపిస్తుందో స్పష్టం చేస్తుంది.
సबसे ముఖ్యమైనది, merge conflicts ను అర్థం చేసుకోవడం — ఇవి రెండు branches ఒకే పంక్తులను విభిన్నంగా మార్చినప్పుడు సంభవిస్తాయి, కాబట్టి Git స్వయంచాలకంగా నిర్ణయం చేయలేకపోతుంది మరియు మీరు resolve చేయమనే కోరుకుంటుంది — ఇది కీలక ఆచరణాత్మక జ్ఞానం: conflicts సహకారం యొక్క సాధారణ, అనివార్య భాగం, మరియు conflict markers (<<<<<<<, =======, >>>>>>>) ను గుర్తించడం, ఫైల్ను సరైన ఫలితానికి సవరించడం, మరియు merge ను పూర్తి చేయడం (stage చేసి commit చేయడం) ఒక essential skill ఇది తరచుగా అర్థం చేసుకోని వారికి ఆందోళన యొక్క మూలం.
Branch మార్పులను merging ద్వారా విలీనం చేయడం సహకార development లో ప్రాథమిక మరియు నిరంతరం జరిగే విషయం, మరియు merge types మరియు ప్రత్యేకించి conflicts resolve చేయడం అవసరం పనిని సరిగ్గా కలపడానికి (సాధారణ, తప్పించుకోలేని పని), merging ఎలా పనిచేస్తుందో అర్థం చేసుకోవడం — basic merges, fast-forward vs merge commits, మరియు conflict resolution — essential, frequently-applied Git knowledge, సహకారం కోసం core skill ఇక్కడ conflict resolution ప్రత్యేకించి ఆచరణాత్మక ఆవశ్యకత ప్రతిটి developer నిశ్చయితలో నిర్వహించాలి.