ఈ పేజీలో

`git init` తో Git రిపాజిటరీని ఎలా ప్రారంభించాలి

సంక్షిప్త సమాధానం: ప్రాజెక్ట్ డైరెక్టరీలో git init నడిపితే స్థానిక Git రిపాజిటరీ తయారవుతుంది. ఇది దాచిన .git/ డైరెక్టరీని సృష్టిస్తుంది; కానీ ఫైళ్లను stage చేయదు, commit చేయదు, GitHub రిపాజిటరీని సృష్టించదు లేదా ఏదీ upload చేయదు.

ఈ పేజీలో ఉపయోగించిన డిఫాల్ట్‌లు: ఇక్కడ చూపిన output, Git యొక్క default SHA-1 object format మరియు default files reference backend ఉపయోగించే రిపాజిటరీ నుంచి వచ్చింది. అందుకే .git/objects/ తో పాటు .git/refs/heads/ కనిపిస్తాయి. git init --object-format=sha256 మరియు git init --ref-format=reftable ఈ రెండు వివరాలను మార్చుతాయి; అయితే ఇక్కడ వివరించిన మొత్తం layout మారదు.

సింటాక్స్

git init                  # initialise the current directory
git init <directory>      # create the directory, then initialise it
git init --bare <dir>     # create a repository with no working tree
git init -b main          # set the initial branch name

Git రిపాజిటరీని ఎలా ప్రారంభించాలి

కొత్త ప్రాజెక్ట్ కోసం ఒక folder తయారు చేసి, దాన్ని initialize చేసి, ఒక ఫైలును stage చేసి commit చేయండి:

mkdir my-project
cd my-project
git init -b main
echo "# My project" > README.md
git add README.md
git commit -m "Initial commit"

మీకు ఇప్పటికే ప్రాజెక్ట్ ఉంటే, కొత్త ఫోల్డర్ సృష్టించకుండా దాని రూట్ నుంచి git init నడపండి. ఈ ఫీచర్ ఉన్న Git వెర్షన్లలో git init -b main ప్రారంభ బ్రాంచ్ పేరును సెట్ చేస్తుంది; సాధారణ git init మీరు కాన్ఫిగర్ చేసిన డిఫాల్ట్‌ను ఉపయోగిస్తుంది. మీరు git addతో ఫైళ్లను స్టేజ్ చేసి, git commitతో కమిట్ నమోదు చేసే వరకు Git ఫైళ్లను ట్రాక్ చేయదు. Git మీ రచయిత వివరాలను అడిగితే, git config గైడ్ చూడండి. రిపాజిటరీని తర్వాత పబ్లిష్ చేయాలంటే, git remoteతో రిమోట్ జోడించి, pushను విడిగా చేయండి.

ఇప్పటికే ఉన్న ప్రాజెక్ట్ ఫోల్డర్‌లో నడిపినప్పుడు, git init .git/లో రిపాజిటరీ మెటాడేటాను సృష్టిస్తుంది లేదా రిఫ్రెష్ చేస్తుంది; ఇది మీ ప్రాజెక్ట్ ఫైళ్లను స్టేజ్ చేయదు లేదా కమిట్ చేయదు. git init <directory> లక్ష్య డైరెక్టరీ లేకపోతే దాన్ని కూడా సృష్టిస్తుంది, మరియు రిపాజిటరీని మళ్లీ ఇనిషియలైజ్ చేస్తే మెటాడేటా లేదా హుక్ టెంప్లేట్లు రిఫ్రెష్ కావచ్చు. ఆ తర్వాత సాధారణ క్రమం — git addతో ఫైళ్లను స్టేజ్ చేయండి, తర్వాత git commitతో మొదటి స్నాప్‌షాట్‌ను నమోదు చేయండి.

`git init` నిజంగా ఏమి చేస్తుంది?

మూలంగా చూస్తే, కంప్యూటర్ filesystem చాలా సరళమైనది: అది filenames, file contents, file sizes, directory hierarchies‌ను track చేస్తుంది. మార్పుల చరిత్ర, author identities లేదా branching paths గురించి దానికి సహజమైన అవగాహన ఉండదు.

