इस पेज पर

`git init` से Git रिपॉजिटरी कैसे शुरू करें

संक्षिप्त उत्तर: किसी प्रोजेक्ट डायरेक्टरी से स्थानीय Git रिपॉजिटरी बनाने के लिए git init चलाएँ। यह एक छिपी हुई .git/ डायरेक्टरी बनाता है, लेकिन फाइलों को स्टेज नहीं करता, कमिट नहीं बनाता, GitHub रिपॉजिटरी नहीं बनाता और कुछ भी अपलोड नहीं करता।

इस पेज पर इस्तेमाल किए गए डिफॉल्ट: यहाँ दिखाया गया आउटपुट Git के डिफॉल्ट SHA-1 ऑब्जेक्ट फॉर्मेट और डिफॉल्ट files रेफरेंस बैकएंड वाली रिपॉजिटरी से लिया गया है, इसलिए आपको .git/objects/ और .git/refs/heads/ दिखाई देते हैं। git init --object-format=sha256 और git init --ref-format=reftable इन दोनों विवरणों को बदल देते हैं, लेकिन यहाँ बताए गए समग्र लेआउट को नहीं बदलते।

सिंटैक्स

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 रिपॉजिटरी कैसे शुरू करें

नए प्रोजेक्ट के लिए एक फोल्डर बनाएँ, उसे शुरू करें, फिर किसी फाइल को स्टेज करके कमिट करें:

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 तब तक फाइलों को ट्रैक नहीं करता, जब तक आप git add से उन्हें स्टेज करके git commit से कमिट दर्ज नहीं करते। अगर Git आपसे लेखक का विवरण माँगे, तो git config गाइड देखें। बाद में रिपॉज़िटरी प्रकाशित करने के लिए git remote से रिमोट जोड़ें और push अलग से करें।

किसी मौजूदा प्रोजेक्ट फोल्डर में चलाने पर git init .git/ में रिपॉज़िटरी मेटाडेटा बनाता है या ताज़ा करता है; यह आपकी प्रोजेक्ट फाइलों को स्टेज या कमिट नहीं करता। git init <directory> लक्ष्य डायरेक्टरी न होने पर उसे भी बना देता है, और किसी रिपॉज़िटरी को फिर से शुरू करने पर मेटाडेटा या हुक टेम्पलेट ताज़ा हो सकते हैं। इसके बाद सामान्य क्रम है — git add से फाइलें स्टेज करें, फिर git commit से पहला स्नैपशॉट दर्ज करें।

`git init` वास्तव में क्या करता है?

मूल रूप से, कंप्यूटर का फाइल सिस्टम अपेक्षाकृत सरल होता है: वह फाइलनाम, फाइल की सामग्री, फाइल का आकार और डायरेक्टरी का क्रम रखता है। उसे बदलावों के इतिहास, लेखकों की पहचान या ब्रांचिंग पथों की कोई अंतर्निहित समझ नहीं होती।

जब आप किसी फोल्डर में git init चलाते हैं, तो Git छिपी हुई .git/ डायरेक्टरी में स्थानीय रिपॉजिटरी डेटाबेस बनाता है। आपकी मौजूदा फाइलें अपरिवर्तित रहती हैं: वे न तो स्टेज होती हैं, न कमिट, और किसी रिमोट सर्वर से संपर्क नहीं किया जाता।

जब आप git status जैसे कमांड चलाते हैं, तब Git वर्किंग ट्री की तुलना रिपॉजिटरी की स्थिति से करता है। git init बैकग्राउंड वॉचर शुरू नहीं करता और फाइलों को ट्रैक नहीं करता; काम दर्ज करने के लिए git add और git commit का इस्तेमाल करें।

`.git/` के अंदर क्या होता है (व्यावहारिक पड़ताल)

Git कैसे काम करता है, यह समझने के लिए आपको .git/ डायरेक्टरी के अंदर देखना होगा। आइए एक नई रिपॉजिटरी शुरू करके Git के आंतरिक डेटाबेस का ढाँचा देखें।

चरण 1: डायरेक्टरी शुरू करें

पहले एक नई डायरेक्टरी बनाएँ और उसे शुरू करें:

नीचे दिए गए शेल आउटपुट में पथ, टाइमस्टैंप, स्वामित्व, अनुमतियाँ और सटीक संदेश ऑपरेटिंग सिस्टम, Git वर्जन, उपयोगकर्ता और कॉन्फिगरेशन के अनुसार बदल सकते हैं; इन्हें प्रतिनिधि उदाहरण मानें।

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

अब नई बनी .git/ डायरेक्टरी की सामग्री की सूची देखें:

$ 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

आइए देखें कि नई शुरू की गई रिपॉजिटरी में इनमें से हर एंट्री क्या करती है:

1. `HEAD` (सक्रिय पॉइंटर)

HEAD एक सादी टेक्स्ट फाइल है, जो Git को बताती है कि वर्तमान में कौन-सी ब्रांच या कमिट सक्रिय है। आइए इस फाइल की सामग्री पढ़ें:

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

यह आउटपुट दिखाता है कि HEAD, refs/heads/main की रेफरेंस फाइल की ओर संकेत करता है।

हालाँकि, अगर हम अपनी रिपॉजिटरी के अंदर देखें, तो ब्रांच फाइल refs/heads/main अभी मौजूद नहीं है!

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

.git/refs/heads:
# Empty!

इस स्थिति को Unborn Branch कहा जाता है। Git HEAD को शुरुआती ब्रांच लक्ष्य (जैसे main) की ओर रखता है, लेकिन पहली कमिट होने तक ब्रांच रेफरेंस नहीं बनाता। इस पेज के SHA-1 उदाहरण में रेफ में 40 हेक्साडेसिमल वर्णों वाली ऑब्जेक्ट ID होती है; SHA-256 रिपॉजिटरी में ID की लंबाई अलग होती है।

2. `config` (स्थानीय कॉन्फिगरेशन सेटिंग)

यह फाइल रिपॉजिटरी-स्तर की उन सेटिंग्स को रखती है, जो आपके सिस्टम और ग्लोबल कॉन्फिगरेशन को ओवरराइड करती हैं (विवरण के लिए git config देखें)। आइए शुरुआती सेटिंग्स देखें:

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

ये कोर वैरिएबल तय करते हैं कि Git आपके फाइल सिस्टम के साथ कैसे काम करता है:

repositoryformatversion = 0: रिपॉजिटरी के डेटाबेस फॉर्मेट का वर्जन बताता है। अगर Git को ऐसा रिपॉजिटरी वर्जन मिले, जो उसके समर्थन से नया हो, तो वह उसे पढ़ने से इनकार कर देगा।
filemode = true: Git को POSIX फाइल के एक्जीक्यूटेबल बिट में हुए बदलावों को ट्रैक करने के लिए कहता है (जैसे chmod +x से किसी स्क्रिप्ट को एक्जीक्यूटेबल बनाना)।
bare = false: बताता है कि यह एक मानक वर्किंग रिपॉजिटरी है, जिसमें डिस्क पर चेक-आउट की गई फाइलें होती हैं। एक “bare” रिपॉजिटरी में केवल Git की प्रशासनिक डायरेक्टरी होती है (आमतौर पर रिमोट होस्टिंग सर्वर के लिए) और इसमें यह मान true होता है।
logallrefupdates = true: Git को reflog बनाए रखने का निर्देश देता है (यह इस बात का विस्तृत इतिहास है कि ब्रांच टिप और HEAD समय के साथ कहाँ-कहाँ संकेत करते रहे हैं; यह .git/logs/ में रखा जाता है)।

3. `description` (पुराना वेब हेल्पर)

यह एक सादी टेक्स्ट फाइल है, जिसमें प्लेसहोल्डर Unnamed repository; edit this file 'description' to name the repository. होता है। इसका इस्तेमाल GitWeb (वेब-आधारित पुराना व्यूअर) करता है। आधुनिक विकास में इस फाइल को अनदेखा किया जाता है; इसे सुरक्षित रूप से हटाया जा सकता है या जैसा है वैसा छोड़ा जा सकता है।

4. `hooks/` (लाइफसाइकल ऑटोमेशन)

इस फोल्डर में शेल स्क्रिप्ट के टेम्पलेट होते हैं, जो Git की घटनाओं (जैसे pre-commit, commit-msg और pre-push) के समय काम अपने-आप करते हैं। शुरुआत के दौरान इन टेम्पलेट को आपके सिस्टम इंस्टॉलेशन की टेम्पलेट डायरेक्टरी से कॉपी किया जाता है। डिफॉल्ट रूप से इस डायरेक्टरी की सभी स्क्रिप्ट .sample पर खत्म होती हैं, इसलिए वे चलती नहीं हैं। किसी हुक को सक्रिय करने के लिए .sample एक्सटेंशन हटाएँ और स्क्रिप्ट को एक्जीक्यूटेबल बनाएँ (chmod +x)।

5. `info/exclude` (केवल स्थानीय इग्नोर सूची)

इस फाइल का इस्तेमाल .gitignore जैसी इग्नोर पैटर्न तय करने के लिए होता है। लेकिन .gitignore कमिट होकर आपकी टीम के साथ साझा होती है, जबकि info/exclude केवल स्थानीय होती है। इसका इस्तेमाल अपनी मशीन से जुड़ी फाइलों (जैसे स्थानीय IDE कॉन्फिगरेशन) को अनदेखा करने के लिए करें, ताकि दूसरे डेवलपर के वातावरण पर असर न पड़े।

6. `objects/` (ऑब्जेक्ट डेटाबेस)

यह आपकी रिपॉजिटरी का मुख्य स्टोरेज डेटाबेस है। इसमें ऑब्जेक्ट को कंटेंट-एड्रेसेबल स्टोरेज के जरिए रखा जाता है और वे इन श्रेणियों में बाँटे जाते हैं:

Blobs: फाइलों की संग्रहीत सामग्री।
Trees: डायरेक्टरी का क्रम।
Commits: ट्री और पैरेंट की ओर संकेत करने वाले मेटाडेटा स्नैपशॉट। शुरुआत में डेटाबेस में केवल दो खाली सबडायरेक्टरी होती हैं: info/ और pack/ (जिनका इस्तेमाल packfile इंडेक्स और स्टोरेज ऑप्टिमाइज़ेशन के लिए होता है)। पहली कमिट करने तक डेटाबेस खाली रहता है।

7. `refs/` (रेफरेंस)

यह डायरेक्टरी आपकी रिपॉजिटरी के कमिट पॉइंटरों की इंडेक्स की तरह काम करती है। इसमें ये चीजें होती हैं:

refs/heads/: स्थानीय ब्रांच पॉइंटर रखता है।
refs/tags/: टैग रखता है (ऐतिहासिक कमिट की स्थिर रेफरेंस)।
refs/remotes/: रिमोट रिपॉजिटरी की ब्रांच की स्थिति पर नज़र रखने वाले पॉइंटर रखता है (रिमोट जोड़ने के बाद बनता है)।

कमांड विकल्पों और उन्नत इस्तेमाल का विवरण

1. मौजूदा रिपॉजिटरी को फिर से शुरू करना

अगर आप पहले से Git रिपॉजिटरी वाली डायरेक्टरी में git init चलाएँ, तो क्या होता है?

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

मौजूदा रिपॉजिटरी पर git init चलाना सुरक्षित है। यह आपकी कमिट, ब्रांच, इंडेक्स या कॉन्फिगरेशन फाइलों को ओवरराइट नहीं करता। इसके बजाय, यह डायरेक्टरी की जाँच करता है, गलती से हटा दिए गए मेटाडेटा फोल्डर को ठीक करता है और सिस्टम की टेम्पलेट डायरेक्टरी से अपडेट किए गए हुक टेम्पलेट ले आता है।

2. Bare रिपॉजिटरी (`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 रिपॉजिटरी की डायरेक्टरी संरचना देखें:

$ 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. शुरुआती ब्रांच का नाम सेट करना

ऐतिहासिक रूप से Git मुख्य ब्रांच को master नाम से शुरू करता था। आधुनिक नामकरण अपनाने के लिए आप शुरुआत के दौरान डिफॉल्ट ब्रांच का नाम तय कर सकते हैं:

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

आप इस डिफॉल्ट ब्रांच नाम को ग्लोबली भी सेट कर सकते हैं, ताकि आगे चलने वाले सभी git init कमांड पर यह अपने-आप लागू हो (इसके लिए git config देखें):

$ git config --global init.defaultBranch main

वास्तविक स्थिति: साफ-सुथरी रिपॉजिटरी सेट करना

आइए पहला कमिट दर्ज करने से पहले एक नया प्रोजेक्ट शुरू करें और उसे मानक सेटिंग्स के साथ कॉन्फिगर करें।

चरण 1: प्रोजेक्ट डायरेक्टरी बनाएँ और Git शुरू करें

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

चरण 2: Git कॉन्फिगरेशन तय करें

यह सुनिश्चित करने के लिए अपनी स्थानीय उपयोगकर्ता सेटिंग्स की जाँच करें कि कमिट आपकी टीम की पहचान से मेल खाएँ:

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

चरण 3: इग्नोर नियम तय करें

अस्थायी फाइलों या सिस्टम कैश को ट्रैक होने से रोकने के लिए .gitignore फाइल बनाएँ:

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

चरण 4: शुरुआती कोड लिखें और पहली कमिट दर्ज करें

एक फाइल बनाएँ, उसे स्टेज करें और कमिट दर्ज करें:

$ 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

अब जब एक कमिट दर्ज हो चुकी है, तो .git/refs/heads/main के अंदर देखें:

$ cat .git/refs/heads/main
f23c92e10db526ab1a9db3f28249a02ce5c144e1

Unborn branch की स्थिति खत्म हो गई है। इस SHA-1/files-backend उदाहरण में refs/heads/main ऊपर दिखाई गई उदाहरणात्मक कमिट ID की ओर संकेत करता है; वास्तविक ऑब्जेक्ट ID रिपॉजिटरी की सामग्री और कमिट मेटाडेटा के अनुसार बदलती हैं।

आम समस्याएँ और गलतियाँ

1. गलती से बनी नेस्टेड रिपॉजिटरी

गलती: ऐसी डायरेक्टरी की सबडायरेक्टरी के अंदर git init चलाना, जिसे कोई Git रिपॉजिटरी पहले से ट्रैक कर रही हो।

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

यह समस्या क्यों है: सबडायरेक्टरी एक अलग रिपॉजिटरी बन जाती है। पैरेंट आमतौर पर इसे अनट्रैक की गई डायरेक्टरी के रूप में देखता है (जब तक इसे इग्नोर न किया गया हो); वह अंदर की रिपॉजिटरी का इतिहास अपने-आप नहीं अपनाता। सबमॉड्यूल के लिए स्पष्ट कॉन्फिगरेशन चाहिए। समाधान: शुरू करने से पहले जाँच लें कि मौजूदा डायरेक्टरी को कौन-सी रिपॉजिटरी समेटे हुए है:

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

अगर आपने गलती से नेस्टेड रिपॉजिटरी बना ली है, तो उसकी .git/ डायरेक्टरी हटाने से उसकी फाइलें पैरेंट वर्किंग ट्री में सामान्य फाइल बन जाएँगी, लेकिन नेस्टेड रिपॉजिटरी का इतिहास और मेटाडेटा हमेशा के लिए हट जाएगा। हटाने से पहले सटीक पथ की जाँच करें:

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

2. सिस्टम की होम डायरेक्टरी में शुरुआत करना

गलती: गलती से अपने टर्मिनल के डिफॉल्ट पथ (जैसे C:\Users\Username\ या /home/username/) में git init चला देना। यह समस्या क्यों है: Git आपके कंप्यूटर की हर फाइल को ट्रैक करने की कोशिश करेगा, जिसमें डेस्कटॉप फाइलें, डाउनलोड, एप्लिकेशन और सिस्टम कैश भी शामिल हैं। इससे आपका टर्मिनल धीमा होता है और कमिट में टकराव पैदा होते हैं। समाधान: अपनी होम डायरेक्टरी में बनी गलती वाली .git फोल्डर को ढूँढकर हटाएँ:

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

(सावधानी: rm -rf .git चलाने से पहले दोबारा जाँच लें कि आप अपनी होम डायरेक्टरी में ही हैं, ताकि किसी वैध प्रोजेक्ट का इतिहास न मिटे।)

3. डेटाबेस ऑब्जेक्ट को हाथ से संपादित करना

गलती: रिपॉजिटरी की समस्या ठीक करने के लिए .git/objects/ या .git/refs/ के अंदर की फाइलों को हाथ से बदलने, उनका नाम बदलने या उनमें लिखने की कोशिश करना। यह समस्या क्यों है: Git का ऑब्जेक्ट डेटाबेस सटीक क्रिप्टोग्राफिक हैशिंग पर निर्भर करता है। किसी ऑब्जेक्ट फाइल में एक वर्ण तक बदलने से हैश खराब हो जाएगा और रिपॉजिटरी पढ़ने योग्य नहीं रहेगी। समाधान: .git/ की फाइलों को सीधे संपादित करने के बजाय रिपॉजिटरी की सामग्री के साथ काम करने के लिए Git के कमांड-लाइन API का इस्तेमाल करें।

कमांड क्विक रेफरेंस

कमांड	कार्रवाई	सामान्य संदर्भ
`git init`	मानक Git रिपॉजिटरी शुरू करता है	प्रोजेक्ट रूट पर एक बार चलाएँ
`git init --bare`	वर्किंग डायरेक्टरी के बिना रिपॉजिटरी शुरू करता है	रिमोट सर्वर / साझा हब
`git init -b <name>`	कस्टम डिफॉल्ट ब्रांच नाम तय करता है	पुराने `master` ब्रांच नामकरण का विकल्प
`git init --template=<dir>`	कस्टम हुक टेम्पलेट के साथ रिपॉजिटरी शुरू करता है	टीम के हुक को मानकीकृत करना
`rm -rf .git`	प्रोजेक्ट की ट्रैकिंग हटाता और पूरा स्थानीय इतिहास मिटाता है	चेतावनी: विनाशकारी और अपरिवर्तनीय

अक्सर पूछे जाने वाले सवाल

`git init` क्या करता है?

git init .git/ सबडायरेक्टरी बनाकर मौजूदा डायरेक्टरी को Git रिपॉजिटरी में बदल देता है। इस डायरेक्टरी में ऑब्जेक्ट डेटाबेस, ब्रांच रेफरेंस और स्थानीय कॉन्फिगरेशन रहते हैं। यह कमिट नहीं बनाता, अभी किसी फाइल को ट्रैक नहीं करता और किसी सर्वर से संपर्क नहीं करता। इतिहास में कुछ दर्ज होने से पहले आपको git add और git commit चलाने होंगे।

क्या `git init` मेरा कोड GitHub पर अपलोड करता है?

नहीं। git init एक स्थानीय कमांड है, जो पूरी तरह आपके कंप्यूटर के स्टोरेज पर काम करता है। यह आपकी डायरेक्टरी में स्थानीय वर्जन डेटाबेस शुरू करता है, लेकिन इंटरनेट से कनेक्ट नहीं होता और बाहरी होस्ट से लिंक नहीं करता। अपना कोड GitHub पर अपलोड करने के लिए आपको GitHub पर रिमोट रिपॉजिटरी बनानी होगी, उसे git remote add से स्थानीय रूप से लिंक करना होगा और अपनी कमिट push करनी होंगी।

`git init` को कैसे वापस करें?

किसी प्रोजेक्ट से Git ट्रैकिंग हटाने के लिए छिपी हुई .git/ फोल्डर हटाएँ। इससे पूरा कमिट इतिहास, ब्रांच, कॉन्फिगरेशन सेटिंग्स और stashes हट जाएँगे। आपकी वर्किंग फाइलें डिस्क पर बनी रहेंगी, लेकिन आगे ट्रैक नहीं होंगी:

$ rm -rf .git

मानक और bare Git रिपॉजिटरी में क्या अंतर है?

मानक Git रिपॉजिटरी में आपकी फाइलों की वर्किंग कॉपी के साथ .git/ फोल्डर होता है, जिससे आप स्थानीय रूप से बदलाव संपादित और कमिट कर सकते हैं। Bare रिपॉजिटरी में केवल Git डेटाबेस फाइलें सीधे उसकी रूट में होती हैं (कोई .git/ फोल्डर नहीं) और कोई वर्किंग डायरेक्टरी नहीं होती। Bare रिपॉजिटरी का इस्तेमाल रिमोट सर्वर पर push की गई कमिट को सुरक्षित रूप से रखने के लिए होता है।

`.git` फोल्डर डिफॉल्ट रूप से छिपा क्यों होता है?

.git/ डायरेक्टरी डिफॉल्ट रूप से इसलिए छिपी होती है, ताकि उसकी सामग्री गलती से बदली, स्थानांतरित या हटाई न जाए। चूँकि पूरा वर्जन इतिहास इसी फोल्डर में रखा जाता है, इसे हटाने से रिपॉजिटरी का पूरा इतिहास मिट जाता है।

अपना ज्ञान परखें

क्विज़ लोड हो रही है…

git init से Git रिपॉजिटरी कैसे शुरू करें