Como posso adicionar um diretório vazio para um repositório Git?

https://stackoverflow.com/questions/115983

02-07-2019
|

Pergunta

Como posso adicionar um diretório vazio (que não contém arquivos) para um repositório Git?

Solução

Outra maneira de fazer uma estadia diretório (quase) vazio (no repositório) é criar um arquivo .gitignore dentro daquele diretório que contém estas quatro linhas:

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

Em seguida, você não tem que obter a ordem à direita o caminho que você tem que fazer no das m104 solução .

Isso também dá o benefício que arquivos no diretório não vai aparecer como "untracked" quando você faz um git status.

@GreenAsJade 's comentário persistente:

Eu acho que é importante notar que esta solução faz precisamente o que a pergunta pediu, mas não é, talvez, o que muitas pessoas a esta pergunta terá sido procurando. Esta solução garante que os restos diretório vazio. Ele diz: "Eu realmente nunca quer arquivos xadrezes aqui". Ao contrário de "Eu não tenho quaisquer arquivos para o check-in aqui, ainda, mas eu preciso do diretório aqui, os arquivos podem estar chegando mais tarde".

Outras dicas

Você não pode. Veja a Git FAQ .

Atualmente, o projeto do índice git (Área de teste) só permite arquivos para ser listados, e ninguém o suficiente competente para fazer a mudança para permitir vazia diretórios tem o suficiente se preocupava esta situação para remediá-lo.

Diretórios são adicionados automaticamente Ao adicionar arquivos dentro deles. Este é, diretórios nunca tem que ser adicionado para o repositório, e não são rastreados por conta própria.

Você pode dizer "git add <dir>" e vai adicionar arquivos lá dentro.

Se você realmente precisa de um diretório para existem em checkouts você deve criar um arquivo nele. .gitignore funciona bem para este propósito; você pode deixá-lo vazio, ou preencher os nomes de arquivos que você esperar para aparecer no diretório.

Criar um arquivo vazio chamado .gitkeep no diretório, e adicionar isso.

Você pode sempre colocar um arquivo README no diretório com uma explicação de por que você quer isso, caso contrário esvaziar, diretório no repositório.

touch .keep

No Linux, isso cria um arquivo vazio chamado .keep. Este nome é preferido em relação .gitkeep como a primeira é agnóstico a GIT, ao passo que o último é específico para GIT. Em segundo lugar, como outro usuário observou, a convenção .git prefixo deve ser reservada para os arquivos e diretórios que se Git usa.

Como alternativa, como observado em outra resposta , o diretório pode conter um descritivo README ou arquivo README.md vez.

Claro que isso exige que a presença do arquivo não fará com que seu aplicativo para quebrar.

Por que precisamos de esvaziar Versioned pastas

As primeiras coisas primeiro:

Um diretório vazio não pode ser parte de uma árvore sob o Git sistema de controle de versão .

Ele simplesmente não serão rastreadas. Mas há situações em que "versionamento" diretórios vazios pode ser significativo, por exemplo:

andaimes um predefinida pasta estrutura , tornando-o disponível para cada usuário / contribuinte do repositório; ou, como um caso especial do exposto, criando uma pasta para arquivos temporários , como um cache/ ou logs/ diretórios, onde queremos proporcionar a pasta, mas .gitignore seu conteúdo
relacionado com o acima, alguns projetos não funcionará sem algumas pastas (que é muitas vezes um toque de um projeto mal concebido, mas é um cenário do mundo real frequentes e talvez poderia haver, digamos, problemas de permissão a ser abordado).

Algumas soluções sugeridas

Muitos usuários sugerem:

A colocação de um arquivo README ou outro arquivo com algum conteúdo, a fim de tornar o diretório não vazio, ou
Criação de um arquivo .gitignore com uma espécie de "lógica inversa" (ou seja, para incluir todos os arquivos), que, no final, tem a mesma finalidade da abordagem # 1.

