Skip to content
This page has been auto-translated and may contain errors.View in English

फाइलों को अनदेखा करना और अच्छी आदतें

docs.scrimba.com

आप weather-app नाम का एक प्रोजेक्ट क्लोन करते हैं, npm install चलाते हैं, और अपने नए रेपो की स्थिति देखते हैं।

bash
$ git status
Untracked files:
  (use "git add <file>..." to include in what will be committed)
	node_modules/
	dist/
	.env

तीन फोल्डर और फाइलें अनट्रैक्ड के रूप में दिखाई देते हैं, और उनमें से कोई भी कमिट में नहीं होना चाहिए। node_modules/ हजारों फाइलें हैं जो npm install सेकंड में package.json से दोबारा जेनरेट करता है। dist/ बिल्ड आउटपुट है जो हर बार आपके सोर्स से दोबारा बनाया जाता है। और .env एक API कुंजी रखता है। इनमें से कोई भी आपके प्रोजेक्ट के इतिहास में कभी नहीं आना चाहिए, और बिना सोचे-समझे git add . टाइप करना ही है कि यह वैसे भी कैसे होता है।

Git को बताएं कि क्या अनदेखा करना है

एक .gitignore फाइल फाइलों और फोल्डरों के पैटर्न को सूचीबद्ध करती है जिन्हें Git को कभी ट्रैक नहीं करना चाहिए। आप इसे अपने प्रोजेक्ट की रूट में एक बार बनाते हैं, वह स्थान जहां आपने आपका पहला रेपोजिटरी में git init चलाया था, और उसके बाद, git status और git add . चुप्पी से कुछ भी स्किप कर देते हैं जो मेल खाता है।

bash
# .gitignore
node_modules/
dist/
.env

हर पंक्ति एक पैटर्न है: dist/ जैसा एक सादा फोल्डर नाम उस पूरे फोल्डर को अनदेखा करता है, जहां भी यह प्रोजेक्ट में दिखाई दे। .gitignore फाइल को स्वयं कमिट करें। यह छोटी है, यह उन सभी के लिए उपयोगी है जो प्रोजेक्ट को क्लोन करते हैं, और यह आपके सोर्स कोड की तरह इतिहास में है।

bash
$ git status
On branch main
nothing to commit, working tree clean

पैटर्न के साथ, git status चुप हो जाता है। यह बिल्कुल सही है: जिन फोल्डरों और फाइलों को आप कभी कमिट नहीं करना चाहते वे शोर के रूप में दिखाई नहीं देते, इसलिए जो चीजें दिखाई देती हैं वे वास्तव में महत्वपूर्ण हैं।

पैटर्न ग्लोब्स का समर्थन करते हैं, इसलिए *.log हर फाइल को अनदेखा करता है जो .log में समाप्त होता है, इसके नाम की परवाह किए बिना। एक ट्रेलिंग स्लैश एक पैटर्न को निर्देशिका तक सीमित करता है, इसलिए dist/ केवल dist नाम के एक फोल्डर से मेल खाता है और किसी भी फाइल को अकेला छोड़ देता है जो नाम साझा करता है। एक पंक्ति की शुरुआत ! से करें ताकि कुछ अनदेखा न किया जाए जो एक व्यापक पैटर्न अन्यथा पकड़ लेता है, जब किसी इग्नोर किए गए फोल्डर के अंदर एक फाइल को ट्रैक करने की आवश्यकता होती है तो यह उपयोगी है:

bash
# .gitignore
logs/
!logs/keep-this.log

Git एक वैश्विक अनदेखा फाइल भी पढ़ता है, प्रति मशीन एक, पैटर्न के लिए जो आप हर रेपो में चाहते हैं चाहे प्रोजेक्ट कुछ भी हो: .DS_Store या *.swp जैसा संपादक कचरा। इसे एक बार git config --global core.excludesfile ~/.gitignore_global के साथ सेट करें, और आपको फिर कभी उन पैटर्न को प्रोजेक्ट दर प्रोजेक्ट जोड़ना नहीं होगा।

अनदेखा पैटर्न उसी तरह मेल खाते हैं जैसे शेल ग्लोब्स करते हैं: किसी भी चरित्र के रन के लिए *, एक के लिए ?, निर्देशिकाओं में मेल खाने के लिए **। स्लैश रहित एक पैटर्न प्रोजेक्ट में किसी भी गहराई से मेल खाता है, जबकि स्लैश युक्त एक पैटर्न उस पथ को लंगर दिया जाता है। उन पैटर्न से मेल करना विशुद्ध रूप से स्थानीय व्यवहार है: Git केवल तभी .gitignore से परामर्श लेता है जब यह तय कर रहा हो कि git status और git add क्या दिखाते हैं। यह Git को एक बार ट्रैक किए गए फाइल को ट्रैक करने से नहीं रोकता है, जो अगले अनुभाग में महत्वपूर्ण है।

JunoGit को बताएं कि क्या अनदेखा करना है एक .gitignore फाइल सूचीबद्ध करती है कि Git को कभी ट्रैक नहीं करना चाहिए: node_modules/, dist/, और .env लगभग किसी भी प्रोजेक्ट में सामान्य संदिग्ध हैं। .gitignore फाइल को स्वयं कमिट करें ताकि जो कोई भी प्रोजेक्ट को क्लोन करता है उसे समान स्वच्छ स्थिति मिले। मैंने इसे सीखने से पहले एक पूरा दोपहर बर्बाद कर दिया था दुर्घटना से हजारों डिपेंडेंसी फाइलों को स्टेजिंग करते हुए।
JunoGit को बताएं कि क्या अनदेखा करना है पैटर्न *.log जैसे ग्लोब्स का समर्थन करते हैं, एक ट्रेलिंग स्लैश का मतलब "केवल निर्देशिका" है, और एक अग्रणी ! एक व्यापक मेल के अंदर कुछ अनदेखा न करता है। एक वैश्विक अनदेखा फाइल, core.excludesfile के साथ सेट की गई है, यह है जहां संपादक और OS कचरा है ताकि आप हर प्रोजेक्ट के .gitignore में .DS_Store को हाथ से जोड़ना बंद कर दें।
JunoGit को बताएं कि क्या अनदेखा करना है अनदेखा नियम शेल-शैली ग्लोब मिलान हैं, क्लाइंट-साइड लागू किए गए हैं, और वे कभी भी केवल यही बदलते हैं कि Git क्या आपको अनट्रैक्ड के रूप में दिखाता है। ध्यान में रखें कि एक नियम केवल एक फाइल को प्रभावित कर सकता है जिसे Git पहले से नहीं जानता है। यह अंतर कागज पर छोटा है और व्यवहार में महंगा है।

कभी भी सीक्रेट्स कमिट न करें

एक API कुंजी, एक डेटाबेस पासवर्ड, या एक हस्ताक्षर प्रमाणपत्र कभी भी कमिट में दिखाई नहीं देना चाहिए। यह एक निजी रेपोजिटरी के लिए उतना ही मजबूती से रहता है जितना कि सार्वजनिक एक के लिए, और यह पहले कमिट से शुरू होता है। सीक्रेट्स को .env जैसी फाइल में रखें, उस फाइल को .gitignore पर दिन एक पर जोड़ें, और मानों को अपने ऐप में से लोड करें उन्हें अपनी सोर्स फाइलों में लिखने के बजाय।

bash
# .env
WEATHER_API_KEY=sk_live_9f8e7d6c5b4a
bash
# .gitignore
.env

इस नियम का अनुसरण करें स्वचालित रूप से, हर बार, कोई अपवाद नहीं। एक कमिट में बैठी कुंजी रेपोजिटरी तक पहुंच वाले किसी के द्वारा पहुंचने योग्य है, और एक सार्वजनिक रेपोजिटरी पर, सभी के द्वारा।

एक वास्तविक प्रोजेक्ट में, सीक्रेट्स आमतौर पर एक से अधिक जगह पर रहते हैं: आपकी अपनी मशीन के लिए एक .env फाइल, और किसी भी तैनात की गई चीज़ के लिए एक सीक्रेट मैनेजर या आपके होस्ट की पर्यावरण-चर सेटिंग्स। दोनों व्यवहार में समान तरीके से काम करते हैं: मूल्य आपकी सोर्स फाइलों के बाहर और Git के बाहर रहता है, और आपका कोड इसे रनटाइम पर पर्यावरण से पढ़ता है। इसके बजाय एक .env.example फाइल भेजें, चर नामों के साथ लेकिन कोई वास्तविक मान नहीं, ताकि सहकर्मी जान सकें कि आपकी वास्तविक कुंजी कभी न देखे बिना क्या सेट करना है।

यह तथ्य है जो इस नियम को ग़ैर-परामर्शदायक बनाता है: एक कमिट जिससे आप एक सीक्रेट को हटाते हैं वह इसे इतिहास से नहीं हटाता है। हर पहले कमिट जिसके पास कुंजी थी अभी भी इसके पास है, रेपोजिटरी के इतिहास में हमेशा के लिए बचाया गया है, और हर क्लोन जो किसी ने बनाया है वह उन पुरानी कमिट्स के साथ ले जाता है। नई कमिट में फाइल को हटाने का मतलब केवल यह है कि नवीनतम स्नैपशॉट में अब इसके पास नहीं है; पुराने मूल्य को रखने वाली वस्तु अभी भी .git में बैठी है, जो कोई भी पहले कमिट को चेक आउट करता है या लॉग के माध्यम से खुदाई करता है उसके द्वारा पहुंचने योग्य।

"फाइल को हटाएं और फिर से कमिट करें" कभी भी पहले से ही रिसे हुई सीक्रेट को ठीक नहीं करता है। अगर कोई वास्तविक सीक्रेट कभी कमिट में आता है, तो इसे प्रदाता पर रोटेट या निरस्त करें (एक नई कुंजी जारी करें, पुरानी को अमान्य करें) ताकि लीक किया गया मूल्य उपयोगी होना बंद कर दे, इसके बाद आप रेपोजिटरी के लिए जो भी करते हैं। एक सीक्रेट को निकालने के लिए इतिहास को दोबारा लिखना संभव है, लेकिन यह कुंजी के किसी भी उपयोग को पूर्ववत नहीं करता है जो यह था जबकि यह खुला था। रोटेशन को महत्वपूर्ण फिक्स के रूप में मानते हैं और इतिहास सफाई को शीर्ष पर एक वैकल्पिक अतिरिक्त के रूप में।

Junoकभी भी सीक्रेट्स कमिट न करें कभी भी किसी कमिट में वास्तविक API कुंजी, पासवर्ड, या प्रमाणपत्र न रखें। सीक्रेट्स को .env जैसी फाइल में रखें और .env को अपने .gitignore में जोड़ें उससे पहले कि आप कभी git add चलाएं। यह पूरे अध्याय में एक नियम है जिसे पूर्ण के रूप में मानने योग्य है।
Junoकभी भी सीक्रेट्स कमिट न करें स्थानीय सीक्रेट्स .env में जाते हैं, तैनात सीक्रेट्स आपके होस्ट की पर्यावरण चर या एक सीक्रेट मैनेजर में जाते हैं, और न ही कभी कमिट किया जाता है। एक .env.example भेजें केवल चर नामों के साथ, ताकि सहकर्मी जान सकें कि कोई वास्तविक मूल्य देखे बिना क्या सेट करना है।
Junoकभी भी सीक्रेट्स कमिट न करें नई कमिट में सीक्रेट को हटाना इसे इतिहास से नहीं हटाता है। हर पहली कमिट और हर मौजूदा क्लोन अभी भी इसके पास है। जिस पल एक कुंजी लीक हो जाए तो प्रदाता पर उसे रोटेट करें: वह रोटेशन है जो फिक्स है जो वास्तव में मायने रखता है।

ट्रैक किए जाने के बाद .gitignore में एक फाइल जोड़ना

यह वह ट्रिप-अप है जो लगभग हर किसी को कम से कम एक बार पकड़ता है। आप दुर्घटना से एक फाइल कमिट करते हैं, अपनी गलती का एहसास करते हैं, इसे .gitignore में जोड़ते हैं (नीचे echo पंक्ति उस पथ को उस फाइल में जोड़ता है), और उम्मीद करते हैं कि Git इसे भूल जाए। वह नहीं करता।

bash
$ git add config/settings.json
$ git commit -m "Add app settings"

# बाद में, आपको एहसास होता है कि यह एक गलती थी
$ echo "config/settings.json" >> .gitignore
$ git status
On branch main
nothing to commit, working tree clean

git status एक स्वच्छ ट्री दिखाता है, लेकिन config/settings.json अभी भी ट्रैक किया जाता है और अभी भी हर भविष्य git log और हर क्लोन में दिखाई देता है। अनदेखा नियम केवल उन फाइलों पर लागू होते हैं जिन्हें Git पहले से नहीं जानता। एक बार जब कोई फाइल जोड़ी जाती है और कमिट की जाती है, तो यह आपके इतिहास का हिस्सा होता है, और .gitignore के पास उस इतिहास में पहले से मौजूद फाइलों के बारे में कोई विचार नहीं है।

