¿Cómo puedo agregar un directorio vacío a un repositorio de Git?

https://stackoverflow.com/questions/115983

02-07-2019
|

Pregunta

¿Cómo puedo agregar un directorio vacío (que no contiene archivos) a un repositorio de Git?

Solución

Otra forma de hacer que un directorio permanezca (casi) vacío (en el repositorio) es crear un .gitignore archivo dentro de ese directorio que contiene estas cuatro líneas:

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

Entonces no tienes que hacer el pedido correctamente como tienes que hacerlo en m104. solución.

Esto también brinda el beneficio de que los archivos en ese directorio no aparecerán como "sin seguimiento" cuando realice un estado de git.

Haciendo @verdeasjadeEl comentario de persistente:

Creo que vale la pena señalar que esta solución hace precisamente lo que pedía la pregunta, pero quizás no sea lo que muchas personas que hayan analizado esta pregunta habrán estado buscando.Esta solución garantiza que el directorio permanezca vacío.Dice "Realmente nunca quiero que los archivos se registren aquí".A diferencia de "Todavía no tengo ningún archivo para registrar aquí, pero necesito el directorio aquí, es posible que los archivos lleguen más tarde".

Otros consejos

No puedes.Ver el Preguntas frecuentes sobre Git.

Actualmente, el diseño del índice GIT (área de puesta en escena) solo permite que los archivos se enumeren, y nadie lo suficientemente competente como para hacer que el cambio para permitir directorios vacíos se haya preocupado lo suficiente por esta situación para remediarlo.

Los directorios se agregan automáticamente al agregar archivos dentro de ellos.Es decir, los directorios nunca tienen que agregarse al repositorio y no se rastrean por su cuenta.

Puedes decir "git add <dir>"Y agregará archivos allí.

Si realmente necesita un directorio para existir en los pagos, debe crear un archivo en él..Gitignore funciona bien para este propósito;Puede dejarlo vacío o completar los nombres de los archivos que espera mostrar en el directorio.

Crea un archivo vacío llamado .gitkeep en el directorio y agréguelo.

Siempre puede colocar un archivo README en el directorio con una explicación de por qué desea este directorio, que de otro modo estaría vacío, en el repositorio.

touch .keep

En Linux, esto crea un archivo vacío llamado .keep.Se prefiere este nombre a .gitkeep ya que el primero es agnóstico de Git, mientras que el segundo es específico de Git.En segundo lugar, como ha señalado otro usuario, el .git La convención de prefijo debe reservarse para archivos y directorios que utiliza Git.

Alternativamente, como se señala en otro respuesta, el directorio puede contener una descripción README o README.md archivo en cambio.

Por supuesto, esto requiere que la presencia del archivo no provoque que su aplicación se rompa.

¿Por qué necesitaríamos carpetas versionadas vacías?

Lo primero es lo primero:

Un directorio vacío no puede ser parte de un árbol bajo el sistema de versiones de Git.

Simplemente no será rastreado.Pero hay escenarios en los que "controlar versiones" de directorios vacíos puede ser significativo, por ejemplo:

andamio un estructura de carpetas predefinida, poniéndolo a disposición de todos los usuarios/colaboradores del repositorio;o, como caso especializado de lo anterior, crear una carpeta para archivos temporales, como una cache/ o logs/ directorios, donde queremos proporcionar la carpeta pero .gitignore su contenido
En relación con lo anterior, algunos proyectos no funcionará sin algunas carpetas (lo que a menudo es un indicio de un proyecto mal diseñado, pero es un escenario frecuente del mundo real y tal vez podría haber, por ejemplo, problemas de permisos que abordar).

Algunas soluciones sugeridas

Muchos usuarios sugieren:

Colocando un README archivo u otro archivo con algún contenido para que el directorio no esté vacío, o
Creando un .gitignore archivo con una especie de "lógica inversa" (es decir,para incluir todos los archivos) que, al final, tiene el mismo propósito que el enfoque n.° 1.

Mientras ambas soluciones seguramente funcionan Los encuentro inconsistentes con un enfoque significativo para el control de versiones de Git.

¿Por qué se supone que debes colocar archivos falsos o README que tal vez no quieras en tu proyecto?
Por que usar .gitignore hacer una cosa (acuerdo archivos) que es todo lo contrario de lo que está destinado (Excluyendo archivos), aunque es posible?

enfoque .gitkeep

Utilice un vacío archivo llamado .gitkeep para forzar la presencia de la carpeta en el sistema de versiones.

Aunque pueda parecer que no es una diferencia tan grande:

Se utiliza un archivo que tiene el soltero propósito de conservar la carpeta.No pones allí ninguna información que no quieras poner.

Por ejemplo, debería utilizar archivos README como archivos README con información útil, no como una excusa para conservar la carpeta.

La separación de preocupaciones siempre es algo bueno y aún puedes agregar una .gitignore para ignorar archivos no deseados.
Nombrarlo .gitkeep lo hace muy claro y directo desde el nombre del archivo en sí (y también a otros desarrolladores, lo cual es bueno para un proyecto compartido y uno de los propósitos principales de un repositorio Git) que este archivo es
- Un archivo no relacionado con el código (debido al punto inicial y al nombre)
- Un archivo claramente relacionado con Git
- Su propósito (mantener) está claramente expresado y es consistente y semánticamente opuesto en su significado a ignorar

Adopción

he visto el .gitkeep enfoque adoptado por marcos muy importantes como Laravel, CLI angular.

Como se describe en otras respuestas, Git no puede representar directorios vacíos en su área de preparación.(Ver el Preguntas frecuentes sobre Git.) Sin embargo, si, para sus propósitos, un directorio está lo suficientemente vacío si contiene un .gitignore archivo solamente, entonces puedes crear .gitignore archivos en directorios vacíos solo a través de:

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

Andy Lester tiene razón, pero si su directorio sólo necesita estar vacío y no vacío vacío, puedes poner un vacío .gitignore archivo allí como solución alternativa.

Aparte, este es un problema de implementación, no un problema fundamental de diseño de almacenamiento de Git.Como se ha mencionado muchas veces en la lista de correo de Git, la razón por la que esto no se ha implementado es que a nadie le ha importado lo suficiente como para enviar un parche, no que no pueda o no deba hacerse.

El Ruby on Rails forma de creación de la carpeta de registro:

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

Ahora el directorio de registro se incluirá en el árbol.Es muy útil durante la implementación, por lo que no tendrá que escribir una rutina para crear directorios de registros.

Los archivos de registro se pueden mantener fuera emitiendo,

echo log/dev.log >> .gitignore

pero probablemente lo sabías.

Git no rastrea directorios vacíos.Ver el Preguntas frecuentes sobre Git para más explicaciones.La solución sugerida es poner un .gitignore archivo en el directorio vacío.No me gusta esa solución, porque .gitignore está "oculto" por la convención de Unix.Además, no hay ninguna explicación de por qué los directorios están vacíos.

Sugiero colocar un archivo README en el directorio vacío que explique por qué el directorio está vacío y por qué es necesario realizar un seguimiento en Git.Con el archivo README en su lugar, en lo que respecta a Git, el directorio ya no está vacío.

La verdadera pregunta es ¿por qué necesitas el directorio vacío en git?Por lo general, tiene algún tipo de script de compilación que puede crear el directorio vacío antes de compilar/ejecutar.Si no, entonces haz uno.Esa es una solución mucho mejor que poner directorios vacíos en git.

Entonces tienes alguna razón por la que necesitas un directorio vacío en git.Ponga ese motivo en el archivo README.De esa manera, otros desarrolladores (y usted en el futuro) sabrán por qué el directorio vacío debe estar allí.También sabrá que puede eliminar el directorio vacío cuando se haya resuelto el problema que requiere el directorio vacío.

Para enumerar todos los directorios vacíos, utilice el siguiente comando:

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

Para crear archivos README de marcador de posición en cada directorio vacío:

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

Para ignorar todo lo que hay en el directorio excepto el archivo README, coloque las siguientes líneas en su .gitignore:

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

Alternativamente, podría simplemente excluir cada El archivo README debe ser ignorado:

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

Para enumerar todos los archivos README después de que ya estén creados:

find -name README.emptydir

ADVERTENCIA:Resulta que este ajuste realmente no funciona. Lo siento por los inconvenientes ocasionados.

Publicación original a continuación:

¡Encontré una solución mientras jugaba con las partes internas de Git!

Supongamos que está en su repositorio.
Crea tu directorio vacío:
```
$ mkdir path/to/empty-folder
```
Agréguelo al índice usando un comando de plomería y el árbol vacío SHA-1:
```
$ git update-index --index-info
040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder
```
Escriba el comando y luego ingrese la segunda línea.Prensa Ingresar y luego Control + D para finalizar su entrada.Nota:el formato es modo [ESPACIO] tipo [ESPACIO] SHA-1hash [PESTAÑA] ruta (la pestaña es importante, el formato de respuesta no la conserva).
¡Eso es todo!Su carpeta vacía está en su índice.Todo lo que tienes que hacer es comprometerte.

