Come posso aggiungere una directory vuota in un repository Git?

https://stackoverflow.com/questions/115983

02-07-2019
|

Domanda

Come posso aggiungere una directory vuota (che non contiene alcun file) in un repository Git?

Soluzione

Un altro modo per rendere una directory (quasi) vuota (nel repository) è quello di creare un file .gitignore all'interno di quella directory che contenga queste quattro righe:

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

Quindi non è necessario eseguire l'ordine nel modo corretto nella soluzione di m104 .

Ciò offre anche il vantaggio che i file in quella directory non verranno visualizzati come " non tracciati " quando si esegue uno stato git.

Rendere persistente il commento di @GreenAsJade :

Penso che valga la pena notare che questa soluzione fa esattamente ciò che la domanda ha posto, ma forse non è quello che molte persone che hanno cercato su questa domanda avrebbero cercato. Questa soluzione garantisce che la directory rimanga vuota. Dice & Quot; Davvero non voglio mai che i file vengano controllati qui & Quot ;. A differenza di & Quot; Non ho ancora alcun file per il check-in qui, ma ho bisogno della directory qui, i file potrebbero essere in arrivo & Quot ;.

Altri suggerimenti

Non puoi. Consulta le Domande frequenti su Git .

Attualmente il design dell'indice git   (area di gestione temporanea) consente solo i file   essere elencato e nessuno abbastanza competente   per apportare la modifica per consentire il vuoto   le directory si sono preoccupate abbastanza   questa situazione per rimediare.

Le directory vengono aggiunte automaticamente   quando si aggiungono file al loro interno. Quello   le directory non devono mai essere aggiunte   nel repository e non vengono tracciati   da soli.

Puoi dire " git add <dir> " ed esso   aggiungerà i file lì dentro.

Se hai davvero bisogno di una directory per   esiste nei checkout è necessario creare un   file in esso. .gitignore funziona bene per   questo scopo; puoi lasciarlo vuoto,   o inserire i nomi dei file   aspettarsi di apparire nella directory.

Crea un file vuoto chiamato .gitkeep nella directory e aggiungilo.

È sempre possibile inserire un file README nella directory con una spiegazione del motivo per cui si desidera questa directory, altrimenti vuota, nel repository.

touch .keep

Su Linux, questo crea un file vuoto chiamato .keep. Questo nome è preferito su .gitkeep poiché il primo è agnostico di Git, mentre il secondo è specifico di Git. In secondo luogo, come ha notato un altro utente, la convenzione del prefisso .git dovrebbe essere riservata ai file e alle directory che Git stesso utilizza.

In alternativa, come indicato in un'altra risposta , la directory può contenere un < README o README.md file invece.

Ovviamente questo richiede che la presenza del file non causi l'interruzione dell'applicazione.

Perché dovremmo aver bisogno di cartelle vuote con versione

Prima le prime cose:

Una directory vuota non può far parte di un albero nel sistema di versioning Git .

Semplicemente non verrà tracciato. Ma ci sono scenari in cui & Quot; versioning & Quot; le directory vuote possono essere significative, ad esempio:

impalcatura di una struttura di cartelle predefinita , rendendola disponibile per ogni utente / collaboratore del repository; o, come caso specializzato di cui sopra, creando una cartella per file temporanei , come una cache/ o logs/ directory, dove vogliamo fornire la cartella ma .gitignore il suo contenuto
in relazione a quanto sopra, alcuni progetti non funzioneranno senza alcune cartelle (che è spesso un suggerimento di un progetto mal progettato, ma è uno scenario del mondo reale frequente e forse potrebbe esserci, ad esempio, problemi di autorizzazione da affrontare).

Alcune soluzioni alternative suggerite

Molti utenti suggeriscono:

Posizionamento di un README file o di un altro file con alcuni contenuti per rendere la directory non vuota, oppure
Creazione di un file .gitkeep con una sorta di " reverse logic " (ovvero includere tutti i file) che, alla fine, ha lo stesso scopo dell'approccio n. 1.

Mentre entrambe le soluzioni funzionano sicuramente le trovo incompatibili con un approccio significativo al controllo delle versioni di Git.

Perché dovresti mettere file fasulli o README che forse non vuoi davvero nel tuo progetto?
Perché usare <=> per fare una cosa ( conservare file) che è esattamente l'opposto di ciò che significa ( escludere ), anche se è possibile ?

approccio .gitkeep

Utilizza un file vuoto chiamato <=> per forzare la presenza della cartella nel sistema di controllo delle versioni.

Anche se potrebbe non sembrare una differenza così grande:

Si utilizza un file che ha lo scopo singolo di conservare la cartella. Non ci metti nessuna informazione che non vuoi mettere.

Ad esempio, dovresti usare README come pure README con informazioni utili, non come scusa per conservare la cartella.

La separazione delle preoccupazioni è sempre una buona cosa e puoi ancora aggiungere un <=> per ignorare i file indesiderati.
Denominarlo <=> lo rende molto chiaro e semplice dal nome del file stesso (e anche ad altri sviluppatori , che è buono per un progetto condiviso e uno degli scopi principali di un Git repository) che questo file è
- Un file non correlato al codice (a causa del punto iniziale e del nome)
- Un file chiaramente correlato a Git
- Il suo scopo ( mantieni ) è chiaramente dichiarato e coerente e semanticamente opposto nel suo significato a ignore

L'adozione

Ho visto l'approccio <=> adottato da quadri molto importanti come Laravel , Angular-CLI .

Come descritto in altre risposte, Git non è in grado di rappresentare directory vuote nell'area di gestione temporanea. (Vedi le Domande frequenti su Git .) Tuttavia, se, per il tuo Ai fini, una directory è abbastanza vuota se contiene solo un .gitignore file, quindi è possibile creare <=> file in directory vuote solo tramite:

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

Andy Lester ha ragione, ma se la tua directory deve solo essere vuota e non vuota vuota, puoi inserire un file .gitignore vuoto come soluzione alternativa.

A parte questo, questo è un problema di implementazione, non un problema di progettazione dello storage Git fondamentale. Come è stato menzionato molte volte nella mailing list di Git, la ragione per cui questo non è stato implementato è che nessuno si è preoccupato abbastanza di inviargli una patch, non che non potesse & # 8217; t o shouldn & # 8217; da fare.

Il Ruby on Rails modo di creazione della cartella di registro:

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

Ora la directory dei log sarà inclusa nella struttura. È molto utile durante la distribuzione, quindi non sarà necessario scrivere una routine per creare directory di registro.

I file di log possono essere esclusi emettendo,

echo log/dev.log >> .gitignore

ma probabilmente lo sapevi.

Git non tiene traccia di directory vuote. Vedi Domande frequenti su Git per ulteriori spiegazioni. La soluzione suggerita è quella di inserire un file .gitignore nella directory vuota. Non mi piace quella soluzione, perché <=> è & Quot; nascosto & Quot; per convenzione Unix. Inoltre non vi è alcuna spiegazione del perché le directory siano vuote.

Suggerisco di mettere un file README nella directory vuota spiegando perché la directory è vuota e perché deve essere tracciata in Git. Con il file README in atto, per quanto riguarda Git, la directory non è più vuota.

La vera domanda è: perché hai bisogno della directory vuota in git? Di solito hai una sorta di script di compilazione che può creare la directory vuota prima di compilare / eseguire. Altrimenti, creane uno. Questa è una soluzione di gran lunga migliore rispetto a mettere directory vuote in git.

Quindi hai qualche motivo per cui hai bisogno di una directory vuota in git. Inserisci questo motivo nel file README. In questo modo altri sviluppatori (e in futuro tu) sanno perché la directory vuota deve essere lì. Saprai anche che puoi rimuovere la directory vuota quando il problema che richiede la directory vuota è stato risolto.

