Jak mogę dodać pusty katalog do repozytorium Git?

Jak mogę dodać pusty katalog (nie zawierający plików) do repozytorium Git?

Innym sposobem na pozostawienie katalogu (prawie) pustego (w repozytorium) jest utworzenie .gitignorepliku w tym katalogu, który zawiera te cztery wiersze:

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

Nie musisz wtedy porządkować zamówienia tak, jak musisz to zrobić w rozwiązaniu m104 .

Daje to również tę korzyść, że pliki w tym katalogu nie będą wyświetlane jako „bez śledzenia”, gdy wykonujesz status git.

Dokonywanie @GreenAsJade „s komentarz trwałe:

Myślę, że warto zauważyć, że to rozwiązanie działa dokładnie tak, jak postawiono pytanie, ale może nie jest to, czego szukało wiele osób przyglądających się temu pytaniu. To rozwiązanie gwarantuje, że katalog pozostanie pusty. Mówi: „Naprawdę nigdy nie chcę, aby pliki były tutaj rejestrowane”. W przeciwieństwie do „Nie mam jeszcze żadnych plików do sprawdzenia, ale potrzebuję katalogu tutaj, pliki mogą pojawić się później”.

Nie możesz Zobacz często zadawane pytania na temat Git .

Obecnie konstrukcja indeksu git (obszar przejściowy) pozwala tylko na wyświetlanie plików i nikt nie jest wystarczająco kompetentny, aby dokonać zmiany, aby zezwolić na puste katalogi, troszczył się wystarczająco o tę sytuację, aby to naprawić.

Katalogi są dodawane automatycznie podczas dodawania plików w nich zawartych. Oznacza to, że katalogi nigdy nie muszą być dodawane do repozytorium i same nie są śledzone.

Możesz powiedzieć „ git add <dir>”, a tam dodasz pliki.

Jeśli naprawdę potrzebujesz katalogu, aby istniał w kasach, powinieneś utworzyć w nim plik. .gitignore działa dobrze w tym celu; możesz pozostawić puste lub wpisać nazwy plików, które mają się pojawiać w katalogu.

Utwórz pusty plik o nazwie .gitkeepw katalogu i dodaj go.

Zawsze możesz umieścić plik README w katalogu z wyjaśnieniem, dlaczego chcesz ten katalog, w przeciwnym razie pusty, w repozytorium.

touch .keep

W systemie Linux tworzy to pusty plik o nazwie .keep. Jak na to jest warte, ta nazwa jest agnostyczna dla Git, podczas gdy .gitkeepbyłaby specyficzna dla Git. Po drugie, jak zauważył inny użytkownik, .gitkonwencja prefiksów powinna być zarezerwowana dla plików i katalogów, z których korzysta sam Git.

Alternatywnie, jak zauważono w innej odpowiedzi , katalog może zawierać zamiast tego opis READMElub README.mdplik .

Oczywiście wymaga to, aby obecność pliku nie spowodowała awarii aplikacji.

Po co nam puste foldery z wersją

Po pierwsze:

Pusty katalog nie może być częścią drzewa w systemie wersjonowania Git .

To po prostu nie będzie śledzone. Są jednak scenariusze, w których „wersjonowanie” pustych katalogów może mieć znaczenie, na przykład:

• rusztowanie wstępnie zdefiniowanej struktury folderów , udostępniając ją każdemu użytkownikowi / współautorowi repozytorium; lub, w wyspecjalizowanym przypadku powyżej, utworzenie folderu dla plików tymczasowych , takich jak a cache/lub logs/katalogi, w których chcemy udostępnić folder, ale .gitignorejego zawartość
• w związku z powyższym niektóre projekty nie będą działać bez niektórych folderów (co często jest oznaką źle zaprojektowanego projektu, ale jest to częsty scenariusz w świecie rzeczywistym i być może mogą wystąpić problemy z pozwoleniem, które można rozwiązać).

Niektóre sugerowane obejścia

Wielu użytkowników sugeruje:

1. Umieszczenie READMEpliku lub innego pliku z pewną zawartością, aby katalog nie był pusty, lub
2. Tworzenie .gitignorepliku z pewnego rodzaju „logiką odwrotną” (tj. Obejmującą wszystkie pliki), która na końcu służy temu samemu celowi podejścia nr 1.

Chociaż oba rozwiązania na pewno działają, uważam je za niespójne z sensownym podejściem do wersji Git.

• Dlaczego powinieneś umieszczać fałszywe pliki lub pliki README, których być może tak naprawdę nie chcesz w swoim projekcie?
• Po .gitignoreco robić coś ( utrzymywanie plików), co jest przeciwieństwem tego, do czego jest przeznaczony (z wyłączeniem plików), chociaż jest to możliwe?

. podejście gitkeep

Użyj pustego pliku o nazwie .gitkeepw celu wymuszenia obecności folderu w systemie kontroli wersji.

Chociaż może się to nie wydawać tak dużą różnicą:

• Używasz pliku, którego jedynym celem jest utrzymanie folderu. Nie umieszczasz tam żadnych informacji, których nie chcesz umieszczać.

  Na przykład powinieneś używać plików README jako plików README z przydatnymi informacjami, a nie pretekstem do przechowywania folderu.

  Oddzielenie problemów jest zawsze dobrą rzeczą i nadal możesz dodać znak, .gitignoreaby zignorować niechciane pliki.

• Nadanie jej .gitkeepnazwy sprawia, że ​​z samej nazwy pliku (a także innych programistów , co jest dobre dla wspólnego projektu i jednego z głównych celów repozytorium Git), jest bardzo jasne i proste, że ten plik to

  • Plik niezwiązany z kodem (ze względu na wiodącą kropkę i nazwę)
  • Plik wyraźnie powiązany z Git
  • Jego cel ( utrzymanie ) jest jasno określony, spójny i semantycznie przeciwny w znaczeniu ignorowania

Adopcja

Widziałem .gitkeeppodejście przyjęte przez bardzo ważne platformy, takie jak Laravel , Angular-CLI .

Jak opisano w innych odpowiedziach, Git nie może reprezentować pustych katalogów w swoim obszarze testowym. (Zobacz często zadawane pytania na temat Git .) Jeśli jednak, dla twoich celów, katalog jest wystarczająco pusty, jeśli zawiera .gitignoretylko plik, możesz tworzyć .gitignorepliki w pustych katalogach tylko poprzez:

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

Andy Lester ma rację, ale jeśli twój katalog musi być pusty, a nie pusty pusty, możesz umieścić tam pusty .gitignoreplik jako obejście.

Nawiasem mówiąc, jest to kwestia implementacji, a nie podstawowy problem projektowania pamięci Git. Jak wielokrotnie wspomniano na liście mailowej Git, powodem tego nie jest to, że nikt nie dbał o to, aby przesłać łatkę, nie dlatego, że nie można lub nie należy tego robić.

Sposób tworzenia folderu dziennika Ruby on Rails :

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

Teraz katalog dziennika zostanie dołączony do drzewa. Jest bardzo przydatny podczas wdrażania, więc nie będziesz musiał pisać procedury tworzenia katalogów dziennika.

Pliki dziennika można ukryć, wydając,

echo log/dev.log >> .gitignore

ale prawdopodobnie to wiedziałeś.

Git nie śledzi pustych katalogów. Więcej informacji znajdziesz w FAQ Git . Sugerowane obejście polega na umieszczeniu .gitignorepliku w pustym katalogu. Nie podoba mi się to rozwiązanie, ponieważ .gitignorejest „ukryte” przez konwencję Uniksa. Nie ma też wyjaśnienia, dlaczego katalogi są puste.

Proponuję umieścić plik README w pustym katalogu, wyjaśniając, dlaczego ten katalog jest pusty i dlaczego należy go śledzić w Git. Gdy plik README jest na miejscu, w przypadku Git katalog nie jest już pusty.

Prawdziwe pytanie brzmi: dlaczego potrzebujesz pustego katalogu w git? Zwykle masz jakiś skrypt kompilacji, który może utworzyć pusty katalog przed kompilacją / uruchomieniem. Jeśli nie, zrób taki. To zdecydowanie lepsze rozwiązanie niż umieszczanie pustych katalogów w git.

Masz więc powód, dla którego potrzebujesz pustego katalogu w git. Umieść ten powód w pliku README. W ten sposób inni programiści (i przyszły użytkownik) wiedzą, dlaczego pusty katalog musi tam być. Będziesz także wiedział, że możesz usunąć pusty katalog, gdy problem wymagający pustego katalogu został rozwiązany.

Aby wyświetlić listę każdego pustego katalogu, użyj następującego polecenia:

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

Aby utworzyć zastępcze pliki README w każdym pustym katalogu:

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

Aby zignorować wszystko w katalogu oprócz pliku README, wstaw następujące wiersze do .gitignore:

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

Alternatywnie, możesz po prostu wykluczyć ignorowanie każdego pliku README:

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

Aby wyświetlić listę wszystkich plików README po ich utworzeniu:

find -name README.emptydir

OSTRZEŻENIE: Ta poprawka nie działa naprawdę, jak się okazuje. Przepraszam za niedogodności.

Oryginalny post poniżej:

Znalazłem rozwiązanie podczas gry z wewnętrznymi elementami Git!

1. Załóżmy, że jesteś w swoim repozytorium.

2. Utwórz pusty katalog:

   $ mkdir path/to/empty-folder
   

3. Dodaj go do indeksu za pomocą polecenia hydraulicznego i pustego drzewa SHA-1 :

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

   Wpisz polecenie, a następnie wprowadź drugi wiersz. Naciśnij, Entera następnie Ctrl+, Daby zakończyć wprowadzanie. Uwaga: format to tryb [SPACJA] typ [SPACJA] SHA-1hash [TAB] (zakładka jest ważna, formatowanie odpowiedzi jej nie zachowuje).

4. Otóż ​​to! Twój pusty folder znajduje się w twoim indeksie. Wszystko, co musisz zrobić, to zatwierdzić.

To rozwiązanie jest krótkie i najwyraźniej działa dobrze ( patrz EDYCJA! ), Ale nie jest tak łatwe do zapamiętania ...

Puste drzewo SHA-1 można znaleźć, tworząc w nim nowe puste repozytorium Git cdi wydaj polecenie git write-tree, które generuje puste drzewo SHA-1.

EDYTOWAĆ:

Korzystam z tego rozwiązania, odkąd je znalazłem. Wygląda na to, że działa dokładnie tak samo jak tworzenie submodułu, z tym wyjątkiem, że nigdzie nie zdefiniowano żadnego modułu. Prowadzi to do błędów podczas wydawania git submodule init|update. Problem polega na tym, że git update-indexprzepisuje 040000 treeczęść na 160000 commit.

Co więcej, żaden plik umieszczony pod tą ścieżką nigdy nie zostanie zauważony przez Git, ponieważ uważa, że ​​należy on do innego repozytorium. Jest to paskudne, ponieważ można je łatwo przeoczyć!

Jeśli jednak nie korzystasz (i nie będziesz) z żadnych podmodułów Git w swoim repozytorium, a folder „pusty” pozostanie pusty lub jeśli chcesz, aby Git wiedział o jego istnieniu i zignorował jego zawartość, możesz użyć ta poprawka. Postępowanie w zwykły sposób z submodułami wymaga więcej kroków niż to ulepszenie.

Powiedzmy, że potrzebujesz pustego katalogu o nazwie tmp :

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

Innymi słowy, musisz dodać plik .gitignore do indeksu, zanim będziesz mógł powiedzieć Gitowi, aby go zignorował (i wszystko inne w pustym katalogu).

Może dodanie pustego katalogu wydaje się być ścieżką najmniejszego oporu, ponieważ masz skrypty, które oczekują, że ten katalog istnieje (być może dlatego, że jest celem generowanych plików binarnych). Innym podejściem byłoby zmodyfikowanie skryptów w celu utworzenia katalogu zgodnie z potrzebami .

mkdir --parents .generated/bin ## create a folder for storing generated binaries
mv myprogram1 myprogram2 .generated/bin ## populate the directory as needed

W tym przykładzie możesz wpisać (zepsuty) symboliczny link do katalogu, aby uzyskać do niego dostęp bez prefiksu „.generated” (ale jest to opcjonalne).

ln -sf .generated/bin bin
git add bin

Aby wyczyścić drzewo źródłowe, możesz po prostu:

rm -rf .generated ## this should be in a "clean" script or in a makefile

Jeśli często sugerujesz podejście do sprawdzania w prawie pustym folderze, masz niewielką złożoność usuwania zawartości bez usuwania pliku „.gitignore”.

Możesz zignorować wszystkie wygenerowane pliki, dodając następujące elementy do katalogu głównego .gitignore:

.generated

Mam również problem z pustymi katalogami. Problem z używaniem plików zastępczych polega na tym, że trzeba je tworzyć i usuwać, jeśli nie są już potrzebne (ponieważ później dodano podkatalogi lub pliki. Przy dużych drzewach źródłowych zarządzanie tymi plikami zastępczymi może być kłopotliwe i powodować błędy skłonny.

Dlatego postanowiłem napisać narzędzie typu open source, które może automatycznie zarządzać tworzeniem / usuwaniem takich plików zastępczych. Jest napisany dla platformy .NET i działa pod Mono (.NET dla Linux) i Windows.

Wystarczy spojrzeć na: http://code.google.com/p/markemptydirs

Lubię odpowiedzi @ Artur79 i @mjs, więc użyłem kombinacji obu i uczyniłem ją standardową dla naszych projektów.

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

Jednak tylko garstka naszych programistów pracuje na komputerach Mac i Linux. Dużo pracy w systemie Windows i nie mogłem znaleźć równoważnego prostego linijki, aby osiągnąć to samo. Niektórzy mieli szczęście, że zainstalowali Cygwin z innych powodów, ale przepisywanie Cygwin tylko z tego powodu wydawało się przesadą.

Edytuj, aby uzyskać lepsze rozwiązanie

Ponieważ większość naszych programistów ma już zainstalowanego Anta , pierwszą rzeczą, o której pomyślałem, było zebranie pliku kompilacji Anta, aby osiągnąć to niezależnie od platformy. To nadal można znaleźć tutaj

Jednak później pomyślałem, że lepiej byłoby przekształcić to w małe polecenie narzędzia, więc odtworzyłem go za pomocą Pythona i opublikowałem tutaj w PyPI . Możesz go zainstalować, po prostu uruchamiając:

pip3 install gitkeep2

Pozwoli ci to na tworzenie i usuwanie .gitkeepplików rekurencyjnie, a także pozwoli ci dodawać do nich wiadomości, aby Twoi rówieśnicy zrozumieli, dlaczego te katalogi są ważne. Ten ostatni kawałek to bonus. Pomyślałem, że byłoby miło, gdyby .gitkeeppliki mogły być samodokumentujące.

$ gitkeep --help
Usage: gitkeep [OPTIONS] PATH

  Add a .gitkeep file to a directory in order to push them into a Git repo
  even if they're empty.

  Read more about why this is necessary at: https://git.wiki.kernel.org/inde
  x.php/Git_FAQ#Can_I_add_empty_directories.3F

Options:
  -r, --recursive     Add or remove the .gitkeep files recursively for all
                      sub-directories in the specified path.
  -l, --let-go        Remove the .gitkeep files from the specified path.
  -e, --empty         Create empty .gitkeep files. This will ignore any
                      message provided
  -m, --message TEXT  A message to be included in the .gitkeep file, ideally
                      used to explain why it's important to push the specified
                      directory to source control even if it's empty.
  -v, --verbose       Print out everything.
  --help              Show this message and exit.

Mam nadzieję, że uznasz to za przydatne.

Nie możesz i niestety nigdy nie będziesz w stanie. Jest to decyzja podjęta przez samego Linusa Torvalda. On wie, co jest dla nas dobre.

Gdzieś raz czytam.

Znalazłem Re: puste katalogi .. , ale może jest jeszcze jeden.

Musisz żyć z obejściami ... niestety.

Gdy dodajesz .gitignoreplik, jeśli zamierzasz w nim umieścić dowolną ilość treści (którą Git ma zignorować), możesz dodać pojedynczą linię z gwiazdką, *aby upewnić się, że przypadkowo nie dodasz ignorowanej treści .

Nie ma sposobu, aby Git śledził katalogi, więc jedynym rozwiązaniem jest dodanie pliku zastępczego w katalogu, który Git ma śledzić.

Plik można nazwać i zawierać dowolne pliki, ale większość osób używa pustego pliku o nazwie .gitkeep(chociaż niektórzy wolą agnostykę VCS .keep).

Prefiks .oznacza go jako plik ukryty.

Innym pomysłem byłoby dodanie READMEpliku wyjaśniającego, do czego będzie używany katalog.

Jak wspomniano, nie można dodawać pustych katalogów, ale tutaj jest jeden linijka, która dodaje puste pliki .gitignore do wszystkich katalogów.

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

Utknąłem to w pliku Rakefile dla łatwego dostępu.

Rozwiązanie Jamie Flournoy działa świetnie. Oto nieco ulepszona wersja, aby zachować .htaccess:

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

Dzięki takiemu rozwiązaniu masz możliwość popełnienia pusty folder, na przykład /log, /tmpczy /cachei folder pozostanie pusta.

Zawsze buduję funkcję, aby sprawdzić pożądaną strukturę folderów i buduję ją dla siebie w ramach projektu. To rozwiązuje ten problem, ponieważ puste foldery są przechowywane w Git przez proxy.

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");
}

To jest w PHP, ale jestem pewien, że większość języków obsługuje tę samą funkcjonalność, a ponieważ tworzenie folderów jest obsługiwane przez aplikację, foldery zawsze tam będą.

Oto hack, ale zabawne, że to działa (Git 2.2.1). Podobne do sugestii @Teka, ale łatwiejsze do zapamiętania:

• Dodaj submoduł do dowolnego repozytorium ( git submodule add path_to_repo)
• Spowoduje to dodanie folderu i pliku .submodules. Zatwierdź zmianę.
• Usuń .submodulesplik i zatwierdź zmianę.

Teraz masz katalog, który jest tworzony, gdy zatwierdzanie jest sprawdzane. Interesującą rzeczą jest to, że jeśli spojrzysz na zawartość obiektu drzewa tego pliku, otrzymasz:

krytyczny: niepoprawna nazwa obiektu b64338b90b4209263b50244d18278c0999867193

Nie zachęciłbym go jednak do użycia, ponieważ może przestać działać w przyszłych wersjach Gita. Co może spowodować uszkodzenie repozytorium.

Wielu już odpowiedziało na to pytanie. Po prostu dodajemy tutaj wersję PowerShell.

Znajdź wszystkie puste foldery w katalogu

Dodaj tam pusty plik .gitkeep

Get-ChildItem 'Path to your Folder' -Recurse -Directory | Where-Object {[System.IO.Directory]::GetFileSystemEntries($_.FullName).Count -eq 0} | ForEach-Object { New-Item ($_.FullName + "\.gitkeep") -ItemType file}

Jeśli chcesz dodać folder, który pomieści wiele danych przejściowych w wielu katalogach semantycznych, jednym z podejść jest dodanie czegoś takiego do swojego katalogu głównego .gitignore ...

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

Następnie możesz zatwierdzić opisowe pliki README.md (lub puste pliki, nie ma to znaczenia, o ile możesz kierować je unikalnie tak jak *.mdw tym przypadku) w każdym katalogu, aby upewnić się, że wszystkie katalogi pozostaną częścią repo, ale pliki (z rozszerzeniami) są ignorowane. OGRANICZENIE: .w nazwach katalogów nie są dozwolone!

Możesz wypełnić wszystkie te katalogi plikami xml / images lub czymkolwiek i dodawać kolejne katalogi w /app/data/miarę upływu czasu wraz z rozwojem potrzeb pamięci dla Twojej aplikacji (pliki README.md służą do zapisania w opisie tego, do czego służy każdy katalog pamięci) dokładnie).

Nie ma potrzeby dalszej zmiany .gitignorelub decentralizacji poprzez utworzenie nowego .gitignoredla każdego nowego katalogu. Prawdopodobnie nie jest to najmądrzejsze rozwiązanie, ale jest zwięzłe gitignore i zawsze działa dla mnie. Ładnie i prosto! ;)

Łatwym sposobem na to jest dodanie .gitkeeppliku do katalogu, który chcesz (obecnie) pozostawić pusty.

Zobacz tę odpowiedź SOF, aby uzyskać więcej informacji - która wyjaśnia również, dlaczego niektórzy uważają, że konkurencyjna konwencja dodawania pliku .gitignore (jak podano w wielu odpowiedziach tutaj) jest myląca.

Dodanie jeszcze jednej opcji do walki.

Zakładając, że chcesz do tego dodać katalog git, do wszystkich celów związanych z git, powinien pozostać pusty i nigdy nie śledzić jego zawartości, .gitignorejak sugeruje to tutaj wielokrotnie, załatwi sprawę .

Format, jak wspomniano, to:

*
!.gitignore

Teraz, jeśli chcesz to zrobić w wierszu poleceń, jednym zamachem, podczas gdy w katalogu, który chcesz dodać, możesz wykonać:

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

Sam mam skrypt powłoki, którego używam do tego celu. Nazwij skrypt, jak chcesz i dodaj go gdzieś na ścieżce dołączania lub bezpośrednio do niego:

#!/bin/bash

dir=''

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

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

Dzięki temu możesz albo wykonać go z katalogu, który chcesz dodać, albo odwołać się do katalogu jako pierwszego i jedynego parametru:

$ ignore_dir ./some/directory

Inną opcją (w odpowiedzi na komentarz przez @GreenAsJade), jeśli chcesz śledzić pusty folder, który MAJ zawierać śledzone pliki w przyszłości, ale będzie pusta do tej pory można ommit *z .gitignorepliku i sprawdzić , że w. Zasadniczo wszystko, co mówi plik, to „nie ignoruj mnie ”, ale poza tym katalog jest pusty i śledzony.

Twój .gitignoreplik wyglądałby następująco:

!.gitignore

To wszystko, sprawdź to, a masz pusty, ale śledzony katalog, w którym możesz śledzić pliki w późniejszym czasie.

Powodem, dla którego sugeruję zachowanie tej jednej linii w pliku, jest to, że podaje .gitignorecel. W przeciwnym razie ktoś po linii może pomyśleć o jego usunięciu. Może to pomóc, jeśli umieścisz komentarz nad linią.

Czasami masz do czynienia ze źle napisanymi bibliotekami lub oprogramowaniem, które potrzebują „prawdziwego” pustego i istniejącego katalogu. Ułożenie prostego .gitignorelub .keepmoże je złamać i spowodować błąd. W tych przypadkach pomocne mogą być następujące elementy, ale nie ma gwarancji ...

Najpierw utwórz potrzebny katalog:

mkdir empty

Następnie dodajesz uszkodzony symboliczny link do tego katalogu (ale w każdym innym przypadku niż opisany powyżej przypadek użycia, użyj READMEwyjaśnienia):

ln -s .this.directory empty/.keep

Aby zignorować pliki w tym katalogu, możesz dodać go do katalogu głównego .gitignore:

echo "/empty" >> .gitignore

Aby dodać zignorowany plik, użyj parametru, aby go wymusić:

git add -f empty/.keep

Po zatwierdzeniu masz zepsuty link symboliczny w indeksie, a git tworzy katalog. Uszkodzony link ma pewne zalety, ponieważ nie jest zwykłym plikiem i nie wskazuje zwykłego pliku. Tak więc pasuje nawet do części pytania „(która nie zawiera plików)”, nie z intencji, ale ze znaczenia:

find empty -type f

To polecenie pokazuje pusty wynik, ponieważ w tym katalogu nie ma żadnych plików. Dlatego większość aplikacji, które pobierają wszystkie pliki z katalogu, zwykle nie widzi tego linku, przynajmniej jeśli robi to „plik istnieje” lub „jest czytelny”. Nawet niektóre skrypty nie znajdą tam żadnych plików:

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

Ale zdecydowanie zalecam stosowanie tego rozwiązania tylko w szczególnych okolicznościach, dobre napisanie READMEw pustym katalogu jest zwykle lepszym rozwiązaniem. (I nie wiem, czy to działa z systemem plików Windows ...)

Czytając odpowiedzi @ofavre i @ stanislav-bashkyrtsev przy użyciu zepsutych odniesień do podmoduła GIT w celu utworzenia katalogów GIT, jestem zaskoczony, że nikt nie zasugerował jeszcze tej prostej zmiany pomysłu, aby wszystko było rozsądne i bezpieczne:

Zamiast włamać fałszywy submoduł do GIT , po prostu dodaj pusty prawdziwy .

Wpisz: https://gitlab.com/empty-repo/empty.git

Repozytorium GIT z dokładnie jednym zatwierdzeniem:

commit e84d7b81f0033399e325b8037ed2b801a5c994e0
Author: Nobody <none>
Date: Thu Jan 1 00:00:00 1970 +0000

Bez wiadomości, bez zatwierdzonych plików.

Stosowanie

Aby dodać pusty katalog do repozytorium GIT:

git submodule add https://gitlab.com/empty-repo/empty.git path/to/dir

Aby przekonwertować wszystkie istniejące puste katalogi na submoduły:

find . -type d -empty -delete -exec git submodule add -f https://gitlab.com/empty-repo/empty.git \{\} \;

Podczas tworzenia odwołania do podmodułu Git zapisze najnowszy skrót zatwierdzenia, więc nie musisz się martwić o mnie (lub GitLab) używającego go do wstrzykiwania złośliwych plików. Niestety nie znalazłem żadnego sposobu na wymuszenie, który identyfikator zatwierdzenia jest używany podczas realizacji transakcji, więc będziesz musiał ręcznie sprawdzić, czy identyfikator zatwierdzenia referencyjnego jest e84d7b81f0033399e325b8037ed2b801a5c994e0używany git submodule statuspo dodaniu repo.

Nadal nie rodem rozwiązanie, ale najlepsze, prawdopodobnie może mieć bez kogoś uzyskiwanie ręce naprawdę , naprawdę brudne w kodzie GIT.

Dodatek: Odtwarzanie tego zatwierdzenia

Powinieneś być w stanie odtworzyć to dokładne zatwierdzenie, używając (w pustym katalogu):

# Initialize new GIT repository
git init

# Set author data (don't set it as part of the `git commit` command or your default data will be stored as “commit author”)
git config --local user.name "Nobody"
git config --local user.email "none"

# Set both the commit and the author date to the start of the Unix epoch (this cannot be done using `git commit` directly)
export GIT_AUTHOR_DATE="Thu Jan 1 00:00:00 1970 +0000"
export GIT_COMMITTER_DATE="Thu Jan 1 00:00:00 1970 +0000"

# Add root commit
git commit --allow-empty --allow-empty-message --no-edit

Tworzenie powtarzalnych zatwierdzeń GIT jest zaskakująco trudne…

Nie możesz Jest to celowa decyzja projektantów wydana przez opiekunów Git. Zasadniczo celem systemu zarządzania kodem źródłowym, takiego jak Git, jest zarządzanie kodem źródłowym, a puste katalogi nie są kodem źródłowym. Git jest również często opisywany jako narzędzie do śledzenia zawartości, a puste katalogi nie są treściami (wręcz przeciwnie), więc nie są śledzone.

Możesz zapisać ten kod jako create_readme.php i uruchomić kod PHP z katalogu głównego swojego projektu Git.

> php create_readme.php

Dodaje pliki README do wszystkich pustych katalogów, aby katalogi te zostały dodane do indeksu.

<?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
            }
        }
?>

Więc zrób

git commit -m "message"
git push