Git
Português (Brasil) ▾ Topics ▾ Latest version ▾ git-add last updated in 2.43.0

NOME

git-add - Adicione o conteúdo do arquivo ao índice

RESUMO

git add [--verbose | -v] [--dry-run | -n] [--force | -f] [--interactive | -i] [--patch | -p]
	  [--edit | -e] [--[no-]all | --[no-]ignore-removal | [--update | -u]]
	  [--intent-to-add | -N] [--refresh] [--ignore-errors] [--ignore-missing] [--renormalize]
	  [--chmod=(+|-)x] [--pathspec-from-file=<arquivo> [--pathspec-file-nul]]
	  [--] [<pathspec>…​]

DESCRIÇÃO

Este comando atualiza o índice utilizando o conteúdo atual encontrado na árvore de trabalho para preparar o conteúdo para o próximo commit. Em geral ele adiciona o conteúdo atual dos caminhos existentes como um todo, mas com algumas opções ele também pode ser utilizado para adicionar o conteúdo com apenas a parte das alterações aplicadas nos arquivos da árvore de trabalho ou remover os caminhos que não existam mais na árvore de trabalho.

O "index" (ou índice) contém um instantâneo do conteúdo da árvore de trabalho que é tomado como o conteúdo do próximo commit. Portanto, depois de fazer alterações na árvore de trabalho e antes de executar o comando commit, você deve utilizar o comando add para adicionar qualquer aquivo novo ou que foi modificado ao índice.

Este comando pode ser executado várias vezes antes de um commit. Ele adiciona apenas o conteúdo do(s) arquivo(s) informados(s) no momento em que o comando add for executado; caso queira que as alterações subsequentes sejam incluídas no próximo commit, execute o comando git add novamente para adicionar o novo conteúdo ao índice.

O comando git status pode ser utilizado para obter um resumo de quais os arquivos que possuem as alterações que foram testadas para o próximo commit.

É predefinido que o comando git add não adicione os arquivos que foram ignorados. Caso algum arquivo ignorado seja especificado explicitamente na linha de comando, o git add falhará com uma lista de arquivos ignorados. Arquivos ignorados alcançados de forma recursiva no diretório ou agrupamento do nome dos arquivos executados pelo Git (cite os seus agrupamentos antes do shell) serão ignorados silenciosamente. O comando git add pode ser utilizado para adicionar os arquivos ignorados com a opção -f (impor).

Consulte git-commit[1] para ver as formas alternativas de adicionar um conteúdo a um commit.

OPÇÕES

<pathspec>…​

Os arquivos que serão adicionados ao conteúdo. Os agrupamentos dos arquivos (*.c por exemplo) podem ser utilizados para adicionar todos os arquivos coincidentes. Também um nome do diretório principal (dir para adicionar dir/arquivo1 e dir/arquivo2 por exemplo) pode ser utilizados para atualizar o índice para coincidir a condição atual do diretório como um todo (definindo o dir gravará não apenas um arquivo dir/arquivo1 modificado na árvore de trabalho, um arquivo dir/arquivo2 adicionado à árvore de trabalho, mas também um arquivo dir/arquivo3 que será removido da árvore de trabalho por exemplo). Observe que as versões mais antigas do Git costumavam ignorar os arquivos removidos; utilize a opção --no-all caso queira adicionar os arquivos novos ou alterados, porém ignore os que foram removidos.

Para mais detalhes sobre a sintaxe <pathspec>, consulte a entrada pathspec em gitglossary[7].

-n
--dry-run

Na verdade, não adicione o(s) arquivo(s), apenas demonstre se eles existem e/ou serão ignorados.

-v
--verbose

Seja loquaz.

-f
--force

Permitir a inclusão dos arquivos que já foram ignorados por outros motivos.

-i
--interactive

Adicione o conteúdo modificado interativamente ao índice da árvore de trabalho. Os argumentos opcionais do caminho podem ser utilizados para limitar a operação em um subconjunto da árvore de trabalho. Para mais detalhes consulte “modo interativo”.

-p
--patch

Escolha interativamente os pedaços do patch entre o índice e a árvore de trabalho para ser adicionado ao índice. Permite que usuário revise a diferença antes de adicionar o conteúdo modificado ao índice.

Efetivamente executa o comando add --interactive porém ignora o menu do comando inicial e salta diretamente para o subcomando` patch`. Para mais detalhes consulte “modo interativo”.

-e
--edit

Abra o diff em conjunto com o índice em um editor e deixe que o usuário o edite. Após o fechamento do editor, ajuste os cabeçalhos dos pedaços e aplique o patch no índice.

O objetivo desta opção é escolher as linhas do patch que serão aplicadas ou mesmo para modificar o conteúdo das linhas que serão preparadas. Isso pode ser mais rápido e flexível do que utilizar o seletor interativo de pedaços. No entanto, é fácil se confundir e criar um patch que não se aplica ao índice. Consulte a seção EDIÇÃO DE PATCHES abaixo.

-u
--update

Atualize o índice exatamente onde ele já possua uma entrada que coincida com o <pathspec>. Remove e altera as entradas no índice para coincidir com a árvore de trabalho sem adicionar novos arquivos.

Caso nenhum <pathspec> seja informado durante o uso da opção -u, todos os arquivos monitorados na árvore de trabalho serão atualizados (as versões antigas do Git costumavam limitar a atualização ao diretório atual e seus subdiretórios).

-A
--all
--no-ignore-removal

Atualize o índice não apenas onde a árvore de trabalho possa um arquivo que coincida com o <pathspec> mas também onde o índice já possua uma entrada. Adiciona, modifica e remove as entradas do índice para que coincida com a árvore de trabalho.

Caso nenhum <pathspec> seja informado durante o uso da opção -A, todos os arquivos na árvore de trabalho serão atualizados (as versões antigas do Git costumavam limitar a atualização ao diretório atual e seus subdiretórios).

--no-all
--ignore-removal

Atualize o índice adicionando os novos arquivos que sejam desconhecidos ao índice e os arquivos modificados na árvore de trabalho, no entanto ignore aqueles arquivos que foram removidos da árvore de trabalho. Esta opção não funciona quando <pathspec> não é utilizado.

Esta opção serve principalmente para ajudar os usuários que estão acostumados com as versões mais antigas do Git, cujo git add <pathspec>... era um sinônimo para git add --no-all <pathspec>..., isto é, ignora a remoção dos arquivos.

-N
--intent-to-add

Registre apenas o fato de onde caminho será adicionado posteriormente. Uma entrada para o caminho é colocada ao índice sem nenhum conteúdo. É útil para, entre outras coisas, para exibir os conteúdos dos tais arquivos que não foram preparados com o comando git diff e que o commit não foi feito com git commit -a.

--refresh

Não adicione o(s) arquivo(s), apenas renove as suas informações stat() no índice.

--ignore-errors

Caso alguns arquivos não possam ser adicionados por motivos de erros durante a indexação, não interrompa a operação e continue a adicionar os outros que não tenham erros. O comando ainda deve sair com a condição diferente de zero. Para que este comportamento esteja sempre ativado, a variável de configuração add.ignoreErrors pode ser definida como true.

--ignore-missing

Esta opção só pode ser utilizada em conjunto com a opção --dry-run. Ao utilizar esta opção, o usuário pode verificar se algum dos arquivos informados seriam ignorados, independentemente caso já estejam presentes na árvore de trabalho ou não.

--no-warn-embedded-repo

É predefinido que o comando git add avisará ao adicionar um repositório incorporado ao índice sem utilizar o comando git submodule add para criar uma entrada no .gitmodules. Esta opção suprimirá o alerta (caso esteja executando as operações manualmente nos submódulos por exemplo).

--renormalize

Aplique o processo "limpo" em todos os arquivos monitorados para impor a sua adição novamente ao índice. É útil após alterar a configuração da variável core.autocrlf ou do atributo` text` para corrigir os arquivos que foram adicionados com caracteres de quebra de linha CRLF ou LF incorretas. Implica no uso da opção -u.

--chmod=(+|-)x

Substitua o bit executável dos arquivos que foram adicionados. Apenas no índice que o bit executável é alterado, os arquivos no disco permanecem inalterados.

--pathspec-from-file=<arquivo>

O "pathspec" é passado com <arquivo> em vez dos argumentos da linha de comando. Caso o <arquivo> seja exatamente -, a entrada padrão será utilizada. Os elementos do "pathspec" são separados por caracteres de término de linha LF ou CR/LF. Os elementos do "pathspec" podem ser citados conforme explicado na variável de configuração core.quotePath (consulte git-config[1]). Consulte também opção --pathspec-file-nul e o global --literal-pathspecs.

--pathspec-file-nul

Só faz algum sentido caso seja utilizado junto com a opção --pathspec-from-file. Os elementos "pathspec" são separados com caracteres NUL e todos os outros caracteres são considerados de forma literal (incluindo as novas linhas e as citações).

--

Esta opção pode ser utilizada para separar as opções da linha de comandos da lista dos arquivos (útil quando os nomes do arquivo puderem ser confundidos com as opções da linha de comando).

EXEMPLOS

  • Adiciona conteúdo de todos os arquivos *.txt sob o diretório Documentation com os seus respectivos subdiretórios:

    $ git add Documentation/\*.txt

    Observe que o asterisco * neste exemplo é citado do shell; isso permite que o comando inclua todos os arquivos dos subdiretórios do diretório Documentation/.

  • Considera a adição do conteúdo de todos os scripts git-*.sh:

    $ git add git-*.sh

    Pelo fato deste exemplo permitir que o shell expanda o asterisco (ou seja, você está listando os arquivos de forma explicita), ele desconsidera o subdir/git-foo.sh.

MODO INTERATIVO

Quando o comando entra no modo interativo, ele exibe a saída do subcomando status e entra em seu loop de comando interativo.

O loop de comando exibe a lista de subcomandos disponíveis e fornece o prompt "Agora o quê>". Em geral, quando o prompt termina com um único >, é possível escolher apenas uma das opções informadas e teclar "Enter" para selecioná-la:

    *** Comandos ***
      1: status       2: atualiza       3: reverte       4: adiciona sem monitoramento
      5: patch        6: diff           7: encerra       8: ajuda
    Agora o quê> 1

Também é possível utilizar s ou sta ou status acima, desde que a escolha seja única.

O loop do comando principal tem 6 subcomandos (incluindo a ajuda e encerrar).

status

Exibe a alteração entre o HEAD e o índice (ou seja, o commit que será caso utilize o comando git commit) e entre o índice e os arquivos da árvore de trabalho (ou seja, o que você poderia realizar antes do comando git commit utilizando o comando git add) para cada caminho. Uma amostra da saída fica assim:

              staged     unstaged path
     1:       binary      nothing foo.png
     2:     +403/-35        +1/-1 git-add--interactive.perl

Demonstra que foo.png tem diferenças em relação ao HEAD (mas por ser binário a contagem das linhas não pode ser exibida) e não há diferença entre a cópia indexada e a versão na árvore de trabalho (caso a versão na árvore de trabalho também fosse diferente, a informação binary (binário) seria exibido no lugar de nothing (nada)). O outro arquivo, git-add{litdd}interactive.perl, possui 403 linhas que foram adicionadas e 35 linhas que foram excluídas caso faça o commit do que está no índice, porém o arquivo na árvore de trabalho possui outras modificações (uma adição e uma exclusão).

update

Exibe as informações da condição geral e emite um prompt "Update>>" (Atualizar). Quando o prompt termina com duplo >>, é possível fazer mais de uma seleção concatenada com um espaço ou uma vírgula. Além disso, você pode utilizar os intervalos. Por exemplo, "2-5 7,9" para escolher 2,3,4,5,7,9 da lista. Caso o segundo número de um intervalo seja omitido, todos os patches restantes serão tomados. Por exemplo. "7-" para escolher 7,8,9 da lista. É possível utilizar * para escolher tudo.

O que você escolheu é destacado com *, assim:

           staged     unstaged path
  1:       binary      nothing foo.png
* 2:     +403/-35        +1/-1 git-add--interactive.perl

Para remover a seleção, prefixe a entrada com - desta maneira:

Update>> -2

Depois de fazer a seleção, responda com uma linha vazia para preparar o conteúdo dos arquivos na árvore de trabalho para os caminhos selecionados no índice.

reverte

Há uma interface muito semelhante à update (atualização) e as informações preparadas para os caminhos selecionados são revertidas para a versão do HEAD. A reversão dos novos caminhos os torna não rastreáveis.

adiciona sem monitoramento

Há uma interface do usuário muito semelhante para update (atualizar) e revert (reverter) que permite adicionar caminhos não rastreados ao índice.

patch

Permite a escolha de um caminho dentre uma seleção de status. Depois de escolher o caminho, é apresentado a diferença entre o índice e o arquivo na árvore de trabalho, pergunta caso queira preparar a alteração de cada pedaço. Você pode selecionar uma das seguintes opções e pressional enter:

y - prepare este pedaço
n - não prepare este pedaço
q - saia; não prepare este pedaço ou qualquer um dos restantes
a - prepare este pedaço e todos os pedaços posteriores no arquivo
d - não prepare este pedaço ou qualquer um dos pedaços posteriores no arquivo
g - selecione um pedaço para ir de encontro com
/ - procure um pedaço correspondente ao regex especificado
j - não decida sobre este pedaço, veja o próximo pedaço indeciso
J - não decida sobre este pedaço, veja o próximo pedaço
k - não decida sobre este pedaço, veja o pedaço indeciso anterior
K - não decida sobre este pedaço, veja o pedaço anterior
s - divide o pedaço atual em pedaços menores
e - edite manualmente o pedaço atual
? - imprima a ajuda

Depois de decidir o destino de todos os pedaços, caso haja algum pedaço selecionado, o índice é atualizado com os pedaços que foram selecionados.

Não é necessário pressionar o enter, ao configurar a variável de configuração interactive.singleKey para true.

diff

Permite a revisão do commit que será feito (entre o HEAD e o índice por exemplo).

EDIÇÃO DE PATCHES

Ao invocar o comando git add -e ou selecionando e no seletor interativo de pedaços, será aberto um patch no seu editor; após a saída do editor, o resultado é aplicado ao índice. Você é livre para fazer alterações arbitrárias no patch, porém observe que algumas alterações podem ter resultados confusos ou até resultar em um patch que não possa ser aplicado. Caso queira abortar completamente a operação (ou seja, não criar nada novo no índice), simplesmente exclua todas as linhas do patch. A lista abaixo descreve algumas coisas comuns que são possíveis de visualizar em um patch e quais as operações da edição fazem sentido nelas.

conteúdo que foi adicionado

O conteúdo adicionado é representado por linhas começando com "+". Você pode impedir a preparação de qualquer linha de adição excluindo-as.

conteúdo que foi removido

O conteúdo removido é representado por linhas que começam com "-". É possível evitar a preparação da remoção convertendo o "-" para um " " (espaço).

conteúdo que foi alterado

O conteúdo modificado é representado por linhas "-" (removendo o conteúdo antigo) seguido por linhas "+" (adicionando o conteúdo de reposição). Você pode impedir a preparação da modificação convertendo as linhas "-" para " " e removendo as linhas "+". Lembre-se que alterar apenas a metade do par provavelmente introduzirá mudanças confusas ao índice.

Também existem operações mais complexas que podem ser executadas. Mas cuidado, porque o patch é aplicado apenas ao índice e não à árvore de trabalho, a árvore de trabalho aparecerá para "desfazer" a mudança no índice. A introdução de uma nova linha no índice que não esteja em HEAD nem na árvore de trabalho por exemplo, organizará a nova linha para o commit, porém a linha parecerá ter sido revertida na árvore de trabalho.

Evite utilizar estas construções ou faça isso com extrema cautela.

removendo um conteúdo intocado

O conteúdo que não difere entre o índice e a árvore de trabalho podem ser exibidas nas linhas do contexto, começando com um " " (espaço). Você pode preparar as linhas de contexto para a remoção, convertendo o espaço em um "-". O arquivo da árvore de trabalho resultante aparecerá para ser adicionada novamente ao conteúdo.

modificando um conteúdo já existente

Também é possível modificar as linhas do contexto, preparando-as para a remoção (convertendo " " para "-") e adicionando uma linha "+" (sinal de mais) ao novo conteúdo. Da mesma forma, é possível modificar as linhas "+" para as adições ou modificações existentes. Em todos os casos, a nova alteração aparecerá de forma reversa na árvore de trabalho.

novos conteúdos

Você também pode adicionar um novo conteúdo que não existe no patch; basta adicionar as novas linhas, cada uma começando com "+". A adição aparecerá de forma reversa na árvore de trabalho.

Existem também várias outras operações que devem ser totalmente evitadas, pois elas tornarão o patch impossível de se aplicar:

  • adicionando as linhas de contexto (" ") ou de remoção ("-")

  • excluindo as linhas de contexto ou de remoção

  • modificando o conteúdo do contexto ou as linhas de remoção

GIT

Parte do conjunto git[1]

scroll-to-top