Pull origin github desktop что это
Git push, git pull, git fetch — в чем разница? Шпаргалка по git-командам
Git — это распределенная система контроля версий. Она позволяет хранить данные обо всех изменениях кода в конкретных папках на жестком диске и обеспечивает удобную командную работу.
Git push
Команда git push в ходе выполнения переносит все изменения, внесенные юзером, в удаленный репозиторий (например, такой как GitHub):
Вынужденная команда push при корректировке коммитов:
Git pull
Команда git pull отвечает за скачивание данных с сервера. Процесс очень похож на клонирование репозитория, но здесь скачиваются не все коммиты, а только новые.
По сути, git pull — это сочетание команд git fetch (загружает коммиты, ссылки, файлы из удаленного репозитория в локальный) и git merge (объединяет несколько коммитов в один общий).
Git pull для удаленной ветки
Git fetch
Синхронизация с командой git fetch origin
Это отобразит ветки, которые уже были загружены:
Git merge
Команда git merge связывает ряд коммитов в одно целое. В свою очередь git создает коммит слияния, где и объединяются изменения обеих последовательностей.
Конфликт в слиянии
По завершению слияния, выполните команду git add : таким образом вы проинформируете, что причина конфликта разрешена. Важно запомнить, что конфликты допустимы только в трехслойном слиянии и никогда не возникают при ускоренном.
Разница между командами git
Условно говоря, git pull – это последовательность двух команд: git fetch (прием изменений от сервера) и git merge (слияние).
В свою очередь, git push переносит ветвь разработки в удаленную исходную точку, а git merge — объединяет изменения из разработки в локальную ветку.
Шпаргалка по git-командам
git init — создание новых репозиториев;
git clone — клонирование удаленного репозитория;
git rm — удаление файла;
git log — просмотр истории коммитов;
git branch
— создание новой ветки;
git branch –d
— удаление ветки;
git merge
— слияние веток;
git push
— отправка ветки на удаленный сервер;
git push :
— удаление ветки на удаленном сервере;
git tag — просмотр меток;
git push — обмен метками;
git remote — отображение удаленных репозиториев;
git pull
— получение данных из удаленного репозитория и слияние с локальным;
git push
— отправка локальных изменений на удаленный сервер.
git pull
Использование git pull
Порядок действий
В этом сценарии команда git pull загрузит все изменения, начиная с того места, где разошлись локальная и главная ветки. В данном примере это точка E. Команда git pull получит удаленные коммиты из отходящей ветки (т. е. точки A‑B‑C). Затем в процессе запуска команды pull будет создан новый локальный коммит слияния, включающий содержимое новых удаленных коммитов из отходящей ветки.
На этой схеме видно, что при перебазировании с помощью команды pull не был создан новый коммит H. Вместо этого удаленные коммиты A‑B‑C были скопированы и добавлены в историю в локальной ветке origin/main перед локальными коммитами E–F–G с перезаписью последних.
Распространенные опции
Подобно вызову по умолчанию, извлекает удаленное содержимое, но не создает новый коммит со слитым содержимым.
Во время выполнения команды pull выдает подробный вывод о загружаемом содержимом и информацию о слиянии.
Обсуждение git pull
Сначала вы думаете, что ваш репозиторий синхронизирован, однако команда git fetch показывает, что с момента последней проверки версия origin ветки main была изменена. Затем команда git merge сразу интегрирует удаленную ветку main в локальную ветку.
Git pull и синхронизация
Команда git pull — одна из множества команд, отвечающих за синхронизацию удаленного содержимого. Команда git remote используется, чтобы указать, на каких удаленных конечных точках будут работать команды синхронизации. Команда git push используется для выгрузки содержимого в удаленный репозиторий.
Сравнение pull и rebase
Примеры использования git pull
В нижеприведенных примерах показано, как использовать команду git pull в общих сценариях.
Поведение по умолчанию
Команда git pull на удаленных ветках
Перебазирование с помощью git pull вместо слияния
В следующем примере показано, как выполнить синхронизацию с главной веткой main центрального репозитория, используя перебазирование.
В этом примере ваши локальные изменения просто помещаются поверх изменений всех остальных участников разработки.
Практическое занятие «Используем клиент GitHub для десктопа»
Хотя большинство разработчиков используют командную строку при работе с системами контроля версий, существует много доступных клиентов с графическим интерфейсом, которые потенциально могут упростить процесс. Такие инструменты могут быть полезны, когда нужно увидеть, что изменилось в файле, поскольку графический интерфейс пользователя может быстро выделить и указать на происходящие изменения.
Типичный процесс использования десктопного клиента
В этом разделе мы научимся использовать десктопный клиент GitHub для управления процессом Git.
Для настройки репозитория Git используя клиента GitHub Desktop:
В списке измененных файлов зеленый знак + означает добавление нового файла. Желтый круг означает изменения существующего файла.
Если посмотреть репозиторий в сети, то увидим, что внесенные изменения были перенесены в основную ветку в источнике. Можно перейти на вкладку History в клиенте GitHub Desktop (вместо вкладки Changes) или перейти в меню View > Show History, чтобы просмотреть ранее внесенные изменения.
Создание ветки
Теперь создадим ветку, внесем изменения и посмотрим как влияют изменения на ветку.
После создания ветки, в центре раскрывающееся меню будет указывать на ту ветку, в которой мы работаем. Создание ветки копирует существующий контент (из ветки master) в новую ветку (development).
Изменения в файле показывают удаленные строки красным и новые строки зеленым цветом. Цвета помогают увидеть, что изменилось.
Обычно новую ветку создают, когда вносят значительные изменения в контент. Например, нужно обновить раздел («Раздел X») в своих документах. Возможно, опубликовать другие обновления не нужно, прежде чем публиковать подробные изменения в Разделе X. Если работа была в той же ветке, было бы сложно выборочно загружать обновления для нескольких файлов за пределами Раздела X без отправки обновлений, которые сделали к файлам в разделе Х.
Посредством ветвления можно ограничить свои изменения конкретной версией, которая не запускается, пока не будут готовы изменения к объединению с master веткой.
Слияние (merge) ветки development с master
Теперь научимся объединять наши ветки.
После слияния веток изменения будут отображаться и в файле в ветке master.
После этого наши изменения будут отображены в репозитории на GitHub.
Слияние ветки через pull request
Теперь объединим ветку development с master, используя процесс pull request. Мы притворимся, что клонировали репозиторий разработчика, и хотим, чтобы разработчик влил наше изменение в ветку development. (Другими словами, у нас может нет прав на слияние веток в мастер.) Для этого мы создадим запрос на извлечение (pull request).
На сайте GiHub pull request выглядит так:
Pull Request
Стрелка влево (указывающая из ветви development в направлении master) указывает, что запрос на извлечение («PR») хочет объединить ветку development с основной веткой.
Чтобы увидеть, какие изменения объединяются с мастером, можете щелкнуть вкладку Files changed (которая появляется на дополнительной навигационной панели вверху). Затем кликаем Merge pull request для объединения в ветке и Confirm merge, чтобы завершить объединение.
Теперь получим обновления, которые мы слили в master ветку, в свою локальную копию. В GitHub Desktop выбираем master ветку и кликаем кнопку Fetch origin. Fetch получает последние обновления из источника, но не обновляет локальную рабочую копию с изменениями.
После нажатия кнопка Fetch origin изменится на Pull Origin.
Проверим файлы и обратим внимание, что обновления, которые изначально были в ветке development, теперь отображаются и в master.
Управление конфликтами слияния
Предположим, мы внесли изменения в свою локальную копию файла в хранилище, а кто-то другой изменяет этот же файл, используя интерфейс браузера GitHub.com. Изменения противоречат друг другу. Что происходит?
Когда нажимаем Push origin от клиента GitHub Desktop, увидим сообщение о том, что хранилище было обновлено с момента последнего извлечения:
Кнопка, которая раньше говорила «Push origin», теперь говорит «Pull origin». кликаем «Pull origin». Теперь получаем еще одно сообщение об ошибке, которое говорит:
Если решим зафиксировать свои изменения, то увидим сообщение, которое гласит:
GitHub Desktop отображает восклицательный знак рядом с файлами с конфликтами слияния. Откройте файл конфликта и найдите маркеры конфликта ( и >>>>>>> ). Например, такие:
Устраняем все конфликты, изменив содержимое маркеров, а затем удалив маркеры. Например, обновите содержимое до этого:
Теперь нужно снова добавить файл в Git. В GitHub Desktop внесем изменения в обновленные файлы. Кликаем Push origin. Обновления на локальном компьютере отправляются на удаленный компьютер без каких-либо конфликтов.
Заключение
Используемые в этом занятии команды в интерфейсе GitHub Desktop можно попробовать и в командной строке. Возможно, что командная строка понравится больше. Но GitHub Desktop может стать хорошей отправной точкой.
Установка GitHub Desktop и его базовое использование
Что такое Git, регистрируемся на GitHub, для чего нужен GitHub Desktop, установим и рассмотрим его базовое использование
Так как эти темы довольно обширные, в статье рассмотрим их обзорно, с минимально необходимой информацией, для общего понимания и базовой работы с GitHub Desktop.
Что такое Git
Git (произносится «гит») — распределённая система управления версиями.
Система управления версиями (от англ. Version Control System, VCS или Revision Control System) — программное обеспечение для облегчения работы с изменяющейся информацией. Система управления версиями позволяет хранить несколько версий одного и того же документа, при необходимости возвращаться к более ранним версиям, определять, кто и когда сделал то или иное изменение, и многое другое.
Если мы верстаем или программируем, не используя систему Git, то в нашем распоряжении только тот код, который пишем сейчас.
При использовании системы Git мы запоминаем версии кода на нужных нам этапах. Имеем доступ к ранним версиям. Можем смотреть изменения, которые были сделаны между версиями. Можем отменить изменения до любой из версий.
У Git много возможностей, но на данный момент рассматриваем только базовые
Что такое GitHub
GitHub — крупнейший веб-сервис для хостинга IT-проектов и их совместной разработки.
Репозито́рий (англ. repository), хранилище — место, где хранятся и поддерживаются какие-либо данные. Чаще всего данные в репозитории хранятся в виде файлов, доступных для дальнейшего распространения по сети.
Репозиторий может храниться локально на компьютере или чаще всего на таких веб-сервисах, как GitHub
Для чего нужен Github Desktop
Работа с Git подразумевает работу через командную строку, но компания GitHub выпустила приложение, которое сильно упрощает использование Git
Для работы с GitHub Desktop, необходимо зарегистрироваться на GitHub
Регистрация на GitHub
Переходим на официальный сайт GitHub
На главной странице заполняем форму справа и нажимаем “Sign up for GitHub”
Проходим проверку и нажимаем “Join a free plan”
На следующей странице можно заполнить небольшую анкету (можно не заполнять)
На этой же странице спускаемся в самый низ и нажимаем “Complete setup”
Далее для завершения регистрации просят подтвердить свой email адрес.
Проверяем свою почту. Если письмо пришло, переходим к следующему пункту.
Если письмо не пришло, нажимаем “Resend verification email”.
В письме от Github нажимаем “Verify email address”
Аккаунт GitHub успешно создан
Установка GitHub Desktop
Переходим на официальный сайт GitHub Desktop
Нажимаем “Download for Windows (64bit)” (операционная система может отличаться)
Запускаем скачанный файл. После установки в появившемся окне нажимаем “Sign in to GitHub.com”
В открывшемся окне браузера вводим в форму свои данные, как при регистрации, и нажимаем “Sign in”
Если браузер запросит, то подтвердить, что нужно “Открыть приложение GitHub Desktop”
Отключаем пункт “Yes, submit periodic usage stats”, если не хотите периодически передавать статистику работы GitHub Desktop и нажимаем “Finish”
Далее видим начальное окно GitHub Desktop
Справа будут отображаться ваши репозитории, которые уже загружены на GitHub, но если только что зарегистрировались, то список будет пуст.
Создаём новый репозиторий
Создаём у себя на компьютере (например, на диске C:) папку projects, где локально будут храниться все наши репозитории.
Переходим в Github Desktop, нажимаем на начальном экране “Create a New Repository on your hard drive…“ или File > New Repository
В папке projects появился репозиторий Project-1
В репозитории Project-1 на данный момент находятся только необходимые служебные файлы Git.
На данный момент репозиторий расположен только локально на компьютере в папке Project-1. Чтобы репозиторий появился в аккаунте GitHub и хранился там, нажимаем “Publish repository”
В появившемся окне оставляем все по-умолчанию. Пункт “Keep this code private” оставляем отмеченным, чтобы репозиторий, пока что, был виден только нам, потом в любой момент репозиторий можно будет сделать открытым, чтобы его видели другие пользователи GitHub. Нажимаем “Publish repository”
Теперь репозиторий скопирован в аккаунт GitHub. Переходим в браузере на GitHub. Сверху справа нажимаем на круглую иконку аккаунта и выбираем пункт “Your repositories”
На странице наших репозиториев появился созданный репозиторий Project-1
Откроем страницу репозитория, нажав на название репозитория в списке. На данный момент в репозитории только служебные файлы.
Создадим на компьютере в папке Project-1 файл index.html и напишем в нем минимальную разметку.
На данный момент файл index.html расположен только локально в папке Project-1. Локальная система Git, которая была создана вместе с репозиторием, об этом файле ничего не знает.
Чтобы Git узнала, что в репозиторий добавился файл, необходимо сообщить это через команду Commit.
Коммитам необходимо давать названия.
Откроем Github Desktop. Во вкладке Changes видим созданный index.html.
На данный момент мы зафиксировали файлы в текущем состоянии и сделали запись об этом в локальную систему Git.
Далее, чтобы передать изменения в репозиторий на GitHub, нажимаем “Push origin”
Переходим в наш репозиторий на GitHub и убеждаемся, что файл index.html был добавлен
Project-1
Видим, что index.html был изменен при коммите add h1
Нажав на название файла index.html, убеждаемся что заголовок добавлен
На данный момент умеем создать репозиторий, делать коммиты, и передавать на GitHub
Далее рассмотрим работу с GitHub Desktop с нескольких рабочих мест
Клонирование репозитория
Создадим теперь на ноутбуке папку для репозиториев, например notebook projects
Устанавливаем на ноутбук GitHub Desktop, заходим под своим аккаунтом. Нажимаем File > Clone Repository
В списке выбираем необходимый репозиторий
В пункте Local path, нажимаем кнопку “Choose…“ и выбираем созданную папку notebook projects. Далее нажимаем “Clone…“
Репозиторий клонирован (скопирован) в папку Project-1.
Если в GitHub Desktop посмотреть вкладку History, то увидим всю историю коммитов
Внесем изменения в index.html на ноутбуке, добавим
Add text from Notebook
Коммит виден в репозитории на GitHub
В index.html добавлен
Add text from Notebook
Отличия есть, поэтому далее нажимаем “Pull origin”
И получаем актуальный проект со всеми изменениями
Преимущества
Мы рассмотрели только базовое использование Git, GitHub, GitHub Desktop, но уже можем выделить достаточно много преимуществ (на самом деле их намного больше, как и возможностей)
Итоги
Возможно, на первый взгляд, покажется сложным, но после небольшой практики, вся базовая работа с GitHub Desktop на начальном этапе сойдется к тому, что вы поработали с проектом на работе > сделали коммит (“Commit to main”) > отправили на GitHub (“Push origin”). Пришли домой > получили изменения из GitHub (“Pull origin”) и продолжаете работу дома.
Возможно, через некоторое время напишу статью про другие возможности GitHub Desktop
Больше информации на официальном сайте GitHub Desktop
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:
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 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).
Обратите внимание на обозначение HEAD^, оно означает «обратиться к предку последнего коммита». Подробней описан синтаксис такой относительной адресации будет ниже, в разделе «Хэши, тэги, относительная адресация». Соответственно, HEAD — ссылка на последний коммит. Ссылка ORIG_HEAD после «мягкого» резета указывает на оригинальный коммит.
Естественно, можно вернуться и на большую глубину коммитов,
Если команда достигнет точки ветвления, удаления коммита не произойдет.
Для команд слияния или выкачивания последних изменений с удаленного репозитория примеры резета будут приведены в соответствующих разделах.
git revert — отмена изменений, произведенных в прошлом отдельным коммитом
Возможна ситуация, в которой требуется отменить изменения, внесенные отдельным коммитом. git revert создает новый коммит, накладывающий обратные изменения.
Отменяет коммит, помеченный тегом:
Отменяет коммит, используя его хэш:
Для отмены коммита слияния (коммита у которого несколько родителей), необходимо указать хэш и номер одного из родителей коммита:
Для использования команды необходимо, чтобы состояние проекта не отличалось от состояния, зафиксированного последним коммитом.
git log — разнообразная информация о коммитах в целом
Иногда требуется получить информацию об истории коммитов; коммитах, изменивших отдельный файл; коммитах за определенный отрезок времени и так далее. Для этих целей используется команда git log.
Простейший пример использования, в котором приводится короткая справка по всем коммитам, коснувшимся активной в настоящий момент ветки (о ветках и ветвлении подробно узнать можно ниже, в разделе «Ветвления и слияния»):
Чтобы просмотреть историю отдельного файла, достаточно указать в виде параметра его имя (кстати, в моей старой версии git этот способ не срабатывает, обязательно добавлять » — » перед «README»):
или, если версия git не совсем свежая:
Далее приводится только более современный вариант синтаксиса. Возможно указывать время, начиная в определенного момента («weeks», «days», «hours», «s» и так далее):
изменения, касающиеся отдельной папки:
Можно отталкиваться от тегов.
Все коммиты, начиная с тега v1:
Все коммиты, включающие изменения файла README, начиная с тега v1:
Все коммиты, включающие изменения файла README, начиная с тега v1 и заканчивая тегом v2:
Выводит на каждый из коммитов по строчке, состоящей из хэша (здесь — уникального идентификатора каждого коммита, подробней — дальше):
Лаконичная информация о коммитах, приводятся только автор и комментарий:
Более полная информация о коммитах, с именем автора, комментарием, датой создания и внесения коммита:
В принципе, формат вывода можно определить самостоятельно:
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 позволяет переключаться между последними коммитами (если упрощенно) веток:
Создаёт ветку, в которую и произойдет переключение:
Вернуть файл (или просто вытащить из прошлого коммита) позволяет команда вида:
Возвращает somefile к состоянию последнего коммита:
Возвращает somefile к состоянию на два коммита назад по ветке:
git merge — слияние веток, разрешение возможных конфликтов
Слияние веток, в отличие от обычной практики централизованных систем, в git происходит практически каждый день. Естественно, что имеется удобный интерфейс к популярной операции.
Пытается объединить текующую ветку и ветку new-feature:
В случае возникновения конфликтов коммита не происходит, а по проблемным файлам расставляются специальные метки а-ля svn; сами же файлы отмечаются в индексе как «не соединенные» (unmerged). До тех пор пока проблемы не будут решены, коммит совершить будет нельзя.
Например, конфликт возник в файле TROUBLE, что можно увидеть в git status.
Произошла неудачная попытка слияния:
Смотрим на проблемные места:
Индексируем наши изменения, тем самым снимая метки:
Совершаем коммит слияния:
Вот и все, ничего сложного. Если в процессе разрешения вы передумали разрешать конфликт, достаточно набрать (это вернёт обе ветки в исходные состояния):
Если же коммит слияния был совершен, используем команду:
git rebase — построение ровной линии коммитов
Предположим, разработчик завел дополнительную ветку для разработки отдельной возможности и совершил в ней несколько коммитов. Одновременно по какой-либо причине в основной ветке также были совершены коммиты: например, в нее были залиты изменения с удаленного сервера, либо сам разработчик совершал в ней коммиты.
В принципе, можно обойтись обычным git merge. Но тогда усложняется сама линия разработки, что бывает нежелательно в слишком больших проектах, где участвует множество разработчиков.
Предположим, имеется две ветки, master и топик, в каждой из которых было совершенно несколько коммитов начиная с момента ветвления. Команда git rebase берет коммиты из ветки topic и накладывает их на последний коммит ветки master.
Вариант, в котором явно указывается, что и куда накладывается:
на master накладывается активная в настоящий момент ветка:
После использования команды история становится линейной. При возникновении конфликтов при поочередном накладывании коммитов работа команды будет останавливаться, а в проблемные местах файлов появятся соответствующие метки. После редактирования, разрешения конфликтов, файлы следует внести в индекс командой:
и продолжить наложение следующих коммитов командой:
Альтернативными выходами будут команды пропустить наложение коммита и перейти к следующему:
и отмена работы команды и всех внесенных изменений:
git cherry-pick — применение к дереву проекта изменений, внесенных отдельным коммитом
Если ведется сложная история разработки, с несколькими длинными ветками разработками, может возникнуть необходимость в применении изменений, внесенных отдельным коммитом одной ветки, к дереву другой (активной в настоящий момент).
Изменения, внесенные указанным коммитом будут применены к дереву, автоматически проиндексированы и станут коммитом в активной ветке:
Git позволяет работать одновременно с несколькими ветками одного репозитория. Для добавления ветки в отдельную директорию необходимо выполнить команду:
Для просмотра всех директориев с ветками можно воспользоваться командой:
Директорию с веткой можно перести в другое место с помощью команды:
После окончания работы с веткой в директории, её можно удалить командой:
Клонирование репозитория с подмодулями
При клонировании репозитория вам необходимо инициализировать и обновить подмодули:
Запуск данной команды эквивалентен запуску команды:
после обычного клонирования репозитория
Подмодуль ссылается на конкретную коммит в другом репозитории. Чтобы получить точное состояние всех подмодулей необходимо запустить:
Для получения состояния последнего коммита всех подмодулей необходимо выполнить следующую команду:
или использовать аргументы по умолчанию команды git pull:
Эта команда просто обновляет локальную рабочую копию. При запуске команды git status каталоги подмодулей будут показаны изменёнными. Чтобы обновить репозиторий необходимо зафиксировать изменения:
Для получения состояние последнего коммита конкретного подмодуля необходимо использовать команду:
В текущий проект можно включить другой репозиторий Git в качестве папки, отслеживаемый Git:
Для перемещение подмодуля из одного места репозитория в другое место репозитория необходимо выполнить команду:
Для удаления подмодуля из репозитория необходимо удалить описание подмодуля и каталог с файлами подмодуля:
Прочие команды и необходимые возможности
Хэш — уникальная идентификация объектов
В git для идентификации любых объектов используется уникальный (то есть с огромной вероятностью уникальный) хэш из 40 символов, который определяется хэшируюшей функцией на основе содержимого объекта. Объекты — это все: коммиты, файлы, тэги, деревья. Поскольку хэш уникален для содержимого, например, файла, то и сравнивать такие файлы очень легко — достаточно просто сравнить две строки в сорок символов.
Больше всего нас интересует тот факт, что хэши идентифицируют коммиты. В этом смысле хэш — продвинутый аналог ревизий Subversion. Несколько примеров использования хэшей в качестве способа адресации.
Ищет разницу текущего состояния проекта и коммита за номером… сами видите, каким:
То же самое, но оставляем только шесть первых символов. Git поймет, о каком коммите идет речь, если не существует другого коммита с таким началом хэша:
Иногда хватает и четырех символов:
Читает лог с коммита по коммит:
Разумеется, человеку пользоваться хэшами не так удобно, как машине, именно поэтому были введены другие объекты — тэги.
git tag — тэги как способ пометить уникальный коммит
Тэг (tag) — это объект, связанный с коммитом; хранящий ссылку на сам коммит, имя автора, собственное имя и некоторый комментарий. Кроме того, разработчик может оставлять на таких тегах собственную цифровую подпись.
Кроме этого в git представленные так называемые «легковесные тэги» (lightweight tags), состоящие только из имени и ссылки на коммит. Такие тэги, как правило, используются для упрощения навигации по дереву истории; создать их очень легко.
Создаёт «легковесный» тэг, связанный с последним коммитом; если тэг уже есть, то еще один создан не будет:
Помечает определенный коммит:
Создаёт тэг для последнего коммита, заменяет существующий, если таковой уже был:
После создания тэга его имя можно использовать вместо хэша в любых командах вроде git diff, git log и так далее:
Обычные тэги имеет смысл использовать для приложения к коммиту какой-либо информации, вроде номера версии и комментария к нему. Иными словами, если в комментарии к коммиту пишешь «исправил такой-то баг», то в комментарии к тэгу по имени «v1.0» будет что-то вроде «стабильная версия, готовая к использованию».
Создаёт обычный тэг для последнего коммита; будет вызван текстовый редактор для составления комментария:
Создаёт обычный тэг, сразу указав в качестве аргумента комментарий:
Команды перечисления, удаления, перезаписи для обычных тэгов не отличаются от команд для «легковесных» тэгов.
Вместо ревизий и тэгов в качестве имени коммита можно опираться на еще один механизм — относительную адресацию. Например, можно обратиться прямо к предку последнего коммита ветки master:
Если после «птички» поставить цифру, то можно адресоваться по нескольким предкам коммитов слияния:
Ищет изменения по сравнению со вторым предком последнего коммита в master; HEAD здесь — указатель на последний коммит активной ветки.
Аналогично, тильдой можно просто указывать, насколько глубоко в историю ветки нужно погрузиться.
Что привнес «дедушка» нынешнего коммита:
Обозначения можно объединять, чтобы добраться до нужного коммита:
Иногда по директориям проекта встречаются файлы, которые не хочется постоянно видеть в сводке git status. Например, вспомогательные файлы текстовых редакторов, временные файлы и прочий мусор.
Пример содержимого такого файла:
Существуют и другие способы указания игнорируемых файлов, о которых можно узнать из справки git help gitignore.
Серверные команды репозитория
Проверяет сколько объектов будет потеряно и объём освобождаемого места при перепаковке репозитория:
Переупаковывает локальный репозиторий:
Создание пустого репозитория на сервере
Импорт svn репозитория на Git-сервер
Связка локальной и удаленной ветки
Отправление ветки local в удаленный репозиторий и установка локальной ветки local отслеживаемой с origin/local:
Пометка локальной ветки как отслеживаемой с origin/local:
Создание новой пустой ветки
Создание пустой ветки с именем newbranch:
Использование Git для получения версии
Установка начала новой версии на текущий коммит:
Получение номера версии для последующие коммитов: