Överföra oengagerade ändringar till en ny Git-gren

Skapa en ny filial för ditt oengagerade arbete

När man utvecklar nya funktioner är det vanligt att inse att förändringarna bör isoleras i sin egen gren. Detta möjliggör bättre organisation och parallell utveckling. Om du har börjat arbeta på en ny funktion och halvvägs bestämmer dig för att den ska ligga i en separat gren, erbjuder Git ett enkelt sätt att överföra dessa oengagerade ändringar.

I den här artikeln guidar vi dig genom processen att flytta ditt befintliga, oengagerade arbete till en ny filial. Dessutom kommer du att lära dig hur du återställer din nuvarande gren utan att förlora några av dina framsteg. Detta säkerställer att ditt arbetsflöde förblir rent och effektivt.

Förstå Git-arbetsflödet för att hantera oengagerat arbete

I det första skriptexemplet flyttar vi manuellt oengagerade ändringar till en ny gren med hjälp av en serie Git-kommandon. Processen börjar med git checkout -b new-feature-branch, som skapar en ny gren som heter "new-feature-branch" och växlar till den. Detta är viktigt för att isolera den nya funktionens arbete från huvudgrenen. Därefter iscensätter vi alla oengagerade förändringar med git add .. Detta kommando säkerställer att alla modifierade och nya filer är förberedda för commit. Efter detta har git commit -m "Move uncommitted work to new feature branch" kommandot begår dessa ändringar till den nya grenen med ett meddelande som förklarar åtgärden.

Efter att ha säkrat ändringarna i den nya grenen återgår vi till den ursprungliga grenen med git checkout original-branch. För att återställa den ursprungliga grenen till dess tidigare tillstånd använder vi git reset --hard HEAD~1. Detta kommando återställer kraftfullt grenen till den föregående commit, och kasserar alla ändringar som gjorts sedan dess. Denna serie av kommandon säkerställer att arbetet med den nya funktionen bevaras i sin egen gren medan den ursprungliga grenen återställs till ett rent tillstånd.

Automatisera processen med ett Shell-skript

Det andra skriptexemplet automatiserar denna process med hjälp av ett skalskript. Skriptet börjar med att kontrollera om ett nytt filialnamn har försetts med if [ -z "$1" ]; then, som lämnar skriptet om inget namn anges. Variabeln NEW_BRANCH=$1 tilldelar det angivna grennamnet till en variabel. Skriptet skapar sedan och växlar till denna nya gren med git checkout -b $NEW_BRANCH. Alla oengagerade förändringar är iscensatta med hjälp av git add ., och engagerad med git commit -m "Move uncommitted work to $NEW_BRANCH".

Efter att ha utfört ändringarna växlar skriptet tillbaka till föregående gren med hjälp av git checkout -. Det sista kommandot git reset --hard HEAD~1 återställer den ursprungliga grenen till dess tidigare commit, och säkerställer att den är ren och fri från ändringarna som flyttades till den nya grenen. Detta skalskript ger ett bekvämt sätt att automatisera processen att flytta oengagerat arbete till en ny gren och återställa den nuvarande grenen, vilket gör det lättare att hantera ditt arbetsflöde i 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

Skapa och hantera funktionsgrenar i Git

När du arbetar med Git är det viktigt att hålla ditt arbetsflöde organiserat, speciellt när du utvecklar nya funktioner. En bästa praxis är att använda funktionsgrenar. En funktionsgren låter dig arbeta med en ny funktion oberoende av huvudkodbasen. Denna isolering hjälper till att förhindra att ofullbordad eller instabil kod påverkar huvudgrenen. För att skapa en funktionsgren, använd kommandot git checkout -b feature-branch. Detta skapar inte bara grenen utan växlar dig också till den, vilket säkerställer att allt nytt arbete görs i rätt sammanhang.

När du har skapat din funktionsgren kan du arbeta med din nya funktion utan att påverka huvudgrenen. Detta är särskilt användbart i en samarbetsmiljö där flera utvecklare arbetar med olika funktioner samtidigt. När din funktion är färdig och noggrant testad kan du slå ihop den tillbaka till huvudgrenen med hjälp av git merge feature-branch. På så sätt innehåller huvudgrenen endast stabil och komplett kod. Om du behöver uppdatera din funktionsgren med de senaste ändringarna från huvudgrenen kan du använda git rebase main medan du är på din funktionsgren, se till att den är uppdaterad.