మీరు ఒక folderలో git init నడిపినప్పుడు, Git దాచిన .git/ డైరెక్టరీలో స్థానిక repository database‌ను సృష్టిస్తుంది. మీకు ఇప్పటికే ఉన్న ఫైళ్లు మారవు: అవి stage లేదా commit కావు, remote server‌ను సంప్రదించదు.

మీరు git status వంటి commands నడిపినప్పుడు Git working treeని repository stateతో పోలుస్తుంది. git init background watcherను ప్రారంభించదు, ఫైళ్లను track చేయదు; పని నమోదు చేయడానికి git add, git commit ఉపయోగించండి.

`.git/` లోపల ఏమి జరుగుతుంది (చేతితో పరిశీలన)

Git ఎలా పనిచేస్తుందో అర్థం చేసుకోవాలంటే .git/ డైరెక్టరీ లోపల చూడాలి. కొత్త repositoryని initialize చేసి, Git అంతర్గత database యొక్క ప్రాథమిక నిర్మాణాన్ని పరిశీలిద్దాం.

దశ 1: డైరెక్టరీని initialize చేయండి

మొదట కొత్త directory సృష్టించి initialize చేయండి:

కింద shell outputలోని paths, timestamps, ownership, permissions, exact messages operating system, Git version, user, configurationను బట్టి మారవచ్చు; వీటిని ఉదాహరణలుగా మాత్రమే చూడండి.

$ mkdir git-init-deepdive && cd git-init-deepdive
$ git init
Initialized empty Git repository in /home/admin/Code/git-init-deepdive/.git/

ఇప్పుడు కొత్తగా సృష్టించిన .git/ folderలోని contents‌ను జాబితా చేద్దాం:

$ ls -al .git/
total 32
drwxr-xr-x 7 admin admin 4096 Jul  7 10:25 .
drwxr-xr-x 3 admin admin 4096 Jul  7 10:25 ..
-rw-r--r-x 1 admin admin   23 Jul  7 10:25 HEAD
-rw-r--r-x 1 admin admin   92 Jul  7 10:25 config
-rw-r--r-x 1 admin admin   73 Jul  7 10:25 description
drwxr-xr-x 2 admin admin 4096 Jul  7 10:25 hooks
drwxr-xr-x 2 admin admin 4096 Jul  7 10:25 info
drwxr-xr-x 4 admin admin 4096 Jul  7 10:25 objects
drwxr-xr-x 4 admin admin 4096 Jul  7 10:25 refs

కొత్తగా initialized repositoryలో వీటిలో ప్రతి entry ఏమి చేస్తుందో చూద్దాం:

1. `HEAD` (ప్రస్తుతం చురుకైన pointer)

HEAD file ప్రస్తుతం activeగా ఉన్న branch లేదా commit ఏదో Gitకు చెబుతుంది. ఈ file contentsను చదుద్దాం:

$ cat .git/HEAD
ref: refs/heads/main

ఈ outputలో HEAD, refs/heads/main వద్ద ఉన్న reference fileను సూచిస్తున్నట్లు తెలుస్తుంది.

అయితే మన repository లోపల branch file refs/heads/main ఇంకా లేదు!

$ ls -R .git/refs
.git/refs:
heads/  tags/

.git/refs/heads:
# Empty!

ఈ స్థితిని Unborn Branch అంటారు. Git HEAD ను ప్రారంభ branch target (ఉదాహరణకు, main)కు చూపిస్తుంది; కానీ మొదటి commit వరకు branch referenceను సృష్టించదు. ఈ పేజీలోని SHA-1 ఉదాహరణలో refలో 40-hex-character object ID ఉంటుంది; SHA-256 repository వేరే ID lengthను ఉపయోగిస్తుంది.

2. `config` (స్థానిక configuration settings)

ఈ file system-level మరియు global configurationsను override చేసే repository-level settingsను కలిగి ఉంటుంది (git config వివరాలు చూడండి). ప్రారంభ settingsను చూద్దాం:

