O .gitignore é um arquivo simples do próprio Git que pode ser criado na raiz do projeto ou dentro de algum diretório dentro do repositório no lugar que deseja.

A partir dele, é possível inserir regras para que determinados arquivos não sejam rastreados pelo git no momento do commit.

Se você deseja saber como esse arquivo é criado e saber com mais detalhes para que ele serve e como ele funciona, fique com a gente e aproveite ao máximo todas as explicações. 

• O que é o .gitignore?
• Como o .gitignore funciona no Git?
• Normalmente quais arquivos devem ser ignorados?
• Quais são os padrões do .gitignore?
• Padrões pessoais no .gitignore!
• Padrões globais no .gitignore!
• Como usar o .gitignore e ignorar arquivos? 7 Exemplos!

Tenha uma ótima leitura.

O que é o .gitignore?

O gitignore é um arquivo de texto oculto que geralmente fica na raiz do repositório, utilizado para descrever ao Git tanto as pastas quanto os arquivos que a pessoa desenvolvedora deseja que sejam ignorados.

Ele pode conter desde um arquivo sensível, ou seja, que contenha AppKey, appToken ou qualquer outro tipo de senha, quanto arquivos comuns que não devem ser commitados.

Portanto, os arquivos que se encontram descritos dentro do gitgnore não serão rastreados e nem versionados, fazendo então com que não tenha chances de serem exibidos, por exemplo, dentro de um repositório remoto.

Um exemplo para entendermos melhor sobre o gitignore pode ser quando estamos em um projeto Node.js e temos a pasta node_modules, onde ficam armazenados todos os pacotes externos que seu projeto precisa para rodar. Como com o comando npm install ou yarn você consegue obtê-los novamente usando o package.json do projeto, não existe a necessidade de subir essa pasta gigante dentro de um repositório remoto. 

Como o .gitignore funciona no Git?

Com o uso de algumas regras para o funcionamento ideal do arquivo, o gitignore é bem simples:

Cada linha dentro desse arquivo possui um arquivo ou pasta a ser ignorada. 

Além de entender como os arquivos são ignorados pelo Git, é de grande importância destacar que o git tem algumas visões diferenciadas em relação a arquivos. Os trềs tipos de arquivos são:

Rastreado

Podem ser considerados arquivos rastreados quando eles já passaram em algum momento por algum commit ou staging. Sendo assim, se você possui um arquivo que acabou de ser criado, por exemplo, ele entra em outra classificação dentro do git.

Não rastreado

Quando falamos de arquivos que não são rastreados, quer dizer que esses arquivos nunca foram commitados ou passaram pelo staging.

Ignorado

Aqui entra o gitignore. Os arquivos ignorados são totalmente diferentes dos rastreados e não rastreados, já que eles necessariamente dependem desse arquivo específico, o .gitignore. 

Normalmente quais arquivos devem ser ignorados?

Quando falamos em quais arquivos devemos ignorar, estamos nos referindo a algo muito variável, uma vez que cada projeto de software apresenta suas particularidades e arquivos específicos. Porém, é bastante comum que os projetos apresentem alguns arquivos que são semelhantes entre eles e que podem ser ignorados sem nenhum problema.

Por sua vez, o processo de utilizar o gitignore para ignorar arquivos é bem simples, porém ele exige uma atenção muito grande. Você deve verificar se isso não fará falta para outras pessoas desenvolvedoras ao clonar o repositório, por exemplo. 

Vamos apresentar agora alguns arquivos que costumam ser ignorados frequentemente dentro de um projeto, sendo eles:

• node_modules 
• arquivos .pyc, .class e .o
• arquivos de log como .lock, .tmp e .log.
• arquivos de configuração pessoal como .idea
• pastas temporárias como temp/ 
• arquivos compilados como dist/ e public/

Quais são os padrões do .gitignore?

O gitignore se trata de um arquivo bastante simples, sem muitos detalhes para a sua utilização, porém algumas regras são necessárias para que ele realmente possa funcionar. 

Inclusive, é muito comum que pessoas desenvolvedoras iniciantes se confundam e acabem gerando um erro no gitgnore por não compreender a utilização dos caracteres especiais. 

Por isso, antes de entrarmos com detalhes em relação aos padrões, vamos entender melhor quais são os caracteres especiais que são utilizadas dentro dos padrões e quais as suas funcionalidades:

• * é considerado um caractere curinga ou seja “todos” os arquivos ou diretórios serão ignorados. Exemplo: *.svn. Nesse caso, estamos solicitando ao git ignorar todo os arquivos que possui a extensão .svn;
• / é utilizado quando desejamos ignorar um arquivo ou diretório que possui um caminho relativo. Com a utilização desse caráter, você tem a liberdade de acessar pastas para que o Git possa ignorá-las. Exemplo: public/* . Nesse caso estamos solicitando que o Git ignore todos os arquivos que encontra dentro da pasta public.

• # é um caráter mais voltado para a organização, ou seja, ele não tem nenhum comportamento de ignorar, apenas adicionar comentários dentro do arquivo .gitignore. Exemplo: Se você deseja ignorar a pasta node_modules, você pode colocar um comentário logo acima para informar isso, dessa forma:

# —---------------------------# 
local Development Tools
# —---------------------------
/node_modules

Agora falando realmente dos padrões que são utilizado pelo gitignore, ele costuma utilizar os padrões globbing para realizar as comparações de nome dos arquivos, sendo que os que mais se destacam são:

• *.log | Tem como objetivo pegar todos os arquivos que apresentam a extensão com o final .log e ignorá-los.
• **/logs | Ao fixar um diretório com dois asteriscos, ele realiza uma combinação de diretórios em qualquer lugar dentro do repositório que está sendo utilizado.
• **/logs/debug.log | O git permite a utilização de asteriscos duplos também para a combinação de arquivos através do diretório-pai.
• !arquivo.log | Ao inserir um ponto de exclamação no início do nome do arquivo, isso faz com que mesmo que haja um padrão previamente definido para ignorar aquele arquivo, ele não seja ignorado.
• /debug.log | Quer dizer que apenas arquivos com o nome debug.log serão ignorados.
• debug.log | A partir do momento em que nada é definido no início do arquivo, permite que todos os arquivos com o nome debug.log sejam ignorados, mesmo se ele não estiver na raiz do projeto.
• debug?.log | a interrogação junto com o nome do arquivo significa que existe um caracter. Dessa forma se você tiver o debugA.log, debug2.log, debugC.log e assim por diante, todos eles serão ignorados.
• debug[0 – 10].log | O git permite que você ignore uma sequência de arquivos específicos, ou seja nesse caso estamos limitando todos os arquivos do 0 ao 10, fazendo então que todos os arquivos, desde o debug1.log, debug2.log até o debug10.log sejam ignorados. Nesse caso, se houver o debug11.log, ele não será ignorado.
• debug[01].log | Um pouco diferente dos outros padrões, o [] que envolve um determinado número corresponde apenas a um único caractere específico.

Padrões pessoais no .gitignore!

O gitignore apresenta algumas funcionalidades que podem facilitar a vida das pessoas desenvolvedoras, como a liberdade de definir padrões pessoais no .gitignore.

Dentro dos repositórios, podem existir alguns tipos de padrões que são únicos para um objetivo específico, ou seja, ele atende apenas a necessidade daquele projeto. 

Para isso, não é necessário realizar o compartilhamento com demais repositórios, esses arquivos somente precisam ficar dentro do  arquivo .git/info/excluide.

Supondo que você deseja ignorar um arquivo que chama meu-arquivo.sh, que é pessoal e possui suas personalizações, você deve adicioná-lo dentro do arquivo .git/info/excluide, assim como você faria dentro do .gitignore, por exemplo.

De início, isso pode parecer confuso, mas imagine que você tem um determinado projeto de software e dentro desse repositório você possui um arquivo único com todas as configurações de sua IDE. De fato, não faz sentido você commitar isso, afinal, é particular seu. Dessa forma, você poderá inseri-lo dentro desse arquivo. 

Padrões globais no .gitignore!

Um pouco diferente dos padrões pessoais, os padrões globais, como o próprio nome já diz, afetam globalmente todo o projeto. Sendo assim, ao utilizá-lo, é de grande importância prestar bastante atenção para que arquivos que são utilizados não sejam ignorados. 

Para utilizar o padrão global, é necessário que a pessoa desenvolvedora realize a criação do arquivo .gitignore declarando a propriedade core.excludesFile. 

Porém, na maioria das vezes, a dúvida em relação ao local que você deve inserir esse arquivo pode acabar surgindo. Caso isso ocorra, opte por escolher um lugar onde você poderá encontrá-lo facilmente, como na raiz do projeto.

Para começar a ignorar padrões, antes de tudo, busque conhecer muito bem toda a estrutura do projeto, já que muitos arquivos que às vezes são desconhecidos pelas pessoas desenvolvedoras podem ser bastante relevantes para o projeto como um todo.

Como usar o .gitignore e ignorar arquivos? 7 Exemplos!

Utilizar o gitignore para ignorar algum diretório ou algum arquivo que se deseja muitas vezes é de grande importância, principalmente quando falamos em bibliotecas externas que podem ser facilmente instaladas para clonar o repositório. 

Com isso, vamos apresentar agora alguns exemplos de como um arquivo ou um diretório pode ser ignorado, para que, ao subir de forma remota, não haja perigo de acabar subindo arquivos desnecessários.

 1. Como criar o .gitignore

O primeiro passo para que possamos utilizar o gitIgnore é realizar a criação do arquivo dentro do repositório. Sua criação é bem simples, sendo necessário seguir apenas dois passos.

1. Abra seu repositório em uma IDE.

2. Logo em seguida, na raiz do projeto, crie um arquivo chamado .gitignore

 2. Devo criar um ou vários arquivos .gitignore?

A resposta depende de sua necessidade. Porém, um único gitignore é suficiente. 

Quando temos um repositório que apresenta uma quantidade mais reduzida de arquivos e diretórios, geralmente utilizamos um único arquivo do .gitignore para ignorar os conteúdos que desejamos.

Já em casos em que a empresa apresenta repositórios maiores, ter diversos gitignore pode acabar facilitando ou trazendo algum benefício de certa forma. Porém, isso deve ser analisado com bastante cautela já que você terá um trabalho maior ao criar diversos .gitignore. É importante notar que, no momento do build, todos os arquivos gitignore estarão unidos gerando apenas um único.

3. Como usar o .gitignore após o commit?

Imaginando o cenário no qual você acabou já realizando commits dentro de seu repositório porém houve a necessidade de ignorar um arquivo, você deve excluir o arquivo de dentro do repositório e realizar a criação do arquivo .gitignore com a regra que deseja ignorar.

Essa exclusão de arquivo é bem simples, você pode acompanhar o passo a passo abaixo:

1. verifique se o arquivo realmente existe. Para isso, rode o seguinte comando:

echo test.log >> .gitignore

2. Logo em seguida vamos remover o arquivo para que possamos ignorar, rode então o comando:

git rm –cached test.log

3. Por último, chegou o momento do commit do arquivo. Então, você pode rodar o seguinte comando:

git add . && git commit -m “Ignorando o arquivo test.log”

4. Como fazer o commit de um arquivo que foi ignorado?

Supondo que você está ignorando um arquivo dentro do .gitignore, porém você deseja realizar o commit dele mesmo assim para uma finalidade específica, você tem essa possibilidade usando a opção -f.

Apesar de que situações como essa serem raras, você pode realizá-la por meio do seguinte comando:

git add -f nomeArquivo.log && git commit -m “Forçando commit”

5. Como fazer o stash de um arquivo que foi ignorado?

O git stash pode trazer grandes contribuições para a rotina de trabalho das pessoas desenvolvedoras, principalmente quando trabalhamos com mais de uma branch .

Vamos analisar um cenário no qual você está desenvolvendo um componente, porém, solicitam um ajuste rápido em um outro lugar do código. Você não deseja realizar o commit do componente que você já fez, dessa forma você pode rodar o seguinte comando:

git stash

Após rodar esse comando, todos os ajustes realizados são “guardados” por um certo período. Se você utiliza o VScode como IDE, é muito provável que o arquivo ficará dessa forma.

Agora, se você desejar voltar a mexer no arquivo que está em stashes, você pode ao passar o mouse em cima do WIP, clicar no ícone de apply stash.

 6. Como fazer a depuração de um arquivo .gitignore?

É normal que em um repositório grande, por exemplo, haja um arquivo a ser ignorado e você não entenda muito bem o porquê, uma vez que existem repositórios que possuem diversos gitignore.

Porém, o Git possui um comando base que pode ser utilizado para determinar qual padrão está sendo utilizado para ignorar um arquivo em específico. Para isso, é necessário você rodar o seguinte comando:

git check-ignore --verbose test.log

Uma grande vantagem que o comando de depuração de arquivos traz é em relação à quantidade de arquivos que você pode buscar. No caso de ter mais de um, o comando ficaria dessa forma: 

git check-ignore --verbose test.log *.js testando.log file.test

 7. Como fazer o .gitignore de um arquivo que já é monitorado?

Ao iniciar um novo repositório e ir criando arquivos, diretórios, instalando bibliotecas externas, entre outros, é normal que o repositório como um todo vá cada vez ficando mais  pesado. Se você tem o Git instalado, todos esses arquivos já serão automaticamente monitorados.

Se você deseja começar a ignorar um arquivo que já está sendo monitorado, você pode seguir o primeiro exemplo que foi abordado e realizar a criação do arquivo gitignore dentro da raiz de seu projeto, inserindo então os arquivos que deseja ignorar. No nosso caso, como podemos ver na imagem abaixo, estamos ignorando a pasta do node_modules.

Com todas as explicações apresentadas, pode-se dizer que o .gitignore trata-se de um arquivo que pode contribuir muito para uma pessoa desenvolvedora no momento de commitar um arquivo.Esperamos que você tenha gostado de saber mais sobre o gitignore e sua importância. Você pode continuar com a gente e ler também sobre os principais comandos do git que uma pessoa programadora deve saber.