Слияние изменений вызывает дополнительную проверку

Question

Когда я совершаю и нажимаю свои изменения, он вызывает другую проверку, которая сливается раньше коммитов от кого-то другого. Например, я меняю один файл, Readme.txt и фиксирую его, затем делаю git pull. Некоторые изменения добавлены в мой репозиторий. Затем я выдвигаю свои изменения. Существует дополнительная проверка, которая гласит:

Merge branch 'mainline' of https://example.com into mainline 

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

Answer 1

То, что вы описываете, называется слиянием-фиксацией.

This очень хорошая страница читать:

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

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

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

Here - статья об избежании слияния-коммитов.

Answer 2

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

Answer 3

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

git pull --rebase 

Что это будет сделать, это:

• Fetch обновления с удаленным
• перемотать фиксации
• применить входящие коммиты в дерево
• И, наконец, воспроизводить ваш местный (не-кнопку) совершает после входящих тех

Конечного результат, как если бы вы сделали git pull, волшебно сделали все изменения мгновенно, а затем их совершили.

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

Допустим, вы начинаете с совершить A и сделать свой местный совершать B:

A --- B 

Между тем, другой разработчик, начиная с A добавляет C, D и E:

A --- C --- D --- E 

Когда вы тянете , происходит то, что две расходящиеся ветви сливаются. Вы в конечном итоге с конечным состоянием, F:

A --- C --- D --- E --- F 
\--- B ---------------/ 

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

A --- C --- D --- E ---- B 

(Опять же, не предполагая слияния конфликта происходит.)

Answer 4

Быстро вперед слияние может избежать таких слияний совершить. Если последнее общее коммит Branch A и Branch B является последним фиксатором Branch A, но не последним фиксатором Branch B, объединение B в A является быстрым слиянием вперед. То есть последовательность коммитов А составляет истинное подмножество последовательности бит B. Давайте посмотрим на эти случаи. Каждое число является фиксацией.

1. A: 1-2-3-4, B: 1-2-3-4. Множество (А) = множество (В). Слияние от A до B или B с A приводит к нулю.
2. A: 1-2-3-4, B: 1-2-3-4-5. set (A) является истинным подмножеством множества (B). Слияние А-В, ничего не происходит. Слияние B в A, ускоренное переключение вперед по умолчанию.
3. A: 1-2-3-4, B: 1-2-3-5. последний бит фиксации (A) последнего не установлен (B), а последний (5) последнего фиксации 5 не установлен (A). Слияние от A до B или от B до A приводит к несложному переходу вперед, как в вашем случае.

git merge --no-ff всегда делает несложное слияние вперед, если слияние может быть выполнено. git merge --ff-only всегда терпит неудачу, если не будет быстрого слияния вперед.

Вы можете использовать git rebase, git reset --hard и git cherry-pick, чтобы сделать ваши 2 филиала в то, что это, как и в случае 2.