Enquanto ambas as soluções certamente trabalho eu encontrá-los incompatíveis com uma abordagem significativa para Git versão.

Por que você deve colocar arquivos falsos ou READMEs que talvez você realmente não quer em seu projeto?
Por que usar .gitignore fazer uma coisa ( manter Arquivos), que é o oposto do que ele significou para ( excluindo arquivos), embora seja possível?

.gitkeep aproximar

Use um vazio arquivo chamado .gitkeep a fim de forçar a presença da pasta no sistema de controle de versão.

Embora possa parecer não uma diferença tão grande:

Você usa um arquivo que tem o única finalidade de manter a pasta. Você não colocar lá qualquer informação que você não quer colocar.

Por exemplo, você deve usar READMEs como, bem, READMEs com informações úteis, não como uma desculpa para manter a pasta.

A separação de interesses é sempre uma coisa boa, e você ainda pode adicionar um .gitignore para ignorar arquivos indesejados.
nomeando-.gitkeep deixa muito claro e direto a partir do próprio nome de arquivo (e também para outros desenvolvedores , que é bom para um projeto compartilhado e um dos propósitos principais de um repositório Git ) que este arquivo é
- Um arquivo relacionado com o código (por causa do ponto inicial e do nome)
- Um arquivo claramente relacionada com Git
- O seu propósito ( manter ) é claramente indicado e consistente e semanticamente oposição em seu significado para ignorar

Adoção

Eu vi a abordagem .gitkeep adotado por estruturas muito importantes, como Laravel , angular-CLI .

Como descrito em outras respostas, Git é incapaz de representar diretórios vazios em sua área de estágio. (Veja a Git FAQ .) No entanto, se, para o seu propósitos, um diretório é suficiente vazia se ele contém um arquivo .gitignore somente, então você pode criar arquivos .gitignore em diretórios vazios única via:

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

Andy Lester é certo, mas se o seu diretório só precisa estar vazia, e não vazio esvaziar, você pode colocar um arquivo .gitignore vazio lá como uma solução alternativa.

Como um aparte, este é um problema de implementação, não uma Git problema fundamental design de armazenamento. Como já foi mencionado muitas vezes na lista de discussão Git, a razão que este não foi implementado é que ninguém se importava o suficiente para enviar um patch para ele, não que não podia ou não deve ser feito.

O Ruby on Rails forma de criação de pasta de log:

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

Agora, o diretório de log será incluído na árvore. É super-útil ao implantar, assim você não terá que escrever uma rotina para fazer pastas de registro.

Os arquivos de log podem ser mantidos fora por emissão,

echo log/dev.log >> .gitignore

mas você provavelmente sabia disso.

Git não acompanha diretórios vazios. Veja a Git FAQ para mais explicações. A solução sugerida é a de colocar um arquivo .gitignore no diretório vazio. Eu não gosto dessa solução, porque o .gitignore está "escondido" por convenção Unix. Também não há nenhuma explicação por que os diretórios estão vazios.

Eu sugiro colocar um arquivo README no diretório vazio explicando porque o diretório está vazio e por isso precisa ser monitorado em Git. Com o arquivo README no lugar, tanto quanto Git está em causa, o diretório não está vazio.

A verdadeira questão é por que você precisa do diretório vazio no git? Normalmente você tem algum tipo de script de construção que pode criar o diretório vazio antes de compilar / executar. Se não, então fazer um. Essa é uma solução muito melhor do que colocar diretórios vazios no git.

Então você tem alguma razão porque você precisa de um diretório vazio no git. Coloque isso no arquivo README. Dessa forma, outros desenvolvedores (e futuro você) sabe por que as necessidades diretório vazio para estar lá. Você também vai saber que você pode remover o diretório vazio quando o problema que requer o diretório vazio foi resolvido.

Para listar cada utilização diretório vazio o seguinte comando:

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

Para criar READMEs espaço reservado em cada diretório vazio:

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

Para ignorar tudo no diretório, exceto o arquivo README colocar as seguintes linhas no seu .gitignore:

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

Como alternativa, você pode simplesmente excluir todas arquivo README de ser ignorado:

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

Para listar todos os README depois que eles já são criados:

find -name README.emptydir

AVISO:.. Este ajuste não está realmente trabalhando como se vê Desculpe o transtorno

Original post abaixo:

Eu encontrei uma solução enquanto brincava com internos Git!

Suponha que você esteja em seu repositório.
Crie a sua pasta vazia:
```
$ mkdir path/to/empty-folder
```
Adicione-lo ao índice usando um comando de encanamento e a árvore vazia SHA-1 :
```
$ git update-index --index-info
040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder
```
Digite o comando e, em seguida, entrar na segunda linha. Pressione Enter e Ctrl + D para encerrar a sua entrada. Nota: o formato é Modo [SPACE] tipo [SPACE] SHA-1hash [TAB] caminho (a guia é importante, a resposta formatação não preservá-lo).
É isso aí! Sua pasta vazia está na sua índice. Tudo que você tem a fazer é cometer.

Esta solução é curto e aparentemente funciona bem ( ver a EDIT! ), mas não é tão fácil de lembrar ...

A árvore vazia SHA-1 pode ser encontrada através da criação de um novo repositório vazio Git, cd nele e emissão git write-tree, que gera a árvore vazia SHA-1.

EDIT:

Eu tenho usado essa solução desde que eu encontrei. Parece funcionar exatamente da mesma maneira como a criação de um sub-módulo, exceto que nenhum módulo é definida em qualquer lugar. Isto leva a erros na emissão git submodule init|update. O problema é que git update-index reescreve a parte 040000 tree em 160000 commit.

Além disso, qualquer arquivo colocado sob esse caminho nunca vai ser notado por Git, pois acha que eles pertencem a algum outro repositório. Isso é desagradável, pois ele pode ser facilmente esquecido!

No entanto, se você já não (e não) usar quaisquer submódulos Git em seu repositório ea pasta "vazio" permanecerá vazia ou se você quiser Git saber de sua existência e ignorar o seu conteúdo, você pode ir com esse ajuste. Indo da maneira usual com submódulos leva mais passos que este ajuste.

Talvez a adição de um diretório vazio parece que ele seria o caminho de menor resistência , porque você tem scripts que esperar esse diretório de existir (talvez porque é um alvo para os binários gerados). Outra abordagem seria a de modificar seus scripts para criar o diretório conforme necessário .

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

Neste exemplo, você pode verificar em um (quebrado) link simbólico para o diretório para que você possa acessá-lo sem o prefixo ".generated" (mas isso é opcional).

ln -sf .generated/bin bin
git add bin

Quando você quiser limpar sua árvore fonte você pode apenas:

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

Se você tomar a abordagem frequentemente sugerido de verificação em uma pasta quase vazia, você tem a complexidade menor de apagar os conteúdos sem apagar também o arquivo ".gitignore".

Você pode ignorar todos os seus arquivos gerados adicionando o seguinte ao seu .gitignore root:

.generated

Vamos dizer que você precisa um diretório vazio chamado tmp :

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

Em outras palavras, você precisa adicionar o arquivo .gitignore com o índice antes que você possa dizer Git ignorá-la (e tudo o mais no diretório vazio).

Eu estive enfrentando o problema com diretórios vazios também. O problema com o uso de arquivos de espaço reservado é que você precisa para criá-los e excluí-los, se eles não são necessários mais (porque mais tarde não foram adicionados sub-diretórios ou arquivos. Com árvores de origem grandes gerenciamento desses arquivos de espaço reservado pode ser complicado e erro propensas.

É por isso que eu decidi escrever uma ferramenta de código aberto que pode gerenciar a criação / exclusão de tais arquivos de espaço reservado automaticamente. Ele é escrito para plataforma .NET e corre sob Mono (.NET para Linux) e Windows.

Basta dar uma olhada em: http://code.google.com/p/markemptydirs

Você não pode e, infelizmente, nunca será capaz de fazer. Esta é uma decisão feita pelo próprio Linus Torvalds. Ele sabe o que é bom para nós.

Há um discurso lá fora em algum lugar eu li uma vez.

Eu encontrei Re: diretórios vazios .. , mas talvez haja outro.

Você tem que viver com as soluções alternativas ... infelizmente.

Eu gosto das respostas por @ Artur79 e @mjs então eu tenho usado uma combinação de ambos e fez um padrão para nossos projetos.

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

No entanto, apenas um punhado de nossos desenvolvedores trabalham no Mac ou Linux. Um trabalho muito no Windows e eu não poderia encontrar um simples equivalente de uma linha para realizar o mesmo lá. Alguns eram bastante sorte de ter Cygwin instalado por outras razões, mas prescrever Cygwin apenas para esta parecia um exagero.

Editar para uma solução melhor

Assim, uma vez que a maioria dos nossos desenvolvedores já possuem Ant instalado, a primeira coisa que pensei foi a montar um arquivo de construção Ant para alcançar este objetivo de forma independente da plataforma. Isso ainda pode ser encontrada aqui

No entanto , I depois pensei que seria melhor fazer isso em um pequeno comando do utilitário, então eu recriado-lo usando Python e publicou-o ao PyPI aqui . Você pode instalá-lo, basta executar:

pip3 install gitkeep2

Ele permitirá que você para criar e remover .gitkeep arquivos de forma recursiva, e que também irá permitir que você adicione mensagens a eles por seus pares para entender por que os diretórios são importantes. Esta última parte é bônus. Eu pensei que seria bom se os arquivos .gitkeep poderia ser auto-documentado.

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

Eu espero que você encontrá-lo útil.

Quando você adiciona um arquivo .gitignore, se você está indo para colocar qualquer quantidade de conteúdo nele (que deseja Git ignorar) que você pode querer adicionar uma única linha com apenas um * asterisco para se certificar de que você não adicionar o conteúdo ignorado acidentalmente.

Como mencionado, não é possível adicionar diretórios vazios, mas aqui está um um forro que adiciona arquivos .gitignore vazias para todos os diretórios.

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

Eu ter ficado isso em um Rakefile para fácil acesso.

A solução de Jamie Flournoy funciona muito bem. Aqui está uma versão pouco reforçada para manter o .htaccess:

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

Com esta solução você é capaz de cometer uma pasta vazia, por exemplo /log, /tmp ou /cache ea pasta vai ficar vazia.

Eu sempre construir uma função para verificar se a minha estrutura pasta desejada e construí-lo para mim dentro do projeto. Este fica em torno este problema como as pastas vazias são realizadas em Git por procuração.

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

Esta é em PHP, mas estou certo que a maioria dos idiomas suportam a mesma funcionalidade, e porque a criação das pastas é cuidado pela aplicação, as pastas estarão sempre lá.

Aqui é um hack, mas é engraçado que ele funciona (Git 2.2.1). À semelhança do que @Teka sugerido, mas mais fácil de lembrar:

Adicionar um sub-módulo de qualquer repositório (git submodule add path_to_repo)
Isto irá adicionar uma pasta e uma .submodules arquivo. Cometer uma mudança.
arquivo .submodules Eliminar e confirmar a alteração.

Agora, você tem um diretório que é criado quando commit é verificado. Uma coisa interessante é que embora se você olhar para o conteúdo do objeto da árvore deste arquivo você vai ter:

fatal: Não é um nome de objeto válido b64338b90b4209263b50244d18278c0999867193

Eu não iria encorajar a usá-lo embora, uma vez que pode parar de funcionar nas futuras versões do Git. Que pode deixar seu repositório corrompido.

Não há nenhuma maneira de obter Git para rastrear diretórios, então a única solução é adicionar um arquivo de espaço reservado dentro do diretório que você deseja Git para rastrear.

O arquivo pode ser nomeado e contêm tudo o que quiser, mas a maioria das pessoas usam um arquivo vazio chamado .gitkeep (embora algumas pessoas preferem o .keep VCS-agnóstico).

As marcas . prefixadas-lo como um arquivo oculto.

Outra idéia seria a de adicionar um arquivo README explicando o que o diretório será utilizado.

Você não pode. Esta é uma decisão de design intencional pelos mantenedores Git. Basicamente, o objetivo de um sistema de gerenciamento de código fonte como Git está a gerir código fonte e diretórios vazios não são código-fonte. Git também é frequentemente descrito como um rastreador de conteúdo, e novamente, diretórios vazios não são de conteúdo (muito pelo contrário, na verdade), então eles não são rastreadas.

Se você quiser adicionar uma pasta que vai abrigar uma grande quantidade de dados temporários em vários diretórios semânticas, em seguida, uma abordagem é adicionar algo como isto a sua raiz .gitignore ...

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

Em seguida, você pode cometer arquivos README.md descritiva (ou arquivos em branco, não importa, contanto que você pode orientá-las exclusivamente como com o *.md neste caso) em cada diretório para garantir que os diretórios todos permanecem parte do repo, mas os arquivos (com extensões) são mantidos ignorado. LIMITAÇÃO: de . não são permitidos nos nomes de diretório

Você pode preencher todos estes diretórios com XML arquivos / imagens ou o que quer e adicionar mais diretórios sob /app/data/ ao longo do tempo como as necessidades de armazenamento para a sua aplicação desenvolver (com os arquivos README.md servir para queimar em uma descrição do que cada diretório de armazenamento é exatamente).

Não há necessidade de alterar ainda mais o seu .gitignore ou descentralizar criando um novo .gitignore para cada novo diretório. Provavelmente não é a solução mais inteligente, mas é conciso gitignore-wise e sempre funciona para mim. Agradável e simples! ;)

Como adicionar mais uma opção para a briga.

Assumindo que você gostaria de adicionar um diretório para git que, para todos os efeitos relacionados com a git, deve permanecer vazio e nunca tem o seu conteúdo rastreado, um .gitignore como sugerido várias vezes aqui, vai fazer o truque.

O formato, como mencionado, é:

*
!.gitignore

Agora, se você quiser uma maneira de fazer isso na linha de comando, em uma só penada, enquanto dentro o diretório que você deseja adicionar, você pode executar:

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

Eu mesmo, eu tenho um shell script que eu uso para fazer isso. Nome do script que você quer projectados, e quer adicioná-lo em algum lugar no seu caminho de inclusão, ou referenciá-lo diretamente:

#!/bin/bash

dir=''

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

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

Com isso, você pode executá-lo de dentro do diretório que você deseja adicionar ou referenciar o diretório que é o primeiro e único parâmetro:

$ ignore_dir ./some/directory

Outra opção (em resposta a um comentário por @GreenAsJade), se você deseja acompanhar uma pasta vazia que pode conter arquivos rastreados no futuro, mas estará vazio por enquanto, você pode omitir o * do arquivo .gitignore e verificação que em. Basicamente, todo o arquivo está dizendo é "não ignore me ", mas caso contrário, o diretório está vazio e monitorados .

Seu arquivo .gitignore seria parecido com:

!.gitignore

É isso, verifique se, e você tem um vazio, ainda rastreado, diretório que você pode rastrear arquivos em algum momento posterior.

A razão que eu sugiro manter que uma linha no arquivo é que dá o propósito .gitignore. Caso contrário, alguém para baixo da linha pode pensar para removê-lo. Pode ajudar se você colocar um comentário sobre a linha.

