Git 🌙
Português (Brasil) ▾ Topics ▾ Latest version ▾ git-add last updated in 2.46.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 | -A | --[no-]ignore-removal | [--update | -u]] [--sparse]
	  [--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, após fazer as alterações na árvore de trabalho e antes de executar o comando commit, utilize o comando add para adicionar qualquer novo arquivo ou qualquer outros arquivos que tenham sido alterados 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.

For more details about the <pathspec> syntax, see the pathspec entry in 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.

--sparse

Permite a atualização das entradas do índice fora da cônica sparse-checkout. Normalmente, o comando git add se recusa a atualizar as entradas dos índices cujos caminhos não caibam dentro da cônica sparse-checkout, uma vez que estes arquivos podem ser removidos da árvore de trabalho sem aviso prévio. Consulte a opção git-sparse-checkout[1] para obter mais detalhes.

-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 num subconjunto da árvore de trabalho. Para mais detalhes consulte “modo interativo”.

-p
--patch

Escolha interativamente pedaços do patch entre o índice, a árvore de trabalho e adicione-os ao índice. Isso dá ao usuário a chance de revisar a diferença antes de adicionar 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 num 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

Update the index just where it already has an entry matching <pathspec>. This removes as well as modifies index entries to match the working tree, but adds no new files.

If no <pathspec> is given when -u option is used, all tracked files in the entire working tree are updated (old versions of Git used to limit the update to the current directory and its subdirectories).

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

Update the index not only where the working tree has a file matching <pathspec> but also where the index already has an entry. This adds, modifies, and removes index entries to match the working tree.

If no <pathspec> is given when -A option is used, all files in the entire working tree are updated (old versions of Git used to limit the update to the current directory and its subdirectories).

--no-all
--ignore-removal

Update the index by adding new files that are unknown to the index and files modified in the working tree, but ignore files that have been removed from the working tree. This option is a no-op when no <pathspec> is used.

This option is primarily to help users who are used to older versions of Git, whose "git add <pathspec>…​" was a synonym for "git add --no-all <pathspec>…​", i.e. ignored removed files.

-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. Os caracteres CR solitários são intocados, logo, enquanto um CRLF é limpo para LF, uma sequência CRCRLF é parcialmente limpa apenas para CRLF.

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

Pathspec is passed in <file> instead of commandline args. If <file> is exactly - then standard input is used. Pathspec elements are separated by LF or CR/LF. Pathspec elements can be quoted as explained for the configuration variable core.quotePath (see git-config[1]). See also --pathspec-file-nul and 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 add-interactive.c

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, add-interactive.c, 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 add-interactive.c

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 - stage this hunk
n - do not stage this hunk
q - quit; do not stage this hunk or any of the remaining ones
a - stage this hunk and all later hunks in the file
d - do not stage this hunk or any of the later hunks in the file
g - select a hunk to go to
/ - search for a hunk matching the given regex
j - leave this hunk undecided, see next undecided hunk
J - leave this hunk undecided, see next hunk
k - leave this hunk undecided, see previous undecided hunk
K - leave this hunk undecided, see previous hunk
s - split the current hunk into smaller hunks
e - manually edit the current hunk
p - print the current hunk
? - print help

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 num 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 num 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 num "-". 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

CONFIGURAÇÃO

Warning

Missing pt_BR/includes/cmd-config-section-all.txt

See original version for this content.

Warning

Missing pt_BR/config/add.txt

See original version for this content.

GIT

Parte do conjunto git[1]

scroll-to-top