10 Comandos Git que todo Dev precisa saber

Git é uma parte importante da programação diária (especialmente se você estiver trabalhando com uma equipe) e é amplamente utilizado na indústria de software.

Como existem vários comandos que você pode usar, dominar o Git leva tempo. Mas alguns comandos são usados ​​com mais frequência (alguns diariamente). Portanto, neste post, irei compartilhar e explicar os 10 comandos Git mais usados ​​que todo desenvolvedor deve conhecer.

1. Clone Git

Clone Git é um comando para baixar o código-fonte existente de um repositório remoto (como o Github, por exemplo). Em outras palavras, o clone do Git basicamente faz uma cópia idêntica da versão mais recente de um projeto em um repositório e a salva em seu computador.

Existem algumas maneiras de baixar o código-fonte, mas eu prefiro o clone com https :

git clone <https://name-of-the-repository-link>

Por exemplo, se quisermos baixar um projeto do Github, tudo o que precisamos fazer é clicar no botão verde (Code), copiar o URL na caixa e colá-lo após o comando git clone que esta acima.

Isso fará uma cópia do projeto em seu computador local para que você possa começar a trabalhar com ele.

2. Ramificação Git (Branch)

Ramificações são muito importantes no git. Ao usar branches, vários desenvolvedores podem trabalhar em paralelo no mesmo projeto simultaneamente. Podemos usar o comando git branch para criar, listar e deletar branches.

Criando uma nova branch:

git branch <branch-name>

Este comando criará uma ramificação localmente . Para enviar o novo branch para o repositório remoto, você precisa usar o seguinte comando:

git push -u <remote> <branch-name>

Visualizando ramos:

git branch or git branch --list

Excluindo um branch:

git branch -d <branch-name>

3. Git checkout

Este também é um dos comandos Git mais usados. Para trabalhar em uma branch, primeiro você precisa mudar para ela. Usamos git checkout principalmente para alternar de um branch para outro. Também podemos usá-lo para verificar arquivos e commits.

git checkout <name-of-your-branch>

Existem algumas etapas que você precisa seguir para alternar com êxito entre os branches:

• As mudanças em seu branch atual devem ser confirmadas ou armazenadas antes de você mudar
• A branches que você deseja verificar deve existir em seu local

Também existe um comando de atalho que permite criar e alternar para um branch ao mesmo tempo:

git checkout -b <name-of-your-branch>

Este comando cria um novo branch em seu local (-b significa branch) e faz checkout para o novo branch logo após ele ter sido criado.

4. Status do Git

O comando de status do Git nos fornece todas as informações necessárias sobre o branch atual.

git status

Podemos coletar informações como:

• Se a branch atual está atualizada
• Se há algo para confirmar, empurrar ou puxar (push  ou pull)
• Se existem arquivos testados, não testados ou não rastreados
• Se houver arquivos criados, modificados ou excluídos

5. Git add

Quando criamos, modificamos ou apagamos um arquivo, essas mudanças acontecerão em nosso local e não serão incluídas no próximo commit (a menos que mudemos as configurações).

Precisamos usar o comando git add para incluir as alterações de um (s) arquivo (s) em nosso próximo commit.

Para adicionar um único arquivo:

git add <file>

Para adicionar tudo de uma vez:

git add -A or git add .

Quando você observar a captura de tela acima na 4ª seção, verá que há nomes de arquivo em vermelho - isso significa que eles são arquivos que não foram adiciondos com git add. Os arquivos em vermelho não serão incluídos em seus commits.

Para incluí-los, precisamos usar git add:

Importante: o comando git add não altera o repositório e as alterações não são salvas até usarmos o git commit.

6. Git commit

Este é talvez o comando mais usado do Git. Assim que chegarmos a um certo ponto de desenvolvimento, queremos salvar nossas alterações (talvez após uma tarefa ou problema específico).

O Git commit é como definir um ponto de verificação no processo de desenvolvimento ao qual você pode voltar mais tarde, se necessário.

Também precisamos escrever uma mensagem curta para explicar o que desenvolvemos ou mudamos no código-fonte.

git commit -m "commit message"

Importante: o Git commit salva suas alterações apenas localmente.

7. Git push

Depois de confirmar suas alterações, a próxima coisa que você deseja fazer é enviar suas alterações para o servidor remoto. Git push carrega seus commits para o repositório remoto (Github por exemplo).

git push <remote> <branch-name>

No entanto, se seu branch foi criado recentemente, você também precisa fazer o upload do branch com o seguinte comando:

git push --set-upstream <remote> <name-of-your-branch>

ou

git push -u origin <branch_name>

Importante: Git push carrega apenas as alterações que foram comitadas.

8. Git pull

O comando git pull é usado para obter atualizações do repo remoto. Este comando é uma combinação de git fetch e git merge, o que significa que, quando usamos git pull, ele obtém as atualizações do repositório remoto (git fetch) e aplica imediatamente as alterações mais recentes em seu local (git merge).

git pull <remote>

Esta operação pode causar conflitos que precisam ser resolvidos manualmente.

9. Git revert

Às vezes, precisamos desfazer as alterações que fizemos. Existem várias maneiras de desfazer nossas alterações local ou remotamente (depende do que precisamos), mas devemos usar cuidadosamente esses comandos para evitar exclusões indesejadas.

Uma maneira mais segura de desfazer nossos commits é usando git revert . Para ver nosso histórico de commits , primeiro precisamos usar git log - oneline:

Então, só precisamos especificar o código hash próximo ao nosso commit que gostaríamos de desfazer:

git revert 9561098

Depois disso, você verá uma tela como a abaixo - basta pressionar shift + q para sair:

O comando Git revert desfará o commit fornecido, mas criará um novo commit sem excluir o anterior:

A vantagem de usar git revert é que ele não altera o histórico de commits. Isso significa que você ainda pode ver todos os commits em seu histórico, mesmo os revertidos.

Outra medida de segurança aqui é que tudo acontece em nosso sistema local, a menos que enviemos para o repo remoto. É por isso que git revert é mais seguro de usar e é a forma preferida de desfazer nossos commits.

10. Git merge

Quando você tiver concluído o desenvolvimento em seu branch e tudo funcionar bem, a etapa final é mesclar o branch com o branch pai (dev ou master). Isso é feito com o git mergecomando.

O Git merge basicamente integra seu branch de recursos com todos os seus commits de volta para o branch dev (ou master). É importante lembrar que primeiro você precisa estar no branch específico que deseja mesclar com o branch de recurso.

Por exemplo, quando você deseja mesclar seu branch de recurso no branch de desenvolvimento:

Primeiro você deve mudar para o branch dev:

git checkout dev

Antes de mesclar, você deve atualizar seu branch de desenvolvimento local:

git fetch

Finalmente, você pode mesclar seu branch de recursos no dev:

Dica: certifique-se de que seu branch dev tenha a versão mais recente antes de mesclar seus branches, caso contrário, você pode enfrentar conflitos ou outros problemas indesejados.

git merge <branch-name>

Concluindo

Portanto, esses são 10 comandos git mais usados ​​que encontro em minha programação diária. Há muito mais coisas que o git é capaz de fazer, mas com esses 10 comandos em mente, você será capaz de se virar muito bem no uso diário.

Ficou com dúvida? sinta-se a vontate para me perguntar nos comentários!