Per elencare tutte le directory vuote usare il seguente comando:

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

Per creare README di segnaposto in ogni directory vuota:

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

Per ignorare tutto nella directory tranne il file README, inserisci le seguenti righe nel tuo <=>:

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

In alternativa, puoi semplicemente escludere ogni file README dall'ignorare:

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

Per elencare tutti i README dopo che sono già stati creati:

find -name README.emptydir

ATTENZIONE: questa modifica non funziona davvero come risulta. Ci scusiamo per l'inconveniente.

Post originale di seguito:

Ho trovato una soluzione mentre giocavo con gli interni di Git!

Supponi di essere nel tuo repository.
Crea la tua directory vuota:
```
$ mkdir path/to/empty-folder
```
Aggiungilo all'indice usando un comando idraulico e l'albero vuoto SHA-1 :
```
$ git update-index --index-info
040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder
```
Digita il comando, quindi inserisci la seconda riga. Premi Invio e poi Ctrl + D per terminare l'input. Nota: il formato è mode [SPACE] type [SPACE] SHA-1hash [TAB] percorso (la scheda è importante, la formattazione della risposta non lo conserva).
Questo è tutto! La tua cartella vuota è nel tuo indice. Tutto quello che devi fare è impegnarti.

Questa soluzione è breve e apparentemente funziona bene ( vedi EDIT! ), ma non è così facile da ricordare ...

L'albero vuoto SHA-1 può essere trovato creando un nuovo repository Git vuoto, cd in esso ed emettendo git write-tree, che genera l'albero vuoto SHA-1.

Modifica

Uso questa soluzione da quando l'ho trovata. Sembra funzionare esattamente come la creazione di un sottomodulo, tranne per il fatto che nessun modulo è definito da nessuna parte. Ciò comporta errori durante l'emissione di git submodule init|update. Il problema è che git update-index riscrive la parte 040000 tree in 160000 commit.

Inoltre, qualsiasi file inserito in quel percorso non verrà mai notato da Git, poiché ritiene che appartengano ad altri repository. Questo è brutto in quanto può essere facilmente trascurato!

Tuttavia, se non si utilizza (e non si desidera) già alcun sottomodulo Git nel proprio repository e il " vuoto " la cartella rimarrà vuota o se vuoi che Git sappia della sua esistenza e ignori il suo contenuto, puoi procedere con questa modifica. Seguire la solita maniera con i sottomoduli compie più passaggi di questo tweak.

Forse l'aggiunta di una directory vuota sembra che sarebbe il percorso di minor resistenza perché hai degli script che prevedono che quella directory esista (forse perché è una destinazione per i binari generati). Un altro approccio sarebbe quello di modificare i tuoi script per creare la directory come necessario .

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

In questo esempio, è possibile archiviare un collegamento simbolico (interrotto) alla directory in modo che sia possibile accedervi senza il " .generated " prefisso (ma questo è facoltativo).

ln -sf .generated/bin bin
git add bin

Quando vuoi ripulire l'albero dei tuoi sorgenti puoi semplicemente:

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

Se si adotta l'approccio spesso suggerito di effettuare il check-in in una cartella quasi vuota, si ha la minore complessità di eliminare il contenuto senza eliminare anche il " .gitignore " file.

È possibile ignorare tutti i file generati aggiungendo quanto segue alla radice .gitignore:

.generated

Supponiamo che tu abbia bisogno di una directory vuota chiamata tmp :

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

In altre parole, è necessario aggiungere il file .gitignore all'indice prima di poter dire a Git di ignorarlo (e tutto il resto nella directory vuota).

Ho riscontrato il problema anche con directory vuote. Il problema con l'utilizzo dei file segnaposto è che è necessario crearli ed eliminarli, se non sono più necessari (perché in seguito sono stati aggiunti sottodirectory o file. Con alberi di origine di grandi dimensioni la gestione di questi file segnaposto può essere ingombrante ed errore prona.

