Hoe kan ik een lege map toevoegen aan een Git-repository?

Hoe kan ik een lege map (die geen bestanden bevat) toevoegen aan een Git-repository?

---

Antwoord 1, autoriteit 100%

Een andere manier om een directory (bijna) leeg te maken (in de repository) is door een .gitignore-bestand in die directory te maken dat deze vier regels bevat:

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

Dan hoef je de bestelling niet goed te krijgen zoals je moet doen in de oplossingvan m104.

Dit geeft ook het voordeel dat bestanden in die map niet worden weergegeven als “niet-getrackt” wanneer je een git-status uitvoert.

De opmerking van @GreenAsJadeblijvend maken:

Ik denk dat het de moeite waard is om op te merken dat deze oplossing precies doet waar de vraag om vroeg, maar misschien niet waar veel mensen naar op zoek waren die naar deze vraag keken. Deze oplossing garandeert dat de directory leeg blijft. Er staat “Ik wil echt nooit dat bestanden hier worden ingecheckt”. In tegenstelling tot “Ik heb nog geen bestanden om hier in te checken, maar ik heb de map hier nodig, bestanden komen mogelijk later”.

---

Antwoord 2, autoriteit 25%

Dat kan niet. Zie de Git FAQ.

Momenteel het ontwerp van de git-index
(staging area) staat alleen bestanden toe om
worden vermeld, en niemand competent genoeg
om de wijziging aan te brengen om leeg toe te staan
directories heeft genoeg om gegeven
deze situatie om het te verhelpen.

Mappen worden automatisch toegevoegd
bij het toevoegen van bestanden erin. Dat
is, mappen hoeven nooit te worden toegevoegd
naar de repository en worden niet gevolgd
alleen.

Je kunt zeggen “git add <dir>” en het
zal daar bestanden aan toevoegen.

Als je echt een map nodig hebt om
bestaan in kassa’s moet u een . maken
bestand erin. .gitignore werkt goed voor
dit doel; je kunt het leeg laten,
of vul de namen in van bestanden die u
verwacht in de directory te verschijnen.

---

Antwoord 3, autoriteit 20%

Maak een leeg bestand met de naam .gitkeepin de directory en voeg dat toe.

---

Antwoord 4, autoriteit 11%

Je kunt altijd een README-bestand in de map plaatsen met een uitleg waarom je deze, anders lege, map in de repository wilt hebben.

---

Antwoord 5, autoriteit 9%

touch .keep

Onder Linux maakt dit een leeg bestand met de naam .keepaan. Voor wat het waard is, deze naam is agnostisch voor Git. Ten tweede, zoals een andere gebruiker heeft opgemerkt, kan de prefixconventie .gitworden gereserveerd voor bestanden en mappen die Git zelf gebruikt voor configuratiedoeleinden.

Als alternatief kan, zoals vermeld in een ander antwoord, de directory een beschrijvende README.mdbestandin plaats daarvan.

Dit vereist hoe dan ook dat de aanwezigheid van het bestand er niet voor zorgt dat uw toepassing kapot gaat.

---

Antwoord 6, autoriteit 7%

Waarom zouden we lege mappen met versiebeheer nodig hebben

Eerst eerst:

Een lege map kan geen deel uitmaken van een boomstructuur onder het Git-versiesysteem.

Het wordt gewoon niet gevolgd. Maar er zijn scenario’s waarin “versiebeheer” van lege mappen zinvol kan zijn, bijvoorbeeld:

• een vooraf gedefinieerde mappenstructuuropstellen, zodat deze beschikbaar is voor elke gebruiker/bijdrager van de repository; of, als een speciaal geval van het bovenstaande, het maken van een map voor tijdelijke bestanden, zoals een cache/of logs/mappen, waar we wil de map opgeven, maar .gitignorede inhoud ervan
• gerelateerd aan het bovenstaande, zullen sommige projecten niet werken zonder enkele mappen(wat vaak een hint is van een slecht ontworpen project, maar het is een veel voorkomend scenario in de echte wereld en misschien zou er, zeg, toestemmingsproblemen die moeten worden opgelost).

Enkele voorgestelde oplossingen

Veel gebruikers stellen voor:

1. Een README-bestand of een ander bestand met enige inhoud plaatsen om de map niet-leeg te maken, of
2. Een .gitignore-bestand maken met een soort “omgekeerde logica” (d.w.z. om alle bestanden op te nemen) dat uiteindelijk hetzelfde doel dient als benadering #1.