$ cat .git/config
[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true

ఈ core variables Git filesystemతో ఎలా పనిచేయాలో నిర్వచిస్తాయి:

repositoryformatversion = 0: repository database format versionను నిర్వచిస్తుంది. Gitకు మద్దతు ఉన్నదానికంటే ఎక్కువ version కనిపిస్తే, దాన్ని చదవడానికి నిరాకరిస్తుంది.
filemode = true: POSIX file executable bitలోని మార్పులను Git track చేయాలని చెబుతుంది (ఉదా., chmod +x ద్వారా scriptను executableగా మార్చితే).
bare = false: diskలో checked-out files ఉన్న సాధారణ working repository అని ప్రకటిస్తుంది. “bare” repositoryలో Git administrative directory మాత్రమే ఉంటుంది (సాధారణంగా remote hosting servers కోసం), మరియు ఇది trueగా ఉంటుంది.
logallrefupdates = true: reflogను నిర్వహించమని చెబుతుంది (branch tips మరియు HEAD కాలక్రమంలో ఎక్కడికి చూపించాయో నమోదు చేసే వివరమైన చరిత్ర, .git/logs/లో నిల్వ అవుతుంది).

3. `description` (పాత Web helper)

ఇది Unnamed repository; edit this file 'description' to name the repository. అనే placeholder ఉన్న plain text file. GitWeb (పాత web-based viewer) దీన్ని ఉపయోగిస్తుంది. ఆధునిక developmentలో ఈ fileను పట్టించుకోకపోవచ్చు; అలాగే ఉంచినా లేదా సురక్షితంగా delete చేసినా సమస్య లేదు.

4. `hooks/` (lifecycle automation)

Git events (ఉదా., pre-commit, commit-msg, pre-push) జరిగినప్పుడు tasksను automate చేసే shell script templates ఈ folderలో ఉంటాయి. Initialization సమయంలో ఇవి మీ system installation యొక్క templates directory నుంచి copy అవుతాయి. డిఫాల్ట్‌గా ఈ directoryలోని scripts అన్నీ .sampleతో ముగుస్తాయి; అందువల్ల అవి execute కావు. Hookను activate చేయాలంటే .sample extensionను తీసివేసి scriptను executableగా చేయండి (chmod +x).

5. `info/exclude` (స్థానికంగా మాత్రమే ఉండే ignore list)

.gitignore fileలాగే ignore patterns నిర్వచించడానికి ఈ file ఉపయోగపడుతుంది. అయితే .gitignore commit చేసి teamతో share చేస్తారు; info/exclude మాత్రం local-only. ఇతర developers environmentsపై ప్రభావం లేకుండా, మీ local machineకు ప్రత్యేకమైన filesను (ఉదా., local IDE configurations) ignore చేయడానికి దీన్ని ఉపయోగించండి.

6. `objects/` (object database)

ఇదే మీ repository యొక్క ప్రధాన storage database. Content-addressable storageను ఉపయోగించి objectsను ఇలా వర్గీకరించి నిల్వ చేస్తుంది:

Blobs: file contentsను నిల్వ చేస్తాయి.
Trees: directory hierarchiesను నిల్వ చేస్తాయి.
Commits: trees మరియు parentsను సూచించే metadata snapshots. ప్రారంభంలో databaseలో రెండు ఖాళీ subdirectories మాత్రమే ఉంటాయి: info/, pack/ (packfile indexes మరియు storage optimization కోసం). మీరు మొదటి commit చేసే వరకు database ఖాళీగానే ఉంటుంది.

7. `refs/` (references)

ఈ directory మీ repository commit pointersకు indexలా పనిచేస్తుంది. ఇందులో ఇవి ఉంటాయి:

refs/heads/: local branch pointersను ఉంచుతుంది.
refs/tags/: tagsను ఉంచుతుంది (చారిత్రక commitsకు స్థిరమైన pointers).
refs/remotes/: remote repositoriesలోని branches స్థితిని track చేసే pointersను ఉంచుతుంది (remote add చేసిన తర్వాత సృష్టించబడుతుంది).

వివరణాత్మక కమాండ్ ఎంపికలు మరియు అధునాతన వినియోగం

1. ఇప్పటికే ఉన్న repositoryని మళ్లీ initialize చేయడం

ఇప్పటికే Git repositoryగా ఉన్న directoryలో git init నడిపితే ఏమవుతుంది?

$ git init
Reinitialized existing Git repository in /home/admin/Code/git-init-deepdive/.git/

ఇప్పటికే ఉన్న repositoryపై git init నడపడం సురక్షితం. ఇది మీ commits, branches, index లేదా configuration filesను overwrite చేయదు. బదులుగా directoryని తనిఖీ చేసి, అనుకోకుండా తొలగిపోయిన metadata foldersను సరిచేస్తుంది; system యొక్క template directory నుంచి updated hook templatesను కూడా తీసుకుంటుంది.

2. Bare repositories (`git init --bare`)

సాధారణ రిపాజిటరీలో, చెక్అవుట్ చేసిన ప్రాజెక్ట్ ఫైళ్లు .git/ డైరెక్టరీ పక్కన ఉన్న వర్కింగ్ ట్రీలో ఉంటాయి. బేర్ రిపాజిటరీలో చెక్అవుట్ చేసిన వర్కింగ్ ట్రీ ఉండదు: రిపాజిటరీ Git డైరెక్టరీయే టాప్-లెవల్ డైరెక్టరీ అవుతుంది. బేర్ రిపాజిటరీలను సాధారణంగా సహచరులు push, clone చేసే భాగస్వామ్య రిమోట్‌లుగా ఉపయోగిస్తారు.

# Initialize a bare repository
$ git init --bare my-project.git
Initialized empty Git repository in /home/admin/Code/my-project.git/

Bare repository directory structureను చూద్దాం:

$ ls -F my-project.git
HEAD  config  description  hooks/  info/  objects/  refs/

ఇక్కడ .git/ సబ్‌డైరెక్టరీ లేదు, చెక్అవుట్ చేసిన ప్రాజెక్ట్ ఫైల్ కూడా లేదు; ఈ ఎంట్రీలే రిపాజిటరీ. రోజువారీ పని కోసం బేర్ రిపాజిటరీని సాధారణ వర్కింగ్ రిపాజిటరీలోకి clone చేయండి. git init --bare ఖాళీ రిపాజిటరీని ప్రారంభిస్తుంది—మీకు ఇప్పటికే ఉన్న ప్రాజెక్ట్ కమిట్లను కాపీ చేయదు. ఇప్పటికే ఉన్న చరిత్రతో బేర్ కాపీ కావాలంటే, బదులుగా git clone --bare <source> <target>.git ఉపయోగించండి. అధికారిక git init మాన్యువల్ మరియు Pro Git Gitను సర్వర్‌పై ఇన్‌స్టాల్ చేయడం గైడ్ చూడండి.

3. ప్రారంభ branch పేరును సెట్ చేయడం

చారిత్రకంగా Git ప్రాథమిక branchను masterగా initialize చేసేది. ఆధునిక naming conventionsను అనుసరించేందుకు initialization సమయంలో default branch పేరును ఇవ్వవచ్చు:

# Initialize a repository with a default branch named "main"
$ git init --initial-branch=main

ఈ default branch పేరు globally కూడా సెట్ చేయవచ్చు. అప్పుడు భవిష్యత్తులోని అన్ని git init commands దాన్ని వర్తింపజేస్తాయి (git config చూడండి):

$ git config --global init.defaultBranch main

వాస్తవ ప్రపంచ సందర్భం: శుభ్రమైన repository ఏర్పాటు

కొత్త projectను initialize చేసి, మొదటి commit నమోదు చేయడానికి ముందు సాధారణ settingsతో configure చేద్దాం.

దశ 1: Project directoryని సృష్టించి Gitను initialize చేయండి

$ mkdir team-portal && cd team-portal
$ git init --initial-branch=main
Initialized empty Git repository in /home/admin/Code/team-portal/.git/

దశ 2: Git configurationsను ఏర్పాటు చేయండి

మీ commits team identityకి సరిపోతున్నాయో నిర్ధారించడానికి local user configurationsను verify చేయండి:

$ git config --local user.name "Alex Developer"
$ git config --local user.email "alex@portalproject.com"

దశ 3: Ignore rulesను నిర్వచించండి

Temporary files లేదా system caches track కాకుండా .gitignore fileను సృష్టించండి:

$ echo "node_modules/" > .gitignore
$ echo ".DS_Store" >> .gitignore
$ echo "*.log" >> .gitignore

దశ 4: ప్రారంభ codeను రాసి మొదటి commitను నమోదు చేయండి

ఒక file సృష్టించి, stage చేసి commit నమోదు చేయండి:

$ echo "<h1>Team Portal</h1>" > index.html
$ git add .
$ git commit -m "chore: initial repository layout"
[main (root-commit) f23c92e] chore: initial repository layout
 2 files changed, 4 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 index.html

ఇప్పుడు commit నమోదు చేసినందున .git/refs/heads/main లోపల చూద్దాం:

$ cat .git/refs/heads/main
f23c92e10db526ab1a9db3f28249a02ce5c144e1

Unborn branch స్థితి పరిష్కరించబడింది. ఈ SHA-1/files-backend ఉదాహరణలో refs/heads/main పై చూపిన illustrative commit IDను సూచిస్తుంది; repository contents మరియు commit metadataను బట్టి exact object IDs మారతాయి.

సాధారణ సమస్యలు మరియు పొరపాట్లు

1. అనుకోకుండా nested repositories సృష్టించడం

పొరపాటు: ఇప్పటికే Git repository track చేస్తున్న folderలోని subdirectoryలో git init నడపడం.

/my-project/ (.git/ exists)
  └── /src/
        └── /components/ (runs git init here)

ఇది ఎందుకు సమస్య: ఆ subdirectory ప్రత్యేక repository అవుతుంది. Parent దాన్ని సాధారణంగా untracked directoryగా చూస్తుంది (ignore చేయకపోతే); inner repository historyని అది స్వయంగా కలుపుకోదు. Submoduleకు explicit configuration అవసరం. పరిష్కారం: initialize చేయడానికి ముందు ప్రస్తుత directory ఏ repositoryలో ఉందో తనిఖీ చేయండి:

# This prints the root of the current repository, if there is one.
$ git rev-parse --show-toplevel

పొరపాటున nested repository సృష్టిస్తే, దాని .git/ directoryని తొలగించడం వల్ల files parent working treeలో ordinary filesగా మారతాయి; అయితే nested repository history మరియు metadata శాశ్వతంగా తొలగిపోతాయి. Delete చేయడానికి ముందు exact pathను verify చేయండి:

$ rm -rf path/to/nested-project/.git

2. మీ system home directoryలో initialize చేయడం

పొరపాటు: మీ terminal default pathలో (ఉదా., C:\Users\Username\ లేదా /home/username/) అనుకోకుండా git init నడపడం. ఇది ఎందుకు సమస్య: desktop files, downloads, applications, system caches సహా మీ computerలోని ప్రతి fileను Git track చేయడానికి ప్రయత్నిస్తుంది. దీనివల్ల terminal నెమ్మదించి commit conflicts వస్తాయి. పరిష్కారం: మీ home directoryలోని అనుకోకుండా సృష్టించిన .git folderను కనుగొని delete చేయండి:

# Navigate to home and delete the hidden .git directory
$ cd ~
$ rm -rf .git

(జాగ్రత్త: చెల్లుబాటయ్యే project history తొలగిపోకుండా rm -rf .git నడపడానికి ముందు మీరు home directoryలోనే ఉన్నారని రెండుసార్లు తనిఖీ చేయండి.)

3. Database objectsను చేతితో మార్చడం

పొరపాటు: repository సమస్యను పరిష్కరించడానికి .git/objects/ లేదా .git/refs/ లోని filesను చేతితో మార్చడం, rename చేయడం లేదా రాయడం. ఇది ఎందుకు సమస్య: Git object database exact cryptographic hashingపై ఆధారపడి ఉంటుంది. object fileలో ఒక్క character మార్చినా hash corrupt అయి repository చదవలేనిదవుతుంది. పరిష్కారం: .git/ లోని filesను నేరుగా edit చేయకుండా repository contentsతో పని చేయడానికి Git command-line APIను ఉపయోగించండి.

కమాండ్ల త్వరిత సూచన

Command	Action	Common Context
`git init`	సాధారణ Git repositoryని initialize చేస్తుంది	project rootలో ఒకసారి నడపండి
`git init --bare`	working directory లేకుండా repositoryని initialize చేస్తుంది	Remote servers / shared hubs
`git init -b <name>`	custom default branch పేరును నిర్దేశిస్తుంది	పాత `master` branch namingకు ప్రత్యామ్నాయం
`git init --template=<dir>`	custom hook templatesతో repoని initialize చేస్తుంది	team hooksను standardize చేయడానికి
`rm -rf .git`	project trackingను ఆపి, మొత్తం local historyని delete చేస్తుంది	Warning: Destructive and irreversible

తరచుగా అడిగే ప్రశ్నలు

`git init` ఏమి చేస్తుంది?

git init ప్రస్తుత directoryని .git/ subdirectory సృష్టించడం ద్వారా Git repositoryగా మారుస్తుంది. ఆ directoryలో object database, branch references, local configuration ఉంటాయి. ఇది commitను సృష్టించదు, ఇప్పటివరకు ఏ fileనూ track చేయదు, serverను సంప్రదించదు. Historyలో ఏదైనా నమోదు కావాలంటే ఇంకా git add, git commit అవసరం.

`git init` నా codeను GitHubకు upload చేస్తుందా?

లేదు. git init పూర్తిగా మీ computer storageపైనే పనిచేసే local command. ఇది మీ directoryలో local version databaseను initialize చేస్తుంది కానీ internetకు connect అవదు, external hostsతో link చేయదు. మీ codeను GitHubకు upload చేయాలంటే GitHubలో remote repository సృష్టించి, స్థానికంగా git remote add తో link చేసి, మీ commitsను push చేయాలి.

`git init`ను ఎలా undo చేయాలి?

Project నుంచి Git trackingను తొలగించాలంటే దాచిన .git/ folderను delete చేయండి. దీనివల్ల commits history, branches, configuration settings, stashes అన్నీ తొలగిపోతాయి. మీ working files diskపై అలాగే ఉంటాయి, కానీ ఇక track కావు:

$ rm -rf .git

standard మరియు bare Git repository మధ్య తేడా ఏమిటి?

Standard Git repositoryలో files working copy పక్కనే .git/ folder ఉంటుంది; అందువల్ల మీరు స్థానికంగా edit చేసి commit చేయవచ్చు. Bare repositoryలో rootలో నేరుగా Git database files మాత్రమే ఉంటాయి (.git/ folder ఉండదు), working directory ఉండదు. Push చేసిన commitsను సురక్షితంగా నిల్వ చేయడానికి bare repositories remote serversలో ఉపయోగిస్తారు.

`.git` folder defaultగా ఎందుకు hiddenగా ఉంటుంది?

దాని contents అనుకోకుండా modify, move లేదా delete కాకుండా .git/ directory defaultగా hiddenగా ఉంటుంది. మొత్తం version history ఈ folderలోనే నిల్వ ఉంటుంది కాబట్టి దాన్ని delete చేస్తే repository మొత్తం history తొలగిపోతుంది.

మీ జ్ఞానాన్ని పరీక్షించుకోండి

క్విజ్ లోడ్ అవుతోంది…

git init తో Git రిపాజిటరీని ఎలా ప్రారంభించాలి