Neste tutorial, abordaremos um cenário hipotético que envolve várias etapas de trabalho com o Git. Vamos seguir suas solicitações e utilizar o padrão gráfico fornecido para ilustrar as ações realizadas em cada etapa.
Esse tutorial faz parte de um treinamento mais completo de Git & GitHub. >> Clique Aqui << para conhecer.
Parte 1: Iniciando no Branch Main e Criando Commits
Vamos começar no branch “main” e criar três commits:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
$ mkdir MeuProjeto $ cd MeuProjeto $ git init # Criar e adicionar arquivos $ touch arquivo1.txt $ git add arquivo1.txt $ git commit -m "Commit 1: Adicionar arquivo1.txt" # Adicionar mais conteúdo $ echo "Conteúdo do arquivo 1" >> arquivo1.txt $ git commit -am "Commit 2: Adicionar conteúdo ao arquivo1.txt" # Adicionar outro arquivo $ touch arquivo2.txt $ git add arquivo2.txt $ git commit -m "Commit 3: Adicionar arquivo2.txt" |
Graficamente, nesse momento temos algo mais ou menos assim:
|
1 2 3 4 5 6 |
main | HEAD | A -- B -- C |
Parte 2: Trabalhando no Branch Frontend e Utilizando Git Stash
Agora vamos criar o branch “frontend” e fazer algumas alterações nele:
|
1 2 3 |
$ git branch frontend $ git checkout frontend |
Graficamente, nesse momento temos algo mais ou menos assim:
|
1 2 3 4 5 6 7 |
main | A -- B -- C \ HEAD | (frontend) |
Adicione novos arquivos e faça commits no branch “frontend”:
|
1 2 3 4 5 6 7 8 9 |
$ touch index.html $ touch style.css $ git add index.html style.css $ git commit -m "Commit 4: Adicionar arquivos do frontend" $ echo "conteudo index.html" >> index.html $ echo "conteudo sytle.css" >> style.css $ git commit -am "Commit 5: Adicionar conteúdo inicial aos arquivos" |
Modifique os arquivos, mas não faça commit ainda:
|
1 2 |
$ echo "Conteudo index.html modificado" >> index.html $ echo "Conteudo style.css modificado" >> style.css |
Agora, vamos supor que alguém pediu para você parar de trabalhar no branch de frontend para corrigir problemas no branch main. Você não quer fazer commit mas também não quer perder as alterações.
Use o git stash para guardar as alterações temporariamente:
|
1 2 |
$ git stash save "Alterações incompletas no frontend" |
Parte 3: Voltando ao Branch Main e Realizando um Commit
|
1 |
$ git checkout main |
Graficamente, nesse momento temos algo mais ou menos assim:
|
1 2 3 4 5 6 7 8 9 10 |
main | HEAD | A -- B -- C \ | (frontend) \__D__E |
Faça uma modificação no arquivo do branc main e faça commit:
|
1 2 |
$ echo "Nova linha de conteúdo" >> arquivo1.txt $ git commit -am "Commit 6: Modificar arquivo1.txt" |
Graficamente, nesse momento temos algo mais ou menos assim:
|
1 2 3 4 5 6 7 8 9 10 |
main | HEAD | A -- B -- C -- -- -- F \ | (frontend) \__D__E |
Parte 4: Voltando ao Branch Frontend e Aplicando Git Stash
Agora vamos voltar ao branch “frontend”:
|
1 |
$ git checkout frontend |
Graficamente, nesse momento temos mais ou menos o desenho a seguir:
|
1 2 3 4 5 6 7 8 9 10 11 |
MAIN | A -- B -- C -- -- -- F \ | (frontend) \__D__E | HEAD |
Vamos recuperar as modificações que guardamos no passo 2 quando usamos o comando “git stash”
|
1 2 |
$ git stash pop |
Faça o commit das alterações recuperadas:
|
1 2 |
$ git commit -am "Commit 7: Continuar desenvolvimento no frontend" |
Parte 5: Finalizando com o Merge
Agora você pode voltar para o branch main e fazer o merge:
|
1 2 3 |
$ git checkout main $ git merge frontend |
O merge será realizado sem conflitos, pois as alterações feitas no branch “main” foram isoladas das alterações no branch “frontend” pelo uso do git stash.
Conclusão
Neste tutorial, seguimos suas solicitações e gerenciamos mudanças entre branches, utilizando o git stash para guardar alterações temporariamente. Ao aplicar esses conceitos, você poderá trabalhar de forma eficiente em projetos complexos, lidando com situações onde mudanças incompletas precisam ser temporariamente guardadas. O Git oferece poderosas ferramentas para auxiliar no gerenciamento e colaboração em projetos de desenvolvimento.
