# List all branches
git branch

# List with last commit
git branch -v

# List all branches (including remote)
git branch -a

# Create a new branch
git branch feature/user-auth

# Create and switch to it
git checkout -b feature/user-auth

# Modern syntax (Git 2.23+)
git switch -c feature/user-auth

# Switch to existing branch
git checkout main
# or
git switch main

# Switch to previous branch
git checkout -

# Feature branches
git checkout -b feature/add-login
git checkout -b feature/payment-integration

# Bug fixes
git checkout -b fix/login-timeout
git checkout -b fix/memory-leak

# Hotfixes (urgent production fixes)
git checkout -b hotfix/security-patch

# Release branches
git checkout -b release/v1.2.0

# Experimental
git checkout -b experiment/new-architecture

# On main branch
git checkout main

# Merge feature branch
git merge feature/user-auth

Before:
main:    A---B
              \
feature:       C---D

After (fast-forward):
main:    A---B---C---D

git checkout main
git merge feature/user-auth

Before:
main:    A---B---E
              \
feature:       C---D

After (merge commit):
main:    A---B---E---M
              \     /
feature:       C---D

git merge feature/redesign
# Auto-merging index.html
# CONFLICT (content): Merge conflict in index.html
# Automatic merge failed; fix conflicts and then commit the result.

<<<<<<< HEAD
<h1>Welcome to My Site</h1>
=======
<h1>Welcome to Our Platform</h1>
>>>>>>> feature/redesign

# Use a visual merge tool
git mergetool

# Abort the merge
git merge --abort

# See conflicts
git diff --name-only --diff-filter=U

# Delete a merged branch
git branch -d feature/user-auth

# Force delete (even if not merged)
git branch -D experiment/failed-idea

# Delete remote branch
git push origin --delete feature/user-auth

# Branches merged into current branch
git branch --merged

# Branches not yet merged
git branch --no-merged

# Branches with last commit info
git branch -vv

# Rename current branch
git branch -m new-name

# Rename another branch
git branch -m old-name new-name

# 1. Create feature branch from main
git checkout main
git pull origin main
git checkout -b feature/add-comments

# 2. Work on feature
# ... make changes ...
git add .
git commit -m "feat: add comment system"

# 3. Keep feature branch updated
git checkout main
git pull origin main
git checkout feature/add-comments
git merge main  # Or rebase

# 4. Push and create pull request
git push origin feature/add-comments
# Create PR on GitHub/GitLab

# 5. After PR is merged, clean up
git checkout main
git pull origin main
git branch -d feature/add-comments

# Main branches: main (production), develop (integration)

# Start a feature
git checkout develop
git checkout -b feature/new-feature

# Finish feature -- always use --no-ff (no fast-forward)
# --no-ff forces a merge commit even when fast-forward is possible.
# Why? Because the merge commit preserves the fact that a feature branch
# existed. Without it, the feature commits blend into develop's history
# and you lose the "this group of commits was one feature" context.
git checkout develop
git merge --no-ff feature/new-feature
git branch -d feature/new-feature

# Start a release -- branch off develop when it has enough features for a release
git checkout -b release/1.2.0 develop
# ... version bumps, last-minute bug fixes, changelog updates ...
# Only bug fixes allowed here -- no new features. This is the "stabilization" phase.
git checkout main
git merge --no-ff release/1.2.0
git tag -a v1.2.0 -m "Release version 1.2.0"
# Merge back to develop so bug fixes from the release branch are not lost
git checkout develop
git merge --no-ff release/1.2.0
git branch -d release/1.2.0

# Hotfix -- branch off main for urgent production fixes
git checkout -b hotfix/1.2.1 main
# ... apply the fix ...
git checkout main
git merge --no-ff hotfix/1.2.1
git tag -a v1.2.1 -m "Hotfix: critical security patch"
# Merge back to develop so the fix is included in future releases
git checkout develop
git merge --no-ff hotfix/1.2.1
git branch -d hotfix/1.2.1

# Short-lived branch (merged same day, ideally within hours)
git checkout main
git pull origin main
git checkout -b quick-fix
# ... make changes (keep them small -- under 200 lines ideally) ...
git commit -am "fix: resolve login issue"
git push origin quick-fix
# Immediate merge after CI passes -- no week-long review cycles

# Incomplete features use feature flags, not long-lived branches.
# The code ships to production but is hidden until the flag is enabled.
# if (featureFlags.isEnabled('new-checkout-flow')) { ... }

git merge feature/new-ui
# Creates a merge commit

# Squash takes ALL commits from the feature branch and stages them
# as a single set of changes -- you then write one clean commit message.
git merge --squash feature/new-ui
git commit -m "feat: add new UI design"

git checkout feature/new-ui
git rebase main
# Replays feature commits on top of main

# Start feature
git checkout -b feature/dark-mode

# Make commits
echo "dark theme CSS" > dark.css
git add dark.css
git commit -m "feat: add dark mode styles"

echo "toggle button" > toggle.js
git add toggle.js
git commit -m "feat: add dark mode toggle"

# Merge to main
git checkout main
git merge feature/dark-mode

# Clean up
git branch -d feature/dark-mode

# Create conflict scenario
git checkout -b branch-a
echo "Version A" > file.txt
git add file.txt
git commit -m "Add version A"

git checkout main
git checkout -b branch-b
echo "Version B" > file.txt
git add file.txt
git commit -m "Add version B"

# Try to merge
git checkout main
git merge branch-a  # Success
git merge branch-b  # CONFLICT!

# Resolve
# Edit file.txt, choose version
git add file.txt
git commit

# Clean up
git branch -d branch-a branch-b

# Option 1: Commit changes (if the work is meaningful, even if incomplete)
git add .
git commit -m "WIP: work in progress"

# Option 2: Stash changes (preferred for quick context switches)
# Stash shelves your changes temporarily so you can come back later
git stash save "WIP: halfway through payment form"
git checkout other-branch
# ... do your work on the other branch ...
git checkout original-branch
git stash pop  # Restore your shelved changes

# Keep their version (the branch you are merging in)
git checkout --theirs file.png
git add file.png

# Keep our version (the branch you are currently on)
git checkout --ours file.png
git add file.png

# First, note the commit hash from git log
git log --oneline -3

# Move commit to the correct branch
git checkout correct-branch
git cherry-pick abc123  # SHA of the commit -- creates a copy on this branch

# Remove from wrong branch
git checkout wrong-branch
git reset --hard HEAD~1  # WARNING: this discards the commit from this branch