Às vezes você tem que lidar com maus escrita bibliotecas ou software, que precisam de um diretório vazio e existente "real". Colocar um .gitignore simples ou .keep pode quebrá-los e causar um erro. A seguir ajuda força nestes casos, mas nenhuma garantia ...

Primeiro, crie o diretório necessário:

mkdir empty

Em seguida, você adicionar um link simbólico quebrado a este diretório (mas em qualquer outro caso que o caso de uso descrito acima, use um README com uma explicação):

ln -s .this.directory empty/.keep

Para ignorar arquivos nesse diretório, você pode adicioná-lo em sua .gitignore root:

echo "/empty" >> .gitignore

Para adicionar o arquivo ignorado, use um parâmetro para forçá-lo:

git add -f empty/.keep

Após a confirmação você tem um link simbólico quebrado em seu índice e git cria o diretório. O link quebrado tem algumas vantagens, uma vez que nenhum arquivo regular e pontos para nenhum arquivo regular. Portanto, mesmo se encaixa à parte da questão "(que não contém arquivos)", e não pela intenção, mas pelo significado, eu acho:

find empty -type f

Este comando mostra um resultado vazio, uma vez que nenhum arquivos estão presentes neste diretório. Assim, a maioria das aplicações, que recebem todos os arquivos em um diretório geralmente não ver este link, pelo menos se eles fazem um "arquivo existe" ou um "legível". Mesmo alguns scripts não vai encontrar todos os arquivos lá:

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

Mas eu recomendo fortemente usar essa solução apenas em circunstâncias especiais, um bom README escrito em um diretório vazio é geralmente uma solução melhor. (E eu não sei se isso funciona com um Windows sistema de arquivos ...)

Você pode salvar esse código como create_readme.php e executar o href="http://en.wikipedia.org/wiki/PHP" rel="nofollow"> PHP código do diretório raiz do seu projeto Git.

> php create_readme.php

Ele irá adicionar arquivos LEIA-ME para todos os diretórios que estão vazias para que esses diretórios seria então adicionado ao í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
            }
        }
?>

Em seguida, faça

git commit -m "message"
git push

Às vezes tenho repositórios com pastas que será sempre apenas contêm arquivos considerados "conteúdo", isto é, eles não são arquivos que eu me preocupo com sendo de versão, e, portanto, nunca deve ser comprometida. Com arquivo .gitignore do Git, você pode ignorar diretórios inteiros. Mas há momentos em que tem a pasta no repo seria benéfica. Aqui está uma solução excelente para realizar esta necessidade.

O que eu fiz no passado é colocar um arquivo .gitignore na raiz do meu repo, e depois excluir a pasta, assim:

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

No entanto, essas pastas, então não se tornar parte do repo. Você poderia adicionar algo como um arquivo README lá. Mas então você tem que dizer a sua aplicação não se preocupar com o processamento de todos os arquivos LEIA-ME.

Se seu aplicativo depende das pastas estar lá (embora vazio), você pode simplesmente adicionar um arquivo .gitignore para a pasta em questão, e usá-lo para atingir dois objetivos:

Diga Git há um arquivo na pasta, o que torna Git adicioná-lo à repo. Diga Git para ignorar o conteúdo dessa pasta, menos este arquivo em si. Aqui está o arquivo .gitignore para colocar dentro de seus diretórios vazios:

*
!.gitignore

A primeira linha (*) diz Git para ignorar tudo neste diretório. A segunda linha diz Git não ignorar o arquivo .gitignore. Você pode encher esse arquivo para cada pasta vazia que você deseja adicionar ao repositório.

Uma maneira fácil de fazer isso é através da adição de um arquivo .gitkeep para o diretório que você deseja (atualmente) manter vazio.

Veja este SOF resposta para mais informações - o que também explica por que algumas pessoas acham que a convenção competindo de adicionar um .gitignore arquivo (como indicado em muitas respostas aqui) confundindo.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow