git-add - Online na nuvem

PROGRAMA:

NOME

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

SINOPSE

git adicionar [--verboso | -v] [--execução a seco | -n] [--força | -f] [--interativo | -i] [--patch | -p]
[--edit | -e] [- [não-] todos | - [no-] ignorar-remoção | [--update | -você]]
[--intenção de adicionar | -N] [--refresh] [--ignore-errors] [--ignore-missing]
[-] [ ...]

DESCRIÇÃO

Este comando atualiza o índice usando o conteúdo atual encontrado na árvore de trabalho, para
preparar o conteúdo encenado para o próximo commit. Normalmente adiciona o conteúdo atual de
caminhos existentes como um todo, mas com algumas opções, também pode ser usado para adicionar conteúdo com
apenas parte das mudanças feitas nos arquivos da árvore de trabalho aplicada, ou remova caminhos que fazem
não existe mais na árvore de trabalho.

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

Este comando pode ser executado várias vezes antes de um commit. Ele apenas adiciona o conteúdo de
o (s) arquivo (s) especificado (s) no momento em que o comando add é executado; se você quiser mudanças subsequentes
incluído no próximo commit, então você deve executar 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 têm alterações que
são encenados para o próximo commit.

O comando git add não adicionará arquivos ignorados por padrão. Se algum arquivo ignorado fosse
especificado explicitamente na linha de comando, git add falhará com uma lista de arquivos ignorados.
Arquivos ignorados alcançados por recursão de diretório ou globbing de nome de arquivo executado pelo Git (aspas
seus globs antes do shell) serão ignorados silenciosamente. o git adicionar comando pode ser usado para
adicione arquivos ignorados com a opção -f (forçar).

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

OPÇÕES

...
Arquivos dos quais adicionar conteúdo. Fileglobs (por exemplo, * .c) podem ser fornecidos para adicionar todas as correspondências
arquivos. Além disso, um nome de diretório principal (por exemplo, dir para adicionar dir / arquivo1 e dir / arquivo2) pode ser
fornecido para atualizar o índice para corresponder ao estado atual do diretório como um todo (por exemplo
especificar dir irá registrar não apenas um arquivo dir / file1 modificado na árvore de trabalho, um
arquivo dir / arquivo2 adicionado à árvore de trabalho, mas também um arquivo dir / arquivo3 removido da
árvore de trabalho. Observe que as versões anteriores do Git costumavam ignorar os arquivos removidos; usar
Opção --no-all se você deseja adicionar arquivos modificados ou novos, mas ignorar os removidos.

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

-v, --verboso
Seja prolixo.

-f, --força
Permitir a adição de arquivos ignorados de outra forma.

-i, --interativo
Adicione conteúdos modificados na árvore de trabalho interativamente ao índice. Caminho opcional
argumentos podem ser fornecidos para limitar a operação a um subconjunto da árvore de trabalho. Ver
“Modo interativo” para detalhes.

-p, --patch
Escolha interativamente pedaços de patch entre o índice e a árvore de trabalho e adicione-os
para o índice. Isso dá ao usuário a chance de revisar a diferença antes de adicionar
conteúdo modificado para o índice.

Isso efetivamente executa add --interactive, mas ignora o menu de comando inicial e
pula diretamente para o subcomando patch. Consulte “Modo interativo” para obter detalhes.

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

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

-u, --atualizar
Atualize o índice apenas onde ele já tem uma correspondência de entrada . Isso remove
assim como modifica as entradas do índice para coincidir com a árvore de trabalho, mas não adiciona novos arquivos.

Se não é fornecido quando a opção -u é usada, todos os arquivos rastreados em todo o
árvore de trabalho são atualizados (versões antigas do Git usadas para limitar a atualização para o atual
diretório e seus subdiretórios).

-A, --all, --no-ignore-remoção
Atualize o índice não apenas onde a árvore de trabalho tem um arquivo correspondente mas
também onde o índice já tem uma entrada. Isso adiciona, modifica e remove o índice
entradas para corresponder à árvore de trabalho.

Se não é fornecido quando a opção -A é usada, todos os arquivos em toda a árvore de trabalho
são atualizados (versões antigas do Git usadas para limitar a atualização para o diretório atual e
seus subdiretórios).

--não-tudo, --ignore-remoção
Atualize o índice adicionando novos arquivos que são desconhecidos do índice e arquivos modificados
na árvore de trabalho, mas ignore os arquivos que foram removidos da árvore de trabalho.
Esta opção é autônoma quando não é usado.

Esta opção é principalmente para ajudar os usuários que estão acostumados com versões mais antigas do Git, cujo
"git add ... "era sinônimo de" git add --no-all ... ", ou seja
arquivos removidos ignorados.

-N, --intenção de adicionar
Registre apenas o fato de que o caminho será adicionado posteriormente. Uma entrada para o caminho é
colocado no índice sem conteúdo. Isso é útil para, entre outras coisas, mostrar
o conteúdo não encenado de tais arquivos com git diff e enviando-os com git commit
-a.

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

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

--ignore-faltando
Esta opção só pode ser usada junto com --dry-run. Usando esta opção, o usuário
pode verificar se algum dos arquivos fornecidos seria ignorado, não importa se eles já são
presente na árvore de trabalho ou não.

--
Esta opção pode ser usada para separar as opções de linha de comando da lista de arquivos,
(útil quando nomes de arquivos 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 arquivo para excluir do git-add, semelhante a
$ GIT_DIR / info / exclude. Os padrões no arquivo de exclusão são usados ​​além daqueles em
info / excluir. Ver gitignore(5).

EXEMPLOS

· Adiciona conteúdo de todos os arquivos * .txt no diretório de documentação e seus
subdiretórios:

$ git add Documentation / \ *. txt

Observe que o asterisco * é citado no shell neste exemplo; isso permite que o
comando inclui os arquivos de subdiretórios de Documentação / diretório.

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

$ git add git - *. sh

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

INTERATIVO MODA

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

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

*** Comandos ***
1: status 2: atualização 3: reverter 4: adicionar não rastreado
5: patch 6: diff 7: sair 8: ajuda
E agora> 1

Você também pode dizer s ou sta ou status acima, desde que a escolha seja exclusiva.

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

estado
Isso mostra a mudança entre HEAD e índice (ou seja, o que será confirmado se você disser
git commit), e entre o índice e os arquivos da árvore de trabalho (ou seja, o que você pode preparar
mais adiante antes de git commit usando git add) para cada caminho. Um exemplo de saída parece
esta:

caminho não encenado
1: binário nada foo.png
2: + 403 / -35 + 1 / -1 git-add - interativo.perl

Isso mostra que foo.png tem diferenças de HEAD (mas isso é binário então a contagem de linha
não pode ser mostrado) e não há diferença entre a cópia indexada e a árvore de trabalho
versão (se a versão da árvore de trabalho também fosse diferente, binário teria sido mostrado
em lugar de nada) O outro arquivo, git-add - interativo.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
outras modificações (uma adição e uma exclusão).

atualizar
Isso mostra as informações de status e emite um prompt "Atualizar >>". Quando o prompt
termina com duplo >>, você pode 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 em um intervalo for omitido, todos os patches restantes são
ocupado. Por exemplo, "7-" para escolher 7,8,9 da lista. Você pode dizer * para escolher tudo.

O que você escolheu é então destacado com *, Como este:

caminho não encenado
1: binário nada foo.png
* 2: + 403 / -35 + 1 / -1 git-add - interativo.perl

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

Atualizar >> -2

Após fazer a seleção, responda com uma linha em branco para organizar o conteúdo do trabalho
arquivos de árvore para caminhos selecionados no índice.

reverter
Isso tem uma IU muito semelhante a atualizar, e as informações preparadas para caminhos selecionados
são revertidos para a versão HEAD. Reverter novos caminhos os torna não rastreados.

adicionar não rastreado
Isso tem uma IU muito semelhante a atualizar e reverter, e permite adicionar caminhos não rastreados para
o índice.

remendo
Isso permite que você escolha um caminho de um estado como seleção. Depois de escolher o caminho,
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
digite return:

y - encenar este pedaço
n - não encenar este pedaço
q - sair; não encenar este pedaço ou qualquer um dos restantes
a - encenar este pedaço e todos os pedaços posteriores no arquivo
d - não coloque este pedaço ou qualquer um dos pedaços posteriores no arquivo
g - selecione um pedaço para ir
/ - procura por um pedaço que corresponda ao regex fornecido
j - deixe este pedaço indeciso, veja o próximo pedaço indeciso
J - deixe este pedaço indeciso, veja o próximo pedaço
k - deixe este pedaço indeciso, veja o pedaço indeciso anterior
K - deixe este pedaço indeciso, veja o pedaço anterior
s - divide o pedaço atual em pedaços menores
e - editar 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, definindo a variável de configuração
interativo.singleKey para verdadeiro.

diff
Isso permite que você revise o que será confirmado (ou seja, entre o HEAD e o índice).

EDIÇÃO REMENDAS

Invocar git add -e ou selecionar e no seletor de pedaços interativo abrirá um patch no
seu editor; depois que o editor sai, o resultado é aplicado ao índice. Você é livre para
fazer alterações arbitrárias no patch, mas observe que algumas alterações podem confundir
resultados, ou mesmo resultar em um patch que não pode ser aplicado. Se você quiser abortar o
operação inteiramente (ou seja, não definir nada de novo no índice), simplesmente exclua todas as linhas do
correção. A lista abaixo descreve algumas coisas comuns que você pode ver em um patch, e quais
as operações de edição fazem sentido neles.

conteúdo adicionado
O conteúdo adicionado é representado por linhas que começam com "+". Você pode evitar o preparo de qualquer
adicionar linhas excluindo-as.

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

conteúdo modificado
O conteúdo modificado é representado por linhas "-" (removendo o conteúdo antigo) seguidas por
"+" linhas (adicionando o conteúdo de substituição). Você pode evitar o preparo da modificação
convertendo as linhas "-" em "" e removendo as linhas "+". Cuidado com a modificação apenas
metade do par provavelmente apresentará mudanças confusas no índice.

Também existem operações mais complexas que podem ser executadas. Mas tome 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 está no HEAD nem a árvore de trabalho irá preparar a nova linha para o commit, mas o
a linha parecerá ser revertida na árvore de trabalho.

Evite usar essas construções ou faça-o com muito cuidado.

removendo conteúdo intocado
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 preparar linhas de contexto para remoção
convertendo o espaço em um "-". O arquivo de árvore de trabalho resultante aparecerá para
adicione novamente o conteúdo.

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

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

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

· Adicionar contexto ("") ou remover ("-") linhas

· Deletar contexto ou remover linhas

· Modificar o conteúdo do contexto ou remover linhas

Use git-add online usando serviços onworks.net