Git funciona de uma maneira interessante para transportar um histórico de alterações de arquivo. Embora possa parecer que procura as mudanças em cada um deles, o que ele realmente faz é carregar um arquivo chamado índice, no qual são inseridas as alterações que estão ocorrendo. Desta forma, apenas lendo o arquivo índice você pode saber quais arquivos e o conteúdo deles foi alterado.
Uma vez que entendemos o conceito de como Git Leva as alterações registadas, é quando podemos começar a tirar o máximo partido da ferramenta, pois é neste momento que poderemos começar a usar os diferentes comandos para tirar as alterações do nosso repositório e tratá-las de uma forma lógica perspectiva.
Classificando arquivos dentro do Git
Antes de continuar com os pontos mais profundos, devemos ver como Git classifica seus arquivos. Isso não significa uma classificação por tipo de arquivo devido à sua extensão, mas sim pelo seu status em relação ao nosso repositório e sua índice.
Basicamente, temos três tipos de arquivos em GIT, cada um tem seu próprio momento dentro do repositório, vamos ver quais são:
MonitoradosEste tipo de arquivo já está adicionado ao nosso repositório e é levado em consideração pelo índice e um arquivo assume este estado, uma vez que o tenhamos adicionado com o seguinte comando.
git add filenameIgnoradoNesta classificação, um arquivo ignorado não é levado em consideração por Git Ao fazer alterações, os arquivos que sofrem muitas alterações ou que não são vitais para a estabilidade do projeto são normalmente classificados desta forma, por exemplo, arquivos de imagem devido ao seu peso ou talvez scripts de Base de dados que não temos que estar sempre modificando. Para ignorar um arquivo, seu nome deve ser incluído em um arquivo chamado .gitignore e adicione-o ao nosso repositório.
Não rastreadoEste tipo de arquivo ainda não pertence ao nosso repositório porque ainda não o adicionamos e é novo no sistema de arquivos, geralmente acontece quando criamos um novo arquivo em um repositório já inicializado ou quando inicializamos um repositório em uma pasta que tem arquivos existentes.
Exemplo prático de classificação de arquivo
Vamos agora ver um pequeno exemplo prático de como podemos detectar tipos de arquivo em um repositório Git, para isso devemos seguir os seguintes passos:
1- Vamos criar uma nova pasta em nosso computador chamada arquivos git.
2- Uma vez que a pasta é criada vamos entrar nela a partir de nosso console e lá vamos executar o comando git init e então nós fazemos git status Para ver o status do nosso repositório, vamos ver como é a aplicação dos comandos anteriores:
3- Quando tivermos concluído a etapa anterior, teremos um repositório Git inicializado e pronto para trabalhar, então podemos criar um novo arquivo nessa pasta e faremos de novo git status para ver a mudança, devemos ter nosso novo arquivo sob a classificação não rastreado.
4- Vamos repetir a etapa anterior e criar um novo arquivo, se virmos o resultado de fazê-lo novamente git status vamos contar os dois arquivos, vamos ver:
5- Agora vamos criar um novo arquivo chamado .gitignore, observe o ponto antes do arquivo e dentro vamos colocar o nome de um de nossos arquivos anteriores, fazemos novamente git status e veremos que agora só obtemos o arquivo que não está nele .gitignore e o arquivo .gitignore acabamos de criar:
6- Então vamos fazer um git add. para adicionar todos os nossos arquivos e, finalmente, executaremos um git commit -m "commit inicial" com isso adicionando nossos arquivos ao repositório, se fizermos uma alteração no arquivo que não colocamos dentro do .gitignore e nós o salvamos, se corrermos novamente git status veremos um arquivo de status ou classificação monitorados.
O comando git add
No exemplo anterior, podemos ver o uso do git add e talvez possamos pensar que é mais um comando da nossa ferramenta mas isso é muito importante, é o que nos permite adicione um arquivo ao nosso repositório se ainda não existe nele e também nos permite adicionar as alterações que aconteceram a um arquivo existente em nosso repositório.
Como usar?Tem algumas maneiras de ser usado, a mais comum é fazer git add filename, onde dizemos a ele qual arquivo adicionar ou se não podemos fazer git add. onde o ponto representa todos os arquivos que foram modificados ou não estão no repositório.
É muito importante que, depois de fazer qualquer alteração no repositório, adicionemos os arquivos com git add, caso contrário não poderemos salvar nossas alterações, além de criar diferentes versões do arquivo, o que pode levar a um possível conflito no futuro.
Usando o git add
Dentro de nossa pasta arquivos git que criamos no exemplo anterior do tutorial, vamos adicionar um novo arquivo que colocaremos newFile3 e então no arquivo existente que não está nele .gitignore vamos fazer uma mudança.
O que queremos alcançar com isso é testar como usar nosso comando git add, vamos ver como fica em nosso console de comando:
Tendo seguido as instruções anteriores, devemos ter algo como o acima na tela, onde é mostrado um arquivo modificado e um novo arquivo no repositório.
Agora vamos adicionar o novo arquivo ao repositório, mas não o faremos com o arquivo existente ou aquele que modificamos anteriormente. Para isso, só temos que fazer git add ourfilename. Então faremos git status. Vamos ver:
Como podemos ver, nosso repositório já leva em consideração o arquivo que adicionamos com git add, esta é a maneira pela qual podemos basicamente trabalhar nas alterações em nossos arquivos.
Exclua arquivos do repositório
A próxima ação que devemos saber realizar é eliminar os arquivos do nosso repositório, pois é muito comum que tenhamos criado algo por engano ou estejamos simplesmente colocando as coisas em ordem dentro dele.
Há duas coisas a levar em consideração, podemos remover o arquivo do índice de nosso repositório, mas manter esse arquivo no sistema de nossa pasta, então se fizermos um git status Nós o veremos disponível novamente. Ou se não podemos excluir o arquivo de nossa pasta e de índice do nosso repositório, para isso podemos usar o comando git rm.
O comando git rm - -cached
Usando o comando rm com a opção adicional de em cache, o que fazemos é excluir o arquivo em questão do índiceNo entanto, vamos mantê-lo em nosso computador, este comando é muito usado quando não queremos adicionar este arquivo ao nosso repositório ainda, mas precisamos salvar as outras alterações.
Para usá-lo, basta fazer o comando quando já tivermos adicionado com git add algum arquivo, vamos ver como fica em nosso console de comando:
Notamos que o arquivo newFile3 que adicionamos ao nosso repositório agora não está lá e tem a classificação não rastreado.
O comando Git rm
Agora vamos ver como usar o comando git rm, este comando é muito mais poderoso, pois remove diretamente o arquivo do índice e do Arquivo, é por isso que devemos ter cuidado ao decidir usá-lo em nosso repositório, é muito provável que uma vez aplicado, não seremos capazes de recuperar a alteração.
Vamos ver no exemplo a seguir como funciona quando o aplicamos a um arquivo, neste caso vamos adicionar newFile3 com git add e então vamos aplicar neste git rm:
Vemos que quando fazemos isso diretamente idiota nos mostra um erro e nos pede para fazer uma exclusão forçada ao adicionar o parâmetro -F à instrução isso se deve à importância da mudança, finalmente faremos um git status e notaremos que o referido arquivo desapareceu de nosso repositório por completo.
Mais de .gitignore
Podemos ver que podemos adicionar um arquivo específico ao nosso arquivo .gitignoreNo entanto, quando trabalhamos em um ambiente no qual lidamos com centenas ou talvez milhares de arquivos, não é muito prático, por isso podemos usar padrões.
Um padrão nos permitirá indicar Git que um arquivo que atenda a seqüência de caracteres ou expressão deve ser ignorado, com isso podemos indicar extensões específicas, tanto em todo o projeto quanto dentro de uma pasta especial. Vejamos um exemplo disso.
* .jpg.webp ele irá ignorar todos os arquivos .jpg.webp de nosso projeto, mas se quisermos manter o rastro de um em particular, basta adicionar:
! filename.jpg.webpÉ simples assim, temos uma estrutura forte e complexa que nos permite manter nosso repositório organizado.
Com isso terminamos este tutorial, vimos de forma extensiva a forma como Git carrega ou gerencia as alterações em nossos arquivos, é importante dominar este assunto, pois com isso poderemos trabalhar de forma mais eficiente em ambientes de equipe onde isso é tratado Git como um controlador de versão.
