Как пользоваться GitHub | Losst

Github — это очень известная платформа для хранения, распространения и управления исходным кодом открытых проектов. Этот сервис используют множество разработчиков по всему миру, среди которых есть и крупные компании, такие как Microsoft, RedHat и множество других, также сотни разработчиков многих популярных проектов.

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

Содержание статьи:

Как пользоваться GitHub

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

1. Создание аккаунта

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

Когда завершите ввод, нажмите кнопку «Sign Up Free»:

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

Аккаунт готов, и вы будете перенаправлены на страницу, где сможете создать свой первый проект. Но перед тем как вы сможете это сделать, нужно подтвердить свой Email адрес. Для этого откройте ваш почтовый ящик и перейдите по ссылке в письме от Github.

 

 

Никакая настройка github не нужна, достаточно лишь несколько кликов мышкой.

2. Создание репозитория

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

«Start a project»:

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

Вы можете сразу же инициализировать репозиторий, создав файл Readme, для этого нужно отметить галочку «Initialize this repository with a README» внизу страницы. Также можно выбрать лицензию:

Когда все будет готово, выберите «Create project», будет создан новый проект с файлом README, в котором находится описание и файлом лицензии.

Дальше все самое интересное как работать с github.

3. Добавление веток

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

Текущая ветка обозначена в верхнем левом углу после слова «Branch». Чтобы создать новую ветку просто разверните этот список и начните набирать ее имя:

 

 

 

Сайт сам предложит вам создать новую ветку, выберите «Create branch».

Сразу же после создания вы будете работать с только что созданной веткой.

4. Изменение файлов и коммиты

Любые изменения файлов на Github делаются с помощью коммитов. Коммит выполняется путем внесения самих исправлений и описания этих исправлений. Это необходимо для того, чтобы вы знали что и когда вы меняли, а также позволяет легко отслеживать работу команды. Слово коммит можно перевести как «фиксировать». То есть мы можем внести изменения в несколько файлов, а затем их зафиксировать. Давайте для примера изменим файл README. Для этого найдите в в правой стороне панели кнопку с кисточкой и нажмите на нее:

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

После того как вы сделаете все что вам нужно, необходимо заполнить поле «Commit» внизу страницы. Кратко опишите что было изменено, а затем нажмите кнопку «Commit changes»:

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

5. Создание запросов слияния (Pull Request)

GitHub для начинающих может показаться очень сложным именно из-за таких возможностей, но это очень удобно если разобраться. Запрос слияния или Pull Request — это возможность, благодаря которой любой разработчик может попросить другого, например, создателя репозитория просмотреть его код и добавить его в основной проект или ветку. Инструмент работы с запросами слияния использует инструмент сравнения diff, поэтому вы можете увидеть все изменения, они будут подчеркнуты другим цветом. Pull Request можно создать сразу же после создания коммита. Давайте отправим Pull Request из нашей testing ветки в основную. Сначала откройте вкладку

«Pull Request».

 

 

Здесь нажмите кнопку «Create Pull Request»:

Дальше вам нужно будет выбрать ветку, которую нужно слить с основной, в нашем случае «testing».

 

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

Дальше нажмите зеленую кнопку «Create Pull Request» и введите описание, как и для коммита:

6. Просмотр и одобрение запросов на слияние

Теперь, на той же вкладке Pull Requests мы видим только что созданный запрос на слияние и нам остается только принять его нажав «Merge Pull Request»:

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

Дальше можно подтвердить Pull Request:

 

 

 

Затем код будет импортирован в основную ветку, а ветка testing может быть безопасно удалена.

 

7. Отчеты об ошибках

Удобно еще то, что возможно использование GitHub не только для разработки и управления кодом, но и для обратной связи с пользователями. На вкладке

«Issue» пользователи могут оставлять сообщения о проблемах, с которыми они столкнулись при использовании вашего продукта. Откройте вкладку «Issues», и нажмите на кнопку «New issue»:

Дальше вам осталось ввести заголовок, текст и нажать «Create new issue».

8. Релизы

Последнее что мы сегодня рассмотрим — это релизы. Когда продукт достиг определенной стадии можно выпустить релиз, чтобы пользователи и вы могли быть уверенны что там все стабильно и никто ничего не сломал неверным Pull Request в Master. Сначала нужно перейти на главную страницу проекта, затем на вкладку «Releases»:

Дальше нажмите кнопку «Create New Release»:

На этой странице нужно указать версию в поле «Tag Version», затем имя релиза и небольшое описание. Если у вас есть скомпилированные архивы с бинарниками то их тоже нужно прикрепить сюда. Затем нажмите

«Create Release»:

После создания релиза будет создана такая страничка:

Ссылки на исходный код в tar.gz и zip будут созданы автоматически, все остальные файлы вам придется добавлять вручную.

Выводы

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

Введение в GitHub: как начать пользоваться?

Всем привет! Несмотря на такой долгую паузу после последней статьи о VestaCP, буду пробовать переходить на более интенсивный режим работы. С этого дня темы новых статей будут немного сменены, теперь вы увидите больше статей, связанных с вёрсткой сайтов. Я не беру на себя функцию обучить вас вёрстке, а, скорее, предоставляю вам миниконспект основ, к которому будет легко вернуться и повторить. Надеюсь, вам понравится и вы сможете эффективно использовать предложенную информацию. Хватит предисловий, приступим к работе.

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

Системы контроля версий

Древняя система контроля версий

Наверное, все когда-нибудь сохраняли 2 версии файла с небольшими отличиями под разными именами? К примеру, научка-вер1.txt и научка-вер1-проверил_Пушкин.txt. Первый файл вы отправили своему научному руководителю, он его проверил, внёс свои изменения и отравил вам второй файл. Такое может повторять вплоть до бесконечности, плодя

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

Такой способ совершенно не приемлем* в мире разработки, особенно, если над проектом трудится много человек одновременно. И вот почему:

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

Современная система контроля версий

Если дать грубое определение по главной задаче GitHub, то это сервис для организации работы

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

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

Цель такой системы — поддержание актуальной версии проекта у всех ее пользователей.

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

Виды современной системы контроля версий

Централизованная.

1. Существует только
   один репозиторий.
2. Простые номера версий файлов (1, 2, 3 и т.д.).
3. У пользователей хранится только текущая версия проекта.
4. Требуется подключение к интернету.
5. Просто, но медленно.
6. Сложности в одновременной работе над одним файлом.

Распределенная.

На один проект приходится много репозиториев.

1. Каждый пользователь создает локальную копию всего репозитория на основе главного облачного.
2. Номера версий сложные.
3. Возможность работать офлайн.
4. Работать быстро и удобно.
5. Требуется синхронизация репозиториев, так как проект — один.

Теперь можно дать определение и слову Git.

Git — это инструмент для реализации работы распределённой системы контроля версий.

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

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

Для работы с GitHub нам потребуется установить клиент контроля версий (в GitHub, это GitHub Desktop) и создать репозиторий. Репозиторий можно создать, как через веб-сайт, так и через клиент.

Принципы работы с репозиторием GitHub

1. С помощью клиента копируем весь репозиторий на свой компьютер (pull).
2. Вносим различные правки, сохраняем, вносим правки и т.д. в различные файлы репозитория.
3. Просим клиента внести изменённые файлы в репозиторий.
   Внесение измененных файлов в репозиторий называется фиксацией изменений или «коммитом» (commit).
4. После коммита версия вашего локального репозитория изменилась.
5. На данный момент изменения фиксированы только на локальном репозитории, чтобы они отобразились на сайте GitHub, требуется еще одна функция «синхронизация репозиториев» (push).
6. Теперь ваш главный репозиторий, расположенный в GitHub, такой же, как на вашем компьютере.

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

Слияние, конфликт, разрешение конфликта

Для понимая нужен пример. Влад и Артем сделали копию репозитория (pull) с фалом версии 1 с GitHub, внесли разные изменения в этот файл, оба зафиксировали изменения (commit) → версии фала в локальных репозиториев изменились, у Влада версия 2, у Артем 2А. И затем Влад запушил (синхронизировал репозитории- push). Теперь на GitHub добавилась версия файла 2. Артем тоже решил запушить свои изменения, т. к. на GitHub есть версия которой нет у Артема (у него нет версии 2), система откажется принимать его репозиторий для сохранения версии 2.

Для того, чтобы внести свои изменения, Артему нужно опять скопировать репозиторий (pull) с GitHub с дополнительной версией этого файла. При копировании произойдет конфликт.

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

Способы решения конфликта:

1. Автоматическое слияние. Сравнивая построчно код Влада и Артема, GitHub может решить совместить куски кода в файле, при этой получится новая версия файла. При таком подходе в репозитории будут находиться версии 1, 2, 2А, и 3, а Артем теперь может запушить все отсутствующие версии файла.
2. Разрешение конфликта вручную. Git пометит, какой код конфликтует, и вам нужно будет решить, какой вариант оставить или вообще внести третий. Создается версия 3, и Артем может запушить отсутствующие версии файла.

Master / не master, Fork, Pull request

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

Пример модели работы с ветками:

В Master лежит последняя стабильная версия, где вы можете вносить незначительные изменения; development — ветка для непосредственной разработки; dev-adaptive — ветка разработки, связанная с планируемым расширением функционала.

Что такое Fork? К примеру, на GitHub вам понравился какой-то проект, но вы заметили в нем ошибку и знаете, как ее решить, но доступа к редактированию чужого проекта у вас нет. Для этого вам нужно создать fokr. Теперь у вас есть доступ для редактирования файлов проекта. Вы справились с багом, но ваши труду пропадут даром т. к. изменения не отобразится в master ветке проекта. Чтобы такого не произошло и создан Pull request.

Pull request — это обращение к владельцам проекта с предложением внести в главную ветку ваши изменения.

На этом небольшое введение походит к концу. Не мучайтесь с допотопной системой версий, переходите на GitHub. Спасибо за внимание.

Как пользоваться Git для начинающих

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

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

Содержание статьи:

Команда git

Уже по традиции, перед тем, как перейти к примерам и работе с командой давайте рассмотрим ее основные опции и параметры. Синтаксис git очень прост:

$ git опции команда аргументы

Сначала рассмотрим опции, они влияют на работу всей утилиты:

• -C — использовать указанную папку репозитория вместо текущей папки;
• -c параметр=значение — использовать указанное значение параметра конфигурации;
• -p — прокручивать весь вывод с помощью less;

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

• add — добавить файл или папку в репозиторий git;
• am — применить все патчи из email;
• archive — создать архив файлов;
• bisect — использовать бинарный поиск для поиска нужного коммита;
• branch — управление ветками проекта;
• bundle — перемещение объектов и ссылок в архиве;
• checkout — переключение между ветками;
• cherry-pick — внести изменения в уже существующие коммиты;
• clean — удалить все неотслеживаемые файлы и папки проекта;
• clone — создать копию удаленного репозитория в папку;
• commit — сохранить изменения в репозиторий;
• diff — посмотреть изменения между коммитами;
• fetch — скачать удаленный репозиторий;
• init — создать репозиторий;
• merge — объединить две ветви;
• pull — интегрировать удаленный репозиторий с локальным;
• push — отправить изменения в удаленный репозиторий;
• tag — управление тегами;
• worktree — управление деревями разработки.

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

Как работает git?

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

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

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

Как пользоваться Git?

Дальше я буду предполагать, что вы выполнили установку и базовую настройку git. Кроме установки, вам нужно указать правильный адрес электронной почты и имя пользователя для доступа к серверу Git, например, на GitHub. Если вы этого еще не сделали смотрите инструкцию установка Git в Ubuntu 16.04.

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

Создание проекта

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

mkdir -p ~/git/testing ; cd ~/git/testing

Эта команда создаст нужную структуру папок и переводит текущий каталог в только что созданный. Теперь создадим первый файл нашего проекта:

touch file

 

Проект готов, но система контроля версий git еще не знает об этом.

Настройка проекта в git

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

git init

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

git add .

Если все прошло хорошо, то команда ничего не выведет.

Фиксация изменений

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

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

git commit -m "Initial Commit" -a

Команде необходимо передать два параметра, первый — это -m, ваш комментарий, второй -a, означает, что нужно применить действие ко всем измененным файлам. Для первого раза используется этот параметр, но обычно вам нужно указать измененные файлы или каталоги. Например, можно делать так:

git commit -m "Changed file" file

 

Отправка изменений

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

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

 git remote add origin https://github.com/Seriyyy95/testing.git

Затем можно посмотреть список удаленных репозиториев:

git remote -v

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

git push origin master

Команда push указывает, что нужно отправить данные в удаленный репозиторий, origin — наш настроенный репозиторий, а master — ветвь.

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

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

git branch -a

 

 

Опция -a указывает что нужно вывести все ветви, даже не синхронизированные. Звездочка указывает на активную ветвь. Теперь создадим ветвь для разработки с помощью команды checkout:

git checkout -b develop

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

git checkout master
$ git checkout develop

Теперь создадим еще один файл:

touch develop

И добавим его в нашу новую ветвь develop:

git add develop

 

 

Сделаем коммит для внесенных изменений:

git commit -m "develop file" develop

Дальше проверим существует ли этот файл в основной ветке master или только в дополнительной. Смотрим текущую ветку:

git branch
$ ls

Затем переключаемся на ветку master и снова смотрим:

git checkout master
$ git branch
$ ls

Здесь файла нет, так и должно быть. В git есть такая полезная вещь, как слияние. С помощью нее вы можете объединить две ветви. Например, переместить код из рабочей ветки в стабильную. Для этого достаточно выполнить команду merge:

git merge develop --no-ff

Перед тем как будет выполнено слияние вам нужно ввести комментарий, зачем это нужно. Затем если вы еще раз выполните ls, то увидите, что здесь уже есть нужный файл. Наши примеры git подошли к концу.

Выводы

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

15 советов по работе с Github / Блог компании Mail.ru Group / Хабр

Я 10 лет разрабатываю ПО, участвовал в нескольких open source-проектах и в многочисленных не-open source-проектах, работал в больших и малых командах, и везде мы использовали Github в качестве репозитория версионирования.

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

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

• Хорошая документация: readme, сайты с документацией и журналы изменений.
• Подробно расписанные соглашения и стандарты кодинга.
• Правильное версионирование с помощью семантического версионирования.
• Автоматизированные тесты: используем их не слишком много, сосредоточимся на функциональных нерегрессионных тестах.
• Конечно же, счастье разработчика!

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

Если вы работает в open source-проекте, то наверняка хотите публиковать свой Github-проект. Git и Github полностью изменили способ разработки OSS, де-факто превратившись, соответственно, в стандартный язык версионирования и площадку для сотрудничества.

Официально предлагаемый Github’ом рабочий процесс называется github flow. Он прекрасно описан на сайте. Этого процесса, с небольшими вариациями, придерживается большинство open source-проектов.

Github Flow очень гибок в том смысле, что он не диктует вам, как нужно релизить и документировать изменения, какую стратегию слияния использовать, когда принимать pull request’ы, какие инструменты применять, каким стандартам коммитов следовать или что нужно рецензировать перед принятием pull request’а. Всё это отдано на ваше усмотрение, и правильно сделано, поскольку не существует универсальных решений, подходящих всем командам.

Дальше я приведу список рекомендаций на основе моего опыта.

По большей части (почти исключительно) я пишу на JavaScript, многие упомянутые мной инструменты являются частью JS-экосистемы, но сами идеи применимы в любом языке.

Приоритезируйте задачи и отслеживайте прогресс с помощью Github Projects

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

Подробнее

Классифицируйте задачи с помощью тегов

Github имеет превосходные возможности по фильтрации. Если вы работаете над open source-проектом, то наверняка заинтересованы в привлечении других участников, а также в том, чтобы им было удобно. Если помечать свои задачи тегами, разработчикам легче будет ориентироваться в списке, это сэкономит им время и облегчит работу над проектом.

Используйте Github-шаблоны для pull request’ов и задач

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

Подробнее

Основные советы по отчётам о багах:

Прежде чем отправлять информацию о проблеме:

• Удостоверьтесь, что пользуетесь последней версией.
• Поищите упоминание об этом баге, возможно, отчёт о нём уже был раньше.

Отчёты о багах должны содержать:

• Краткое описание.
• Как вы столкнулись с багом? Инструкция по воспроизведению.
• Какого поведения вы ожидали от приложения?
• Как приложение повело себя на самом деле?
• Ссылки на все связанные с ситуацией тикеты или информационные источники.
• По мере возможности, прикрепите визуальное подтверждение бага. Скриншоты, видео и/или анимационные гифы.

Общие рекомендации по pull request’ам:

• Проверьте, что по вашей проблеме ещё нет других pull request’ов.
• Проверьте в баг-трекере, не было ли проблем, связанных с вашим багом.
• Нетривиальные изменения лучше предварительно обсудить.
• Сообщите нам, над какой задачей работаете.
• Разрабатывайте в конкретной тематической ветке, а не в мастере.
• Напишите описание полезного pull request’а.
• Соблюдайте рекомендации по коммитам в проекте.
• Напишите хорошее описание своего pull request’а.
• Укажите в описании ссылку на Github-задачу.

Пользуйтесь командной строкой

Консоль — ваш друг. По моему опыту, освоение работы с Github через командную строку — лучшая трата времени, когда работаешь с open source-технологиями. Да, существует много хороших графических интерфейсов, но все они менее гибки в использовании. Кроме того, есть инструменты только под командную строку, которые сильно упрощают жизнь и повышают эффективность разработки:

• hub — обёртка для Git, облегчающая работу с GitHub. Не важно, новичок вы или опытный open source-разработчик, hub облегчит извлечение репозиториев, навигацию по страницам проекта, работу с форками и даже отправку pull request’ов. И всё это из командной строки. hub.github.com
• tj/git-extras — набор Git-утилит, таких как сводка по репозиторию, repl, журнал изменений, статистика коммитов по авторам, и многое другое. github.com/tj/git-extras

Соблюдайте строгие стандарты коммит-сообщений и категоризируйте коммиты

Всегда определяйте и соблюдайте ясные стандарты написания коммит-сообщений. Вот некоторые рекомендации:

• Коммитьте каждый фикс как отдельное изменение.
• Пишите полезные коммит-сообщения.
• Пишите короткое коммит-сообщение в первой строке (50–100 символов). Если посмотрите результат выполнения gitk или git log –oneline, то поймёте, почему.
• Ссылайтесь на Git-задачу в теле коммит-сообщения.

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

Определяйте стандарты оформления кода и конфигурируйте прекоммит-хуки

Для написания удобного в сопровождении кода очень важно определять стандарты оформления и соблюдать их в прекоммит-хуках (pre-commits hooks). Стандарты помогут поддерживать единообразие кода вне зависимости от того, кто его пишет, а также помогут принимать и сопровождать код, написанный кем-то другим.

Я рекомендую использовать Prettier и StandardJS, но это дело вкуса, существует множество других решений; к тому же, вы можете сделать что-то своё. Главное, следуйте выбранным стандартам оформления кода, это пойдёт на пользу.

typicode/husky — прекрасный инструмент для конфигурирования прекоммит-хуков.

Используйте автоматизированные тесты и проверки pull request’ов

Очень желательно автоматизировать функциональные тесты и проверки безопасности и стиля оформления кода в каждом pull request’е. Вряд ли вы захотите всё это делать вручную. Можно быстро сконфигурировать сервер непрерывной интеграции, вроде TravisCI, чтобы автоматически прогонять тематическую ветку через тесты после отправки каждого pull request’а. Также можно сконфигурировать Github, чтобы он не позволял разработчику присоединять pull request’ы, если те не прошли тесты. При сбое тестов Github покажет автору сообщение, чтобы он исправил свои pull request’ы.

Подробнее.

Защищайте свою мастер-ветку и требуйте проводить ревизию кода

Github позволяет защищать мастер-ветку от прямых коммитов, принудительных push’ей и перебазирования. Это очень важно, когда работаешь с кем-то над проектом. Кроме того, обязательно требуйте проводить ревизию кода, прежде чем объединять его с мастер-веткой. Это задаётся во вкладке настроек каждого репозитория.

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

Сквошьте свои pull request’ы

Много споров о том, что правильно: объединять, сквошить (squash) или перебазировать. Я считаю, что лучше всего сквошить, потому что:

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

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

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

Учитывая шаблон MAJOR.MINOR.PATCH, увеличивайте:

• Старшую (MAJOR) версию, если вносите несовместимые с предыдущими версиями изменения в API.
• Младшую (MINOR) версию, если добавляете обратно совместимую функциональность.
• Патч-версию (PATCH), если вносите обратно совместимые исправления ошибок.

В качестве расширений шаблона MAJOR.MINOR.PATCH можно использовать дополнительные метки для пререлизов и сборок.

Помимо изменения версии package.json, рекомендую для каждой версии генерировать git-тег.

Подробнее.

Спецификация Conventional Commits подразумевает при написании коммит-сообщений соблюдение простого стандартизированного соглашения. Оно увязано с соглашением SemVer, которое просит разработчиков описывать в коммит-сообщениях все фичи, исправления и критические изменения. Соблюдая соглашение, мы создаём стандартный язык, упрощающий отладку в различных проектах.

Подробнее.

Автоматизировать этот процесс поможет TravisCI.

Также обратите внимание на эти пакеты: dominique-mueller/automatic-release, semantic-release/semantic-release.

Автоматизируйте развёртывание с помощью тег-хуков

Не обязательно использовать ветки релизов, как это предлагается в рамках Git Flow. Можно брать артефакты развёртывания из Git-тегов. Здесь описано, как с помощью TravisCI развернуть Git-теги в heroku. Это очень просто, нужно лишь для атрибута тегов задать значение true. Такое поведение можно реализовать с помощью любого другого CI-сервера.

Для среды разработки можно настроить хук, который развёртывает последний мастер-коммит. А для сред комплектов (feature environments) можно использовать и не такие долгоживующие ветки; при желании, для каждого PR-запроса вы можете предоставлять временную тестовую среду, но такой подход сложнее, да и не является обязательным.

Настройте потоковый Github-канал для чата

Очень удобный способ отслеживания активности в ваших Github-репозиториях из места, идеально подходящего для взаимодействия с командой: простой поток уведомлений в одном или нескольких чатах. К слову, в чатах вы можете делать и многое другое, в 2013-м на Github появился термин ChatOps, подробнее о нём рассказывается здесь.

Автоматизируйте обновление зависимостей

Нам приходится регулярно тратить много времени на актуализацию зависимостей. Это идеальная задача для автоматизации. Существует много инструментов, помогающих поддерживать зависимости «свежими», автоматически создавая в проекте pull request’ы с последними версиями. Эти запросы будут прогнаны через автоматизированные нерегрессионные тесты, и если пройдут успешно, то можно надеяться, что код после объединения будет работать нормально. Будьте осторожны с изменениями уровня старших версий, дважды всё проверяйте.

Пара полезных инструментов: greenkeeper.io и david-dm.org.

С помощью расширений улучшайте работу с интерфейсом Github’а

Open source-разработчики создали много полезных расширений, улучшающих работу с интерфейсом Github’а. Например:

• GitHub Avatars [chrome] — отображает аватары в новостной ленте.
• GitHub Awesome Autocomplete [chrome] [firefox] — добавляет функцию мгновенного поиска в поисковый блок GitHub.
• GitHub Categoric [chrome] — категоризирует ваши смешанные GitHub-уведомления.
• GitHub Hovercard [chrome] [firefox] — удобный GitHub-плагин hovercard для пользователей/репозитория/задач.
• GitHub Isometric Contributions [chrome] [safari] — отображает вклад в проект разных людей в виде изометрического pixel art-графика.
• GitHub Linker [chrome] — линкует зависимости в пакете или bower-файле с их GitHub-страницами.
• GitHub Octotree [chrome] [safari] [firefox] [opera] — отображает GitHub-код в виде дерева.
• GitHub Selfies [chrome] — добавляет селфи в pull request’ы и комментарии.
• GitHub Stars Tagger [chrome] — прямо в GitHub добавляет теги в ваши отмеченные звёздами (starred) репозитории.
• Github NPM Hub [chrome] — позволяет исследовать npm-зависимости в GitHub-репозиториях.
• Github vscode-icons [chrome] — показывает vscode-иконки в браузере репозитория.

Другие расширения: GitHub Browser Extensions.

На Kikobeats/awesome-Github есть ещё инструменты для улучшения вашего рабочего процесса.

Постоянная учёба и самосовершенствование

Github и методики разработки open source ПО постоянно развиваются, поэтому держите руку на пульсе новейших тенденций и инструментов, отслеживая Github-новости и соблюдая стандарты вашего сообщества. Прекрасный источник информации — Youtube-канал GitHub Training & Guides.

11 продвинутых советов по использованию Git / Хабр

*»ублюдок» — вольный перевод слова «git» — «an unpleasant or contemptible person», «неприятный или презренный человек».

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

Давайте посмотрим, что можно использовать, чтобы улучшить себе жизнь. Статья предполагает, что читатель умеет пользоваться основными возможностями git и понимает что делает, когда, скажем, вводит в консоль git rebase --merge --autostash.

1. Используйте консольный и графический интерфейсы git одновременно

Начнём с того, как именно Вы пользуетесь возможностями git? Многие работают строго из консоли или из приложения вроде SourceTree, и с первого взгляда может показаться, что эти варианты взаимоисключают друг друга.

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

Удобства графического интерфейса очевидны невооружённым взглядом:

• Вы наглядно видите изменения в файле сразу в своём любимом редакторе.
• Вы можете контролировать стейджинг (добавление файлов для коммита) текущих изменений практически в реальном времени, не обращаясь к git status.
• Вы получаете быстрый доступ к истории файла.
• … и многое другое, что зависит от конкретных редакторов и/или используемых плагинов.

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

• В первую очередь, это поддержка всех возможных команд и опций, поскольку git в первую очередь консольная команда, а любой GUI — это посредник между ним и Вами.
• Подсказки по этим «всем возможным командам и опциям».

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

Применительно к VS Code с установленным плагином GitLens хочу поделиться парочкой специфичных лайфхаков.

• Привяжите хоткей к команде gitlens.diffWithBranch — эта команда позволяет быстро сравнить текущий файл с его версией в любой ветке.
• Если хотите пометить для себя место в каком-либо файле, чтобы иметь возможность быстро к нему вернуться в процессе работы над текущей веткой — просто добавьте в нужное место пустую строчку. Таким образом файл всегда будет под рукой в боковой панели. Да, для закладок существует богатый ассортимент плагинов, но обычно списки закладок быстро захламляются и в них бывает сложно ориентироваться, когда смешиваются закладки из разных веток.

2. Конфиги, конфиги, конфиги. Разделяйте и властвуйте

Да, именно три штуки: системный (--system), пользовательский (--global) и локальный (--local). Соответственно, они применяются в порядке иерархии, каждый последующий оверрайдит предыдущий — системный применяется для всех пользователей, пользовательский — конкретно для Вас, локальный — для конкретного репозитория. Ловко лавируя между ними, можно гибко адаптировать свой рабочий процесс под условия окружающей среды.

(Upd. Как оказалось, есть ещё четвёртый уровень конфигов, специфичный для отдельных рабочих копий одного репозитория worktree. Подробнее про worktree см. ниже.)

Когда какой стоит применять? В большинстве случаев случаев Вы предпочтёте воспользоваться глобальным, чтобы вынести в него общие для всех настройки core.eol, алиасы, а также user.name и user.email, переопределяя только специфические вещи для конкретного репозитория. Однако в некоторых случаях, например когда несколько разработчиков по очереди отлаживают встраиваемое ПО, часть общих настроек имеет смысл вынести на системный уровень, переопределяя в глобальном (== пользовательском) только user.name/email.

Также в моей практике был случай, когда в рабочих репозиториях надо было пользоваться строго рабочей почтой, при этом в своих локальных репозиториях я продолжал пользоваться личной. Чтобы даже случайно нельзя было перепутать где что, я удалил user.name/email из глобального конфига, каждый раз указывая их заново в локальном, держа процесс под контролем.

3. Используйте временные коммиты вместо stash при переходе между ветками

Скорее всего, Вы сталкивались хотя бы раз с ситуацией, когда надо срочно переключиться с одной ветки на другую, бросив всё в разобранном состоянии. Очень вероятно, что Вы знаете про git stash (от англ. «тайник»), который позволяет «спрятать» Ваши текущие изменения. Однако во время его использования Вы можете столкнуться со следующими вещами:

• Если коммитами Вы пользуетесь постоянно и все часто встречающиеся параметры типа --amend можете написать с закрытыми глазами, stash имеет несколько перпендикулярный интерфейс. Чтобы сохранить его надо сделать git stash save (при этом save может быть опущен). А чтобы восстановить — есть git stash apply (применяет последний стеш из всех) и git stash pop (применяет стеш и удаляет его из стека). Соответственно, когда придёт внезапная необходимость переключиться, Вы можете не сразу вспомнить, а что собственно надо вводить и что от команды ожидать.
• Если stash-ить буквально пару строчек, то можно вообще не вспомнить, что делал stash, и потом сидишь и удивляешься, куда делись изменения.
• stash по умолчанию распространяется только на изменённые (modified) файлы и не включает в себя неотслеживаемые (untracked). Соответственно, не зная этого, при переключении веток можно потерять их, если, например, они авто-генерируемые.

Что же делать, если не stash? Наиболее простое решение — взять и закоммитить всё с комментарием WIP (распространённая аббревиатура от «Work In Progress»). Не надо морочить себе голову, вспоминать названия команд и искать потом, в который из стешей сохранены изменения.

А зачем тогда stash вообще нужен? Я предпочитаю их использовать для хранения мелких фиксов, которые нужны только для отладки и не должны быть закоммичены вообще. Есть возможность применять не только последний из стешей, но и вообще любой, ссылаясь на его имя. Самое большое удобство в том, что стеши хоть и «помнят» на какой ветке были сделаны, но ни к чему не обязывают и могут быть применены на любой ветке. Я где-то когда-то нашёл очень удобные алиасы для этого:

git config --global alias.sshow "!f() { git stash show stash^{/$*} -p; }; f"
git config --global alias.sapply "!f() { git stash apply stash^{/$*}; }; f"

# сохранить
git stash save "hack"
# посмотреть
git sshow "hack"
# применить
git sapply "hack"

4. Используйте «-» для возврата к предыдущей ветке

После того, как вы сделали свои грязные дела в другой ветке и хотите вернуться к предыдущей, вместо того чтобы вспоминать и вводить её полное имя, можно просто передать «-«:

git checkout -

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

cd /some/long/path
...
cd -

5. Не клонируйте репозиторий, когда в этом нет нужды

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

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

$ git worktree add -b emergency-fix ../temp master
$ pushd ../temp
# ... hack hack hack ...
$ git commit -a -m 'emergency fix for boss'
$ popd
$ git worktree remove ../temp

Клонирования не происходит, по сути просто чекаут в другую папку, которую потом можно оставить или не жалко удалить.

6. Применяйте pull только как fast-forward

На всякий случай, напоминаю, что pull по умолчанию делает fetch (выкачивание ветки с удалённого репозитория) и merge (слияние локальной и удалённой веток), а fast-forward — это режим слияния, когда нет никаких изменений в локальной ветке и происходит «перемотка» её на последний коммит из удалённой. Если изменения есть, то происходит классический мерж с ручным разрешением конфликтов и мерж-коммитом.

Некоторые предпочитают использовать git pull --rebase, но не всегда это возможно, например, когда вы локально смержили другую ветку из origin в master и перед пушем делаете pull (надеюсь, не надо напоминать, чем в данном случае может грозить rebase).

Соответственно, чтобы не попасть случайно в ситуацию, когда Вы неудачным pull-ом смержили не то и не туда, можно использовать параметр --ff-only или вписать соответствую опцию в конфиг:

git config --global pull.ff only

Что мы получаем?

• Автоматический фейл, если в локальной ветке есть новые незапушенные коммиты.
• Автоматический фейл, если во входящей ветке есть изменения в тех же файлах, в которых у Вас есть локальные незакоммиченные изменения (а это с большой вероятностью может вылиться потом в конфликт мержа).
• Автоматический фейл, если Вы случайно делаете pull не в ту ветку — например, на автомате вписали git pull origin master upstream вместо my_feature.
• Успех, когда всё прекрасно.

7. Скрывайте лишнее через git exclude

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

Для решения этого вопроса есть чудесная возможность добавить соответствующий паттерн в файл .git/info/exclude. А для удобства редактирования этого файла можно использовать алиас:

git config --global alias.exclude '!f() { vim .git/info/exclude; }; f'

(Не забудьте подставить Ваш любимый редактор.)

8. Скрывайте локальные изменения, когда не хотите их «вливать»

А теперь про то, когда Вы не хотите чтобы отслеживались изменённые файлы. Яркий пример: очень многие, особенно долгоживущие репозитории, хранят в себе ряд конфигов. Часто они служат для обеспечения единообразия настроек (к примеру, .editorconfig) или тасков сборки/линтинга (.vscode/tasks.json). И иногда так случается, что хочется их как-то изменить, но возможность разделения конфигов на «общие» и «пользовательские» отсутствует.

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

git update-index --assume-unchanged <path to file>

С этих пор он «пропадает с радаров» даже если Вы продолжите его изменять. Если во время pull-а приходят новые изменения в этом же файле — в этом случае он будет продолжать считаться неизменённым, но легко смержиться Вам не даст. Чтобы вернуть всё как было, надо снять флаг, добавив no:

git update-index --no-assume-unchanged <path to file>

9. Отслеживайте хаки локальные изменения в обход репозитория

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

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

Долго ли, коротко ли, узнал я о том, что вовсе необязательно, чтобы папка с репозиторием называлась .git. Её можно назвать как угодно ещё на этапе создания репозитория и работать с ней, передавая в команды параметр gitdir. А значит… Просто выполнить git init --separate-git-dir=.git_dev в существующей папке нам не дадут, произойдёт переименование каталога. Поэтому делаем хитрее: выполняем команду в новой папке, и кладём свежесозданный репозиторий рядом с существующим.

Что только что сейчас произошло? Мистическим образом у нас оказалось два репозитория в одной папке, а значит и возможность вести параллельную историю файлов! Почему .git_dev? Да для единообразия. Давайте заведём себе алиас, чтобы упростить работу со вторым репозиторием:

git config --global alias.dev '!git --git-dir=\"./.git_dev\"'

Пробуем:

> git status -s
?? .git_dev/

> git dev status -s
?? .git_dev/
?? .gitignore
?? Program.cs
?? habr.csproj

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

Игнорировать .git/ у гита заложено в генах, а вот всё остальное, как мы видим, отображается как есть. Наибольшая проблема — .gitignore у них будет один на двоих, так что практически всё, что может потребоваться во втором репозитории, придётся добавлять через -f, а всё что не требуется — не забываем игнорировать через .git_dev/info/exclude. По умолчанию можно добавить следующие строчки:

# ignore all files
/*
# ignore all folders
*/

В качестве бонуса, саму идею использования git для отслеживания конфигов можно использовать в том числе для того, чтобы хранить все свои заботливо собранные .vimrc, .bashrc, создавая репозиторий прямо в ~ (для Windows это C:\Users\%USERNAME%\).

10. Используйте хуки

Про хуки много рассказано в других статьях, например и вот, но не упомянуть их нельзя. Благодаря git bash они одинаково работают как в Unix-like системах так и в Windows, правда, если они при этом запускают что-то ещё, можно огрести приключений. Полезны, например, хуки:

• прогоняющие код через линтер/автоформаттер перед коммитом;
• вычленяющие номер задачи из текущей ветки и добавляющие её в сообщение коммита;
• пересобирающие вспомогательные библиотеки после чекаута и мержа.

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

11. Требуйте автодополнение

Напоследок хочу сказать довольно банальную вещь — автодополнение существенно улучшает качество жизни. В большинстве Unix-систем оно идёт из коробки, но если Вас угораздило оказаться в инфраструктуре Windows — настоятельно рекомендую перейти на Powershell (если ещё не) и установить posh-git, который обеспечивает автодополнение большинства команд и даёт минималистичную сводку в prompt:

---

Спасибо за внимание; желаю всем приятной и эффективной каждодневной работы.

Приложение

Бонус для внимательных. Упомянутые выше и несколько неупомянутых алиасов из конфига:

[alias]
    # `git sshow hack` - показать содержимое стеша с названием, включающим "hack". Строка может быть неточной
    sshow = "!f() { git stash show stash^{/$*} -p; }; f"

    # `git sapply hack` - применить стеш "hack"
    sapply = "!f() { git stash apply stash^{/$*}; }; f"

    # работа с `.git_dev`
    dev = !git --git-dir=\"./.git_dev\"

    # отображение статуса одновременно `.git/` и `.git_dev/` 
    statys = "!f() { git status ; echo \"\n\" ; git dev status ; }; f"

    # поиск ветки по части названия
    findb = "!f(){ git branch -ra | grep $1; }; f"

    # последние пять коммитов в ветке. Если вызвать как `git hist -n 10`, отобразит 10
    hist = log --pretty=format:\"%ad | %h | %an: \t %s%d\" --date=short -n5

    # `git dist branch-name` отображает разницу в списке коммитов между текущей веткой и branch-name 
    dist = "!git log --pretty=format:\"%ad | %h | %an: \t %s%d\" --date=short \"$(git rev-parse --abbrev-ref HEAD)\" --not "

    # редактирование локального `exclude`
    exclude = "!f() { vim .git/info/exclude; }; f"

    # вывести список файлов, скрытых через `--assume-unchanged`
    ignored = !git ls-files -v | grep "^[[:lower:]]"

    # переход на следующий коммит - операция, обратная `git reset HEAD~1`
    forward = "!f() { git log --pretty=oneline --all | grep -B1 `git rev-parse HEAD` | head -n1 | egrep -o '[a-f0-9]{20,}' | xargs git checkout ; }; f"

Работа с распределенной системой контроля версий Git на примере GitHub / Хабр

Работа с распределенной системой контроля версий Git на примере GitHub
Год начала данной публикации: 2019
Год окончания данной публикации: не указан

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

Предупреждение по использованию:

Данная публикация является учебной для освоения основ системы контроля версий git, на примере использования GitHub. Это не руководство к действию. Вы должны понимать, то что вы делаете применяя команды и идеи изложенные в публикации. Не спешите применять сказанное к вашим рабочим проектам. Создайте черновой проект, локальный репозиторий. Потренируйтесь на нем. Создайте свой учебный проект на GitHub. Когда вы хорошо будете понимать, что и как работает, только тогда вы сможете применить ваши знания в рабочих проектах. Публикация не является переводом какой либо работы. Это авторская работа с целью прояснить некоторые вопросы. Более подробно смотрите раздел: «Цель публикации».

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

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

Обязательно прочитайте в документации: что не должно попадать в GitHub и как настроить .gitignore.

Система контроля версий довольно сложная штука. Но пусть вас это не пугает. Попробуем разобраться. Дать определения, и внести ясность. Если вы работаете один над своим проектом, то вам даже не обязательно регистрироваться на сервере. Вы можете просто установить себе Git и работать с системой контроля версий локально. Вам для локальной работы над проектом не обязательно даже будет подключение к интернету. Репозиторий который вы создаете локально — это фактически такой же репозиторий как на сервере, только без возможности работать над проектом распределенной команды разработчиков. Система контроля версий — по существу это реализация права программиста на ошибку в своем коде. Как вы помните «человеку свойственно ошибаться». Так вот, ошибаться программисту следует гораздо меньше. И, чтобы вернуться к своему коду и исправить ошибку, добавить функциональность и существует такая замечательная система, как система контроля версий. Кроме того использование системы контроля версий — это более эффективный менеджмент.

Ответьте на вопрос: В чем заключается работа в команде и вы поймете насколько управление проектом становится более эффективным с системой контроля версий. Еще одно преимущество: Система контроля версий облегчает процесс ревью(пересмотра, доработки) кода. Следующее преимущество: Автоматическое разрешение конфликтов. То есть объединение, например разных версий методов, сделанных разными разработчиками в одну ветку. Здесь, в данном материале я не рассматриваю плагины для git в IDE. Здесь рассматриваются только общие вопросы работы с git и работы с удаленным репозиторием на GitHub.

Контрольные вопросы:
В чем заключается экономия времени при использовании системы контроля версий?
В чем преимущества использования системы контроля версий?
Что такое Git?
Как начать использовать git?
Как начать использовать GitHub?
Основные(наиболее часто используемые) команды Git.
Какие сервисы существуют для Git?
Как работать с локальным репозиторием?
Как работать с распределенным репозиторием?

Git-хостинг на разных условиях предлагают многие компаний.
Довольно известные из них: Github, Sourceforge, Google Code, GitLab, Codebase и тд.

Сервисы git в порядке популярности(тут, чтобы не возникло холивара, допишу: По моему мнению):

1. Ваш локальный сервис, использование git только локально
2. GitHub
3. BitBucket
4. GitLab

Про использование своего git сервера вы можете прочитать на хабре >>>

В данной публикации я рассматриваю в основном работу с сервисом GitHub.

Цель публикации: Коротко рассказать что такое Git.

Описать некоторые, основные команды консоли Git. Хотя в интернет существует довольно много описаний работы с git, многое из документации может показаться запутанным и некоторые определения раскрыты не полностью. Что может ввести начинающих в заблуждение. Некоторые определения следует написать в более развернутом виде, для ясности понимания.
Также с практическими примерами намного легче освоить систему. Цель статьи сделать небольшой обзор о системе Git. Показать как использовать некоторые команды, для более быстрого освоения начинающими. Показать как настроить систему для конкретного использования. Следующая цель, предотвратить бездумное использование тех или иных команд Git.

Предметная область и основные термины

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

Git — одна из распределенных систем контроля версий.
GitHub — один из сервисов для использования системы контроля версий Git.

repository — некоторое хранилище файлов, ссылок на изменения в файлах
commit — отслеживание изменений, сохраняет разницу в изменениях
HEAD — (специальный указатель) символическая ссылка на последние изменения. Примечание: Не обязательно ссылается на commit. Может указывать на ветвь. Состояние — «Detached HEAD»
HEAD используется репозиторием для определения того, что выбрано с помощью checkout.
Обратите внимание на это различие: «head» (в нижнем регистре) относится к любому из названных заголовков в хранилище; «HEAD» (верхний регистр) относится исключительно к текущему активному заголовку(ссылке). Это различие часто используется в документации Git. HEAD может указывать на именованную вершину какой-либо ветки или на commit.
Объекты Git. Четыре типа объектов: Blob, Tree, Commit и References.
Ветвь определяется не в самом Git, а наследуется от операционной и файловой систем.
Более подробно об объектах Git вы можете прочитать в документации.

git сервисы — сервисы предоставляющие услуги для пользователей git.

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

.

working directory — рабочий каталог на вашем компьютере
staging area — область подготовленных файлов или рабочая область
branch — ветка, состоит из набора коммитов, обычно ссылается на последний коммит
merge — слияние, слияние веток в одну
pull — втянуть, взять проект с сервера, получить изменения из удаленного репозитория
push — вытолкнуть, отправить изменения на сервер

Символы:
# — в данном случае символ комментария
<> — угловые скобки, там где вам нужно вписать нужное исключая эти скобки
$ — приглашение ввода в терминале

Небольшое вступление

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

Git — одна из систем контроля версий.

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

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

История создания

Цитата из Вики:

Git (произнoсится «гит»[8]) — распределённая система управления версиями. Проект был создан Линусом Торвальдсом для управления разработкой ядра Linux, первая версия выпущена 7 апреля 2005 года. На сегодняшний день его поддерживает Джунио Хамано.

Теоретическая часть(коротко)

Проект был создан Линусом Торвальдсом для управления разработкой ядра Linux
Git свободная система и распространяется она под лицензией GNU GPL 2.

Git is an Open Source project covered by the GNU General Public License version 2 (some parts of it are under different licenses, compatible with the GPLv2).

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

Какие существуют системы управления версиями:
1. Централизованные
2. Децентрализованные(распределенные)

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

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

Взаимодействие с другими системами контроля версий
В стандартной поставке Git поддерживается взаимодействие с CVS (импорт и экспорт, эмуляция CVS-сервера) и Subversion (частичная поддержка импорта и экспорта). Стандартный инструмент импорта и экспорта внутри экосистемы — архивы серий версионированных файлов в форматах .tar.gz и .tar.bz2.

Fork – удаленная копия репозитория на сервере, отличная от оригинала. Это даже не git-концепция, а, скорее, политико-социальная идея. Clone – это не то же самое, что и fork. Клон удаленного репозитория располагается локально. Фактически при клонировании копируются все данные, включая историю коммитов и существующие ветки.
Branch, или создание ветки, – это способ внести изменения в проект и объединить их в итоге с остальным кодом. Ветка является частью репозитория.

Рабочее дерево (рабочая директория, рабочее пространство) – это дерево исходных файлов, которые вы можете видеть и редактировать.
Индекс (область подготовленных файлов, staging area) – это один большой бинарный файл .git/index, в котором указаны все файлы текущей ветки, их SHA1, временные метки и имена. Это не отдельная директория с копиями файлов.
Указатель HEAD – это ссылка на последний коммит в текущей извлеченной ветке.

Некоторое отступление от темы: Зачем я так много привел цитат?
Ответ самый простой. Чтобы в дальнейшем дать более точные и ясные определения.

Практическая часть

Для использования системы git вам нужно:

1. Установить программу git на вашей системе.
2. Настроить программу и проверить её работоспособность локально
3. Зарегистрировать ваш аккаунт на GitHub
4. Создать локальный репозиторий или копировать репозиторий существующего проекта
5. Написать файл README.MD.
6. В случае, если вы начинаете проект, создать удаленный репозиторий
7. Фиксировать изменения локально
8. Отправлять изменения на GitHub
9. Зарегистрировать аккаунты разработчиков вашего проекта
10. Выдать им ссылку на проект

1. Установка git

В Linux:

sudo apt-get update && sudo apt-get upgrade #обновление перед установкой

sudo apt-get install git #установка git

В Windows:
Git для Windjws >>>

1. После установки вы можете кликнуть правой кнопкой мышки на папке в проводнике Windows и выбрать открыть «Git Bash Here». Git Bash Here — означает отрыть терминал git здесь.

В терминале введите команду

git --version #вывод версии

проверить версию вашего git.

В Linux,(Ctrl+Alt+T — терминал, если у вас не назначены другие горячие клавиши) откройте терминал и введите

git --version

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

2.Настройка программы Git

Примечание:
Тут следует упомянуть, что настройку Git вы осуществляете на нескольких уровнях.
То есть некоторые настройки вы делаете для определенного пользователя операционной системы(не системы git, а операционной системы). Другие настройки вы делаете для всех пользователей операционной системы. Далее вы можете делать настройки для определенной папки(локально). Вы делает настройки для репозитория находящегося на сервере. Эти настройки вы можете не делать, если работаете только со своим локальным репозиторием.
В данной публикации я рассматриваю команды консоли в основном Windows git-bash.
Более подробно об отличиях вы можете посмотреть в документации. Упомяну только что есть некоторые отличия. Например в параметрах пути к файлам и папкам. В Windows используется / — слеш, а в Linux обратный слеш \. Хотя в Windows вы можете самостоятельно настроить на использование обратного слеша.

Настройка пользователя и емейл:

git config --global user.name "My Name"

git config --global user.email [email protected]

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

Настройка внешнего редактора.

git config --global core.editor emacs  #подключить внешний редактор emacs

#команда для Linux.
Вы можете выбрать другой текстовый редактор. Например не emacs, a vi или nano или другой на ваше усмотрение.

В Windows, такой командой вы можете задать текстовый редактор, например notepad++.

For x64 Windows change to: git config —global core.editor «‘C:/Program Files (x86)/Notepad++/notepad++.exe’ -multiInst -notabbar -nosession -noPlugin»

Для x64 Windows вы можете использовать команду(только пропишите свой путь):

git config --global core.editor "'C:/Program Files (x86)/Notepad++/notepad++.exe' -multiInst -notabbar -nosession -noPlugin" 

Настройки git хранятся в файлах.

Git проверяет 4 места для файла конфигурации(здесь в Linux):
Файл вашего компьютера .gitconfig.
Ваш пользовательский, файл вашего пользователя .gitconfig файл находится в ~/.gitconfig.
Второй пользовательский файл конфигурации, расположенный в $ XDG_CONFIG_HOME/git/config или $HOME/.config/git/config.
Конфигурационный файл локального репозитория: .git/config

cat .git/config #просмотр конфигурации локального репозитория

Каждый файл добавляет или переопределяет параметры git, определенные в файле над ним.

Конфигурация системы.
Конфигурация пользователя.
Конфигурация, специфичная для репозитория.

Ссылка на документацию >>>

Вы можете просмотреть файлы конфигурации

#для системы и всех пользователей

git config --system --list

git config --system --edit

#для пользователя

git config --global --list

git config --global --edit

Проверка настроек вашей конфигурации git:

git config --list #вывести на экран конфигурацию.

Если список большой, вы можете пролистывать его с помощью стрелок клавиатуры или «pg up», «pg dn». Для выхода клавиша q.

#какая конфигурация, где установлена:

git config --list --show-origin

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

Команды Git(консольные)

git опции команда аргументы 

пример:

git branch -d <name> # удалить локальную ветку с именем name 

git branch -d bugFix00 #удалить локальную ветку с именем bugFix00.

Опции:
-C — использовать указанную папку репозитория вместо текущей папки;
-c параметр=значение — использовать указанное значение параметра конфигурации;
-p — прокручивать весь вывод с помощью less;

Инициализация локального репозитория.

1. Переходим в папку проекта.

cd ваша_папка #команда терминала, переход в папку с именем ваша_папка 

2.

git init #инициализация локального репозитория

3.

git add . #тут мы добавляем все. 

Папку. Точка после add отделенная пробелом.
Можно добавить отдельный файл
Например

git add имя.расширение

Таким образом мы говорим — отслеживать изменения нашего файла.
Для добавления всего в папке рекомендуют использовать команду

git add -A

4. Создание commit

git commit #сохранить изменения в локальном репозитории

-m «комментарий» #аргумент создания комментария коммиту. Ваши изменения будут уже с осмысленным комментарием.
Вы можете использовать полное имя ключа, вместо его сокращения. К примеру, вместо -m вы можете использовать —message=«комментарий»

git commit --message="$Ваш осмысленный комментарий"

Тут нужно сделать некоторое замечание. Чтобы использовать русские буквы в комментариях, нужно сделать предварительные настройки. Вам нужно настроить кодировку символов в системе, кодировку символов в текстовом редакторе или IDE, кодировку символов в терминале, кодировку символов в git. Другой момент: Windows «не любит» одиночные апострофы, поэтому коментарий заклечен в кавычки. На Linux есть возможность использовать апострофы при оформлении коментария к коммиту.

5.

git show #показать изменения внесенные вашим коммитом

6.

git status  #просмотр текущего состояний git

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

Ветки. Branches

Ветка(branch) — ссылка на определенный коммит.

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

git branch имяВетки #будет создана ветка с именем "имяВетки"

, используйте для имени латинские буквы. Тут есть одно замечание. Когда мы создали ветку с некоторым именем, текущей осталась ветка, которая была выделена до этого. Ну например master. И если после создания ветки мы скажем git commit, то будет продолжена ветка master. Не понимание этого часто приводит к ошибкам.

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

1. Создаем ветку:

git branch feature #создание ветки с именем "feature" локально

2. Переключаемся на созданную ветку:

git checkout feature#выбор ветки с именем "feature" локально

3. Делаем commit:

git commit

Теперь у нас есть вторая ветка с именем feature.

Объединение веток(merge).
Объединение веток создает коммит от двух родителей, от текущей ветки и ветки указанной в команде git.

1. Переключаемся на ветку master
2. Сморим какая ветка текущая
3. Объединяем ветки

git merge feature  #объединить текущую ветку с веткой feature

Мы можем сделать по другому. Переключиться на ветку feature и объединить её с веткой master

1.

git checkout feature #выбор ветки feature 

2.

git merge master #объединить текущую ветку

, в данном случае feature c веткой master.

Просмотр доступных веток:

git branch -v -a #просмотреть все доступные ветки, которые можно получить

git diff --cached #посмотреть какие изменения добавились в stage

stash — стек, временное хранилище
Не путайте со stage, это не одно и то же.

Команда

git stash

сохраняет все не закомиченные изменения во временное хранилище и сбрасывает состояние ветки до HEAD.

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

Стеш(stash) предназначит для того, что бы спрятать не нужные на данный момент изменения, потому он и называется stash, в переводе — прятать, припрятывать.

git stash apply #применить изменения к текущей версии
git stash list  #вывести список изменений
git stash show #вывести последние изменения
git stash drop #удалить последние изменения в списке 
git stash pop  # [apply] + [drop]
git stash clear #очистить список изменений

git stash drop# удалит последний git stash

git stash drop [email protected]{5}#удалит git stash под номером 5

рис 1.

На рисунке показана подготовка папки на локальном компьютере для git.
Добавление в staging area. Добавление изменений в локальный репозиторий(git commit).
Отправка в удаленный репозиторий(git push).
На данной схеме не показана сущность stash.

рис 2.

На диаграмме рис 2. показана работа команд add, commit all, commit, reset, git reset head, git update index.

Untacked files — непроиндексированные файлы.
Working tree — ваша рабочая папка
Index — индексация файлов
Commit — изменения файлов

Здесь нужно внести некоторую ясность. Диаграмма относится к вашему локальному репозиторию. Но это другой вид диаграммы. Это как будто мы рассматриваем работу git c различных точек, под «разным углом». Показан некоторый жизненный цикл индексации изменений локального репозитория.

Работа с командами:

cherry-pick
reset
revert
rebase
merge

Очень полезные команды. Рассмотрите их самостоятельно.

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

Далее я перейду к описанию работы с удаленным репозиторием.
Вы можете работать с удаленным репозиторием и вашим проектом через протокол [url]https://,[/url]
то есть в вашем браузере(chrome, mozilla, opera и других).

GitHub.com >>>
Интерфейс GitHub на английском языке.

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

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

git init #инициализация локального репозитория

git add -A

Подключить ветку на удаленном(в данном случае GitHub) компьютере:

git remote add origin https://github.com/имя_ник_пользователя/ИмяРепозитория.git

«имя_ник_пользователя» — в данном случае ник пользователя удаленного репозитория.
«ИмяРепозитория» — в данном случае это имя вашего уже созданного заранее репозитория на GitHub

Показать какие пути назначены:

git remote -v

Вывод:

origin  [url]https://github.com/имя_пользователя/имя_репозитория.git[/url] (fetch)
origin  [url]https://github.com/имя_пользователя/имя_репозитория.git[/url] (push)

 git remote show #показать какие ветки есть в удаленном репозитории

Обычно там одна ветка origin.
То есть это не сама ветка, а её сокращенное название ассоциированное с репозиторием.
Вы можете добавить, ассоциировать еще одну ветку на удаленном репозитории.

git remote add <сокращенное_имя_удаленного_репозитория> [email protected]:имя_пользователя/имя_удаленного_репозитория.git

git remote add <имя_удаленного_реп> протокол@github.com:пользователь/имя_удаленного_репозитория.git

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

git remote set-url origin [url]https://имя_пользователя@github.com/имя_пользователя/test.git[/url] #установить новый путь 

git pull origin master #забрать все изменения с сервера из ветки origin  в локальную ветку master 

Только данная команда забирает одну ветку из удаленного репозитория.
Кроме того она сливает(объединяет, merge) все изменения из удаленного репозитория с вашими локальными. Эту команду следует применять, когда вы только начинаете работать с удаленным репозиторием и у вас своих наработок в локальном пока нет.

git remote -v #показать путь к удаленному репозиторию

git clone --recursive https://github.com/имя_пользователя/имя_репозитория.git #рекурсивное получение репозитория

 git clone --recursive https://github.com/имя_пользователя/имя_удаленного_репозитория.git Lимя_локальной_папки

Эта команда создает папку с именем Lимя_локальной_папки.
Берет все изменения из репозитория «github.com/имя_пользователя/имя_удаленного_репозитория.git» и сохраняет их в папке «Lимя_локальной_папки».
Здесь я написал префикс L перед именем папки, чтобы отличить локальную папку от удаленной на сервере.

gitk #утилита отображения графа изменений

Диаграмма ниже показывает отличие работы с локальным репозиторием и с репозиторием на GitHub
[url]https://greenido.files.wordpress.com/2013/07/git-local-remote.png?w=696&h=570[/url]

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

Чтобы некоторые ваши файлы не попадали в репозиторий.
Вы хотите чтобы некоторые файлы не индексировались и не попадали в репозиторий?
Вам нужно создать файл с именем .gitignore.

touch .gitignore #создает пустой файл .gitignore

В терминале cmd windows:

type nul > .gitignore #создает пустой файл .gitignore

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

По умолчанию файл .gitignore не добавляется в репозиторий.
О файле .gitignore вы можете прочесть в документации:
git-scm.com/docs/gitignore
Приводится пример файла и кратко описывается его синтаксис.

Вы можете создать глобальный файл для пользователя

git config --global core.excludesfile ~/.gitignore_global #создает ссылку на файл .gitignore_global

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

git config --get core.excludesfile #показывает где должен находиться файл .gitignore_global

Вам осталось создать этот файл. Откройте терминал(В Windows cmd).

cd c:\путь\где\должен_находиться_файл .gitignore_global

type nul > .gitignore_global #создать пустой файл .gitignore_global

Вы можете скопировать готовый файл отсюда >>>
Откройте ваш пустой файл .gitignore_global в текстовом редакторе и скопируйте текст из готового файла в ваш. Сохраните файл.

рис 3.

На данной диаграмме показана работа команд: git add, git commit, git push и git fetch.

Предупреждение:

git push -f #чревато потерей данных при работе с веткой нескольких человек…

git push --force #чревато потерей данных при работе с веткой нескольких человек…

git fetch #забирает изменения с сервера, но только в локальный репозиторий

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

git pull #берет данные с сервера в локальный репозитория и сливает их с рабочей веткой.

Проще говоря,

git pull 

состоит из двух команд:

git fetch

и

git merge

.

Опции(ключи) -n, —dry-run #многие команды git имеют данные ключи. Эти опции нужны для того чтобы посмотреть какие изменения сделает команда.

То есть, вы можете увидеть результат выполнения данной команды и затем применить её при уверенности без ключей -n, —dry-run

Модели ветвления в Git:

Для чего нужны модели ветвления?
Для лучшей организации потока работы(Workflow). Для стандартизации. То есть в вашей организации может быть принята, в зависимости от целей некоторая модель ветвления.

Central Workflow
Developer Branch Workflow
Feature Branch Workflow
Issue Branch Workflow
Forking Workflow
Patch Workflow

Central Workflow (центральный рабочий процесс) в этом контексте определяется как «вы отправляете изменения тому же репозиторий, из которого вы обычно получаете свои последние вышестоящие изменения», независимо от того, используете ли вы rebase или merge. (pull = fetch + merge или fetch + rebase, в зависимости от конфигурации и параметров)

Feature Branching являет логическим расширением Central Workflow (центрального рабочий процесса). Основная идея рабочего процесса Feature Branch: разработка всех функций должна осуществляться в выделенной ветви вместо основной ветви. Главная ветвь никогда не должна содержать неработающий код. Это является большим преимуществом в средах непрерывной интеграции.

Gitflow Workflow
Рабочий процесс Gitflow был впервые опубликован в блоге Винсента Дриссена от nvie за 2010 год. Рабочий процесс Gitflow определяет строгую модель ветвления, разработанную для выпуска проекта. Этот рабочий процесс не добавляет каких-либо новых концепций или команд помимо того, что требуется для рабочего процесса Feature Branch. Вместо этого он назначает очень конкретные роли различным ветвям и определяет, как и когда они должны взаимодействовать.

Forking Workflow
Рабочий процесс Forking отличается от других рабочих процессов. Вместо того чтобы использовать один серверный репозиторий в качестве «центральной» кодовой базы, он предоставляет каждому разработчику серверный репозиторий. Это означает, что у каждого участника есть не один, а два репозитория Git: частный локальный и общедоступный серверный.

Рекомендации:

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

Выводы:
Мы с вами рассмотрели работу системы git и работу с удаленными репозиториями.
В некоторой степени коснулись вопроса установки и конфигурации git, регистрации удаленного репозитория на примере GitHub. Применения git как локально, так и удаленно. А также некоторые моменты организации рабочего процесса. В одной статье невозможно рассказать обо всем. Вы можете продолжить обучение изучая материалы документации и публикации других авторов. Что меня по настоящему восхищает в git, так это проектирование и реализация хорошей экосистемы.

.gitignore. Отправка только тех файлов в репозиторий, которые необходимы
Вам может понадобится чтобы в ваш репозиторий не попадали лишние файлы.
Вы можете редактировать файл .gitignore вручную.
Для автоматического исключения некоторых файлов проекта вы можете скачать плагин для вашего IDE. Например для NetBeans 10 вы можете скачать и установить плагин с официального сайта netbeans:
plugins.netbeans.org/plugin/50356/gitignore-io
Владелец плагина: junichi11
Лицензия: Apache License, Version 2.0

Как установить:
1. Скачиваем файл в папку на локальном диске
2. Открываем IDE NetBeans
3. Tools/Plugin/Downloaded/Add Plugins
4. Указываем путь к плагину на вашем локальном компьютере.
5. Перезапуск IDE

Для IDE Intellij Idea вы можете скачать плагин «Add to gitignore»
plugins.jetbrains.com/plugin/7495—ignore

1.Переходим на сайт с плагином
2. Выбираем вашу версию IDE
3. Читаем инструкцию.
4. Скачиваем и устанавливаем

Вы можете установить плагин из IDE:
Preferences > Plugins > Browse repositories… > Search for «.ignore» > Install Plugin
После установки «Restart Idea».

git update-git-for-windows #обновить git для windows

Дополнительные ресурсы:
Онлайн книга по Git >>>
10 полезных Git команд, которые облегчат работу >>>
Отладка кода с Git: 3 инструмента для поиска ошибок >>>
Магия Git. Студенты. Stanford >>>
Здесь, на хабре есть замечательная публикация о Git автора jsirex, «Ежедневная работа с Git»

Как вы знаете от версии к версии в программы вносятся изменения.
Какие изменения были сделаны для версии git 2.0: >>>

Здесь еще следует немного рассказать о безопасности использования git и то что относится к использованию различных UI для git.

Продолжение, уточнение следует…

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

легендарная платформа для совместного управления кодом

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

Что такое Git

Отслеживать изменения в файле с течением времени сложно, но важно. Git — это система контроля версий (VCS) — инструмент, который помогает отслеживать различия в файле с течением времени.

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

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

Первоначально Git был разработан Линусом Торвальдсом при поддержке ядра Linux в 2005 году.

Как пользоваться Git

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

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

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

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

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

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

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

Что такое Github

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

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

Наиболее важные инструменты слоев GitHub поверх Git включают в себя:

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

Официальный сайт GitHub.

Как пользоваться GitHub

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

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

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

Компании, которые используют Github

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

Многие компании имеют как публичные, так и частные репозитории, поскольку в разработке ПО существует прецедент альтруизма с открытым исходным кодом. Например, у Facebook есть множество ПО с открытым исходным кодом на GitHub.

Другие популярные компании, которые используют Git и GitHub для размещения исходного кода:

• Netflix
• Amazon
• Airbnb
• Google
• IBM

GitHub — безусловно, самый популярный хостинг Git. По состоянию на октябрь 2018 года в мире насчитывалось 31 миллион пользователей с более чем 96 миллионами хранилищ. По состоянию на октябрь 2017 года у GitHub было почти в 5 раз больше пользователей, чем у следующего популярного сайта с исходным кодом, Bitbucket.

Преимущества и недостатки Github

Преимущества

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

Недостатки

• Основным недостатком как Git, так и GitHub является то, что у них обоих довольно трудно обучиться.

Установка и конфигурция

Для установки гитзхаба понадобится лишь одна команда — sudo apt-get install gitДля начала зафиксируем ваше имя и почту git config —global user.name «Имя»
git config —global user.email «почта»Создаём локальный репозиторий. git init testcd testВ данную папку можно выводить любые файлы. Я создам файл readme. subl READMEи файл типа C. subl test.cТеперь его можно добавить в индекс двумя командами:

git add README
git add sample.cКогда все файлы готовы вы можете прокоммнтировать их git commit -m «комментарий»Переходим на сайт, регистрируем свой профиль если не сделали этого ранее, и добавляем репозиторий, нажав на плюс в правом нижнем углу.Называем репозиторий также, как и в консоли, и натраиваем по вашей необходимостиТеперь можно вывести все файлы в сам репозиторий, вписав команду git remote add origin https://github.com/имя/test.git . Не забудьте изменить строку с названием репозитория и вашим именем.

Вывод

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

Как использовать GitHub | GitHub Tutorial For Beginners

Если вы не знаете, как использовать GitHub, то этот блог для вас. Github — это веб-платформа, используемая для контроля версий. Git упрощает процесс работы с другими людьми и упрощает совместную работу над проектами. Члены команды могут работать с файлами и легко объединять свои изменения с основной веткой проекта. Git & GitHub skill постепенно превратился из предпочтительных навыков в навыки, необходимые для выполнения нескольких рабочих ролей.В этом блоге я расскажу вам о различных функциях и возможностях GitHub.

В этом блоге «Как использовать Github» вы узнаете:

Шаг 1. Что такое Github?

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

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

Почему Github так популярен?

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

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

Теперь позвольте мне перечислить способы, которыми GitHub упрощает git:

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

Итак, давайте начнем с GitHub.

Шаг 2: Как создать репозиторий GitHub?

Репозиторий — это хранилище, в котором находится ваш проект. Он может быть локальным в папке на вашем компьютере или в хранилище на GitHub или другом онлайн-хосте. Вы можете хранить файлы кода, текстовые файлы, изображения или любые файлы в репозитории.Вам понадобится репозиторий GitHub, когда вы внесли некоторые изменения и готовы к загрузке. Этот репозиторий GitHub действует как ваш удаленный репозиторий. Так что позвольте мне упростить вашу задачу, просто выполните следующие простые шаги, чтобы создать репозиторий GitHub:

• Перейдите по ссылке: https://github.com/. Заполните форму регистрации и нажмите «Зарегистрироваться на Github».
• Щелкните «Начать новый проект».

См. Снимок экрана ниже, чтобы лучше понять.

• Введите любое имя репозитория и нажмите «Создать репозиторий».Вы также можете дать описание своему репозиторию (необязательно).

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

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

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

Шаг 3: Создание веток и выполнение операций

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

Как показано на изображении выше, существует ветвь master / production, у которой есть новая ветка для тестирования. В этой ветке выполняются два набора изменений, и по завершении они объединяются обратно в основную ветку. Вот как работает ветвление!
Давайте поговорим о том, как использовать GitHub, и узнаем, как создать ветку.

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

• Щелкните раскрывающийся список «Branch: master»
• Как только вы нажмете на ветку, вы сможете найти существующую ветку или создать новую. .В моем случае я создаю новую ветку с именем «readme- changes». Обратитесь к приведенному ниже снимку экрана для лучшего понимания.

После того, как вы создали новую ветку, у вас теперь есть две ветки в вашем репозитории, то есть read-me (основная ветка) и readme- changes. Новая ветка — это просто копия главной ветки. Итак, давайте внесем некоторые изменения в нашу новую ветку и сделаем ее отличной от основной.

Как использовать GitHub: Операции

Команда фиксации:

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

• Щелкните файл «readme-changes», который мы только что создали.
• Щелкните значок «редактировать» или значок карандаша в правом углу файла.
• Как только вы нажмете на это, откроется редактор, где вы можете ввести изменения или что-то еще.
• Напишите сообщение фиксации, которое идентифицирует ваши изменения.
• В конце нажмите «Принять изменения».

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

Мы успешно сделали нашу первую фиксацию. Теперь этот файл «readme-changes» отличается от основной ветки.Затем давайте посмотрим, как мы можем открыть запрос на перенос.

Команда извлечения

Команда извлечения является самой важной командой в GitHub. Он сообщает об изменениях, внесенных в файл, и просит других участников просмотреть его, а также объединить его с основной веткой. Как только фиксация будет завершена, любой может вытащить файл и начать обсуждение по нему. Как только все будет готово, вы можете объединить файл. Команда Pull сравнивает изменения, внесенные в файл, и, если есть какие-либо конфликты, вы можете вручную разрешить их.Теперь давайте посмотрим, как выполнить pull request в GitHub можно на разных этапах.

• Щелкните вкладку «Запросы на извлечение».
• Нажмите «Новый запрос на извлечение».
• После того, как вы нажмете запрос на вытягивание, выберите ветку и щелкните файл «readme- changes», чтобы просмотреть изменения между двумя файлами, присутствующими в нашем репозитории.
• Щелкните «Создать запрос на вытягивание».
• Введите любой заголовок, описание ваших изменений и нажмите «Создать запрос на перенос». См. Скриншоты ниже.

Теперь давайте продвинемся вперед и посмотрим, как вы можете объединить свой запрос на перенос.

Команда слияния

А вот и последняя команда, которая объединяет изменения в главную главную ветвь. Мы увидели изменения в розовом и зеленом цвете, теперь давайте объединим файл «readme-changes» с основной веткой / read-me. Выполните следующие шаги, чтобы объединить запрос на перенос.

• Щелкните «Merge pull request», чтобы объединить изменения в главную ветку.
• Нажмите «Подтвердить слияние».
• Вы можете удалить ветку после того, как все изменения будут внесены, и если нет конфликтов.См. Скриншоты ниже.

Надеюсь, вы, ребята, пытаетесь выполнить эти шаги одновременно, пока учитесь использовать GitHub. Затем давайте перейдем к нашей последней теме в блоге «как использовать GitHub», то есть к клонированию и форкованию репозитория GitHub.

Шаг 4: Клонирование и форк репозитория GitHub

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

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

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

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

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

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

• Перейдите в раздел «Обзор» и выполните поиск общедоступных репозиториев.
• Щелкните «вилка». Обратите внимание, что этот «касательный» репозиторий уже был разветвлен 27 раз и находится под учетной записью «google» . См. Изображение ниже для лучшего понимания.
  
  

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

Поздравляем! Вы успешно создали ветвь существующего репозитория под своей учетной записью.

Вот и все для этого поста. Надеюсь, вам понравилось, и вы получили решение, «как использовать GitHub».

Если вы нашли этот блог «Как использовать GitHub » релевантным, ознакомьтесь с DevOps-тренингом от Edureka, надежной компании онлайн-обучения с сетью из более чем 250 000 человек. учащиеся распространяются по всему миру.Курс Edureka DevOps Certification Training помогает учащимся получить опыт в различных процессах и инструментах DevOps, таких как Puppet, Jenkins, Nagios и GIT, для автоматизации нескольких этапов в SDLC.

.

с использованием Git — GitHub Docs

Документы GitHub

• Все продукты
• GitHub.com
• Начиная
  • Быстрый старт
    • Настроить Git
    • Создать репо
    • Форк репо
    • Быть социальным
  • Изучение GitHub
    • Продукты GitHub
    • Изучение выпусков раннего доступа с предварительным просмотром функций
    • Типы аккаунтов GitHub
    • Часто задаваемые вопросы об изменениях в планах GitHub
    • GitHub CLI
    • GitHub Desktop
    • GitHub для мобильных устройств
    • Разрешения на доступ на GitHub
    • Глоссарий GitHub
    • Шпаргалка по Git
    • Учебные ресурсы Git и GitHub
  • Регистрация на GitHub
    • Регистрация новой учетной записи GitHub
    • Подтверждение адреса электронной почты
    • Настройка пробной версии GitHub Enterprise Cloud
    • Настройка пробной версии GitHub Enterprise Server

.

Изучение GitHub — Документы GitHub

Документы GitHub

• Все продукты
• GitHub.com
• Начиная
  • Быстрый старт
    • Настроить Git
    • Создать репо
    • Форк репо
    • Быть социальным
  • Изучение GitHub
    • Продукты GitHub
    • Изучение выпусков раннего доступа с предварительным просмотром функций
    • Типы аккаунтов GitHub
    • Часто задаваемые вопросы об изменениях в планах GitHub
    • GitHub CLI
    • GitHub Desktop
    • GitHub для мобильных устройств
    • Разрешения на доступ на GitHub
    • Глоссарий GitHub
    • Шпаргалка по Git
    • Учебные ресурсы Git и GitHub
  • Регистрация на GitHub
    • Регистрация новой учетной записи GitHub
    • Подтверждение адреса электронной почты
    • Настройка пробной версии GitHub Enterprise Cloud

.

Документация GitHub

Документы GitHub

• GitHub.com
• Администраторы предприятия
• Действия GitHub
• Пакеты GitHub
• Разработчики
• REST API
• GraphQL API
• GitHub Insights
• GitHub Desktop
• Атом
• Электрон

Документы GitHub

Узнать по продукту

GitHub.com Администраторы предприятия Действия GitHub Пакеты GitHub Разработчики REST API GraphQL API GitHub Insights GitHub Desktop Атом .