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

Как создать новую ветку в 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 branch | Atlassian Git Tutorial

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

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

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

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

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

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

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

Распространенные опции

git branch

Отображение списка веток в репозитории. Это синоним команды git branch --list.

git branch 

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

git branch -d 

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

git branch -D 

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

git branch -m 

Изменение имени текущей ветки на .

 git branch -a

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

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


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

Затем вы создаете новую ветку с помощью следующей команды.

git branch crazy-experiment

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

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

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


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

 $ git remote add new-remote-repo https://bitbucket.com/user/repo.git # Добавление удаленного репозитория в конфигурацию локального репозитория $ git push  crazy-experiment~ # Отправка ветки crazy-experiment в новый удаленный репозиторий new-remote-repo

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

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


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

git branch -d crazy-experiment

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

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

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

git branch -D crazy-experiment

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

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

 git push origin --delete crazy-experiment

или

git push origin :crazy-experiment

Эта команда отправит удаленному репозиторию сигнал на удаление ветки crazy-experiment.

Резюме


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

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

Где и Как использовать Git Branch: Ветвление в Git

VPS

access_time

16 января, 2020

hourglass_empty

3мин. чтения

Git – это инструмент, используемый разработчиками для контроля версий их приложений. Он очень популярен и используется на многих серьёзных проектах, таких как GNOME и другие. Одной из важнейших функций Git является контроль над ветками разработки, что помогает улучшить процесс реализации проекта. Вот почему в этом руководстве мы покажем вам, как использовать git branch, или ветки Git. Любой проект, в том числе и проекты на основе VPS, определённо выиграет от этой замечательной функции.

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

Что Такое Git Branch

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

Использование Git Branches имеет несколько преимуществ. Тем не менее, мы хотим подчеркнуть следующие два:

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

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

Где и как использовать Git Branch

Не забудьте получить доступ к вашему серверу по SSH перед запуском. Вот руководство по PuTTY, которое вам поможет!

Работать с Git branches довольно просто, это видно из самих команд. Но, как и в большинстве других случаев, чем больше у вас веток, тем сложнее управлять ими.

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

git branch

Если вы не создали ни одной Git branch, в терминале не будет выходных данных. Создать ветку действительно просто:

git branch [new_branch]

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

git checkout [new_branch]

Результат сообщит нам, что мы перешли в новую ветку. Мы назвали её тестовой, так что мы увидим следующее сообщение:

Switched to branch ‘test’

Теперь в этой новой ветви разработки мы можем создать столько модификаций кода, сколько захотим, без необходимости что-либо менять в основной Git branch. Как мы видим, это поддерживает готовность программы к добавлению новых частей кода.

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

git branch

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

Если мы хотим удалить ветку из Git, мы можем сделать это с помощью следующей команды:

git branch -d [branch_name]

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

git checkout master

git branch -d test

Наконец, наступил момент, когда мы внесли много изменений в ветку разработки и она превратилась в стабильную, поэтому мы хотим связать её с другой веткой разработки. Для этого и существует команда слияния (merge).

Сначала найдите ветку разработки, к которой должна быть присоединена другая ветка. Например, мы хоти прикрепить тестовую ветвь к основной ветке – master branch. Для этого мы должны перейти в master branch и осуществить merge с помощью команды:

git merge [branch]

Как видите, основные функции ветки Git довольно просты. Вам просто нужно знать основы и стараться поддерживать порядок в своём проекте.

Выводы

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

В этой статье мы научили вас основам работы с ветками Git.

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

Правила работы с git | Flexberry PLATFORM Documentation

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

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

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

GitHub — это один из популярных хостингов git-репозиториев.

Основные команды для работы с git

Для работы с git можно использовать GUI-приложения (в т.ч. интерфейсы для работы с git в Visual Studio и WebStorm), но в большинстве случаев, с git работают из консоли (эмулятор терминала).

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

Клонирование существующего репозитория

Для получения копии существующего Git-репозитория, например, проекта, в который надо внести изменения, необходимо использовать команду git clone.

# Клонирование репозитория осуществляется командой git clone [URL].
git clone https://github.com/Flexberry/ember-flexberry.git

Ветвление

Ветвление используется для одновременной и независимой разработки. Основной веткой является master или develop. Другие ветки — это исправления и изменения которые еще не добавлены в основную ветку.

Для переключения между ветками, необходимо использовать команду git checkout <имя ветки>.

Сделать новую ветку и переключится сразу на нее, можно выполнив команду git checkout -b <имя новой ветки>.

Note: При создании веток соблюдайте правила их именования. Если ветка для добававления новой функциональность, то ее название должно иметь вид: feature-<номер задачи если есть>-<заголовок задачи>. Если ветка для исправлений, то fix-<номер задачи если есть>-<заголовок задачи>.

# Переключиться на ветку от которой надо наследоватся (обычно это основная ветка master или develop)
git checkout develop

# Получить последнии изменения для текущей ветки.
git pull

# Создать новую ветку.
git checkout -b <имя новой ветки>

Слить ветку в текущую, можно командой: git merge <ветка>.

Запись изменений в репозииторий

Область подготовленных изменений (staging area) — область куда попадают изменения(файлы), которые надо включить в коммит.

Добавить изменения в staging area — git add <имя файла> или git add * если надо включить все изменения.

Удалить изменения из staging area — git checkout -- <имя файла> или git checkout -- * если надо удалить все изменения.

Просмотреть содержимое рабочей директории и staging area — git status

Зафиксировать(сохранить) подготовленные изменения в локальном репозитории — git commit -m "Комментарий к коммиту"

Note: Создавая коммит, надо использовать принятый в команде стандарт Conventional Commits.

Работа с удаленным репозиторием

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

Получить последние изменения, сделанные в ветке, с удаленного репозитория — git pull

Отправить зафиксированные изменения из локального репозитория в удаленный — git push origin <ветка>

Полезные ссылки

Please enable JavaScript to view the comments powered by Disqus.

Шпаргалка по Git. Решение основных проблем — Блог HTML Academy

Перевод проекта First Aid Git от команды HTML Academy.

Восстановление накопленных изменений


В том случае, если изменения, внесённые пользователем, находятся в режиме накопления, применить их к ветке можно с помощью команды git stash apply. Также можно запустить git diff — эта команда поможет выявить различия. Для того, чтобы затем избавиться от накопленных данных, нужно запустить команду:

git stash drop


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

git stash list затем можно применить его, воспользовавшись его индексом:

git stash@{1}


Необходимо учитывать, что отсчёт индексов ведётся от нуля.

Восстановление удалённого тега


В том случае, если необходимо восстановить случайно удалённый тег, начать можно с его поиска:

git fsck --unreachable | grep tag


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

git update-ref refs/tags/название-тега

Восстановление удалённого файла


Если вы случайно удалили файл, его можно быстро восстановить:

git checkout myfile.txt


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

git checkout $commit~1 myfile.txt

Восстановление удалённой ветки


С помощью комманды git reflog можно узнать хеш (SHA1) последнего коммита в удалённой ветке. Скопируйте этот хеш и используйте в команде:

git checkout <sha>


После этого восстановить удалённую ветку можно будет вот такой командой:

git checkout -b <название-ветки>

Изменение сообщения коммита перед его отправкой


Изменить сообщение коммита можно с помощью команды git commit --amend, она откроет редактор, в котором можно будет внести необходимые поправки в последнее сообщение.


Сообщение можно изменить и напрямую с помощью команды

git commit --amend -m "Новое прекрасное сообщение"

Изменение сообщения коммита после его отправки


В данном случае процесс занимает два шага. Сначала нужно изменить сообщение с помощью комманды git commit --amend, а затем перезаписать историю коммитов локальной ветки: git push <remote> <branch> --force

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

Использование алиасов команд в командной строке


Устали каждый раз печатать git status? Этой команде можно присвоить простой алиас, который проще и быстрее вбивать в git.

git config --global alias.st status


— теперь нужно писать только git st


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

git config --global alias.logme 'log -p --author=Rob'


Теперь алиас git logme будет выводить все наши коммиты.

Коммит в неправильную ветку


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

git checkout -b название-новой-ветки.


А затем переключиться к оригинальной ветке:

git checkout название-оригинальной-ветки


…и «откатиться» до последнего коммита, который нужно сохранить.


Чтобы это сделать, можно воспользоваться командой git log и сохранить хеш (SHA1) последнего коммита, который нужно оставить.. Например, это a31a45c.


Теперь его нужно сбросить: git reset --hard a31a45c и отправить получившийся результат.

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

Обновление конкретного подмодуля


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

git submodule update --remote --merge <path>

Откат к конкретному коммиту в истории


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

git reset --hard HEAD~1


Эта команда установит HEAD на конкретный коммит. Также можно воспользоваться хешем коммита.

Отмена коммита до публикации изменений


Если вы сделали коммит, который впоследствии понадобилось отредактировать или полностью стереть, поможет команда git reset.


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

git revert -n HEAD

Отмена локальных изменений файлов


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

git checkout myfile.txt


Кроме того, можно восстановить конкретный путь к файлу:

git checkout -- путь-до-файла

Отображение всех коммитов одного файла


Если вы хотите просмотреть все коммиты с изменениями конкретного файла, воспользуйтесь командой git log --follow -p -- myfile


Аргумент —follow позволяет вывести все изменения над файлом, даже если в процессе работы он был переименован.


Если опустить опцию -p, то система выведет только сообщения коммитов, но не их содержимое.

Отображения числа коммитов от каждого участника


Хотите узнать, сколько коммитов сделал каждый участник команды?


Эта команда выведет список, отсортированный в порядке убывания количества коммитов: git shortlog -s -n

Отобразить коммиты, содержащие удалённые файлы


Узнать, в каких коммитах содержатся удалённые файлы, можно с помощью команды:

git log --diff-filter=D --summary


Она покажет список коммитов, в которых удалялись файлы.

Отсортировать коммиты по автору


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

git log --author="Имя автора"

Очистка всех скрытых состояний


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

git stash clear

Переименование локальной и удалённой ветки


Предложим, у вас есть ветка «fix-bug25», которую вы захотели переименовать в «hotfix-users». Прежде всего, нужно будет изменить локальную ветку:

git branch -m fix-bug25 hotfix-users


А затем — удалённую ветку: переименовать её напрямую нельзя, поэтому нужно будет её удалить, и затем опубликовать заново уже с новым именем. Прежде чем приступать к этим процедурам, следует убедиться, что никто из членов команды не работает с этой веткой! Удаляем ветку: git push origin :fix-bug25


А теперь заново публикуем её с новым именем: git push origin hotfix-users

Переименование тега


Чтобы переименовать существующий тег:

git tag новое-название-тега старое-название-тега
git tag -d старое-название-тега
git push origin :refs/tags/старое-название-тега
git push --tags

Перестать отслеживать существующие файлы


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

git rm -r --cached


Она удалит изменённые файлы из зоны подготовленных файлов (staging area). Затем нужно запустить команду:

git add . 


и отправить изменения.

Подготовка удалённых файлов


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

git add -u


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

git add -u .

Поиск конкретного сообщения во всех коммитах


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

git log --grep <запрос>

Пометить конфликтующий файл, как разрешённый


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

git add название-файла


Затем можно запустить git commit, чтобы разрешить конфликты и опубликовать изменения.

Просмотр всех неотправленных коммитов


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

git log --branches --not --remotes


Кроме того, можно использовать:

git log origin/master..HEAD

Просмотр старой ревизии файла


Существует возможность просмотреть содержимое файла в конкретный момент времени в прошлом. Для этого нужно использовать команду:

git show commitHash:myfile.txt

Публикация локальной ветки для удалённого редактирования


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

git push -u origin название-моей-новой-ветки


Теперь они тоже смогут вносить изменения в эту ветку.

Сброс локальной ветки до состояния удалённой


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


Прежде всего нужно получить свежие обновления из удалённой ветки:

git fetch название-удалённой-ветки.


А затем нужно сообщить git, что локальную ветку следует «откатить» до состояния удалённой:

git reset --hard origin/название-локальной-ветки.


При наличии коммита, который нужно сохранить, перед сбросом нужно создать новую ветку и произвести коммит: git commit -m «Обновление»

git branch название-новой-ветки

Синхронизировать ветку с master-репозиторием


Чтобы синхронизировать последние изменения в репозитории master (или с любой другой веткой, с которой вы работали) необходимо «перебазировать» локальную ветку. Предположим, вы работаете над веткой foobar:

git checkout foobar


А затем осуществляете «перебазирование»:

git rebase master


После этого будут применены коммиты origin из master. После разрешения конфликтов процесс можно продолжить с помощью команды git rebase —continue. Теперь можно продолжать работу над своей веткой или осуществить её слияние (merge) с главным репозиторием.

Слияние локальных изменений с другой веткой


Это можно сделать прямо в процессе стандартного слияния (merge). Вам стоит сохранить историю слияний используя флаг —no-ff, что означает no fast forward.


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

git merge <другая-ветка> --no-ff


Затем появится сообщение о коммите merge X into Y branch, после чего вы можете смело запушить ваше слияние.>

Совмещение двух и более коммитов


Здесь нам понадобится произвести интерактивное перебазирование. Если перебазирование происходит относительно master-ветки, то начать следует с команды git rebase -i master. Однако, если перебазирование происходит не относительно ветки, то нужно будет перебазироваться относительно HEAD.


Если есть необходимость в совмещении двух последних коммитов, можно использовать команду

git rebase -i HEAD~2.


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

Совмещение коммитов по конкретной функции для добавления в ветку релиза


Если вы решите совместить и опубликовать коммиты, то возникнет новый коммит в ветке релиза, поэтому история ветки конкретной функции останется неизменной.


Ниже представлен пример того, как достичь подобного эффекта:

git fetch origin
git checkout [release-branch]
git rebase origin/[release-branch]
git merge —squash —no-commit [feature-branch]
git commit -m 'Merge X into Y'


В конечном итоге останется только один коммит в ветке релиза, а история изменений в ветке разработки конкретной функции останется нетронутой.

Подробнее о ветках функций

Создание новой ветки с изменениями текущей


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

git checkout -b название-моей-новой-ветки


Эта команда перенесёт файлы из текущей ветки в новую, которую потом уже можно «закоммитить».

Убрать файл из буфера


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

git reset HEAD unlovedfile.txt

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


Если вы хотите удалить ветку, введите команду:

git push origin --delete название-ветки

Удаление неотслеживаемых файлов и папок


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

git clean -f


Чтобы в принципе удалить их:

git clean -fd


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

git clean -n

Удаление старых веток, стёртых из внешнего репозитория


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

git-remote prune название-удалённой-ветки.


Она удалит старую ветку под названием название-удалённой-ветки, которая уже была стёрта из внешнего репозитория, но всё ещё доступна локально в remotes/название-удалённой-ветки.

Удаление файла из git с сохранением его локальной копии


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

git rm --cached myfile.txt

Без Гита и жизнь не та

Получите практику в Git на курсах HTML Academy. Мы расскажем всё, что знаем сами, чтобы вы прокачали навыки в веб-разработке.

Узнать больше

руководство для начинающих. Часть 2

Часть 1, Часть 2

Рабочий процесс на 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.

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

<figure><iframe src="/media/645604587ba05da2b5095a0cb2cf64e5" allowfullscreen=""></iframe></figure>

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

Перевод статьи Anne Bonner: Getting started with Git and GitHub: the complete beginner’s guide

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

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

Есть несколько разных вариантов использования при создании веток в Git. Давайте рассмотрим каждый из них по очереди.

Как мне создать новую ветку на основе текущего HEAD ?

Чтобы создать новую ветку, основанную на вашей текущей ветке (HEAD), просто используйте «git branch» с именем новой ветки в качестве единственного параметра:

  $ git branch <новая ветка>
  

Как мне создать новую ветку на основе существующей ветки ?

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

  $ git branch <новая-ветка> <базовая-ветка>
  

Если вы используете клиент Tower Git, вы можете просто использовать перетаскивание для создания новых веток (а также для слияния, выбора вишни и т. Д.):

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

Если вы хотите запустить новую ветку на основе определенной фиксации (а не ветки), вы можете указать хеш фиксации в качестве отправной точки:

  $ git branch <новая ветка> f71ac24d
  

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

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

  $ git branch <новая ветка> v1.2
  

Как мне создать новую ветку из удаленной ветки ?

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

  $ git branch --track <новая-ветка> origin / <базовая-ветка>
  

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

  $ git checkout --track origin / 
  

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

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

  $ git push -u origin <локальная-ветка>
  

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

Что делает команда «git branch»?

Команда «git branch» используется для множества задач:

• создание новых местных филиалов
• удаление существующих локальных или удаленных филиалов
• со списком локальных и / или удаленных филиалов
• со списком ветвей, например еще не объединены

Узнать больше

«Git create branch» — Как создать ветку в git [Учебник]

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

‍

Если вы работаете в терминале и хотите создать ветку, вы можете попробовать ` git создать ветку my-branch`.Синтаксис интуитивно понятный, короткий и, к сожалению, не существует.

Вместо этого вы остаетесь с этой командой:

git checkout -b моя ветка

‍

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

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

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

‍

Что такое филиал?

‍

Чтобы понять, что такое ветвление, давайте углубимся в документацию Git по ветвлению. Вот что они говорят:

Ветвь в Git — это просто легкий подвижный указатель на [фиксацию]. Имя ветки по умолчанию в Git — master. Когда вы изначально делаете коммиты, вам дается главная ветка, которая указывает на последнюю сделанную вами фиксацию.Каждый раз, когда вы делаете коммит, он автоматически продвигается вперед.

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

Однако, если ветка является просто «указателем» или ссылкой на конкретную фиксацию, то эта ментальная модель вообще не работает.Ветви, являющиеся указателями, подразумевают, что Git хранит свои данные в плоской структуре, а не в виде каталога, что на самом деле верно! Фактически, все коммиты находятся рядом друг с другом на одном уровне. Подумайте об этом — у вас никогда не будет ветки внутри другой ветки. Ясно, что мы здесь не имеем дело с папками.

Тогда возникает другой вопрос: как коммиты упорядочиваются последовательно? То есть, как узнать, какие коммиты в ветке совершает другой, если ветка — это просто указатель на одну единственную фиксацию?

Опять же, в документации Git есть ответ.

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

Не только ветки указывают на коммиты, но и сами коммиты могут указывать на другие коммиты. Когда вы запускаете `git log` или какую-либо другую утилиту или просматриваете коммиты на GitHub, эти инструменты проверяют отношения между коммитами, чтобы представить их по порядку.

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

‍

Что делает команда проверки?

‍

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


git checkout моя существующая ветка


‍

Команда `checkout` находит фиксацию, на которую ссылается переданная ей ветвь, затем обновляет все файлы на вашем жестком диске (файлы в вашем« рабочем дереве »), чтобы они соответствовали файлам, хранящимся в этом совершить.

Он также переключает ваш текущий HEAD на эту ветку, так что если вы создаете новую фиксацию, эта фиксация сохранит указатель на последнюю фиксацию, сделанную в извлеченной ветке.

Обычно эта команда используется для проверки уже существующих ветвей. Однако, когда мы передаем флаг «-b», эта команда создаст ветку с этим именем и обновит HEAD, чтобы указать на эту ветку.

Это поведение дает тот же результат, что и выполнение этих двух команд по порядку:


git ветка имя моей ветки



git checkout имя-ветки


‍

Отправка ветки в исходную точку

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


git push —set-upstream origin my-branch-name


‍

Эта команда сообщает удаленному серверу, что новая ветка была создана локально, чтобы он мог воссоздать ту же ветку.

Флаг —set-upstream создает связь между ветвью на сервере и этой ветвью локально. Интересно, что эта связь не устанавливается автоматически Git — это потому, что локальная ветвь на самом деле может быть связана с ветвью с совершенно другим именем на сервере.

‍

Лучшие практики для создания и присвоения имен веткам

‍

Теперь, когда вы разобрались с основами создания веток, самое время рекомендовать использовать некоторые передовые методы — в общем, вам следует придерживайтесь того, что называется «git flow» для управления вашим репозиторием.Если вы не являетесь индивидуальным разработчиком, работающим над побочным проектом, его, вероятно, стоит использовать.

Git flow — это методология создания, наименования и слияния ветвей, которая постоянно поддерживает вашу кодовую базу в «чистом» состоянии, так что вы можете объединять запросы на вытягивание и создавать выпуски плавно и без ошибок. О том, как это работает, читайте в блоге его автора Винсента Дриссена.

Конечно, есть и другие шаблоны — они всегда есть — если вы тоже заинтересованы в их проверке, прочтите этот ответ о переполнении стека.

Удачного кодирования!

‍

Как создать ветку Git — devconnected

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

При разработке новой функции вы будете делать это отдельно, создав новую ветку Git.

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

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

В этом руководстве мы увидим, как вы можете легко создать ветку Git.

Создать ветку Git с помощью проверки

Самый простой способ создать ветку Git — использовать команду «git checkout» с параметром «-b» для новой ветки. Далее вам просто нужно указать имя ветки, которую вы хотите создать.

  $ git checkout -b <имя-ветки>  

В качестве примера предположим, что вы хотите создать новую ветку Git из основной ветки с именем «feature»

.

Для этого вы запустите команду «git checkout» с параметром «-b» и добавите «feature» в качестве имени ветки.

  $ git checkout -b функция
Перешел на новую функцию ветки  

Как видите, используя команду «git checkout», вы создаете новую ветку и автоматически переключаетесь на эту новую ветку.

Но что, если вы хотите создать ветвь Git без автоматического переключения на новую ветку?

Создать ветку Git без переключения

Чтобы создать новую ветку Git, не переключаясь на эту новую ветку, вы должны использовать команду «git branch» и указать имя создаваемой ветки Git.

  $ git branch   

Позже вы можете переключиться на новую ветку Git с помощью функции «git checkout».

  $ git checkout <имя_отрасли>  

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

  $ функция ветки git  

Вы можете проверить существующие ветки, запустив команду «git branch» с параметром «-a» для всех ветвей.

  $ git branch -a  

Отлично, вы успешно создали новую ветку Git и переключились на нее с помощью команды checkout.

Создать ветку Git из коммита

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

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

Чтобы создать ветку Git из фиксации, используйте команду «git checkout» с параметром «-b» и укажите имя ветки, а также фиксацию, из которой будет создана ветка.

  $ git checkout -b <имя_отрасли>   

Кроме того, вы можете использовать команду «git branch» с именем ветки и SHA фиксации для новой ветки.

  $ git branch <имя_ответки>   

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

Чтобы получить SHA коммитов из вашей истории, вы должны использовать «git log» с опцией «–oneline».

  $ git log --oneline --graph

* 9127753 (HEAD -> master) Зафиксировать 3
* f2fcb99 Коммит 2
* cab6e1b (origin / master) master: начальная фиксация  

Чтобы создать новую ветку Git из второй фиксации (f2fcb99), вы должны запустить следующую команду

  $ git checkout -b функция f2fcb99
Перешел на новую ветку с названием «функция»  

Используя команду «git log», вы можете проверить, что ваша ветка была создана на основе второй фиксации вашей истории.

  $ git log --oneline --graph

* f2fcb99 (HEAD -> feature) Commit 2
* cab6e1b (origin / master) master: начальная фиксация  

Прекрасно, вы успешно создали новую ветку Git из определенного коммита!

Создать ветку Git из тега

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

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

Чтобы создать новую ветку Git из тега, используйте команду «git checkout» с параметром «-b» и укажите имя ветки, а также имя тега для вашей новой ветки.

  $ git checkout -b <имя_отрасли> <имя_ тега>  

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

  $ git branch <имя_ответки> <имя_ тега>  

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

Чтобы перечислить существующие теги, вы можете использовать команду «git tag». В качестве альтернативы вы можете использовать команду «git log», чтобы определить тег, связанный с фиксацией.

  $ git tag
Версия 1.0  

Теперь, когда вы определили свой тег, вы можете создать из него новую ветку с помощью команды «git checkout».

  $ git checkout -b функция v1.0  

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

В качестве альтернативы вы могли бы использовать «ветвь git» для создания этой ветки.

  $ функция ветки git v1.0  

Примечание о неоднозначных именах

Когда вы создаете новые объекты Git (будь то ветки, теги или коммиты), вы можете столкнуться с этой ошибкой

  фатальный: неоднозначное имя объекта: <объект>  

Так почему же возникает эта ошибка?

Это исключение возникает, когда два объекта называются одинаково: например, ветвь и тег.

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

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

Если вы создаете новую ветку из тега с именем «v1.0», но одна из ваших ветвей уже имеет имя «v1.0», вы увидите эту ошибку

  $ git checkout -b функция v1.0
предупреждение: refname 'v1.0' неоднозначно.
предупреждение: refname 'v1.0 'неоднозначно.
фатальный: неоднозначное имя объекта: 'v1.0'.  

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

Для устранения неоднозначной записи просто добавьте обозначение refs к неоднозначному объекту

  $ git checkout -b функция refs / tags / v1.0
Перешел на новую ветку 'особенность'  

Заключение

В этом руководстве вы узнали, как легко создавать ветки Git с помощью команды «git checkout».

Вы также узнали, что можете использовать команду «git branch», если не хотите автоматически переключаться на новую ветку.

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

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

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

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

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

Должно получиться примерно так:

 функция ветки git-A 

Это создаст ветку Git для вашей текущей извлеченной ссылки.

Как вы просматриваете свой список веток Git?

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

Как оформить заказ на новую ветку Git?

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

 функция проверки git-A 

Как вы одновременно создаете и проверяете ветку Git?

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

Вы можете объединить два действия по созданию и извлечению ветки в Git с помощью:

 git checkout -b <название ветки> 

Это создаст новую ветку и сразу проверит ветку.

Как создать ветку в GitKraken?

Для сравнения: если вы используете клиент GitKraken Git для визуализации своего репозитория, создание ветки станет еще проще.

Как создавать ветви в Git — Linux Подсказка

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

В этой статье я собираюсь поговорить об очень важной особенности Git, ветки Git. Итак, приступим.

Филиалов Git:

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

Что ж, вы можете создать новую ветку Git в своем проекте, а затем начать тестировать свои идеи в новой ветке.Если вам это нравится, вы можете объединить его с веткой master . Если он вам не нравится, вы можете в любой момент отказаться / удалить его. Это не повлияет на вашу оригинальную работу.

Обратите внимание, что ветка master является ветвью по умолчанию в Git. Он автоматически создается и используется при инициализации нового репозитория Git.

В следующих разделах этой статьи я покажу вам, как создавать ветки Git, использовать ветки Git и удалять ветки Git. Итак, вперед.

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

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

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

$ git clone https://github.com/shovon8/angular-hero-api

После клонирования репозитория Github перейдите в каталог проекта следующим образом:

Список существующих веток Git:

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

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

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

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

$ Новые возможности ветки git

Новая ветка new-features должна быть создана из HEAD (последняя фиксация) ветки master .

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

Оформить заказ в филиалы Git:

Ранее вы создали новую ветку Git new-features . Но он не активен, как вы можете видеть на скриншоте ниже.

Активация ветки в Git называется оформлением заказа.

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

$ Новые возможности git checkout

Теперь, если вы перечислите все ветви, вы должны увидеть, что ветка с новой функцией активна.

Создание и выписка из нового филиала:

Если вы не хотите сначала создавать ветку, а потом проверять ее с помощью двух разных команд, то у Git есть решение для вас. Вы можете создать и оформить заказ в свою недавно созданную ветку одновременно с помощью одной команды. Для этого вы можете использовать опцию -b из git checkout .

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

$ git checkout -b новая функция

Подтверждение изменений в ветвях Git:

После оформления заказа в новую ветку new-features вы можете начать добавлять новые коммиты в эту ветку.

Например, я изменил файл package.json в моем репозитории Git, как вы можете видеть из команды git status :

Теперь вы можете добавлять новые коммиты в новую ветку new-features , как вы можете видеть на скриншоте ниже.

$ git add -A
$ git commit -m ‘исправленные версии пакета в файле package.json’

Как видите, новый коммит добавлен в ветку с новой функцией .

Теперь, если вы перейдете в ветку master , вы не увидите новую фиксацию. Новый коммит доступен только в ветке new-features , пока вы не объедините две ветки.

Создание новой ветви из другой ветви или фиксации:

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

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

Чтобы создать новую ветку (скажем, test ) из HEAD (последняя фиксация) другой ветки (скажем, new-features ), выполните следующую команду:

$ git branch test новые возможности

Как видите, ветка test и new-features имеют одинаковую историю фиксации.

Допустим, вы хотите создать новую ветку test2 из существующей фиксации из другой ветки master .

Сначала перечислите все коммиты с помощью следующей команды:

$ git log –oneline master

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

Теперь предположим, что вы хотите использовать для фиксации 45c336e в качестве HEAD (последняя фиксация) новой ветки test2 .Для этого выполните следующую команду.

$ git branch test2 45c336e

Как видите, новая ветка test2 имеет до 45c336e коммитов.

Вот как вы создаете ветки в Git. Спасибо, что прочитали эту статью.

Как создавать ветки и объединять их с помощью Git

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

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

Введение

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

Давайте теперь посмотрим на использование этих команд в контексте поддержки и улучшения нашего сайта.

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

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

Мы создадим новую ветку под названием cart :

  $ git checkout -b cart
Перешел на новую ветку "тележка"
  

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

  $ git branch cart
$ git кассира
  

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

Другой филиал

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

  $ git checkout -b bugfix
Перешел на новую ветку bugfix
  

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

  $ git commit -m "fixed the bug"
[bugfix c42b77e] исправленная ошибка
1 файл изменен
  

А теперь отправьте ветку в наш удаленный репозиторий:

  $ git push -u origin buxfix
* [новая ветка] исправление -> исправление
Исправление ошибки ветки, настроенное для отслеживания исправления ошибки удаленной ветки из источника
  

Объединение ветки

Мы протестировали исправление и остались довольны, поэтому давайте объединим это изменение в мастер.Но сначала нам нужно вернуться к нашей основной ветке:

  $ git checkout master
Перешел на ветку master
В вашей ветке установлена ​​последняя версия "origin / master"
  

Теперь мы можем объединить наше исправление:

  $ git merge bugfix
Обновление 68fb3f6..c42b77e
Перемотка вперед
index.html | 1
1 файл изменен
  

И нажмите на GitHub:

  $ git push origin master
Всего 0 (дельта 0), повторно используется 0 (дельта 0)
на [email protected]: adamw / first-project / repository.мерзавец
68fb3f6..c42b77e мастер -> мастер
  

Уборка

Все выглядит хорошо, ошибка исправлена ​​и развернута. Удалим нашу ветку с исправлением ошибок:

  $ git branch -d bugfix
Исправление удаленной ветки (было c42b77e)
  

Мы также захотим удалить ветку из нашего удаленного репозитория.

  $ git push origin - удалить ошибку
Кому [email protected]: adamw / first-project / repository.git
- [удалено] исправление
  

Сводка

В этом руководстве мы рассмотрели создание, объединение и удаление веток как локально, так и удаленно.

Глава 22 Филиалы | Удачного Git и GitHub для пользователейR

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

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

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

Вы можете создать новую ветку с помощью git branch , а затем проверить ветку с помощью git checkout . Чтобы отличить его от основного потока разработки, предположительно на master , мы назовем это «функциональной веткой».

  git branch issue-5
git checkout issue-5  

Вы также можете использовать ярлык git checkout -b issue-5 для одновременного создания и проверки ветки.

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

Коммутационные отделения

Вы используете git checkout для переключения между ветвями.

Но что делать, если вы работаете в ветке и вам нужно переключиться,
а работа над текущей веткой не завершена? Один из вариантов — Git
тайник, но обычно
лучший вариант — защитить текущее состояние с помощью временной фиксации. Здесь я
используйте «WIP» в качестве сообщения фиксации, чтобы указать на незавершенную работу.

  git commit --all -m "WIP"
Мастер проверки git  

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

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

Присоединение филиала

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

  мастер проверки git
git merge проблема-5  

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

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

  git merge issue-5
# Автоматическое объединение index.html
# CONFLICT (content): конфликт слияния в index.html
# Автоматическое слияние не удалось; исправить конфликты и зафиксировать результат.  

Первое, что нужно сделать, это NOT PANIC . Конфликты слияния — это не конец
world и большинство из них относительно малы и их легко разрешить.

Первым шагом к разрешению конфликта слияния является определение файлов в
конфликт, который вы можете сделать с git status :

  git статус
# На ветке мастера
# У вас есть несвязанные пути.# (исправить конфликты и запустить "git commit")
#
# Не объединенные пути:
# (используйте "git add  ...", чтобы отметить разрешение)
#
# оба изменены: index.html
#
# в коммит изменений не было (используйте "git add" и / или "git commit -a")  

Таким образом, это показывает, что только index.html не объединено и требует разрешения. Мы можем
затем откройте файл, чтобы увидеть, какие строки конфликтуют.

  <<<<<<< HEAD: index.html
 контакт: [email protected] 
=======

 свяжитесь с нами по адресу [email protected]

>>>>>>> проблема-5: index.html  

В этом конфликте строки между <<<<<< HEAD: index.html и ====== являются
контент из ветки, в которой вы сейчас находитесь. Строки между =======
и >>>>>>> issue-5: index.html взяты из ветви функций, которую мы объединяем.

Чтобы разрешить конфликт, редактируйте этот раздел, пока он не будет отражать желаемое состояние в объединенном результате.Выберите ту или иную версию или создайте гибрид. Также удалите маркеры конфликта <<<<<< , ====== и >>>>>> .

  

свяжитесь с нами по [email protected]
  

Теперь запустите git add index.