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

NOME

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

SINOPSE

git add [--verbose | -v] [--dry-run | -n] [--force | -f] [--interativo | -i] [--patch | -p]
	  [--edit | -e] [- [no-]todos | - [no-]ignorar-remoção| [--update | -u]]
	  [--intent-to-add | -N] [--refresh] [--ignore-errors] [--ignore-missing] [--renormalize]
	  [--chmod = (+ | -) x] [-] [<pathspec> …​]

DESCRIÇÃO

Esse comando atualiza o índice usando o conteúdo atual encontrado na árvore de trabalho, para preparar o conteúdo testado para o próximo commit. Geralmente, ele adiciona o conteúdo atual dos caminhos existentes como um todo, mas com algumas opções também pode ser usado para adicionar conteúdo com apenas parte das alterações feitas nos arquivos da árvore de trabalho aplicados ou remover caminhos que não existem na árvore de trabalho não mais.

O "índice" contém um instantâneo do conteúdo da árvore de trabalho e é esse instantâneo que é considerado o conteúdo do próximo commit. Assim, depois de fazer qualquer alteração na árvore de trabalho, e antes de executar o comando commit, você deve usar o comando add para adicionar quaisquer arquivos novos ou modificados ao índice.

Esse comando pode ser executado várias vezes antes de uma confirmação. Ele apenas adiciona o conteúdo do(s) arquivo(s) especificado(s) no momento em que o comando add é executado; se você quiser mudanças subsequentes incluídas no próximo commit, então você deve rodar o git add novamente para adicionar o novo conteúdo ao índice.

O comando git status pode ser usado para obter um resumo de quais arquivos possuem mudanças que são testadas para o próximo commit.

O comando git add não adicionará arquivos ignorados por padrão. Se algum arquivo ignorado foi explicitamente especificado na linha de comando, o git add falhará com uma lista de arquivos ignorados. Os arquivos ignorados alcançados pela recursão de diretório ou globalização de nomes de arquivos executada pelo Git (citar seus globs antes do shell) serão silenciosamente ignorados. O comando git add pode ser usado para adicionar arquivos ignorados com a opção -f (force).

Por favor, veja git-commit[1] para formas alternativas de adicionar conteúdo a um commit.

OPÇÕES

<pathspec>…​

Arquivos para adicionar conteúdo de. Fileglobs (por exemplo, * .c) podem ser fornecidos para adicionar todos os arquivos correspondentes. Também um nome de diretório principal (por exemplo, dir para adicionar` dir/file1` e dir/file2) pode ser dado para atualizar o índice para corresponder ao estado atual do diretório como um todo (por exemplo, especificando` dir` irá gravar não apenas um arquivo dir/file1 modificado na árvore de trabalho, um arquivo dir/file2 adicionado à árvore de trabalho, mas também um arquivo dir /file3 removido da árvore de trabalho). Note que versões mais antigas do Git costumavam ignorar arquivos removidos; use a opção --no-all se você quiser adicionar arquivos modificados ou novos, mas ignorar os removidos.

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

-n
--dry-run

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

-v
--verbose

Seja verboso.

-f
--force

Permitir a adição de arquivos ignorados.

-i
--interactive

Adicione conteúdo modificado na árvore de trabalho de forma interativa ao índice. Argumentos de caminho opcionais podem ser fornecidos para limitar a operação a um subconjunto da árvore de trabalho. Veja ‘` modo interativo '’ para detalhes.

-p
--patch

Interativamente, escolha pedaços de patch entre o índice e 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.

Isso efetivamente executa add --interactive, mas ignora o menu de comando inicial e pula diretamente para o subcomando` patch`. Veja ‘` modo interativo '’ para detalhes.

-e
--edit

Abra o diff versus o índice em um editor e deixe o usuário editá-lo. Depois que o editor foi fechado, ajuste os cabeçalhos e aplique o patch ao índice.

A intenção dessa opção é escolher linhas do patch a ser aplicado ou modificar o conteúdo das linhas a serem testadas. Isso pode ser mais rápido e mais flexível do que usar o seletor interativo. No entanto, é fácil confundir a si mesmo e criar um patch que não se aplique ao índice. Veja EDITANDO OS PATCHES abaixo.

-u
--update

Atualize o índice exatamente onde ele já tem uma entrada correspondente a <pathspec>. Isso remove e modifica entradas de índice para corresponder à árvore de trabalho, mas não adiciona novos arquivos.

Se nenhum <pathspec> for fornecido quando a opção -u for usada, todos os arquivos rastreados na árvore de trabalho inteira serão atualizados (versões antigas do Git usadas para 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 possui um arquivo correspondente <pathspec>, mas também onde o índice já possui uma entrada. Isso adiciona, modifica e remove entradas de índice para corresponder à árvore de trabalho.

Se nenhum <pathspec> for fornecido quando a opção -A for usada, todos os arquivos na árvore de trabalho inteira serão atualizados (versões antigas do Git usadas para limitar a atualização ao diretório atual e seus subdiretórios).

--no-all
--ignore-removal

Atualize o índice adicionando novos arquivos que são desconhecidos ao índice e arquivos modificados na árvore de trabalho, mas ignore os arquivos que foram removidos da árvore de trabalho. Esta opção é um no-op quando nenhum <pathspec> é usado.

Esta opção é principalmente para ajudar usuários que estão acostumados com versões mais antigas do Git, cujo "git add <pathspec> …​" era um sinônimo para "git add --no-all <pathspec> …​", isto é, ignorado removido arquivos.

-N
--intent-to-add

Registre apenas o fato de que o caminho será adicionado posteriormente. Uma entrada para o caminho é colocada no índice sem conteúdo. Isso é útil para, entre outras coisas, mostrar o conteúdo não organizado de tais arquivos com o git diff e confirmá-los com` git commit -a`.

--refresh

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

--ignore-errors

Se alguns arquivos não puderem ser adicionados devido a erros de indexação, não cancele a operação, mas continue adicionando os outros. O comando ainda deve sair com status diferente de zero. A variável de configuração add.ignoreErrors pode ser configurada como true para tornar este o comportamento padrão.

--ignore-missing

Esta opção só pode ser usada em conjunto com --dry-run. Ao utilizar esta opção, o usuário pode verificar se algum dos arquivos fornecidos seria ignorado, não importando se eles já estão presentes na árvore de trabalho ou não.

--no-warn-embedded-repo

Por padrão, o git add irá avisar quando adicionar um repositório embutido ao índice sem usar o` git submodule add` para criar uma entrada no .gitmodules. Esta opção suprimirá o aviso (por exemplo, se você estiver executando operações manualmente em submódulos).

--renormalize

Aplique o processo "limpo" recentemente a todos os arquivos rastreados para adicioná-los à força novamente ao índice. Isso é útil depois de alterar a configuração core.autocrlf ou o atributo` text` para corrigir arquivos adicionados com terminações de linha CRLF/LF erradas. Esta opção implica -u.

--chmod=(+|-)x

Substituir o bit executável dos arquivos adicionados. O bit executável é alterado apenas no índice, os arquivos no disco são mantidos inalterados.

--

Essa opção pode ser usada para separar as opções da linha de comandos da lista de arquivos (útil quando nomes de arquivo podem ser confundidos com opções de linha de comando).

CONFIGURAÇÃO

A variável de configuração opcional core.excludesFile indica um caminho para um arquivo contendo padrões de nomes de arquivos a serem excluídos do git-add, similar a $GIT_DIR/info/exclude. Padrões no arquivo de exclusão são usados além daqueles em info/exclude. Veja gitignore[5].

EXEMPLOS

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

    $ git add Documentação /\*.txt

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

  • Considera adicionar conteúdo de todos os scripts git - *. sh:

    $ git add git-*.sh

    Como este exemplo permite que o shell expanda o asterisco (ou seja, você está listando os arquivos explicitamente), ele não considera subdir/git-foo.sh.

MODO INTERATIVO

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

O loop de comando mostra a lista de subcomandos disponíveis e fornece um prompt "What now>". Em geral, quando o prompt termina com um único >, você pode escolher apenas uma das opções dadas e digitar return, assim:

    ***Comandos***
      1: status       2: atualização       3: reverter      4: adicionar sem rastreamento
      5: patch        6: diff       7: sair       8: ajuda
    O que agora> 1

Você também poderia dizer s ou` sta` ou status acima, desde que a escolha seja única.

O loop de comando principal tem 6 subcomandos (mais ajuda e sair).

estado

Isto mostra a mudança entre HEAD e index (i.e. o que será cometido se você disser git commit), e entre index e working tree files (i.e. o que você poderia colocar mais antes` git commit` usando git add) para cada caminho. Um exemplo de saída é assim:

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

Ele mostra que foo.png tem diferenças de HEAD (mas isso é binário, então a contagem de linhas não pode ser mostrada) e não há diferença entre a cópia indexada e a versão da árvore de trabalho (se a versão da árvore de trabalho também fosse diferente, binary teria foi mostrado no lugar de nada). O outro arquivo, git-add {litdd} interactive.perl, tem 403 linhas adicionadas e 35 linhas excluídas se você confirmar o que está no índice, mas o arquivo da árvore de trabalho tem modificações adicionais (uma adição e uma exclusão).

atualizar

Isso mostra as informações de status e emite um prompt "Atualizar". Quando o prompt terminar com double >>, você poderá fazer mais de uma seleção, concatenada com espaço em branco ou vírgula. Além disso, você pode dizer intervalos. Por exemplo. "2-5 7,9" para escolher 2,3,4,5,7,9 da lista. Se o segundo número de um intervalo for omitido, todos os restantes serão tomados. Por exemplo. "7-" para escolher 7,8,9 da lista. Você pode dizer * 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, prefixar a entrada com - assim:

Atualização >> -2

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

reverter

Isso tem uma interface do usuário muito semelhante para atualizar, e as informações testadas para os caminhos selecionados são revertidas para aquela da versão HEAD. A reversão de novos caminhos os torna desimpedidos.

adicione sem traçado

Isso tem uma interface do usuário muito semelhante para atualizar e reverter e permite adicionar caminhos não rastreados ao índice.

patch

Isso permite escolher um caminho de uma seleção como "status". Depois de escolher o caminho, ele apresenta a diferença entre o índice e o arquivo da árvore de trabalho e pergunta se você deseja encenar a mudança de cada pedaço. Você pode selecionar uma das seguintes opções e digitar retornar:

y - encenar esse pedaço
n - não encenar esse pedaço
q - sair; não encenar este pedaço ou qualquer um dos restantes
a - encenar esse pedaço e todos os pedaços posteriores no arquivo
d - não encenar esse pedaço ou qualquer um dos pedaços posteriores no arquivo
g - selecione um pedaço para ir
/ - procure por um pedaço que corresponda à regex dada
j - deixe esse pedaço indeciso, veja o próximo pedaço indeciso
k - deixe esse pedaço indeciso, veja o pedaço indeciso anterior
K - deixe esse pedaço indeciso, veja o pedaço anterior
s - divide o pedaço atual em pedaços menores
e - edite manualmente o pedaço atual
? - ajuda de impressão

Depois de decidir o destino de todos os pedaços, se houver algum pedaço escolhido, o índice é atualizado com os pedaços selecionados.

Você pode omitir ter que digitar return aqui, configurando a variável de configuração interactive.singleKey para` true`.

diff

Isso permite revisar o que será confirmado (por exemplo, entre HEAD e índice).

EDIÇÃO DE PATCHES

Chamar git add -e ou selecionar` e` no seletor interativo irá abrir um patch no seu editor; depois que o editor sai, o resultado é aplicado ao índice. Você está livre para fazer alterações arbitrárias no patch, mas observe que algumas alterações podem gerar resultados confusos ou até resultar em um patch que não pode ser aplicado. Se você quiser abortar a operação completamente (isto é, não colocar nada novo no índice), simplesmente exclua todas as linhas do patch. A lista abaixo descreve algumas coisas comuns que você pode ver em um patch e quais operações de edição fazem sentido nelas.

conteúdo adicionado

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

conteúdo removido

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

conteúdo modificado

O conteúdo modificado é representado por linhas "-" (removendo o conteúdo antigo) seguido por linhas "+" (adicionando o conteúdo de substituição). Você pode impedir a preparação da modificação convertendo as linhas "-" para " " e removendo as linhas "+". Tenha em atenção que é provável que a modificação de apenas metade do par introduza alterações confusas no índice.

Existem também 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. Por exemplo, a introdução de uma nova linha no índice que não esteja em HEAD nem na árvore de trabalho organizará a nova linha para confirmação, mas a linha parecerá ser revertida na árvore de trabalho.

Evite usar essas construções ou faça isso com extrema cautela.

removendo conteúdo intocado

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

modificando o conteúdo existente

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

novos conteúdos

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

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

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

  • excluindo linhas de contexto ou remoção

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

GIT

Parte do git[1] suite