बाइटरी फाइलों के बिना gitignore

Question

.gitignore फ़ाइल का उपयोग कर git में द्विआधारी फ़ाइलों को कैसे अनदेखा किया जा सकता है?

उदाहरण:

$ g++ hello.c -o hello 

"हैलो" फ़ाइल एक बाइनरी फ़ाइल है। क्या git इस फ़ाइल को अनदेखा कर सकता है?

Answer 1

.gitignore फ़ाइल में तरह

*.o 

कुछ जोड़ें और अपने रेपो की जड़ में यह जगह (या आप किसी भी उप निर्देशिका आप चाहते हैं में जगह कर सकते हैं - इस पर उस स्तर से लागू होगा) और चेक उस में

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

कोई विस्तार के साथ बाइनरी के लिए, आप से बेहतर कर रहे हैं उन्हें bin/ या कुछ अन्य फ़ोल्डर में रखा गया है। बाद में सामग्री-प्रकार के आधार पर कोई अनदेखा नहीं है।

आप

* 
!*.* 

कोशिश कर सकते हैं लेकिन यह है कि सरल नहीं है।

Answer 2

द्विआधारी के साथ आपकी सबसे अच्छी शर्त या तो उन्हें एक एक्सटेंशन प्रदान करना है जिसे आप आसानी से मानक पैटर्न के साथ फ़िल्टर कर सकते हैं, या उन निर्देशिकाओं में डाल सकते हैं जिन्हें आप निर्देशिका स्तर पर फ़िल्टर कर सकते हैं।

एक्सटेंशन सुझाव विंडोज में अधिक लागू है, क्योंकि एक्सटेंशन मानक हैं और मूल रूप से आवश्यक हैं, लेकिन यूनिक्स में, आप अपने निष्पादन योग्य बाइनरी पर एक्सटेंशन का उपयोग कर सकते हैं या नहीं भी कर सकते हैं। इस मामले में, आप उन्हें एक बिन/फ़ोल्डर में डाल सकते हैं, और 0gको अपने .gitignore में जोड़ सकते हैं।

अपने बहुत विशिष्ट, छोटे-स्कोप उदाहरण में, आप अपने .gitignore में hello डाल सकते हैं।

Answer 3

मुझे कोई अन्य समाधान नहीं पता है, लेकिन उन्हें एक से .gitignore में जोड़ना है।

find . \(! -regex '.*/\..*' \) -type f | xargs -n 1 file | egrep "ASCII|text" 

संपादित

क्यों आप बस आप निष्पादन योग्य hello.bin नाम नहीं:

परीक्षण करने के लिए एक कच्चे रास्ते फ़ाइल आदेश के उत्पादन grep के लिए है?

Answer 4

अपने .gitignore (जो आप शायद "बाइनरी फ़ाइल" अपने प्रश्न से पहचानने मतलब) के लिए सभी निष्पादनयोग्य संलग्न करने के लिए, आप

find . -executable -type f >>.gitignore 

उपयोग कर सकते हैं आप अपने .gitignore में लाइनों के आदेश के बारे में परवाह नहीं करते हैं , आप अपने .gitignore को निम्न आदेश के साथ भी अपडेट कर सकते हैं जो डुप्लीकेट को हटा देता है और वर्णमाला क्रम को बरकरार रखता है।

T=$(mktemp); (cat .gitignore; find . -executable -type f | sed -e 's%^\./%%') | sort | uniq >$T; mv $T .gitignore 

ध्यान दें, आप उस फ़ाइल के काट-छांट से पहले cat पढ़ने के लिए खुलता है, पाइप .gitignore के लिए सीधे उत्पादन नहीं कर सकते हैं।साथ ही, आप यह देखने के विकल्प के रूप में \! -regex '.*/.*/.*' जोड़ना चाहेंगे कि क्या आप उपनिर्देशिका में निष्पादन योग्य फ़ाइलों को शामिल नहीं करना चाहते हैं।

Answer 5

आप अपने .gitignore में कोशिश कर सकते हैं:

* 
!*.c 

यह दृष्टिकोण कई नुकसान है, लेकिन यह छोटी परियोजनाओं के लिए स्वीकार्य है।

Answer 6

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

यहां एक छोटा हास्केल प्रोजेक्ट के लिए मेकफ़ाइल का उदाहरण दिया गया है;

all: $(patsubst %.hs, %, $(wildcard *.hs)) 

%: %.hs 
    ghc $^ 
    grep -xq "$@" .gitignore || echo $@ >> .gitignore 

यह makefile हास्केल कोड से बाहर निष्पादनयोग्य बनाने के लिए एक नियम परिभाषित करता है। Ghc के बाद आक्रमण के बाद, हम यह देखने के लिए .gitignore को जांचते हैं कि बाइनरी पहले से मौजूद है या नहीं। यदि ऐसा नहीं है, तो हम फ़ाइल में बाइनरी का नाम जोड़ते हैं।

Answer 7

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

import subprocess, os 

git_root = subprocess.check_output(['git', 'root']).decode("UTF-8").strip() 
exes = [] 
cut = len(git_root) 

for root, dirnames, filenames in os.walk(git_root+"/src/"): 
    for fname in filenames: 
    f = os.path.join(root,fname) 
    if not os.access(f,os.X_OK): 
     continue 

    ft = subprocess.check_output(['file', f]).decode("UTF-8") 

    if 'ELF' in ft and 'executable' in ft: 
     exes.append(f[cut:]) 

gifiles = [ str.strip(a) for a in open(git_root + "/.gitignore").readlines() ] 
gitignore=frozenset(exes+gifiles) 

with open(git_root+"/.gitignore", "w") as g: 
    for a in sorted(gitignore): 
    print(a, file=g) 

Answer 8

एक तरह से भी कुछ subdir में अनदेखी करने के लिए, न केवल एक रूट में:

# Ignore everything in a root 
/* 
# But not files with extension located in a root 
!/*.* 
# And not my subdir (by name) 
!/subdir/ 
# Ignore everything inside my subdir on any level below 
/subdir/**/* 
# A bit of magic, removing last slash or changing combination with previous line 
# fails everything. Though very possibly it just says not to ignore sub-sub-dirs. 
!/subdir/**/ 
# ...Also excluding (grand-)children files having extension on any level 
# below subdir 
!/subdir/**/*.* 

या, यदि आप केवल फ़ाइलों में से कुछ विशेष प्रकार के शामिल करना चाहते हैं:

/* 
!/*.c 
!/*.h 
!/subdir/ 
/subdir/**/* 
!/subdir/**/ 
!/subdir/**/*.c 
!/subdir/**/*.h 

ऐसा लगता है कि यदि आप चाहें तो यह हर नई उपनिर्देशिका के लिए भी काम कर सकता है !:

/* 
!/*.c 
!/*.h 
!/*/ 
/*/**/* 
!/*/**/ 
!/*/**/*.c 
!/*/**/*.h 

प्रमुख स्लेश केवल पहले दो पंक्तियों में और दूसरे में वैकल्पिक हैं। !/*/ और !/subdir/ में टैलिंग स्लैश भी वैकल्पिक है, लेकिन केवल इस पंक्ति में।

Answer 9

# Ignore all 
* 

# Unignore all with extensions 
!*.* 

# Unignore all dirs 
!*/ 

### Above combination will ignore all files without extension ### 

# Ignore files with extension `.class` & `.sm` 
*.class 
*.sm 

# Ignore `bin` dir 
bin/ 
# or 
*/bin/* 

# Unignore all `.jar` in `bin` dir 
!*/bin/*.jar 

# Ignore all `library.jar` in `bin` dir 
*/bin/library.jar 

# Ignore a file with extension 
relative/path/to/dir/filename.extension 

# Ignore a file without extension 
relative/path/to/dir/anotherfile 

Answer 10

बस अपने .gitignore को hello या /hello जोड़ें। या तो काम करता है।

Answer 11

मैंने GOPATH निर्देशिका में दो प्रविष्टियों के साथ एक .gitignore फ़ाइल बनाई है।

/bin 
/pkg 

यह वर्तमान में सभी संकलित विकास को अनदेखा करता है।

Answer 12

.gitignore कम से कम लिनक्स पर फ़ाइलों को फ़िल्टर करने के लिए glob programming का उपयोग करता है।

मैं एक मीटिंग में कोडिंग टॉक देने वाला हूं और तैयारी में, मैंने कई उपनिर्देशिकाओं के साथ एक निर्देशिका बनाई है जिसे मैं उन्हें प्रस्तुत करना चाहता हूं: 01_subject1, 02_subject2, 03_subject3। प्रत्येक उपनिर्देशिका में एक भाषा-निर्भर एक्सटेंशन के साथ एक स्रोत फ़ाइल होती है जो एक निष्पादन योग्य फ़ाइल के लिए संकलित होती है जिसका नाम सामान्य अभ्यास के अनुसार विस्तार के बिना स्रोत फ़ाइल नाम से मेल खाता है।

मैं संकलित फ़ाइलों को निम्नलिखित के साथ अंकों-उपसर्ग निर्देशिका में बहिष्कृत करता हूं।gitignore लाइन:

[0-9][0-9]_*/[!\.]*

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