Hoewel beide oplossingen zeker werkenvind ik ze inconsistent met een zinvolle benadering van Git-versiebeheer.

• Waarom zou je nepbestanden of README’s moeten plaatsen die je misschien niet echt in je project wilt hebben?
• Waarom .gitignoregebruiken om iets te doen (bestanden bewaren) dat precies het tegenovergestelde is van waar het voor bedoeld is (exclusiefbestanden) , ook al is het mogelijk?

.gitkeep benadering

Gebruik een leegbestand met de naam .gitkeepom de aanwezigheid van de map in het versiesysteem te forceren.

Hoewel het misschien niet zo’n groot verschil lijkt:

• Je gebruikt een bestand dat het enigedoel heeft om de map te bewaren. Je plaatst daar geen informatie die je niet wilt plaatsen.

  U zou bijvoorbeeld README’s moeten gebruiken als, nou ja, README’s met nuttige informatie, niet als een excuus om de map te bewaren.

  Het scheiden van zorgen is altijd een goede zaak, en je kunt nog steeds een .gitignoretoevoegen om ongewenste bestanden te negeren.

• Door het .gitkeepte noemen, wordt het heel duidelijk en duidelijk vanuit de bestandsnaam zelf (en ook voor andere ontwikkelaars, wat goed is voor een gedeeld project en een van de kerndoelen van een Git-repository) dat dit bestand is

  • Een bestand dat geen verband houdt met de code (vanwege de eerste punt en de naam)
  • Een bestand dat duidelijk gerelateerd is aan Git
  • Het doel (behouden) is duidelijk vermeld en consistent en semantisch tegengesteld in zijn betekenis om negeren

Adoptie

Ik heb de .gitkeep-benadering gezien die is toegepast door zeer belangrijke frameworks zoals Laravel, Angular-CLI.

---

Antwoord 7, autoriteit 3%

Zoals beschreven in andere antwoorden, is Git niet in staat om lege mappen in zijn staging-gebied weer te geven. (Zie de Git FAQ.) doeleinden is een map leeg genoeg als deze alleen een .gitignore-bestand bevat, dan kunt u alleen .gitignore-bestanden in lege mappen maken via:

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

---

Antwoord 8, autoriteit 2%

Andy Lester heeft gelijk, maar als je directory gewoon leeg moet zijn, en niet leegleeg, dan kun je daar een leeg .gitignore-bestand plaatsen als tijdelijke oplossing .

Terzijde, dit is een implementatieprobleem, geen fundamenteel Git-opslagontwerpprobleem. Zoals al vaak is vermeld op de Git-mailinglijst, is de reden dat dit niet is geïmplementeerd, dat niemand er genoeg om heeft gegeven om er een patch voor in te dienen, niet dat het niet kon of niet moest worden gedaan.

---

Antwoord 9

De Ruby on Railsmanier om de logmap te maken:

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

Nu wordt de logdirectory opgenomen in de boomstructuur. Het is superhandig bij het implementeren, dus je hoeft geen routine te schrijven om logdirectory’s te maken.

De logfiles kunnen buitengehouden worden door

echo log/dev.log >> .gitignore

maar dat wist je waarschijnlijk wel.

---

Antwoord 10

Git houdt geen lege mappen bij. Zie de Git FAQvoor meer uitleg. De voorgestelde oplossing is om een .gitignore-bestand in de lege map te plaatsen. Ik hou niet van die oplossing, omdat de .gitignore“verborgen” is door Unix-conventie. Er is ook geen verklaring waarom de mappen leeg zijn.

Ik stel voor om een README-bestand in de lege map te plaatsen waarin wordt uitgelegd waarom de map leeg is en waarom deze moet worden bijgehouden in Git. Met het README-bestand op zijn plaats, voor zover het Git betreft, is de map niet langer leeg.

De echte vraag is waarom je de lege map in git nodig hebt? Meestal heb je een soort build-script dat de lege map kan maken voordat je gaat compileren/uitvoeren. Zo niet, maak er dan een. Dat is een veel betere oplossing dan lege mappen in git te plaatsen.

Dus je hebt een reden waarom je een lege map in git nodig hebt. Zet die reden in het README-bestand. Op die manier weten andere ontwikkelaars (en toekomstige jij) waarom de lege map daar moet zijn. U zult ook weten dat u de lege map kunt verwijderen wanneer het probleem dat de lege map vereist is opgelost.

---

Gebruik de volgende opdracht om elke lege map weer te geven:

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

Om tijdelijke README’s aan te maken in elke lege map:

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

Om alles in de directory behalve het README-bestand te negeren, plaatst u de volgende regels in uw .gitignore:

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

U kunt ook gewoon uitsluiten dat elkREADME-bestand wordt genegeerd:

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

Om elke README weer te geven nadat ze al zijn gemaakt:

find -name README.emptydir

---

Antwoord 11

WAARSCHUWING: Deze aanpassing werkt niet echt, zo blijkt.Sorry voor het ongemak.

Originele post hieronder:

Ik heb een oplossing gevonden tijdens het spelen met Git internals!

1. Stel dat u zich in uw repository bevindt.

2. Maak je lege map:

   $ mkdir path/to/empty-folder
   

3. Voeg het toe aan de index met behulp van een loodgietersopdracht en de lege boom SHA-1:

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

   Typ de opdracht en voer vervolgens de tweede regel in. Druk op Enteren vervolgens op Ctrl+ Dom uw invoer te beëindigen.
   Opmerking: het formaat is mode[SPACE] type[SPACE] SHA-1hash [TAB]pad (het tabblad is belangrijk, de opmaak van het antwoord bewaart het niet).

4. Dat is het! Je lege map staat in je index. Het enige wat je hoeft te doen is je committeren.

Deze oplossing is kort en werkt blijkbaar prima (zie de EDIT!), maar het is niet zo gemakkelijk te onthouden…

De lege boom SHA-1 kan worden gevonden door een nieuwe lege Git-repository te maken, cderin en git write-treeuit te geven, die de lege boom SHA uitvoert -1.

BEWERKEN:

Ik gebruik deze oplossing sinds ik hem heb gevonden. Het lijkt op precies dezelfde manier te werken als het maken van een submodule, behalve dat er nergens een module is gedefinieerd.
Dit leidt tot fouten bij het uitgeven van git submodule init|update.
Het probleem is dat git update-indexhet gedeelte 040000 treeherschrijft in 160000 commit.

Bovendien zal elk bestand dat onder dat pad wordt geplaatst nooit worden opgemerkt door Git, omdat het denkt dat het bij een andere repository hoort. Dit is vervelend omdat het gemakkelijk over het hoofd kan worden gezien!

Echter, als je nog geen Git-submodules in je repository gebruikt (en niet wilt) en de “lege” map zal leeg blijven of als je wilt dat Git weet dat het bestaat en de inhoud negeert, kan gaan met deze tweak. Door op de gebruikelijke manier met submodules te werken, zijn meer stappen nodig dan deze aanpassing.

---

Antwoord 12

Stel dat je een lege map nodig hebt met de naam tmp:

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

Met andere woorden, je moet het .gitignore-bestand aan de index toevoegen voordat je Git kunt vertellen het te negeren (en al het andere in de lege map).

---

Antwoord 13

Misschien lijkt het toevoegen van een lege map het pad van de minste weerstandomdat je scripts hebt die verwachten dat die map bestaat (misschien omdat het een doelwit is voor gegenereerde binaire bestanden). Een andere benadering zou zijn om uw scripts aan te passen om de directory naar behoefte aan te maken.

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

In dit voorbeeld kunt u een (gebroken) symbolische link naar de directory inchecken zodat u deze kunt openen zonder het voorvoegsel “.generated” (maar dit is optioneel).

ln -sf .generated/bin bin
git add bin

Als u uw bronstructuur wilt opschonen, kunt u het volgende doen:

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

Als je de vaak gesuggereerde aanpak gebruikt om een bijna lege map in te checken, heb je de kleine complexiteit van het verwijderen van de inhoud zonder ook het “.gitignore”-bestand te verwijderen.

Je kunt al je gegenereerde bestanden negeren door het volgende toe te voegen aan je root .gitignore:

.generated

---

Antwoord 14

Dat kun je niet en zul je helaas nooit kunnen. Dit is een beslissing van Linus Torvald zelf. Hij weet wat goed voor ons is.

Er is ergens een tirade die ik ooit heb gelezen.

Ik heb Re: lege mappen..gevonden, maar misschien is er nog een.

Je moet leven met de tijdelijke oplossingen…helaas.

---

Antwoord 15

Ik heb het probleem ook gehad met lege mappen. Het probleem met het gebruik van plaatsaanduidingsbestanden is dat u ze moet maken en ze moet verwijderen als ze niet meer nodig zijn (omdat er later submappen of bestanden zijn toegevoegd). Met grote bronbestanden kan het beheer van deze plaatsaanduidingsbestanden omslachtig en fout zijn gevoelig.

Daarom heb ik besloten een open source-tool te schrijven die het aanmaken/verwijderen van dergelijke tijdelijke aanduiding-bestanden automatisch kan beheren. Het is geschreven voor het .NET-platform en draait onder Mono (.NET voor Linux) en Windows.

Kijk maar eens op: http://code.google.com/p/markemptydirs

---

Antwoord 16

Ik ben blij met de antwoorden van @Artur79 en @mjs, dus ik heb een combinatie van beide gebruikt en er een standaard van gemaakt voor onze projecten.

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

Echter, slechts een handvol van onze ontwikkelaars werkt op Mac of Linux. Veel werk aan Windows en ik kon geen gelijkwaardige eenvoudige one-liner vinden om daar hetzelfde te bereiken. Sommigen hadden het geluk om Cygwinom andere redenen geïnstalleerd te hebben, maar Cygwin alleen hiervoor voorschrijven leek overdreven.

Bewerken voor een betere oplossing

Dus, aangezien de meeste van onze ontwikkelaars Antal hebben geïnstalleerd, was het eerste waar ik aan dacht om samen een Ant-buildbestand om dit onafhankelijk van het platform te bereiken. Dit is hier

nog steeds te vinden

Echterdacht ik later dat het beter zou zijn om dit in een klein hulpprogramma-commando te maken, dus ik maakte het opnieuw met Python en publiceerde het op de PyPI hier. Je kunt het installeren door simpelweg het volgende uit te voeren:

pip3 install gitkeep2

Hiermee kun je recursief .gitkeep-bestanden maken en verwijderen, en je kunt er ook berichten aan toevoegen zodat je collega’s begrijpen waarom die mappen belangrijk zijn. Dit laatste is een bonus. Ik dacht dat het leuk zou zijn als de .gitkeepbestanden zelfdocumenterend zouden zijn.

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

Ik hoop dat je het nuttig vindt.

---

Antwoord 17

Als je een .gitignore-bestand toevoegt, en je wilt er een hoeveelheid inhoud in plaatsen (die je wilt dat Git negeert), wil je misschien een enkele regel toevoegen met alleen een asterisk *om ervoor te zorgen dat u de genegeerde inhoud niet per ongeluk toevoegt.

---

Antwoord 18

Er is geen manier om Git directory’s te laten volgen, dus de enige oplossing is om een tijdelijke aanduiding-bestand toe te voegen aan de directory die Git moet bijhouden.

Het bestand kan een naam hebben en alles bevatten wat je wilt, maar de meeste mensen gebruiken een leeg bestand met de naam .gitkeep(hoewel sommige mensen de voorkeur geven aan de VCS-agnostische .keep) .

Het voorvoegsel .markeert het als een verborgen bestand.

Een ander idee zou zijn om een README-bestand toe te voegen waarin wordt uitgelegd waarvoor de map zal worden gebruikt.

---

Antwoord 19

Zoals gezegd is het niet mogelijk om lege mappen toe te voegen, maar hier is een one-liner die lege .gitignore-bestanden aan alle mappen toevoegt.

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

Ik heb dit in een Rakefile gestoken voor gemakkelijke toegang.

---

Antwoord 20

Velen hebben deze vraag al beantwoord. Voeg hier gewoon een PowerShell-versie toe.

Vind alle lege mappen in de directory

Voeg daar een leeg .gitkeep-bestand toe

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}

---

Antwoord 21

Lezen van @ofavre‘s en @stanislav-bashkyrtsev‘s antwoorden met behulp van gebroken GIT-submodulereferenties om de GIT-directory’s te maken, het verbaast me dat nog niemand deze eenvoudige wijziging van het idee heeft voorgesteld om het geheel gezond en veilig te maken:

In plaats van een nep-submodule in GIT te hacken, voeg gewoon een lege echte toe.

Voer in: https://gitlab.com/empty-repo/empty.git

Een GIT-repository met precies één commit:

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

Geen bericht, geen vastgelegde bestanden.

Gebruik

Om een lege map aan je GIT repo toe te voegen:

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

Om alle bestaande lege mappen naar submodules te converteren:

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

