Удалить все локальные ветки git windows

There will come a time when you optimize your workflow to ensure PR requests are as small as possible.
Each request can be minimal, so you end up with tons of new local branches that have probably already been merged.

Below is an example of my local daily.dev repo with all the branches I have locally.

Картинка с сайта: dev.to

Time to make some changes and clean up our mess.

Removing local git branches

We could go to the editor and click remove on the local branches.
However, we wouldn’t be developers if we didn’t use the terminal correctly.

To delete one local branch, we can use the following command.

git branch -d BRANCH_NAME

However, this will only work for merged branches. If you still want to proceed, you can use the capital D like this:

git branch -D BRANCH_NAME

Deleting all local branches

However, when we have many local branches, we might want to delete all of them at once.

For that, it’s important to note that the delete call can handle multiple files.

First, we have to find all the branches. I used the following command.

git branch | grep -v \*

However, this also includes our master/main branch.

git branch | grep -v "master\|main"

And if you only want to remove merged branches, you can use the following addition.

git branch --merged | grep -v "master\|main"

To execute deletion, we can pass another argument for the delete command.

git branch --merged | grep -v "master\|main" | xargs git branch -D

Conclusion

We can have many local branches that we might want to clean up in one go.

To delete a single branch, use the following command.

git branch -d BRANCH_NAME
# use -D for unmerged branches

If you want to delete all merged local branches except master/main, use the following command.

git branch --merged | grep -v "master\|main" | xargs git branch -D

Note: The above only deletes merged branches

If you want to delete all local branches except master/main, use the following.

git branch | grep -v "master\|main" | xargs git branch -D

Note: The above also deletes unmerged branches

Thank you for reading, and let’s connect!

Thank you for reading my blog. Feel free to subscribe to my email newsletter and connect on Facebook or Twitter

Оптимизировав рабочий процесс Git и приступив к пул-реквестам, вы обнаруживаете гору объединенных локальных веток, которые стоило бы удалить.  

Данное руководство научит не только с легкостью решать эту задачу, но и создавать псевдонимы Git (англ. alias) с возможностью повсеместного переиспользования. 

Удаление одной локальной ветки

Для удаления одной локальной ветки достаточно открыть интерфейс Git GUI и нажать delete применительно к выбранной ветке. 

Однако оправдаем свое звание разработчика, продемонстрировав умение работать с терминалом. 

Переключаемся на терминал и удаляем ветку следующей командой: 

git branch -d YOUR_BRANCH

К сожалению (или к счастью), команда подходит для удаления ветки, которая уже подверглась слиянию. При желании удалить ветку, которая еще не прошла эту процедуру, задействуем заглавную букву D:

git branch -D YOUR_BRANCH

Удаление всех локальных веток 

При наличии нескольких локальных веток целесообразно удалить все одной командой, а не применять delete к каждой по отдельности. 

Для реализации функции, выполняющей данную задачу, важно знать, что git branch -D может обрабатывать одновременно несколько файлов. 

С учетом этого сначала напишем команду для поиска всех веток в репозитории: 

git branch | grep -v \*

При выполнении данной команды в CLI вы увидите, что в поиск также включены главная и/или защищенные ветки: master, main, release и т.д. 

Вы можете настроить вышеуказанную команду под свои потребности (в данном случае main/master/develop). Рассмотрим пример: 

git branch | grep -v "main\|master\|develop"

Кроме того, можно добавить флаг --merged, ограничивающий поиск только объединенными ветками: 

git branch --merged | grep -v "main\|master\|develop"

Теперь передаем результат в команду delete, рассмотренную в предыдущем разделе: 

git branch --merged | grep -v "main\|master\|develop" | xargs git branch -D

Выполнение данной команды в любом репозитории Git (в котором main/master являются защищенной веткой) приведет к удалению всех объединенных веток, не имеющих локальных изменений. С помощью -d можно отменить команду, если вдруг вы забыли --merged.

Важное примечание 

Если при выполнении этого скрипта вы находитесь на измененной ветке, то операция закончится ошибкой not found (не найдено): 

error: branch '*' not found.

Во избежание данной проблемы скорректируем команду, добавив в конце \|*. Пример: 

git branch --merged | grep -v "main\|master\|develop\*" | xargs git branch -D

Создание псевдонима Git

Простые псевдонимы Git 

Псевдонимы Git  —  это функциональность, которая упрощает и оптимизирует работу с Git. Она объединяет команды в псевдоним, которым можно воспользоваться в любое время. 

Приведем примеры востребованных псевдонимов: 

• co для переключения веток и выгрузки их содержимого в рабочий каталог; 
• ci для коммита. 

Для настройки этих псевдонимов выполняем: 

git config --global alias.co checkout
git config --global alias.ci commit

К сожалению, простые псевдонимы Git не позволяют корректно задействовать оператор конвейера и передавать результаты одной команды в другую. 

К счастью, Git позволяет использовать оболочку в создании псевдонимов!

Сложные псевдонимы Git

С помощью оператора ! псевдонимы могут переходить в оболочку, открывая мир новых возможностей для работы с ними. Эта технология позволяет применять: 

• параметры и расширения оболочки; 
• многочисленные команды git; 
• утилиту grep, конвейеры (англ. pipe) и другие установленные инструменты командной строки Unix. 

Для создания нового псевдонима Git можно воспользоваться следующим шаблоном и добавить свою команду:  

fancy_alias = "!f() { (your complex commands here) }; f"

В этом псевдониме применяется простой прием обертывания фактической команды git в анонимную функцию bash (или, точнее сказать, в функцию с именем f()). При таком подходе получить доступ к переменным командной строки и расширениям оболочки можно следующим образом:

• использовать $1, $2 и $3 для первого, второго и третьего параметров, переданных в псевдоним Git; 
• связать команды git в цепочки с помощью &&;
• передать результаты по конвейеру посредством |;
• задействовать полный набор инструментов Unix.

Рассмотрим действие функциональности сложных псевдонимов Git на двух практических примерах: 

1. Показ коммитов с момента последней команды git 

git config --global alias.new = !sh -c 'git log $1@{1}..$1@{0} "$@"'

Данный псевдоним запускается в работу путем выполнения git new и предоставления HEAD:

git new HEAD

2. Добавление удаленного репозитория в локальный 

git config --global alias.ra = "!f() { git remote add $1 $2; }; f"

Псевдоним готов к работе после выполнения git ra и добавления имени и URL удаленного репозитория: 

git ra cool_remote [email protected]:paulknulst/nestjs-starter.git

Создание псевдонима для удаления веток 

Зная способ создания расширенного псевдонима Git, воспользуемся предыдущей информацией и обернем команду анонимной функцией bash с именем f():

'!f() { git branch --merged | grep -v "main\|master\|develop\|*" | xargs git branch -D; }; f'

Далее с помощью команды git config создаем глобальный псевдоним Git для пользователя, в настоящий момент вошедшего в систему: 

git config --global alias.clean-branches '!f() { git branch --merged | grep -v "main\|master\|develop\|*" | xargs git branch -D; }; f'

Заключение 

Бывает, что вы забываете удалять локальные ветки сразу же после закрытия пул-реквеста, и они со временем накапливаются. Возможно, удаленная ветка уже устранена, но зато ежедневно растет локальный каталог. К счастью, теперь вы знаете способ решения этой проблемы и можете реализовать его в CLI для удаления окончательно объединенных локальных веток.

Кроме того, вы научились использовать простые и сложные псевдонимы Git с оператором !, способствующие оптимизации рабочего процесса. 

Читайте также:

• Как написать хороший README: краткий курс
• 7 малоизвестных команд и приемов Git
• Руководство для начинающих по Git: что такое журнал изменений и как его создать

Читайте нас в Telegram, VK и Дзен

Перевод статьи Paul Knulst: How to Remove Local Git Branches by Creating Git Aliases

Being the most popular version control software in the world, Git is very good at providing developers with easy commands to manage branches of their Git repositories. A lot of the time, developers need to delete a local branch to clean their git repositories.

Luckily, this is very easy to do in Git.

To delete a local branch in git you need to use the git branch -d command.

bashgit branch -d your-branch

The rest of the article will explore the delete branch operation, as well as show you what to do in different situations that you may encounter while deleting a branch.

Let’s get to it 😎.

Картинка с сайта: timmousk.com

How to delete a branch in git?

To delete a local branch, you need to use the git branch -d command.

bashgit branch -d your-branch

This command might fail if you have changes that haven’t been merged to a local or remote branch. You will need to merge the branch first, and then repeat the command.

If, however, you want to force delete a branch that hasn’t been pushed or that has unmerged changes, you can use this command.

bashgit branch -D your-branch

Your branch is now deleted, but only locally. If you want to delete the branch remotely, you will need to use another command.

How to delete a remote git branch?

Картинка с сайта: timmousk.com

To delete a branch remotely you will first need to find out your remote repository name.

The remote name is usually origin, but it can also be different…

You can delete a remote branch, by using the git push command. (I assume that the remote name is origin)

bashgit push origin --delete your-branch

The branch is now deleted from your remote repository 😁.

But, what to do if you don’t remember the branch names that you have? In that case, you will need to list which branches exist both locally and remotely and then remove the unnecessary ones.

How to list all git branches?

Sometimes, we might have too many branches in our git repository to remember. That’s where the git branch command becomes handy.

Use the git branch command to list all local branches.

bashgit branch

To list all remote branches, use the git branch -r command.

bashgit branch -r

To list both local and remote branches, use the git branch -a command.

bashgit branch -a

Now that you have listed all the local branches, you can delete the ones that you do not need.

Картинка с сайта: timmousk.com

But, what if you want to delete all your local branches? This can be done using the bash grep command.

How to delete all local git branches?

Sometimes, you have so many locale git branches, that it’s just easier to delete them all.

Use a combination of the git branch —merged command with the bash grep command to delete all the merged branches.

Proceed with caution! This command will delete a lot of branches.

bashgit branch --merged | grep -v \* | xargs git branch -D

This command will delete all the branches that were merged.

If, however, you want to delete all the branches that are not present on the remote server you will need to use a different command.

How to delete branches that do no longer exist on the remote server?

To delete branches that are no longer present on the remote server, you will need to first, use this command.

bashgit remote prune origin

It will remove local references to remote branches that no longer exist.

Then, you will need to use this command (I know it’s a scary command).

bashgit fetch -p && git branch --merged | grep -v '*' | grep -v 'master' | xargs git branch -d

This command will delete all local branches that are not on the remote server and that are merged.

How to fix the ‘Cannot delete branch’ error?

To fix this annoying error you need to follow those steps:

1. Check if you are on the same branch that you are trying to delete… If you are, you need to switch branches, because you cannot delete a branch that you are currently on.
2. Check if you have created multiple worktrees… If you did, you will need to run git prune, before deleting the branch. You can also remove the .git/worktree/ folder and try to delete the branch again.

How to revert a deleted branch?

So you made an error. You deleted a branch that you weren’t supposed to. Don’t panic, it may be not as bad as it seems… In most cases, you can revert a deleted branch by going into your git reflog.

Картинка с сайта: timmousk.com

First, you need to go into your git reflog.

bashgit reflog

Then, find the last commit sha of the deleted branch and restore it with this command.

bashgit checkout -b <branch> <sha>

This command will restore your branch to its latest commit.

Final thoughts

As you can see deleting a branch in git is very easy, but you need to always triple-check that you are deleting the branch that you actually want to remove. Luckily when you make a mistake you can always go into your git reflog and revert it.

If you are interested in learning more about git, I have written a few tutorials on it.

Thank you for reading this article, I hoped you’ve enjoyed it and you understand git a little bit better.

Please share this article with your fellow coders.

Уровень сложностиСредний

Время на прочтение9 мин

Количество просмотров58K

Git стал стандартом де-факто в мире разработки программного обеспечения. Это мощная система контроля версий, которая позволяет командам эффективно сотрудничать, отслеживать изменения и управлять кодовой базой. Новичку Git может показаться сложным из-за обилия команд и концепций. Однако правда в том, что для выполнения 90% повседневных задач достаточно уверенно владеть небольшим набором ключевых команд.

В этой статье мы разберем 15 команд Git, которые покроют почти все ваши задачи. Понимание их работы, контекста использования и потенциальных подводных камней позволит вам чувствовать себя уверенно при работе с Git, будь то личный проект или крупный командный репозиторий. Постараюсь объяснить все как для самых маленьких.

Если вам интересен процесс и вы хотите следить за дальнейшими материалами, буду признателен за подписку на мой телеграм-канал. Там я публикую полезныe материалы по разработке, разборы сложных концепций, советы как быть продуктивным и конечно же отборные мемы: https://t.me/nullPointerDotEXE.

git clone

Эта команда используется для создания локальной копии удаленного репозитория. По сути, вы скачиваете всю историю проекта и рабочие файлы с сервера (например, с GitHub, GitLab, Bitbucket) на свой компьютер. Это самая первая команда, которую вы выполняете, когда начинаете работать с существующим проектом. Вы указываете URL репозитория, и Git создает папку с именем репозитория (если не указать другое имя) и загружает туда все необходимое.
Пример:

git clone https://github.com/имя_пользователя/имя_репозитория.git
# Или так, чтобы клонировать в папку с другим именем:
git clone https://github.com/имя_пользователя/имя_репозитория.git моя_папка_проекта

Просто убедитесь, что у вас есть права доступа к репозиторию, если он приватный. И помните, git clone автоматически настраивает связь с удаленным репозиторием под именем origin, что упрощает последующие push и pull.

git status

Ваш главный индикатор состояния репозитория. Эта команда показывает, какие файлы были изменены с момента последнего коммита, какие файлы готовы к коммиту , а какие файлы Git еще не отслеживает. Выполнять git status стоит часто – перед add, перед commit, после pull, чтобы всегда понимать, что происходит в вашем рабочем каталоге. Она не меняет ничего, только информирует.
Пример:

git status

Вывод покажет текущую ветку, наличие неотправленных коммитов и списки измененных, проиндексированных и неотслеживаемых файлов. Это ваша приборная панель в Git, не пренебрегайте ей. Если вывод кажется непонятным, значит, самое время разобраться, что именно изменилось.

git add

Эта команда добавляет изменения из рабочего каталога в так называемую «staging area». Staging area – это промежуточный этап перед созданием коммита. Вы сами выбираете, какие именно изменения войдут в следующий коммит. Это позволяет делать атомарные, логически завершенные коммиты, даже если вы внесли множество разных изменений в разные файлы. Можно добавлять файлы по одному, группами или все сразу.
Примеры:

# Добавить конкретный файл
git add имя_файла.txt

# Добавить все изменения в текущей папке и подпапках
git add .

# Добавить все измененные и новые файлы во всем репозитории
git add -A

# Интерактивно выбрать, какие части изменений в файле добавить
git add -p

Часто используется git add ., но будьте внимательны: эта команда добавит все изменения, включая случайные или временные файлы, если они не указаны в .gitignore. Использование git add -p очень полезно для ревью собственных изменений перед коммитом.

git commit

Фиксирует изменения, добавленные в staging area (git add), в локальной истории репозитория. Каждый коммит — это снимок состояния проекта в определенный момент времени, снабженный уникальным хешем и сообщением, описывающим суть изменений. Хорошее сообщение коммита критически важно для понимания истории проекта вами и вашей командой.
Примеры:

# Создать коммит с коротким сообщением прямо из командной строки
git commit -m "Исправлена опечатка в README"

# Открыть текстовый редактор для ввода подробного сообщения коммита
git commit

Старайтесь писать осмысленные сообщения коммитов. Стандартная практика — начинать с краткой строки (до 50 символов), описывающей суть, а затем, после пустой строки, добавлять более подробное описание, если это необходимо. Если вы забыли что-то добавить в последний коммит, можно использовать git commit --amend, но делайте это только с коммитами, которые еще не были отправлены на удаленный сервер (git push), иначе создадите проблемы коллегам.

git push

Отправляет ваши локальные коммиты на удаленный репозиторий (тот самый origin, который обычно настраивается при git clone). Это делает ваши изменения доступными для других членов команды. Вы указываете имя удаленного репозитория (обычно origin) и имя ветки, которую хотите отправить.
Примеры:

# Отправить изменения из текущей локальной ветки в одноименную ветку на origin
git push origin имя_ветки

# Более короткая версия, если upstream уже настроен (часто работает после первого push)
git push

Перед git push всегда полезно сделать git pull, чтобы убедиться, что ваша локальная версия ветки актуальна и избежать потенциальных конфликтов при отправке. Если Git откажется пушить из-за расхождения историй, вам сначала нужно будет интегрировать эти удаленные изменения (git pull).

git pull

Забирает изменения с удаленного репозитория и пытается слить их с вашей текущей локальной веткой. По сути, это комбинация двух других команд: git fetch (скачивает изменения, но не применяет их) и git merge (сливает скачанные изменения с вашей веткой). Это стандартный способ обновить вашу локальную копию проекта последними изменениями от коллег.
Примеры:

# Скачать изменения из ветки 'main' репозитория 'origin' и слить их с текущей локальной веткой
git pull origin main

# Короткая версия, если upstream настроен для текущей ветки
git pull

Будьте готовы к тому, что git pull может привести к конфликтам слияния, если вы и кто-то другой редактировали одни и те же участки кода в разных коммитах. Git сообщит об этом и отметит конфликтующие места в файлах. Вам нужно будет вручную разрешить эти конфликты, затем добавить (git add) исправленные файлы и завершить слияние (часто это делается новым коммитом). Иногда вместо merge при pull используется rebase (git pull --rebase), что сохраняет историю более линейной.

git branch

Управляет ветками в вашем репозитории. Ветки — это независимые линии разработки, позволяющие работать над новой функциональностью или исправлением ошибок, не затрагивая основной стабильный код (например, в ветке main или master). Команда git branch без аргументов покажет список всех локальных веток и отметит текущую звездочкой.
Примеры:

# Показать все локальные ветки
git branch

# Создать новую ветку с именем 'new-feature'
git branch new-feature

# Удалить ветку (безопасно - не даст удалить, если изменения не слиты)
git branch -d old-feature

# Удалить ветку принудительно (опасно - можно потерять изменения)
git branch -D very-old-feature

# Показать все ветки (локальные и удаленные)
git branch -a

Создание веток — дешевая операция в Git. Не бойтесь создавать их для каждой новой задачи. Это изолирует вашу работу и упрощает процесс ревью и слияния кода. Следите за количеством старых веток и удаляйте те, что уже не нужны, чтобы не захламлять репозиторий.

git checkout

Эта команда используется для переключения между ветками или восстановления файлов в рабочем каталоге до состояния из определенного коммита или индекса. Это одна из самых многозадачных (и потому иногда путающих) команд в Git. Основное применение — переход на другую ветку для работы над ней.
Примеры:

# Переключиться на существующую ветку 'develop'
git checkout develop

# Создать новую ветку 'hotfix' и сразу переключиться на неё
git checkout -b hotfix

# Отменить изменения в файле 'config.yml' до состояния последнего коммита
git checkout -- config.yml

Использование git checkout -- файл опасно, так как отменяет все незакоммиченные изменения в файле безвозвратно. Будьте уверены, что делаете это намеренно. Из-за многозначности checkout, в новых версиях Git появились команды git switch (для переключения веток) и git restore (для восстановления файлов), которые делают код более читаемым и безопасным. Но checkout всё ещё очень распространён.

git switch

Более современная и безопасная альтернатива git checkout для переключения между ветками. Эта команда создана специально для работы с ветками, что делает намерения в коде более ясными и снижает риск случайной потери данных при восстановлении файлов (так как switch этим не занимается).
Примеры:

# Переключиться на существующую ветку 'feature/auth'
git switch feature/auth

# Создать новую ветку 'bugfix/login-issue' и переключиться на неё
git switch -c bugfix/login-issue

# Вернуться на предыдущую ветку
git switch -

Если вы используете свежую версию Git, рекомендуется отдавать предпочтение git switch для переключения веток вместо git checkout. Это делает ваши скрипты и ручные операции более понятными и менее подверженными ошибкам.

git merge

Сливает изменения из одной ветки в другую. Обычно вы переключаетесь на ветку, в которую хотите влить изменения (например, main или develop), а затем выполняете git merge с указанием ветки, из которой хотите забрать изменения (например, ваша feature ветка). Git попытается автоматически объединить истории.
Пример:

# Переключаемся на основную ветку
git switch main

# Вливаем изменения из ветки 'new-feature' в 'main'
git merge new-feature

Если конфликтов нет, Git создаст новый «коммит слияния» (merge commit), у которого будет два родительских коммита. Если есть конфликты, Git остановит процесс, отметит конфликты в файлах, и вам нужно будет разрешить их вручную, добавить исправленные файлы (git add) и завершить слияние командой git commit. Слияние — ключевой процесс интеграции работы разных разработчиков или разных фич.

git rebase

Альтернатива merge. Позволяет «переписать» историю, подставив коммиты ветки поверх другой. Используется для чистой истории без лишних merge-коммитов. Пример:

git checkout feature #переключаемся на ветку
git rebase main #так же вливаем изменения

После завершения — git push --force, если история уже была опубликована.

git log

Показывает историю коммитов текущей ветки, начиная с самого последнего. Вы увидите хеш каждого коммита, автора, дату и сообщение коммита. Это основной инструмент для изучения истории проекта, понимания, кто и когда внес определенные изменения. git log имеет множество опций для форматирования вывода.
Примеры:

# Показать стандартный лог
git log

# Показать лог в более компактном виде (одна строка на коммит)
git log --oneline

# Показать лог с графическим представлением веток и слияний
git log --graph --oneline --decorate

# Показать лог изменений для конкретного файла
git log имя_файла.py

# Показать последние 5 коммитов
git log -n 5

Изучение git log и его опций — очень полезный навык. Он помогает не только смотреть историю, но и находить конкретные коммиты, например, чтобы отменить их (git revert) или посмотреть изменения (git show ).

git diff

Показывает разницу между различными состояниями: между рабочим каталогом и индексом (staging area), между индексом и последним коммитом, между двумя коммитами или ветками. Это незаменимый инструмент для просмотра изменений перед их добавлением (git add) или коммитом (git commit).
Примеры:

# Показать изменения в рабочем каталоге, которые еще НЕ добавлены в индекс (unstaged changes)
git diff

# Показать изменения, которые добавлены в индекс, но еще НЕ закоммичены (staged changes)
git diff --staged
# или
git diff --cached

# Показать разницу между двумя коммитами
git diff  

# Показать разницу между двумя ветками
git diff main develop

Используйте git diff перед git add . или git commit -a, чтобы точно понимать, какие изменения вы собираетесь зафиксировать. Это помогает избежать случайного коммита отладочного кода или нежелательных изменений. Также git diff часто используется при код-ревью для просмотра конкретных изменений между ветками.

git stash

Временно сохраняет ваши незакоммиченные изменения (как из рабочего каталога, так и из индекса), чтобы вы могли переключиться на другую ветку или выполнить другую операцию, не теряя свою текущую работу. Это как положить свою работу на полку, чтобы потом вернуться к ней. После того как вы закончили с другими делами, вы можете вернуть сохраненные изменения обратно.
Примеры:

# Сохранить текущие незакоммиченные изменения в 'stash'
git stash save "Работа над интерфейсом пользователя" # Необязательное сообщение

# Показать список сохраненных состояний ('stashes')
git stash list

# Применить последние сохраненные изменения и удалить их из списка stash
git stash pop

# Применить последние сохраненные изменения, но оставить их в списке stash
git stash apply

# Удалить последнее сохраненное состояние из списка
git stash drop

git stash — это спасение, когда вам срочно нужно переключиться на другую задачу (например, исправить баг в продакшене), но ваша текущая работа еще не готова к коммиту. Только не забывайте про сохраненные изменения в stash, со временем там может накопиться много всего, и будет сложно вспомнить, что к чему относится.

git reset

Команда с несколькими режимами, используемая в основном для отмены изменений. Она может перемещать указатель HEAD (и текущей ветки) на другой коммит, а также опционально изменять индекс (staging area) и рабочий каталог. Это мощная, но потенциально опасная команда, особенно в режиме --hard.
Примеры:

# Отменить 'git add' для файла (убрать из индекса, но оставить изменения в рабочем каталоге)
git reset HEAD имя_файла
# или более современный вариант: git restore --staged имя_файла

# Откатить последний коммит, но оставить изменения в рабочем каталоге и индексе (--soft)
git reset --soft HEAD~1

# Откатить последний коммит, оставить изменения в рабочем каталоге, но убрать из индекса (--mixed - это режим по умолчанию)
git reset HEAD~1

# Откатить последний коммит И УДАЛИТЬ все связанные с ним изменения из рабочего каталога и индекса (--hard - ОПАСНО!)
git reset --hard HEAD~1

Используйте git reset с осторожностью, особенно --hard, так как он безвозвратно удаляет незакоммиченные изменения. git reset также используется для отмены коммитов, которые еще не были отправлены на удаленный сервер. Если коммит уже опубликован (git push), для его отмены лучше использовать git revert, чтобы не переписывать общую историю.

Что дальше?

Освоив эти 15 команд, вы действительно сможете решать почти все задачи разработчика, связанных с Git. Практикуйтесь: создайте тестовый репозиторий, экспериментируйте с ветками, слияниями, отменой изменений. Понимание приходит с опытом.

Git — мощный инструмент, и его изучение может продолжаться долго. Но шпаргалка из этих 15 команд позволит вам уверенно навигировать в мире контроля версий и эффективно сотрудничать с другими разработчиками. Гудлак!

Управление ветками

Теперь, когда вы уже попробовали создавать, объединять и удалять ветки, пора познакомиться с некоторыми инструментами для управления ветками, которые вам пригодятся, когда вы начнёте использовать ветки постоянно.

Команда git branch делает несколько больше, чем просто создаёт и удаляет ветки.
При запуске без параметров, вы получите простой список имеющихся у вас веток:

$ git branch
  iss53
* master
  testing

Обратите внимание на символ *, стоящий перед веткой master: он указывает на ветку, на которой вы находитесь в настоящий момент (т. е. ветку, на которую указывает HEAD).
Это означает, что если вы сейчас сделаете коммит, ветка master переместится вперёд в соответствии с вашими последними изменениями.
Чтобы посмотреть последний коммит на каждой из веток, выполните команду git branch -v:

$ git branch -v
  iss53   93b412c Fix javascript issue
* master  7a98805 Merge branch 'iss53'
  testing 782fd34 Add scott to the author list in the readme

Опции --merged и --no-merged могут отфильтровать этот список для вывода только тех веток, которые слиты или ещё не слиты в текущую ветку.
Чтобы посмотреть те ветки, которые вы уже слили с текущей, можете выполнить команду git branch --merged:

$ git branch --merged
  iss53
* master

Ветка iss53 присутствует в этом списке потому что вы ранее слили её в master.
Те ветки из этого списка, перед которыми нет символа *, можно смело удалять командой git branch -d; наработки из этих веток уже включены в другую ветку, так что ничего не потеряется.

Чтобы увидеть все ветки, содержащие наработки, которые вы пока ещё не слили в текущую ветку, выполните команду git branch --no-merged:

$ git branch --no-merged
  testing

Вы увидите оставшуюся ветку.
Так как она содержит ещё не слитые наработки, попытка удалить её командой git branch -d приведёт к ошибке:

$ git branch -d testing
error: The branch 'testing' is not fully merged.
If you are sure you want to delete it, run 'git branch -D testing'.

Если вы действительно хотите удалить ветку вместе со всеми наработками, используйте опцию -D, как указано в подсказке.

$ git checkout testing
$ git branch --no-merged master
  topicA
  featureB

$ git branch --move bad-branch-name corrected-branch-name

$ git push --set-upstream origin corrected-branch-name

$ git branch --all
* corrected-branch-name
  main
  remotes/origin/bad-branch-name
  remotes/origin/corrected-branch-name
  remotes/origin/main

$ git push origin --delete bad-branch-name

$ git branch --move master main

$ git push --set-upstream origin main

$ git branch --all
* main
  remotes/origin/HEAD -> origin/master
  remotes/origin/main
  remotes/origin/master

$ git push origin --delete master