ikili dosyalar olmadan gitignore

Nasıl ikili dosyalar göz ardı edilebilir gitkullanarak .gitignoredosyayı?

Misal:

$ g++ hello.c -o hello

"Merhaba" dosyası bir ikili dosyadır. Can gitbu dosyayı görmezden?

# 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

Gibi bir şey ekle

*.o

.gitignore dosyasında kopyalayın ve deponuzun kök dizinine yerleştirin (veya istediğiniz alt dizine yerleştirebilirsiniz - bu düzeyden geçerli olacaktır) ve check-in yapın.

Düzenle:

Uzantısı olmayan ikili dosyalar için bunları bin/veya başka bir klasöre yerleştirmeniz daha iyi olur . Sonuçta içerik türüne göre yoksayma yoktur.

Deneyebilirsin

*
!*.*

ama bu kusursuz değildir.

Tüm yürütülebilir dosyaları .gitignore(muhtemelen soruna bakarak “ikili dosya” ile kastedilen) eklemek için şunu kullanabilirsiniz:

find . -executable -type f >>.gitignore

Satırlarınızdaki satırların sırasını önemsemiyorsanız, yinelemeleri de kaldıran ve alfabetik sıralamayı olduğu gibi tutan aşağıdaki komutla .gitignoreda güncelleyebilirsiniz .gitignore.

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

Doğrudan çıktıya yöneltemeyeceğinizi unutmayın .gitignore, çünkü bu dosyayı catokumak için açmadan önce keser . Ayrıca, \! -regex '.*/.*/.*'alt dizinlere yürütülebilir dosyalar eklemek istemiyorsanız bulmak için bir seçenek olarak eklemek isteyebilirsiniz.

İkililerle yaptığınız en iyi bahis, onlara standart bir desenle kolayca filtre uygulayabileceğiniz bir uzantı vermek veya bunları dizin düzeyinde filtreleyebileceğiniz dizinlere koymaktır.

Uzantı önerisi Windows için daha geçerlidir, çünkü uzantılar standart ve temel olarak gereklidir, ancak Unix'te yürütülebilir ikili dosyalarınızda uzantıları kullanabilir veya kullanmayabilirsiniz. Bu durumda, bunları bir bin / klasöre koyabilir ve bin/.gitignore'unuza ekleyebilirsiniz .

Çok özel, küçük kapsamlı bir örnekte, hello.gitignore'nuzu girebilirsiniz.

Şunları deneyebilirsiniz .gitignore:

*
!*.c

Bu yaklaşımın birçok dezavantajı vardır, ancak küçük projeler için kabul edilebilir.

Bir makefile kullanıyorsanız, yeni ikili dosyaların adlarını .gitignore dosyanıza eklemek için make kurallarınızı değiştirmeyi deneyebilirsiniz.

İşte küçük bir Haskell projesi için Makefile örneği;

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

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

Bu makefile, Haskell kodundan yürütülebilir dosyalar oluşturmak için bir kural tanımlar. Ghc çağrıldıktan sonra, ikili dosyada zaten olup olmadığını görmek için .gitignore öğesini kontrol ederiz. Değilse, ikilinin adını dosyaya ekleriz.

İkili dosyalar genellikle uzantısızdır. Durum buysa, şunu deneyin:

*
!/**/
!*.*

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

İşte dosya kullanan başka bir çözüm. Bu şekilde çalıştırılabilir komut dosyaları gitignore ile sonuçlanmaz. Dosyadan çıktının sisteminize uyacak şekilde nasıl yorumlanacağını değiştirmeniz gerekebilir. Daha sonra, her komut verdiğinizde bu komut dosyasını çağırmak için bir ön işleme kanca ayarlanabilir.

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)

Sadece bir kökte değil, bazı alt dizelerde yoksaymanın bir yolu:

# 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/**/*.*

Veya yalnızca belirli dosya türlerini dahil etmek istiyorsanız:

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

İsterseniz her yeni alt dizin için bile işe yarayabilir gibi görünüyor !:

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

Öncü eğik çizgiler yalnızca ilk iki satırda önemlidir ve diğer satırlarda isteğe bağlıdır. Kuyruk eğik çizgi !/*/ve !/subdir/ayrıca isteğe bağlıdır, ancak sadece bu satırda.

Bu komutları .gitignore dosyanızda uygularsanız ve dosyalar hala görünüyor gibi görünüyorsa, denemek isteyebilirsiniz:

git rm --cached FILENAME

Bundan sonra .gitignore'nuzu ekleyin, taahhüt edin ve itin. Bunu anlamam için 40 dakika sürdü, umarım bu benim gibi yeni başlayanlara yardımcı olur

Eski iplik, ama yine de alakalı. Ben makefile değiştirdikten sonra bağlantı sonra ortaya çıkan ikili dosya [filname] adı var. yalnızca [filname] yerine bin . Sonra gitignore'a * .bin dosyaları ekledim.
Bu rutin ihtiyaçlarımı karşılıyor.

Başka bir çözüm bilmiyorum ama onları birer birer ekliyorum .gitignore.

Test etmenin kaba bir yolu, dosya komutunun çıktısını grep etmektir:

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

DÜZENLE

Neden sadece çalıştırılabilir olarak adlandırmıyorsunuz hello.bin?

Sadece .gitignore'nuza ekleyin helloveya ekleyin /hello. İkisi de işe yarıyor.

GOPATH dizininde iki girişli bir .gitignore dosyası oluşturdum.

/bin
/pkg

Şu anda derlenen tüm gelişmeleri görmezden geliyor.

.gitignore en azından Linux'ta dosyaları filtrelemek için glob programlama kullanır .

Bir Meetup'ta bir kodlama konuşması yapmak üzereyim ve hazırlıkta, onları sunmak istediğim sıraya göre adlandırılan birkaç alt dizine sahip bir dizin yaptım: 01_subject1, 02_subject2, 03_subject3. Her alt dizin, yaygın uygulamaya göre, adı kaynak dosya adıyla uzantı olmadan eşleşen yürütülebilir bir dosyaya derlenen, dile bağlı bir uzantıya sahip bir kaynak dosyası içerir.

Aşağıdaki .gitignore satırı ile sayısal önekli dizinlerde derlenen dosyaları hariç tutuyorum:

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

Dokümanları anladığım kadarıyla işe yaramıyor. Sondaki yıldız işaretine sahip olmak başarısız olmalıdır çünkü '.' Dahil olmak üzere herhangi bir sayıda belirtilmemiş karakterle eşleşmelidir. + uzantı. Sondaki yıldız işaretini atlamak başarısız olur (ve yapar) çünkü [!\.]yalnızca tek bir nokta olmayan karakterle eşleşir. Ancak, düzenli bir ifade için yaptığım gibi sondaki yıldız işaretini ekledim ve işe yarıyor. İşe göre, git , kaynak dosyada değişiklik olduğunu fark eder, ancak derlenmiş dosyaların varlığını veya değişikliklerini değiştirmez.

VenomVendors cevabı üzerine inşa

# Ignore all
*

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

# Unignore Makefiles recursively
!**/Makefile

# other .gitignore rules...

Aşağıdakileri .gitignore dosyanıza ekleyin:

[^\.]*

Açıklama:

[] 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"

.gitignoreMekanizma yalnızca dosya dayalı çalışır isimlerin değil dosya üzerinde, içindekiler . İkili dosya olmak, içeriğin bir özelliğidir, bu nedenle git'in ikili dosyaları doğrudan yoksaymasını istemezsiniz, ancak yalnızca adlarına göre yoksaymasını istersiniz (ve diğer önerilenler gibi, tüm ikili dosya adlarını bilgisayarınıza ekleyebilir .gitignoreveya uygun bir adlandırma kuralı).

.gitignoreDosya adlarında çalışan gerçeği, performans açısından önemli bir özelliktir: Git'in yalnızca dosyaları listelemesi gerekir, ancak hangi dosyaların göz ardı edileceğini bilmek için bunları açıp okuması gerekmez. Başka bir deyişle Git, dosyaları içeriklerine göre yoksaymasını isteyebilseydiniz çok yavaş olurdu.