इसे वास्तव में आगे बढ़ते हुए ट्रैक करना बंद करने के लिए, Git को यह बताएं कि फाइल को ड्रॉप कर दे जो यह अपनी डिस्क पर फाइल को छोड़ते हुए अनुसरण करता है:

bash
$ git rm --cached config/settings.json
$ git commit -m "Stop tracking config/settings.json"

git rm --cached <file> Git के ट्रैकिंग से फाइल को हटाता है आपकी कार्यशील निर्देशिका से हटाए बिना। उस हटाने को कमिट करें, और उस बिंदु से आपका .gitignore पैटर्न वह काम करता है जो आप शुरुआत से ही चाहते थे।

समान फिक्स git rm -r --cached <folder> के साथ एक पूरे फोल्डर पर काम करता है, जो सामान्य कदम है node_modules/ या dist/ को एहसास करने के बाद कि यह प्रोजेक्ट के जीवन के शुरुआत में कमिट किया गया था, उससे पहले कि किसी ने .gitignore जोड़ा हो बिल्कुल। इसे एक बार चलाएं, हटाने को कमिट करें, और फोल्डर भविष्य की कमिट्स से गायब हो जाता है जबकि हर सहकर्मी की डिस्क पर फाइलों की स्थानीय प्रति अक्षत रहती है।

यह व्यवहार सीधे इस बात से अनुसरण करता है कि स्टेजिंग क्षेत्र वास्तव में क्या है। Git इंडेक्स के माध्यम से फाइलों को ट्रैक करता है, अगली कमिट में क्या जाएगा इसका सटीक रिकॉर्ड। एक फाइल को जोड़ना और कमिट करना इसके लिए इंडेक्स में और कमिट के स्नैपशॉट में एक प्रविष्टि लिखता है; .gitignore केवल तब परामर्श दिया जाता है जब Git यह तय कर रहा हो कि एक ऐसी फाइल के साथ क्या करना है जिसके पास अभी तक कोई इंडेक्स प्रविष्टि नहीं है।

एक बार जब एक प्रविष्टि मौजूद होती है, तो पैटर्न को अनदेखा करना इसके लिए अप्रासंगिक हो जाता है। git rm --cached इंडेक्स प्रविष्टि को ड्रॉप करता है डिस्क पर फाइल रखते हुए, यही कारण है कि यह वह कमांड है जो वास्तव में इसे ठीक करता है, जहां केवल अनदेखा पैटर्न को संपादित करना कुछ नहीं करता है।

Junoट्रैक किए जाने के बाद .gitignore में एक फाइल जोड़ना.gitignore में एक फाइल जोड़ना उसके बाद Git पहले से ट्रैक करता है वह उस फाइल के साथ कुछ नहीं करता है। अनदेखा नियम केवल उन फाइलों पर लागू होते हैं जिन्हें Git ने कभी भी नहीं जोड़ा। एक फाइल को ट्रैक करना बंद करने के लिए जो दुर्घटना से फिसल गई हो, git rm --cached <file> चलाएं और उस परिवर्तन को कमिट करें।
Junoट्रैक किए जाने के बाद .gitignore में एक फाइल जोड़ना.gitignore केवल अनट्रैक्ड फाइलों को प्रभावित करता है। किसी भी पहले से कमिट की गई चीज़ के लिए, इसे git rm --cached <file> के साथ ड्रॉप करें, या git rm -r --cached <folder> पूरी निर्देशिका के लिए, फिर कमिट करें। हर किसी की स्थानीय फाइलें वहीं रहती हैं, केवल Git का उन्हें ट्रैक करना बदलता है।
Junoट्रैक किए जाने के बाद .gitignore में एक फाइल जोड़ना इंडेक्स हर ट्रैक की गई फाइल के लिए एक प्रविष्टि रखता है, और .gitignore केवल तभी परामर्श दिया जाता है जब अभी तक कोई प्रविष्टि नहीं है। git rm --cached इंडेक्स प्रविष्टि को हटाता है डिस्क पर फाइल को छुए बिना, जो वास्तविक फिक्स है यहां। अच्छे उपाय के लिए अनदेखा पैटर्न जोड़ें ताकि फाइल फिर से फिसल न सके।

अच्छी आदतें: छोटे कमिट्स और एक स्वच्छ रेपो

