10 principais comandos git essenciais

O Git se tornou o sistema de controle de versão por excelência. A ascensão da popularidade do Git pode ser atribuída à sua velocidade, agilidade e versatilidade. Seja você um desenvolvedor de web freelancer ou um designer de software para aplicativos de nível corporativo, você pode se beneficiar do uso do Git. Ajuda você a acompanhar seus arquivos por meio de versão sistemática. O Git facilita o rolamento para versões mais antigas de código ou criar novas ramificações para experimentar na base de código atual. Além disso, o Git é um sistema de controle de versão distribuído, o que significa que você nem precisa sempre se conectar a um servidor central para fazer seu trabalho.Abaixo estão os comandos GIT essenciais que ajudarão em suas tarefas diárias. Os exemplos simples lhe darão uma compreensão dos comandos, para que você possa se lembrar facilmente da sintaxe quando precisar usá -los.

1. git add

O comando add git permite começar a rastrear arquivos e pastas para o seu repositório Git e os move para a área de estadiamento. Você terá que usar o comando Git Commit para torná -los permanentes em seus instantâneos históricos.

Usar o comando é fácil. Você pode optar por adicionar arquivos e pastas individualmente ou usar o operador de Asterisk do tipo Linux (*) para adicioná -los em grupos.

Vamos dar o exemplo abaixo:

Suponha, no caso acima, já adicionamos o ReadMe.TXT. Mas o restante dos arquivos não foi adicionado.

Vamos verificar o status:

$ git status
No mestre da filial
Sua filial está atualizada com 'Origin/Master'.
Arquivos não rastreados:
(use 'git add…' para incluir no que será comprometido)
arquivo1.TXT
File2.TXT
pasta1/

Os arquivos e pastas estão em vermelho, o que significa que não estão sendo rastreados. Podemos adicioná -los usando:

$ git add file1.txt file2.pasta txt1/*

Se verificarmos o status agora:

$ git status
No mestre da filial
Sua filial está atualizada com 'Origin/Master'.
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Novo arquivo: arquivo1.TXT
Novo arquivo: arquivo2.TXT
Novo arquivo: pasta1/file3.TXT
Novo arquivo: pasta1/file4.TXT

O comando add git adicionou os arquivos à área de estadiamento. Os arquivos são mantidos na área de preparação antes de torná -los permanentes através do processo de confirmação.

2. ramo git

No git, ramificar é fácil. Em outros sistemas de controle de versão, foi uma operação cara. Mas os algoritmos Git são otimizados para ramificação. Para que você possa usar o comando git ramo sempre que quiser criar uma linha de desenvolvimento separada sem se preocupar com o desempenho.

Vejamos o seguinte exemplo.

$ git status
No mestre da filial
Sua filial está atualizada com 'Origin/Master'.
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Novo arquivo: arquivo1.TXT
Novo arquivo: arquivo2.TXT
Novo arquivo: pasta1/file3.TXT
Novo arquivo: pasta1/file4.TXT

Observe que estamos 'no mestre do ramo'. Quando você cria um novo projeto, você acabará no Branch Master. Você também pode usar o comando git ramo -a descobrir em qual ramo você está:

$ git ramo -a
* mestre

O exposto acima está lhe dizendo que há apenas um ramo chamado 'mestre' e o asterisco (*) significa que você está nesse ramo.

Vamos criar um novo ramo chamado 'Testing':

Teste de ramificação $ git

Agora podemos verificar as filiais novamente:

$ git ramo -a
* mestre
teste

Mesmo assim, ainda estamos no ramo 'mestre', também podemos ver o novo ramo de 'testes' que foi criado. O ramo de 'teste' é uma réplica do ramo 'mestre'.

3. checkout git

O comando Git checkout leva você a uma filial, para que você possa trabalhar com os recursos lá. Você pode pensar em galhos como rios e riachos. Com uma filial, você cria um novo fluxo. Com o comando de checkout, você se move para esse fluxo.

Vamos verificar a filial 'Testing' do exemplo anterior:

Teste de checkout de $ git
Mudou para o 'teste' da filial

Agora vamos verificar o status e as ramificações novamente:

$ git status
No teste de ramificação
nada para se comprometer, diretório de trabalho limpo
$ git ramo -a
mestre
* Teste

Você pode ver no comando git -ramo -a que mudamos para o ramo de teste.

4. clone git

O comando git clone permite que você faça uma cópia de qualquer repositório Git. Assim que você clonar um repositório, a nova pasta clonada começará a acompanhar as alterações localmente. Como o Git é distribuído, um clone é um repositório Git totalmente autônomo.

Para mostrar como a clonagem funciona, vamos criar um novo repositório:

$ mkdir dir1
$ CD Dir1
$ mkdir myProject
$ CD MyProject/
$ git init
Repositório Git vazio inicializado em/dir1/myProject/.git/
$ touch readme.TXT
$ git Commit -m 'Inicialize meu repositório'
[Mestre (compensação raiz) 5a0bd75] Inicialize meu repositório
1 arquivo alterado, 0 inserções (+), 0 deleções (-)
Criar modo 100644 ReadMe.TXT

No exemplo acima, criamos o repositório Git chamado 'MyProject' dentro da pasta 'dir1'. Suponha que este seja o nosso principal repositório. Agora queremos fazer uma cópia e trabalhar em outro lugar.

Vamos criar um diretório chamado 'dir2' e clonar o repositório 'myproject'. Estamos usando o clone Git para clonar 'MyProject':

$ mkdir dir2
$ CD Dir2
CLONE DE $ GIT/DIR1/MYPROJECT/
Clonando em 'MyProject'…
feito.
$ ls
meu projeto

O comando git clone funciona com um URL também.

$ git clone https: // github.com/teste/teste.git

Além disso, você pode alterar o nome do clone especificando -o após o endereço do repositório Git:

$ git clone https: // github.com/teste/teste.git mytest

5. Git Commit

O comando Git Commit é executado após o comando git add. Em nosso exemplo, add, tínhamos adicionado os arquivos para rastreamento, mas não o tínhamos começado ao repositório Git. Rastrear permanece local até que um compromisso seja feito. Quando você comete as mudanças, elas se tornam parte do registro permanente.

Abaixo, estamos executando o comando git -m -m:

$ git Commit -m 'Comando meus arquivos e pastas'
[Master 3EF57B3] Comando meus arquivos e pastas
4 arquivos alterados, 0 inserções (+), 0 deleções (-)
Criar modo 100644 arquivo1.TXT
Criar modo 100644 arquivo2.TXT
Criar modo 100644 pasta1/file3.TXT
Criar modo 100644 pasta1/arquivo4.TXT

Se você não usar a opção -m para colocar um comentário, o git abrirá seu editor de texto padrão e pedirá. Os comentários são considerados uma boa prática de controle de versão. Então sempre coloque comentários significativos em seu compromisso.

6. Config Git

O comando Git Config permite configurar várias opções para o seu repositório Git. Por exemplo, você pode usar o comando Git Config -Global para obter e definir seu usuário.nome e usuário.e-mail.

Veja como você pode definir os valores:

$ Git Config -Usuário global.nome 'zak h'
$ Git Config -Usuário global.Envie um e -mail [email protected]

Veja como você pode verificar os valores:

$ Git Config -Usuário global.nome
Zak h
$ Git Config -Usuário global.e-mail
[email protected]

7. Git Dif

O comando git diff ajuda você a ver as diferenças entre arquivos e pastas. Se você estiver fazendo alterações em um arquivo, é uma ferramenta útil para avaliar rapidamente as alterações que você fez.

Vamos supor que começamos nosso trabalho com um readme.Arquivo TXT com duas linhas. Então nos livramos da segunda linha e adicionamos uma terceira linha.

Agora, se executarmos o comando diff, ele mostrará as diferenças entre a versão comprometida e a versão alterada local na área de estadiamento. Aqui está como vai ficar:

$ git diff
diff - -git a/readme.txt b/readme.TXT
ÍNDICE 9475DDC… 1804904 100644
--- A/README.TXT
+++ b/ReadMe.TXT
@@ -1,2 +1,2 @@
Linha 1: minha primeira linha
-Linha 2: minha segunda linha
+Linha 3: minha terceira linha

A linha 1 é inalterada (branca), a linha 2 removida (vermelha) e a linha 3 adicionada (verde).
Você pode usar o comando DIFF para também encontrar diferenças entre compromissos específicos.

8. git busca

O comando Git Fetch recebe os recursos mais recentes da origem especificada.

Vejamos um exemplo. Supunha -se que você tenha a seguinte condição:

Dir1/MyProject
Dir2/MyProject (clonado)

A pasta 'Dir2/MyProject' é clonada de 'Dir1/MyProject'. Agora, se alguém cometeu mudanças no 'DIR1/MyProject', você poderá obter essas alterações como essa de 'Dir2/MyProject':

$ git busca origem
Remoto: contando objetos: 2, feito.
Remoto: Compressioning Objetos: 100% (2/2), feito.
Remoto: Total 2 (delta 0), reutilizado 0 (delta 0)
Descepcionando objetos: 100% (2/2), feito.
De /dir2 /… /dir1 /myProject
5a0bd75… 1713734 Mestre -> Origin/Master

É importante lembrar que o comando git busca não mescla as mudanças. Para buscar e mesclar automáticos, use o comando git pull. Então você pode estar se perguntando por que usar este comando em primeiro lugar. Pode haver opções Git avançadas, onde você obtém todas as alterações do seu servidor de origem e, em seguida, aplica apenas alterações seletivamente a determinados arquivos. O comando Git Fetch permite que você consiga isso. No entanto, é um tópico avançado que você pode encontrar na documentação Git busca.

9. Git Grep

O comando Git Grep permite que você pesquise sua árvore Git para obter informações. Aqui está o exemplo de pesquisa da palavra 'linha' em nosso repositório Git. A opção -n ou -linha -número mostra números de linha em que o Git encontra uma correspondência:

$ Git Grep -n Line
Leia-me.txt: 1: linha 1: minha primeira linha
Leia-me.txt: 2: linha 3: minha terceira linha

Você pode executar uma pesquisa semelhante por número de vezes que a partida está lá com -C ou -Opção de contagem:

Git Grep -c Line
Leia-me.txt: 2

O motivo do uso do Git Grep sobre o Linux Grep é que o Git Grep é mais rápido para repositórios Git.

10. log git

O comando Git Log mostra o histórico de compromissos.

$ git log
COMIT 171373479FC309846EF605FBE650933767AFD0FB
Autor: Zak H
Data: Qua 21 de novembro 20:26:32 2018 -0800
Novos arquivos adicionados
COMIT 5A0BD759506D20B2B989873258BF60D003AA3D36
Autor: Zak H
Data: Qua 21 de novembro 18:48:35 2018 -0800
Inicialize meu repositório

Você também pode usar a opção -Oline para ver uma versão abreviada. A versão abreviada é mais fácil de seguir.

$ git log --oneeline
1713734 novos arquivos adicionados
5a0bd75 inicialize meu repositório

11. Merge do Git

O comando Git mescla mescla ramificações.

Vamos criar um novo repositório com 'Main' e depois criar um ramo de 'teste'.

$ mkdir myProject
$ CD MyProject
$ git init
Repositório Git vazio inicializado em/git_essentials/myProject/.git/
$ touch readme.TXT
$ git add -a
$ git commit -m 'Commits inicial'
[Mestre (Compromisso Raiz) B31D4E1] Commiti
1 arquivo alterado, 0 inserções (+), 0 deleções (-)
Criar modo 100644 ReadMe.TXT
Teste de ramificação $ git
$ git ramo -a
* mestre
teste
Teste de checkout de $ git
Mudou para o 'teste' da filial

No ramo 'teste', vamos fazer algumas alterações:

$ touch file1.txt file2.TXT
$ Ls
Arquivo1.txt file2.txt readme.TXT
$ git add -a
$ git Commit -m 'Adicionado dois novos arquivos'
[Teste 7E11910] adicionou dois novos arquivos
2 arquivos alterados, 0 inserções (+), 0 deleções (-)
Criar modo 100644 arquivo1.TXT
Criar modo 100644 arquivo2.TXT

Adicionamos dois arquivos ao teste.

$ git ramo -a
mestre
* teste
$ ls
Arquivo1.txt file2.txt readme.TXT
$ git checkout mestre
Mudou para a filial 'Mestre'
$ git ramo -a
* mestre
teste
$ ls
Leia-me.TXT

Vemos do exposto, esse arquivo1.txt e file2.txt existe no ramo de 'teste', mas não em 'mestre'.

Vamos mergulhar agora.

Teste de mesclagem $ git
Atualizando B31D4E1… 7E11910
Avanço rápido
Arquivo1.txt | 0
File2.txt | 0
2 arquivos alterados, 0 inserções (+), 0 deleções (-)
Criar modo 100644 arquivo1.TXT
Criar modo 100644 arquivo2.TXT
$ ls
Arquivo1.txt file2.txt readme.TXT
$ git ramo -a
* mestre
teste

Agora temos 'file1.txt 'e' file2.txt 'in' master 'ramo também.

Nota: Pense na fusão como uma operação de tração. Você tem que estar no ramo que deseja se fundir. Nesse caso, você está no ramo 'mestre' puxando as alterações do ramo 'teste'.

12. git mv

O Git MV é um comando de atalho para executar comandos add add e git rm. Pode ser usado para renomear arquivos.

Aqui está um exemplo:

$ git mv readme.txt readme.MD
$ git status
No mestre da filial
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Renomeado: ReadMe.txt -> readme.MD

13. Git Pull

O comando git pull é muito parecido com a busca git, exceto que a mesclagem acontece automaticamente.

Aqui está um exemplo de execução do Git Pull Origin, como o Git buscando um (estamos executando uma solicitação de tração do clone para obter alterações do repositório Git original):

$ Git Pull Origin
Remoto: contando objetos: 3, feito.
Remoto: Compressioning Objetos: 100% (2/2), feito.
Remoto: Total 3 (delta 0), reutilizado 0 (delta 0)
Descepcionando objetos: 100% (3/3), feito.
De/LearnGit/git_essentials/myProject
7E11910… E67F932 Mestre -> Origin/Master
Atualizando 7e11910… e67f932
Avanço rápido
Arquivo1.txt | 1 +
File2.txt | 1 +
Arquivo3.txt | 1 +
Leia-me.txt => readme.md | 0
4 arquivos alterados, 3 inserções (+)
Criar modo 100644 arquivo3.TXT
Renomeie o ReadMe.txt => readme.MD (100%)

Você pode ver que as mudanças foram baixadas da origem e mescladas no clone.

14. git push

O comando git push é usado para empurrar mudanças para repositórios remotos. Aqui está um exemplo de execução do comando push:

$ Git Push Origin Master
Contando objetos: 2, feito.
Compressão delta usando até 4 threads.
Objetos de compactação: 100% (2/2), feito.
Objetos de escrita: 100% (2/2), 242 bytes | 0 bytes/s, feito.
Total 2 (Delta 1), reutilizado 0 (delta 0)
Para/LearnGit/Git_ESSEncials/MyProject
E67F932… 90DC546 Mestre -> Mestre

O comando Git Push Origin Master está enviando alterações para o ramo 'mestre' da origem (o repositório Git que você clonou) do ramo 'mestre' do repositório clonado. Visualmente, o impulso se parece com o seguinte:

clonado/mestre -> origem/mestre

15. Git Rebase

O comando git rebase ajuda você a mudar a base dos ramos. Em uma mesclagem geral, algo assim acontece:

A filial de teste foi fundida no ramo 'mestre' para criar uma nova confirmação.

Em uma rebase, é isso que acontece:

As mudanças de E e F Changelist são recalculadas e travadas no final do ramo mestre. Rebasing ajuda a simplificar os ramos.

Vamos supor que temos essa situação no ramo 'mestre':

$ git log --oneeline
7F573D8 Commit C: Adicionado C.TXT
795DA3C Commit B: Adicionado B.TXT
0f4ed5b Commit A: Adicionado um.TXT

E uma filial de recursos:

$ git log --oneeline
8ed0c4e Commit F: modificado B.TXT
6E12B57 Commit E: modificado a.TXT
795DA3C Commit B: Adicionado B.TXT
0f4ed5b Commit A: Adicionado um.TXT

Se rebasemos, obtemos o Git Rebase Master:

Recurso de checkout de $ git
Mudou para o ramo 'Recurso'
$ git rebase mestre

Primeiro, retrocedendo a cabeça para reproduzir seu trabalho em cima dele ..

Aplicação: Commit E: modificado a.TXT
Aplicação: Commit F: modificado B.TXT
Em seguida, mesclar 'recurso' em 'mestre'.
$ git checkout mestre
Mudou para a filial 'Mestre'
Recurso de mesclagem $ git
Atualizando 7F573D8… 9EFA1A3
Avanço rápido
a.txt | 1 +
b.txt | 1 +
2 arquivos alterados, 2 inserções (+)

Agora, se você for ao ramo 'mestre' e 'recurso', verá os mesmos logs:

$ git log --oneeline
9EFA1A3 Commit F: modificado B.TXT
8710174 Commit E: modificado a.TXT
7F573D8 Commit C: Adicionado C.TXT
795DA3C Commit B: Adicionado B.TXT
0f4ed5b Commit A: Adicionado um.TXT

Rebasing os esmagou.

Nota: Nunca use a Rebasing em repositórios públicos, pois os desenvolvedores terão problemas de mesclagem.

Git remoto

O comando git remoto permite definir um servidor remoto para o seu repositório. Em uma situação de clonagem, o repositório de origem se torna automaticamente o controle remoto.

Por exemplo:

$ PWD
/LearnGit/git_essencials/teste
$ git remoto -v
Origin/LearnGit/Git_ESSEncials/MyProject (busca)
Origin/LearnGit/Git_ESSEncials/MyProject (push)

O exposto acima está mostrando que o servidor remoto para 'teste' é outra pasta chamada 'MyProject'. O motivo é que o 'teste' foi clonado para o meu projeto.

Mas o servidor remoto não precisa ser local. Você pode ter algo assim com um URL:

$ git remoto -v
origem https: // github.com/zakh/myProject (busca)
origem https: // github.com/zakh/myProject (push)

Você pode configurar um repositório remoto Git usando o comando git remoto add:

$ git remoto adicionar origem https: // github.com/zakh/myproject

Isso conectará seu repositório à origem para que você possa buscar e empurrar.

17. Redefinição do Git

A redefinição do Git permite que você solte arquivos adicionados.

Digamos que você tenha adicionado o arquivo 'teste.txt 'para o seu repositório:

Teste de Touch.TXT
$ git add -a
$ git status
No mestre da filial
Sua filial está atualizada com 'Origin/Master'.
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Novo arquivo: teste.TXT

No entanto, você decide que não quer rastrear 'teste.txt 'mais. Você pode usar o comando Git Redefinir Head para soltar o arquivo:

$ git reiniciar o teste da cabeça.TXT

Se você verificar o status, o arquivo será novamente não rastreado:

$ git status
No mestre da filial
Sua filial está atualizada com 'Origin/Master'.
Arquivos não rastreados:
(use 'git add…' para incluir no que será comprometido)
teste.TXT

O arquivo 'teste.txt 'não é mais rastreado.

18. Git reverter

O comando git revert permite reverter as alterações usando o número de hash de comprometimento.

$ echo 'teste 1' >> myfile.TXT
$ git add -a
$ git Commit -m 'Alterar adicionado 1'
[Master 78A8277] Adicionado mudança 1
2 arquivos alterados, 1 inserção (+)
Criar modo 100644 MyFile.TXT
Criar modo de teste 100644.TXT
$ Cat MyFile.TXT
Teste 1
$ echo 'teste 2' >> myfile.TXT
$ git add -a
$ git Commit -m 'Alterar adicionado 2'
[Master A976E9C] Adicionado mudança 2
1 arquivo alterado, 1 inserção (+)
$ Cat MyFile.TXT
Teste 1
Teste 2
$ git log --oneeline
A976E9C adicionou mudança 2
78A8277 Alterar 1
90dc546 adicionou um arquivo
E67F932 adicionou novos arquivos
7E11910 adicionou dois novos arquivos
B31D4E1 COMÍNDO INICIAL

Nós criamos um 'myfile.txt 'e comprometido duas alterações, então o arquivo tem as linhas' teste 1 'e' teste 2 '. Mas decidimos que não queremos o segundo compromisso. Então, encontramos o hash de confirmação (A976E9C) para isso. Podemos usar o Git reverter para nos livrar do commit:

$ git revert a976e9c
[Master 4F270E7] reverter 'Alterar adicionado 2'
1 arquivo alterado, 1 exclusão (-)
$ git log --oneeline
4F270E7 REVERT 'ADICIONAR 2'
A976E9C adicionou mudança 2
78A8277 Alterar 1
90dc546 adicionou um arquivo
E67F932 adicionou novos arquivos
7E11910 adicionou dois novos arquivos
B31D4E1 COMÍNDO INICIAL
$ Cat MyFile.TXT
Teste 1

Vemos que houve um novo hash de compromisso criado que reverteu o compromisso da linha 'Test 2'. O arquivo tem apenas a linha 'Teste 1' agora.

19. git rm

O comando git rm configura arquivos para deletes futuros. Ele coloca os arquivos que são excluídos na área de estadiamento.

Teste de $ git rm.TXT
RM 'teste.TXT'
$ git status
No mestre da filial
Sua filial está à frente de 'Origin/Master' por 3 Commits.
(Use 'Git Push' para publicar seus compromissos locais)
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Excluído: teste.TXT

Você tem que cometer as mudanças para o Excluir entrar em vigor.

20. Git Stash

O comando git stash permite que você abandone temporariamente o trabalho que você não está pronto para cometer ainda.
Suponha que você esteja trabalhando em um repositório com os seguintes arquivos:

$ ls
John.txt mary.TXT
Você deseja alterar esses arquivos para ser mais baseado em projetos. Então você começa com:
$ git mv John.TXT Projectfile1.TXT
$ ls
Mary.TXT Projectfile1.TXT
$ git status
No mestre da filial
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Renomeado: John.txt -> Projectfile1.TXT

No meio da renomeação e atualização 'John.txt 'to' Projectfile1.txt ', você recebe um pedido para mudar algo no projeto. Mas você não está pronto para enviar 'Projectfile1.TXT'. Então você esconde.

$ git Stash

Diretório de trabalho salvo e WIP de estado de índice no mestre: f0b5a01 init john and Mary

Head está agora em f0b5a01 init John e Mary

$ ls
John.txt mary.TXT

Seu ambiente de trabalho local está de volta para onde você estava antes de fazer suas alterações baseadas em projetos. Depois, atendendo à interrupção, em vez de voltar para 'John.txt ', você decide trabalhar na' Mary.arquivo txt 'agora:

$ Git MV Mary.TXT Projectfile2.TXT
$ git status
No mestre da filial
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Renomeado: Mary.txt -> Projectfile2.TXT
$ ls
John.TXT Projectfile2.TXT

Você é interrompido novamente e esconde seu novo trabalho em 'Mary.TXT':

$ git Stash
Diretório de trabalho salvo e WIP de estado de índice no mestre: f0b5a01 init john and Mary
Head está agora em f0b5a01 init John e Mary
$ ls
John.txt mary.TXT

Depois que o trabalho de interrupção é feito, você verifica a lista de stash:

Lista de esconderijo $ git
Stash@0: WIP no mestre: f0b5a01 init john and Mary
Stash@1: WIP no Mestre: F0B5A01 Init John e Mary

Você tem dois trabalhos em andamento (WIP) no esconderijo. Firs tempo você coloca o estoque, você recebe o mais recente 'Mary.Txt 'muda:

$ Git Stash Pop
Removendo Maria.TXT
No mestre da filial
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Novo arquivo: Projectfile2.TXT
Mudanças não encenadas para comprometer:
(use 'git add/rm…' para atualizar o que será comprometido)
(Use 'checkout git -…' para descartar mudanças no diretório de trabalho)
Excluído: Mary.TXT
Ref

Segunda vez você coloca o estoque, você recebe o 'John.Alterações relacionadas ao TXT'

$ Git Stash Pop
Removendo John.TXT
No mestre da filial
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Novo arquivo: Projectfile1.TXT
Novo arquivo: Projectfile2.TXT
Mudanças não encenadas para comprometer:
(use 'git add/rm…' para atualizar o que será comprometido)
(Use 'checkout git -…' para descartar mudanças no diretório de trabalho)
Excluído: John.TXT
Excluído: Mary.TXT
Ref
$ ls
Projectfile1.TXT Projectfile2.TXT

E você tem seu trabalho em andamento 'Projectfile1.txt 'e' Projectfile2.TXT 'de volta.

Portanto, o comando Git Stash ajuda você a esconder seu trabalho para que você possa voltar a ele mais tarde.

21. status git

O comando de status Git exibe a diferença entre os arquivos atuais e o compromisso da cabeça.

Aqui está um exemplo:

$ git status
No mestre da filial
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
Renomeado: File2.txt -> arquivo3.TXT
Mudanças não encenadas para comprometer:
(use 'git add…' para atualizar o que será comprometido)
(Use 'checkout git -…' para descartar mudanças no diretório de trabalho)
modificado: file1.TXT

Está mostrando que 'file2.txt 'está sendo renomeado para' file3.txt 'que está pronto para comprometer, mas as modificações em' file1.txt 'ainda não está na área de estadiamento.

Então, adicionamos tudo:

$ git add -a

Agora, quando verificamos o status:

$ git status
No mestre da filial
Mudanças a serem comprometidas:
(Use 'Git Reset Head…' para se desencadear)
modificado: file1.TXT
Renomeado: File2.txt -> arquivo3.TXT

Vemos todas as mudanças estão prontas para se comprometer.

22. tag git

O comando git tag ajuda você a criar tags para seus importantes pontos históricos. Geralmente é usado para configurar números de versão.

O comando git tag mostrará as tags disponíveis atuais:

$ git tag
v1.0
v2.0

Você pode marcar com o formato de comando tag Git:

$ git tag v3.0

Para ver o que está na tag, você pode usar o comando git show:

$ git show v1.0
Commit 61E9E8AA1B98B2A657303E6822B291D2374314B5
Autor: Zak H
Data: Qui 22 de novembro 01:06:42 2018 -0800
Primeiro comprometimento
diff -git a/1.txt b/1.TXT
Novo modo de arquivo 100644
ÍNDICE 0000000… E69DE29

Você também pode marcar usando um hash de commit e o formato de comando tag Git:

$ git log --oneeline
374EFE9 Arquivo modificado
A621765 Adicionar
6d6ed84 Segundo Commit
61E9E8A Primeira confirmação
$ git tag v4.0 A621765
$ git show v4.0
CONMIDE A6217650A2C7B2531ECB9C173BA94BD4B3BA7ABD
Autor: Zak H
Data: Qui 22 de novembro 01:15:55 2018 -0800
Adicionar
diff -git a/1.txt b/1.TXT
ÍNDICE E69DE29… 587BE6B 100644
--- A/1.TXT
+++ b/1.TXT
@@ -0,0 +1 @@

Para concluir

Para qualquer comando, você pode usar o git -h para obter mais informações.

Um estudo mais aprofundado

• https: // git-scm.com/docs