clone, fetch, pull மற்றும் push ஆகியவற்றுக்கு இடையேயான வேறுபாடு என்ன?

Question

Accepted Answer

இந்த நான்கு commands உங்கள் **local** repository மற்றும் **remote** repositories இடையே தரவை நகர்த்துகின்றன, ஆனால் அவை வெவ்வேறு செயல்களைச் செய்கின்றன. வேறுபாடுகளைப் புரிந்துகொள்வது — குறிப்பாக **fetch vs pull** — remotes களுடன் சரியாக வேலை செய்வதற்கு முக்கியமாகும்.

## clone — ஒரு repository ஐ நகல் செய்யவும் (ஒரு முறை)

```bash
git clone <url>
# → creates a LOCAL copy of an entire remote repository (all history + branches)
# → sets up "origin" pointing to the remote; done ONCE to start working on a project
```

`clone` ஒரு complete copy of a remote repository ஐ download செய்து வேலை செய்யத் தொடங்குகிறது — ஒரு project க்கு ஒரு முறை செய்யப்படுகிறது.

## fetch — remote changes ஐ download செய்யவும் (merge செய்யாதீர்கள்)

```bash
git fetch origin
# → downloads new commits/branches from the remote into remote-tracking branches
#   (origin/main, etc.) but does NOT change your working files or current branch
# → SAFE: lets you SEE what's new before integrating it
git log origin/main            # inspect the fetched changes
```

`fetch` remote changes ஐ **merge செய்யாமல்** download செய்கிறது — உங்கள் working files கள் தொடப்படாமல் இருக்கும், integrate செய்வதற்கு முன் inspect செய்ய உங்களை அனுமதிக்கிறது.

## pull — fetch மற்றும் merge

```bash
git pull origin main
# → fetch + merge: downloads remote changes AND merges them into your current branch
# → updates your working files (may cause merge conflicts)
# pull = fetch + merge (or fetch + rebase with --rebase)
```

`pull` `fetch` செய்து பின்னர் உடனடியாக changes ஐ உங்கள் current branch க்கு **merge** செய்கிறது — ஒரு வசதியான combination, ஆனால் இது உங்கள் files களை மாற்றுகிறது (மற்றும் conflict ஆக முடியும்).

## push — உங்கள் commits ஐ upload செய்யவும்

```bash
git push origin main
# → uploads YOUR local commits to the remote (the opposite direction of pull)
# → shares your work; fails if the remote has changes you don't have (pull first)
```

```text
clone → copy a repo (start)      fetch → download (no merge)
pull  → fetch + merge (update)   push  → upload your commits (share)
```

## இது ஏன் முக்கியமாக இருக்கிறது

clone, fetch, pull, மற்றும் push ஆகியவற்றுக்கு இடையேயான வேறுபாட்டைப் புரிந்துகொள்வது **remote repositories களுடன் சரியாக வேலை செய்வதற்கு** முக்கியமாகும், எனவே இது essential practical knowledge ஆக இருக்கிறது — மற்றும் இவை பொதுவாக குழ்வப்படுகின்றன, குறிப்பாக fetch vs pull.

ஒவ்வொன்றும் தனித்துவமான நோக்கத்தை பூரணம் செய்கிறது: **`clone`** ஒரு entire remote repository ஐ வேலை செய்யத் தொடங்க நகல் செய்கிறது (ஒரு முறை செய்யப்படுகிறது), **`fetch`** remote changes ஐ **merge செய்யாமல்** download செய்கிறது (safely உங்களை integration க்கு முன் என்ன புதிய என்பதை inspect செய்ய அனுமதிக்கிறது), **`pull`** fetch செய்து **மற்றும் merge** செய்கிறது (conveniently உங்கள் branch ஐ update செய்கிறது ஆனால் உங்கள் files களை மாற்றுகிறது மற்றும் potentially conflicts ஐ ஏற்படுத்தக்கூடும்), மற்றும் **`push`** உங்கள் commits ஐ upload செய்து உங்கள் வேலையைப் பகிர்ந்துகொள்கிறது.

**fetch vs pull distinction குறிப்பாக முக்கியமாக இருக்கிறது மற்றும் பொதுவாக misunderstand செய்யப்படுகிறது**: `fetch` non-destructive ஆக இருக்கிறது (download செய்கிறது உங்கள் வேலையை தொடாமல், எனவே நீங்கள் முதலில் changes களை review செய்யலாம்), அதேசமயம் `pull` உடனடியாக changes களை உங்கள் working branch க்கு integrate செய்கிறது — இதைப் புரிந்துகொள்வது உங்களை safer `fetch`-then-inspect approach ஐ தேர்வு செய்ய அனுமதிக்கிறது நீங்கள் control விரும்பினால், அதற்கு பதிலாக எப்போதும் blindly pull செய்பவர்களாக இருக்காமல்.

**`push` fail ஆவதை understand செய்வது remote ல் changes இருந்தால் நீங்களிடம் இல்லை** (requiring you to pull first) ஒரு common situation ஐ விளக்குகிறது.

Directions ஐ understand செய்வது (clone/fetch/pull bring changes *in*; push sends changes *out*) local மற்றும் remote க்கு இடையே data flow ஐ clarify செய்கிறது.

Remotes உடன் வேலை செய்வது collaboration க்கு fundamental ஆக இருக்கிறது என்பதிலிருந்து மற்றும் இந்த நான்கு commands ஆகிய்ன local மற்றும் remote repositories க்கு இடையே data ஐ கொண்டு செல்லும் வழி, மற்றும் confusing them க்கு (particularly fetch vs pull) mistakes அல்லது unexpected merges க்கு lead ஆக செய்கிறது, clone, fetch, pull, மற்றும் push ஆகியவற்றுக்கு இடையேயான வேறுபாட்டை understand செய்வது essential, frequently-applied Git knowledge ஆக இருக்கிறது collaborative development க்கு — clarifying the core remote operations every developer uses மற்றும் resolving a commonly-confused distinction (fetch vs pull) that affects how safely you integrate others' changes.