Git

22 comandos essenciais do Git

22 comandos essenciais do Git
Git se tornou o sistema de controle de versão por excelência. O aumento da popularidade do Git pode ser atribuído à sua velocidade, agilidade e versatilidade. Seja você um desenvolvedor web freelancer ou um designer de software para aplicativos de nível empresarial, você pode se beneficiar com o uso do Git. Ele ajuda você a manter o controle de seus arquivos por meio de versões sistemáticas. Git torna mais fácil reverter para versões mais antigas do código ou criar novos branches para experimentar na base de código atual. Além disso, Git é um sistema de controle de versão distribuído, o que significa que você nem sempre precisa se conectar a um servidor central para fazer seu trabalho.Abaixo estão os comandos essenciais do Git que ajudarão nas suas tarefas do dia-a-dia. Os exemplos simples darão a você uma compreensão dos comandos, para que você possa lembrar facilmente a sintaxe quando precisar usá-los.

1. git add

O comando git add permite que você comece a rastrear arquivos e pastas para o seu repositório Git e os mova para a área de teste. 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 escolher adicionar arquivos e pastas individualmente ou usar o operador glob do tipo asterisco (*) do Linux para adicioná-los aos grupos.

Vejamos o exemplo abaixo:

Suponha que, no caso acima, já adicionamos o arquivo ReadMe.TXT. Mas o resto dos arquivos não foram adicionados.

Vamos verificar o status:

$ git status
No mestre de filial
Sua filial está atualizada com 'origin / master'.
Arquivos não rastreados:
(use 'git add ... 'para incluir no que será comprometido)
arquivo1.TXT
arquivo2.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.arquivo txt 2.pasta txt1 / *

Se verificarmos o status agora:

$ git status
No mestre de filial
Sua filial está atualizada com 'origin / master'.
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
novo arquivo: arquivo1.TXT
novo arquivo: arquivo2.TXT
novo arquivo: pasta1 / arquivo3.TXT
novo arquivo: pasta1 / arquivo4.TXT

O comando git add adicionou os arquivos à área de teste. Os arquivos são mantidos na área de teste antes de torná-los permanentes por meio do processo de confirmação.

2. ramo git

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

Vejamos o seguinte exemplo.

$ git status
No mestre de filial
Sua filial está atualizada com 'origin / master'.
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
novo arquivo: arquivo1.TXT
novo arquivo: arquivo2.TXT
novo arquivo: pasta1 / arquivo3.TXT
novo arquivo: pasta1 / arquivo4.TXT

Observe que estamos 'On branch master'. Ao criar um novo projeto, você acabará no branch master. Você também pode usar o comando git branch -a para descobrir em qual branch você está:

$ git branch -a
* mestre

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

Vamos criar um novo branch chamado 'teste':

teste de branch $ git

Agora podemos verificar os ramos novamente:

$ git branch -a
* mestre
testando

Mesmo que ainda estejamos no branch 'master', também podemos ver o novo branch 'testando' que foi criado. O ramo 'teste' é uma réplica do ramo 'mestre'.

3. git checkout

O comando git checkout leva você a um branch, para que você possa trabalhar nos recursos lá. Você pode pensar nos ramos como rios e riachos. Com um branch, você cria um novo fluxo. Com o comando checkout, você entra nesse fluxo.

Vamos verificar o branch de 'teste' do exemplo anterior:

teste de checkout $ git
Mudou para o ramo 'teste'

Agora vamos verificar o status e os branches novamente:

$ git status
No teste de filial
nada para confirmar, diretório de trabalho limpo
$ git branch -a
mestre
* teste

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

4. git clone

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 monitorar as alterações localmente. Como o Git é distribuído, um clone é um repositório Git totalmente autônomo.

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

$ mkdir dir1
$ cd dir1
$ mkdir meuprojeto
$ cd myproject /
$ git init
Repositório Git vazio inicializado em / dir1 / myproject /.git /
$ touch ReadMe.TXT
$ git commit -m 'Inicializar meu repositório'
[master (root-commit) 5a0bd75] Inicializar meu repositório
1 arquivo alterado, 0 inserções (+), 0 exclusões (-)
modo de criação 100644 ReadMe.TXT

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

Vamos criar um diretório chamado 'dir2' e clonar o repositório 'meuprojeto'. Estamos usando o clone git

para clonar 'meuprojeto':

$ mkdir dir2
$ cd dir2
$ git clone / dir1 / myproject /
Clonando em 'meuprojeto' ..
feito.
$ ls
meu projeto

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

$ git clone https: // github.com / test / test.idiota

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 / test / test.git mytest

5. git commit

O comando git commit é executado após o comando git add. Em nosso exemplo de git add, adicionamos os arquivos para rastreamento, mas não os colocamos no repositório Git. O rastreamento permanece local até que um commit seja feito. Quando você confirma as alterações, elas se tornam parte do registro permanente.

Abaixo, estamos executando o git commit -m comando:

$ git commit -m 'Confirmando meus arquivos e pastas'
[master 3ef57b3] Comprometendo meus arquivos e pastas
4 arquivos alterados, 0 inserções (+), 0 exclusões (-)
modo de criação 100644 arquivo1.TXT
modo de criação 100644 arquivo 2.TXT
modo de criação 100644 pasta1 / arquivo3.TXT
modo de criação 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á por ele. Os comentários são considerados boas práticas de controle de versão. Portanto, sempre coloque comentários significativos em seu commit.

6. git config

O comando git config permite que você configure várias opções para o seu repositório git. Por exemplo, você pode usar o git config -global comando para obter e definir seu usuário.nome e usuário.o email.

Veja como você pode definir os valores:

$ git config - usuário global.nome 'Zak H'
$ git config - usuário global.email zakh @ example.com

Veja como você pode verificar os valores:

$ git config - usuário global.nome
Zak H
$ git config - usuário global.o email
zakh @ exemplo.com

7. git diff

O comando git diff ajuda 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 feitas.

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 confirmada e a versão alterada local na área de teste. Veja 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 permanece inalterada (branca), a linha 2 foi removida (vermelha) e a linha 3 foi adicionada (verde).
Você pode usar o comando diff para também encontrar diferenças entre commits particulares.

8. git fetch

O comando git fetch obtém os recursos mais recentes da origem especificada.

Vejamos um exemplo. Suponha que você tenha a seguinte condição:

dir1 / meuprojeto
dir2 / meuprojeto (clonado)

A pasta 'dir2 / meuprojeto' é clonada de 'dir1 / meuprojeto'. Agora, se alguém confirmou as alterações em 'dir1 / meuprojeto', você pode obter essas alterações como esta de dentro de 'dir2 / meuprojeto':

$ git fetch origin
remoto: Contando objetos: 2, concluído.
remoto: compactando objetos: 100% (2/2), concluído.
remoto: Total 2 (delta 0), reutilizado 0 (delta 0)
Descompactando objetos: 100% (2/2), concluído.
De / dir2 /… / dir1 / meuprojeto
5a0bd75… 1713734 mestre -> origem / mestre

É importante lembrar que o comando git fetch não mescla as mudanças. Para obter e mesclar automaticamente, 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 mudanças do seu servidor de origem e só aplica as mudanças seletivamente a certos arquivos. O comando git fetch permite que você faça isso. No entanto, é um tópico avançado que você pode encontrar na documentação do git fetch.

9. git grep

O comando git grep permite que você pesquise sua árvore Git para obter informações. Aqui está um exemplo de pesquisa da palavra 'Line' em nosso repositório git. A opção -n ou --line-number mostra os números das linhas onde o Git encontra uma correspondência:

Linha $ git grep -n
Leia-me.txt: 1: Linha 1: Minha primeira linha
Leia-me.txt: 2: Linha 3: Minha TERCEIRA linha

Você pode executar uma pesquisa semelhante para o número de vezes que a correspondência existe com a opção -c ou --count:

git grep -c Line
Leia-me.txt: 2

A razão para usar git grep sobre Linux grep é que git grep é mais rápido para repositórios git.

10. git log

O comando git log mostra o histórico de commits.

$ git log
commit 171373479fc309846ef605fbe650933767afd0fb
Autor: Zak H
Data: Quarta, 21 de novembro 20:26:32 2018 -0800
Novos arquivos adicionados
commit 5a0bd759506d20b2b989873258bf60d003aa3d36
Autor: Zak H
Data: Quarta, 21 de novembro 18:48:35 2018 -0800
Inicializar meu repositório

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

$ git log --oneline
1713734 Novos arquivos adicionados
5a0bd75 Inicializar meu repositório

11. git merge

O comando git merge mescla ramos.

Vamos criar um novo repositório com 'principal' e, em seguida, criar um branch de 'teste'.

$ mkdir meuprojeto
$ cd myproject
$ git init
Repositório Git vazio inicializado em / git_essentials / myproject /.git /
$ touch ReadMe.TXT
$ git add -A
$ git commit -m 'commit inicial'
[master (root-commit) b31d4e1] Confirmação inicial
1 arquivo alterado, 0 inserções (+), 0 exclusões (-)
modo de criação 100644 ReadMe.TXT
$ git branch test
$ git branch -a
* mestre
teste
$ git checkout test
Mudou para o ramo 'teste'

No branch 'test', vamos fazer algumas mudanças:

$ touch File1.txt File2.TXT
$ Ls
Arquivo1.txt File2.txt ReadMe.TXT
$ git add -A
$ git commit -m 'Adicionados dois novos arquivos'
[teste 7e11910] Adicionados dois novos arquivos
2 arquivos alterados, 0 inserções (+), 0 exclusões (-)
modo de criação 100644 Arquivo1.TXT
modo de criação 100644 Arquivo 2.TXT

Adicionamos dois arquivos para o teste.

$ git branch -a
mestre
* teste
$ ls
Arquivo1.txt File2.txt ReadMe.TXT
$ git checkout master
Mudou para branch 'master'
$ git branch -a
* mestre
teste
$ ls
Leia-me.TXT

Vemos acima, que Arquivo1.txt e Arquivo2.txt existe no branch 'test', mas não no 'master'.

Vamos nos fundir agora.

$ git merge test
Atualizando b31d4e1… 7e11910
Avanço rápido
Arquivo1.txt | 0
Arquivo2.txt | 0
2 arquivos alterados, 0 inserções (+), 0 exclusões (-)
modo de criação 100644 Arquivo1.TXT
modo de criação 100644 Arquivo 2.TXT
$ ls
Arquivo1.txt File2.txt ReadMe.TXT
$ git branch -a
* mestre
teste

Agora temos 'Arquivo1.txt 'e' Arquivo2.txt 'no ramo' master 'também.

Nota: Pense na fusão como uma operação pull. Você tem que estar no branch ao qual deseja se fundir. Neste caso, você está no branch 'master' puxando as alterações do branch 'test'.

12. git mv

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

Aqui está um exemplo:

$ git mv ReadMe.txt ReadMe.md
$ git status
No mestre de filial
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
renomeado: ReadMe.txt -> ReadMe.md

13. git pull

O comando git pull é muito parecido com o git fetch, exceto que a fusão acontece automaticamente.

Aqui está um exemplo de execução de origem git pull como git fetch (estamos executando uma solicitação pull do clone para obter alterações do repositório Git original):

$ git pull origin
remoto: Contando objetos: 3, concluído.
remoto: compactando objetos: 100% (2/2), concluído.
remoto: Total 3 (delta 0), reutilizado 0 (delta 0)
Desempacotando objetos: 100% (3/3), concluído.
De / LearnGIT / git_essentials / myproject
7e11910… e67f932 mestre -> origem / mestre
Atualizando 7e11910… e67f932
Avanço rápido
Arquivo1.txt | 1 +
Arquivo2.txt | 1 +
Arquivo3.txt | 1 +
Leia-me.txt => ReadMe.md | 0
4 arquivos alterados, 3 inserções (+)
modo de criação 100644 Arquivo3.TXT
renomear ReadMe.txt => ReadMe.md (100%)

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

14. git push

O comando git push é usado para enviar alterações para repositórios remotos. Aqui está um exemplo de execução do comando push:

$ git push origin master
Contando objetos: 2, concluído.
Compressão delta usando até 4 threads.
Comprimir objetos: 100% (2/2), concluído.
Escrevendo objetos: 100% (2/2), 242 bytes | 0 bytes / s, concluído.
Total 2 (delta 1), reutilizado 0 (delta 0)
Para / LearnGIT / git_essentials / myproject
e67f932… 90dc546 mestre -> mestre

O comando git push origin master está enviando alterações para o branch 'master' da origem (o repositório Git que você clonou) do branch 'master' do repositório clonado. Visualmente, o push se parece com isto:

clonado / mestre -> origem / mestre

15. git rebase

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

O branch de teste foi mesclado com o branch 'master' para criar um novo commit.

Em um rebase, isso é o que acontece:

As alterações da lista de mudanças E e F são recalculadas e travadas no final do branch master. Rebasing ajuda a simplificar os ramos.

Vamos supor que temos esta situação no branch 'master':

$ git log --oneline
7f573d8 Commit C: adicionado c.TXT
795da3c Commit B: adicionado b.TXT
0f4ed5b Commit A: adicionou um.TXT

E um branch de recursos:

$ git log --oneline
8ed0c4e Commit F: modificado b.TXT
6e12b57 Commit E: modificado a.TXT
795da3c Commit B: adicionado b.TXT
0f4ed5b Commit A: adicionou um.TXT

Se fizermos o rebase, obteremos o git rebase master:

$ git checkout feature
Comutado para 'recurso' de ramificação
$ git rebase master

Primeiro, rebobinando a cabeça para repetir seu trabalho em cima dela ..

Aplicando: Commit E: modificado a.TXT
Aplicando: Commit F: modificado b.TXT
Em seguida, mesclar 'recurso' em 'mestre'.
$ git checkout master
Mudou para o branch 'master'
$ git merge feature
Atualizando 7f573d8… 9efa1a3
Avanço rápido
uma.txt | 1 +
b.txt | 1 +
2 arquivos alterados, 2 inserções (+)

Agora, se você for para o branch 'master' e 'feature', verá os mesmos logs:

$ git log --oneline
9efa1a3 Commit F: b modificado.TXT
8710174 Commit E: modificado a.TXT
7f573d8 Commit C: adicionado c.TXT
795da3c Commit B: adicionado b.TXT
0f4ed5b Commit A: adicionou um.TXT

Rebasing os esmagou.

Observação: nunca use rebasing em repositórios públicos, pois os desenvolvedores enfrentarão grandes problemas de mesclagem.

16. git remote

O comando git remote permite que você defina um servidor remoto para o seu repositório. Em uma situação de clonagem, o repositório de origem automaticamente se torna o remoto.

Por exemplo:

$ pwd
/ LearnGIT / git_essentials / test
$ git remote -v
origin / LearnGIT / git_essentials / myproject (fetch)
origin / LearnGIT / git_essentials / myproject (push)

O acima está mostrando que o servidor remoto para 'teste' é outra pasta chamada 'meuprojeto'. A razão é 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 remote -v
origem https: // github.com / zakh / myproject (buscar)
origem https: // github.com / zakh / myproject (push)

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

$ git remote add origin https: // github.com / zakh / myproject

Isso conectará seu repo à origem para que você possa buscar e enviar.

17. git reset

O git reset permite remover o estágio de arquivos adicionados.

Digamos que você adicionou o arquivo 'test.txt 'para o seu repositório:

teste $ touch.TXT
$ git add -A
$ git status
No mestre de filial
Sua filial está atualizada com 'origin / master'.
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
novo arquivo: teste.TXT

No entanto, você decide que não deseja rastrear 'teste.txt 'mais. Você pode usar o git reset Head comando para descompactar o arquivo:

$ git reset teste HEAD.TXT

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

$ git status
No mestre de 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 revert

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

$ echo 'Teste 1' >> MeuArquivo.TXT
$ git add -A
$ git commit -m 'Alteração 1 adicionada'
[master 78a8277] Alteração 1 adicionada
2 arquivos alterados, 1 inserção (+)
modo de criação 100644 MyFile.TXT
modo de criação 100644 teste.TXT
$ cat MyFile.TXT
Teste 1
$ echo 'Teste 2' >> MeuArquivo.TXT
$ git add -A
$ git commit -m 'Alteração adicionada 2'
[master a976e9c] Alteração 2 adicionada
1 arquivo alterado, 1 inserção (+)
$ cat MyFile.TXT
Teste 1
Teste 2
$ git log --oneline
a976e9c Adicionada Alteração 2
78a8277 Alteração 1 adicionada
90dc546 Adicionado um arquivo
e67f932 Novos arquivos adicionados
7e11910 Adicionados dois novos arquivos
b31d4e1 Confirmação inicial

Criamos um 'MyFile.txt 'e confirmou duas alterações, então o arquivo tem as linhas' Teste 1 'e' Teste 2 '. Mas decidimos que não queremos o segundo commit. Então, encontramos o hash de commit (a976e9c) para ele. Podemos usar o git revert para se livrar do commit:

$ git revert a976e9c
[master 4f270e7] Reverter 'Alteração adicionada 2'
1 arquivo alterado, 1 exclusão (-)
$ git log --oneline
4f270e7 Reverter 'Alteração adicionada 2'
a976e9c Adicionada Alteração 2
78a8277 Alteração 1 adicionada
90dc546 Adicionado um arquivo
e67f932 Novos arquivos adicionados
7e11910 Adicionados dois novos arquivos
b31d4e1 Confirmação inicial
$ cat MyFile.TXT
Teste 1

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

19. git rm

O comando git rm configura arquivos para exclusões futuras. Ele coloca os arquivos a serem excluídos na área de teste.

teste $ git rm.TXT
teste rm '.TXT'
$ git status
No mestre de filial
Seu branch está à frente de 'origin / master' por 3 commits.
(use 'git push' para publicar seus commits locais)
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
excluído: teste.TXT

Você tem que confirmar as alterações para que a exclusão tenha efeito.

20. git stash

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

$ ls
João.txt Mary.TXT
Você deseja alterar esses arquivos para serem mais baseados em projetos. Então você começa com:
$ git mv John.txt ProjectFile1.TXT
$ ls
Mary.txt ProjectFile1.TXT
$ git status
No mestre de filial
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
renomeado: John.txt -> ProjectFile1.TXT

No meio da renomeação e atualização de 'John.txt 'para' ProjectFile1.txt ', você recebe uma solicitação para alterar 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 e Mary

HEAD está agora em f0b5a01 Init John e Mary

$ ls
João.txt Mary.TXT

Seu ambiente de trabalho local está de volta onde você estava antes de fazer as mudanças baseadas no projeto. Depois, atendendo à interrupção, em vez de voltar para 'John.txt ', você decide trabalhar no' Mary.arquivo txt 'agora:

$ git mv Mary.txt ProjectFile2.TXT
$ git status
No mestre de filial
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
renomeado: Mary.txt -> ProjectFile2.TXT
$ ls
João.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 e Mary
HEAD está agora em f0b5a01 Init John e Mary
$ ls
João.txt Mary.TXT

Depois que o trabalho de interrupção for concluído, você verifica a lista de estoque:

$ git stash list
stash @ 0: WIP no mestre: f0b5a01 Init John e Mary
stash @ 1: WIP no mestre: f0b5a01 Init John e Mary

Você tem dois trabalhos em andamento (WIP) no estoque. Da primeira vez que você estourar o estoque, você obterá o último 'Mary.txt 'changes:

$ git stash pop
Removendo Maria.TXT
No mestre de filial
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
novo arquivo: ProjectFile2.TXT
Mudanças não preparadas para confirmação:
(use 'git add / rm ... 'para atualizar o que será confirmado)
(use 'git checkout -- ... 'para descartar as alterações no diretório de trabalho)
excluído: Mary.TXT
Refs / stash descartados @ 0 (9b77a6b75e4e414fb64de341668c812d3d35150c)

Na segunda vez que você abre o estoque, obtém o 'John.mudanças relacionadas ao txt:

$ git stash pop
Removendo John.TXT
No mestre de filial
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
novo arquivo: ProjectFile1.TXT
novo arquivo: ProjectFile2.TXT
Mudanças não preparadas para confirmação:
(use 'git add / rm ... 'para atualizar o que será confirmado)
(use 'git checkout -- ... 'para descartar as alterações no diretório de trabalho)
excluído: John.TXT
excluído: Mary.TXT
Refs / stash descartados @ 0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ ls
ProjectFile1.txt ProjectFile2.TXT

E você tem seu trabalho em andamento 'ProjectFile1.txt 'e' ProjectFile2.txt 'de volta.

Então, o comando git stash ajuda a esconder seu trabalho para que você possa voltar a ele mais tarde.

21. git status

O comando git status exibe a diferença entre os arquivos atuais e o commit HEAD.

Aqui está um exemplo:

$ git status
No mestre de filial
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
renomeado: Arquivo2.txt -> Arquivo3.TXT
Mudanças não preparadas para confirmação:
(use 'git add ... 'para atualizar o que será confirmado)
(use 'git checkout -- ... 'para descartar as alterações no diretório de trabalho)
modificado: Arquivo1.TXT

Está mostrando que 'Arquivo2.txt 'está sendo renomeado para' Arquivo3.txt 'que está pronto para confirmação, mas as modificações em' Arquivo1.txt 'ainda não está na área de teste.

Então, adicionamos tudo:

$ git add -A

Agora, quando verificamos o status:

$ git status
No mestre de filial
Mudanças a serem confirmadas:
(use 'git reset HEAD ... 'para sair do palco)
modificado: Arquivo1.TXT
renomeado: Arquivo2.txt -> Arquivo3.TXT

Vemos que todas as mudanças estão prontas para serem confirmadas.

22. git tag

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

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

tag $ git
v1.0
v2.0

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

$ git tag v3.0

Para ver o que há 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 commit
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 confirmação e o formato de comando git tag :

$ git log --oneline
374efe9 arquivo modificado
a621765 Adicionar
6d6ed84 Segundo commit
61e9e8a Primeiro commit
tag $ git v4.0 a621765
$ git show v4.0
commit 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 @@

Em conclusão

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

Um estudo mais aprofundado

  • https: // git-scm.com / docs
AppyMouse na tela Trackpad e ponteiro do mouse para tablets Windows
Os usuários de tablets costumam perder o ponteiro do mouse, especialmente quando costumam usar laptops. Os smartphones e tablets touchscreen vêm com m...
O botão do meio do mouse não funciona no Windows 10
O botão do meio do mouse ajuda você a percorrer longas páginas da web e telas com muitos dados. Se isso parar, você vai acabar usando o teclado para r...
Como alterar os botões esquerdo e direito do mouse no PC com Windows 10
É normal que todos os dispositivos de mouse de computador sejam ergonomicamente projetados para usuários destros. Mas existem dispositivos de mouse di...