एक साफ-सुथरा .gitignore रेपोजिटरी में रहने योग्य रखने का एक आधा है। दूसरा आधा यह है कि आप अपने कमिट्स को कैसे आकार देते हैं। प्रत्येक कमिट को एक केंद्रित परिवर्तन बनाएं: एक बग फिक्स, एक छोटी सी सुविधा, एक एकल रिफ़ैक्टर। अगर एक दोपहर का काम कई असंबंधित चीज़ों को छूता है, तो इसे एक ही दिन के अंत में सब कुछ गिराने के बजाय कई कमिट्स में विभाजित करें।

bash
$ git add src/weather-widget.js
$ git commit -m "Fix temperature rounding in weather widget"

छोटे कमिट्स की समीक्षा करना आसान है, अगर कुछ टूटता है तो रिवर्ट करना आसान है, और छह महीने बाद पढ़ना आसान है जब आप यह याद करने की कोशिश कर रहे हों कि एक पंक्ति कोड क्यों मौजूद है। कमिट लूप कवर करता है कि एक कमिट संदेश उपयोगी क्या बनाता है; यह आदत परिवर्तन को स्वयं छोटा रखने के बारे में है ताकि एक अच्छा संदेश लिखना संभव हो।

इस आदत को एक स्वच्छ .gitignore के साथ संयोजित करें और भुगतान चक्रवृद्धि: एक इतिहास छोटे, उद्देश्यपूर्ण कमिट्स के बने, कोई जेनरेट किया गया फोल्डर या आवारा कॉन्फ़िग फाइलों को क्लच नहीं। dist/ churn के अलावा एक परिवर्तन की समीक्षा करना जिसे किसी ने संपादित किए गए दो वास्तविक पंक्तियां सभी के लिए दयनीय हैं, और यह पूरी तरह से टालने योग्य है .gitignore के साथ दिन एक पर सेट करें।

बड़े पैमाने पर यह तरीकों में भुगतान करता है जो पठनीयता से परे हैं। जेनरेट की गई फाइलों और डिपेंडेंसी फोल्डरों से मुक्त एक रेपोजिटरी क्लोन करने के लिए काफी छोटा रहता है और इसके माध्यम से स्वच्छ रूप से खोज करता है, और केंद्रित कमिट्स का एक इतिहास वह है जो git log --oneline और git diff को दो बिंदुओं के बीच वास्तव में उपयोगी बनाता है समय कि समझने के लिए क्या हुआ और क्यों। कोई भी यह अच्छी तरह से काम नहीं करता है एक इतिहास के विरुद्ध जहां आधी कमिट्स node_modules/ churn हैं और दूसरा आधा पांच असंबंधित परिवर्तनों को मिश्रित करता है।

Junoअच्छी आदतें: छोटे कमिट्स और एक स्वच्छ रेपो प्रत्येक कमिट को एक केंद्रित परिवर्तन के लिए रखें, और अपने .gitignore को फोल्डरों और सीक्रेट्स को कवर करते हुए रखें जिन्हें कभी ट्रैक नहीं किया जाना चाहिए। वे दो आदतें एक साथ ज्यादातर यह हैं कि एक रेपोजिटरी में काम करना सुखद क्या बनाता है। छोटी आदतें, जल्दी बनाई गई, आपको बाद में बहुत सफाई बचाती हैं।
Junoअच्छी आदतें: छोटे कमिट्स और एक स्वच्छ रेपो छोटे, केंद्रित कमिट्स प्लस एक स्वच्छ .gitignore समीक्षाओं और diffs को पठनीय बनाते हैं जेनरेट किए गए शोर में दफन होने के बजाय। पहली कमिट से पहले .gitignore को सेट करें। पांचवीं बार node_modules/ को पुल अनुरोध में दिखना देखने तक प्रतीक्षा करना उसे सेट करने से अधिक सफाई की लागत रखता है।
Junoअच्छी आदतें: छोटे कमिट्स और एक स्वच्छ रेपो एक दुबला रेपोजिटरी और केंद्रित कमिट्स का एक इतिहास वह है जो क्लोन को तेज़ रखता है और जब आप इसके माध्यम से खोज रहे होते हैं तो इतिहास को पठनीय रखता है। हर जेनरेट की गई फाइल या डिपेंडेंसी फोल्डर जो इतिहास में फिसल जाता है हर भविष्य क्लोन और खोज को एक छोटा टैक्स है। नियमों को अनदेखा करना आगे सेट करें और यह फिर से सोचने योग्य समस्या नहीं बन जाता है।