Git zal de laatste commit-hash opslaan bij het maken van de submodule-referentie, dus je hoeft je geen zorgen te maken dat ik (of GitLab) dit gebruik om kwaadaardige bestanden te injecteren. Helaas heb ik geen manier gevonden om te forceren welke commit ID wordt gebruikt tijdens het afrekenen, dus je zult handmatig moeten controleren of de referentie commit ID e84d7b81f0033399e325b8037ed2b801a5c994e0is met behulp van git submodule statusna het toevoegen van de opslagplaats.

Nog steeds geen native oplossing, maar de beste die we waarschijnlijk kunnen hebben zonder dat iemand zijn handen echt, echtvuil maakt in de GIT-codebase.

Bijlage: deze commit opnieuw maken

Je zou deze exacte commit opnieuw moeten kunnen maken met (in een lege map):

# 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

Reproduceerbare GIT-commits maken is verrassend moeilijk…

---

Antwoord 22

De oplossing van Jamie Flournoywerkt prima. Hier is een beetje verbeterde versie om de .htaccesste behouden:

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

Met deze oplossing kun je een lege map vastleggen, bijvoorbeeld /log, /tmpof /cacheen de map zal blijf leeg.

---

Antwoord 23

Ik bouw altijd een functie om te controleren op mijn gewenste mappenstructuur en bouw deze voor mij binnen het project. Dit omzeilt dit probleem omdat de lege mappen bij proxy in Git worden vastgehouden.

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

Dit is in PHP, maar ik weet zeker dat de meeste talen dezelfde functionaliteit ondersteunen, en omdat het maken van de mappen wordt verzorgd door de applicatie, zullen de mappen er altijd zijn.

---

Antwoord 24

Hier is een hack, maar het is grappig dat het werkt (Git 2.2.1). Vergelijkbaar met wat @Teka suggereerde, maar gemakkelijker te onthouden:

• Voeg een submodule toe aan een willekeurige repository (git submodule add path_to_repo)
• Hiermee worden een map en een bestand .submodulestoegevoegd. Voer een wijziging door.
• Verwijder .submodulesbestand en bevestig de wijziging.

Nu heb je een directory die wordt aangemaakt wanneer de commit wordt uitgecheckt. Een interessant ding is echter dat als je naar de inhoud van het boomobject van dit bestand kijkt, je het volgende krijgt:

fataal: geen geldige objectnaam
b64338b90b4209263b50244d18278c0999867193

Ik zou het echter niet aanmoedigen om het te gebruiken, omdat het in toekomstige versies van Git misschien niet meer werkt. Waardoor uw repository mogelijk beschadigd raakt.

---

Antwoord 25

Deze oplossing werkte voor mij.

1. Voeg een .gitignorebestand toe aan je lege directory:

*
*/
!.gitignore

• *negeer alle bestanden in de map
• */Submappen negeren
• !.gitignorevoeg het .gitignore-bestand toe

2. Verwijder vervolgens je cache, stage je bestanden, commit en push:

git rm -r --cached .
git add . // or git stage .
git commit -m ".gitignore fix"
git push

---

Antwoord 26

Als je een map wilt toevoegen die veel tijdelijke gegevens in meerdere semantische mappen zal bevatten, dan is een benadering om zoiets toe te voegen aan je root .gitignore…

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

Vervolgens kun je beschrijvende README.md-bestanden vastleggen (of lege bestanden, maakt niet uit, zolang je ze maar uniek kunt targeten zoals in dit geval met de *.md) in elke map om ervoor te zorgen dat de mappen allemaal deel blijven uitmaken van de repo, maar dat de bestanden (met extensies) genegeerd worden. BEPERKING: .‘s zijn niet toegestaan in de directorynamen!

Je kunt al deze mappen vullen met xml/images-bestanden of wat dan ook en in de loop van de tijd meer mappen toevoegen onder /app/data/naarmate de opslagbehoeften voor je app toenemen (met de README. md-bestanden die dienen om te branden in een beschrijving van waar elke opslagdirectory precies voor is).

Het is niet nodig om uw .gitignoreverder te wijzigen of te decentraliseren door voor elke nieuwe map een nieuwe .gitignoreaan te maken. Waarschijnlijk niet de slimste oplossing, maar is gitignore-gewijs en werkt altijd voor mij. Lekker simpel! 😉

---

Antwoord 27

Een gemakkelijke manier om dit te doen is door een .gitkeepbestand toe te voegen aan de map die je (momenteel) leeg wilt houden.

Zie dit SOF-antwoordvoor meer informatie – wat ook verklaart waarom sommige mensen de concurrerende conventie vinden om een .gitignore toe te voegen bestand (zoals vermeld in veel antwoorden hier) verwarrend.

---

Antwoord 28

Soms heb je te maken met slecht geschreven bibliotheken of software, die een “echte” lege en bestaande directory nodig hebben. Het plaatsen van een simpele .gitignoreof .keepkan ze breken en een bug veroorzaken. Het volgende kan in deze gevallen helpen, maar geen garantie…

Maak eerst de benodigde directory:

mkdir empty

Vervolgens voeg je een verbroken symbolische link toe aan deze map (maar gebruik in elk ander geval dan de hierboven beschreven use case een READMEmet uitleg):

ln -s .this.directory empty/.keep

Om bestanden in deze map te negeren, kun je deze toevoegen aan je root .gitignore:

echo "/empty" >> .gitignore

Om het genegeerde bestand toe te voegen, gebruik je een parameter om het te forceren:

git add -f empty/.keep

Na de commit heb je een verbroken symbolische link in je index en git maakt de directory aan. De verbroken link heeft enkele voordelen, aangezien het geen gewoon bestand is en naar geen gewoon bestand verwijst. Dus het past zelfs bij het deel van de vraag “(dat geen bestanden bevat)”, niet door de bedoeling maar door de betekenis, denk ik:

find empty -type f

Dit commando toont een leeg resultaat, aangezien er geen bestanden aanwezig zijn in deze map. Dus de meeste applicaties, die alle bestanden in een map krijgen, zien deze link meestal niet, tenminste als ze een “bestand bestaat” of een “is leesbaar” hebben. Zelfs sommige scripts zullen daar geen bestanden vinden:

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

Maar ik raad ten zeerste aan om deze oplossing alleen in speciale omstandigheden te gebruiken, een goed geschreven READMEin een lege map is meestal een betere oplossing. (En ik weet niet of dit werkt met een Windows-bestandssysteem…)

---

Antwoord 29

Nog een optie aan de strijd toevoegen.

Ervan uitgaande dat je een map aan gitwilt toevoegen die, voor alle doeleinden gerelateerd aan git, leeg zou moeten blijven en de inhoud nooit moet worden gevolgd, een .gitignorezoals hier meerdere keren gesuggereerd, zal het lukken.

Het formaat, zoals vermeld, is:

*
!.gitignore

Als je nu een manier wilt om dit via de opdrachtregel te doen, kun je in één klap, terwijl je binnende map die je wilt toevoegen, het volgende uitvoeren:

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

Ik heb zelf een shellscript dat ik hiervoor gebruik. Noem het script wat je maar wilt, en voeg het ergens in je include-pad toe, of verwijs er rechtstreeks naar:

#!/bin/bash
dir=''
if [ "$1" != "" ]; then
    dir="$1/"
fi
echo "*" > $dir.gitignore && \
echo '!.gitignore' >> $dir.gitignore && \
git add $dir.gitignore

Hiermee kunt u het ofwel uitvoeren vanuit de map die u wilt toevoegen, of naar de map verwijzen als de eerste en enige parameter:

$ ignore_dir ./some/directory

Een andere optie (in reactie op een opmerking van @GreenAsJade), als u een lege map wilt bijhouden die MEIin de toekomst getraceerde bestanden bevat, maar voorlopig leeg zal zijn, kunt u deze weglaten de *uit het .gitignorebestand, en vink dataan. Kortom, het enige wat het bestand zegt is “neger me niet “, maar verder is de map leeg en wordt bijgehouden.

Uw .gitignore-bestand ziet er als volgt uit:

!.gitignore

Dat is het, vink dat aan en je hebt een lege, maar bijgehouden directory waar je op een later tijdstip bestanden in kunt traceren.

De reden dat ik voorstel om die ene regel in het bestand te houden, is dat het het doel .gitignoregeeft. Anders kan iemand langs de lijn denken om het te verwijderen. Het kan helpen als je een opmerking boven de regel plaatst.

---

Antwoord 30

Dat kan niet. Dit is een opzettelijke ontwerpbeslissing van de Git-beheerders. Kortom, het doel van een broncodebeheersysteem zoals Git is het beheren van de broncode en lege mappen zijn geen broncode. Git wordt ook vaak beschreven als een contenttracker, en nogmaals, lege mappen zijn geen content (integendeel zelfs), dus worden ze niet gevolgd.