it-swarm-eu.dev

Jak mohu přidat prázdný adresář do úložiště Git?

Jak mohu přidat prázdný adresář (který neobsahuje žádné soubory) do úložiště Git?

3790
Laurie Young

Dalším způsobem, jak vytvořit adresář (téměř) prázdný (v úložišti) je vytvořit soubor .gitignore uvnitř tohoto adresáře, který obsahuje tyto čtyři řádky:

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

Pak nemusíte získat pořádek tak, jak to musíte udělat v m104 řešení .

To také dává výhodu, že soubory v tomto adresáři se nezobrazí jako "nesledované", když uděláte stav git.

Provádění @GreenAsJade trvalé komentáře:

Myslím, že to stojí za zmínku, že toto řešení dělá přesně to, o co se ptalo, ale není to, co mnoho lidí, kteří se na tuto otázku dívají, bude hledat. Toto řešení zaručuje, že adresář zůstane prázdný. Říká: "Opravdu nikdy nechci soubory kontrolované zde". Na rozdíl od "nemám žádné soubory, abych se zde mohl zkontrolovat, ale potřebuji adresář, soubory mohou přijít později".

3691
Jamie Flournoy

Nemůžeš. Viz Git FAQ .

V současné době návrh indexu git (pracovní oblast) umožňuje pouze soubory, které mají být uvedeny, a nikdo, kdo je dostatečně kompetentní na to, aby změnu umožnil vypuštění adresářů, se o této situaci dostatečně nestaral, aby ji odstranil.

Adresáře se přidávají automaticky při přidávání souborů do nich. To znamená, že adresáře nikdy nemusí být přidány do úložiště a nejsou sledovány na vlastní pěst.

Můžete říci "git add <dir>" a přidat tam soubory.

Pokud opravdu potřebujete adresář existovat v pokladnách, měli byste v něm vytvořit soubor. pro tento účel funguje dobře; můžete jej nechat prázdný nebo vyplnit názvy souborů, které se mají zobrazit v adresáři.

1023
Andy Lester

V adresáři vytvořte prázdný soubor s názvem .gitkeep a přidejte jej.

645
Artur79

Soubor README můžete vždy v adresáři umístit s vysvětlením, proč chcete tento, jinak prázdný adresář v úložišti.

392
John Mee
touch .keep

V Linuxu se vytvoří prázdný soubor s názvem .keep. Toto jméno je preferováno před .gitkeep jako první je agnostic k Git, zatímco latter je specifický pro Git. Za druhé, jak poznamenal jiný uživatel, konvence předpony .git by měla být vyhrazena pro soubory a adresáře, které Git sám používá.

Alternativně, jak je uvedeno v jiném answer , adresář může obsahovat popisný soubor README NEBO README.md místo.

To samozřejmě vyžaduje, aby přítomnost souboru nezpůsobila přerušení vaší aplikace.

292
A-B-B

Proč bychom potřebovali prázdné verze

Pěkně popořádku:

Prázdný adresář nemůže být součástí stromu pod verzí systému Git.

To prostě nebude sledováno. Existují však scénáře, ve kterých mohou být prázdné adresáře "verzí" smysluplné, například:

  • rozbalit strukturu předdefinovaných složek, což ji zpřístupní každému uživateli/přispěvateli úložiště; nebo jako specializovaný případ výše vytvořte složku pro dočasné soubory, například adresáře cache/ nebo logs/, kde chceme složku, ale .gitignore její obsah poskytnout.
  • související s výše uvedenými, některé projekty nebude fungovat bez některých složek (což je často náznak špatně navrženého projektu, ale je to častý scénář reálného světa a možná by to mohlo být, řekněme, problémy s povolením být řešeny).

Některá navrhovaná řešení

Mnoho uživatelů navrhuje:

  1. Umístění souboru README nebo jiného souboru s nějakým obsahem, aby byl adresář prázdný, nebo
  2. Vytvoření souboru .gitignore s typem "reverzní logiky" (tj. Zahrnutí všech souborů), které na konci slouží stejnému účelu přístupu # 1.

Zatímco obě řešení jistě fungují Považuji je za nekonzistentní s smysluplným přístupem ke správě verzí Git.

  • Proč byste měli dát falešné soubory nebo README, které možná ve svém projektu opravdu nechcete?
  • Proč použít .gitignore udělat něco (vedení soubory), což je naprosto opak toho, co je určeno pro (kromě souborů), i když je to možné?

.gitkeep přístup

Použijte soubor prázdný nazvaný .gitkeep, abyste vynutili přítomnost složky v systému pro správu verzí.

Ačkoli se to může zdát tak velký rozdíl:

  • Použijete soubor, který má single účel uchovávání složky. Nemáte tam žádné informace, které nechcete dát.

    Měli byste například použít READMEs jako, READMEs s užitečnými informacemi, nikoli jako omluvu pro udržení složky.

    Oddělení zájmů je vždy dobrá věc a stále můžete přidat .gitignore, abyste mohli nechtěné soubory ignorovat.

  • Pojmenováním .gitkeep je to velmi jasné a jasné ze samotného názvu souboru (a také ostatním vývojářům, což je dobré pro sdílený projekt a jeden z hlavních cílů úložiště Git), který tento soubor obsahuje.

    • Soubor nesouvisející s kódem (kvůli počáteční tečce a názvu)
    • Soubor jednoznačně souvisí s Git
    • Jeho účel (keep) je jasně vyjádřen a konzistentní a sémanticky protikladný ve svém smyslu ignorovat

Přijetí

Viděl jsem přístup .gitkeep, který přijaly velmi důležité rámce jako Laravel , Angular-CLI .

254
Cranio

Jak je popsáno v jiných odpovědích, Git není schopen reprezentovat prázdné adresáře ve své pracovní oblasti. (Viz Git FAQ .) Pokud je však pro vaše účely adresář prázdný, pokud obsahuje pouze soubor .gitignore, můžete vytvořit soubory .gitignore v prázdných adresářích pouze prostřednictvím:

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

Andy Lester má pravdu, ale pokud váš adresář potřebuje být prázdný a ne prázdný prázdný, můžete do něj umístit prázdný soubor .gitignore jako řešení.

Jako stranou, toto je implementace problém, ne základní Git úložiště design problém. Jak již bylo mnohokrát zmíněno na mailing listu Git, důvodem, proč to nebylo provedeno, je to, že nikdo se nestaral o to, aby pro něj předložil patch, ne že by to nemohlo nebo nemělo být provedeno.

61

Způsob vytvoření složky Ruby on Rails :

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

Adresář bude nyní zahrnut do stromu. Je velmi užitečný při nasazování, takže nebudete muset psát rutinu, abyste vytvořili adresáře protokolu.

Záznamy lze uchovávat mimo vydávání,

echo log/dev.log >> .gitignore

ale pravděpodobně jste to věděli.

30
Thomas E

Git nesleduje prázdné adresáře. Více informací naleznete v Git FAQ . Navrhované řešení je umístit soubor .gitignore do prázdného adresáře. Toto řešení se mi nelíbí, protože .gitignore je "skryté" unixovou konvencí. Také neexistuje vysvětlení, proč jsou adresáře prázdné.

Doporučuji umístit soubor README do prázdného adresáře s vysvětlením, proč je adresář prázdný a proč musí být sledován v Gitu. Pokud je soubor README na místě, pokud jde o Git, adresář již není prázdný.

Skutečnou otázkou je, proč potřebujete prázdný adresář v programu git? Obvykle máte nějaký sestavovací skript, který může vytvořit prázdný adresář před kompilací/spuštěním. Pokud ne, udělejte jednu. To je mnohem lepší řešení, než dát prázdné adresáře v git.

Takže máte nějaký důvod, proč potřebujete prázdný adresář v git. Tento důvod vložte do souboru README. Tímto způsobem ostatní vývojáři (a budoucí) vědí, proč tam musí být prázdný adresář. Budete také vědět, že prázdný adresář můžete odstranit, pokud byl vyřešen problém vyžadující prázdný adresář.


Pro zobrazení každého prázdného adresáře použijte následující příkaz:

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

Vytvoření zástupných README v každém prázdném adresáři:

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

Chcete-li ignorovat vše v adresáři kromě souboru README, vložte do souboru .gitignore následující řádky:

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

Případně můžete vyloučit každý soubor README ignorovat:

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

Chcete-li zobrazit seznam všech README po jejich vytvoření:

find -name README.emptydir
27
lesmana

VAROVÁNÍ: Tento Tweak nefunguje tak, jak to dopadá. Omlouváme se za nepříjemnosti.

Původní příspěvek níže:

Našel jsem řešení při hraní s Git internals!

  1. Předpokládejme, že jste ve svém úložišti.
  2. Vytvořte prázdný adresář:

    $ mkdir path/to/empty-folder
    
  3. Přidejte ji do indexu pomocí příkazu instalatérství a prázdného stromu SHA-1 :

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

    Zadejte příkaz a zadejte druhý řádek. lis Enter a pak Ctrl + D ukončíte svůj vstup. Poznámka: formát je režim [SPACE] typ [SPACE] SHA-1hash [ TAB] cesta (karta je důležitá, formátování odpovědi ji nezachovává).

  4. A je to! Vaše prázdná složka je ve vašem indexu. Jediné, co musíte udělat, je dopustit se.

Toto řešení je krátké a zřejmě funguje dobře ( viz EDIT! ), ale není to tak snadné zapamatovat si ...

Prázdný strom SHA-1 lze nalézt vytvořením nového prázdného úložiště Git, cd do něj a vydáním git write-tree, které vydává prázdný strom SHA-1.

EDIT:

Použil jsem toto řešení, protože jsem ho našel. Zdá se, že funguje přesně stejně jako vytvoření submodulu, kromě toho, že žádný modul není definován nikde. To vede k chybám při vydávání git submodule init|update. Problém je v tom, že git update-index přepíše 040000 tree část do 160000 commit.

Navíc žádný soubor umístěný pod touto cestou si Git nikdy nevšimne, protože si myslí, že patří do nějakého jiného úložiště. To je ošklivé, protože se dá snadno přehlédnout!

Pokud však ještě (a nebudete) používat ve svém úložišti žádné submoduly Git a „prázdná“ složka zůstane prázdná, nebo pokud chcete, aby Git věděl o své existenci a ignoroval její obsah, můžete jít s tento Tweak. Pokračování obvyklým způsobem s submoduly trvá více kroků, které tento Tweak.

26
ofavre

Zdá se, že přidání prázdného adresáře by bylo cesta nejméně odporu protože máte skripty, které očekávají, že adresář bude existovat (možná proto, že je to cíl pro generované binární soubory). Dalším přístupem by bylo upravit skripty tak, aby vytvořily adresář podle potřeby .

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

V tomto příkladu můžete zkontrolovat (nefunkční) symbolický odkaz na adresář, abyste k němu mohli přistupovat bez předpony ".generated" (ale toto je volitelné).

ln -sf .generated/bin bin
git add bin

Chcete-li vyčistit zdrojový strom, můžete:

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

Pokud vezmete v úvahu téměř navržený přístup ke kontrole v téměř prázdné složce, máte menší složitost vymazání obsahu, aniž byste také odstranili soubor „.gitignore“.

Všechny vygenerované soubory můžete ignorovat přidáním následujícího kořenového adresáře .gitignore:

.generated
20
nobar

Řekněme, že potřebujete prázdný adresář s názvem tmp :

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

Jinými slovy, musíte přidat soubor .gitignore do indexu dříve, než mu můžete říct, aby ho ignoroval (a vše ostatní v prázdném adresáři).

20
m104

Také jsem čelil problému s prázdnými adresáři. Problém s použitím zástupných souborů spočívá v tom, že je potřebujete vytvořit a odstranit, pokud již nejsou nutné (protože později byly přidány podadresáře nebo soubory. S velkými zdrojovými stromy, které spravují tyto zástupné soubory, může být těžkopádné a chybné náchylný.

Proto jsem se rozhodl napsat open source nástroj, který dokáže automaticky spravovat vytváření/mazání takových zástupných souborů. Je napsán pro platformu .NET a běží pod Mono (.NET pro Linux) a Windows.

Podívejte se na: http://code.google.com/p/markemptydirs

14
Jonny Dee

Nemůžete a bohužel nikdy nebudete schopni. Toto je rozhodnutí, které učinil sám Linus Torvald. Ví, co je pro nás dobré.

Kdesi jsem tam někde četl rant.

Našel jsemRe: Prázdné adresáře .., ale možná je další.

Musíte žít s řešením ... bohužel.

12
user2334883

Pokud přidáte soubor .gitignore, chcete-li do něj vložit libovolné množství obsahu (chcete, aby aplikace Git ignorovala), můžete přidat jediný řádek s hvězdičkou *, abyste se ujistili, že ignorovaný obsah nepřidáte. obsah náhodně.

10
Michael Johnson

Líbí se mi odpovědi @ Artur79 a @mjs, takže jsem používal kombinaci obou a dělal to standard pro naše projekty.

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

Nicméně pouze několik našich vývojářů pracuje na počítačích Mac nebo Linux. Hodně práce na Windows a já jsem nemohl najít ekvivalentní jednoduchý one-liner dosáhnout stejného tam. Někteří měli to štěstí, že mají Cygwin instalované z jiných důvodů, ale předepisování Cygwinu jen pro toto se zdálo být přehnané.

Úprava pro lepší řešení

Takže, protože většina našich vývojářů již má Ant instalován, první věc, kterou jsem si myslel, bylo sestavit soubor sestavení Ant, aby to bylo dosaženo nezávisle na platformě. Toto lze stále nalézt zde

Nicméně , později jsem si myslel, že by bylo lepší udělat to v malém nástrojovém příkazu, tak jsem ho vytvořil pomocí Pythonu a publikoval do PyPI zde . Můžete jej nainstalovat jednoduše spuštěním:

pip3 install gitkeep2

To vám umožní vytvářet a odstraňovat soubory .gitkeep rekurzivně, a také vám umožní přidávat zprávy, aby jim vaši kolegové porozuměli, proč jsou tyto adresáře důležité. Tento poslední kousek je bonus. Myslel jsem, že by bylo hezké, kdyby soubory .gitkeep mohly být samo dokumentující.

$ 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.

Doufám, že to považujete za užitečné.

10
Mig82

Řešení Jamie Flournoy funguje skvěle. Zde je trochu rozšířená verze, která udržuje .htaccess:

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

S tímto řešením můžete spouštět prázdnou složku, například /log, /tmp nebo /cache a složka zůstane prázdná.

8
Roman

Jak již bylo zmíněno, není možné přidávat prázdné adresáře, ale zde je jedna vložka, která přidává prázdné soubory .gitignore do všech adresářů.

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

Vložil jsem to do Rakefile pro snadný přístup.

8
Peter Hoeg

Tady je hack, ale je to legrační, že to funguje (Git 2.2.1). Podobně jako @Teka navrhl, ale snadněji si zapamatovat:

  • Přidání submodulu do libovolného úložiště (git submodule add path_to_repo)
  • Tím se přidá složka a soubor .submodules. Změnit.
  • Odstraňte soubor .submodules a proveďte změnu.

Nyní máte adresář, který se vytvoří při odhlášení. Zajímavostí je, že pokud se podíváte na obsah stromu tohoto souboru, získáte:

fatální: Neplatný název objektu b64338b90b4209263b50244d18278c0999867193

Nedoporučoval bych ho používat, protože může přestat fungovat v budoucích verzích Gitu. Což může váš repozitář zanechat poškozené.

7

Neexistuje žádný způsob, jak dostat Git ke sledování adresářů, takže jediným řešením je přidat zástupný soubor do adresáře, který chcete Git sledovat.

Soubor může být pojmenován a obsahovat cokoliv chcete, ale většina lidí používá prázdný soubor s názvem .gitkeep (i když někteří lidé dávají přednost VCS-agnostic .keep).

Předpona . ji označí jako skrytý soubor.

Další myšlenkou by bylo přidat soubor README vysvětlující, pro co bude adresář použit.

7
Zaz

Vždy buduju funkci, abych zkontroloval požadovanou strukturu složek a vytvořil to pro mě v rámci projektu. Tento problém se obejde, protože prázdné složky jsou drženy v Git 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");
}

Toto je v PHP, ale jsem si jistý, že většina jazyků podporuje stejnou funkcionalitu, a protože o vytvoření složek se stará aplikace, budou složky vždy tam.

7
Mild Fuzz

Pokud chcete přidat složku, ve které se bude nacházet mnoho přechodných dat ve více sémantických adresářích, jedním z přístupů je přidat něco takového do kořenového adresáře .gitignore ...

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

Pak můžete spouštět popisné soubory README.md (nebo prázdné soubory, nezáleží na tom, pokud je můžete v tomto případě jednoznačně zacílit pomocí *.md) v každém adresáři, abyste zajistili, že všechny adresáře zůstanou součástí repo, ale soubory (s příponami) jsou ignorovány. OMEZENÍ: . 's nejsou v názvech adresářů povoleny!

Všechny tyto adresáře můžete zaplnit soubory xml/images nebo cokoliv a přidávat další adresáře pod /app/data/ v čase, kdy se vyvíjejí potřeby úložiště pro vaši aplikaci (soubory README.md slouží k vypálení v popisu toho, co je každý adresář úložiště přesně).

Není třeba dále měnit .gitignore nebo decentralizovat vytvořením nového souboru .gitignore pro každý nový adresář. Pravděpodobně ne nejchytřejší řešení, ale je to trýzní gitignore-moudrý a vždy pracuje pro mě. Pěkné a jednoduché! ;)

 enter image description here

5
ajmedway

Nemůžeš. Toto je záměrné rozhodnutí o návrhu ze strany správců Git. Účelem systému pro správu zdrojových kódů, jako je Git, je spravovat zdrojový kód a prázdné adresáře nejsou zdrojovým kódem. Git je také často popisován jako tracker obsahu a prázdné adresáře nejsou opět obsahové (ve skutečnosti naopak), takže nejsou sledovány.

5
Jörg W Mittag

Přidání další možnosti k roztřepení.

Za předpokladu, že byste chtěli přidat adresář do git, který by pro všechny účely související s git měl zůstat prázdný a nikdy by neměl být sledován jeho obsah, .gitignore jak je zde mnohokrát navrženo, bude stačit.

Formát, jak je uvedeno, je:

*
!.gitignore

Pokud chcete, jak to udělat na příkazovém řádku, v jednom pádu, zatímco uvnitř adresáře, který chcete přidat, můžete provést:

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

Já sám mám skript Shell, který používám k tomu. Pojmenujte skript bez ohledu na to, co chcete, a buď jej přidejte někam do cesty zahrnutí, nebo jej přímo odkazujte:

#!/bin/bash

dir=''

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

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

Tímto způsobem jej můžete spustit buď z adresáře, který chcete přidat, nebo odkazovat na adresář jako na první a jediný parametr:

$ ignore_dir ./some/directory

Pokud chcete sledovat prázdnou složku, kteráMŮŽEobsahuje sledované soubory v budoucnu, ale bude nyní prázdná, můžete tuto možnost vynechat z * z .gitignore soubor, a kontrolovat to in. V podstatě, celý soubor říká, že "není ignorovat me ", ale jinak je adresář prázdný a sledován.

Soubor .gitignore by vypadal takto:

!.gitignore

To je vše, zkontrolujte, zda máte, a máte prázdný, ale sledovaný adresář, ve kterém můžete soubory později sledovat.

Důvod, proč navrhuji, aby jeden řádek v souboru byl, že dává .gitignore účel. V opačném případě by se mohlo stát, že některý z nich v řádku odstraní. To může pomoci, pokud umístíte komentář nad řádek.

4
Mike

Někdy se musíte vypořádat se špatnými písemnými knihovnami nebo softwarem, které potřebují "skutečný" prázdný a existující adresář. Uvedení jednoduchého .gitignore nebo .keep by je mohlo zlomit a způsobit chybu. V těchto případech může pomoci následující, ale žádná záruka ...

Nejprve vytvořte potřebný adresář:

mkdir empty

Pak přidáte do tohoto adresáře přerušený symbolický odkaz (ale v každém jiném případě, než je popsáno výše, použijte README s vysvětlením):

ln -s .this.directory empty/.keep

Chcete-li soubory v tomto adresáři ignorovat, můžete je přidat do kořenového adresáře .gitignore:

echo "/empty" >> .gitignore

Chcete-li ignorovaný soubor přidat, použijte jej k vynucení:

git add -f empty/.keep

Po potvrzení máte v indexu zlomený symbolický odkaz a git vytvoří adresář. Rozbitý odkaz má některé výhody, protože se nejedná o běžný soubor a odkazuje na žádný pravidelný soubor. Takže to dokonce zapadá do části otázky "(která neobsahuje žádné soubory)", nikoli úmyslem, ale významem, myslím:

find empty -type f

Tento příkaz zobrazuje prázdný výsledek, protože v tomto adresáři nejsou žádné soubory. Většina aplikací, které dostanou všechny soubory v adresáři, obvykle tento odkaz nevidí, přinejmenším v případě, že soubor „existuje“ nebo „je čitelný“. Ani některé skripty zde nenajdou žádné soubory:

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

Ale důrazně doporučuji používat toto řešení pouze za zvláštních okolností, dobré napsané README v prázdném adresáři je obvykle lepší řešení. (A nevím, jestli to funguje se souborovým systémem Windows ...)

4
Trendfischer

Někdy mám repozitáře se složkami, které budou obsahovat pouze soubory, které jsou považovány za „obsah“ - to znamená, že se nejedná o soubory, o které mi záleží na jejich verzi, a proto by neměly být nikdy spáchány. Se souborem Gitignore Git můžete ignorovat celé adresáře. Ale jsou chvíle, kdy mít složku v repo by bylo prospěšné. Zde je vynikající řešení pro dosažení této potřeby.

To, co jsem v minulosti udělal, je umístit soubor .gitignore do kořenového adresáře mého repo a poté tuto složku vyloučit takto:

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

Tyto složky se však nestanou součástí repo. Můžete přidat něco jako soubor README tam. Ale pak musíte říct vaší aplikaci, aby se nezajímala o zpracování souborů README.

Pokud vaše aplikace závisí na složkách, které jsou tam (i když jsou prázdné), můžete do příslušné složky jednoduše přidat soubor .gitignore a použít jej k dosažení dvou cílů:

Řekni Gitovi, že ve složce je soubor, který Git přidává do repo. Řekněte Gitu, aby ignoroval obsah této složky, mínus tento soubor samotný. Zde je soubor .gitignore, který se vloží do prázdných adresářů:

*
!.gitignore

První řádek (*) říká Gitu, aby vše v tomto adresáři ignoroval. Druhý řádek říká Gitu, aby ignoroval soubor .gitignore. Tento soubor můžete uložit do každé prázdné složky, kterou chcete přidat do úložiště.

2
Rahul Sinha

Tento kód můžete uložit jako create_readme.php a spustit PHP code z kořenového adresáře vašeho projektu Git.

> php create_readme.php

Přidá README soubory do všech adresářů, které jsou prázdné, takže tyto adresáře budou pak přidány do indexu.

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

Pak to udělej

git commit -m "message"
git Push
2
user665190