git - मैं गिट भंडार में एक खाली निर्देशिका कैसे जोड़ सकता हूं?





directory git-add (24)


मान लें कि आपको tmp नाम की एक खाली निर्देशिका की आवश्यकता है:

$ mkdir tmp
$ touch tmp/.gitignore
$ git add tmp
$ echo '*' > tmp/.gitignore
$ git commit -m 'Empty directory' tmp

दूसरे शब्दों में, आपको गिट को यह अनदेखा करने के लिए बताए जाने से पहले इंडेक्स में .gitignore फ़ाइल को जोड़ना होगा (और खाली निर्देशिका में बाकी सब कुछ)।

मैं एक गिट भंडार में एक खाली निर्देशिका (जिसमें कोई फाइल नहीं है) कैसे जोड़ सकता हूं?




जैसा कि बताया गया है कि खाली निर्देशिकाएं जोड़ना संभव नहीं है, लेकिन यहां एक लाइनर है जो सभी निर्देशिकाओं में खाली .gitignore फ़ाइलों को जोड़ता है।

ruby -e 'require "fileutils" ; Dir.glob(["target_directory","target_directory/**"]).each { |f| FileUtils.touch(File.join(f, ".gitignore")) if File.directory?(f) }'

मैंने इसे आसान पहुंच के लिए रेकैकाइल में फंस लिया है।




गिट खाली निर्देशिकाओं को ट्रैक नहीं करता है। अधिक स्पष्टीकरण के लिए गिट एफएक्यू देखें। सुझाया गया कामकाज खाली निर्देशिका में एक .gitignore फ़ाइल डालना है। मुझे वह समाधान पसंद नहीं है, क्योंकि .gitignore कन्वेंशन द्वारा .gitignore "छुपा" है। इसके अलावा कोई स्पष्टीकरण नहीं है कि निर्देशिका खाली क्यों हैं।

मैं खाली निर्देशिका में एक README फ़ाइल डालने का सुझाव देता हूं कि यह बता रहा है कि निर्देशिका खाली क्यों है और इसे गिट में क्यों ट्रैक किया जाना चाहिए। रीडमे फ़ाइल के साथ, जहां तक ​​गिट का संबंध है, निर्देशिका अब खाली नहीं है।

असली सवाल यह है कि आपको गिट में खाली निर्देशिका क्यों चाहिए? आमतौर पर आपके पास कुछ प्रकार की बिल्ड स्क्रिप्ट होती है जो संकलन / चलने से पहले खाली निर्देशिका बना सकती है। यदि नहीं तो एक बनाओ। गिट में खाली निर्देशिका डालने से यह एक बेहतर समाधान है।

तो आपके पास कुछ कारण है कि आपको गिट में खाली निर्देशिका क्यों चाहिए। रीडमे फ़ाइल में उस कारण को रखें। इस तरह अन्य डेवलपर्स (और भविष्य आप) ​​जानते हैं कि खाली निर्देशिका क्यों होनी चाहिए। आपको यह भी पता चलेगा कि खाली निर्देशिका को हल करने की समस्या को हल करने के दौरान आप खाली निर्देशिका को हटा सकते हैं।

प्रत्येक खाली निर्देशिका को सूचीबद्ध करने के लिए निम्न आदेश का उपयोग करें:

find -name .git -prune -o -type d -empty -print

प्रत्येक खाली निर्देशिका में प्लेसहोल्डर READMEs बनाने के लिए:

find -name .git -prune -o -type d -empty -exec sh -c \
  "echo this directory needs to be empty because reasons > {}/README.emptydir" \;

README फ़ाइल को छोड़कर निर्देशिका में सब कुछ अनदेखा करने के लिए निम्न पंक्तियों को अपने .gitignore में डालें:

path/to/emptydir/*
!path/to/emptydir/README.emptydir
path/to/otheremptydir/*
!path/to/otheremptydir/README.emptydir

वैकल्पिक रूप से, आप केवल हर रीडमे फ़ाइल को अनदेखा होने से बाहर कर सकते हैं:

path/to/emptydir/*
path/to/otheremptydir/*
!README.emptydir

प्रत्येक README को पहले से बनाए जाने के बाद सूचीबद्ध करने के लिए:

find -name README.emptydir



कभी-कभी आपको बुरी लिखित पुस्तकालयों या सॉफ़्टवेयर से निपटना पड़ता है, जिसे "वास्तविक" खाली और मौजूदा निर्देशिका की आवश्यकता होती है। एक साधारण डालने .gitignoreया .keepउन्हें तोड़ने और एक बग का कारण बन सकता है। निम्नलिखित इन मामलों में मदद कर सकते हैं, लेकिन कोई गारंटी नहीं ...

पहले आवश्यक निर्देशिका बनाएं:

mkdir empty

फिर आप इस निर्देशिका के लिए एक टूटी प्रतीकात्मक लिंक जोड़ते हैं (लेकिन उपरोक्त वर्णित उपयोग मामले की तुलना में किसी अन्य मामले पर, कृपया READMEस्पष्टीकरण के साथ उपयोग करें ):

ln -s .this.directory empty/.keep

इस निर्देशिका में फ़ाइलों को अनदेखा करने के लिए, आप इसे अपनी जड़ में जोड़ सकते हैं .gitignore:

echo "/empty" >> .gitignore

अनदेखा फ़ाइल जोड़ने के लिए, इसे बल देने के लिए पैरामीटर का उपयोग करें:

git add -f empty/.keep

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

find empty -type f

यह आदेश एक खाली परिणाम दिखाता है, क्योंकि इस निर्देशिका में कोई भी फाइल मौजूद नहीं है। इसलिए अधिकांश एप्लिकेशन, जो किसी निर्देशिका में सभी फाइलें प्राप्त करते हैं, आमतौर पर यह लिंक नहीं देखते हैं, कम से कम अगर वे "फ़ाइल मौजूद हैं" या "पठनीय" है। यहां तक ​​कि कुछ स्क्रिप्ट को कोई भी फाइल नहीं मिलेगी:

$ php -r "var_export(glob('empty/.*'));"
array (
  0 => 'empty/.',
  1 => 'empty/..',
)

लेकिन मैं दृढ़ता से केवल विशेष परिस्थितियों में इस समाधान का उपयोग करने की सलाह देता हूं, एक READMEखाली निर्देशिका में लिखा गया एक अच्छा आमतौर पर एक बेहतर समाधान होता है। (और मुझे नहीं पता कि यह विंडोज़ फाइल सिस्टम के साथ काम करता है ...)




हमें खाली संस्करण वाले फ़ोल्डरों की आवश्यकता क्यों होगी

पहली चीजें पहले:

एक खाली निर्देशिका गिट संस्करण प्रणाली के तहत एक पेड़ का हिस्सा नहीं हो सकता है

यह बस ट्रैक नहीं किया जाएगा। लेकिन ऐसे परिदृश्य हैं जिनमें "संस्करण" खाली निर्देशिका उपयोगी हो सकती है, उदाहरण के लिए:

  • एक पूर्वनिर्धारित फ़ोल्डर संरचना मचान, और इस संरचना को भंडार के प्रत्येक उपयोगकर्ता / योगदानकर्ता के लिए उपलब्ध कराएं; या, उपर्युक्त के एक विशेष मामले के रूप में , अस्थायी फ़ाइलों के लिए एक फ़ोल्डर बनाते हैं, जैसे cache/ या logs/ निर्देशिका, जहां हम फ़ोल्डर प्रदान करना चाहते हैं, लेकिन इसकी सामग्री को .gitignore
  • घबराहट से संबंधित, कुछ परियोजनाएं कुछ फ़ोल्डर्स के बिना काम नहीं करतीं (जो प्रायः खराब डिजाइन किए गए प्रोजेक्ट का संकेत देती है, लेकिन यह अक्सर वास्तविक दुनिया का परिदृश्य है और शायद कह सकता है, अनुमति समस्याएं हो सकती हैं)।

कुछ सुझाए गए कामकाज

कई उपयोगकर्ता सुझाव देते हैं:

  1. निर्देशिका को खाली करने के लिए, या कुछ सामग्री के साथ एक README फ़ाइल या किसी अन्य फ़ाइल को रखना, या
  2. एक .gitignore फ़ाइल को "रिवर्स लॉजिक" (यानी सभी फाइलों को शामिल करने के लिए) के साथ बनाना, अंत में, दृष्टिकोण # 1 के समान उद्देश्य को पूरा करता है।

जबकि दोनों समाधान निश्चित रूप से काम करते हैं, मैं उन्हें गिट संस्करण के सार्थक दृष्टिकोण के साथ असंगत पाते हैं।

  • आपको फर्जी फाइलें या रीडमेम्स क्यों डालना चाहिए जो शायद आप वास्तव में अपनी परियोजना में नहीं चाहते हैं?
  • एक चीज करने के लिए .gitignore का उपयोग क्यों करें (फ़ाइलों को रखते हुए ) जो कि इसका मतलब है (फ़ाइलों को छोड़कर ) के विपरीत है, भले ही यह संभव हो?

गिटकीप दृष्टिकोण

वर्जनिंग सिस्टम में फ़ोल्डर की उपस्थिति को बल देने के लिए .gitkeep नामक एक खाली फ़ाइल का उपयोग करें।

हालांकि ऐसा कोई बड़ा अंतर नहीं लग सकता है:

  • आप उस फ़ाइल का उपयोग करते हैं जिसमें फ़ोल्डर को रखने का एकमात्र उद्देश्य है। आप वहां कोई ऐसी जानकारी नहीं डालते जिसे आप नहीं रखना चाहते हैं।

    उदाहरण के लिए, आपको उपयोगी जानकारी के साथ READMEs का उपयोग करना चाहिए, फ़ोल्डर को रखने का बहाना नहीं।

    चिंताओं का पृथक्करण हमेशा एक अच्छी बात है, और आप अभी भी अवांछित फ़ाइलों को अनदेखा करने के लिए एक .gitignore जोड़ सकते हैं।

  • इसका नामकरण। .gitkeep इसे फ़ाइल नाम से ही स्पष्ट और सीधा बनाता है (और अन्य डेवलपर्स के लिए भी, जो एक साझा परियोजना के लिए अच्छा है और गिट भंडार के मुख्य उद्देश्यों में से एक है) कि यह फ़ाइल है

    • कोड से संबंधित एक फ़ाइल (प्रमुख बिंदु और नाम की वजह से)
    • एक फ़ाइल स्पष्ट रूप से गिट से संबंधित है
    • इसका उद्देश्य ( रखें ) स्पष्ट रूप से बताया गया है और अनदेखा करने के अर्थ में लगातार और अर्थात् विरोध किया गया है

दत्तक ग्रहण

मैंने .gitkeep , .gitkeep Angular-CLI जैसे बहुत महत्वपूर्ण ढांचे द्वारा अपनाई गई। .gitkeep दृष्टिकोण को देखा है।




जेमी फ्लोरनोय का समाधान बहुत अच्छा काम करता है। यहां रखने के लिए थोड़ा उन्नत संस्करण दिया गया है .htaccess:

# Ignore everything in this directory
*
# Except this file
!.gitignore
!.htaccess

इस समाधान के साथ आप खाली फ़ोल्डर को करने में सक्षम हैं, उदाहरण के लिए /log, /tmpया /cacheफ़ोल्डर खाली रहेगा।




touch .keep

लिनक्स पर, यह .keep नाम की एक खाली फ़ाइल बनाता है। इस नाम को .gitkeep पर प्राथमिकता दी गई है क्योंकि पूर्व गिट के लिए अज्ञेयवादी है, जबकि बाद वाला गिट के लिए विशिष्ट है। दूसरा, जैसा कि किसी अन्य उपयोगकर्ता ने नोट किया है, .git उपसर्ग सम्मेलन उन फ़ाइलों और निर्देशिकाओं के लिए आरक्षित होना चाहिए जो गिट स्वयं ही उपयोग करता है।

वैकल्पिक रूप से, जैसा कि किसी अन्य answer में बताया गया है, निर्देशिका में इसके बजाय एक वर्णनात्मक README.md या README.md फ़ाइल हो सकती है

बेशक यह आवश्यक है कि फ़ाइल की उपस्थिति आपके एप्लिकेशन को तोड़ने का कारण नहीं बनती है।




निर्देशिका को खाली रखने के लिए एक और तरीका (भंडार में) उस निर्देशिका के अंदर एक .gitignore फ़ाइल बनाना है जिसमें इन चार पंक्तियां हैं:

# Ignore everything in this directory
*
# Except this file
!.gitignore

फिर आपको आदेश को सही तरीके से प्राप्त करने की आवश्यकता नहीं है जिसे आपको m104 के solution ।

यह लाभ भी देता है कि जब आप गिट स्थिति करते हैं तो उस निर्देशिका में फ़ाइलें "अनचाहे" के रूप में दिखाई नहीं देगी।

@GreenAsJade की टिप्पणी लगातार बना रही है:

मुझे लगता है कि यह ध्यान देने योग्य है कि यह समाधान ठीक से पूछताछ के लिए क्या करता है, लेकिन शायद इस सवाल को देखने वाले बहुत से लोग इस बात की तलाश नहीं कर रहे हैं। यह समाधान गारंटी देता है कि निर्देशिका खाली बनी हुई है। यह कहता है "मैं वास्तव में कभी भी फाइलों को चेक नहीं करना चाहता हूं"। "मेरे पास यहां जांचने के लिए कोई फाइल नहीं है, लेकिन मुझे यहां निर्देशिका की आवश्यकता है, फाइलें बाद में आ रही हैं"।




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

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




कभी-कभी मेरे पास फ़ोल्डर्स के साथ रिपोजिटरी होती है जिसमें केवल "सामग्री" के रूप में माना जाने वाली फाइलें होंगी -यह है, वे ऐसी फ़ाइलें नहीं हैं जिन्हें मैं संस्करणित करने की परवाह करता हूं, और इसलिए कभी भी प्रतिबद्ध नहीं होना चाहिए। गिट की .gitignore फ़ाइल के साथ, आप पूरी निर्देशिका को अनदेखा कर सकते हैं। लेकिन ऐसे समय होते हैं जब रेपो में फ़ोल्डर होना फायदेमंद होगा। इस आवश्यकता को पूरा करने के लिए यहां एक उत्कृष्ट समाधान है।

मैंने अतीत में जो किया है, वह मेरे रेपो की जड़ पर एक .gitignore फ़ाइल डालता है, और उसके बाद फ़ोल्डर को बहिष्कृत करता है, जैसे:

/app/some-folder-to-exclude
/another-folder-to-exclude/*

हालांकि, ये फ़ोल्डर्स फिर रेपो का हिस्सा नहीं बनते हैं। आप वहां एक रीडमे फ़ाइल की तरह कुछ जोड़ सकते हैं। लेकिन फिर आपको अपने आवेदन को बताना होगा कि किसी भी रीडमी फाइलों को संसाधित करने की चिंता न करें।

यदि आपका ऐप वहां मौजूद फ़ोल्डरों पर निर्भर करता है (हालांकि खाली), तो आप केवल एक .gitignore फ़ाइल को प्रश्न में फ़ोल्डर में जोड़ सकते हैं, और दो लक्ष्यों को पूरा करने के लिए इसका उपयोग कर सकते हैं:

गिट को बताएं कि फ़ोल्डर में एक फाइल है, जो गिट को रेपो में जोड़ती है। इस फ़ोल्डर की सामग्री को अनदेखा करने के लिए गिट को बताएं, इस फ़ाइल को कम करें। अपनी खाली निर्देशिकाओं के अंदर डालने के लिए .gitignore फ़ाइल यहां दी गई है:

*
!.gitignore

पहली पंक्ति (*) इस निर्देशिका में सब कुछ अनदेखा करने के लिए गिट को बताती है। दूसरी पंक्ति गिट को बताती है कि .gitignore फ़ाइल को अनदेखा न करें। आप इस फ़ाइल को प्रत्येक रिक्त फ़ोल्डर में संग्रहीत कर सकते हैं जिसे आप रेपॉजिटरी में जोड़ना चाहते हैं।




मुझे @ आर्टूर 7 9 और @ एमजेएस के उत्तरों पसंद हैं, इसलिए मैं दोनों के संयोजन का उपयोग कर रहा हूं और इसे हमारी परियोजनाओं के लिए मानक बना रहा हूं।

find . -type d -empty -exec touch {}/.gitkeep \;

हालांकि, हमारे कुछ डेवलपर्स मैक या लिनक्स पर काम करते हैं। विंडोज़ पर बहुत काम और मुझे वहां पूरा करने के लिए एक समान सरल एक-लाइनर नहीं मिला। कुछ भाग्यशाली थे कि Cygwin को अन्य कारणों से स्थापित किया गया था, लेकिन इसके लिए सिग्विन को निर्धारित करना बहुत अधिक लग रहा था।

इसलिए, चूंकि हमारे अधिकांश डेवलपर्स में पहले से ही Ant स्थापित है, इसलिए मैंने इसे प्लेटफॉर्म से स्वतंत्र रूप से पूरा करने के लिए एक बिल्ड फ़ाइल बनाई है।

<?xml version="1.0" encoding="ISO-8859-1"?>
<project name="Gitkeep" basedir="." default="keep">
    <!--Apply to all subdirs of this dir-->
    <target name="keep" description="-> Add a .gitkeep file to all empty subdir's of this dir.">

        <!--Create a ref to all the subdirs in the tree of this dir-->
        <dirset id="dirs.ref" dir="./" includes="**/*"/>
        <!--Create a list of the subdirs under this dir-->
        <property name="dirs.list" refid="dirs.ref" />

        <!--For each subdir-->
        <for list="${dirs.list}" delimiter=";" param="dir">
            <sequential>
                <!--If the subdir is empty this target will add a .gitkeep file to it-->
                <antcall target="gitkeep" inheritall="false">
                    <param name="dir" value="@{dir}"/>
                </antcall>
            </sequential>
        </for>
    </target>

    <!--Add a .gitkeep file to a directory if it's empty-->
    <target name="gitkeep" description="-> Add a .gitkeep file to a specific subdir of this dir. Use -Ddir=relative/path/to/dir">

        <!--Create a ref of the files inside this dir-->
        <fileset dir="${dir}" id="contents.ref"/>

        <!--Create a path to the contents of this directory, ONLY if it's not empty-->
        <pathconvert refid="contents.ref" property="contents.path" setonempty="false"/>

        <if>
            <!--If the dir is empty create the .gitkeep file-->
            <not><isset property="contents.path"/></not>
            <then>
                <!--Create the .gitkeep file-->
                <echo message="Version this dir in Git even if its empty." file="./${dir}/.gitkeep" force="true" append="false"/>
            </then>
        </if>
    </target>
