Подключение локального репозитория к удаленному репозиторию GitHub

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

Git Remote в Git

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

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

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

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

Возвращаясь к той же странице GitHub, которую мы оставили выше, обратите внимание, что у нас есть раздел с именем …or push an existing repository from the command line.

Подключение локального репозитория к удаленному репозиторию GitHub

1. Откройте свой Git Bash и перейдите к хранилищу, которое необходимо связать.

1. Проверьте, чист ли репозиторий, используя команду git status.

1. Выполните команду git remote

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

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

git remote add origin https://github.com/harishrajora805/myFirstRepo.git

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

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

Как проверить, подключен ли локальный репозиторий к удаленному репозиторию?

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

Как видно, исходный репозиторий доступен. Продолжайте и используйте команду git remote-v для просмотра того же результата вместе с URL-адресом, как показано на рисунке.

В последнем уроке мы познакомились с командой Git fetch и Read more

В одной из последних статей мы узнали о команде Git Read more

Мы уже знаем, как вносить изменения в локальное хранилище и Read more

Команда git push при выполнении перемещает изменения, внесенные пользователем на Read more

«Клонирование» означает создание идентичных особей естественным или искусственным путем. Клонирование Read more

Сегодня мы узнаем, как скопировать чужой репозиторий в наш аккаунт Read more

Подключение репозитория GitHub на Windows

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

Создаем на сайте GitHub репозиторий. В нашем случае git@github.com:obemgcabazn/*имя репозитория*.git

Открываем в папке проекта командную строку и выполняем команду git init . Она создаст папку .git

git remote add origin https://github.com/obemgcabazn/*имя репозитория*.git Привязываем папку к нашему репозиторию на GitHub (origin — это синоним «удаленного репозитория»).

git add . — эта команда добавит в индекс все файлы из папки

git add -u — (u — updated) добавить в stage файлы измененные с последнего коммита файлы

git status покажет, что на данный момент находится в индексе

git rm -r —cached /frontend/psd/. — Если нам не нужно передавать какие-то файлы в коммит, то можем удалить их из индекса командой rm . Здесь нужно быть внимательным, так как без флагов эта команда удалит и файлы с жесткого диска.

• Чтобы оставить файлы на диске и удалить их из индекса, есть флаг —cached
• Если нужно удалить все файлы из индекса, лежащие в какой-то определенной папке, то нужно поставить флаг -r . Чтобы пройти рекурсивно по всем файлам.

Если файлы готовы, то можно сделать коммит git commit -m ‘сообщение коммита’ — где флаг -m нужен для передачи сообщения коммита без открытия редактора.

Отправить в коммит только modified файлы — git commit -am ‘сообщение коммита’ .

После этого нужно сделать пуш на сервер — git push -u origin master

Добавить SSH ключи

Если не работает по причине нехватки прав, то, возможно проблема с SSH ключами. Нужно запустить Gti Bash и набрать следующую команду: ssh-keygen -t rsa -C «myemail@mail.ru» . Конечно, указать свой почтовый ящик. На все вопросы нажимаем Enter. После выполнения, в каталоге C:\Documents and Settings\username\.ssh появятся файлы id_rsa и id_rsa.pub.

Далее на GitHub.com заходим в аккаунт в Settings -> SSH and GPG keys -> «New SSH key». В Заголовок вставляем что угодно, что поможет потом понять на какой компьютер установлен ключ (например, имя или место компьютера), а в поле key вставляем содержимое id_rsa.pub .

После этого гитхаб должен перестать ругаться на отсутствие прав доступа.

Часто используемые команды

• git add файлы — добавляет файлы в индекс
• git commit — отправляет из индекса в хранилище для дальнейшей отправки (git push) в удаленный репозиторий
• git reset — файлы заменяет файлы в индексе файлами из последнего коммита
• git checkout файлы — заменяет файлы проекта ни диске файлами из индекса
• git push origin master — отправляет файл на сервер, чтобы не вводить каждый раз логин/пароль, воспользуйтесь флагом ‘-u’

Чтобы создать новую ветку, нужно использовать команду git branch [Название_ветки] . Если написать просто git branch — покажет список существующих веток.

git checkout [Название ветки] — выбор ветки

Чтобы создать ветку и сразу ее выбрать git checkout -b [Новая ветка]

Работа с удаленными репозиториями github через git bash

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

Итак, вы установили git bash и у имеете [удаленный репозиторий на github и] учетную запись, созданную через веб-интерфейс сайта github.com. Запускаем git bush и переходим в папку, в которой будет храниться/уже хранится наш локальный репозиторий. В дальнейшем, чтобы минимизировать выполняемые действия, советую создать небольшой скрипт вида:

В моем случае это

Который автоматически будет запускать git-bash в корне проекта.

Теперь нужно сказать, что github предоставляет два варианта взаимодействия с сервером: https и ssh. Ниже мы рассмотрим их более детально в трех вариантах развития событий. И первый вариант развития:

1. Новый репозиторий

Вы только что создали репозиторий на гитхаб и собираетесь выложить туда готовый проект

Для начала необходимо подготовить локальный репозиторий. Для этого вводим команды:

Первой командой ( git init ) мы инициализировали новый репозиторий. Команда git add . проиндексировала все файлы внутри текущей директории, а командой git commit -m «first commit» мы сделали первый commit (фиксацию изменений). Все, ура. Но пока промежуточное. Теперь нужно правильно выложить это все на гитхаб:

Для этого необходимо выполнить команду

• https (например, https://github.com/Sanshain/django_test.git либо https://Sanshain@bitbucket.org/Sanshain/obfuscatenet.git для bitbucket)
• ssh (например, git@github.com:Sanshain/django_test.git )

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

2. Удаленный репозиторий

У вас уже есть репозиторий с вашим проектом на гитхаб, и нужно его синхронизировать с новым локальным репозиторием на пк. Переходим в папку, где будет храниться наш /репозиторий/проект (у меня это D: & cd D:\_github\ )

Для примера возьму свой репозиторий https://github.com/Sanshain/django_test.

Для клонирования существующего репозитория по https пишем:

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

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

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

Создается .gitignore с помощью команды touch .gitignore либо сразу с содержимым — echo ‘manage.py’ > .gitignore .

Если у вас python, советую добавить туда pyc-файлы строкой `*.pyc`.

Однако это не все… Если ‘manage.py’ уже проиндексирован, то необходимо его удалить [из индекса], сделать коммит и затем снова добавить (не забудьте скопировать перед выполнением):

И добавляем обратно. Пишем еще какие-то изменения.

Если в процессе изменений были добавлены новые файлы, делаем git add . .

Теперь можно коммитить на удаленный репозиторий наши изменения. Сперва проверяем удаленные репозитории:

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

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

— второй потребует создание публичного ключа шифрования для гитхаб

Если удаленные репозитории уже заданы, делаем git push origin master (если репозиторий уже отpushен с другого локального репозитория, то сперва необходимо выполнить git pull origin master )

3. Общий репозиторий

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

Вася сделал коммит со своего компа на удаленный репозиторий и ушел домой, но Петя остался на работе и продолжил править файлы, и сделал коммит на удаленный позже Васи. Вася на следующий день придет и уже не сможет продолжить работу со своим локальным репозиторием без угрозы потери изменений, которые делал Петя в его отсутствие в глобальный репозиторий, поскольку если он продолжит работу со своим локальным репозиторием и ‘от push ит’ его в глобальный, то попросту рискует их затереть. Поэтому ему необходимо сделать так называемый pull.

Команда pull объединяет в себе две команды — fetch (скачивает изменения) и merge (делает слияние). Выглядит она вот так:

В моем случае это выглядит вот так:

Если же Вася перед push уже успел внести какие-либо правки до выполнения команды pull , то при ее выполнении он может столкнуться с конфликтами. Конфликты бывают разной степени «тяжести».

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

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

Далее выполнить `git add -u` и git commit -m ‘merge’ .

rdnvndr / MainGit.md

Основы работы с Git

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

Система спроектирована как набор программ, специально разработанных с учётом их использования в скриптах. Это позволяет удобно создавать специализированные системы контроля версий на базе Git или пользовательские интерфейсы. Например, Cogito является именно таким примером фронтенда к репозиториям Git, а StGit использует Git для управления коллекцией патчей.

Git поддерживает быстрое разделение и слияние версий, включает инструменты для визуализации и навигации по нелинейной истории разработки. Как и Darcs, BitKeeper, Mercurial, SVK, Bazaar и Monotone, Git предоставляет каждому разработчику локальную копию всей истории разработки; изменения копируются из одного репозитория в другой.

Удалённый доступ к репозиториям Git обеспечивается git-daemon, gitosis, SSH или HTTP-сервером. TCP-сервис git-daemon входит в дистрибутив Git и является наряду с SSH наиболее распространённым и надёжным методом доступа. Метод доступа по HTTP, несмотря на ряд ограничений, очень популярен в контролируемых сетях, потому что позволяет использовать существующие конфигурации сетевых фильтров.

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

git clone — создание копии (удаленного) репозитория

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

Клонирует репозиторий, используя протокол http:

Клонирует репозиторий с той же машины в директорию myrepo:

Клонирует репозиторий, используя безопасный протокол ssh:

У git имеется и собственный протокол:

Импортирует svn репозиторий, используя протокол http:

где -s – понимать стандартные папки SVN (trunk, branches, tags)

git fetch и git pull — забираем изменения из центрального репозитория

Для синхронизации текущей ветки с репозиторием используются команды git fetch и git pull.

git fetch — забирает изменения удаленной ветки из репозитория по умолчания, основной ветки; той, которая была использована при клонировании репозитория. Изменения обновят удаленную ветку (remote tracking branch), после чего надо будет провести слияние с локальной ветку командой git merge.

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

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

Естественно, что после оценки изменений, например, командой git diff, надо создать коммит слияния с основной:

Команда git pull сразу забирает изменения и проводит слияние с активной веткой. Забирает из репозитория, для которого были созданы удаленные ветки по умолчанию:

Забирает изменения и метки из определенного репозитория:

Как правило, используется сразу команда git pull.

git push — вносим изменения в удаленный репозиторий

После проведения работы в экспериментальной ветке, слияния с основной, необходимо обновить удаленный репозиторий (удаленную ветку). Для этого используется команда git push.

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

Отправляет изменения из ветки master в ветку experimental удаленного репозитория:

В удаленном репозитории origin удаляет ветку experimental:

Отправляет в удаленную ветку master репозитория origin (синоним репозитория по умолчанию) ветки локальной ветки master:

Отправляет метки в удаленную ветку master репозитория origin:

Изменяет указатель для удаленной ветке master репозитория origin (master будет такой же как и develop):

Добавляет ветку test в удаленный репозиторий origin, указывающую на коммит ветки develop:

Работа с локальным репозиторием

git init — создание репозитория

Команда git init создает в директории пустой репозиторий в виде директории .git, где и будет в дальнейшем храниться вся информация об истории коммитов, тегах — о ходе разработки проекта:

git add и git rm — индексация изменений

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

Индексирует измененный файл, либо оповещение о создании нового:

Вносит в индекс все изменения, включая новые файлы:

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

Удаляет из индекса и дерева проекта отдельные файлы:

Хороший пример удаления из документации к git, удаляются сразу все файлы txt из папки:

Вносит в индекс все удаленные файлы:

Сбросить весь индекс или удалить из него изменения определенного файла можно командой git reset:

Удаляет из индекса конкретный файл:

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

git status — состояние проекта, измененные и не добавленные файлы, индексированные файлы

Команду git status, пожалуй, можно считать самой часто используемой наряду с командами коммита и индексации. Она выводит информацию обо всех изменениях, внесенных в дерево директорий проекта по сравнению с последним коммитом рабочей ветки; отдельно выводятся внесенные в индекс и неиндексированные файлы. Использовать ее крайне просто:

Кроме того, git status указывает на файлы с неразрешенными конфликтами слияния и файлы, игнорируемые git.

git commit — совершение коммита

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

Если индекс не пустой, то на его основе будет совершен коммит, после чего пользователя попросят прокомментировать вносимые изменения вызовом команды edit. Сохраняемся, и вуаля! Коммит готов. Есть несколько ключей, упрощающих работу с git commit.

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

Комментирует коммит прямо из командной строки вместо текстового редактора:

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

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

git reset — возврат к определенному коммиту, откат изменений, «жесткий» или «мягкий»

Помимо работы с индексом (см. выше), git reset позволяет сбросить состояние проекта до какого-либо коммита в истории. В git данное действие может быть двух видов: «мягкого»(soft reset) и «жесткого» (hard reset).

«Мягкий» (с ключом —soft) резет оставит нетронутыми ваши индекс и все дерево файлов и директорий проекта, вернется к работе с указанным коммитом. Иными словами, если вы обнаруживаете ошибку в только что совершенном коммите или комментарии к нему, то легко можно исправить ситуацию:

1. Некорректный коммит
2. Переход к работе над уже совершенным коммитом, сохраняя все состояние проекта и проиндексированные файлы
3. Редактирование файла или файлов
4. Добавление файлов в индекс
5. Возврат к последнему коммиту, будет предложено отредактировать его сообщение Если сообщение оставить прежним, то достаточно изменить регистр ключа -с

Обратите внимание на обозначение HEAD^, оно означает «обратиться к предку последнего коммита». Подробней описан синтаксис такой относительной адресации будет ниже, в разделе «Хэши, тэги, относительная адресация». Соответственно, HEAD — ссылка на последний коммит. Ссылка ORIG_HEAD после «мягкого» резета указывает на оригинальный коммит.

Естественно, можно вернуться и на большую глубину коммитов,

«Жесткий» резет (ключ —hard) — команда, которую следует использовать с осторожностью. git reset —hard вернет дерево проекта и индекс в состояние, соответствующее указанному коммиту, удалив изменения последующих коммитов:

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

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

git revert — отмена изменений, произведенных в прошлом отдельным коммитом

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

Отменяет коммит, помеченный тегом:

Отменяет коммит, используя его хэш:

Для отмены коммита слияния (коммита у которого несколько родителей), необходимо указать хэш и номер одного из родителей коммита:

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

git log — разнообразная информация о коммитах в целом

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

Простейший пример использования, в котором приводится короткая справка по всем коммитам, коснувшимся активной в настоящий момент ветки (о ветках и ветвлении подробно узнать можно ниже, в разделе «Ветвления и слияния»):

Получает подробную информацию о каждом в виде патчей по файлам из коммитов можно, добавив ключ -p (или -u):

Статистика изменения файлов, вроде числа измененных файлов, внесенных в них строк, удаленных файлов вызывается ключом —stat:

За информацию по созданиям, переименованиям и правам доступа файлов отвечает ключ —summary:

Чтобы просмотреть историю отдельного файла, достаточно указать в виде параметра его имя (кстати, в моей старой версии git этот способ не срабатывает, обязательно добавлять » — » перед «README»):

или, если версия git не совсем свежая:

Далее приводится только более современный вариант синтаксиса. Возможно указывать время, начиная в определенного момента («weeks», «days», «hours», «s» и так далее):

изменения, касающиеся отдельной папки:

Можно отталкиваться от тегов.

Все коммиты, начиная с тега v1:

Все коммиты, включающие изменения файла README, начиная с тега v1:

Все коммиты, включающие изменения файла README, начиная с тега v1 и заканчивая тегом v2:

Интересные возможности по формату вывода команды предоставляет ключ —pretty.

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

Лаконичная информация о коммитах, приводятся только автор и комментарий:

Более полная информация о коммитах, с именем автора, комментарием, датой создания и внесения коммита:

В принципе, формат вывода можно определить самостоятельно:

Определение формата можно поискать в разделе по git log из Git Community Book или справке. Красивый ASCII-граф коммитов выводится с использованием ключа —graph.

git diff — отличия между деревьями проекта, коммитами и т.д.

Своего рода подмножеством команды git log можно считать команду git diff, определяющую изменения между объектами в проекте — деревьями (файлов и директорий).

Показывает изменения, не внесенные в индекс:

Изменения, внесенные в индекс:

Изменения в проекте по сравнению с последним коммитом:

Можно сравнивать «головы» веток:

или активную ветку с какой-либо:

git show — показать изменения, внесенные отдельным коммитом

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

git blame и git annotate — команды, помогающие отслеживать изменения файлов

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

Можно указать и конкретные строки для отображения:

Аналогично работает команда git annotate, выводящая и строки, и информацию о коммитах, их коснувшихся:

git grep — поиск слов по проекту, состоянию проекта в прошлом

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

Ищет слова tst в проекте:

Подсчитывает число упоминаний tst в проекте:

Ищет в старой версии проекта:

Команда позволяет использовать логическое И и ИЛИ.

Ищет строки, где упоминаются и первое слово, и второе:

Ищет строки, где встречается хотя бы одно из слов:

git branch — создание, перечисление и удаление веток

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

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

Создаёт новую ветку new-branch:

Удаляет ветку, если та была залита (merged) с разрешением возможных конфликтов в текущую:

Удаляет ветку в любом случае:

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

Показывает коммит ответвления ветки new-name-branch от ветки master:

git checkout — переключение между ветками, извлечение файлов

Команда git checkout позволяет переключаться между последними коммитами (если упрощенно) веток:

Создаёт ветку, в которую и произойдет переключение:

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

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

Вернуть файл (или просто вытащить из прошлого коммита) позволяет команда вида:

Возвращает somefile к состоянию последнего коммита:

Возвращает somefile к состоянию на два коммита назад по ветке:

git merge — слияние веток, разрешение возможных конфликтов

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

Пытается объединить текующую ветку и ветку new-feature:

В случае возникновения конфликтов коммита не происходит, а по проблемным файлам расставляются специальные метки а-ля svn; сами же файлы отмечаются в индексе как «не соединенные» (unmerged). До тех пор пока проблемы не будут решены, коммит совершить будет нельзя.

Например, конфликт возник в файле TROUBLE, что можно увидеть в git status.

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

Смотрим на проблемные места:

Индексируем наши изменения, тем самым снимая метки:

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

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

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

git rebase — построение ровной линии коммитов

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

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

Предположим, имеется две ветки, master и топик, в каждой из которых было совершенно несколько коммитов начиная с момента ветвления. Команда git rebase берет коммиты из ветки topic и накладывает их на последний коммит ветки master.

Вариант, в котором явно указывается, что и куда накладывается:

на master накладывается активная в настоящий момент ветка:

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

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

Альтернативными выходами будут команды пропустить наложение коммита и перейти к следующему:

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

С ключом -i (—interactive) команда будет работать в интерактивном режиме. Пользователю будет предоставлена возможность определить порядок внесения изменений, автоматически будет вызывать редактор для разрешения конфликтов и так далее.

git cherry-pick — применение к дереву проекта изменений, внесенных отдельным коммитом

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

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

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

git worktree — одновременная работа с несколькими ветками

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

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

Директорию с веткой можно перести в другое место с помощью команды:

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

Клонирование репозитория с подмодулями

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

Запуск данной команды эквивалентен запуску команды:

после обычного клонирования репозитория

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

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

или использовать аргументы по умолчанию команды git pull:

Эта команда просто обновляет локальную рабочую копию. При запуске команды git status каталоги подмодулей будут показаны изменёнными. Чтобы обновить репозиторий необходимо зафиксировать изменения:

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

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

После этого необходимо добавить и зафиксировать новый файл .gitmodules. В нём описано какие подмодули следует клонировать при запуске команды git submodule update

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

Для удаления подмодуля из репозитория необходимо удалить описание подмодуля и каталог с файлами подмодуля:

Прочие команды и необходимые возможности

Хэш — уникальная идентификация объектов

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

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

Ищет разницу текущего состояния проекта и коммита за номером… сами видите, каким:

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

Иногда хватает и четырех символов:

Читает лог с коммита по коммит:

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

git tag — тэги как способ пометить уникальный коммит

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

Кроме этого в git представленные так называемые «легковесные тэги» (lightweight tags), состоящие только из имени и ссылки на коммит. Такие тэги, как правило, используются для упрощения навигации по дереву истории; создать их очень легко.

Создаёт «легковесный» тэг, связанный с последним коммитом; если тэг уже есть, то еще один создан не будет:

Помечает определенный коммит:

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

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

Обычные тэги имеет смысл использовать для приложения к коммиту какой-либо информации, вроде номера версии и комментария к нему. Иными словами, если в комментарии к коммиту пишешь «исправил такой-то баг», то в комментарии к тэгу по имени «v1.0» будет что-то вроде «стабильная версия, готовая к использованию».

Создаёт обычный тэг для последнего коммита; будет вызван текстовый редактор для составления комментария:

Создаёт обычный тэг, сразу указав в качестве аргумента комментарий:

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

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

Если после «птички» поставить цифру, то можно адресоваться по нескольким предкам коммитов слияния:

Ищет изменения по сравнению со вторым предком последнего коммита в master; HEAD здесь — указатель на последний коммит активной ветки.

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

Что привнес «дедушка» нынешнего коммита:

Обозначения можно объединять, чтобы добраться до нужного коммита:

Файл .gitignore — объясняем git, какие файлы следует игнорировать

Иногда по директориям проекта встречаются файлы, которые не хочется постоянно видеть в сводке git status. Например, вспомогательные файлы текстовых редакторов, временные файлы и прочий мусор.

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

Пример содержимого такого файла:

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

Серверные команды репозитория

Команда создания вспомогательных файлов для dumb-сервера в $GIT_DIR/info и $GIT_OBJECT_DIRECTORY/info каталогах, чтобы помочь клиентам узнать, какие ссылки и пакеты есть на сервере:

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

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

Создание пустого репозитория на сервере

Импорт svn репозитория на Git-сервер

Связка локальной и удаленной ветки

Отправление ветки local в удаленный репозиторий и установка локальной ветки local отслеживаемой с origin/local:

Пометка локальной ветки как отслеживаемой с origin/local:

Создание новой пустой ветки

Создание пустой ветки с именем newbranch:

Использование Git для получения версии

Установка начала новой версии на текущий коммит:

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

• v1.0-dev — имя тега
• 3 — количество коммитов после этого тега (0 если тэг поставлен на текущий коммит)
• 387f83f — короткий хэш текущего коммита.