gitignore không có tệp nhị phân

Làm thế nào có thể bỏ qua các tệp nhị phân trong gitviệc sử dụng .gitignoretệp?

Thí dụ:

$ g++ hello.c -o hello

Tệp "xin chào" là một tệp nhị phân. Có thể gitbỏ qua tập tin này?

# 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

Thêm một cái gì đó như

*.o

trong tệp .gitignore và đặt nó vào thư mục gốc của repo của bạn (hoặc bạn có thể đặt trong bất kỳ thư mục con nào bạn muốn - nó sẽ áp dụng từ cấp đó trở đi) và kiểm tra nó.

Biên tập:

Đối với các tệp nhị phân không có phần mở rộng, tốt hơn hết bạn nên đặt chúng vào bin/hoặc một số thư mục khác. Sau đó, không có bỏ qua dựa trên loại nội dung.

Bạn co thể thử

*
!*.*

nhưng đó không phải là hoàn hảo.

Để nối tất cả các tệp thực thi vào .gitignore(mà bạn có thể có nghĩa là "tệp nhị phân" đánh giá từ câu hỏi của bạn), bạn có thể sử dụng

find . -executable -type f >>.gitignore

Nếu bạn không quan tâm đến việc sắp xếp các dòng trong bạn .gitignore, bạn cũng có thể cập nhật lệnh của bạn .gitignorebằng lệnh sau đây cũng sẽ loại bỏ trùng lặp và giữ nguyên thứ tự chữ cái.

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

Lưu ý, rằng bạn không thể dẫn đầu ra trực tiếp .gitignore, bởi vì điều đó sẽ cắt bớt tệp trước khi catmở nó để đọc. Ngoài ra, bạn có thể muốn thêm \! -regex '.*/.*/.*'dưới dạng tùy chọn để tìm nếu bạn không muốn bao gồm các tệp thực thi trong thư mục con.

Đặt cược tốt nhất của bạn với nhị phân là cung cấp cho chúng một tiện ích mở rộng mà bạn có thể dễ dàng lọc ra bằng một mẫu chuẩn hoặc đặt chúng vào các thư mục mà bạn có thể lọc ra ở cấp thư mục.

Đề xuất tiện ích mở rộng được áp dụng nhiều hơn trong Windows, vì các tiện ích mở rộng là tiêu chuẩn và cơ bản là bắt buộc, nhưng trong Unix, bạn có thể hoặc không thể sử dụng các tiện ích mở rộng trên các tệp nhị phân thực thi của mình. Trong trường hợp này, bạn có thể đặt chúng vào thùng / thư mục và thêm bin/vào .gitignore của bạn.

Trong ví dụ rất cụ thể, phạm vi nhỏ của bạn, bạn chỉ có thể đặt hellovào .gitignore của mình.

Bạn có thể thử trong .gitignore:

*
!*.c

Cách tiếp cận này có nhiều nhược điểm, nhưng nó được chấp nhận cho các dự án nhỏ.

Nếu bạn đang sử dụng tệp tạo tệp, bạn có thể thử sửa đổi quy tắc tạo của mình để nối tên của các tệp nhị phân mới vào tệp .gitignore của bạn.

Đây là một ví dụ Makefile cho một dự án Haskell nhỏ;

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

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

Makefile này định nghĩa một quy tắc để tạo các tệp thực thi từ mã Haskell. Sau khi ghc được gọi, chúng tôi kiểm tra .gitignore để xem nhị phân đã có trong đó chưa. Nếu không, chúng tôi sẽ thêm tên của tệp nhị phân vào tệp.

Các tệp nhị phân thường không có phần mở rộng. Nếu đây là trường hợp của bạn, hãy thử điều này:

*
!/**/
!*.*

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

Đây là một giải pháp khác sử dụng tập tin. Bằng cách này, các kịch bản thực thi sẽ không kết thúc trong gitignore. Bạn có thể cần thay đổi cách xuất ra từ tệp để phù hợp với hệ thống của bạn. Sau đó, người ta có thể thiết lập một hook hook trước để gọi script này mỗi khi bạn cam kết.

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)

Một cách để bỏ qua trong một số thư mục con, không chỉ trong một thư mục gốc:

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

Hoặc, nếu bạn chỉ muốn bao gồm một số loại tệp cụ thể:

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

Có vẻ như nó cũng có thể hoạt động như mọi thư mục con mới nếu bạn muốn!:

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

Chém hàng đầu chỉ quan trọng trong hai dòng đầu tiên và tùy chọn khác. Đuôi chém trong !/*/và !/subdir/cũng là tùy chọn, nhưng chỉ trong dòng này.

Nếu bạn làm theo các lệnh này trên tệp .gitignore của bạn và các tệp dường như vẫn xuất hiện, bạn có thể muốn thử:

git rm --cached FILENAME

Sau đó, thêm .gitignore của bạn, cam kết và đẩy. Mất 40 phút để hiểu điều đó, hy vọng điều này sẽ giúp những người mới như tôi

Chủ đề cũ, nhưng vẫn có liên quan. Tôi đã thay đổi makefile để tệp nhị phân kết quả sau khi liên kết có tên [tên tệp]. bin thay vì chỉ [tên tệp]. Sau đó, tôi đã thêm các tệp * .bin trong gitignore.
Thói quen này đáp ứng nhu cầu của tôi.

Tôi không biết bất kỳ giải pháp nào khác ngoài việc thêm từng cái một vào .gitignore.

Một cách thô để kiểm tra là grep đầu ra của lệnh tệp:

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

BIÊN TẬP

Tại sao bạn không chỉ đơn giản gọi tên bạn thực thi hello.bin?

Chỉ cần thêm hellohoặc /hellovào .gitignore của bạn. Hoặc là hoạt động.

Tôi đã tạo một tệp .gitignore với hai mục trong thư mục GOPATH.

/bin
/pkg

Nó bỏ qua tất cả các phát triển biên dịch, hiện tại.

.gitignore sử dụng lập trình toàn cầu để lọc các tệp, ít nhất là trên Linux.

Tôi chuẩn bị nói chuyện mã hóa tại Meetup và, để chuẩn bị, tôi đã tạo một thư mục với một số thư mục con được đặt tên theo thứ tự tôi muốn trình bày chúng: 01_subject1, 02_subject2, 03_subject3. Mỗi thư mục con chứa một tệp nguồn có phần mở rộng phụ thuộc ngôn ngữ sẽ biên dịch thành tệp thực thi có tên khớp với tên tệp nguồn mà không có phần mở rộng theo thông lệ.

Tôi loại trừ các tệp đã biên dịch trong các thư mục có tiền tố số với dòng .gitignore sau:

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

Theo sự hiểu biết của tôi về tài liệu này, nó không nên hoạt động. Có dấu hoa thị nên không thành công vì nó phù hợp với bất kỳ số lượng ký tự không xác định nào, bao gồm cả '.' + gia hạn. Việc bỏ dấu hoa thị sẽ không thành công (và không) vì [!\.]chỉ khớp với một ký tự không theo chu kỳ. Tuy nhiên, tôi đã thêm dấu hoa thị, như tôi đã làm cho một biểu thức thông thường, và nó hoạt động. Bằng cách làm việc, tôi có nghĩa là git thông báo thay đổi tệp nguồn, nhưng không phải là sự tồn tại hoặc thay đổi đối với các tệp được biên dịch.

Xây dựng trên VenomVendors trả lời

# Ignore all
*

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

# Unignore Makefiles recursively
!**/Makefile

# other .gitignore rules...

Thêm phần sau vào tệp .gitignore của bạn:

[^\.]*

Giải trình:

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

Cơ .gitignorechế chỉ hoạt động dựa trên tên tệp , không phải trên nội dung tệp . Trở thành một tệp nhị phân là một thuộc tính của nội dung, do đó bạn không thể yêu cầu git bỏ qua các tệp nhị phân trực tiếp mà chỉ bỏ qua chúng theo tên (và như được đề xuất khác, bạn có thể thêm tất cả các tên tệp nhị phân vào .gitignorehoặc sử dụng một tên thích hợp quy ước đặt tên).

Thực tế .gitignorehoạt động trên tên tệp là một đặc tính quan trọng về hiệu năng: Git chỉ cần liệt kê các tệp, nhưng không mở và đọc chúng để biết tệp nào cần bỏ qua. Nói cách khác, Git sẽ rất chậm nếu bạn có thể yêu cầu nó bỏ qua các tệp dựa trên nội dung của chúng.