Git новая ветка: git — Как создать новую ветку и залить изменения

Git — как работают ветки

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

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

Давайте попробуем. По умолчанию в гите создается ветка мастер. На ней мы с вами все это время работали.

Если мы напишем

git branch

то мы увидим список всех веток, которые у нас есть. В нашем случае это только мастер. Обратите внимание на звездочку перед названием мастер. Эта звездочка показывает на какой ветке мы сейчас.

Давайте создадим новую ветку

git branch implement-new-logic

Если мы еще раз напишем git branch, то увидим у нас 2 ветки, но мы все еще находимся на ветке мастер.
Чтобы перейти на ветку, которую мы только что создали нужно написать

git checkout implement-new-logic

Теперь написав git branch мы видим что мы на ветке implement-new-logic.

Давайте добавим функцию getPerson в файл 2.js. Просто создадим функцию getPerson, которая будет склеивать имя и фамилию.

function getPerson(name, surname) {
  return name + " " + surname;
}

сохраним и запушим наши изменения.

git add .
git commit -m "Added getPerson function"
git push

Теперь если мы зайдем в наш репозиторий в браузере, то мы увидим что у нас там 2 ветки: implement-new-logic и master. Если мы перейдем на ветку implement-new-logic, то мы увидим, что на ней 5 коммитов, а в файле 2.js есть наша функция, которую мы добавили.

Если же мы перейдем обратно на мастер, для этого мы можем написать

git checkout master

то наши изменения, которые мы сделали так и останутся на той ветке.
И пока мы их не вольем в ветку master, она не изменится.

В гите термин вливания ветки в другую ветку называется merge. Для того, что смерджить нашу ветку implement-new-logic в мастер, нам нужно сначала перейти на мастер и потом написать какую ветку мы хотим влить.

Давайте напишем

git merge implement-new-logic

Как мы видим, у нас написало, что ветка обновилась и добавился файл 2.js. Теперь у нас ветки стали идентичные и добавленный нами функционал находится в мастер ветке. Если мы напишем

git log

то увидим наш коммит, который мы добавляли на другой ветке.
Так как мы ветку уже смерджили и она нам не нужна больше, давайте ее удалим.

git branch -d implement-new-logic

Теперь написав git branch мы опять видим только мастер. Давайте запушим эти изменения.

git add .
git commit -m "Merged implementing new logic to master"
git push

Теперь мы запушили наши изменения. И если мы заходим и видим master ветку, то мы видим, что у нас 5 коммитов и последним идет тот, который мы добавили. Единственное отличие в том, что мы удалили ветку локально, но не удалили ее на сервере. Вы можете зайти в список веток, all branches и нажать delete this branch. И это удаляет ветку не локально уже, а на сервере.

О ветвлении в Git — Основы Git

Основы Git

Видео может быть заблокировано из-за расширений браузера. В статье вы найдете решение этой проблемы.

Рекомендуем перейти в курс Введение в Git

Мы обновили этот курс — добавили новые темы, самостоятельные задания и практические упражнения. Посмотрите его по ссылке: https://ru.hexlet.io/courses/intro_to_git

Здравствуйте!

Сегодня мы поговорим про одну из самых важных вещей в Git — про ветвление.

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

Некоторые говорят, что модель ветвления Git’а это его “killer feature“ и она безусловно выделяет Git в СКВ-сообществе. Что же в ней такого особенного? Способ ветвления в Git’е чрезвычайно легковесен, что делает операции ветвления практически мгновенными и переключение туда-сюда между ветками обычно так же быстрым. В отличие от многих других СКВ, Git поощряет процесс работы, при котором ветвление и слияние осуществляется часто, даже по несколько раз в день. Понимание и владение этой функциональностью даёт вам уникальный мощный инструмент и может буквально изменить то, как вы ведёте разработку.

Что такое ветка?

Чтобы на самом деле разобраться в том, как Git работает с ветками, мы должны сделать шаг назад и рассмотреть, как Git хранит свои данные. Как вы, наверное, помните Git хранит данные не как последовательность изменений или дельт, а как последовательность снимков состояния (snapshot).

Когда вы создаёте коммит в Git’е, Git записывает в базу объект-коммит, который содержит указатель на снимок состояния (tree), записанный ранее в индекс, метаданные автора и комментария и один или более указателей на коммиты, являющиеся прямыми предками этого коммита: один — для обычного коммита и несколько — для коммита, полученного в результате слияния двух или более веток.

Для наглядности давайте предположим, что у вас есть директория, содержащая три файла, и вы хотите добавить их все в индекс и сделать коммит. При добавлении файлов в индекс для каждого из них вычислится контрольная сумма (SHA-1 хеш), затем эти версии файлов будут сохранены в Git-репозиторий (Git обращается к ним как к двоичным данным), а их контрольные суммы добавятся в индекс:

$ git add README.md CHANGELOG LICENSE.md
$ git commit -m 'initial commit of my project'

Когда вы создаёте коммит, выполняя git commit, Git вычисляет контрольную сумму каждой поддиректории (в нашем случае только корневого каталога) и сохраняет эти объекты-деревья в Git-репозиторий. Затем Git создаёт объект для коммита, в котором есть метаданные и указатель на объект-дерево для корня проекта. Таким образом, Git сможет воссоздать текущее состояние, когда будет нужно.

Ваш Git-репозиторий теперь содержит пять объектов:

• по одному блобу для содержимого каждого из трёх файлов,
• одно дерево, в котором перечислено содержимое каталога и определено соответствие имён файлов и блобов,
• один коммит с указателем на тот самый объект-дерево для корня и со всеми метаданными коммита.

Схематично данные в этом Git-репозитории выглядят так, как показано на рисунке.

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

Ветка в Git’е — это просто легковесный подвижный указатель на один из этих коммитов. Ветка по-умолчанию в Git’е называется master. Когда вы создаёте коммиты на начальном этапе, вам дана ветка master, указывающая на последний сделанный коммит. При каждом новом коммите она сдвигается вперёд автоматически (в файле ветки записывается sha нового коммита).

Что произойдёт, если вы создадите новую ветку? Итак, этим вы создадите новый указатель, который можно будет перемещать. Скажем, создадим новую ветку под названием testing. Это делается командой git branch:

$ git branch testing

Эта команда создаст новый указатель на тот самый коммит, на котором вы сейчас находитесь.

Откуда Git узнает, на какой ветке вы находитесь в данный момент? Он хранит специальный указатель, который называется HEAD. Учтите, что это сильно отличается от концепции HEAD в других СКВ, таких как Subversion или CVS, к которым вы, возможно, привыкли. В Git’е это указатель на локальную ветку, на которой вы находитесь. В данный момент вы всё ещё на ветке master. Команда git branch только создала новую ветку, она не переключила вас на неё.

Чтобы перейти на существующую ветку, вам надо выполнить команду git checkout. Давайте перейдём на новую ветку testing:

$ git checkout testing

Это действие передвинет HEAD так, чтобы тот указывал на ветку testing.

В чём же важность этого? Давайте сделаем ещё один коммит:

$ touch test.rb
$ git commit -a -m 'Added test.rb file'

На рисунке показан результат.

Это интересно, потому что теперь ваша ветка testing передвинулась вперёд, но ветка master всё ещё указывает на коммит, на котором вы были, когда выполняли git checkout, чтобы переключить ветки. Давайте перейдём обратно на ветку master:

$ git checkout master

На рисунке можно увидеть результат.

Эта команда выполнила два действия. Она передвинула указатель HEAD назад на ветку master и вернула файлы в вашем рабочем каталоге назад, в соответствие со снимком состояния, на который указывает master. Это также означает, что изменения, которые вы делаете, начиная с этого момента, будут ответвляться от старой версии проекта. Это, по сути, откатывает изменения, которые вы временно делали на ветке testing, так что дальше вы можете двигаться в другом направлении.

Давайте снова внесём немного изменений и сделаем коммит:

$ touch script.rb
$ git commit -a -m 'Added script.rb'

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

Из-за того, что ветка в Git’е на самом деле является простым файлом, который содержит 40 символов контрольной суммы SHA-1 коммита, на который он указывает, создание и удаление веток практически беззатратно. Создание новой ветки настолько же быстрое и простое, как запись 41 байта в файл (40 символов + символ новой строки).

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

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты.

Ошибки, сложный материал, вопросы >

Нашли опечатку или неточность?

Выделите текст, нажмите
ctrl + enter
и отправьте его нам. В течение нескольких дней мы исправим ошибку или улучшим формулировку.

Что-то не получается или материал кажется сложным?

Загляните в раздел «Обсуждение»:

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

Об обучении на Хекслете

Как создать новую ветку в Git

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

Что такое Git Branch?

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

Связанный: Как использовать ветви Git для структурирования вашего проекта программирования

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

Создание новой ветви в командной строке

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

Используйте команду git branch <branchname>, чтобы создать новую ветку с заданным именем:

 $ git branch dev
Branch 'dev' set up to track local branch 'master'.

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

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

 $ git branch
1 dev
2 * master

Вы можете увидеть дополнительную информацию, в том числе, какую ветвь отслеживает другая, используя флаг -vv :

 $ git branch -vv
1 dev d1a9e5b [master] commit comment
2 * master d1a9e5b commit comment

Если вы попытаетесь создать ветку до первой фиксации, вы получите сообщение об ошибке, например:

 fatal: Not a valid object name: 'master'.

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

 fatal: A branch named 'dev' already exists.

Команда git branch создает новую ветку, указывающую на тот же коммит, над которым вы сейчас работаете. Однако ваша рабочая копия по-прежнему будет указывать на основную ветку. Чтобы переключиться на новую ветку, которую вы только что создали, используйте git checkout :

 git checkout dev

Термин « проверка» может сбивать с толку, если вы привыкли к другим системам контроля версий; в Git проверка относится к переключению текущей активной ветки. Поскольку вы обычно хотите переключиться на новую ветку после ее создания, для всего процесса есть ярлык:

 git checkout -b dev

Эта команда означает «создать новую ветку под названием« dev »и немедленно переключиться на нее». Это эквивалент:

 git branch dev
git checkout dev

Фактически, вы даже можете использовать git checkout для создания ветки из любой другой, а не только из той, которая в данный момент проверена. Например, чтобы создать новую ветку с именем another , из ветки с именем dev :

 git checkout -b another dev

Создание новой ветки с помощью GitHub Desktop

Другой способ создания веток Git в Windows или macOS – использовать GitHub Desktop , программу с официальным графическим интерфейсом пользователя (GUI), предоставляемую GitHub. Использование графического интерфейса идеально подходит для новичков и тех, кому снятся кошмары, когда кто-то шепчет слово Vim.

GitHub Desktop всегда будет показывать вашу текущую ветку на главной панели инструментов:

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

Обратите внимание, что, если вы начнете вводить имя ветки без совпадений, GitHub Desktop предложит вам создать новую ветку и покажет сочетание клавиш для этого – полезно, если вы действительно много делаете этого:

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

Ваша новая ветка всегда будет основана на той ветке, которая была активна, когда вы ее создали. GitHub Desktop переключится на вашу новую ветку, которая будет автоматически отслеживать ветку, из которой вы ее создали.

Создание новой ветви с использованием башни

Другие графические интерфейсы доступны у сторонних производителей. Tower бесплатен в течение 30-дневного пробного периода и доступен в macOS и Windows.

Чтобы создать новую ветку из текущей извлеченной ветки, выберите « Создать новую ветку» в главном меню репозитория :

Чтобы создать новую ветку из любой доступной ветки, щелкните правой кнопкой мыши ветку на левой боковой панели и выберите « Создать новую ветку из <имя ветки>» :

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

Создание новой ветки с помощью GitKraken

GitKraken – еще один популярный графический интерфейс, который сначала может показаться устрашающим, но он хорошо справляется с визуальным представлением ключевых концепций Git, включая ветки. GitKraken бесплатен для использования с открытым исходным кодом и доступен для Windows, Mac и Linux.

Убедитесь, что вы работаете с правильной активной веткой; это тот, который выделен в списке веток на левой боковой панели:

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

Введите название ветки и нажмите ENTER:

Новая ветка будет автоматически проверена, и вы получите уведомление в правой части экрана.

Создание новой ветки на GitHub

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

GitHub отображает вашу текущую (активную) ветку в представлении вашего репозитория в левом верхнем углу:

Нажмите кнопку, чтобы отобразить существующие ветки:

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

После создания ваша новая ветка становится активной.

Создание новой ветки на Bitbucket

Bitbucket – еще одно популярное веб-приложение для управления версиями, которое предлагает бесплатные учетные записи с неограниченным количеством частных репозиториев.

На любой странице вашего репозитория выберите пункт Ветви в меню слева:

Нажмите кнопку Создать ветку в правом верхнем углу. Введите новое имя ветки и нажмите « Создать» . Если вам нужно перейти из любого места, кроме мастера , сначала измените ветку From :

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

После создания Bitbucket отображает вид вашей новой ветки:

Научитесь расширяться с помощью Git

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

Связанный

Знакомство с Git и GitHub: руководство для начинающих | by Olga Sayfudinova | NOP::Nuances of Programming

Предыдущая статья: Часть 1, Часть 2

Совместная работа — это визитная карточка GitHub!

Рабочий процесс на GitHub

Допустим, у вас есть проект с кучей разных идей и возможностей для дальнейшей реализации. Что-то из этого уже готово, а над чем-то еще стоит потрудиться. Вполне возможно, что вы сотрудничаете с другими пользователями, которые работают над чем-то своим. Здесь и пригодится ветвление!

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

Единственная ветка, которая может изменять проект, — это master. Если вы не хотите вносить изменения сразу, то выделите их отдельной веткой, а затем сливайте с master.

Если вы работаете с другими и хотите внести собственные изменения либо работаете над проектом и хотите изменить что-то, не затрагивая master, то создавайте отдельную ветку. Сделать это можно в любое время.

Очень удобно создавать в терминале ветку с названием new_feature (новая опция) и переходить в нее по команде:

git checkout -b new_feature

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

Теперь поговорим о переключении между ветками:

git checkout

Команда позволяет «заглянуть» в репозиторий, который в данный момент не открыт. Например, вы можете перейти в ветку master:

git checkout master

или открыть ветку new_feature:

git checkout new_feature

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

git merge new_feature

Эта команда берет все изменения в ветке new_feature и добавляет их в ветку master.

Вы можете отправить изменения в репозиторий и установить удаленную ветку (например, new_feature) в качестве «отслеживаемой»:

git push — set-upstream origin new_feature

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

Эмммм… это делается через сайт?

Да, все это делается с сайта GitHub.

Pull request создается по нажатию одноименной кнопки, о которой мы говорили ранее при редактировании README-файла. Элементарно!

А еще вы можете создать отдельную ветку на сайте через сам репозиторий. Перейдите в репозиторий и кликните по выпадающему меню в левой части экрана. Там еще написано Branch: master. Задайте имя новой ветки и выберите Create branch (либо нажмите Enter на клавиатуре). Теперь у вас есть две одинаковые ветки. Это отличное место для внесения изменений и тестирования их до слияния с master.

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

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

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

Pull request можно открыть сразу при создании коммита, даже если вы все еще работаете с кодом. Делается это с сайта GitHub. Допустим, вы внесли изменения в ветку и хотите слить их с master. Тогда:

• Кликните по вкладке Pull request вверху экрана.
• Нажмите зеленую кнопку New pull request.
• Перейдите в поле Example Comparisons. Выберите ветку, которую хотите сравнить с master.
• Еще раз просмотрите все изменения, убедитесь, что они готовы для коммита.
• Нажмите большую зеленую кнопку New pull request. Напишите заголовок запроса, дайте краткое описание изменений. Нажмите Create pull request.

Новый Pull requestСоздание pull request

Если это ваш репозиторий, то слить изменения с master можно через зеленую кнопку Merge pull request. Нажмите Confirm merge. Сразу после объединения нужной ветки с master нажмите Delete branch в фиолетовом боксе.

Если вы участвуете в чужом проекте, то у участников команды (или проверяющего коммиты) могут возникнуть вопросы или замечания. Хотите внести какие-то изменения? Сейчас — самое время. Сразу по завершению изменений участники проекта смогут развертывать эти изменения напрямую из ветки и проводить конечное тестирование до слияния с master. Вы также сможете произвести развертку изменений для проверки их в рабочей среде.

После утверждения изменений необходимо произвести слияние вашего кода с веткой master. В Pull request хранится запись о ваших изменениях. Таким образом, вы всегда сможете открыть этот запрос и понять, какие изменения были сделаны и почему.

Обновление и слияние

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

git pull

Для слияния какой-то ветки с вашей активной веткой воспользуйтесь:

git merge <имя_ветки>

Git старается автоматически сливать изменения, однако это не всегда возможно. Иногда возникают конфликты слияния. Если такое произошло, то необходимо разрешить конфликт слияния вручную. После внесения нужных изменений отметьте их в качестве «объединенных» или «слитых» через git add <имя_файла>. Просмотреть изменения до слияния можно по команде:

git diff <исходная_ветка> <целевая_ветка >

Перейти к ветке master можно через:

git checkout master

После слияния последних изменений обязательно удалите эту ветку через команду:

git branch -d new_feature

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

git push origin <ветка>

Подборка полезных команд

Для начала, вот вам шпаргалка по GitHub, где перечислены все самые полезные Git-команды.

Просмотр истории коммита в репозитории:

git log

Просмотр коммитов одного пользователя:

git log — author=<имя>

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

git diff

Сложно запомнить нужные команды? Получите подсказку из 21 самой популярной команды:

git help

Либо почитайте разъяснения по использованию определенных команд. Например, вот эта команда показывает, как пользоваться clone:

git help clone

Давайте потренируемся, а заодно и поприветствуем всех, кто знакомится с Git и GitHub. Мы создадим Стену для записей GitHub Wall, где изучающие Git и GitHub смогут оставлять комментарии и участвовать в своих первых open-source проектах.

На своей Стене вы можете разместить любые материалы. Главное — помните о вежливости и доброжелательности. Оставьте комментарий, добавьте какую-то картинку… да что угодно. Если вам сложно придумать приветственный текст, то можете взять готовый шаблон из README-файла (ссылку см. ниже).

git clone https://github.com/bonn0062/github_welcome_wall.git

• Создайте новую ветку, добавьте файл welcome_wall.md с какой-нибудь мотивирующей цитатой. Это можно сделать на сайте GitHub. Но куда интереснее склонировать репозиторий на свой компьютер, открыть файл в любимом текстовом редакторе и вписать там нужный комментарий. Так знания лучше усвоятся.
• Создайте Pull request.
• Добавьте комментарий, описывающий суть изменений. Нажмите зеленую кнопку для отправки Pull request.

Поздравляю — вы успешно справились!

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

Git: копирование исходного кода в новую ветвь без истории

У меня есть 2 ветви в репозитории git: common и myown .

Я хочу скопировать источник из одной ветви в другую ветвь, но я хочу видеть в истории ветви common только коммиты, связанные с миграцией функций (с myown на common ).

Можно ли скопировать исходный код без истории или требуется новый репозиторий?

Кроме того, может потребоваться слияние с common на myown и после некоторых изменений скопировать исходный код обратно как новый коммит (и только как этот коммит — без истории всех других коммитов, как я уже говорил ранее).

git

branch

Поделиться

Источник

Maxim    

26 декабря 2013 в 19:17

3 ответа

• Как скопировать диапазон коммитов без слияния в новую ветвь?

  У меня есть feature/branch , который в разные моменты слил ветвь develop в себя в течение своей истории. Я хочу взять все коммиты без слияния (т. е. только те коммиты, которые были сделаны первоначально в ветке feature) и скопировать их в новую ветвь (на основе master), так что у меня нет никаких…

• Как включить новые обновления исходного кода, сохраняя при этом существующие модификации в Git?

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

19

Я нашел более быстрый способ, который можно использовать:

git checkout <branch> -- .

Это заменит содержимое текущей проверяемой ветви содержимым <branch> .

Это не копирует историю фиксации(коммита) <branch> .

Если вы просто хотите проверить только некоторые файлы, просто замените . на пути к файлам из <branch> .

EDIT: я обнаружил, что это только заменит текущие файлы и не удалит файлы, которых нет на <branch> .

Тогда лучше запустить rm -rf перед выполнением проверки.

Поделиться

Zlopez    

27 июля 2017 в 07:24

8

Похоже, я уже придумал, как это сделать. Например, у нас есть ветвь myown .
И нам нужно создать новый пустой (без истории):

git checkout —сирота обыкновенный

Теперь нам нужно добавить файлы:

git add .

И совершить все:

git commit-м «Initial»

Вы можете увидеть в журнале только этот коммит (не все сделано в ветке myown).
Теперь мы можем проверить ветка myown и продолжить работу:

git checkout мой родной город

Мы можем сделать несколько коммитов в собственной ветке (аналогично обычной работе):

…

git commit-м «feature1»

…

git commit-м «feature2»

Теперь мы зафиксировали оба, и журнал содержит оба. Нам нужно скопировать это в ветку common и назвать ее «release1»

git checkout общее

git merge —сквош мой дом

git commit-м «release1»

Вот и все, что касается моей первой части вопроса.
Кроме того, его легко зафиксировать в репозитории common (небольшое изменение/исправление, например, связанное с самим release1). Вы можете сделать регулярное слияние, чтобы вернуть код обратно в ветвь myown .

Поделиться

Maxim    

01 января 2014 в 17:36

0

Очистите папку, но держите ее скрытой files/folders:

mkdir ../delete
mv * ../delete
rm -rf ../delete

Копирование исходного кода из ветки :

git checkout <branch> .

Поделиться

Medical physicist    

14 января 2020 в 09:32

Похожие вопросы:

Переместить ветвь в другую точку истории

У нас есть следующая история start master public | | | v v v o—o— … —o—o—o К сожалению, мы сделали несколько коммитов в ветку master , содержащую некоторые конфиденциальные данные. Мы…

Git: как вернуть ветвь merge без перезаписи истории?

У меня есть две ветви: master и opengl . Я недавно закончил реализацию (или, по крайней мере, я так думал) ветви opengl и решил merge превратить ее в master : git checkout master git merge opengl…

Git как мне протолкнуть проект, который был загружен из исходного кода

Я работал с графическим дизайнером, который не клонировал мой аккаунт github. Он скачал проект из исходного кода, а не с помощью команды git clone. С тех пор как он вытащил свои файлы, прошел месяц,…

Как скопировать диапазон коммитов без слияния в новую ветвь?

У меня есть feature/branch , который в разные моменты слил ветвь develop в себя в течение своей истории. Я хочу взять все коммиты без слияния (т. е. только те коммиты, которые были сделаны…

Как включить новые обновления исходного кода, сохраняя при этом существующие модификации в Git?

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

Как выбрать вишню из ветви а в ветвь Б в системе без истории?

Предположим, у меня есть новая система без истории git, и я беру новую проверку ветви A. ветвь A уже имеет фиксацию(коммит) C1, которую я сделал вчера из какой-то другой системы. Теперь я хочу…

git: вытяните определенную ветвь, сохраните только последнее дерево (без какой-либо истории)

Как я могу вытащить определенную ветвь из удаленного репозитория, проверяя только последнее дерево без сохранения какой-либо истории? Этот вопрос конкретно связан с проверкой дерева Portage Gentoo:…

Миграция репозитория GIT сохранение истории нетронутой

Я пытаюсь перенести существующий репозиторий с Gitlab на Github. Размер репозитория составляет 8 ГБ. При осмотре выяснилось, что размер файла пакета, созданного внутри папки .git, составляет почти…

Создайте сиротскую ветвь без использования флага сироты

У меня есть существующее РЕПО с некоторыми ветками. Я хочу создать новую ветку без какой-либо истории в этом РЕПО. Я пытаюсь сделать это с помощью Dulwich, который поддерживает большинство операций…

git — восстановление удаленной ветви svn без перечитывания истории svn

Я случайно удалил ветку svn из моего местного git repo. Ветвь все еще находится на сервере, и у меня все еще есть git branch, который отслеживал эту ветвь svn. Я хотел бы восстановить эту ветвь там,…

2. Создание новой функциональности в проекте. Командная работа

Быстрое резюме:

Переключаемся в ветку develop:
git checkout develop

Обновляем ветку develop, на случай если она успела устареть:
git pull

Создаем ветку для новой фичи и переключаемся в нее:
git checkout -b ui-buttons

…
…верстаем кнопочки…
…

Сохраняем наши изменения
git add .

git commit -m "ui buttons ready"

Снова переключаемся в develop и обновляем ее, на случай если локальная develop устарела:
git checkout develop

git pull

Переключаемся в ветку с нашей фичей и мержим в нее обновленный develop, чтобы избежать возможных конфликтов при мерже на сервере:

git checkout ui-buttons

git merge develop

Отправляем ветку с нашей фичей на сервер:

git push -u origin ui-buttons

…
…мержим изменения из ui-buttons в develop на сервере…
…

Обновляем локальный develop
git checkout develop

git pull

Удаляем локальную ветку ui-buttons:
git branch -D ui-buttons

… и удаленную:
git push origin --delete ui-buttons

Profit!

Всем привет. В первой части мы скачали проект к себе на компьютер, запустили его и уже вовсю готовы начать над ним работу. Но как? Что делать? Как правильно организовать работу? Сейчас разберемся.

Постановка задачи

Обозначим задачу. Что мы делаем, какие цели преследуем, для чего и что хотим получить.

У нас есть проект. И команда разработчиков. Нужно организовать командную работу, таким образом чтобы каждый разработчик создал новый функционал в проекте и не мешал работать остальным. Для этого нам поможет система контроля версий git и ее ветки (branches).

Мат-часть. План работы

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

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

Шаг 1. Перейти в ветку develop Создание новой ветки.

Вы скачали, запустили и протестировали работу сборки. Она работает. Сейчас вы по умолчанию находитесь в ветке master.

Чтобы проверить в какой ветке вы сейчас введите команду git branch. Она отобразит список веток и зеленым и звездочкой выделит активную ветку, на которой вы сейчас находитесь. Если вы только скачали репозиторий, то вы пока не увидите другие ветки, которые были в удаленном (remote) репозитории. Чтобы увидеть все ветки введите команду git branch -a .Теперь вы увидите все ветки, которые были на удаленном репозитории.

1. Проверьте в какой ветке вы находитесь:
   git branch
2. Проверьте что у вас есть ветка develop:
   git branch -a
3. Перейдите в ветку develop. Она уже должна быть в удаленном репозитории, ее там должен создать тим-лидер. Чтобы перейти в ветку develop пишите команду:
   git checkout develop
4. Проверьте что вы действительно перешли в develop:
   git branch
   В консоли develop должна отличаться зеленым цветом от других веток, и перед ней должна быть звездочка *.
5. Обновитесь. Очень важно регулярно, минимум 1 раз в день обновлять свою локальную версию. Так как вся разработка ведется из ветки develop, то обновлять мы будем ее. Находясь в ветке develop выполните следующую команду:
   git pull
   Эта команда стянет (заберет) все новые изменения в ветке develop с удаленного репозитория и загрузит их к вам на компьютер в ветку develop.

Шаг 2. Создание новой ветки

Сейчас вы находитесь в ветке develop. Из нее необходимо создать новую ветку в которой вы будете делать новую функциональность проекта.

Команда для создания новой ветки и быстрого переключения в нее:
git checkout -b ui-buttons

Я собираюсь работать над кнопками в проекте, поэтому создал новую ветку с именем ui-buttons. Теперь если ввести git branch я мы увидим что находимся в только что созданной ветке ui-buttons.

Шаг 3. Работа в новой ветке и отправка изменений на сервер

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

Сделаем коммит изменений в текущей ветке.
Вводим команду:
git add .
она подготовит все измененные файлы к коммиту, добавит их в слепок, перед коммитом

Далее вводим команду:
git commit -m "ui buttons ready"
Она сделает коммит, иначе говоря — сохранение моей работы с сообщением «ui buttons ready». В вашем случае сообщение будет другим.

Теперь можно отправить свои изменения на сервер. Если я все делал быстро и на сервере не было изменений в ветке develop то все хорошо. И в дальнейшем при мерже можно избежать конфликтов. Но что если ветка develop на сервере уже изменилась. И наша версия проекта немного устарела. Здесь я рассмотрю такую ситуацию. И сделаю обновление своей сборки. Для этого надо переключится в ветку develop. Обновить ее. Переключится обратно в ветку с моими изменениями, у меня это ui-buttons и слить в нее ветку develop.

Переключаюсь в ветку develop:
git checkout develop

Забираю обновления ветки develop с сервера:
git pull

Переключаюсь в ветку со своими изменениями:
git checkout ui-buttons

Переношу новые изменения из ветки develop в свою ветку ui-buttons:
git merge develop

К слову если на этапе git pull в ветке develop — новых изменений с сервера не было, то этап мержа можно пропустить. Так как он не имеет смысла.

Отправим изменения из ветки ui-buttons на сервер.
На сервере еще нет ветки ui-buttons, она есть только у нас локально.
Поэтому при первой отправке надо использовать команду:
git push -u origin ui-buttons

Далее в коммитах внутри ветки ui-buttons ее уже можно будет отправлять просто через git push.

Шаг 4. Слияние изменений в проекте

Мы отправили наш новый функционал на сервер. Сейчас мои кнопочки находятся на удаленном репозитории в ветке ui-buttons. Но участники команды еще не могут использовать мои наработки в проекте. Сначала эти изменения надо влить в ветку develop.

Переходим на сайт GitHub. Заходим в репозиторий нашего проекта. Напротив своей ветки, в моем случае напротив ui-buttons — нажимаю кнопку «New Pull request».

Далее настраиваете вверху фильтр куда в какой репозиторий и в какую ветку вы будете сливать изменения, и откуда. Будьте здесь внимательны. По умолчанию может быть выбран первоначальный репозиторий, от которого наследовалась ваша команда. Выберите там репозиторий который лежит в аккаунте вашего тим-лидера. Мой пример:

В итоге получится вот так. Также укажите reviewers — вашего тим-лидера и меня, вашего преподавателя nobleworkshop.

После нажимаете на зеленую кнопку «Create pull request».

Далее я и тим-лид сделаем ревью вашей работы. Если все в порядке — мы сделаем мерж в develop и вы сможете переходить к следующей задаче.

В случае если потребуются изменения, мы вам напишем. Вы должны будете внести изменения локально, в моем случае в ветке ui-buttons.
Я внес изменения, и делаю коммит чтобы сохранить их.
git add .
git commit -m "ui-buttons - hover state fix"

После отправляем корректировки на сервер, находясь в ветке ui-buttons написать:
git push

Далее в review процессе на GitHub написать что внесены изменения. Чтобы тим-лид проверил, утвердил что все верно и сделал мерж в develop.

Далее когда на сервере ваши изменения попали в ветку develop, стоит забрать их к себе.

Переключаемся локально в develop:
git checkout develop

Забираем обновления ветки develop с сервера:
git pull

Шаг 5. Удаление ненужной ветки

Убедившись что ваши изменения есть в develop ветке на сервере, можно удалить локальную ветку ui-buttons и также удалить ее на сервере.

Удаляем ветку локально:
git branch -D ui-buttons

Удаляем ветку на сервере:
git push origin --delete ui-buttons

Почитать подробнее про удаление веток.

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

P.S. Про Trello здесь не писал. Просто не забывайте менять статус карточки с задачей над которой работаете на доске 😉

Git merge | Atlassian Git Tutorial

Команда git merge отвечает за объединение ветвлений в истории Git и позволяет выполнять слияние отдельных процессов разработки, созданных с помощью команды git branch, в единую ветку.

Обратите внимание: все приведенные ниже команды выполняют слияние в текущую ветку, в то время как целевая ветка остается без изменений. Поэтому git merge часто используется в сочетании с командами git checkout (выбор текущей ветки) и git branch -d (удаление целевой устаревшей ветки).

Порядок действий

Команда git merge объединяет несколько последовательностей коммитов в общую историю. Чаще всего с помощью команды git merge объединяют две ветки. Подобный метод слияния рассматривается в примерах ниже. В таких случаях команда git merge берет два указателя на коммиты (обычно последние) и находит общий для них родительский коммит. Затем Git создает «коммит слияния», в котором сочетаются изменения из обеих последовательностей, выбранных к слиянию.

Представим, что у нас есть новая функциональная ветка, которая отходит от основной (master). Нам нужно объединить функциональную ветку с master.

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

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

Подготовка к слиянию

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

Проверка выбора принимающей ветки

Выполните команду git status. Это позволит убедиться, что HEAD указывает на ветку, принимающую результаты слияния. При необходимости выполните команду git checkout , чтобы переключиться на принимающую ветку. Для примера выполним команду git checkout master.

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

Убедитесь, что в принимающей ветке и ветке для слияния содержатся последние изменения из удаленного репозитория. Выполните команду git fetch, чтобы получить из него последние коммиты. Затем убедитесь, что в ветке master также содержатся последние изменения. Для этого можно выполнить команду git pull.

Выполнение слияния

После указанных выше действий по подготовке можете приступать к слиянию. Для этого выполните команду git merge , где — название ветки, которая будет объединена с принимающей.

Ускоренное слияние

Ускоренное слияние происходит, когда последний коммит текущей ветки является прямым продолжением целевой ветки. В этом случае для объединения истории Git не выполняет полноценное слияние, а просто переносит последний коммит текущей ветки в конец целевой ветки. Объединение историй проходит успешно, поскольку все коммиты целевой ветки теперь доступны в текущей. Так, ускоренное слияние одной из функций с master будет выглядеть следующим образом:

Однако выполнить ускоренное слияние не получится, если ветки после разделения развивались независимо друг от друга. Если до целевой ветки нет прямого пути, Git будет вынужден объединить их методом трехстороннего слияния. Такое слияние выполняется с помощью специального коммита, который служит для объединения двух историй. Метод называется трехсторонним, поскольку Git использует три коммита для создания коммита слияния (последние коммиты двух веток и общий родительский элемент).

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

В первом примере демонстрируется ускоренное слияние. С помощью кода создается новая ветка, после чего в нее добавляется два коммита. Затем она включается в основную ветку посредством ускоренного слияния.

# Start a new feature
git checkout -b new-feature master
# Edit some files
git add <file>
git commit -m "Start a feature"
# Edit some files
git add <file>
git commit -m "Finish a feature"
# Merge in the new-feature branch
git checkout master
git merge new-feature
git branch -d new-feature

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

Обратите внимание, что теперь Git сможет без проблем выполнить команду git branch -d, поскольку ветка new-feature теперь напрямую связана с основной.

Если при ускоренном слиянии вам понадобится доступ к коммиту слияния для учета изменений, вы сможете выполнить команду git merge с опцией --no-ff.

git merge --no-ff <branch>

Эта команда выполнит объединение указанной ветки с текущей с обязательным созданием коммита слияния (даже если слияние будет ускоренным). Это полезно для учета всех слияний в репозитории.

Трехстороннее слияние

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

Start a new feature
git checkout -b new-feature master
# Edit some files
git add <file>
git commit -m "Start a feature"
# Edit some files
git add <file>
git commit -m "Finish a feature"
# Develop the master branch
git checkout master
# Edit some files
git add <file>
git commit -m "Make some super-stable changes to master"
# Merge in the new-feature branch
git merge new-feature
git branch -d new-feature

Обратите внимание, что Git не может выполнить ускоренное слияние. Это происходит, поскольку невозможно перенести указатель master на ветку new-feature без использования предыдущих коммитов.

В большинстве случаев ветка new-feature отводится под более объемные функции с продолжительным временем разработки, за которое в ветке master появляются новые коммиты. Если бы реальный размер вашей функциональной ветки был так же мал, как в примере выше, было бы проще перебазировать ее на ветку master и выполнить ускоренное слияние. В этом случае не потребовалось бы засорять историю проектов лишними коммитами слияния.

Разрешение конфликтов

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

Преимущество слияния в Git заключается в том, что разрешение конфликтов проходит по привычной схеме «изменение — подготовка — коммит». При обнаружении конфликта выполните команду git status, чтобы увидеть, какие файлы необходимо исправить. Так, если в обеих ветках изменена одна и та же часть файла hello.py, вы увидите следующее:

On branch master
Unmerged paths:
(use "git add/rm ..." as appropriate to mark resolution)
both modified: hello.py

Представление конфликтов

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

here is some content not affected by the conflict
<<<<<<< master
this is conflicted text from master
=======
this is conflicted text from feature branch
>>>>>>> feature branch;

Обычно содержимое перед отметкой ======= относится к принимающей ветке, а все, что указано после нее — к ветке, для которой выполняется слияние.

После обнаружения конфликтующих участков кода вы можете исправить их по своему усмотрению. Когда вы будете готовы завершить слияние, выполните команду git add на конфликтующем файле или файлах — так вы сообщите Git, что конфликт разрешен. Затем запустите обычную команду git commit, чтобы создать коммит слияния. Поскольку процесс ничем не отличается от фиксирования обычного снимка состояния, рядовому разработчику не составит труда разрешить конфликты при слиянии.

Обратите внимание, что конфликты возможны только в процессе трехстороннего слияния и не могут возникать при ускоренном слиянии.

Резюме

В этом документе содержится сводная информация о команде git merge. Слияние — необходимый инструмент для работы в Git. Мы познакомились с принципами его работы, а также обсудили различия между ускоренным и полноценным трехсторонним слиянием. Ниже перечислены основные моменты:

1. При слиянии в Git последовательности коммитов объединяются в общую историю.
2. В основном Git выполняет объединение двумя способами: ускоренным и трехсторонним слиянием.
3. Если в обеих последовательностях коммитов нет конфликтующих изменений, Git объединит их автоматически.

В документе также упоминались другие команды Git: git branch, git pull и git fetch. Подробные сведения о них см. на соответствующих страницах.

Git Branch — как перейти на

В Git часто встречаются неправильные представления о ветвлении. Например, некоторые предполагают, что ветвь — это группа коммитов или что ветвь должна расходиться в графе Git.

Фактически, ветвь — это просто указатель на одну конкретную фиксацию.

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

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

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

Узнайте больше о том, как создать ветку в Git, в том числе о том, как использовать одну команду для одновременного создания и извлечения новой ветки.

Как переименовать ветку Git?

Вы можете легко переименовать ветку Git в любое время.

Чтобы удалить ветку Git с помощью терминала, вам нужно будет использовать команду git branch -d вместе с именем локальной ветки, которую вы хотите удалить.Узнайте больше о том, как удалить ветку Git локально.

Чтобы удалить удаленную ветку в Git, вы фактически собираетесь использовать команду git push . Узнайте больше о том, как удалить удаленную ветку в Git.

Как переключить ветку Git?

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

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

Ветвление в Git с помощью GitKraken

Теперь давайте рассмотрим, как работает ветвление, когда вы используете клиент Git, такой как GitKraken, для визуализации своего репозитория.

Управление ветвями Git — PhpStorm

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

Вы также можете управлять ветвями и выполнять пакетные операции с несколькими ветвями на панели «Ветви» окна инструмента Git.

Отметить ветки как избранные

Если у вас много веток, вы можете видеть только свои любимые. Основная ветка по умолчанию помечена как избранная. Избранные ветки всегда отображаются вверху всплывающего окна «Ветви» и на панели «Ветви» окна инструмента Git.

• Чтобы пометить ветку как избранную, во всплывающем окне «Ветви» наведите курсор мыши на имя ветки и щелкните звездочку, которая появляется слева:

  Вы также можете выбрать ветвь на панели «Ветви» в окно инструмента Git и щелкните на панели инструментов.

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

Создать новую ветку

Создать новую ветку из текущей

1. Во всплывающем окне «Ветви» выберите «Новая ветвь» или щелкните правой кнопкой мыши текущую ветвь на панели «Ветви» в окне инструмента окна инструментов Git и выберите «Новая ветвь». .

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

   Новая ветвь начнется с HEAD текущей ветки.

Создать новую ветку из выбранной ветки

1. Во всплывающем окне «Ветви» или на панели «Ветви» окна инструмента Git выберите локальную или удаленную ветку, из которой вы хотите начать новую ветку, и выберите «Новая ветвь из». Выбрано.

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

Создать новую ветвь из выбранной фиксации

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

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

Извлечь ветки (git-checkout)

Извлечь ветку как новую локальную ветку

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

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

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

2. Выберите Checkout из списка действий.

3. При необходимости введите новое имя для этой ветви или оставьте имя по умолчанию, соответствующее удаленной ветви, и нажмите OK.

   Новая локальная ветвь будет настроена для отслеживания исходной удаленной ветки.

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

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

1. Во всплывающем окне «Ветви» или на панели «Ветви» окна инструмента Git выберите ветку, на которую вы хотите переключиться, в разделе «Локальные ветки» и выберите «Оформить заказ» из списка доступных операций.

2. Что произойдет дальше, зависит от того, есть ли конфликты между вашими локальными изменениями, которые вы еще не зафиксировали, и ветвью, которую вы собираетесь проверить:

   • Если ваше рабочее дерево чистое (это означает, что у вас есть нет незафиксированных изменений), или ваши локальные изменения не конфликтуют с указанной веткой, эта ветка будет извлечена (уведомление появится в правом нижнем углу окна PhpStorm).

   • Если ваши локальные изменения будут перезаписаны при оформлении заказа, PhpStorm отображает список файлов, которые не позволяют вам проверить выбранную ветку, и предлагает выбрать между принудительной проверкой и интеллектуальной проверкой.

     Если вы нажмете «Принудительная проверка», ваши локальные незафиксированные изменения будут перезаписаны, и вы потеряете их.

     Если вы нажмете Smart Checkout, PhpStorm отложит незафиксированные изменения, проверит выбранную ветку, а затем уберет изменения. Если во время операции снятия полки возникает конфликт, вам будет предложено объединить изменения. Подробнее см. Разрешение конфликтов.

     Если вы хотите очистить свою рабочую копию, используя тайник вместо полки, в диалоговом окне «Настройки / Предпочтения» Ctrl + Alt + S перейдите в Управление версиями | Git и выберите Shelve под чистым рабочим деревом с помощью настройки.

PhpStorm сохраняет ваш контекст (набор открытых файлов, текущую конфигурацию запуска и точки останова) при условии, что параметр «Восстановить рабочее пространство при переключении ветвей» включен в диалоговом окне «Настройки / Предпочтения» Ctrl + Alt + S под Контроль версий | Подтверждение. Когда вы переключаетесь на ветку, PhpStorm автоматически восстанавливает ваш контекст, связанный с этой веткой.

Сравнить ветви

Сравнить ветвь с текущей веткой

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

1. Во всплывающем окне «Ветви» или на панели «Ветви» окна инструмента Git выберите ветвь, которую нужно сравнить с текущей ветвью, и выберите «Сравнить с текущей».

   В окно инструмента Git будет добавлена ​​новая вкладка, в которой будут перечислены все коммиты, которые существуют в выбранной ветке и не существуют в текущей ветке.

   Вы можете щелкнуть ссылку Swap Branch, чтобы изменить, какая ветвь считается базовой, с которой вы сравниваете другую ветвь.

   Во всплывающем окне «Ветви» или на панели «Ветви» окна инструмента Git выберите ветвь, которую вы хотите сравнить с текущей ветвью, и выберите «Сравнить с текущей».

2. В окно инструмента Git будет добавлена ​​новая вкладка, в которой перечислены все коммиты, которые существуют в выбранной ветке и не существуют в текущей ветке.

   Вы можете щелкнуть ссылку Swap Branch, чтобы изменить, какая ветвь считается базовой, с которой вы сравниваете другую ветвь.

3. Чтобы просмотреть список всех файлов, которые различаются в двух ветвях, нажмите Ctrl + A : на панели «Измененные файлы» будут перечислены все файлы, содержащие различия.

Сравнить ветку с рабочим деревом

Помимо сравнения ветки с текущей ветвью, вы можете сравнить ее с локальным состоянием текущей ветки. Это полезно, если у вас есть локальные незавершенные изменения.

• Во всплывающем окне «Ветви» или на панели «Ветви» окна инструмента Git выберите ветвь, которую вы хотите сравнить с локальным рабочим деревом, и выберите «Показать различия с рабочим деревом».

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

  • Файлы, которые существуют в выбранной ветке и отсутствуют в текущей ветке, отмечены серым .

  • Файлы, которые существуют в текущей ветке, но отсутствуют в выбранной ветке, отмечены зеленым.

  • Файлы, содержащие различия между выбранной и текущей ветвью, отмечены синим цветом.

  Вы можете щелкнуть ссылку Swap Branch, чтобы изменить, какая ветвь будет считаться базовой, с которой вы сравниваете другую ветвь.

  • Чтобы просмотреть различия в конкретном файле, выберите его и щелкните на панели инструментов или нажмите Ctrl + D .

  • Чтобы применить все содержимое файла к текущей ветви, щелкните (подробности см. В разделе «Применить отдельные файлы»).

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

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

1. Найдите ветку, которую собираетесь использовать для дальнейшей работы.

2. Во всплывающем окне «Ветви» или на панели «Ветви» окна инструмента Git выберите ветку, которую нужно удалить, и нажмите «Удалить».

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

Если ветка содержала коммиты, которые еще не были объединены с ее восходящей веткой или с текущая ветка, она все равно будет немедленно удалена (эквивалент git branch --D или git branch --delete --force command), но уведомление также будет содержать ссылку, позволяющую вам просмотреть несоединенные коммиты .

Если удаленная ветвь отслеживала удаленную ветвь, в этом уведомлении также будет ссылка для удаления удаленной ветки.

Если вы закрыли уведомление, а позже решили, что хотите восстановить удаленную ветку, ссылка будет доступна в журнале событий до тех пор, пока вы не перезапустите PhpStorm.

Настроить синхронное управление ветвями

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

1. В диалоговом окне «Настройки / Предпочтения» Ctrl + Alt + S выберите «Управление версиями» | Git.

2. Выберите параметр «Выполнить операции ветвления для всех корней» (обратите внимание, что этот параметр доступен только в том случае, если у вашего проекта несколько корней).

Последнее изменение: 2 февраля 2021 г.

git-new-branch (1)

  $ git map-branch -v
происхождение / хозяин
  cool_feature [впереди 4]
    подфункция [впереди 2 | позади 1]
  fixit [впереди 2]
    Frozen_branch * [впереди 3]
$ git new-branch independent_cl
$ git карта-ветки -v
происхождение / хозяин
  cool_feature [впереди 4]
    подфункция [впереди 2 | позади 1]
  fixit [впереди 2]
    Frozen_branch [впереди 3]
  независимый_cl *
$ vi foo && git add -A && git commit -m foo
$ git карта-ветки -v
происхождение / хозяин
  cool_feature [впереди 4]
    подфункция [впереди 2 | позади 1]
  fixit [впереди 2]
    Frozen_branch [впереди 3]
  независимый_cl * [впереди 1]
$ git new-branch - вложенная функция восходящего потока nested_cl
$ git карта-ветки -v
происхождение / хозяин
  cool_feature [впереди 4]
    подфункция [впереди 2 | за 1]  <1> 
      вложенный_cl *
  fixit [впереди 2]
    Frozen_branch [впереди 3]
  independent_cl [впереди 1]
$ git checkout cool_feature
Перешел на ветку cool_feature
Ваша ветка опережает origin / master на 4 коммита.(используйте "git push" для публикации ваших локальных коммитов)
$ git новая ветка --upstream_current cl_depends_on_cool_feature
$ git карта-ветки -v
происхождение / хозяин
  cool_feature [впереди 4]
    cl_depends_on_cool_feature *
    подфункция [впереди 2 | позади 1]
      вложенный_cl
  fixit [впереди 2]
    Frozen_branch [впереди 3]
  independent_cl [впереди 1]
Подфункция $ git checkout
Переключен на ветку subfeature
Ваша ветка и cool_feature разошлись,
и имеют 2 и 1 разные коммиты соответственно.(используйте "git pull", чтобы объединить удаленную ветку с вашей)
$ git новая ветка --inject_current injected_cl
$ git карта-ветки -v
происхождение / хозяин
  cool_feature [впереди 4]  <1> 
    cl_depends_on_cool_feature
    injected_cl *
      подфункция [впереди 2 | позади 1]
        вложенный_cl
  fixit [впереди 2]
    Frozen_branch [впереди 3]
  independent_cl [впереди 1]
  

Как удалить, оформить, создать и переименовать ветку в Git

Git Branch

Функции ветвления Git позволяют создавать новые ветви проекта для проверки идей, выделения новых функций или экспериментов, не влияя на основной проект.

Оглавление

Просмотр веток

Чтобы просмотреть ветки в репозитории Git, выполните команду:

  git branch  

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

  git branch -a  

Рядом с веткой, в которой вы сейчас находитесь, будет звездочка (*).

Есть несколько различных опций, которые вы можете включить в git branch , чтобы увидеть различную информацию.Для получения дополнительных сведений о ветвях вы можете использовать параметр -v (или -vv , или --verbose ). Список веток будет включать значение SHA-1 и строку темы фиксации для HEAD каждой ветки рядом с ее именем.

Вы можете использовать параметр -a (или --all ), чтобы показать локальные ветки, а также любые удаленные ветки для репозитория. Если вы хотите видеть только удаленные ветки, используйте параметр -r (или --remotes ).

Оформить ветку

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

  git checkout ИМЯ ОТВЕТА  

Как правило, Git не позволит вам проверить другую ветку, если ваш рабочий каталог не чист, потому что вы потеряет все изменения рабочего каталога, которые не были зафиксированы. У вас есть три варианта обработки ваших изменений:

1. удалить их (подробности см. В Git checkout) или
2. зафиксировать их (подробности см. В Git commit) или
3. спрятать (подробности см. В Git stash).

Создать новую ветку

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

  git branch NEW-BRANCH-NAME  

Обратите внимание, что эта команда создает только новую ветку. Вам нужно будет запустить git checkout NEW-BRANCH-NAME , чтобы переключиться на него.

Есть ярлык для одновременного создания и оформления покупки новой ветки. Вы можете передать опцию -b (для ветки) с помощью git checkout . Следующие команды делают то же самое:

  # Двухэтапный метод
git ветка NEW-BRANCH-NAME
git checkout NEW-ФИЛИАЛ

# Ярлык
git checkout -b NEW-BRANCH-NAME  

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

Переименовать ветку

Чтобы переименовать ветку, выполните команду:

  git branch -m OLD-BRANCH-NAME NEW-BRANCH-NAME

# Альтернатива
git branch --move OLD-BRANCH-NAME NEW-BRANCH-NAME  

Удалить ветку

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

  git branch -d BRANCH-TO-DELETE

# Альтернатива:
git branch --delete ФИЛИАЛ ДЛЯ УДАЛЕНИЯ  

Ветвь, на которую вы переключаетесь, имеет значение.Git выдаст ошибку, если изменения в ветке, которую вы пытаетесь удалить, не будут полностью объединены с текущей веткой. Вы можете переопределить это и заставить Git удалить ветку с опцией -D (обратите внимание на заглавную букву) или используя опцию --force с -d или --delete :

  git branch -D ОТВЕТИТЬ ДЛЯ УДАЛЕНИЯ

# Альтернативы
git branch -d --force ОТРАБОТАТЬ ДЛЯ УДАЛЕНИЯ
git branch --delete --force BRANCH-TO-DELETE  

Сравнить ветви

Вы можете сравнить ветки с помощью команды git diff :

  git diff FIRST-BRANCH..SECOND-BRANCH  

Вы увидите цветной вывод для изменений между ветвями. Для всех строк, которые были изменены, версия ВТОРАЯ ВЕТКА будет зеленой линией, начинающейся с «+», а версия ПЕРВАЯ ВЕТКА будет красной линией, начинающейся с «-». Если вы не хотите, чтобы Git отображал две строки для каждого изменения, вы можете использовать параметр --color-words . Вместо этого Git покажет одну строку с удаленным текстом красным цветом и добавленным текстом зеленым.

Если вы хотите увидеть список всех ветвей, которые полностью объединены в вашу текущую ветку (другими словами, ваша текущая ветка включает все изменения других веток, которые перечислены), выполните команду git branch - объединены .

Справка по Git Branch

Если вы забыли, как использовать параметр, или хотите изучить другие функции, связанные с командой git branch , вы можете запустить любую из этих команд:

  git help branch
git ветка --help
man git-branch  

Дополнительная информация:

24. Создание ветки

Голы

• Научиться создавать локальную ветку в репозитории

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

01 Создать филиал

Назовем нашу новую ветку «стилем».

Пробег:

 git checkout -b стиль
git статус 

Примечание: git checkout -b <имя ветки> — это ярлык для git branch <имя ветки> , за которым следует git checkout <имя ветки> .

Обратите внимание, что команда git status сообщает, что вы находитесь в ветке стиля.

02 Добавить файл style.css

Пробег:

 сенсорная библиотека / style.css 

Файл:

lib / style.css

 h2 {
  красный цвет;
} 

Пробег:

 git добавить lib / style.css
git commit -m "Добавлена ​​таблица стилей css" 

03 Изменить главную

Обновите файл hello.html , чтобы использовать стиль.css.

Файл:

lib / hello.html

 

  
   
  
  
    
 Привет, мир! 
 
 

Пробег:

 git добавить lib / hello.html
git commit -m "Hello использует style.css" 

04 Изменить index.html

Обновите индекс .html , поэтому он использует style.css

Файл:

index.html

 
  <заголовок>