Gestión de ramas de Git

La gestión de ramas de Git es una de las funciones potentes de Git, que permite que varios desarrolladores trabajen en paralelo, desarrollen nuevas funciones, corrijan errores o realicen experimentos sin afectar el repositorio de código principal.

Casi todos los sistemas de control de versiones admiten ramas de alguna forma; una rama representa una línea de desarrollo independiente.

Usar ramas significa que puedes separarte de la línea principal de desarrollo y seguir trabajando sin afectar la línea principal.

Las ramas de Git son en realidad punteros a instantáneas de cambios.

Algunos llaman al modelo de ramas de Gitla característica asesina, y es precisamente por esto queGitse distingue de la familia de los sistemas de control de versiones.

Crear una rama

Crear una nueva rama y cambiar a ella:

git checkout -b <branchname>

Por ejemplo:

git checkout -b feature-xyz

Comando para cambiar de rama:

git checkout (branchname)

Por ejemplo:

git checkout main

Cuando cambias de rama, Git reemplaza el contenido de tu directorio de trabajo con la instantánea de la última confirmación de esa rama, por lo que varias ramas no necesitan varios directorios.

Ver ramas

Ver todas las ramas:

git branch

Ver ramas remotas:

git branch -r

Ver todas las ramas locales y remotas:

git branch -a

Fusionar ramas

Fusionar otra rama en la rama actual:

git merge <branchname>

Por ejemplo, cambia a la rama main y fusiona la rama feature-xyz:

git checkout main
git merge feature-xyz

Resolver conflictos de fusión

Cuando surge un conflicto durante la fusión, Git marca los archivos en conflicto y debes resolver el conflicto manualmente.

Abre el archivo en conflicto y resuelve el conflicto siguiendo las marcas.

Marca el conflicto como resuelto:

git add <conflict-file>

Confirma el resultado de la fusión:

git commit

Eliminar ramas

Eliminar una rama local:

git branch -d <branchname>

Forzar la eliminación de una rama no fusionada:

git branch -D <branchname>

Eliminar una rama remota:

git push origin --delete <branchname>

Ejemplo

Antes de comenzar, creamos un directorio de prueba:

$ mkdir gitdemo
$ cd gitdemo/
$ git init
Initialized empty Git repository...
$ touch README
$ git add README
$ git commit -m '第一次版本提交'
[master (root-commit) 3b58100] 第一次版本提交
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 README

Gestión de ramas de Git

Listar ramas

Comando básico para listar ramas:

git branch

Cuando no se pasan argumentos,git branchse listan tus ramas locales.

$ git branch
* master

Esto significa que tenemos una rama llamadamaster, y esa rama es la rama actual.

Cuando ejecutasgit init, por defecto Git crea para ti la ramamaster.

Si queremos crear una rama manualmente, con ejecutargit branch (branchname)es suficiente.

$ git branch testing
$ git branch
* master
  testing

Ahora podemos ver que hay una nueva ramatesting。

Cuando creas una nueva rama de esta manera después de la última actualización de confirmación, si luego hay más confirmaciones de actualización y luego cambias a la ramatesting, Git restaurará tu directorio de trabajo al estado en que estaba cuando creaste la rama.

A continuación demostraremos cómo cambiar de rama. Usamos git checkout (branch) para cambiar a la rama que queremos modificar.

$ ls
README
$ echo 'example.com' > test.txt
$ git add .
$ git commit -m 'add test.txt'
[master 3e92c19] add test.txt
 1 file changed, 1 insertion(+)
 create mode 100644 test.txt
$ ls
README        test.txt
$ git checkout testing
Switched to branch 'testing'
$ ls
README

Cuando cambiamos a la ramatesting, el nuevo archivo test.txt que agregamos fue eliminado. Al volver a la ramamaster, esos archivos reaparecieron.

$ git checkout master
Switched to branch 'master'
$ ls
README        test.txt

También podemos usar el comando git checkout -b (branchname) para crear una nueva rama y cambiar inmediatamente a ella, para así trabajar en esa rama.

$ git checkout -b newtest
Switched to a new branch 'newtest'
$ git rm test.txt 
rm 'test.txt'
$ ls
README
$ touch ejemplo.php
$ git add .
$ git commit -am 'removed test.txt、add ejemplo.php'
[newtest c1501a2] removed test.txt、add ejemplo.php
 2 files changed, 1 deletion(-)
 create mode 100644 ejemplo.php
 delete mode 100644 test.txt
$ ls
README        ejemplo.php
$ git checkout master
Switched to branch 'master'
$ ls
README        test.txt

Como puedes ver, creamos una rama, eliminamos algunos archivos test.txt en ella y agregamos el archivo ejemplo.php; luego volvimos a nuestra rama principal, el archivo test.txt eliminado reapareció y el nuevo ejemplo.php no existe en la rama principal.

Usar ramas divide el trabajo, lo que nos permite trabajar en diferentes entornos de desarrollo y alternar entre ellos.

Eliminar ramas

Comando para eliminar ramas:

git branch -d (branchname)

Por ejemplo, queremos eliminar la rama testing:

$ git branch
* master
  testing
$ git branch -d testing
Deleted branch testing (was 85fc7e7).
$ git branch
* master

Fusión de ramas

Una vez que una rama tiene contenido independiente, con el tiempo querrás fusionarla de nuevo en tu rama principal. Puedes usar el siguiente comando para fusionar cualquier rama en la rama actual:

git merge

$ git branch
* master
  newtest
$ ls
README        test.txt
$ git merge newtest
Updating 3e92c19..c1501a2
Fast-forward
 ejemplo.php | 0
 test.txt   | 1 -
 2 files changed, 1 deletion(-)
 create mode 100644 ejemplo.php
 delete mode 100644 test.txt
