Comment puis-je ajouter un répertoire vide à un dépôt Git?

vous ne pouvez pas. Voir la git FAQ .

actuellement la conception de l'indice git (aire de repos) ne permet que les être listé, et personne assez compétent pour faire le changement pour permettre à vide les répertoires se sont assez souciés de cette situation pour y remédier.

Les répertoires

sont ajoutés automatiquement lors de l'ajout de fichiers à l'intérieur d'eux. Que est, répertoires ne jamais être ajouté à l' référentiel, et ne sont pas suivis sur leur propre.

, Vous pouvez dire " git add <dir> " et il va ajouter des fichiers.

Si vous avez vraiment besoin d'un répertoire existent dans les extractions vous devez créer un fichier. .gitignore fonctionne bien pour ce but; vous pouvez le laisser vide, ou remplissez les noms des fichiers que vous s'attendre à apparaître dans le répertoire.

crée un fichier vide appelé .gitkeep dans le répertoire, et ajoute cela.

vous pouvez toujours mettre un fichier README dans le répertoire avec une explication de la raison pour laquelle vous voulez ce répertoire, sinon vide, dans le dépôt.

touch .keep

sur Linux, cela crée un fichier vide nommé .keep . Ce nom est préféré à .gitkeep car le premier est agnostique à Git, tandis que le second est spécifique à git. Deuxièmement, comme un autre utilisateur l'a noté, la convention de préfixe .git devrait être réservée aux fichiers et répertoires que Git lui-même utilise.

alternativement, comme indiqué dans une autre réponse , le répertoire peut contenir un descriptif README ou README.md fichier à la place.

bien sûr, cela exige que la présence du fichier ne causera pas votre demande de briser.

pourquoi aurions-nous besoin de dossiers vides avec versions

tout d'Abord:

Un répertoire vide ne peut pas faire partie d'un arbre sous le système de gestion de versions Git .

il ne sera tout simplement pas suivi. Mais il existe des scénarios dans lesquels "versionner" un répertoire vide peut être utile, par exemple:

• bâtiment a structure de dossier prédéfinie pour les dossiers de projet utiles, et mettre cette structure à la disposition de chaque utilisateur/contributeur du dépôt; ou, comme cas spécialisé de ce qui précède, création d'un dossier pour fichiers temporaires , tels que cache/ ou logs/ répertoires
• quelques projets "1519150920 n'est tout simplement pas fonctionner sans certains dossiers (ce qui est souvent un indicateur d'une mauvaise conception du projet, mais il est souvent le scénario du monde réel et peut-être qu'il pourrait y avoir, par exemple, des problèmes de permission).

Certains ont suggéré des solutions de contournement

de nombreux utilisateurs suggèrent:

1. placer un README fichier ou un autre fichier avec un certain contenu afin de rendre le répertoire non vide, ou
2. la Création d'un .gitignore fichier avec une sorte de "logique inverse" (c'est à dire d'inclure tous les fichiers) qui, à la fin, sert le même but de l'approche no 1.

, Alors que les deux solutions sûrement travail je les trouve unconsistent avec une approche significative de versioning Git.

• Pourquoi es-tu supposé mettre des fichiers ou des READMEs bidons que peut-être tu ne veux pas vraiment dans ton projet?
• Pourquoi utiliser .gitignore pour faire une chose ( conserver fichiers) qui est le contraire de ce que cela signifie ( à l'exclusion des fichiers ), même si c'est possible?

.gitkeep approach

utilisez un vide fichier appelé .gitkeep afin de forcer la présence du dossier dans le système de versioning.

bien qu'il ne semble pas une grande différence:

• vous utilisez un fichier qui a le simple but de conserver le dossier. Tu n'y mets aucune info que tu ne veux pas mettre.

  par exemple, vous devriez utiliser READMEs comme, bien, READMEs avec des informations utiles, pas comme excuse pour garder le dossier.

  la Séparation des préoccupations est toujours une bonne chose, et vous pouvez toujours ajouter un .gitignore ignorer les fichiers indésirables.

• le nommer .gitkeep le rend très clair et simple de la nom de fichier lui-même (et aussi à d'autres développeurs , ce qui est bon pour un projet partagé et l'un des buts principaux d'un dépôt Git) que ce fichier est

  • un fichier sans rapport avec le code (en raison du point de tête et du nom)
  • Un fichier est clairement lié à Git
  • son objet ( keep ) est clairement énoncé et compatible et sémantiquement opposé dans son sens à ignorer

Adoption

j'ai vu l'approche .gitkeep adoptée par des cadres très importants comme Laravel , Angular-CLI .

tel que décrit dans d'autres réponses, Git n'est pas en mesure de représenter des répertoires vides dans sa zone de transit. (Voir la git FAQ .) Cependant, si, pour vos besoins, un répertoire est assez vide s'il contient seulement un fichier .gitignore , alors vous pouvez créer des fichiers .gitignore dans des répertoires vides uniquement via:

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

Andy Lester a raison, mais si votre répertoire doit juste être vide, et pas vide vide, vous pouvez y mettre un fichier .gitignore vide comme solution de contournement.

mis à part, il s'agit d'un problème de mise en œuvre, et non d'un problème fondamental de conception de stockage Git. Comme cela a été mentionné à plusieurs reprises sur la liste de diffusion Git, la raison pour laquelle cela n'a pas été implémenté est que personne ne s'est suffisamment soucié de soumettre un patch pour cela, non pas qu'il ne pouvait pas ou ne devrait pas être fait.

Le Ruby on Rails :

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

maintenant le répertoire log sera inclus dans l'arbre. Il est super-utile lors du déploiement, donc vous n'aurez pas à écrire une routine pour faire des répertoires log.

les fichiers journaux peuvent être tenus à l'écart en émettant,

echo log/dev.log >> .gitignore

mais vous le saviez probablement.

Git ne trace pas les répertoires vides. Voir la git FAQ pour plus d'explications. La solution suggérée est de mettre un fichier .gitignore dans le répertoire vide. Je n'aime pas cette solution, parce que le .gitignore est "caché" par la convention Unix. Aussi il n'y a aucune explication pourquoi les répertoires sont vides.

je suggère de mettre un fichier README dans le répertoire vide en expliquant pourquoi le répertoire est vide et pourquoi il doit être suivi dans Git. Avec le fichier README en place, en ce qui concerne Git, le répertoire n'est plus vide.

la vraie question est pourquoi avez-vous besoin du répertoire vide dans git? Habituellement, vous avez une sorte de script de construction qui peut créer le répertoire vide avant de compiler/exécuter. Si non, alors en faire un. C'est une bien meilleure solution que de mettre les répertoires vides dans git.

donc vous avez une raison pour laquelle vous avez besoin d'un répertoire vide dans git. Mettez cette raison dans le fichier README. De cette façon, les autres développeurs (et vous futurs) savent pourquoi le répertoire vide doit être là. Vous savez aussi que vous pouvez supprimer le répertoire vide lorsque le problème nécessitant le répertoire vide a été résolu.

pour lister tous les répertoires vides, utilisez la commande suivante:

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

pour créer des readmes dans chaque répertoire vide:

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

pour ignorer tout dans le répertoire sauf le fichier README mettre les lignes suivantes dans votre .gitignore :

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

sinon, vous pouvez simplement exclure chaque fichier README d'être ignoré:

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

pour lister chaque README après qu'ils sont déjà créés:

find -name README.emptydir

AVERTISSEMENT: Ce tweak n'est pas vraiment travailler comme il s'avère. Désolé pour le dérangement.

Original post ci-dessous:

j'ai trouvé une solution en jouant avec Git internals!

1. supposez que vous êtes dans votre dépôt.

2. créez votre répertoire vide:

   $ mkdir path/to/empty-folder
   

3. ajouter à l'index en utilisant une commande de plomberie et l'arbre vide SHA-1 :

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

   tapez la commande puis inscrivez la deuxième ligne. Appuyez sur Enter et ensuite Ctrl + D pour terminer votre entrée. Note: le format est mode [espace] type [espace] SHA-1hash [TAB] chemin (le tab est important, le formatage de la réponse ne le préserve pas).

4. C'est ça! Votre dossier vide dans votre index. Tout ce que vous avez à faire est de s'engager.

Cette solution est court et apparemment fonctionne très bien ( voir l'EDIT! ), mais il n'est pas si facile à mémoriser...

L'arbre vide SHA-1 peut être trouvé en créant un nouveau dépôt git vide, cd en elle et l'édition git write-tree , qui affiche L'arbre vide SHA-1.

EDIT:

j'utilise cette solution Depuis que je l'ai trouvée. Il semble fonctionner exactement de la même façon que la création d'un sous-module, sauf qu'aucun module n'est défini nulle part. Cela conduit à des erreurs lors de l'émission git submodule init|update . Le problème est que git update-index réécrit la partie 040000 tree en 160000 commit .

en outre, tout dossier placé sous ce chemin ne jamais être remarqué par Git, car il pense qu'ils appartiennent à un autre référentiel. C'est désagréable car on peut facilement l'ignorer!

cependant, si vous n'utilisez pas déjà (et ne voulez pas) de sous-modules Git dans votre dépôt, et le dossier "vide" restera vide ou si vous voulez que Git sache son existence et ignore son contenu, Vous pouvez utiliser ce tweak. Aller de la manière habituelle avec des sous-modules prend plus de mesures que cela tweak.

peut-être que l'ajout d'un répertoire vide semble comme si ce serait le chemin de moindre résistance parce que vous avez des scripts qui s'attendent à ce que ce répertoire existe (peut-être parce que c'est une cible pour les binaires générés). Une autre approche serait de modifier vos scripts pour créer le répertoire nécessaire .

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

dans cet exemple, vous pouvez enregistrer un lien symbolique (cassé) vers le répertoire pour y accéder. sans le ".généré" préfixe (mais c'est facultatif).

ln -sf .generated/bin bin
git add bin

quand vous voulez nettoyer votre arbre source vous pouvez juste:

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

si vous prenez l'approche souvent suggérée de vérifier dans un dossier presque vide, vous avez la petite complexité de supprimer le contenu sans supprimer aussi le".gitignore de fichier".

vous pouvez ignorer tous vos fichiers générés en ajoutant ce qui suit à votre root .gitignore:

.generated

disons que vous avez besoin d'un répertoire vide nommé tmp :

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

En d'autres termes, vous devez ajouter les .le fichier gitignore à l'index avant que vous puissiez dire à Git de l'ignorer (et tout le reste dans le répertoire vide).

j'ai été confronté au problème avec des répertoires vides, aussi. Le problème avec l'utilisation de placeholder les fichiers est que vous devez les créer, et les supprimer, si elles ne sont plus nécessaires (parce que plus tard il y avait ajouté des sous-répertoires ou des fichiers. Avec de grandes arborescences de sources, la gestion de ces fichiers placeholder peut être lourde et sujette à des erreurs.

C'est pourquoi j'ai décidé d'écrire un outil open source qui peut gérer la création/suppression des fichiers temporaires automatiquement. Il est écrit pour la plate-forme .NET et fonctionne sous Mono (.net pour Linux) et Windows.

il suffit de jeter un oeil à: http://code.google.com/p/markemptydirs

vous ne pouvez pas et ne pourrez malheureusement jamais. C'est une décision prise par Linus Torvald lui-même. Il sait ce qui est bon pour nous.

il y a une rumeur quelque part que j'ai lu une fois.

j'ai trouvé Re: les répertoires Vides.. , mais il y en a peut-être un autre.

Vous devez vivre avec les solutions de contournement...malheureusement.

lorsque vous ajoutez un fichier .gitignore , si vous allez y mettre n'importe quelle quantité de contenu (que vous voulez que Git ignore) vous pourriez vouloir ajouter une ligne simple avec juste un astérisque * pour s'assurer que vous n'ajoutez pas le contenu ignoré accidentellement.

j'aime les réponses de @Artur79 et @mjs donc j'ai utilisé une combinaison des deux et en a fait une norme pour nos projets.

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

cependant, seulement une poignée de nos développeurs travaillent sur Mac ou Linux. Beaucoup de travail sur les fenêtres et je ne pouvais pas trouver un équivalent simple une doublure pour accomplir la même là. Certains ont eu la chance d'avoir Cygwin installé pour d'autres raisons, mais prescrire Cygwin juste pour cela semblait exagéré.

donc, puisque la plupart de nos développeurs ont déjà Ant installé, j'ai mis en place un fichier de construction pour accomplir ceci indépendamment de la plate-forme.

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

maintenant je peux simplement exécuter

ant -f gitkeep.xml

et cela crée un .gitkeep fichier dans n'importe quel vide sous répertoire. Même sur Windows :) Note: Ce fichier de compilation nécessite le Ant Contrib jar.

je continue à travailler sur ce concept ici .

https://github.com/mig82/gitkeep

comme mentionné il n'est pas possible d'ajouter des répertoires vides, mais voici un liner qui ajoute vide .les fichiers gitignore à tous les répertoires.

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

j'ai mis ceci dans un Rakefile pour un accès facile.

je construis toujours une fonction pour vérifier la structure de mon dossier et la construire pour moi dans le projet. Cela permet de contourner ce problème car les dossiers vides sont tenus dans git par 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");
}

C'est en PHP, mais je suis sûr que la plupart des langues supportent la même fonctionnalité, et parce que la création des dossiers est prise en charge par l'application, les dossiers seront toujours là.

voici un hack, mais c'est marrant que ça marche (Git 2.2.1). Semblable à ce que @Teka a suggéré, mais plus facile à se rappeler:

• Ajouter un sous-module à n'importe quel dépôt ( git submodule add path_to_repo )
• Cela va ajouter un dossier et un fichier .submodules . Commettre un changement.
• Supprimer .submodules fichier et valider la modification.

Maintenant, vous avez un répertoire qui est créé lorsque commit est coché. Une chose intéressante cependant est que si vous regardez le contenu de l'arbre objet de ce fichier, vous obtiendrez:

fatal: Pas un nom d'objet valide b64338b90b4209263b50244d18278c0999867193

Je ne l'encouragerais pas à l'utiliser car il pourrait cesser de fonctionner dans les futures versions de Git. Ce qui peut laisser votre dépôt corrompu.

il n'y a aucun moyen d'obtenir Git pour suivre les répertoires, donc la seule solution est d'ajouter un fichier placeholder dans le répertoire que vous voulez que git suive.

le fichier peut être nommé et contenir tout ce que vous voulez, mais la plupart des gens utilisent un fichier vide nommé .gitkeep (bien que certaines personnes préfèrent le VCS-agnostic .keep ).

le préfixe . le marque comme un fichier caché.

une Autre idée serait d'ajouter un README fichier expliquant à quoi servira le répertoire.

La solution de Jamie Flournoy fonctionne à merveille. Voici une version améliorée pour garder le .htaccess :

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

avec cette solution vous êtes en mesure de commettre un dossier vide, par exemple /log , /tmp ou /cache et le dossier restera vide.

vous ne pouvez pas. Il s'agit d'une décision de conception intentionnelle prise par les responsables de Git. Fondamentalement, le but d'un système de gestion de Code Source comme Git est de gérer le code source et les répertoires vides ne sont pas du code source. Git est aussi souvent décrit comme un tracker de contenu, et encore une fois, les répertoires vides ne sont pas du contenu (bien au contraire, en fait), donc ils ne sont pas tracés.

parfois, vous devez faire face à de mauvaises bibliothèques écrites ou logiciels, qui ont besoin d'un "vrai" répertoire vide et existant. Mettre un simple .gitignore ou .keep pourrait les casser et causer un bug. Ce qui suit pourrait aider dans ces cas, mais pas de garantie...

créez D'abord le répertoire nécessaire:

mkdir empty

ensuite vous ajoutez un lien symbolique cassé à ce répertoire (mais sur tout autre cas que le cas d'utilisation décrit ci-dessus), s'il vous plaît utiliser un README avec une explication):

ln -s .this.directory empty/.keep

Pour ignorer les fichiers dans ce répertoire, vous pouvez l'ajouter dans votre racine .gitignore :

echo "/empty" >> .gitignore

pour ajouter le fichier ignoré, utilisez un paramètre pour le forcer:

git add -f empty/.keep

après la propagation vous avez un lien symbolique cassé dans votre index et git crée le répertoire. Le lien cassé a quelques avantages, car il n'est pas un fichier régulier et les points à aucun régulier fichier. Donc, il correspond même à la partie de la question "(qui ne contient pas de fichiers)", pas par l'intention mais par le sens, je suppose:

find empty -type f

Cette commande affiche un résultat vide, car aucun fichier n'est présent dans ce répertoire. Ainsi la plupart des applications, qui obtiennent tous les fichiers dans un répertoire ne voient généralement pas ce lien, au moins si elles font un "fichier existe" ou un "est lisible". Même certains scripts n'y trouveront pas de fichiers:

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

Mais Je fortement recommandé d'utiliser cette solution que dans des circonstances spéciales, un bon écrit README dans un répertoire vide est généralement une meilleure solution. (Et je ne sais pas si cela fonctionne avec un système de fichiers windows...)

ajout D'une option de plus à la mêlée.

en supposant que vous voulez ajouter un répertoire à git qui, pour tout usage lié à git , devrait rester vide et ne jamais avoir son contenu suivi, un .gitignore comme suggéré de nombreuses fois ici, fera l'affaire.

le format, tel que mentionné, est:

*
!.gitignore

Maintenant, si vous voulez un moyen de faire cela en ligne de commande, d'un seul coup, alors que inside le répertoire que vous voulez ajouter, vous pouvez exécuter:

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

Moi, j'ai un script shell que j'utilise pour ce faire. Nom du script que vous souhaitez, et l'ajouter quelque part dans votre chemin, ou d'une référence directe:

#!/bin/bash

dir=''

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

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

avec ceci, vous pouvez soit l'exécuter à partir du répertoire que vous souhaitez ajouter, ou référencer le répertoire comme premier et seul paramètre:

$ ignore_dir ./some/directory

une autre option (en réponse à un commentaire de @GreenAsJade), si vous voulez tracer un dossier vide que mai contiennent des fichiers suivis dans le futur, mais sera vide pour l'instant, vous pouvez omettre le * à partir du .gitignore fichier, et cochez que dans. Fondamentalement, tout ce que le fichier DIT est "ne pas ignorer me ", mais autrement, le répertoire est vide et traqué.

Votre fichier .gitignore ressemblerait à:

!.gitignore

c'est tout, vérifiez cela, et vous avez un répertoire vide, mais suivi, que vous pouvez suivre des fichiers à un moment ultérieur.

la raison pour laquelle je suggère de garder cette ligne dans le fichier est qu'elle donne le but .gitignore . Sinon, quelqu'un pourrait penser à le supprimer. Cela peut aider si vous placez un commentaire au-dessus de la ligne.

si vous voulez ajouter un dossier qui hébergera beaucoup de données transitoires dans plusieurs répertoires sémantiques, alors une approche consiste à ajouter quelque chose comme ça à votre racine .gitignore...

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

alors vous pouvez commettre README descriptif.les fichiers md (ou les fichiers Vierges, n'a pas d'importance, tant que vous pouvez les cibler uniquement comme avec le *.md dans ce cas-ci) dans chaque répertoire pour s'assurer que les répertoires restent tous partie de la mais les fichiers (avec extensions) sont gardés ignorés. LIMITATION: . 's ne sont pas autorisés dans les noms de répertoire!

vous pouvez remplir tous ces répertoires avec des fichiers xml/images ou n'importe quoi et ajouter plus de répertoires sous /app/data/ au fil du temps que les besoins de stockage pour votre application se développent (avec le README.md file serving to burn in a description of what each storage directory is for exactly).

il n'est pas nécessaire de modifier votre .gitignore ou décentraliser en créant un nouveau .gitignore pour chaque nouveau répertoire. Probablement pas la solution la plus intelligente, mais est laconique gitignore-sage et travaille toujours pour moi. Simple et sympathique! ;)

vous pouvez enregistrer ce code comme create_readme.php et exécutez le code PHP à partir du répertoire racine de votre projet Git.

> php create_readme.php

il va ajouter des fichiers README à tous les répertoires qui sont vides afin que ces répertoires soient ensuite ajoutés à l'index.

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

Puis faites

git commit -m "message"
git push

parfois, j'ai des dépôts avec des dossiers qui ne contiendront que des fichiers considérés comme du "contenu" -c'est-à-dire qu'ils ne sont pas des fichiers que je me soucie d'être suivis en versions, et ne devraient donc jamais être engagés. Avec Git .gitignore, vous pouvez ignorer des répertoires entiers. Mais il y a des moments lorsque le dossier de l'opération serait bénéfique. Voici une excellente solution pour réaliser ce besoin.

ce que j'ai fait dans le passé est mis A.fichier gitignore à la racine de mon repo, puis d'exclure le dossier, comme suit:

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

cependant, ces dossiers ne font alors pas partie du repo. Vous pouvez ajouter quelque chose comme un fichier README là-dedans. Mais ensuite, vous devez dire à votre application de ne pas se soucier du traitement des fichiers README.

si votre application dépend de la présence des dossiers (bien que vides), vous pouvez simplement ajouter un .gitignore fichier dans le dossier en question, et de l'utiliser pour accomplir deux objectifs:

dites à Git qu'il y a un fichier dans le dossier, ce qui fait que Git l'ajoute à la pension. Indiquer à Git d'ignorer le contenu de ce dossier, moins ce fichier lui-même. Ici est la .gitignore fichier à mettre à l'intérieur de vos répertoires vides:

*
!.gitignore

la première ligne (*) dit à Git d'ignorer tout ce qui se trouve dans ce répertoire. La deuxième ligne dit à Git de ne pas l'ignorer .dossier gitignore. Vous pouvez farcir ce fichier dans chaque dossier vide que vous souhaitez ajouter au référentiel.