Transferindo alterações não confirmadas para uma nova ramificação do Git

Configurando uma nova filial para seu trabalho não comprometido

Ao desenvolver novas funcionalidades, é comum perceber que as alterações devem ser isoladas em seu próprio branch. Isso permite uma melhor organização e desenvolvimento paralelo. Se você começou a trabalhar em um novo recurso e decidiu no meio do caminho que ele deveria residir em um branch separado, o Git fornece uma maneira direta de transferir essas alterações não confirmadas.

Neste artigo, iremos guiá-lo através do processo de transferência do seu trabalho existente e não comprometido para uma nova filial. Além disso, você aprenderá como redefinir seu branch atual sem perder nenhum progresso. Isso garante que seu fluxo de trabalho permaneça limpo e eficiente.

Compreendendo o fluxo de trabalho do Git para gerenciar trabalho não comprometido

No primeiro exemplo de script, movemos manualmente as alterações não confirmadas para um novo branch usando uma série de comandos Git. O processo começa com git checkout -b new-feature-branch, que cria um novo branch chamado "new-feature-branch" e muda para ele. Isto é essencial para isolar o trabalho do novo recurso do branch principal. A seguir, preparamos todas as alterações não confirmadas com git add .. Este comando garante que todos os arquivos novos e modificados estejam preparados para confirmação. Seguindo isso, o git commit -m "Move uncommitted work to new feature branch" O comando confirma essas alterações no novo branch com uma mensagem explicando a ação.

Depois de garantir as alterações no novo branch, voltamos ao branch original com git checkout original-branch. Para redefinir o branch original ao seu estado anterior, usamos git reset --hard HEAD~1. Este comando redefine forçosamente o branch para o commit anterior, descartando quaisquer alterações feitas desde então. Esta série de comandos garante que o trabalho no novo recurso seja preservado em sua própria ramificação enquanto a ramificação original é redefinida para um estado limpo.

Automatizando o Processo com um Shell Script

O segundo exemplo de script automatiza esse processo usando um script de shell. O script começa verificando se um novo nome de branch foi fornecido com if [ -z "$1" ]; then, que sai do script se nenhum nome for fornecido. A variável NEW_BRANCH=$1 atribui o nome da ramificação fornecida a uma variável. O script então cria e alterna para esse novo branch com git checkout -b $NEW_BRANCH. Todas as alterações não confirmadas são preparadas usando git add ., e comprometido com git commit -m "Move uncommitted work to $NEW_BRANCH".

Depois de confirmar as alterações, o script volta para o branch anterior usando git checkout -. O comando final git reset --hard HEAD~1 redefine o branch original para seu commit anterior, garantindo que ele esteja limpo e livre das alterações que foram movidas para o novo branch. Este script de shell fornece uma maneira conveniente de automatizar o processo de movimentação de trabalho não confirmado para uma nova ramificação e redefinição da ramificação atual, facilitando o gerenciamento de seu fluxo de trabalho no Git.

# Step 1: Create a new branch and switch to it
git checkout -b new-feature-branch

# Step 2: Stage all uncommitted changes
git add .

# Step 3: Commit the staged changes
git commit -m "Move uncommitted work to new feature branch"

# Step 4: Switch back to the original branch
git checkout original-branch

# Step 5: Reset the original branch to the previous commit
git reset --hard HEAD~1

#!/bin/bash

# Check if the user provided a branch name
if [ -z "$1" ]; then
  echo "Usage: $0 <new-branch-name>"
  exit 1
fi

NEW_BRANCH=$1

# Create and switch to the new branch
git checkout -b $NEW_BRANCH

# Stage all uncommitted changes
git add .

# Commit the changes
git commit -m "Move uncommitted work to $NEW_BRANCH"

# Switch back to the original branch
git checkout -

# Reset the original branch
git reset --hard HEAD~1

Criando e gerenciando ramificações de recursos no Git

Ao trabalhar com Git, é importante manter seu fluxo de trabalho organizado, especialmente ao desenvolver novos recursos. Uma prática recomendada é usar ramificações de recursos. Uma ramificação de recursos permite que você trabalhe em um novo recurso independentemente da base de código principal. Esse isolamento ajuda a evitar que códigos inacabados ou instáveis ​​afetem a ramificação principal. Para criar uma ramificação de recurso, use o comando git checkout -b feature-branch. Isso não apenas cria o branch, mas também direciona você para ele, garantindo que qualquer novo trabalho seja feito no contexto correto.

Depois de criar seu branch de recursos, você poderá trabalhar em seu novo recurso sem afetar o branch principal. Isto é particularmente útil em um ambiente colaborativo onde vários desenvolvedores trabalham em diferentes recursos simultaneamente. Quando seu recurso estiver completo e exaustivamente testado, você poderá mesclá-lo novamente no branch principal usando git merge feature-branch. Dessa forma, o branch principal contém apenas código estável e completo. Se precisar atualizar seu branch de recursos com as alterações mais recentes do branch principal, você pode usar git rebase main enquanto estiver em sua ramificação de recursos, garantindo que esteja atualizado.