Git avanço rápido VS sem mesclagem de avanço rápido

A mesclagem Git nos permite executar a junção de avanço rápido e sem avanço rápido. Alguma idéia de quando usar a mesclagem de avanço rápido e quando usar a mesclagem de avanço rápido?

A --no-ffopção é útil quando você deseja ter uma noção clara de sua ramificação de recursos. Portanto, mesmo enquanto nenhum commit foi feito, o FF é possível - você ainda quer que às vezes cada commit na linha principal corresponda a um recurso. Portanto, você trata uma ramificação de recursos com um monte de confirmações como uma única unidade e as mescla como uma única unidade. É evidente em seu histórico quando você apresenta uma fusão com ramificação --no-ff.

Se você não se importa com isso - provavelmente poderá se safar da FF sempre que possível. Assim, você terá uma sensação mais semelhante ao svn do fluxo de trabalho.

Por exemplo, o autor deste artigo pensa que essa --no-ffopção deve ser o padrão e seu raciocínio está próximo ao descrito acima:

Considere a situação em que uma série de commits secundários no ramo "feature" compõe coletivamente um novo recurso: se você apenas "git merge feature_branch" sem --no-ff", é impossível ver no histórico do Git quais objetos de commit juntos têm implementou um recurso - você precisaria ler manualmente todas as mensagens de log. A reversão de um recurso inteiro (ou seja, um grupo de confirmações) é uma verdadeira dor de cabeça [se --no-ffnão for usada], enquanto é fácil se a --no-ffflag foi usada [porque é apenas um commit]. "

Eu posso dar um exemplo comumente visto no projeto.

Aqui, a opção --no-ff(ou seja, mesclagem verdadeira ) cria uma nova confirmação com vários pais e fornece um melhor rastreamento do histórico. Caso contrário, --ff( por exemplo, mesclagem de avanço rápido ) é por padrão.

$ git checkout master
$ git checkout -b newFeature
$ ...
$ git commit -m 'work from day 1'
$ ...
$ git commit -m 'work from day 2'
$ ...
$ git commit -m 'finish the feature'
$ git checkout master
$ git merge --no-ff newFeature -m 'add new feature'
$ git log
// something like below
commit 'add new feature'         // => commit created at merge with proper message
commit 'finish the feature'
commit 'work from day 2'
commit 'work from day 1'
$ gitk                           // => see details with graph

$ git checkout -b anotherFeature        // => create a new branch (*)
$ ...
$ git commit -m 'work from day 3'
$ ...
$ git commit -m 'work from day 4'
$ ...
$ git commit -m 'finish another feature'
$ git checkout master
$ git merge anotherFeature       // --ff is by default, message will be ignored
$ git log
// something like below
commit 'work from day 4'
commit 'work from day 3'
commit 'add new feature'
commit 'finish the feature'
commit ...
$ gitk                           // => see details with graph

(*) Observe que aqui, se o newFeatureramo for reutilizado, em vez de criar um novo ramo, o git terá que fazer uma --no-ffmesclagem de qualquer maneira. Isso significa que a mesclagem de avanço rápido nem sempre é elegível.

Quando trabalhamos no ambiente de desenvolvimento e mesclamos nosso código ao ramo de preparação / produção, o Git no fast forward pode ser uma opção melhor. Geralmente, quando trabalhamos no ramo de desenvolvimento de um único recurso, tendemos a ter vários commits. O rastreamento de alterações com várias confirmações pode ser inconveniente posteriormente. Se mesclarmos com o ramo de teste / produção usando o Git no fast forward, ele terá apenas 1 commit. Agora, sempre que quisermos reverter o recurso, basta reverter esse commit. Vida é fácil.

Também é possível que você queira ter ramificações de recursos personalizadas, nas quais o código é colocado apenas no final do dia. Isso permite acompanhar o desenvolvimento com mais detalhes.

Eu não gostaria de poluir o desenvolvimento principal com código que não funciona, fazendo assim --no-ff pode ser apenas o que se está procurando.

Como observação lateral, pode não ser necessário confirmar o código de trabalho em uma ramificação personalizada, pois o histórico pode ser reescrito git rebase -ie forçado no servidor desde que ninguém mais esteja trabalhando nessa mesma ramificação.