Удаление ветки git: Как удалить ветку в Git

Содержание

Как удалить ветку в GIT, примеры на локальном и удалённом репозитории

Вам когда-нибудь приходилось создавать промежуточную ветку в ГИТ, чтобы сохранить изменения, а после определённых действий, надобность в этой ветке пропадала? Так бывает очень часто, когда, либо создаёшь временную ветку, чтобы переместить коммиты в другую, либо ветка была создана по ошибке. И в этой статье я покажу несколько советов, как удалить локальную ветку GIT, и как удалить удалённую ветку.

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

Чтобы удалить локальную ветку GIT, вы можете выполнить одну из следующих команд:

git branch -d branch_name
git branch -D branch_name

Как вы можете заметить, эти команды, в разных вариациях использования, имеют 2 разных аргумента, d и D.

Параметр -d означает --delete, который удалит локальную ветвь, только в случае, если вы смерджили её с какой-то из веток.

Опция -D обозначает --delete --force, которая удаляет ветку независимо от ее статуса push или merge, так что будьте осторожны при её использовании!

Удаление удалённой ветки GIT

Для того, чтобы удалить ветку, уже опубликованную в удалённом репозитории (например, в Bitbucket, GitHub, GitLab), вы можете использовать следующую команду:

git push <remote_repository_name> --delete <branch_name>

Или же, есть ещё одна опция, которую, возможно, будет немного сложнее запомнить:

git push <remote_repository_name> :<branch_name>

Эти основные параметры также могут быть использованы, если вы хотите удалить «тег».

В большинстве случае использования, в качестве remote_branch_name используется origin.
К примеру, код будет выглядеть так: git push origin --delete tests

В некоторых случаях бывает, что при попытке выполнить запрос на удаление ветки, получаем ошибку fatal: 'origin' does not appear to be a git repository fatal: Could not read from remote repository.
Это значит, что мы вводим неправильное имя удалённой ветки.

Это имя задаётся при добавлении удалённого репозитория к себе в проект. К примеру, выполняя эту команду на добавления удалённого репозитория он будет сохранён под именем origin:

git remote add origin https://github.com/truehero/test.git

Но этот же репозиторий мы можем сохранить под любым другим именем, к примеру, выполнив команду:

git remote add test_project https://github.com/truehero/test.git

Уже сможем обращаться к этому репозиторию по имени test_project.

Потому, чтобы избавиться от этой ошибки, достаточно либо сохранить этот репозиторий под именем origin, либо обращаться к этому репозиторию по его реальному имени.

Если вы получили такую ошибку, но не помните, какое имя вы присваивали этому репозиторию, выполните команду: git remote, которая покажет список актуальных удалённых репозиториев и их имена.

Или же, если вы используете PHPStorm для работы, можете зайти во вкладку меню VCS > Git > Remotes, где сможете увидеть список всех удалённых репозиториев:
И тут вы и можете подсмотреть имя, которое нужно для обращений к репозиторию. К примеру, как показано у меня на скрине, у меня один репозиторий, который имеет имя tests, потому для удаления ветки в этом репозитории нужно выполнить команду

git push tests --delete useless-branch

Добавить коммиты на удаленную ветку и сразу удалить ветку локально

Если вам когда-нибудь станет необходимость перенести свою локальную ветку в удалённый репозиторий, после чего, удалить локальную, вы можете использовать команду git push с опцией -d в качестве псевдонима для —delete.

Если вы регулярно пользуетесь GIT-ом, то я рекомендую купить себе книгу Pro Git и поставить её себе на стол, как библию по ГИТ-у.

Резюме

В этой статье я рассказал и привёл примеры, как удалить ветку в репозитории гит. Как оказалось, удаление локальной ветки и удалённой в GIT немного отличается. Потому, я подробно остановится на этом, и показал на реальном примере, как удалить ветку в github, gitlab, или bitbucket, а так же, показал, как избежать некоторых ошибок при работе с удалённым репозиторием. Я вас категорически поздравляю, потому что теперь вы умеете удалять ветки на git не только локально, но и на удалённом сервере.

При удалении ветки все данные с неё стираются, будьте особо внимательны при удалении данных с ГИТ-а.

Как удалить локальную и удаленную ветку Git

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

В этой статье рассказывается, как удалять локальные и удаленные ветви Git.

Удалить локальную ветку Git

Чтобы удалить локальную ветку Git, используйте команду git branch с флагом -d ( --delete):

git branch -d branch_name

Deleted branch branch_name (was 17d9aa0).

Если вы попытаетесь удалить ветку, которая содержит изменения, которые еще не объединены, вы получите следующую ошибку:

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

Как сказано в сообщении выше, вы можете принудительно удалить флаг -D, используя ярлык для --delete --force:

git branch -D branch_name

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

git branch –no-merged.

Если вы вернетесь в ветку, которую удалили, вы получите следующее сообщение:

error: Cannot delete branch 'branch_name' checked out at '/path/to/repository'

Вы не можете удалить активную ветку. Сначала переключитесь на другую ветку, а затем удалите branch_name:

git checkout mastergit branch -d branch_name

Удалить удаленную ветку Git

В Git локальные и удаленные ветви являются отдельными объектами. Удаление локальной ветки не удаляет удаленную ветку.

Чтобы удалить удаленную ветку, используйте команду git push с флагом -d( --delete):

git push remote_name --delete branch_name

Где remote_name обычно находится origin:

git push origin --delete branch_name

...
 - [deleted]         branch_name

Есть также альтернативная команда для удаления удаленной ветки, то есть, по крайней мере, мне труднее запомнить:

git push origin remote_name :branch_name

Если вы работаете над проектом с группой людей и попытаетесь удалить удаленную ветку, которая уже была удалена кем-то другим, вы получите следующее сообщение об ошибке:

error: unable to push to unqualified destination: branch_name The destination refspec neither matches an existing ref on the remote nor begins with refs/, and we are unable to guess a prefix based on the source ref. error: failed to push some refs to '[email protected]:/my_repo'

В подобных ситуациях вам нужно синхронизировать список веток с:

git fetch -p

Флаг -p сообщит Git удалить все ссылки на удаленное отслеживание, которые больше не существуют в удаленном хранилище, перед извлечением.

Заключение

Из этого урока вы узнали, как удалять локальные и удаленные ветви Git. Ветви – это, по сути, ссылка на снимок ваших изменений и короткий жизненный цикл. Как только ветвь объединена с главной (или другой основной ветвью), она больше не нужна и должна быть удалена.

Если вы столкнулись с проблемой или у вас есть отзыв, оставьте комментарий ниже.

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Как удалить ветку Git как локально, так и удаленно?

Если вам нужны более подробные объяснения следующих команд, см. Длинные ответы в следующем разделе.

удаление удаленной ветви:

git push origin --delete <branch>  # Git version 1.7.0 or newer
git push origin :<branch>          # Git versions older than 1.7.0

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

git branch --delete <branch>
git branch -d <branch> # Shorter version
git branch -D <branch> # Force delete un-merged branches

удаление локальной ветви удаленного отслеживания:

git branch --delete --remotes <remote>/<branch>
git branch -dr <remote>/<branch> # Shorter

git fetch <remote> --prune # Delete multiple obsolete tracking branches
git fetch <remote> -p      # Shorter

когда вы имеете дело с удалением ветки как локально, так и дистанционно, имейте в виду, что есть 3 различных ветвей, участвующих:

местное отделение X.
ветвь удаленного происхождения X.
местное отделение удаленного отслеживания origin/X это отслеживает удаленную ветку X.

оригинальный плакат используется

git branch -rd origin/bugfix

который только удалил его местное отделение дистанционного отслеживания origin/bugfix, а не фактическая удаленная ветвь bugfix on origin.

чтобы удалить эту фактическую удаленную ветку необходимо

git push origin --delete bugfix

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

нажатие для удаления удаленных ветвей также удаляет удаленные ветви отслеживания

обратите внимание, что удаление удаленной ветви X из командной строки с помощью git push также удалит локальную ветку удаленного отслеживания origin/X, поэтому нет необходимости обрезать устаревшую ветку удаленного отслеживания с git fetch --prune или git fetch -p, хотя это не повредит, если вы все равно это сделаете.

вы можете проверить, что ветка удаленного отслеживания origin/X также был удален, выполнив следующее:

# View just remote-tracking branches
git branch --remotes
git branch -r

# View both strictly local as well as remote-tracking branches
git branch --all
git branch -a

обрезка устаревшей локальной ветви удаленного отслеживания origin / X

если вы не удалили удаленную ветку X из командной строки (как указано выше), тогда ваше локальное репо по-прежнему будет содержать (теперь устаревшую) ветку удаленного отслеживания origin/X. Это может произойти, если вы удалили удаленную ветку непосредственно через веб-интерфейс GitHub, например.

типичный способ удалить эти устаревшие ветви удаленного отслеживания (начиная с Git версии 1.6.6) — просто запустить git fetch С --prune или меньше -p. Примечание. что это удаляет все устаревшие локальные ветви удаленного отслеживания для любых удаленных ветвей, которые больше не существуют на удаленном:

git fetch origin --prune
git fetch origin -p # Shorter

вот соответствующая цитата из 1.6.6 выпуске (выделено мной):

» git fetch » узнал --all и --multiple options, чтобы запустить выборку из
много хранилищ, и --prune возможность удаления удаленного отслеживания
ветви, которые стали черствыми. это делает «удаленное обновление git» и » git
remote prune «менее необходим (нет плана по удалению» remote
обновление » или «удаленная чернослив», хотя).

альтернатива выше автоматическая обрезка устаревших удаленные ветки

альтернативно, вместо обрезки устаревших локальных ветвей удаленного отслеживания через git fetch -p, вы можете избежать лишней работы в сети просто вручную удалив ветку (ы) с помощью --remote или -r флаги:

git branch --delete --remotes origin/X
git branch -dr origin/X # Shorter

См. Также

1665

автор: Valentin Lorentz

Ветвление Git с примерами из реальной жизни

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

Есть важное правило: вы
не должны работать с этими ветками напрямую. Для любого изменения в программном
проекте надо сначала создать новую ветвь, унаследовавшись от dev и дать ей имя,
отражающее сделанное изменение.

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

Предположим, есть
тестовый репозиторий на GitHub. Перейдём на главную страницу этого репозитория
и щёлкнем по разделу 1 branch.

Как можно видеть, здесь
только созданная по умолчанию ветка master. Она сообщает,
что содержимое домашней страницы репозитория загружается при выборе данной ветки.

Вернёмся на главную
страницу и кликнем по выпадающему меню Branch: master. Если написать dev и нажать на
появившийся пункт Create branch: dev, можно создать ветку dev в своём
удалённом репозитории.

Создание ветки на
локальном репозитории

Для просмотра локального репозитория после добавления ветки dev в удалённый репозиторий,
используется следующая команда:

        $git branch

или такая:

        $git branch –-list

Эта
команда выведет в окно терминала локальные ветви.

Чтобы
выйти из списка веток, используйте клавишу q.

Для
просмотра удалённых веток применяется следующая команда:

        $git branch –r

Получение
изменений из удалённого репозитория

Теперь попробуем заставить появиться удалённую ветку dev. Извлечём все последние
изменения удалённого репозитория:

        $git fetch –all

Теперь
dev появилась среди других веток, потому что с помощью git fetch извлекаются
последние актуальные метаданные.

Чтобы
извлечь и скопировать все изменения из удалённого репозитория, нужно использовать команду
git pull:

        $git pull origin dev (ключевое слово origin указывает на удаленный репозиторий)

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

        $git branch –a

Переключение
между ветками

Всё готово к разработке, и непосредственно перед началом нам нужно изменить текущую
ветку с master на dev. Сделаем это в локальном репозитории с помощью команды:

        $git checkout dev

Как
говорилось ранее, dev должна быть основной ветвью для разработки и все
действия должны начинаться именно из неё.

Создание
ветви

Создадим
новую ветвь из ветви dev:

        $git branch my-new-faeture

Снова
проверим локальные ветви:

Обновление
имени ветки

Чтобы
поменять имя существующей ветки, нет необходимости создавать всё сначала т. к.
есть специальная команда:

        $git branch -m my-bug-fix

Если
вы находитесь в другой ветви, вы всё равно можете переименовать любую из них
следующим образом:

        $git branch -m my-new-faeture my-new-feature

Проверим
правильность указанных имён:

Коммит
ветки

Внесём
изменения в файл README.md и проверим локальный репозиторий:

        $git status

Перенесём
файл в промежуточную область и сделаем коммит:

        $git add README.md
$git commit -m "my first commit"

Проверяем:

Отправка
изменений на удалённый сервер

Теперь можно пушить коммит:

        $git push origin my-new-branch

После
отправки актуальной информации о ветке в удалённый репозиторий, нужно
проверить, всё ли прошло корректно:

Удаление
ветки

Если
есть необходимость в удалении ветви, переходим в dev (или в любую ветку,
которую нужно удалить) и выполняем удаление:

        $git checkout dev
$git branch -d my-new-branch

Удаление
завершилось неудачно т. к. удаление локальной ветви с помощью команды git branch -d является безопасной операцией. Если ветка имеет статус unpushed или
unmerged , её можно удалить только принудительно:

        $git branch -D my-new-branch

Как
насчёт удаления remote-ветки? Для этой цели у push есть ключ --delete:

        $git push origin --delete my-new-branch

Проверим:

Видим,
что my-new-branch очищена от всех локальных и удалённых репозиториев.

Проделаем
всё сначала и создадим новую ветку, как «правильные ребята»:

Внесём
изменения:

Проверим
состояние ветки:

        $git status

Наблюдаем
изменённый файлик README.md, коммитим текущее изменение локального репозитория,
добавив файл в промежуточную область:

        $git add README.md
$git commit -m "my killer feature"

Пушим
результат на удалённый сервер:

        $git push origin feature/my-killer-feature

Теперь предположим, что ваш
коллега нашёл какой-то баг в коде, исправил его и создал копию данной ветки с
другим именем: fix/my-killer-feature-bug-fix.

Слияние
ветвей

Как
обычно, сначала получаем актуальную информацию о репозитории:

Далее ищем ветку, над которой работал коллега:

Теперь можно сливать исправленную ветку с feature/my-killer-feature
с помощью команды git merge (убедитесь, что
находитесь в нужной ветви).

        $git merge origin/fix/my-killer-feature-fix

Проверяем
конечный результат:

Редакция Библиотеки Программиста надеется, что этот
материал поможет вам узнать или укрепить знания о ветвлении в Git для
ежедневного использования.

Если вам интересен Git, у нас для него есть специальный тег.

В этом теге наиболее близкие к этой статье следующие:

Как удалить все ветви Git, которые были объединены?

я использовал ответ Адама в течение многих лет. Тем не менее, есть несколько случаев, когда он вел себя не так, как я ожидал:

ветви содержится слово » мастер «было проигнорировано, например» notmaster «или» masterful», а не только главная ветвь
ветви содержится слово » dev «было проигнорировано, например» dev-test», а не только ветвь dev
удаление ветвей, которые доступны из глава настоящее ветку (то есть, не обязательно мастер)
в отделенном состоянии головы, удаление ветвь, доступная из текущей фиксации

1 & 2 были просты в обращении, с просто изменением регулярного выражения.
3 зависит от контекста того, что вы хотите (т. е. только удалять ветви, которые не были объединены в master или против вашей текущей ветви).
4 имеет потенциал быть катастрофическим (хотя и восстанавливаемым с git reflog), если вы непреднамеренно запустили это в отстраненном головном состоянии.

наконец, я хотел, чтобы все это было в одной строке, которая не требовала отдельного скрипта (Bash|Ruby|Python).

TL; DR

создайте псевдоним git «sweep», который принимает необязательный -f флаг:

git config --global alias.sweep '!f(){ git branch --merged $([[  != "-f" ]] \
&& git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" \
| xargs git branch -d; }; f'

и вызовите его с помощью:

git sweep

или:

git sweep -f

мне было проще всего создать пример git repo с некоторыми ветвями и фиксациями для проверки правильного поведения:

создайте новое git-РЕПО с одной фиксацией

mkdir sweep-test && cd sweep-test && git init
echo "hello" > hello
git add . && git commit -am "initial commit"

Создайте несколько новых ветвей

git branch foo && git branch bar && git branch develop && git branch notmaster && git branch masterful
git branch --list

  bar
  develop
  foo
* master
  masterful
  notmaster

желаемое поведение: выберите все объединенные ветви, кроме: master, develop или настоящее

оригинальное регулярное выражение пропускает ветви «masterful» и » notmaster» :

git checkout foo
git branch --merged | egrep -v "(^\*|master|dev)"

bar

с обновленным регулярным выражением (которое теперь исключает «разработку», а не»dev»):

git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

bar
masterful
notmaster

переключитесь на ветку foo, сделайте новую фиксацию, затем проверьте новую ветку, foobar, на основе foo:

echo "foo" > foo
git add . && git commit -am "foo"
git checkout -b foobar
echo "foobar" > foobar
git add . && git commit -am "foobar"

моя текущая ветвь-foobar, и если я повторю команду выше, чтобы перечислить ветви, которые я хочу удалить, ветвь «foo» включена, даже если она не была объединена в мастер:

git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  foo
  masterful
  notmaster

однако, если я запускаю ту же команду на master, ветка «foo»не включена:

git checkout master && git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

и это просто потому, что git branch --merged по умолчанию используется руководитель текущей ветви, если не указано иное. По крайней мере, для моего рабочего процесса я не хочу удалять локальные ветви, если они не были объединены в master, поэтому я предпочитаю следующее вариант:

git checkout foobar
git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

обособленное головное государство

полагаться на поведение по умолчанию git branch --merged имеет еще более значительные последствия в отстраненном состоянии головы:

git checkout foobar
git checkout HEAD~0
git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  foo
  foobar
  masterful
  notmaster

это удалило бы ветку, на которой я только что был, «foobar» вместе с «foo», что почти наверняка не является желаемым результатом.
С нашей пересмотренной командой, однако:

git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

одна строка, включая фактическое удаление

git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" | xargs git branch -d

все завернуто в псевдоним git «sweep»:

git config --global alias.sweep '!f(){ git branch --merged $([[  != "-f" ]] \
&& git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" \
| xargs git branch -d; }; f'

псевдоним принимает необязательный -f флаг. Поведение по умолчанию-удалить только ветви, которые были объединены в master, но -f флаг удалит ветви, которые были объединены в текущий отделение.

git sweep

Deleted branch bar (was 9a56952).
Deleted branch masterful (was 9a56952).
Deleted branch notmaster (was 9a56952).

git sweep -f

Deleted branch foo (was 2cea1ab).

Удаление ветки в git удаляет ее из истории?

в Git ветви — это просто указатели (ссылки) на коммиты в направленном ациклическом графе (DAG) коммитов. Это означает, что удаление ветви удаляет только ссылки на коммиты, которые могут сделать некоторые коммиты в DAG недоступными, поэтому невидимыми. Но все коммиты, которые были на удаленной ветке, все равно будут в репозитории, по крайней мере, до тех пор, пока недостижимые коммиты не будут обрезаны (например, используя git gc).

отметим, что git branch -d отказался бы удалить ветку, если она не может быть уверена это удаление не оставит недостижимых коммитов. Вам нужно использовать более git branch -D чтобы принудительно удалить ветку, если она может оставить недостижимые коммиты.

Также обратите внимание, что недостижимые коммиты, если они присутствуют, — это только те коммиты между последней вершиной удаленной ветви и либо коммитом, который был объединен с другой существующей ветвью, любой помеченной фиксацией, либо точкой ветвления; в зависимости от того, что позже. Например, в следующем ситуация:

----O----*----*----/M----*    <-- master <-- HEAD
     \            /
      \--.----.--/--x---y     <-- deleted branch

только коммиты » x » и » y » станут недоступными после удаления ветви.

если вы работали на удаленной ветви в gc.reflogExpire период, по умолчанию 90 дней, у вас будет последний наконечник удаленной ветви, записанный в head reflog (см. git reflog show HEAD или git log --oneline --walk-reflogs HEAD). Вы должны иметь возможность использовать Head reflog для восстановления удаленного указателя. Обратите внимание также, что в этом случае недостижимые коммиты только в удаленной ветви будут защищены от обрезки (удаление) в пределах gc.reflogExpireUnreachable период, который по умолчанию составляет 30 дней.

если вы не можете найти кончик просто удалил ветку в reflog для головы, вы можете попробовать использовать git fsck чтобы найти «недостижимый commit » и изучить их (через git show <sha1> или git log <sha1>), чтобы найти кончик удаленной ветви.

независимо от того, как вы находите кончик удаленной ветви, вы можете отменить удаление или, скорее, воссоздать только что удаленную ветку с помощью

git branch <deleted-branch> <found-sha1-id>

Примечание. что reflog для филиала будут потеряны.

появилась git-resurrect.sh скрипт contrib/ который помогает найти следы наконечника ветви с заданным именем и воскресить (восстановить) его.

автор: Jakub Narębski

Git Branch | Учебник Atlassian Git

Этот документ представляет собой углубленный обзор команды git branch и обсуждение общей модели ветвления Git. Ветвление — это функция, доступная в большинстве современных систем контроля версий. Ветвление в других VCS может быть дорогостоящей операцией как с точки зрения времени, так и с точки зрения дискового пространства. В Git ветки являются частью повседневного процесса разработки. Ветки Git фактически являются указателем на снимок ваших изменений. Когда вы хотите добавить новую функцию или исправить ошибку, независимо от ее размера или размера, вы создаете новую ветку для инкапсуляции ваших изменений.Это усложняет слияние нестабильного кода с основной базой кода и дает вам возможность очистить историю своего будущего, прежде чем объединять ее с основной веткой.

На приведенной выше диаграмме визуализируется репозиторий с двумя изолированными линиями разработки, одна для небольшой функции, а другая для более продолжительной функции. Разрабатывая их в ветвях, можно не только работать с ними обоими параллельно, но и избавлять основную ветвь master от сомнительного кода.

Реализация ветвей Git намного легче, чем другие модели системы контроля версий. Вместо того, чтобы копировать файлы из каталога в каталог, Git сохраняет ветку как ссылку на фиксацию. В этом смысле ветка представляет собой вершину серии коммитов — это не контейнер для коммитов. История ветки экстраполируется через отношения фиксации.

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

Как это работает

Ветка представляет собой самостоятельную линию развития. Ветви служат абстракцией для процесса редактирования / этапа / фиксации. Вы можете думать о них как о способе запросить новый рабочий каталог, промежуточную область и историю проекта. Новые коммиты записываются в историю текущей ветки, что приводит к возникновению вилки в истории проекта.

Команда git branch позволяет создавать, перечислять, переименовывать и удалять ветки.Это не позволяет вам переключаться между ветвями или снова собирать разветвленную историю. По этой причине git branch тесно интегрирован с командами git checkout и git merge .

Общие параметры

  ветка git

Список всех веток в вашем репозитории. Это синоним git branch --list.

  ветка git

Создайте новую ветку с именем .Это , а не , проверяет новую ветку.

  ветка git -d

Удалить указанную ветку. Это «безопасная» операция, так как Git не позволяет вам удалить ветку, если в ней есть не объединенные изменения.

  ветка git -D

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

  git ветка -m

Переименуйте текущую ветку в .

  ветка git -a

Список всех удаленных веток.

Создание филиалов

Важно понимать, что ветки — это просто указатели на коммиты. Когда вы создаете ветку, все, что нужно сделать Git, — это создать новый указатель, он никаким другим образом не изменяет репозиторий. Если вы начнете с репозитория, который выглядит так:

Затем вы создаете ветку, используя следующую команду:

  git ветка сумасшедший эксперимент

История репозитория остается без изменений.Все, что вы получаете, это новый указатель на текущий коммит:

Обратите внимание, что только создает новую ветку. Чтобы начать добавлять в него коммиты, вам нужно выбрать его с помощью git checkout , а затем использовать стандартные команды git add и git commit .

Создание удаленных веток

Пока что все эти примеры демонстрируют операции локальных филиалов. Команда git branch также работает с удаленными ветвями. Чтобы работать с удаленными ветвями, необходимо сначала настроить удаленное репо и добавить его в конфигурацию локального репо.

  $ git remote add new-remote-repo https://bitbucket.com/user/repo.git # Добавить удаленное репо к конфигурации локального репо -репо

Эта команда отправит копию локальной ветки crazy-Experiment в удаленное репо .

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

Когда вы закончите работу над веткой и объедините ее с основной базой кода, вы можете удалить ветку без потери истории:

  git branch -d сумасшедший эксперимент

Однако, если ветка не была объединена, приведенная выше команда выдаст сообщение об ошибке:

 Ошибка : ветка «сумасшедший эксперимент» не полностью объединена.Если вы уверены, что хотите его удалить, запустите git branch -D crazy -experiment.

Это защищает вас от потери доступа ко всей линии разработки. Если вы действительно хотите удалить ветку (например, это неудачный эксперимент), вы можете использовать флаг с большой буквы -D :

  git branch -D сумасшедший эксперимент

Это удаляет ветку независимо от ее статуса и без предупреждений, поэтому используйте ее с умом.

Предыдущие команды удаляют локальную копию ветви.Ветка может все еще существовать в удаленных репозиториях. Чтобы удалить удаленную ветку, выполните следующие действия.

  git push origin - удалить сумасшедший эксперимент

или

  git push origin: сумасшедший эксперимент

Это отправит сигнал удаления в репозиторий удаленного источника, который запускает удаление удаленной ветки crazy-Experiment .

Сводка

В этом документе мы обсудили поведение ветвления Git и команду git branch .Основные функции команд git branch — создание, перечисление, переименование и удаление веток. Для дальнейшей работы с результирующими ветками команда обычно используется с другими командами, такими как git checkout . Узнайте больше о git checkout операций ветвления; например, переключение ветвей и слияние ветвей на странице git checkout .

По сравнению с другими VCS, операции веток Git недороги и часто используются. Эта гибкость позволяет настраивать мощный рабочий процесс Git.Для получения дополнительной информации о рабочих процессах Git посетите наши расширенные страницы обсуждения рабочих процессов: рабочий процесс
Feature Branch, рабочий процесс GitFlow и рабочий процесс разветвления.

Вывод и удаление коммитов Git, не находящихся в ветке (болтающихся?)

Переполнение стека

Около
Продукты
Для команд

Переполнение стека
Общественные вопросы и ответы
Переполнение стека для команд
Где разработчики и технологи делятся частными знаниями с коллегами
Вакансии
Программирование и связанные с ним технические возможности карьерного роста
Талант
Нанимайте технических специалистов и создавайте свой бренд работодателя
Реклама
Обратитесь к разработчикам и технологам со всего мира
О компании

Загрузка…

Пн	Вт	Ср	Чт	Пт	Сб	Вс
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31