Ecco perché ho deciso di scrivere uno strumento open source in grado di gestire automaticamente la creazione / cancellazione di tali file segnaposto. È scritto per la piattaforma .NET e funziona su Mono (.NET per Linux) e Windows.

Dai un'occhiata a: http://code.google.com/p/markemptydirs

Non puoi e sfortunatamente non sarai mai in grado di farlo. Questa è una decisione presa dallo stesso Linus Torvald. Sa cosa è buono per noi.

C'è uno sfogo là fuori che ho letto una volta.

Ho trovato Ri: directory vuote .. , ma forse c'è un altro.

Devi convivere con le soluzioni alternative ... sfortunatamente.

Mi piacciono le risposte di @ Artur79 e @mjs, quindi ho usato una combinazione di entrambi e l'ho resa uno standard per i nostri progetti.

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

Tuttavia, solo alcuni dei nostri sviluppatori lavorano su Mac o Linux. Molto lavoro su Windows e non sono riuscito a trovare un semplice one-liner equivalente per ottenere lo stesso risultato. Alcuni hanno avuto la fortuna di avere Cygwin installato per altri motivi, ma prescrivere Cygwin proprio per questo sembrava eccessivo.

Modifica per una soluzione migliore

Quindi, poiché la maggior parte dei nostri sviluppatori ha già Ant installato, la prima cosa che ho pensato è stata mettere insieme un file build Ant per farlo indipendentemente dalla piattaforma. Questo può ancora essere trovato qui

Tuttavia , in seguito ho pensato che sarebbe stato meglio trasformarlo in un piccolo comando di utilità, quindi l'ho ricreato usando Python e l'ho pubblicato su PyPI qui . Puoi installarlo semplicemente eseguendo:

pip3 install gitkeep2

Ti consentirà di creare e rimuovere .gitkeep file in modo ricorsivo e ti consentirà inoltre di aggiungere loro messaggi per far capire ai tuoi colleghi perché tali directory sono importanti. Quest'ultimo bit è bonus. Ho pensato che sarebbe bello se i <=> file potessero essere auto-documentati.

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

Spero che lo trovi utile.

Quando aggiungi un file .gitignore, se hai intenzione di inserire qualsiasi quantità di contenuto (che vuoi che Git ignori) potresti voler aggiungere una sola riga con solo un asterisco * per assicurarti non aggiungi accidentalmente il contenuto ignorato.

Come accennato, non è possibile aggiungere directory vuote, ma qui c'è una riga che aggiunge file .gitignore vuoti a tutte le directory.

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

L'ho bloccato in un Rakefile per un facile accesso.

La soluzione di Jamie Flournoy funziona alla grande. Ecco una versione leggermente migliorata per mantenere .htaccess:

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

Con questa soluzione è possibile eseguire il commit di una cartella vuota, ad esempio /log, /tmp o /cache e la cartella rimarrà vuota.

Costruisco sempre una funzione per verificare la struttura della cartella desiderata e crearla per me all'interno del progetto. Questo risolve questo problema poiché le cartelle vuote sono mantenute in Git dal 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");
}

Questo è in PHP, ma sono sicuro che la maggior parte delle lingue supporta la stessa funzionalità e poiché l'applicazione delle cartelle è curata dall'applicazione, le cartelle saranno sempre lì.

Ecco un trucco, ma è divertente che funzioni (Git 2.2.1). Simile a quanto suggerito da @Teka, ma più facile da ricordare:

Aggiungi un sottomodulo a qualsiasi repository (git submodule add path_to_repo)
Ciò aggiungerà una cartella e un file .submodules. Commetti un cambiamento.
Elimina <=> file e conferma la modifica.

Ora hai una directory che viene creata quando viene eseguito il checkout. Una cosa interessante è che se guardi il contenuto dell'oggetto albero di questo file otterrai:

fatale: non un nome oggetto valido b64338b90b4209263b50244d18278c0999867193

Non incoraggerei a usarlo anche se potrebbe smettere di funzionare nelle future versioni di Git. Il che potrebbe lasciare corrotto il tuo repository.

Non è possibile far sì che Git tenga traccia delle directory, quindi l'unica soluzione è aggiungere un file segnaposto all'interno della directory che Git deve tracciare.

Il file può essere nominato e contenere tutto ciò che vuoi, ma la maggior parte delle persone usa un file vuoto chiamato .gitkeep (anche se alcune persone preferiscono il VCS-agnostico .keep).

Il prefisso . lo contrassegna come file nascosto.

Un'altra idea sarebbe quella di aggiungere un README file che spiega a cosa servirà la directory.

Non puoi. Questa è una decisione di progettazione intenzionale da parte dei manutentori di Git. Fondamentalmente, lo scopo di un sistema di gestione del codice sorgente come Git è la gestione del codice sorgente e le directory vuote non sono codice sorgente. Git è anche spesso descritto come tracker dei contenuti e, di nuovo, le directory vuote non sono dei contenuti (al contrario, in realtà), quindi non vengono monitorate.

Se si desidera aggiungere una cartella che conterrà un sacco di dati transitori in più semantico directory, quindi, un approccio è quello di aggiungere qualcosa di simile per il root .gitignore...

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

Poi si può commettere descrittivo README.md file (o file vuoti, non importa, come a lungo possibile la loro destinazione in modo univoco come con il *.md in questo caso) in ogni directory, per garantire che le directory sono ancora tutti parte di repo ma i file (estensioni) sono tenuti ignorato.LIMITAZIONE: .'s non sono ammessi nella directory nomi!

Si può riempire tutte queste cartelle con xml/file di immagine o qualsiasi altra cosa e aggiungere altre cartelle sotto /app/data/ nel tempo, le esigenze di archiviazione per la vostra app di sviluppare (con il file LEGGIMI.md file che serve per bruciare in una descrizione di ciò che ogni directory di archiviazione è per l'appunto).

Non c'è bisogno di modificare ulteriormente il vostro .gitignore o decentrare la creazione di un nuovo .gitignore per ogni nuova directory.Probabilmente non è la soluzione più intelligente, ma è conciso gitignore-saggio e funziona sempre per me.Bello e semplice!;)

Aggiunta di un'altra opzione alla mischia.

Supponendo che desideri aggiungere una directory a git che, per tutti gli scopi relativi a .gitignore, dovrebbe rimanere vuota e non tenere traccia dei suoi contenuti, un * come suggerito più volte qui, farà il trucco .

Il formato, come detto, è:

*
!.gitignore

Ora, se vuoi un modo per farlo dalla riga di comando, in un colpo solo, mentre dentro la directory che vuoi aggiungere, puoi eseguire:

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

Io stesso, ho uno script di shell che uso per fare questo. Assegna un nome allo script come desideri e aggiungilo da qualche parte nel percorso di inclusione oppure fai riferimento direttamente a:

#!/bin/bash

dir=''

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

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

Con questo, puoi eseguirlo dall'interno della directory che desideri aggiungere o fare riferimento alla directory come primo e unico parametro:

$ ignore_dir ./some/directory

Un'altra opzione (in risposta a un commento di @GreenAsJade), se si desidera tenere traccia di una cartella vuota che MAGGIO contiene file tracciati in futuro, ma sarà vuota per ora, è possibile accedere il <=> dal <=> file, e controlla che in. Fondamentalmente, tutto il file dice è " non ignorare me " ma per il resto, la directory è vuota e tracciata.

Il tuo <=> file sarebbe simile a:

!.gitignore

Ecco fatto, controlla quello e hai una directory vuota, ma tracciata, in cui puoi tracciare i file in un secondo momento.

Il motivo per cui suggerisco di mantenere una riga nel file è che ha lo scopo <=>. Altrimenti, qualcuno lungo la linea potrebbe pensare di rimuoverlo. Può essere utile inserire un commento sopra la riga.

A volte devi avere a che fare con librerie o software scritti male, che richiedono un " real " directory vuota ed esistente. Inserire un semplice .gitignore o .keep potrebbe romperli e causare un bug. Quanto segue potrebbe aiutare in questi casi, ma nessuna garanzia ...

Per prima cosa creare la directory necessaria:

mkdir empty

Quindi aggiungi un collegamento simbolico interrotto a questa directory (ma in qualsiasi altro caso diverso dal caso d'uso sopra descritto, utilizza un README con una spiegazione):

ln -s .this.directory empty/.keep

Per ignorare i file in questa directory, è possibile aggiungerlo nella root <=>:

echo "/empty" >> .gitignore

Per aggiungere il file ignorato, utilizzare un parametro per forzarlo:

git add -f empty/.keep

Dopo il commit hai un link simbolico interrotto nel tuo indice e git crea la directory. Il collegamento interrotto presenta alcuni vantaggi, poiché non è un file normale e non indica alcun file normale. Quindi si adatta anche alla parte della domanda & Quot; (che non contiene file) & Quot ;, non dall'intenzione ma dal significato, immagino:

find empty -type f

Questo comando mostra un risultato vuoto, poiché in questa directory non sono presenti file. Quindi la maggior parte delle applicazioni, che ottengono tutti i file in una directory di solito non vedono questo link, almeno se fanno un & Quot; il file esiste & Quot; o un " è leggibile " ;. Anche alcuni script non troveranno alcun file lì:

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

Ma consiglio vivamente di usare questa soluzione solo in circostanze speciali, una buona scrittura <=> in una directory vuota è di solito una soluzione migliore. (E non so se funziona con un filesystem di Windows ...)

Puoi salvare questo codice come create_readme.php ed eseguire il PHP dalla directory principale del tuo progetto Git.

> php create_readme.php

Aggiungerà i file README a tutte le directory vuote in modo che tali directory vengano quindi aggiunte all'indice.

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

Quindi

git commit -m "message"
git push

A volte ho repository con cartelle che conterranno sempre e solo i file considerati " content " & # 8212; cioè, non sono file a cui tengo di avere la versione, e quindi non dovrebbe mai essere commesso. Con il file .gitignore di Git, puoi ignorare intere directory. Ma ci sono momenti in cui avere la cartella nel repository sarebbe utile. Ecco un'ottima soluzione per soddisfare questa esigenza.

Quello che ho fatto in passato è mettere un file .gitignore alla radice del mio repository e quindi escludere la cartella, in questo modo:

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

Tuttavia, queste cartelle non diventano parte del repository. Puoi aggiungere qualcosa come un file README lì dentro. Ma poi devi dire alla tua applicazione di non preoccuparsi di elaborare alcun file README.

Se la tua app dipende dal fatto che le cartelle siano presenti (sebbene vuote), puoi semplicemente aggiungere un file .gitignore alla cartella in questione e utilizzarlo per raggiungere due obiettivi:

Di 'a Git che c'è un file nella cartella, che fa sì che Git lo aggiunga al repository. Di 'a Git di ignorare il contenuto di questa cartella, meno questo file stesso. Ecco il file .gitignore da inserire nelle tue directory vuote:

*
!.gitignore

La prima riga (*) dice a Git di ignorare tutto in questa directory. La seconda riga dice a Git di non ignorare il file .gitignore. Puoi inserire questo file in ogni cartella vuota che desideri aggiungere al repository.

Un modo semplice per farlo è quello di aggiungere un file .gitkeep alla directory che desideri (attualmente) vuota.

Vedi questa risposta SOF per ulteriori informazioni - il che spiega anche perché alcune persone trovano la convenzione concorrente di aggiungere un .gitignore file (come indicato in molte risposte qui) confuso.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow