Summary  
This chapter explains how to manage branches in Git—covering listing, creating, renaming, deleting, and switching branches—and how HEAD tracks the current branch.  

General domain of usage  
Version control for software development

## git branch
Al trabajar con ramas en Git, se utiliza principalmente el comando `git branch`. De hecho, este comando puede emplearse para varios propósitos:
* **Listar ramas**;
* **Crear ramas**;
* **Eliminar ramas**;
* **Manipular ramas** (por ejemplo, renombrar ramas).


## Listado y creación de ramas

Primero, listar todas las ramas en el repositorio:
```
git branch
```

Como puedes ver, la única rama existente es `master`, la rama **predeterminada**.
Su nombre puede variar en tu configuración, así que no te preocupes si aparece con otro nombre.


Actualmente, las nuevas versiones de Git suelen usar `main` como nombre para la rama predeterminada en lugar de `master`.


Nota

Un **asterisco** (`*`) junto al nombre de la rama indica que **HEAD** apunta a esa rama, lo que significa que te encuentras en ella actualmente.

Para crear una nueva rama, utiliza el comando `git branch` seguido del nombre deseado para la rama:

```bash
git branch <branch_name>
```

Aquí, `<branch_name>` es el nombre de la rama que deseas crear.


## Convenciones de nomenclatura de ramas
Es común seguir **convenciones de nomenclatura** para las ramas, como utilizar prefijos como `feature/`, `bugfix/` o `hotfix/` para indicar el propósito de la rama. **Convenciones de nomenclatura consistentes** facilitan la comprensión del rol de cada rama en el proceso de desarrollo.


## Ejemplo de flujo de trabajo

Crear una nueva rama llamada `testing/some-tests` y luego listar todas las ramas:
```
git branch testing/some-tests
```

## Cambio entre ramas

Actualmente, hay dos ramas.
Dado que el asterisco (`*`) está junto a la rama `master`, **HEAD** todavía apunta a ella.
Sin embargo, **HEAD** es un **puntero movible**, por lo que se puede cambiar a otra rama usando el comando `git checkout`:

```bash
git checkout <branch_name>
```

Aquí, `<branch_name>` es el nombre de la rama a la que se desea cambiar.
Este comando **actualiza** el árbol de trabajo para que coincida con la rama seleccionada, incluyendo tanto los **archivos** como el **historial de Git**.

Ahora cambia a la rama recién creada y lista todas las ramas:
```
git checkout testing/some-tests
```

Como puedes ver, el asterisco (`*`) ahora está junto a la nueva rama, lo que significa que actualmente te encuentras en ella (**HEAD** apunta a esta rama).
Para verificar esto, crea un archivo de texto simple y haz un commit:
```
echo "New branch" > branch_learning.txt
```

```
git commit -m "Add a test text file"
```

El commit se realizó correctamente, así que ahora revisa los dos commits más recientes en el historial de commits:
```
git log -n 2
```

Dado que actualmente estás en la rama `testing/some-tests`, esta apunta al commit más reciente (al igual que **HEAD**), mientras que la rama `master` permanece un commit detrás.

Selecciona todos los posibles casos de uso del comando `git branch`.

Git es el sistema de control de versiones más popular, utilizado por millones de desarrolladores en todo el mundo. Tanto si eres un desarrollador experimentado como si eres principiante, este curso te proporcionará los conocimientos y habilidades necesarios para gestionar eficientemente tus proyectos de software, colaborar con otros y dominar el arte del control de versiones.

Primero, se proporcionará una visión general de los sistemas de control de versiones en general. Posteriormente, se abordará Git y se aprenderán los conceptos básicos de la creación de un repositorio y la realización de cambios en él.

Ahora es momento de abordar una interacción más avanzada con Git, lo que aumentará su eficiencia y le permitirá familiarizarse con algunos de los flujos de trabajo comunes en Git.

Como sistema de control de versiones, Git permite deshacer cambios cuando sea necesario, por lo que es momento de descubrir las técnicas en Git para revertir cambios no preparados en el árbol de trabajo, cambios preparados e incluso revertir o sobrescribir commits.

Las ramas en Git son sumamente útiles al colaborar con otras personas, corregir errores o desarrollar ciertas funcionalidades en tu proyecto. Sin más preámbulos, exploremos todos los matices del trabajo con ramas.

Creación de Ramas

git branch

Listado y creación de ramas

Convenciones de nomenclatura de ramas

Ejemplo de flujo de trabajo

Cambio entre ramas