Um requisito básico de qualquer sistema de controle de versão é armazenar diferentes versões de arquivos para você. No Git, o comando que faz isso é commit. Aqui está tudo o que você precisa saber.
O que é um commit no Git?
Commits são as séries de instantâneos feitos ao longo do ciclo de vida de um projeto que compõem seu histórico de desenvolvimento. Commits são o que nos permite extrair uma versão do projeto como era em diferentes pontos no passado. Por que isso é importante?
Os sistemas de controle de versão (VCSs) são mais comumente usados com código-fonte de software e projetos de desenvolvimento. Mas eles podem ser usados com sucesso com qualquer coleção de arquivos de texto, como arquivos Markdown contendo capítulos de um livro.
Você pode não querer que todos os arquivos em seus diretórios de projeto sejam manipulados pelo VCS, então você precisa ser capaz de nomear os arquivos que deseja que sejam controlados por versão. Isso os adiciona à exibição de controle de versão do projeto. Eles serão monitorados quanto a mudanças.
Outra maneira de conseguir isso é usar uma lista de ignorados. Isso informa ao Git quais arquivos, diretórios ou tipos de arquivos ele deve sempre ignorar.
Com o tempo, à medida que novos arquivos são adicionados ao projeto, alguns precisarão ser adicionados ao sistema de controle de versão. No Git, isso é tratado pelo add comando. Na verdade, o add comando faz serviço duplo, como veremos.
Para manter um histórico das mudanças que foram feitas no projeto, você pedirá periodicamente ao Git para armazenar um instantâneo do estado do projeto, usando o comando commit comando. É aqui que o add comando reaparece em nosso fluxo de trabalho. Nós usamos o add comando para dizer ao Git qual mudado arquivos que queremos incluir no instantâneo. Então nós usamos commit para dizer ao Git para criar o instantâneo.
Configurando o comando commit
As informações sobre o commit são armazenadas com ele, para que seja sempre possível saber quem fez o commit, quando e o que o commit contém. Alguns desses metadados são capturados no momento do commit, como a mensagem de commit.
Os metadados relativos à identidade dos membros da equipe de desenvolvimento podem ser configurados por cada usuário, para evitar o fornecimento repetido da mesma informação.
Para definir seu nome globalmente para todos os repositórios em seu computador, use este comando.
git config --global user.name "Dave McKay"
Para verificar se seu nome foi definido, use este comando.
git config --global user.name
Se você precisar usar um nome diferente em um determinado repositório, vá para o diretório do projeto e use o mesmo comando sem o --global opção.
git config user.name "McKay, David"
git config user.name
Agora temos um nome de usuário padrão diferente para este repositório e nosso nome global ainda é usado para outros repositórios.
De maneira semelhante, podemos definir um endereço de e-mail globalmente ou para um único repositório, incluindo ou omitindo o --global opção.
git config user.email "dave@phony-domain.com"
git config --global user.email "dave@fake-domain.com"
git config user.email
git config --global user.email
Essas configurações são mantidas em arquivos de configuração. As configurações globais do Git são mantidas em “~/.gitconfig” e as configurações específicas do repositório são mantidas no arquivo “.git/config” do repositório.
O commit O comando faz referência e usa esses valores à medida que opera.
Usando o comando commit
O uso básico do commit O comando é pegar os arquivos que estão na área de teste, conhecida como índice, e armazená-los como um commit na ramificação atual do repositório.
Um compromisso básico
Temos um projeto com um arquivo alterado. vamos usar o add comando para preparar o arquivo e confirmá-lo. Estamos usando o -m (commit message) para que possamos fornecer uma breve descrição do propósito das alterações. Se não usarmos essa opção, será solicitada uma mensagem de confirmação à medida que a confirmação ocorre. É mais conveniente adicionar um na linha de comando.
git add jibber.c
git commit -m "Updated help text"
Se usarmos o git log podemos revisar os detalhes dos commits, em ordem cronológica, com o commit mais recente no topo da lista.
git log
Os commits são exibidos em less.
O commit foi marcado com o nome e o endereço de e-mail que fornecemos anteriormente, e nossa mensagem de commit também está registrada.
Arquivos de preparo automático
A preparação de muitos arquivos pode demorar um pouco. Uma abordagem diferente é usar o -A (todas) opção com add.
Isso prepara automaticamente todos modificado arquivos junto com todos atualmente não rastreado arquivos. A preparação de arquivos não rastreados respeita as configurações em seu arquivo “.gitignore”. O Git não testará os arquivos que você disse que não deseja incluir. Finalmente, os arquivos no índice que não estão mais no diretório de trabalho são removido do índice.
Claramente, o -A opção pode fazer com que muita coisa aconteça de uma só vez. O --dry-run A opção fornece uma visualização das alterações sem realmente executá-las.
git add -A --dry-run
Em nosso exemplo, ele preparará dois arquivos existentes modificados e dois novos arquivos. Vamos em frente e usar o -A opção antes de usarmos o commit comando.
git add -A
git commit -m "Enhanced parsing"
Podemos ver que ao todo quatro arquivos foram alterados. Dois deles são os arquivos recém-criados, que estão listados.
Encenação e Compromisso ao Mesmo Tempo
O commit comando tem uma letra minúscula -a (todas) opção. Isso executa a preparação e a confirmação de arquivos em uma etapa.
O commit -a estágios de opção e commits modificados existir arquivos, e remove arquivos do índice se eles tiverem sido removidos de seu diretório de trabalho. Isto não preparar automaticamente arquivos não rastreados.
Como o add comando, o comando commit tem um --dry-run opção que permite visualizar suas ações antes de executá-lo.
git commit -a --dry-run
Agora vamos executar o comando.
git commit -a --dry-run
Os arquivos são preparados e confirmados para nós.
Comprometendo-se com um ramo diferente
Se você fez algumas alterações nos arquivos em seu diretório de trabalho, percebe que não fez o checkout da ramificação correta, você precisa que suas alterações sejam confirmadas na ramificação correta sem afetar a ramificação atual.
O Git não tem um comando para confirmar em um branch diferente. Mas você pode corrigir essa situação com um pouco de destreza do Git.
Usaremos o Git stash comando para fazer uma cópia das alterações. Em seguida, verificaremos o branch correto e aplicaremos as alterações do stash. Para aplicar as alterações ocultas, estamos usando o pop comando em vez do apply comando. O pop O comando aplica as alterações e também as remove do stash.
Fizemos algumas alterações em nosso repositório new-parser filial. Deveriam ter sido feitos no classic-parser filial.
git stash
git checkout classic-parser
git stash pop
Agora podemos realizar um commite atualize esta ramificação.
git commit -a -m "Added pre-parser functions"
Se voltarmos ao new-parser branch, podemos ver que está atualizado, o que significa que as alterações foram removidas do seu diretório de trabalho e seu repositório e arquivos estão sincronizados.
git checkout new-parser
git status
RELACIONADO: Como atualizar e manter ramificações separadas do Git
Fazendo alterações nos commits
Se você precisa melhorar sua mensagem de commit—talvez tenha detectado um erro de digitação nela—ou você esqueceu de preparar um arquivo que deveria ter sido incluído no commit, você pode usar o comando --amend opção de consertar as coisas. A ressalva é que isso não deve ser usado em commits que foram enviados para um repositório remoto.
Em nossa última mensagem de commit, “fraze” deveria ser “phrase”. Se usarmos git log podemos ver isso.
Para corrigir isso, usaremos o --amend opção como esta.
git commit --amend -m "Optimized phrase identification"
Se usarmos git log mais uma vez, podemos ver que o commit antigo foi substituído por um novo com a mensagem de commit corrigida.
Se quisermos adicionar um arquivo que esquecemos de testar, podemos fazer o commit desse arquivo para que apareça como parte do commit anterior.
nós vamos usar add para preparar o arquivo, então faça um commit com o --amend opção. O --no-edit opção significa que não precisamos fornecer uma nova mensagem de confirmação. A mensagem de confirmação anterior é mantida.
git add jibber.c
git commit --amend --no-edit
Removendo alterações de um commit
Se você inadvertidamente preparou e fez o commit de um arquivo que não pretendia, você pode remover esse arquivo do commit usando o comando reset comando. Vamos redefinir o commit de volta para a área de teste, ou index. Em seguida, removeremos o arquivo e confirmaremos novamente o restante dos arquivos.
Para redefinir o último commit para a área de preparação, usamos o reset --soft comando. HEAD~ é uma abreviação de “o commit atrás do HEAD da linha do tempo do commit do projeto”, ou em inglês, “the last commit”.
git reset --soft HEAD~
Para remover o arquivo que não deveria ter sido incluído, usamos o reset --mixed comando. Isso redefine essas alterações de volta para o diretório de trabalho, recriando o arquivo modificado como um arquivo não confirmado e não testado.
git reset --mixed jibber.c
Precisamos confirmar os outros arquivos que restam no índice.
git commit -m "Experimental tweaks"
Os outros dois arquivos que estavam no commit original foram confirmados novamente para nós.
RELACIONADO: Como corrigir, editar ou desfazer confirmações do Git (alterando o histórico do Git)
Revertendo um commit inteiro
Às vezes, desfazer um commit inteiro é a coisa mais fácil de fazer. Ele coloca seu diretório de trabalho e repositório de volta ao estado em que estavam antes do commit.
Precisamos usar o ID de referência com hash do commit. Podemos encontrar isso usando git log:
Copie essa referência e use-a no revert comando:
git revert e5bd4560aef8164c6ca9d6d4620b9db7f66aecc8
Isso abrirá seu editor padrão para que você possa editar uma mensagem de reversão. Há uma mensagem padrão inserida para você. Você pode usar isso ou editá-lo ao seu gosto.
Quando estiver satisfeito com sua mensagem de reversão, salve o arquivo e saia do editor. No nano, você faz isso com “Ctrl+O” e “Ctrl+X”.
Usando git log mais uma vez, podemos ver que um novo commit foi adicionado que desfaz as alterações do commit revertido.
O canivete suíço Git
Obviamente, commit é um dos comandos Git mais importantes. Ele pode fazer muito, então há muito o que aprender. Conhecer seus recursos menos usados é um tempo bem gasto. Quando você precisar corrigir um erro – agora mesmo – ficará feliz por ter se preparado com antecedência.
RELACIONADO: Como usar o Git merge
0 Comments