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

Question

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

उदाहरण:

$ g++ hello.c -o hello

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

Comments

संभव डुप्लिकेट कैसे मैं उन्हें (सभी एक्सटेंशन-कम फ़ाइलों) डॉट्स के बिना gitignore फ़ाइल में फ़ाइलें जोड़ूँ?

— मैड फिजिसिस्ट

मुझे बहुत आश्चर्य है कि इस तरह के एक पुराने और महत्वपूर्ण प्रश्न का कोई उचित उत्तर नहीं है। मैं और भी हैरान हूं कि इसका जवाब सीधा है [^\.]*।

— TamaMcGlinn

यह काम नहीं करता है

— टिमोथीकोर

Answer 1

# 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

Comments

यह समाधान एक आकर्षण की तरह काम करता है! मुझे समझ नहीं आ रहा है कि सभी डायरों को "" /? "" के साथ जोड़कर, यह सबडिर की फाइलों को एक्सटेंशन के साथ भी असाइन कर सकता है? (उदा। आआ / bbb.c) लेकिन फिर भी एक्सटेंशन के बिना सबडिर की फ़ाइल को अनदेखा करें। (उदा।

— आका

लगता है कि यह विधि अपेक्षा के अनुरूप काम नहीं करती है जब मैंने पाया कि जब निर्देशिका की कई परतें होती हैं ...

— ड्रैगनक्सवैंग

@dragonxlwang मैं उत्सुक हूँ कि यह कहाँ काम नहीं करेगा? यहां स्वीकृत समाधान stackoverflow.com/a/19023985/1426932 थोड़ा अलग है, और !/**/इसके बजाय का उपयोग करता है !*/; कौनसा सही है? / सीसी @VonC

— timotheecour

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

— पीटर हेलफर

यह

— मेकफाइल

Answer 2

जैसे कुछ जोड़ो

*.o

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

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

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

तुम कोशिश कर सकते हो

*
!*.*

लेकिन वह मूर्ख नहीं है।

Comments

जोड़ा गया संपादन। क्या कोई कारण है कि आप अपने बाइनरी को विस्तार नहीं करना चाहते हैं

— मनोजोसेस

एक्जीक्यूटिव के पास अक्सर एक्सटेंशन नहीं होते हैं। मैं यहाँ द्वारा बनाई गई फ़ाइलों के लिए एक ही बात करने के लिए कोशिश कर रहा हूँ gccगुजर -o $@।

— नाथन लिलिएनथल

Answer 3

सभी निष्पादकों को अपने पास भेजने के लिए .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

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

Answer 4

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

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

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

Answer 5

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

*
!*.c

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

Comments

यह अच्छा होगा यदि आप कम से कम प्रमुख नुकसानों की सूची दें

— pjvds

स्पष्ट नुकसान अनुमति-अस्वीकार नियमों का क्रम है, उचित तरीका केवल अवांछित फ़ाइलों को अनदेखा करना है, सभी को अस्वीकार नहीं करना और फिर केवल इच्छा वाली फ़ाइलों को शामिल करना है।

— आंद्रेई बेलियनकौ

Answer 6

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

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

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

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

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

Comments

अब, यह एक अलग दृष्टिकोण है।

— रेने न्यफेनेगर

Answer 7

बाइनरी फाइलें अक्सर एक्सटेंशन के बिना होती हैं। यदि यह आपका मामला है, तो यह प्रयास करें:

*
!/**/
!*.*

REF: https://stackoverflow.com/a/19023985/1060487

Answer 8

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

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)

Comments

मैंने एक समान स्क्रिप्ट बनाई, और एक डुप्लिकेट प्रश्न पर पोस्ट किया: stackoverflow.com/a/28258619/218294 आपका कोड अच्छे है :) मेरा शायद तेज चलता है क्योंकि यह केवल एक बार "फाइल" चलाता है, या कुछ बार (xargs का उपयोग करके)।

— सैम वाटकिंस

Answer 9

न केवल जड़ में, बल्कि कुछ उपनिषदों में उपेक्षा करने का एक तरीका:

# 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 10

यदि आप अपनी .gitignore फ़ाइल और फ़ाइलों पर इन आदेशों का पालन करते हैं, तब भी लगता है कि आप कोशिश करना चाहते हैं:

git rm --cached FILENAME

उसके बाद, अपना .gitignore, कमिट करें और पुश करें। मुझे समझने में 40 मिनट लगे, उम्मीद है कि यह मेरे जैसे नए लोगों की मदद करेगा

Answer 11

पुराना धागा, लेकिन अभी भी प्रासंगिक है। मैंने मेकफाइल को बदल दिया इसलिए लिंक करने के बाद परिणामी बाइनरी फ़ाइल का नाम [फ़ाइलनाम] है। बिन के बजाय केवल [filname]। फिर मैंने gitignore में * .bin फाइलें जोड़ीं।
यह दिनचर्या मेरी जरूरतों को पूरा करती है।

Answer 12

मैं किसी भी अन्य समाधान नहीं जानता, लेकिन उन्हें एक-एक करके जोड़ रहा हूं .gitignore।

परीक्षण का एक कच्चा तरीका फ़ाइल कमांड के आउटपुट को टटोलना है:

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

संपादित करें

आप केवल निष्पादन योग्य नाम क्यों नहीं रखते hello.bin?

Comments

क्योंकि फ़ाइल एक्सटेंशन के साथ निष्पादन नामकरण .binखराब अभ्यास है।

— एमडी एक्सएफ

Answer 13

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

Comments

यह भी नामक एक फ़ोल्डर को अनदेखा करेगा hello।

— पैट्रिक डी'प्पोलोनियो

Answer 14

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

/bin
/pkg

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

Answer 15

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

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

मैं संकलित-पूर्वनिर्धारित निर्देशिकाओं में संकलित फाइलों को निम्न .गरिग्नोर लाइन के साथ बाहर करता हूं:

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

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

Answer 16

VenomVendors जवाब पर बिल्डिंग

# Ignore all
*

# Unignore all files with extensions recursively
!**/*.*

# Unignore Makefiles recursively
!**/Makefile

# other .gitignore rules...

Answer 17

अपनी .gitignore फ़ाइल में निम्न जोड़ें:

[^\.]*

स्पष्टीकरण:

[] encloses a character class, e.g. [a-zA-Z] means "any letter".
^  means "not"
\. means a literal dot - without the backslash . means "any character"
*  means "any number of these characters"

Answer 18

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

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