Esta solución es breve y aparentemente funciona bien (ver la EDITAR!), pero no es tan fácil de recordar...

El árbol vacío SHA-1 se puede encontrar creando un nuevo repositorio Git vacío, cd en él y emitir git write-tree, que genera el árbol vacío SHA-1.

EDITAR:

He estado usando esta solución desde que la encontré.Parece funcionar exactamente de la misma manera que crear un submódulo, excepto que no hay ningún módulo definido en ninguna parte.Esto conduce a errores al emitir git submodule init|update.El problema es ese git update-index reescribe el 040000 tree parte en 160000 commit.

Además, Git nunca notará cualquier archivo colocado en esa ruta, ya que cree que pertenece a algún otro repositorio.¡Esto es desagradable porque puede pasarse por alto fácilmente!

Sin embargo, si aún no utiliza (y no utilizará) ningún submódulo de Git en su repositorio y la carpeta "vacía" permanecerá vacía o si desea que Git sepa de su existencia e ignore su contenido, puede continuar con este ajuste.Seguir el camino habitual con los submódulos requiere más pasos que este ajuste.

Tal vez agregar un directorio vacío parezca que sería el camino de menor resistencia porque tiene scripts que esperan que ese directorio exista (tal vez porque es un destino para los archivos binarios generados).Otro enfoque sería modifique sus scripts para crear el directorio según sea necesario.

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

En este ejemplo, puede registrar un enlace simbólico (roto) al directorio para poder acceder a él sin el prefijo ".generado" (pero esto es opcional).

ln -sf .generated/bin bin
git add bin

Cuando quieras limpiar tu árbol fuente, puedes simplemente:

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

Si adopta el enfoque frecuentemente sugerido de registrar una carpeta casi vacía, tendrá la menor complejidad de eliminar el contenido sin eliminar también el archivo ".gitignore".

Puede ignorar todos los archivos generados agregando lo siguiente a su raíz .gitignore:

.generated

Digamos que necesita un directorio vacío llamado tmp :

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

En otras palabras, necesitas agregar el archivo .gitignore al índice antes de poder decirle a Git que lo ignore (y todo lo demás en el directorio vacío).

También me he enfrentado al problema de los directorios vacíos.El problema con el uso de archivos de marcador de posición es que es necesario crearlos y eliminarlos si ya no son necesarios (porque más adelante se agregaron subdirectorios o archivos).Con árboles de fuentes grandes, la gestión de estos archivos de marcador de posición puede resultar engorrosa y propensa a errores.

Es por eso que decidí escribir una herramienta de código abierto que pueda gestionar la creación/eliminación de dichos archivos de marcador de posición automáticamente.Está escrito para la plataforma .NET y se ejecuta en Mono (.NET para Linux) y Windows.

Solo echa un vistazo a: http://code.google.com/p/markemptydirs

No puedes y lamentablemente nunca podrás hacerlo.Esta es una decisión tomada por el propio Linus Torvald.Él sabe lo que es bueno para nosotros.

Hay una queja por ahí que leí una vez.

encontré Re:Directorios vacíos.., pero tal vez haya otro.

Tienes que vivir con las soluciones alternativas... desafortunadamente.

Me gustan las respuestas de @Artur79 y @mjs, así que he estado usando una combinación de ambos y la convertí en un estándar para nuestros proyectos.

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

Sin embargo, sólo un puñado de nuestros desarrolladores trabajan en Mac o Linux.Mucho trabajo en Windows y no pude encontrar una frase simple equivalente para lograr lo mismo allí.Algunos tuvieron la suerte de tener Cygwin instalado por otras razones, pero recetar Cygwin solo para esto parecía excesivo.

Editar para una mejor solución

Entonces, dado que la mayoría de nuestros desarrolladores ya tienen Hormiga instalado, lo primero que pensé fue en armar un archivo de compilación Ant para lograr esto independientemente de la plataforma.Esto todavía se puede encontrar. aquí

Sin embargo, Más tarde pensé que sería mejor convertir esto en un pequeño comando de utilidad, así que lo recreé usando Python y lo publiqué en PyPI. aquí.Puedes instalarlo simplemente ejecutando:

pip3 install gitkeep2

Te permitirá crear y eliminar .gitkeep archivos de forma recursiva y también le permitirá agregarles mensajes para que sus pares comprendan por qué esos directorios son importantes.Esto último es una ventaja.Pensé que sería bueno si el .gitkeep Los archivos podrían ser autodocumentados.

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

Espero que le sea útil.

Cuando agregas un .gitignore archivo, si va a poner cualquier cantidad de contenido en él (que desea que Git ignore), es posible que desee agregar una sola línea con solo un asterisco * para asegurarse de no agregar el contenido ignorado accidentalmente.

Como se mencionó, no es posible agregar directorios vacíos, pero aquí hay una línea que agrega archivos .gitignore vacíos a todos los directorios.

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

He guardado esto en un Rakefile para facilitar el acceso.

La solución de Jamie Flournoy Funciona genial.Aquí hay una versión un poco mejorada para mantener el .htaccess :

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

Con esta solución puedes confirmar una carpeta vacía, por ejemplo /log, /tmp o /cache y la carpeta permanecerá vacía.

Siempre construyo una función para verificar la estructura de carpetas que deseo y la construyo dentro del proyecto.Esto soluciona este problema ya que las carpetas vacías se mantienen en Git mediante 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");
}

Esto está en PHP, pero estoy seguro de que la mayoría de los lenguajes admiten la misma funcionalidad y, debido a que la aplicación se encarga de la creación de las carpetas, las carpetas siempre estarán ahí.

Aquí hay un truco, pero es curioso que funcione (Git 2.2.1).Similar a lo que sugirió @Teka, pero más fácil de recordar:

Agregue un submódulo a cualquier repositorio (git submodule add path_to_repo)
Esto agregará una carpeta y un archivo. .submodules.Realizar un cambio.
Borrar .submodules archivo y confirmar el cambio.

Ahora, tiene un directorio que se crea cuando se desprotege la confirmación.Sin embargo, una cosa interesante es que si observa el contenido del objeto de árbol de este archivo, obtendrá:

fatal:No es un nombre de objeto válido B64338B90B4209263B50244D18278C0999867193

Sin embargo, no recomendaría su uso ya que puede dejar de funcionar en futuras versiones de Git.Lo que puede dejar su repositorio dañado.

No hay forma de hacer que Git rastree directorios, por lo que la única solución es agregar un archivo de marcador de posición dentro del directorio que desea que Git rastree.

El archivo puede tener un nombre y contener lo que quieras, pero la mayoría de la gente usa un archivo vacío llamado .gitkeep (aunque algunas personas prefieren el VCS-agnóstico .keep).

el prefijado . lo marca como un archivo oculto.

Otra idea sería agregar un README archivo que explica para qué se utilizará el directorio.

No puedes.Esta es una decisión de diseño intencional por parte de los mantenedores de Git.Básicamente, el propósito de un sistema de administración de código fuente como Git es administrar el código fuente y los directorios vacíos no son código fuente.Git también se describe a menudo como un rastreador de contenido y, nuevamente, los directorios vacíos no son contenido (en realidad, todo lo contrario), por lo que no se rastrean.

Si desea agregar una carpeta que albergará una gran cantidad de datos transitorios en múltiples directorios semánticos, entonces un enfoque es agregar algo como esto a su raíz .gitignore...

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

Luego puede enviar archivos README.md descriptivos (o archivos en blanco, no importa, siempre y cuando pueda apuntar a ellos de forma única, como con el *.md en este caso) en cada directorio para garantizar que todos los directorios sigan siendo parte del repositorio pero que los archivos (con extensiones) se mantengan ignorados.LIMITACIÓN: .¡Los 's no están permitidos en los nombres de directorio!

Puede llenar todos estos directorios con archivos xml/images o lo que sea y agregar más directorios en /app/data/ con el tiempo a medida que se desarrollan las necesidades de almacenamiento de su aplicación (con los archivos README.md sirviendo para grabar una descripción de para qué sirve exactamente cada directorio de almacenamiento).

No es necesario modificar más su .gitignore o descentralizar creando una nueva .gitignore para cada nuevo directorio.Probablemente no sea la solución más inteligente, pero es concisa en cuanto a gitignore y siempre funciona para mí.¡Bonito y sencillo!;)

Sumando una opción más a la refriega.

Suponiendo que desea agregar un directorio a git que, para todos los efectos relacionados con git, debe permanecer vacío y nunca rastrear su contenido, un .gitignore como se sugiere numerosas veces aquí, funcionará.

El formato, como se mencionó, es:

*
!.gitignore

Ahora, si desea una manera de hacer esto en la línea de comando, de una sola vez, mientras adentro el directorio que desea agregar, puede ejecutar:

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

Yo mismo tengo un script de shell que uso para hacer esto.Asigne al script el nombre que desee y agréguelo en algún lugar de su ruta de inclusión o haga referencia a él directamente:

#!/bin/bash

dir=''

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

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

Con esto, puede ejecutarlo desde el directorio que desea agregar o hacer referencia al directorio como su primer y único parámetro:

$ ignore_dir ./some/directory

Otra opción (en respuesta a un comentario de @GreenAsJade), si desea rastrear una carpeta vacía que PUEDE contener archivos rastreados en el futuro, pero estarán vacíos por ahora, puede omitir el * desde el .gitignore archivar y comprobar eso en.Básicamente, todo lo que dice el archivo es "no ignorar a mí", pero por lo demás, el directorio está vacío y se realiza un seguimiento.

Su .gitignore el archivo se vería así:

!.gitignore

Eso es todo, verifíquelo y tendrá un directorio vacío, aún rastreado, en el que podrá rastrear archivos en algún momento posterior.

La razón por la que sugiero mantener esa línea en el archivo es que proporciona la .gitignore objetivo.De lo contrario, alguien más adelante podría pensar en eliminarlo.Puede resultar útil colocar un comentario encima de la línea.

A veces tienes que lidiar con bibliotecas o software mal escritos, que necesitan un directorio "real" vacío y existente.poniendo un simple .gitignore o .keep podría romperlos y causar un error.Lo siguiente podría ayudar en estos casos, pero no es garantía...

Primero cree el directorio necesario:

mkdir empty

Luego agrega un enlace simbólico roto a este directorio (pero en cualquier otro caso que no sea el caso de uso descrito anteriormente, use un README con una explicación):

ln -s .this.directory empty/.keep

Para ignorar archivos en este directorio, puede agregarlo en su raíz .gitignore:

echo "/empty" >> .gitignore

Para agregar el archivo ignorado, use un parámetro para forzarlo:

git add -f empty/.keep

Después de la confirmación, tiene un enlace simbólico roto en su índice y git crea el directorio.El enlace roto tiene algunas ventajas, ya que no es un archivo normal y no apunta a ningún archivo normal.Así que incluso se ajusta a la parte de la pregunta "(que no contiene archivos)", no por la intención sino por el significado, supongo:

find empty -type f

Este comando muestra un resultado vacío, ya que no hay archivos presentes en este directorio.Por lo tanto, la mayoría de las aplicaciones que obtienen todos los archivos en un directorio generalmente no ven este enlace, al menos si ven un "archivo existe" o "es legible".Incluso algunos scripts no encontrarán ningún archivo allí:

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

Pero recomiendo encarecidamente utilizar esta solución sólo en circunstancias especiales, un buen escrito README en un directorio vacío suele ser una mejor solución.(Y no sé si esto funciona con un sistema de archivos de Windows...)

Puede guardar este código como create_readme.php y ejecutar el PHP código del directorio raíz de su proyecto Git.

> php create_readme.php

Agregará archivos README a todos los directorios que estén vacíos para que luego esos directorios se agreguen al índice.

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

Entonces hazlo

git commit -m "message"
git push

A veces tengo repositorios con carpetas que solo contendrán archivos considerados "contenido", es decir, no son archivos que me interesen versionar y, por lo tanto, nunca deberían confirmarse.Con el archivo .gitignore de Git, puedes ignorar directorios completos.Pero hay ocasiones en las que sería beneficioso tener la carpeta en el repositorio.He aquí una excelente solución para satisfacer esta necesidad.

Lo que hice en el pasado fue colocar un archivo .gitignore en la raíz de mi repositorio y luego excluir la carpeta, así:

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

Sin embargo, estas carpetas no pasan a formar parte del repositorio.Podrías agregar algo así como un archivo README allí.Pero luego tienes que decirle a tu aplicación que no se preocupe por procesar ningún archivo README.

Si su aplicación depende de que las carpetas estén ahí (aunque vacías), simplemente puede agregar un archivo .gitignore a la carpeta en cuestión y usarlo para lograr dos objetivos:

Dígale a Git que hay un archivo en la carpeta, lo que hace que Git lo agregue al repositorio.Dígale a Git que ignore el contenido de esta carpeta, menos este archivo en sí.Aquí está el archivo .gitignore para colocar dentro de sus directorios vacíos:

*
!.gitignore

La primera línea (*) le dice a Git que ignore todo lo que hay en este directorio.La segunda línea le dice a Git que no ignore el archivo .gitignore.Puede colocar este archivo en cada carpeta vacía que desee agregar al repositorio.

Una forma sencilla de hacerlo es añadiendo un .gitkeep archivo al directorio que desea (actualmente) mantener vacío.

Mira esto respuesta SOF para obtener más información, lo que también explica por qué algunas personas encuentran confusa la convención competitiva de agregar un archivo .gitignore (como se indica en muchas respuestas aquí).

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow