Spec-Zone.ru › Git

git-pull

Имя

git-pull — получение данных из другого репозитория или локальной ветки и интеграция изменений

Синопсис

git pull [<options>] [<repository> [<refspec>…​]]

Описание

Интегрирует изменения из удалённого репозитория в текущую ветку.

Сначала git pull запускает git fetch с теми же аргументами (за исключением параметров слияния), чтобы получить данные об удалённых ветках. Затем команда решает, какую удалённую ветку интегрировать: если запустить git pull без аргументов, по умолчанию используется вышестоящая ветка текущей ветки. Затем эта ветка интегрируется в текущую.

Существует четыре основных способа интеграции удалённой ветки:

  1. git pull --ff-only выполняет только обновления с «перемоткой вперёд»: команда завершается с ошибкой, если локальная ветка разошлась с удалённой. Это способ по умолчанию.

  2. git pull --rebase запускает git rebase

  3. git pull --no-rebase запускает git merge.

  4. git pull --squash запускает git merge --squash

Также можно задать параметры конфигурации pull.rebase, pull.squash или pull.ff, чтобы выбрать предпочтительное поведение.

Если во время слияния или перебазирования возник конфликт, который вы не хотите разрешать, его можно безопасно прервать с помощью git merge --abort или git rebase --abort.

Параметры

<repository>

«Удалённый» репозиторий, из которого нужно получить данные. Это может быть URL-адрес (см. раздел URL-АДРЕСА GIT ниже) или имя удалённого репозитория (см. раздел УДАЛЁННЫЕ РЕПОЗИТОРИИ ниже).

По умолчанию используется настроенная вышестоящая ветка текущей ветки или origin. Подробнее о настройке вышестоящих веток см. ниже в разделе ВЫШЕСТОЯЩИЕ ВЕТКИ.

<refspec>

Ветка или другие ссылки, данные которых нужно получить и интегрировать в текущую ветку, например main в git pull origin main. По умолчанию используется настроенная вышестоящая ветка текущей ветки.

Это может быть ветка, тег или другая совокупность ссылок. Полный синтаксис см. ниже в разделе <refspec> подраздела «Параметры, связанные с получением данных», а сведения о том, как git pull использует этот аргумент для определения интегрируемой удалённой ветки, см. ниже в разделе ПОВЕДЕНИЕ ПО УМОЛЧАНИЮ.

-q
--quiet

Передаётся как базовой команде git-fetch, чтобы подавить сообщения во время передачи данных, так и базовой команде git-merge, чтобы подавить вывод при слиянии.

-v
--verbose

Передаёт --verbose командам git-fetch и git-merge.

--recurse-submodules[=(yes|on-demand|no)]
--no-recurse-submodules

Этот параметр определяет, следует ли получать новые коммиты заполненных подмодулей, а также обновлять ли рабочие деревья активных подмодулей (см. git-fetch[1], git-config[1] и gitmodules[5]).

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

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

Параметры, связанные со слиянием

--commit
--no-commit

Выполняет слияние и фиксирует результат. Этот параметр можно использовать для переопределения --no-commit. Полезен только при слиянии.

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

Обратите внимание: обновления с перемоткой вперёд не создают коммит слияния, поэтому остановить такое слияние с помощью --no-commit невозможно. Поэтому, если нужно гарантировать, что команда слияния не изменит и не обновит ветку, используйте --no-ff вместе с --no-commit.

--edit
-e
--no-edit

Перед фиксацией успешно выполненного автоматического слияния запускает редактор, чтобы можно было изменить автоматически сформированное сообщение о слиянии и объяснить его причины и обоснование. Параметр --no-edit можно использовать, чтобы принять автоматически сформированное сообщение (обычно это не рекомендуется).

Старые сценарии могут зависеть от прежнего поведения, при котором пользователю не разрешалось редактировать сообщение в журнале слияния. При запуске git merge в них будет открываться редактор. Чтобы упростить адаптацию таких сценариев к обновлённому поведению, в начале сценария можно задать переменную окружения GIT_MERGE_AUTOEDIT со значением no.

--cleanup=<mode>

Этот параметр определяет, как будет очищено сообщение о слиянии перед фиксацией. Подробнее см. git-commit[1]. Кроме того, если для <mode> задано значение scissors, перед передачей системе фиксации при конфликте слияния в MERGE_MSG будут добавлены ножницы.

--ff-only

Обновляет ветку до новой истории только в том случае, если локальная история не разошлась с удалённой. Это способ по умолчанию, если метод согласования разошедшихся историй не задан (с помощью флагов --rebase).

--ff
--no-ff

При слиянии, а не перебазировании, определяет, как выполнять слияние, если включаемая история уже является потомком текущей истории. Если запрошено слияние, по умолчанию используется --ff, за исключением случая слияния аннотированного (и, возможно, подписанного) тега, который хранится не в своём обычном месте в иерархии refs/tags/; в этом случае предполагается --no-ff.

С параметром --ff, если возможно, выполняет слияние с перемоткой вперёд (только перемещает указатель ветки, чтобы он указывал на объединённую ветку; коммит слияния не создаётся). Если это невозможно (включаемая история не является потомком текущей), создаёт коммит слияния.

С параметром --no-ff всегда создаёт коммит слияния, даже если слияние можно было выполнить с перемоткой вперёд.

-S[<key-id>]
--gpg-sign[=<key-id>]
--no-gpg-sign

Подписывает полученный коммит слияния с помощью GPG. Аргумент <key-id> необязателен; по умолчанию используется идентификатор автора коммита. Если аргумент указан, он должен следовать сразу за параметром без пробела. Параметр --no-gpg-sign полезен для отмены действия как переменной конфигурации commit.gpgSign, так и более раннего параметра --gpg-sign.

--log[=<n>]
--no-log

Помимо имён веток, добавляет в сообщение журнала однострочные описания не более чем <n> фактических коммитов, которые сливаются. См. также git-fmt-merge-msg[1]. Полезен только при слиянии.

С параметром --no-log однострочные описания фактических сливаемых коммитов не выводятся.

--signoff
--no-signoff

Добавляет в конец сообщения журнала коммита завершающую строку Signed-off-by от имени автора коммита. Значение подтверждения зависит от проекта, в который вы отправляете изменения. Например, оно может удостоверять, что автор коммита имеет право предоставить эту работу на условиях лицензии проекта или согласен с некоторым подтверждением со стороны участника, например с Сертификатом происхождения разработчика. (См. https://developercertificate.org — вариант, используемый в проектах ядра Linux и Git.) Чтобы понять, как в конкретном проекте используются такие подтверждения, ознакомьтесь с документацией проекта или обратитесь к его руководству.

Параметр --no-signoff можно использовать для отмены более раннего параметра --signoff в командной строке.

В Git нет (и не будет) переменной конфигурации, которая по умолчанию включает параметр командной строки --signoff; подробнее см. запись commit.signoff в gitfaq[7].

--stat
-n
--no-stat

Показывает в конце слияния статистику различий. Вывод этой статистики также регулируется параметром конфигурации merge.stat.

С параметром -n или --no-stat статистика различий в конце слияния не выводится.

--compact-summary

Показывает в конце слияния краткую сводку.

--squash
--no-squash

Создаёт такое состояние рабочего дерева и индекса, как если бы произошло настоящее слияние (за исключением сведений о слиянии), но не создаёт коммит, не перемещает HEAD и не записывает $GIT_DIR/MERGE_HEAD (чтобы следующая команда git commit создала коммит слияния). Это позволяет создать поверх текущей ветки один коммит, результат которого будет таким же, как при слиянии другой ветки (или нескольких веток в случае слияния типа «осьминог»).

С параметром --no-squash выполняет слияние и фиксирует результат. Этот параметр можно использовать для переопределения --squash.

При использовании --squash параметр --commit недопустим, и команда завершится с ошибкой.

Полезен только при слиянии.

--verify
--no-verify

По умолчанию запускаются хуки pre-merge и commit-msg. Если указан параметр --no-verify, они пропускаются. См. также githooks[5]. Полезен только при слиянии.

-s <strategy>
--strategy=<strategy>

Использует указанную стратегию слияния; параметр можно указать несколько раз, задав порядок их применения. Если параметр -s не указан, вместо него используется встроенный список стратегий (ort при слиянии одной вершины, в противном случае — octopus).

-X <option>
--strategy-option=<option>

Передаёт выбранной стратегии слияния параметр, относящийся к этой стратегии.

--verify-signatures
--no-verify-signatures

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

Полезен только при слиянии.

--summary
--no-summary

Синонимы для --stat и --no-stat; эти параметры устарели и будут удалены в будущем.

--autostash
--no-autostash

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

--allow-unrelated-histories

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

Полезен только при слиянии.

-r
--rebase[=(true|merges|false|interactive)]
true

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

merges

перебазирует с помощью git rebase --rebase-merges, включая локальные коммиты слияния в перебазирование (подробности см. в git-rebase[1]).

false

сливает вышестоящую ветку с текущей.

interactive

включает интерактивный режим перебазирования.

Если вы хотите, чтобы git pull всегда использовал --rebase вместо слияния, см. pull.rebase, branch.<name>.rebase и branch.autoSetupRebase в git-config[1].

+

Примечание
Этот режим работы потенциально опасен. Он переписывает историю, что может привести к проблемам, если вы уже опубликовали эту историю. Не используйте этот параметр, не ознакомившись внимательно с git-rebase[1].
--no-rebase

Это сокращённая запись для --rebase=false.

Параметры, связанные с получением

--all
--no-all

Получить данные со всех удалённых репозиториев, кроме тех, для которых задана переменная конфигурации remote.<name>.skipFetchAll. Это переопределяет переменную конфигурации fetch.all.

-a
--append

Добавить имена ссылок и имена объектов полученных ссылок к существующему содержимому .git/FETCH_HEAD. Без этого параметра старые данные в .git/FETCH_HEAD будут перезаписаны.

--atomic

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

--depth=<depth>

Ограничить получение указанным числом коммитов от вершины истории каждой удалённой ветки. Если данные получаются в shallow репозиторий, созданный командой git clone с параметром --depth=<depth> (см. git-clone[1]), углубить или сократить историю до указанного числа коммитов. Теги для углублённых коммитов не получаются.

--deepen=<depth>

Аналогично --depth, но задаёт число коммитов от текущей границы неглубокой истории, а не от вершины истории каждой удалённой ветки.

--shallow-since=<date>

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

--shallow-exclude=<ref>

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

--unshallow

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

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

--update-shallow

По умолчанию при получении данных из неглубокого репозитория git fetch отклоняет ссылки, для обновления которых требуется изменить .git/shallow. Этот параметр обновляет .git/shallow и принимает такие ссылки.

--negotiation-restrict=(<commit>|<glob>)
--negotiation-tip=(<commit>|<glob>)

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

--negotiation-restrict — предпочтительное название этого параметра; --negotiation-tip принимается как синоним.

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

Аргументом этого параметра может быть шаблон glob для имён ссылок, ссылка или SHA-1 коммита (возможно, сокращённый). Указание шаблона glob равносильно многократному указанию этого параметра — по одному разу для каждого совпадающего имени ссылки.

См. также переменные конфигурации fetch.negotiationAlgorithm и push.negotiate, описанные в git-config[1], а также параметр --negotiate-only ниже.

--negotiation-include=(<commit>|<glob>)

Гарантировать, что коммиты в указанных вершинах всегда будут отправляться в виде строк «have» во время согласования получения данных, независимо от выбранного алгоритма согласования. Это полезно, чтобы гарантировать учёт общей истории, достижимой из определённых ссылок, даже если --negotiation-restrict ограничивает набор вершин или алгоритм согласования иначе пропустил бы их.

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

Аргументом может быть точное имя ссылки (например, refs/heads/release), хеш объекта или шаблон glob (например, refs/heads/release/{asterisk}). Синтаксис шаблонов совпадает с синтаксисом для --negotiation-restrict.

Если используется --negotiation-restrict, сначала набор have ограничивается этим параметром, а затем расширяется за счёт вершин, указанных в --negotiation-include.

Если этот параметр не указан в командной строке, вместо него используются значения конфигурации remote.<name>.negotiationInclude для текущего удалённого репозитория.

--negotiate-only

Не получать данные с сервера, а вместо этого вывести предков предоставленных аргументов --negotiation-restrict=, которые являются общими с сервером.

Несовместим с --recurse-submodules=(yes|on-demand). Внутри Git этот параметр используется для реализации параметра push.negotiate; см. git-config[1].

--dry-run

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

--porcelain

Вывести данные в стандартный поток вывода в удобном для разбора скриптами формате. Подробности см. в разделе OUTPUT документации git-fetch[1].

Несовместим с --recurse-submodules=(yes|on-demand) и имеет приоритет над параметром конфигурации fetch.output.

--filter=<filter-spec>

Использовать функцию частичного клонирования и запросить у сервера подмножество достижимых объектов в соответствии с заданным фильтром объектов. При использовании --filter предоставленный <filter-spec> используется для частичного получения данных.

Если используется --filter=auto, спецификация фильтра определяется автоматически путём объединения спецификаций фильтров, объявленных сервером для принимаемых клиентом удалённых репозиториев-обещателей (см. gitprotocol-v2[5] и параметр конфигурации promisor.acceptFromServer в git-config[1]).

Подробные сведения обо всех остальных доступных спецификациях фильтров см. в описании параметра --filter=<filter-spec> в git-rev-list[1].

Например, --filter=blob:none отфильтрует все blob-объекты (содержимое файлов), пока они не понадобятся Git. Также --filter=blob:limit=<size> отфильтрует все blob-объекты размером не менее <size>.

-f
--force

При использовании git fetch со спецификацией ссылки <src>:<dst> локальная ветка может быть не обновлена, как описано в разделе <refspec> документации git-fetch[1]. Этот параметр отменяет эту проверку.

-k
--keep

Сохранить загруженный pack-файл.

--prefetch

Изменить настроенную спецификацию ссылок, чтобы поместить все ссылки в пространство имён refs/prefetch/. См. задачу prefetch в git-maintenance[1].

-p
--prune

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

--no-tags

По умолчанию теги, указывающие на объекты, загружаемые из удалённого репозитория, извлекаются и сохраняются локально. Этот параметр отключает автоматическое следование тегам. Поведение по умолчанию для удалённого репозитория можно задать параметром remote.<name>.tagOpt. См. git-config[1].

--refmap=<refspec>

При получении ссылок, перечисленных в командной строке, использовать указанную спецификацию ссылок (можно указать несколько раз) для сопоставления ссылок с ветками отслеживания удалённых репозиториев вместо значений переменных конфигурации remote.<name>.fetch для удалённого репозитория. Если для параметра --refmap указать пустой <refspec>, Git проигнорирует настроенные спецификации ссылок и будет использовать только спецификации, переданные в аргументах командной строки. Подробности см. в разделе «Настроенные ветки отслеживания удалённых репозиториев».

-t
--tags

Получить все теги из удалённого репозитория (т. е. получить удалённые теги refs/tags/* в локальные теги с теми же именами) в дополнение ко всему, что было бы получено в обычном случае. Использование этого параметра само по себе не приводит к удалению тегов, даже если указан --prune (однако теги всё же могут быть удалены, если они также являются назначением явной спецификации ссылок; см. --prune).

-j <n>
--jobs=<n>

Выполнять все виды получения данных параллельно, используя не более <n> заданий одновременно.

Значение 0 означает, что будет использовано разумное значение по умолчанию.

Если указан параметр --multiple, различные удалённые репозитории будут опрашиваться параллельно. Если получаются данные из нескольких подмодулей, они будут получаться параллельно. Чтобы управлять ими независимо, используйте параметры конфигурации fetch.parallel и submodule.fetchJobs (см. git-config[1]).

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

--set-upstream

Если получение данных из удалённого репозитория прошло успешно, добавить вышестоящую (отслеживаемую) ссылку, используемую командами git-pull[1] без аргументов и другими командами. Дополнительные сведения см. в описании branch.<name>.merge и branch.<name>.remote в git-config[1].

--upload-pack <upload-pack>

Если этот параметр указан, а репозиторием, из которого выполняется получение данных, управляет git fetch-pack, --exec=<upload-pack> передаётся команде, чтобы указать нестандартный путь к команде, выполняемой на другой стороне.

--progress

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

-o <option>
--server-option=<option>

Передать указанную строку серверу при взаимодействии с использованием протокола версии 2. Указанная строка не должна содержать символ NUL или LF. Обработка сервером параметров, в том числе неизвестных, зависит от конкретного сервера. Если указано несколько параметров --server-option=<option>, все они передаются другой стороне в порядке, заданном в командной строке. Если в командной строке не указан ни один параметр --server-option=<option>, вместо них используются значения переменной конфигурации remote.<name>.serverOption.

--show-forced-updates

По умолчанию Git проверяет, была ли ветка принудительно обновлена во время получения данных. Эту проверку можно отключить с помощью fetch.showForcedUpdates, но параметр --show-forced-updates гарантирует её выполнение. См. git-config[1].

--no-show-forced-updates

По умолчанию Git проверяет, была ли ветка принудительно обновлена во время получения данных. Передайте --no-show-forced-updates или установите для fetch.showForcedUpdates значение false, чтобы пропустить эту проверку ради повышения производительности. При использовании во время git-pull параметр --ff-only всё равно проверит принудительные обновления перед попыткой выполнить перемотку вперёд. См. git-config[1].

-4
--ipv4

Использовать только адреса IPv4, игнорируя адреса IPv6.

-6
--ipv6

Использовать только адреса IPv6, игнорируя адреса IPv4.

<repository>

«Удалённый» репозиторий, являющийся источником операции получения данных или извлечения изменений. Этот параметр может быть URL-адресом (см. раздел URL-адреса Git ниже) или именем удалённого репозитория (см. раздел Удалённые репозитории ниже).

<refspec>

Задаёт, какие ссылки получать и какие локальные ссылки обновлять. Если в командной строке не указаны <refspec>ы, ссылки для получения считываются из переменных remote.<repository>.fetch (см. раздел «НАСТРОЕННЫЕ ВЕТКИ ОТСЛЕЖИВАНИЯ УДАЛЁННЫХ РЕПОЗИТОРИЕВ» в git-fetch[1]).

Формат параметра <refspec>: необязательный знак «плюс» +, за которым следует исходная <src>, двоеточие : и целевая <dst>. Двоеточие можно опустить, если <dst> пуста. <src> обычно является ссылкой или шаблоном glob с одной * для сопоставления набора ссылок, но также может быть полным шестнадцатеричным именем объекта.

<refspec> может содержать * в своей <src> для указания простого сопоставления с шаблоном. Такая спецификация ссылок работает как шаблон glob, который сопоставляется с любой ссылкой, соответствующей шаблону. Шаблон <refspec> должен содержать ровно одну * как в <src>, так и в <dst>. Сопоставленные ссылки будут отображаться в целевое пространство заменой * содержимым, совпавшим с исходным значением.

Если перед спецификацией ссылок стоит ^, она интерпретируется как отрицательная спецификация ссылок. Вместо указания ссылок для получения или локальных ссылок для обновления такая спецификация указывает ссылки, которые нужно исключить. Ссылка считается подходящей, если она соответствует хотя бы одной положительной спецификации ссылок и не соответствует ни одной отрицательной. Отрицательные спецификации ссылок полезны для ограничения области действия шаблонной спецификации, чтобы исключить из неё конкретные ссылки. Отрицательные спецификации ссылок сами могут быть шаблонными, однако они могут содержать только <src> и не задают <dst>. Полные шестнадцатеричные имена объектов также не поддерживаются.

tag <tag> означает то же, что и refs/tags/<tag>:refs/tags/<tag>; этот параметр запрашивает получение всего, вплоть до указанного тега.

Получается удалённая ссылка, соответствующая <src>, и, если <dst> не является пустой строкой, предпринимается попытка обновить соответствующую ей локальную ссылку.

Возможность выполнить это обновление без --force зависит от пространства имён ссылок, в которое выполняется получение, типа получаемого объекта и того, считается ли обновление перемоткой вперёд. В общем случае при получении применяются те же правила, что и при отправке; см. раздел <refspec>... в git-push[1]. Исключения из этих правил, относящиеся к git fetch, перечислены ниже.

До версии Git 2.20, в отличие от отправки с помощью git-push[1], любые обновления refs/tags/* принимались без + в спецификации ссылок (или --force). При получении данных все обновления тегов с удалённого репозитория без разбора считались принудительными. Начиная с версии Git 2.20 получение данных для обновления refs/tags/* работает так же, как и при отправке. То есть любые обновления будут отклонены без + в спецификации ссылок (или --force).

В отличие от отправки с помощью git-push[1], любые обновления за пределами refs/{tags,heads}/* принимаются без + в спецификации ссылок (или --force), будь то замена, например, объекта дерева на blob-объект или одного коммита другим, у которого предыдущий коммит не является предком, и т. п.

В отличие от отправки с помощью git-push[1], конфигурации, изменяющей эти правила, не существует, как и перехватчика pre-fetch, аналогичного перехватчику pre-receive.

Как и при отправке с помощью git-push[1], все описанные выше правила о недопустимых обновлениях можно переопределить, добавив необязательный начальный + к спецификации ссылок (или используя параметр командной строки --force). Единственное исключение: никакое принудительное обновление не заставит пространство имён refs/heads/* принять объект, не являющийся коммитом.

Примечание
Если известно, что удалённая ветка, которую вы хотите получить, регулярно перематывается назад и перебазируется, ожидается, что её новая вершина не будет потомком предыдущей вершины (сохранённой в вашей ветке отслеживания удалённого репозитория при последнем получении данных). Для таких веток следует использовать знак +, указывающий на необходимость обновлений без перемотки вперёд. Невозможно определить или объявить, что ветка в репозитории будет вести себя таким образом; пользователь, получающий изменения, должен сам знать, что для этой ветки это ожидаемый сценарий использования.
Примечание
Существует разница между перечислением нескольких <refspec> непосредственно в командной строке git pull и наличием нескольких записей remote.<repository>.fetch в конфигурации для <repository> с последующим запуском команды git pull без явных параметров <refspec>. Явно перечисленные в командной строке <refspec> всегда объединяются с текущей веткой после получения данных. Иными словами, если перечислить несколько удалённых ссылок, команда git pull создаст слияние типа Octopus. С другой стороны, если в командной строке не перечислены явные параметры <refspec>, команда git pull получит все спецификации <refspec>, найденные в конфигурации remote.<repository>.fetch, и объединит с текущей веткой только первую найденную спецификацию <refspec>. Это объясняется тем, что создание слияния типа Octopus из удалённых ссылок выполняется редко, тогда как отслеживание нескольких удалённых вершин путём одновременного получения данных из нескольких источников часто бывает полезно.

URL-адреса Git

Как правило, URL содержат информацию о транспортном протоколе, адресе удалённого сервера и пути к репозиторию. В зависимости от транспортного протокола часть этой информации может отсутствовать.

Git поддерживает протоколы ssh, git, http и https (кроме того, для получения данных можно использовать ftp и ftps, но это неэффективно и считается устаревшим; не используйте их).

Нативный транспорт (то есть URL git://) не использует аутентификацию, поэтому в незащищённых сетях его следует применять с осторожностью.

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

  • ssh://[<user>@]<host>[:<port>]/<path-to-git-repo>

  • git://<host>[:<port>]/<path-to-git-repo>

  • http[s]://<host>[:<port>]/<path-to-git-repo>

  • ftp[s]://<host>[:<port>]/<path-to-git-repo>

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

  • [<user>@]<host>:/<path-to-git-repo>

Этот синтаксис распознаётся только в том случае, если перед первым двоеточием нет косых черт. Это позволяет отличить локальный путь, содержащий двоеточие. Например, локальный путь foo:bar можно указать как абсолютный путь или как ./foo:bar, чтобы его не приняли за URL ssh.

Протоколы ssh и git дополнительно поддерживают подстановку ~<username>:

  • ssh://[<user>@]<host>[:<port>]/~<user>/<path-to-git-repo>

  • git://<host>[:<port>]/~<user>/<path-to-git-repo>

  • [<user>@]<host>:~<user>/<path-to-git-repo>

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

  • /path/to/repo.git/

  • file:///path/to/repo.git/

Эти две формы в основном эквивалентны, за исключением клонирования: первая предполагает параметр --local. Подробности см. в git-clone[1].

Команды git clone, git fetch и git pull, но не git push, также принимают подходящий файл bundle. См. git-bundle[1].

Если Git не знает, как обрабатывать определённый транспортный протокол, он пытается использовать удалённый помощник remote-<transport>, если он существует. Чтобы явно запросить удалённый помощник, можно использовать следующий синтаксис:

  • <transport>::<address>

где <address> может быть путём, сервером и путём или произвольной строкой, похожей на URL и распознаваемой вызываемым удалённым помощником. Подробности см. в gitremote-helpers[7].

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

        [url "<actual-url-base>"]
                insteadOf = <other-url-base>

Например, с такой конфигурацией:

        [url "git://git.host.xz/"]
                insteadOf = host.xz:/path/to/
                insteadOf = work:

URL вида "work:repo.git" или "host.xz:/path/to/repo.git" в любом контексте, где требуется URL, будет преобразован в "git://git.host.xz/repo.git".

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

        [url "<actual-url-base>"]
                pushInsteadOf = <other-url-base>

Например, с такой конфигурацией:

        [url "ssh://example.org/"]
                pushInsteadOf = git://example.org/

URL вида "git://example.org/path/to/repo.git" при отправке изменений будет преобразован в "ssh://example.org/path/to/repo.git", а при получении изменений по-прежнему будет использоваться исходный URL.

Удалённые репозитории

Вместо URL в качестве аргумента <repository> можно использовать имя одного из следующих объектов:

  • удалённый репозиторий из файла конфигурации Git: $GIT_DIR/config,

  • файл в каталоге $GIT_DIR/remotes или

  • файл в каталоге $GIT_DIR/branches.

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

Именованный удалённый репозиторий в файле конфигурации

Можно указать имя удалённого репозитория, настроенного ранее с помощью git-remote[1], git-config[1] или даже вручную в файле $GIT_DIR/config. Для доступа к репозиторию будет использоваться URL этого удалённого репозитория. Если в командной строке не указан refspec, по умолчанию будет использоваться refspec этого удалённого репозитория. Запись в файле конфигурации будет выглядеть так:

        [remote "<name>"]
                url = <URL>
                pushurl = <pushurl>
                push = <refspec>
                fetch = <refspec>

Параметр <pushurl> используется только для отправки изменений. Он необязателен и по умолчанию равен <URL>. При отправке изменений в удалённый репозиторий используются все заданные pushurl или все заданные url, если pushurl не заданы. Однако при получении данных, если задано несколько url, данные будут получены только с первого из них.

Именованный файл в $GIT_DIR/remotes

Можно указать имя файла в каталоге $GIT_DIR/remotes. URL из этого файла будет использоваться для доступа к репозиторию. Если в командной строке не указан refspec, по умолчанию будет использоваться refspec из этого файла. Файл должен иметь следующий формат:

        URL: one of the above URL formats
        Push: <refspec>
        Pull: <refspec>

Строки Push: используются командами git push, а строки Pull: — командами git pull и git fetch. Для дополнительных сопоставлений веток можно указать несколько строк Push: и Pull:.

Именованный файл в $GIT_DIR/branches

Можно указать имя файла в каталоге $GIT_DIR/branches. URL из этого файла будет использоваться для доступа к репозиторию. Файл должен иметь следующий формат:

        <URL>#<head>

Параметр <URL> обязателен; #<head> необязателен.

В зависимости от выполняемой операции git будет использовать один из следующих refspec, если вы не укажете его в командной строке. <branch> — это имя этого файла в каталоге $GIT_DIR/branches, а <head> по умолчанию равно master.

Для git fetch используется:

        refs/heads/<head>:refs/heads/<branch>

Для git push используется:

        HEAD:refs/heads/<head>

Вышестоящие ветки

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

  • Она используется по умолчанию командами git pull или git fetch, если не указаны аргументы.

  • Она используется по умолчанию командой git push, если не указаны аргументы, за некоторыми исключениями. Например, с помощью параметра branch.<name>.pushRemote можно отправлять изменения в другой удалённый репозиторий, отличный от того, из которого вы получаете изменения; кроме того, по умолчанию при использовании push.default=simple настроенная вышестоящая ветка должна иметь то же имя.

  • Различные команды, в том числе git checkout и git status, покажут, сколько коммитов было добавлено в текущую и вышестоящую ветки с момента их ответвления, например: «Ваша ветка и origin/main разошлись, в них соответственно 2 и 3 разных коммита».

Вышестоящая ветка хранится в .git/config, в полях «remote» и «merge». Например, если вышестоящая ветка main — это origin/main:

[branch "main"]
   remote = origin
   merge = refs/heads/main

Вышестоящую ветку можно задать явно с помощью git push --set-upstream <remote> <branch>, однако часто Git настраивает её автоматически, например:

  • При клонировании репозитория Git автоматически задаёт вышестоящую ветку для ветки по умолчанию.

  • Если задан параметр конфигурации push.autoSetupRemote, команда git push автоматически задаст вышестоящую ветку при первой отправке ветки.

  • При переключении на ветку удалённого отслеживания с помощью git checkout <branch> автоматически создаётся локальная ветка с таким же именем, и в качестве вышестоящей задаётся удалённая ветка.

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

Стратегии слияния

Механизм слияния (команды git merge и git pull) позволяет выбрать backend merge strategies с помощью параметра -s. Некоторые стратегии также могут принимать собственные параметры, которые можно передать в виде аргументов -X<option> командам git merge и/или git pull.

ort

Это стратегия слияния по умолчанию при получении изменений или слиянии одной ветки. Эта стратегия может разрешать конфликты только между двумя вершинами веток с помощью алгоритма трёхстороннего слияния. Если у веток есть несколько общих предков, подходящих для трёхстороннего слияния, стратегия создаёт объединённое дерево общих предков и использует его в качестве опорного дерева для трёхстороннего слияния. По результатам тестов на реальных коммитах слияния из истории разработки ядра Linux 2.6, это позволяет уменьшить число конфликтов слияния и при этом не приводит к ошибочным слияниям. Кроме того, эта стратегия может обнаруживать и обрабатывать слияния, в которых были переименования. Обнаруженные копирования не учитываются. Название этого алгоритма — акроним («Ostensibly Recursive’s Twin»), возникший потому, что он был написан как замена предыдущему алгоритму по умолчанию recursive.

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

Стратегия ort принимает следующие параметры:

ours

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

Не путайте это с стратегией слияния ours, которая вообще не рассматривает содержимое другого дерева. Она отбрасывает все изменения другого дерева, объявляя, что история our содержит всё, что в нём произошло.

theirs

Это противоположность параметра ours; обратите внимание, что, в отличие от ours, стратегии слияния theirs, с которой можно было бы спутать этот параметр слияния, не существует.

ignore-space-change
ignore-all-space
ignore-space-at-eol
ignore-cr-at-eol

Для целей трёхстороннего слияния строки с указанным типом изменений пробельных символов считаются неизменёнными. Изменения пробелов, смешанные с другими изменениями в строке, не игнорируются. См. также -b, -w, --ignore-space-at-eol и --ignore-cr-at-eol в git-diff[1].

  • Если версия their вносит в строку только изменения пробельных символов, используется версия our;

  • Если версия our вносит изменения пробельных символов, но версия their содержит существенное изменение, используется версия their;

  • В противном случае слияние выполняется обычным образом.

renormalize

Выполняет виртуальную проверку извлечения и добавления для всех трёх состояний каждого файла, которому требуется трёхстороннее слияние. Этот параметр предназначен для слияния веток с разными фильтрами очистки или правилами нормализации окончаний строк. Подробности см. в разделе «Слияние веток с различающимися атрибутами checkin/checkout» в gitattributes[5].

no-renormalize

Отключает параметр renormalize. Этот параметр имеет приоритет над переменной конфигурации merge.renormalize.

find-renames[=<n>]

Включает обнаружение переименований, при необходимости задавая порог сходства. Это значение используется по умолчанию. Этот параметр имеет приоритет над переменной конфигурации merge.renames. См. также --find-renames в git-diff[1].

rename-threshold=<n>

Устаревший синоним для find-renames=<n>.

no-renames

Отключает обнаружение переименований. Этот параметр имеет приоритет над переменной конфигурации merge.renames. См. также --no-renames в git-diff[1].

histogram

Устаревший синоним для diff-algorithm=histogram.

patience

Устаревший синоним для diff-algorithm=patience.

diff-algorithm=(histogram|minimal|myers|patience)

Использует при слиянии другой алгоритм сравнения различий, что может помочь избежать ошибочных слияний, возникающих из-за совпадения несущественных строк (например, фигурных скобок в разных функциях). См. также --diff-algorithm в git-diff[1]. Обратите внимание, что для ort по умолчанию используется diff-algorithm=histogram, а для обычного сравнения различий в настоящее время используется настройка конфигурации diff.algorithm.

subtree[=<path>]

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

recursive

Теперь это синоним для ort. До версии v2.49.0 это была альтернативная реализация, но в версии v2.50.0 её перенаправили на ort. Предыдущая стратегия recursive была стратегией по умолчанию для разрешения слияний двух вершин веток начиная с Git v0.99.9k и до v2.33.0.

resolve

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

octopus

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

ours

Разрешает любое число вершин веток, но результирующее дерево слияния всегда соответствует вершине текущей ветки, то есть изменения всех остальных веток игнорируются. Эта стратегия предназначена для замены старой истории разработки боковых веток. Обратите внимание, что она отличается от параметра -Xours стратегии слияния ort.

subtree

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

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

Поведение по умолчанию

Часто команду git pull используют без параметров. Традиционно это было эквивалентно команде git pull origin. Однако если для текущей ветки <name> задан параметр конфигурации branch.<name>.remote, вместо origin используется его значение.

Чтобы определить, какой URL использовать для получения данных, проверяется значение параметра конфигурации remote.<origin>.url; если такой переменной нет, используется значение строки URL: в файле $GIT_DIR/remotes/<origin>.

Чтобы определить, какие удалённые ветки получать (и при необходимости сохранять в ветках удалённого отслеживания), если команда запущена без параметров refspec в командной строке, проверяются значения переменной конфигурации remote.<origin>.fetch; если их нет, проверяется $GIT_DIR/remotes/<origin> и используются его строки Pull:. Помимо форматов refspec, описанных в разделе ПАРАМЕТРЫ, можно использовать refspec с шаблоном glob следующего вида:

refs/heads/*:refs/remotes/origin/*

У refspec с шаблоном glob правая часть должна быть непустой (то есть полученные данные должны сохраняться в ветках удалённого отслеживания), а левая и правая части должны заканчиваться на /*. Приведённая выше запись указывает отслеживать все удалённые ветки с помощью веток удалённого отслеживания в иерархии refs/remotes/origin/ под теми же именами.

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

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

Если в командной строке refspec не указан, команда git pull использует refspec из конфигурации или $GIT_DIR/remotes/<origin>. В таких случаях применяются следующие правила:

  1. Если для текущей ветки задана конфигурация branch.<name>.merge <name>, то она указывает имя ветки на удалённом узле, которая будет объединена.

  2. Если refspec содержит шаблон glob, ничего не объединяется.

  3. В противном случае объединяется удалённая ветка, указанная в первом refspec.

Примеры

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

    $ git pull
    $ git pull origin

    Обычно объединяется ветка HEAD удалённого репозитория, однако выбор определяется параметрами branch.<name>.remote и branch.<name>.merge; подробности см. в git-config[1].

  • Объединить с текущей веткой удалённую ветку next:

    $ git pull origin next

    При этом временная копия next останется в FETCH_HEAD, а ветка удалённого отслеживания origin/next будет обновлена. Того же результата можно добиться, выполнив команды fetch и merge:

    $ git fetch origin
    $ git merge origin/next

Если попытка выполнить pull привела к сложным конфликтам и вы хотите начать заново, можно восстановить исходное состояние с помощью git reset.

Безопасность

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

Известны следующие векторы атак:

  1. Жертва отправляет строки «have», объявляя идентификаторы имеющихся у неё объектов, которыми явно не предполагалось делиться, но которые можно использовать для оптимизации передачи, если они есть и у другой стороны. Злоумышленник выбирает идентификатор объекта X, который хочет украсть, и отправляет ссылку на X, но ему не нужно отправлять содержимое X, поскольку оно уже есть у жертвы. Теперь жертва считает, что у злоумышленника есть X, и позднее отправляет ему содержимое X. (Клиенту проще всего провести эту атаку на сервере: создать ссылку на X в пространстве имён, к которому у клиента есть доступ, а затем получить его. Серверу проще всего провести такую атаку на клиенте, «объединив» X с общедоступной веткой и надеясь, что пользователь выполнит в этой ветке дополнительную работу и отправит её обратно на сервер, не заметив объединения.)

  2. Как и в случае № 1, злоумышленник выбирает идентификатор объекта X, который хочет украсть. Жертва отправляет объект Y, который уже есть у злоумышленника, а злоумышленник ложно утверждает, что у него есть X, но нет Y, поэтому жертва отправляет Y в виде дельты относительно X. Эта дельта раскрывает злоумышленнику области X, похожие на Y.

Ошибки

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

См. также

git-fetch[1], git-merge[1], git-config[1]

pull

© 2005–2026 Linus Torvalds and others
Licensed under the GNU General Public License version 2.
https://git-scm.com/docs/git-pull

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API