Jak Mogę dodać pusty katalog do repozytorium Git?

Nie możesz. Zobacz GIT FAQ .

Obecnie projekt indeksu git (miejsce postoju) zezwala tylko na być na liście, a nikt wystarczająco kompetentny aby dokonać zmiany zezwalającej na puste katalogów dbał wystarczająco o ta sytuacja, aby to naprawić.

Katalogi są dodawane automatycznie podczas dodawania plików wewnątrz nich. Że jest, katalogi nigdy nie muszą być dodawane do repozytorium i nie są śledzone sami.

Możesz powiedz "git add <dir> " i to doda tam pliki.

Jeśli naprawdę potrzebujesz katalogu do istnieje w kasach należy utworzyć / align = "left" / .gitignore działa dobrze dla tego celu; można pozostawić puste, lub wpisz nazwy plików, które spodziewaj się, że pojawi się w katalogu.

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

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

touch .keep

W Linuksie tworzy to pusty plik o nazwie .keep. Ta nazwa jest preferowana zamiast .gitkeep, ponieważ pierwsza jest agnostyczna dla Git, podczas gdy druga jest specyficzna dla Git. Po drugie, jak zauważył inny użytkownik, konwencja prefiksu .git powinna być zarezerwowana dla plików i katalogów, których używa Sam Git.

Alternatywnie, jak zaznaczono w innej odpowiedzi , katalog może zawierać opis README lub README.md zamiast pliku.

Oczywiście wymaga to obecność pliku nie spowoduje pęknięcia aplikacji.

Po co nam puste wersjonowane foldery

Po pierwsze:

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

To po prostu nie będzie śledzone. Istnieją jednak scenariusze, w których "wersjonowanie" pustego katalogu może być użyteczne, na przykład:

• budowanie predefiniowanej struktury folderów dla użytecznych folderów projektu i udostępnienie tej struktury każdemu użytkownikowi / współtwórcy projektu repozytorium; lub, w wyspecjalizowanym przypadku powyżej, tworzenie folderu dla plików tymczasowych , takich jak cache/ lub logs/ katalogów
• niektóre projekty po prostu nie będą działać bez niektórych folderów (co jest często wskazówką źle zaprojektowanego projektu, ale jest to częsty scenariusz w świecie rzeczywistym i może być, powiedzmy, problemy z uprawnieniami).

Niektóre sugerowane obejścia

Wielu użytkowników sugeruje:

1. umieszczenie pliku README lub innego Plik z pewną zawartością w celu uczynienia katalogu niepustym lub
2. Tworzenie pliku .gitignore z rodzajem "odwrotnej logiki" (tj. do włączenia wszystkich plików), który na końcu służy temu samemu celowi podejścia #1.

Podczas gdy oba rozwiązania na pewno działają uważam, że nie istnieją ze znaczącym podejściem do wersjonowania Gita.

• dlaczego masz umieszczać fałszywe pliki lub odczyty, których może nie chcesz w swoim projekcie?
• dlaczego użyć {[3] } do zrobienia rzeczy (przechowującej pliki), która jest przeciwieństwem tego, do czego jest przeznaczona (wyłączając pliki), nawet jeśli jest to możliwe?

.podejście gitkeep

Użyj pustego pliku o nazwie .gitkeep, aby wymusić obecność folderu w systemie wersjonowania.

Choć może się wydawać, że nie taka duża różnica:

• Używasz pliku, który ma pojedynczy cel przechowywania folderu. Ty nie umieść tam wszelkie informacje, których nie chcesz umieścić.

  Na przykład, powinieneś używać READMEs jako, Cóż, READMEs z użytecznymi informacjami, a nie jako pretekstu do zachowania folderu.

  Rozdzielenie obaw jest zawsze dobrą rzeczą, i nadal możesz dodać .gitignore, aby zignorować niechciane pliki.

• Nazwanie go .gitkeep sprawia, że jest on bardzo jasny i prosty od samej nazwy pliku (a także do innych programistów, co jest dobre dla wspólnego projektu i jednego z podstawowych cele repozytorium Git), że plik ten jest

  • plik niezwiązany z kodem (ze względu na wiodącą kropkę i nazwę)
  • plik wyraźnie powiązany z Git
  Jego celem (zachować) jest jasno określone i spójne i semantycznie przeciwne w jego znaczeniu do ignorować

Adopcja

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

Jak opisano w innych odpowiedziach, Git nie jest w stanie reprezentować pustych katalogów w swoim obszarze przejściowym. (Zobacz Git FAQ .) Jeśli jednak, dla Twoich celów, katalog jest wystarczająco pusty, jeśli zawiera tylko plik .gitignore, możesz tworzyć pliki .gitignore tylko w pustych katalogach za pomocą:

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 plik .gitignore jako obejście.

Na marginesie, jest to problem z implementacją, a nie podstawowy problem z projektowaniem pamięci Git. Jak już wielokrotnie wspomniano na liście dyskusyjnej Git, powodem, dla którego nie zostało to zaimplementowane, jest to, że nikt nie troszczył się na tyle, aby przesłać do niego łatkę, a nie to, że nie można lub nie powinno się tego zrobić.

The Ruby on Rails way:

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

Teraz katalog logów zostanie dołączony do drzewa. Jest to bardzo przydatne podczas wdrażania, więc nie będziesz musiał pisać procedury, aby tworzyć katalogi dziennika.

Pliki dziennika mogą być przechowywane przez wystawienie,

echo log/dev.log >> .gitignore

Git nie śledzi pustych katalogów. Zobacz Git FAQ po więcej wyjaśnień. Sugerowanym obejściem jest umieszczenie pliku .gitignore w pustym katalogu. Nie podoba mi się to rozwiązanie, ponieważ .gitignore jest "ukryty" w konwencji Uniksa. Nie ma również wyjaśnienia, dlaczego katalogi są puste.

Proponuję umieścić plik README w pustym katalogu wyjaśniający dlaczego katalog jest pusty i dlaczego musi być śledzony w Git. Z plikiem README w miejscu, o ile Git jest katalog nie jest już pusty.

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

Więc masz jakiś powód, dla którego potrzebujesz pustego katalogu w git. Umieść ten powód w pliku README. W ten sposób inni deweloperzy (i przyszły ty) wiedzą, dlaczego pusty katalog musi tam być. Będziesz również wiedzieć, że możesz usunąć pusty katalog, gdy problem wymagający pustego katalogu został rozwiązany.

Aby wyświetlić listę wszystkich pustych katalogów użyj następującego polecenia:

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

Aby utworzyć placeholder READMEs 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 z wyjątkiem pliku README umieść następujące linie w .gitignore:

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

Alternatywnie, można po prostu wykluczyć każdy Plik README z ignorowania:

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

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

find -name README.emptydir

UWAGA: Ta zmiana nie działa tak naprawdę, jak się okazuje. przepraszamy za niedogodności.

Oryginalny post poniżej:

Znalazłem rozwiązanie podczas gry z git internals!

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 plumbing i pustego drzewa SHA-1:

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

   Wpisz polecenie, a następnie wprowadź drugi Kolejka Naciśnij Enter , a następnie Ctrl + d aby zakończyć wejście. Uwaga: formatem jest mode [SPACE] type [SPACE] SHA-1hash [TAB] path (karta jest ważna, formatowanie odpowiedzi jej nie zachowuje).

4. To jest to! Twój pusty folder znajduje się w indeksie. Musisz się tylko zaangażować.

To rozwiązanie jest krótkie i najwyraźniej działa dobrze (Zobacz edycję!), ale nie jest tak łatwo pamiętaj...

Puste drzewo SHA - 1 można znaleźć poprzez utworzenie nowego pustego repozytorium Git, cd do niego i wydanie git write-tree, które wyświetla puste drzewo SHA-1.

EDIT:

Używam tego rozwiązania, odkąd go znalazłem. Wygląda na to, że działa dokładnie tak samo jak tworzenie podmodułu, z tym wyjątkiem, że żaden moduł nie jest nigdzie zdefiniowany. Prowadzi to do błędów przy wystawianiu git submodule init|update. Problem polega na tym, że git update-index przepisuje 040000 tree część na 160000 commit.

Ponadto każdy plik umieszczone pod tą ścieżką nigdy nie zostaną zauważone przez Git, ponieważ uważa, że należą one do innego repozytorium. To jest paskudne, ponieważ można je łatwo przeoczyć!

Jeśli jednak nie używasz (i nie będziesz) żadnych podmodułów Git w swoim repozytorium, a" pusty " folder pozostanie pusty lub jeśli chcesz, aby Git wiedział o jego istnieniu i ignorował jego zawartość, możesz przejść do tej zmiany. Przechodzenie w zwykły sposób z modułami podrzędnymi zajmuje więcej kroków, niż To dostosowanie.

Być może dodanie pustego katalogu wydaje się być ścieżką o najmniejszym oporze, ponieważ masz skrypty, które oczekują istnienia tego katalogu (może dlatego, że jest on celem dla wygenerowanych binariów). Innym podejściem byłoby zmodyfikować skrypty, aby utworzyć katalog w razie potrzeby .

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 sprawdzić (uszkodzony) dowiązanie symboliczne do katalogu, aby uzyskać do niego dostęp bez".wygenerowany " prefiks (ale to jest opcjonalnie).

ln -sf .generated/bin bin
git add bin

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

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

Jeśli przyjmiesz często sugerowane podejście sprawdzania w prawie pustym folderze, masz niewielką złożoność usuwania zawartości bez usuwania również ".gitignore " plik.

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

.generated

Załóżmy, ż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ć .gitignore plik do indeksu zanim będziesz mógł powiedzieć Gitowi, aby go zignorował (i wszystko inne w pustym katalogu).

Też miałem do czynienia z problemem pustych katalogów. Problem z używaniem plików zastępczych polega na tym, że trzeba je utworzyć i usunąć, jeśli nie są już potrzebne (ponieważ później dodano podkatalogi lub pliki. Dzięki dużym drzewom źródłowym zarządzanie tymi plikami zastępczymi może być uciążliwe i podatne na błędy.

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

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

Nie możesz i niestety nigdy nie będziesz w stanie. Decyzja ta została podjęta przez samego Linusa Torvalda. Wie, co jest dla nas dobre.

Gdzieś tam gdzieś czytałem kiedyś rant.

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

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

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

Lubię odpowiedzi @Artur79 i @ mjs, więc używam kombinacji obu i uczyniłem to standardem dla naszych projektów.

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

Więc, ponieważ większość naszych programistów już po zainstalowaniu Ant, ułożyłem plik kompilacji, aby osiągnąć to niezależnie od platformy.

<?xml version="1.0" encoding="ISO-8859-1"?>
<project name="Gitkeep" basedir="." default="keep">
    <!--Apply to all subdirs of this dir-->
    <target name="keep" description="-> Add a .gitkeep file to all empty subdir's of this dir.">

        <!--Create a ref to all the subdirs in the tree of this dir-->
        <dirset id="dirs.ref" dir="./" includes="**/*"/>
        <!--Create a list of the subdirs under this dir-->
        <property name="dirs.list" refid="dirs.ref" />

        <!--For each subdir-->
        <for list="${dirs.list}" delimiter=";" param="dir">
            <sequential>
                <!--If the subdir is empty this target will add a .gitkeep file to it-->
                <antcall target="gitkeep" inheritall="false">
                    <param name="dir" value="@{dir}"/>
                </antcall>
            </sequential>
        </for>
    </target>

    <!--Add a .gitkeep file to a directory if it's empty-->
    <target name="gitkeep" description="-> Add a .gitkeep file to a specific subdir of this dir. Use -Ddir=relative/path/to/dir">

        <!--Create a ref of the files inside this dir-->
        <fileset dir="${dir}" id="contents.ref"/>

        <!--Create a path to the contents of this directory, ONLY if it's not empty-->
        <pathconvert refid="contents.ref" property="contents.path" setonempty="false"/>

        <if>
            <!--If the dir is empty create the .gitkeep file-->
            <not><isset property="contents.path"/></not>
            <then>
                <!--Create the .gitkeep file-->
                <echo message="Version this dir in Git even if its empty." file="./${dir}/.gitkeep" force="true" append="false"/>
            </then>
        </if>
    </target>
</project>

Now I can simply run

ant -f gitkeep.xml

I to tworzy .plik gitkeep w dowolnym pustym podkatalogu. Nawet na Windows :) Uwaga: ten plik kompilacyjny wymaga jar Ant Contrib .

Nadal pracuję nad tą koncepcją tutaj .

Https://github.com/mig82/gitkeep

Jak wspomniano, nie można dodawać pustych katalogów, ale tutaj jest jeden liner, który 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) }'

Włożyłem to do Rakefile dla łatwego dostępu.

Zawsze buduję funkcję sprawdzającą pożądaną strukturę folderów i buduję ją dla mnie w ramach projektu. Pozwala to obejść 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");
}

Jest to 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ą.

Tutaj jest hack, ale to zabawne, że to działa (Git 2.2.1). Podobne do tego, co zasugerował @ Teka, ale łatwiej zapamiętać:

• Dodaj podmoduł do dowolnego repozytorium (git submodule add path_to_repo)
• spowoduje dodanie folderu i Pliku .submodules. Zatwierdź zmianę.
• Usuń plik .submodules i zatwierdź zmianę.

Teraz masz katalog, który zostanie utworzony, gdy commit jest sprawdzany. Ciekawą rzeczą jest jednak to, że jeśli spojrzysz na zawartość obiektu tree tego pliku, będziesz get:

Fatal: Niepoprawna nazwa obiektu b64338b90b4209263b50244d18278c0999867193

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

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

Plik może być nazwany i zawierać cokolwiek chcesz, ale większość ludzi używa pustego pliku o nazwie .gitkeep (chociaż niektórzy wolą VCS-agnostic .keep).

Prefiks . oznacza go jako ukryty plik.

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

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

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

Dzięki temu rozwiązaniu możesz zatwierdzić pusty folder, na przykład /log, /tmp lub {[4] } i folder pozostanie pusty.

Nie możesz. Jest to zamierzona decyzja projektowa przez opiekunów Gita. 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 content tracker i ponownie, puste katalogi nie są zawartością (wręcz przeciwnie), więc nie są śledzone.

Czasami masz do czynienia ze źle napisanymi bibliotekami lub oprogramowaniem, które potrzebują "prawdziwego" pustego i istniejącego katalogu. Umieszczenie prostych .gitignore lub .keep może je złamać i spowodować błąd. W takich przypadkach mogą pomóc następujące elementy, ale nie ma gwarancji...

Najpierw Utwórz potrzebny katalog:

mkdir empty

Następnie dodajesz zepsuty dowiązanie symboliczne do tego katalogu (ale w każdym innym przypadku niż opisany powyżej przypadek użycia, użyj README z wyjaśnieniem):

ln -s .this.directory empty/.keep

To ignoruj pliki w tym katalogu, możesz dodać je do katalogu głównego .gitignore:

echo "/empty" >> .gitignore

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

git add -f empty/.keep

Po zatwierdzeniu masz zepsute dowiązanie symboliczne w indeksie i git tworzy katalog. Zepsuty link ma pewne zalety, ponieważ nie jest zwykłym plikiem i nie wskazuje na zwykły plik. Tak więc nawet pasuje do części pytania "(które nie zawiera plików)", nie przez intencję, ale przez Znaczenie, myślę:

find empty -type f

To polecenia pokazują pusty wynik, ponieważ żadne pliki nie są obecne w tym katalogu. Tak więc większość aplikacji, które pobierają wszystkie pliki w katalogu, zwykle nie widzi tego linku, przynajmniej jeśli robią "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 polecam używać tego rozwiązania tylko w szczególnych okolicznościach, dobrze napisany README w pustym katalogu jest zwykle lepszym rozwiązaniem. (I nie wiem czy to działa z Windowsem system plików...)

Dodanie jeszcze jednej opcji do walki.

Zakładając, że chcesz dodać katalog do git, który, dla wszystkich celów związanych z git, powinien pozostać pusty i nigdy nie być śledzony jego zawartość, .gitignore jak sugerowano wiele razy tutaj, poradzi sobie.

Format, jak wspomniano, to:

*
!.gitignore

Teraz, jeśli chcesz zrobić to w wierszu poleceń, za jednym zamachem, a wewnątrz katalogu, który chcesz dodać, możesz wykonanie:

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

Sam mam skrypt powłoki, którego używam do tego. Nazwa skryptu niezależnie od tego, co piszesz, i albo dodaj go gdzieś w ścieżce dołączania, albo odwołaj się do niego bezpośrednio: {]}

#!/bin/bash

dir=''

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

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

W ten sposób możesz albo uruchomić go z katalogu, który chcesz dodać, albo odwołać się do katalogu jako pierwszego i jedynego parametru:

$ ignore_dir ./some/directory

Inna opcja (w odpowiedzi na komentarz @GreenAsJade), jeśli chcesz śledzić pusty folder, który Może zawierać śledzone pliki w przyszłości, ale na razie będą puste, możesz ommit {[8] } z pliku .gitignore i sprawdzić , że w. Zasadniczo, cały plik mówi " nie ignoruj me ", ale poza tym katalog jest pusty i śledzony.

Twój plik .gitignore będzie wyglądał następująco:

!.gitignore

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

Powód, dla którego sugeruję zachowanie tego linia w pliku jest taka, że daje .gitignore cel. W przeciwnym razie, ktoś w dół linii może pomyśleć, aby go usunąć. Może to pomóc, jeśli umieścisz komentarz nad linią.

Jeśli chcesz dodać folder, który będzie zawierał wiele przejściowych danych w wielu katalogach semantycznych, to jednym z sposobów jest dodanie czegoś takiego do katalogu głównego .gitignore...

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

Wtedy możesz zatwierdzić opisowe README.md pliki (lub puste pliki, nie ma znaczenia, o ile można je kierować w sposób unikalny, jak w tym przypadku *.md) w każdym katalogu, aby upewnić się, że wszystkie katalogi pozostają częścią repo, ale pliki (z rozszerzeniami) są ignorowane. Ograniczenie: . ' s nie są dozwolone w nazwach katalogów!

Możesz wypełnić wszystkie te katalogi plikami xml / images lub czymkolwiek innym i dodać więcej katalogów pod /app/data/ w miarę rozwoju potrzeb przechowywania aplikacji (z README.md pliki służące do nagrywania w opisie do czego dokładnie służy każdy katalog pamięci).

Nie ma potrzeby dalszej zmiany .gitignore lub decentralizacji poprzez utworzenie nowego .gitignore dla każdego nowego katalogu. Prawdopodobnie nie jest to najmądrzejsze rozwiązanie ale jest Treser gitignore-mądry i zawsze działa dla mnie. Ładnie i prosto! ;)

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

> php create_readme.php

Doda pliki README do wszystkich katalogów, które są puste, więc te katalogi zostaną 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
            }
        }
?>

To zrób

git commit -m "message"
git push

Czasami mam repozytoria z folderami, które zawsze będą zawierać tylko pliki uważane za "zawartość" -to znaczy, nie są to pliki, które dbam o wersjonowanie i dlatego nigdy nie powinny być zatwierdzane. Z Gitem .plik gitignore, możesz ignorować całe katalogi. Ale są chwile, kiedy posiadanie folderu w repo byłoby korzystne. Oto doskonałe rozwiązanie dla realizacji tej potrzeby.

To, co zrobiłem w przeszłości, to umieścić .plik gitignore w katalogu głównym mojego repo, a następnie wyklucz folder, w ten sposób:

/app/some-folder-to-exclude
/another-folder-to-exclude/*

Jednak te foldery nie stają się częścią repo. Możesz tam dodać coś w rodzaju pliku README. Ale potem musisz powiedzieć swojej aplikacji, aby nie martwiła się przetwarzaniem plików README.

Jeśli Twoja aplikacja zależy od folderów, które tam są (choć puste), możesz po prostu dodać .plik gitignore do danego folderu i użyj go do osiągnięcia dwóch celów:

Powiedz Gitowi, że w folderze znajduje się plik, co sprawia, że Git dodaj to do repo. Powiedz Gitowi, aby zignorował zawartość tego folderu, bez tego samego pliku. Tutaj jest .plik gitignore do umieszczenia wewnątrz pustych katalogów:

*
!.gitignore

Pierwsza linia ( * ) mówi Gitowi, aby zignorował wszystko w tym katalogu. Druga linia mówi Gitowi, aby nie ignorował .plik gitignore. Możesz umieścić ten plik w każdym pustym folderze, który chcesz dodać do repozytorium.