$ ls
README        ejemplo.php

En el ejemplo anterior fusionamos la rama newtest en la rama principal y el archivo test.txt fue eliminado.

Después de fusionar, puedes eliminar la rama:

$ git branch -d newtest
Deleted branch newtest (was c1501a2).

Después de eliminar, solo queda la rama master:

$ git branch
* master

Conflictos de fusión

Fusionar no es solo una simple operación de agregar o eliminar archivos; Git también fusiona modificaciones.

$ git branch
* master
$ cat ejemplo.php

Nota:Si no existe ejemplo.php, primero debes crear este archivo; el comando puede sertouch ejemplo.php。

Primero, creamos una rama llamada change_site, cambiamos a ella y modificamos el contenido de ejemplo.php a:

<?php
echo 'ejemplo';
?>

Crear la rama change_site:

$ git checkout -b change_site
Switched to a new branch 'change_site'
$ vim ejemplo.php
$ head -3 ejemplo.php
<?php
echo 'ejemplo';
?>
$ git commit -am 'changed the ejemplo.php'
[change_site 7774248] changed the ejemplo.php
 1 file changed, 3 insertions(+)

Puedes consultar las operaciones del comando vim en:Linux vi/vim。

Confirma los cambios en la rama change_site. Ahora, si cambiamos de nuevo a la rama master, podemos ver que el contenido se restauró al estado anterior a nuestra modificación (archivo vacío, sin código); modificamos nuevamente el archivo ejemplo.php.

$ git checkout master
Switched to branch 'master'
$ cat ejemplo.php
$ vim ejemplo.php    # 修改内容如下
$ cat ejemplo.php
<?php
echo 1;
?>
$ git diff
diff --git a/ejemplo.php b/ejemplo.php
index e69de29..ac60739 100644
--- a/ejemplo.php
+++ b/ejemplo.php
@@ -0,0 +1,3 @@
+<?php
+echo 1;
+?>
$ git commit -am '修改代码'
[master c68142b] 修改代码
 1 file changed, 3 insertions(+)

Ahora estos cambios están registrados en mi rama "master". A continuación fusionamos la rama "change_site".

$ git merge change_site
Auto-merging ejemplo.php
CONFLICT (content): Merge conflict in ejemplo.php
Automatic merge failed; fix conflicts and then commit the result.

$ cat ejemplo.php     # 打开文件，看到冲突内容
<?php
<<<<<<< HEAD
echo 1;
=======
echo 'ejemplo';
>>>>>>> change_site
?>

Fusionamos la rama anterior en la rama master; aparece un conflicto de fusión y a continuación debemos resolverlo manualmente.

$ vim ejemplo.php 
$ cat ejemplo.php
<?php
echo 1;
echo 'ejemplo';
?>
$ git diff
diff --cc ejemplo.php
index ac60739,b63d7d7..0000000
--- a/ejemplo.php
+++ b/ejemplo.php
@@@ -1,3 -1,3 +1,4 @@@
  <?php
 +echo 1;
+ echo 'ejemplo';
  ?>

En Git, podemos usar git add para indicar a Git que el conflicto del archivo se ha resuelto.

$ git status -s
UU ejemplo.php
$ git add ejemplo.php
$ git status -s
M  ejemplo.php
$ git commit
[master 88afe0e] Merge branch 'change_site'

Ahora hemos resuelto con éxito el conflicto de fusión y hemos confirmado el resultado.

Manual de comandos

Comando	Descripción	Ejemplo de uso
`git branch`	Lista, crea o elimina ramas. No cambia de rama; solo se usa para gestionar la existencia de ramas.	`git branch`: lista todas las ramas `git branch new-branch`: crea una nueva rama `git branch -d old-branch`: elimina una rama
`git checkout`	Cambia a la rama especificada o restaura archivos en el directorio de trabajo. También se puede usar para extraer (checkout) una confirmación específica.	`git checkout branch-name`: cambiar de rama `git checkout file.txt`: restaurar archivos al área de trabajo `git checkout <commit-hash>`: extraer una confirmación específica
`git switch`	Está diseñado específicamente para cambiar de rama; en comparación con`git checkout`es más simple e intuitivo, y se usa principalmente para operaciones con ramas.	`git switch branch-name`: cambia a la rama especificada `git switch -c new-branch`: crea una nueva rama y cambia a ella
`git merge`	Fusiona los cambios de la rama especificada en la rama actual.	`git merge branch-name`: fusiona los cambios de la rama especificada en la rama actual
`git mergetool`	Inicia la herramienta de fusión para resolver conflictos de fusión.	`git mergetool`: resuelve conflictos con la herramienta de fusión predeterminada `git mergetool --tool=<tool-name>`: especifica la herramienta de fusión
`git log`	Muestra el historial de confirmaciones.	`git log`: muestra el historial de confirmaciones `git log --oneline`: muestra el historial de confirmaciones en modo compacto
`git stash`	Guarda los cambios no confirmados en el directorio de trabajo actual y lo restaura a un área de trabajo limpia.	`git stash`: guarda los cambios actuales `git stash pop`: restaura los cambios guardados más recientemente `git stash list`: lista todos los cambios guardados
`git tag`	Crea, lista o elimina etiquetas. Las etiquetas se usan para marcar confirmaciones específicas.	`git tag`: lista todas las etiquetas `git tag v1.0`: crea una nueva etiqueta `git tag -d v1.0`: elimina una etiqueta
`git worktree`	Permite verificar múltiples áreas de trabajo en un repositorio; es adecuado para trabajar con varias ramas al mismo tiempo.	`git worktree add <path> branch-name`: agrega un nuevo área de trabajo en la ruta especificada y cambia a la rama especificada `git worktree remove <path>`: elimina el área de trabajo

Otras extensiones