</project>

अब मैं बस चला सकता हूँ

ant -f gitkeep.xml

और यह किसी भी खाली उपदिर में एक .gitkeep फ़ाइल बनाता है। विंडोज़ पर भी :) नोट: इस बिल्ड फ़ाइल को चींटी कंट्रीब जार की आवश्यकता है ।

मैं here इस अवधारणा पर काम करना जारी रखता हूं ।

here




आप निर्देशिका में एक रीडमे फ़ाइल हमेशा एक स्पष्टीकरण के साथ डाल सकते हैं कि आप इसे क्यों चाहते हैं, अन्यथा खाली, रिपोजिटरी में निर्देशिका।




आप इस कोड को create_readme.php के रूप में सहेज सकते हैं और PHP कोड को अपने गिट प्रोजेक्ट की मूल निर्देशिका से चला सकते हैं।

> php create_readme.php

यह रिक्त फ़ाइलों को उन सभी निर्देशिकाओं में जोड़ देगा जो खाली हैं, इसलिए उन निर्देशिकाओं को इंडेक्स में जोड़ा जाएगा।

<?php
    $path = realpath('.');
    $objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path),       RecursiveIteratorIterator::SELF_FIRST);
    foreach($objects as $name => $object){
        if ( is_dir($name) && ! is_empty_folder($name) ){
            echo "$name\n" ;
            exec("touch ".$name."/"."README");
        }
    }

    function is_empty_folder($folder) {
        $files = opendir($folder);
        while ($file = readdir($files)) {
            if ($file != '.' && $file != '..')
                return true; // Not empty
            }
        }
?>

फिर करो

git commit -m "message"
git push



मैदान में एक और विकल्प जोड़ना।

मान लीजिए कि आप उसमें एक निर्देशिका जोड़ना चाहते हैं git, सभी उद्देश्यों से संबंधित git, खाली रहना चाहिए और कभी भी इसकी सामग्री को ट्रैक नहीं किया जाना चाहिए, .gitignoreजैसा कि यहां कई बार सुझाया गया है, यह चाल करेगा।

जैसा कि बताया गया है, प्रारूप है:

*
!.gitignore

अब, यदि आप कमांड लाइन पर ऐसा करने का कोई तरीका चाहते हैं, तो एक में झुकाव गिर गया, जबकि निर्देशिका के अंदर आप जोड़ना चाहते हैं, आप निष्पादित कर सकते हैं:

$ echo "*" > .gitignore && echo '!.gitignore' >> .gitignore && git add .gitignore

स्वयं, मेरे पास एक शेल स्क्रिप्ट है जिसे मैं ऐसा करने के लिए उपयोग करता हूं। जो कुछ भी आप चाहते हैं उसे स्क्रिप्ट का नाम दें, और या तो इसे अपने पथ में कहीं भी जोड़ें, या इसे सीधे संदर्भित करें:

#!/bin/bash

dir=''

if [ "$1" != "" ]; then
    dir="$1/"
fi

echo "*" > $dir.gitignore && \
echo '!.gitignore' >> $dir.gitignore && \
git add $dir.gitignore

इसके साथ, आप इसे उस निर्देशिका में से निष्पादित कर सकते हैं, जिसे आप जोड़ना चाहते हैं, या निर्देशिका को संदर्भित करें क्योंकि यह पहला और केवल पैरामीटर है:

$ ignore_dir ./some/directory

एक अन्य विकल्प (@GreenAsJade द्वारा एक टिप्पणी के जवाब में), अगर आपको लगता है कि कोई खाली फोल्डर को ट्रैक करना चाहते हो सकता है भविष्य में पता लगाया फ़ाइलें हो, लेकिन अब के लिए खाली हो जाएगा, तो आप कर सकते हैं ommit *से .gitignoreफ़ाइल, और जाँच कि में। असल में, सभी फाइलें कह रही हैं " मुझे अनदेखा न करें ", लेकिन अन्यथा, निर्देशिका खाली है और ट्रैक की गई है।

आपकी .gitignoreफाइल इस तरह दिखेगी:

!.gitignore

यही है, उसमें जांचें, और आपके पास एक खाली, अभी तक ट्रैक की गई है, निर्देशिका है कि आप कुछ समय बाद फ़ाइलों को ट्रैक कर सकते हैं।

कारण मैं सुझाव देता हूं कि फाइल में एक पंक्ति यह है कि यह .gitignoreउद्देश्य देता है । अन्यथा, लाइन के नीचे कोई भी इसे हटाने के लिए सोच सकता है। यदि आप लाइन के ऊपर एक टिप्पणी करते हैं तो यह मदद कर सकता है।




गिट को निर्देशिकाओं को ट्रैक करने का कोई तरीका नहीं है, इसलिए एकमात्र समाधान निर्देशिका के भीतर प्लेसहोल्डर फ़ाइल को जोड़ना है जिसे आप ट्रैक करना चाहते हैं।

फ़ाइल का नाम और कुछ भी आप चाहते हैं, लेकिन अधिकांश लोग नाम की एक खाली फ़ाइल का उपयोग कर सकते हैं .gitkeep(हालांकि कुछ लोग वीसीएस-अज्ञेयवादी पसंद करते हैं .keep)।

प्रीफिक्स्ड .इसे एक छिपी हुई फाइल के रूप में चिह्नित करता है।

एक और विचार यह READMEसमझाने के लिए एक फाइल जोड़ना होगा कि निर्देशिका का उपयोग किस प्रकार किया जाएगा।




मुझे भी खाली निर्देशिकाओं के साथ इस मुद्दे का सामना करना पड़ रहा है। प्लेसहोल्डर फ़ाइलों का उपयोग करने में समस्या यह है कि आपको उन्हें बनाने की आवश्यकता है, और उन्हें हटाएं, अगर वे अब आवश्यक नहीं हैं (क्योंकि बाद में वहां उप-निर्देशिका या फ़ाइलें शामिल की गई थीं। इन प्लेसहोल्डर फ़ाइलों को प्रबंधित करने वाले बड़े स्रोत पेड़ों के साथ बोझिल और त्रुटि हो सकती है होने का खतरा।

यही कारण है कि मैंने एक ओपन सोर्स टूल लिखने का फैसला किया जो स्वचालित रूप से ऐसी प्लेसहोल्डर फ़ाइलों के निर्माण / हटाना का प्रबंधन कर सकता है। यह .NET प्लेटफार्म के लिए लिखा गया है और मोनो (लिनक्स के लिए .NET) और विंडोज के तहत चलता है।

बस एक नज़र डालें: http://code.google.com/p/markemptydirs




चेतावनी: यह चिमटा वास्तव में काम नहीं कर रहा है क्योंकि यह पता चला है। असुविधा के लिए खेद है।

नीचे मूल पोस्ट:

गिट आंतरिक के साथ खेलते समय मुझे एक समाधान मिला!

  1. मान लीजिए कि आप अपने भंडार में हैं।
  2. अपनी खाली निर्देशिका बनाएं:

    $ mkdir path/to/empty-folder
    
  3. इसे प्लंबिंग कमांड और खाली पेड़ SHA-1 का उपयोग करके इंडेक्स में जोड़ें:

    $ git update-index --index-info
    040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder
    

    आदेश टाइप करें और फिर दूसरी पंक्ति दर्ज करें। एंटर दबाएं और फिर अपने इनपुट को समाप्त करने के लिए Ctrl + D दबाएं । नोट: प्रारूप मोड [स्पेस] प्रकार [स्पेस] SHA-1hash [TAB] पथ है (टैब महत्वपूर्ण है, उत्तर स्वरूपण इसे संरक्षित नहीं करता है)।

  4. बस! आपका खाली फ़ोल्डर आपकी अनुक्रमणिका में है। आपको बस इतना करना है।

यह समाधान छोटा है और स्पष्ट रूप से ठीक काम करता है ( संपादित करें! ), लेकिन यह याद रखना इतना आसान नहीं है ...

खाली पेड़ SHA-1 एक नया खाली गिट भंडार, cd बनाकर और git write-tree जारी करके पाया जा सकता है, जो खाली पेड़ SHA-1 का उत्पादन करता है।

संपादित करें:

मैं इस समाधान का उपयोग कर रहा हूं क्योंकि मुझे यह मिला है। यह एक सबमिशन बनाने के समान ही काम करता प्रतीत होता है, सिवाय इसके कि कोई मॉड्यूल कहीं भी परिभाषित नहीं किया गया है। git submodule init|update जारी करते समय यह त्रुटियों की ओर जाता है। समस्या यह है कि git update-index 040000 tree भाग को 160000 commit में फिर से लिखता है।

इसके अलावा, उस पथ के नीचे रखी गई कोई भी फ़ाइल गिट द्वारा कभी नहीं देखी जाएगी, क्योंकि ऐसा लगता है कि वे किसी अन्य भंडार से संबंधित हैं। यह बुरा है क्योंकि इसे आसानी से अनदेखा किया जा सकता है!

हालांकि, अगर आप पहले से (और नहीं करेंगे) अपने भंडार में किसी भी गिट सबमिड्यूल का उपयोग नहीं करते हैं, और "खाली" फ़ोल्डर खाली रहेगा या यदि आप गिट को अपने अस्तित्व के बारे में जानना चाहते हैं और इसकी सामग्री को अनदेखा करना चाहते हैं, तो आप साथ जा सकते हैं यह चिमटा Submodules के साथ सामान्य तरीका जा रहा है कि इस tweak और कदम उठाता है।




निर्देशिका में .gitkeep नामक एक खाली फ़ाइल बनाएं, और उसे जोड़ें।




रेल पर रूबी लॉग फ़ोल्डर निर्माण तरीका:

mkdir log && touch log/.gitkeep && git add log/.gitkeep

अब लॉग निर्देशिका पेड़ में शामिल किया जाएगा। तैनाती करते समय यह बहुत उपयोगी होता है, इसलिए आपको लॉग निर्देशिका बनाने के लिए नियमित रूप से लिखना नहीं होगा।

लॉगफाइल जारी करके बाहर रखा जा सकता है,

echo log/dev.log >> .gitignore

लेकिन आप शायद यह जानते थे।




मैं हमेशा अपनी वांछित फ़ोल्डर संरचना की जांच करने और परियोजना के भीतर इसे मेरे लिए बनाने के लिए एक फ़ंक्शन बनाता हूं। यह इस समस्या के आसपास हो जाता है क्योंकि रिक्त फ़ोल्डर्स प्रॉक्सी द्वारा गिट में आयोजित किए जाते हैं।

function check_page_custom_folder_structure () {
    if (!is_dir(TEMPLATEPATH."/page-customs"))
        mkdir(TEMPLATEPATH."/page-customs");    
    if (!is_dir(TEMPLATEPATH."/page-customs/css"))
        mkdir(TEMPLATEPATH."/page-customs/css");
    if (!is_dir(TEMPLATEPATH."/page-customs/js"))
        mkdir(TEMPLATEPATH."/page-customs/js");
}

यह PHP में है, लेकिन मुझे यकीन है कि अधिकतर भाषाएं समान कार्यक्षमता का समर्थन करती हैं, और क्योंकि फ़ोल्डर्स के निर्माण को एप्लिकेशन द्वारा ख्याल रखा जाता है, तो फ़ोल्डर्स हमेशा वहां रहेंगे।




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




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




यदि आप एक फ़ोल्डर जोड़ना चाहते हैं जो कई अर्थपूर्ण निर्देशिकाओं में बहुत अधिक क्षणिक डेटा रखेगा, तो एक दृष्टिकोण यह है कि आप इस तरह की कुछ रूट को जोड़ दें .gitignore ...

/app/data/**/*.* !/app/data/**/*.md

फिर आप *.mdप्रत्येक निर्देशिका में वर्णनात्मक README.md फ़ाइलों (या रिक्त फाइलें, इससे कोई फर्क नहीं पड़ता, जब तक कि आप उन्हें इस मामले में विशिष्ट रूप से लक्षित नहीं कर सकते ), यह सुनिश्चित करने के लिए कि निर्देशिका सभी रिपो का हिस्सा बने रहें लेकिन फ़ाइलों (एक्सटेंशन के साथ) अनदेखा रखा जाता है। सीमा: .निर्देशिका नामों में अनुमति नहीं है!

आप इन सभी निर्देशिकाओं को एक्सएमएल / इमेज फाइलों के साथ भर सकते हैं या जो भी हो और /app/data/समय के साथ और अधिक निर्देशिकाएं जोड़ सकते हैं क्योंकि आपके ऐप के लिए स्टोरेज की जरूरत है (README.md फ़ाइलों के साथ प्रत्येक स्टोरेज निर्देशिका के विवरण में जला देने के लिए ठीक ठीक)।

प्रत्येक नई निर्देशिका के लिए .gitignoreनया बनाकर अपने या विकेन्द्रीकरण को बदलने की कोई आवश्यकता नहीं है .gitignore। शायद सबसे बुद्धिमान समाधान नहीं है लेकिन यह गिटिनोरोर-वार है और हमेशा मेरे लिए काम करता है। अच्छा और सरल! ;)




मैंने मूर्खतापूर्वक एक हाइफ़न से शुरू होने वाली शाखा का नाम दिया, और फिर मास्टर की जांच की। मैं अपनी शाखा को हटाना नहीं चाहता था, मैंने इसमें काम किया था।

इनमें से कोई भी काम नहीं किया:

git checkout -dumb-name

git checkout -- -dumb-name

" एस, और एस ने या तो मदद नहीं की। git branch -m काम नहीं करता है।

यहां बताया गया है कि मैंने अंत में इसे कैसे ठीक किया। अपनी कामकाजी प्रतिलिपि में जाएं। Git / refs / head, फ़ाइल नाम "-डंब-नाम" ढूंढें, शाखा के हैश प्राप्त करें। फिर यह इसे देखेगा, एक सायन नाम के साथ एक नई शाखा बनायेगा, और पुराने को हटा देगा।

git checkout {hash}
git checkout -b brilliant-name
git branch -d -- -dumb-name






git directory git-add