Ramas y Fusión de Cambios: branch, merge, switch y checkout

También puedes hacer uso de `git switch -c <nombre>` para crear una rama y directamente moverte a ella en lugar de usar `git checkout -b <nombre>`. Aunque cualquiera de los dos es válido. 👍

- git branch: Saber en qué rama me encuentro. - git checkout -b “nombre rama”: Crea una nueva rama y se mueve a ella. - git branch: Lista, crea o elimina ramas - git checkout: Cambia entre ramas - git switch: Cambia entre ramas - git merge: Fusiona ramas (unifica todas las ramas en main) - git branch -D “nombre rama”: Eliminar rama. El una buena práctica después del merge. git branch git checkout -b "dev" nano testing_dev.txt git add . git commit -m "nuevo archivo creado" git checkout dev git switch main git merge dev git branch ls git log clear git branch -D dev

Las ramas y fusión de cambios : branch, merge, checkout se utiliza para no detener, del trabajo de otras implementaciones y puede ser como una o muchas ramas ### COMO SABER EN QUE RAMO ME ENCUENTRO * `git branch` > permite saber que ramas existen y en que rama estas actualmente la manera de identificar en la que estas es con el \* en el nombre de la rama ### COMO CREAR UNA NUEVA RAMA Y MOVERSE A ELLA * `git checkout -b <nombre>` > Sin el `-b`, el comando `git checkout` simplemente te cambia a una rama existente. Con `-b`, estás indicando explícitamente que quieres **crear una nueva rama**. * `git switch -c <nombre>` > El comando `git switch -c <nombre>` es una alternativa moderna a `git checkout -b <nombre>` y se utiliza para **crear una nueva rama** en el repositorio y cambiarte automáticamente a ella, todo en un solo paso. ### MOVERSE ENTRE RAMAS * `git checkout <Nombre de la rama>` >Funciona para moverte a la rama a la cual necesitas moverte * `git switch <Nombre de la rama>` > Funciona de la misma manera que `git checkout <Nombre de la rama>` ### MOVER TODOS LOS CAMBIOS A LA RAMA PRINCIPAL * `git merge <Nombre de la rama>` > Realiza la unificación entre ramas ### COMO BORRAR UNA RAMA QUE QUE CUMPLIO SU PROPOSITO `git branch -D <nombre de la rama>` > Con este comando se borra la rama que ya cumplio su propósito y se tiene en cuenta que esto es una buen practica cada rama nueva que se inicia debe tener su final


Ambos comandos, `git checkout` y `git switch`, se utilizan para cambiar de rama en Git, pero hay diferencias clave. `git checkout` es un comando versátil que puede ser usado tanto para cambiar ramas como para restaurar archivos. Sin embargo, puede ser confuso, ya que también se utiliza para otras tareas. Por otro lado, `git switch` fue introducido para simplificar el cambio de rama. Es más específico y menos propenso a errores, ya que solo se utiliza para cambiar entre ramas. Se recomienda usar `git switch` para cambiar de rama y `git checkout` para operaciones más amplias. Esto mejora la claridad y la seguridad en el uso de Git.



Bajo el concepto de "Un unico uso", se recomienda dejar de usar git checkout porque este comando, ademas de cambiar de rama, permite crear una nueva rama y cambiar a ella; mientras que usando git branch solo creas la rama, mas no cambias a ella. Por ello, recomiendo usar git branch y git switch en vez de seguir usando git checkout... porque imagina que cada vez que quieras cambiar de rama se te escape alguna letrita mas...

Trabajar con ramas y fusiones en Git es esencial para un flujo de trabajo eficiente, especialmente en proyectos colaborativos y de gran envergadura. ### Consejos Prácticos * Usa `git branch -a` para ver todas las ramas, incluidas las remotas. * Si quieres forzar un cambio de rama sin confirmar los cambios, usa `git switch -f`. * Para resolver conflictos durante una fusión, edita los archivos conflictivos, haz `git add` y luego `git commit`.

Otra forma de crear nuevas ramas (a partir de Git 2.23) es: `git switch -c <nombre-rama>` Este comando podría resultar más intuitivo, ya que el checkout que se usa en el checkout -b tiene múltiples usos y podría generar confusión. Igual, son dos formas de crear una nueva rama a partir de la rama en la que estás parado.

Lindo trabalenguas, "rama de amin no de main". Muy buen curso!!!

Hola Les comparto los comandos vistos en clase ```python git branch git checkout -b dev git branch nano testing_dev.txt ls git status git add . git commit -m "File created from dev branch" git checkout main git checkout dev git switch main git merge dev git branch ls git log clear git branch -D dev ```

hola! para intercambiar entre ramas rápidamente bastante con usar git checkout -

Sí, una rama fusionada puede seguir siendo utilizada, pero no es una práctica recomendada. Después de fusionar una rama en la rama principal, lo ideal es eliminarla para evitar confusiones y mantener el repositorio limpio. Sin embargo, si necesitas realizar cambios adicionales en la misma rama o mantenerla por un motivo específico, puedes seguir trabajando en ella. Recuerda que cada rama debe tener un propósito claro.

Cuando ejecutas `git status` y ves texto en rojo, generalmente indica que hay archivos que han sido modificados, pero no están listos para ser comprometidos (staged). Esto significa que estos archivos han cambiado desde el último commit y necesitan ser añadidos al staging area usando `git add`. Así podrás incluir esos cambios en tu próximo commit. También puede indicar que hay archivos no rastreados que Git no está siguiendo. Para ver más detalles, revisa los mensajes que aparecen junto a los nombres de los archivos.

```js ``` 

puedes usar `git checkout -B rama` para sobre escribir una rama y pisar los cambios, usenlo con precaucion!

me gustaba mas el otro curso de fredy te lo explicaba con dibujitos y se entendia mas lo de las ramas y la fusion :c

git checkout nombre\_rama simpre lo hacias asi, pero de ahora en mas a usar switch como corresponde

Esta genial eso del git switch

Las ramas son herramientas que utilizamos para mantener una jerarquía y un orden en nuestro espacio de trabajo. Haciendo un paralelismo con **líneas de producción en una fábrica.** * Las ramas serían como las diferentes líneas de montaje donde se trabaja en partes específicas de un producto, y la rama principal (main) sería el área de ensamblaje final, donde todas las partes terminadas se unen para crear el producto completo. * Cada línea de producción (rama) puede trabajar de manera independiente en una función o característica del producto sin interferir con las demás. * Cuando está lista y probada, se integra en el ensamblaje final. Esto nos permite mantener un flujo de trabajo organizado y controlado, asegurando que cada cambio sea revisado y aprobado antes de formar parte del resultado final.

Las ramas te permiten explorar cambios en el desarrollo **sin comprometer la línea de tiempo principal del proyecto**. Esto permite probar hipótesis o hacer experimentos en el desarrollo sin alterar la estabilidad del código productivo, como si cada rama fuera un "universo paralelo" en el que los cambios existen hasta que decides fusionarlos con la realidad principal (la rama `main` o `develop`).

Git nos permite realizar modificaciones al proyecto en el que se esté trabajando sin poder afectar la rama principal (main) El trabajar utilizando ramas facilita que varias personas colaboren con un proyecto sin afectar la rama principal. La rama creada puede ir avanzando mediante `git commit` y en cuanto este listo para integrarse a la rama principal utilizamos `git merge`.  Las ramas (branches) pueden ser ilimitadas y nombrarlas a nuestra conveniencia. Como buenas prácticas es importante tener un orden y una planeación con las ramas que creemos ya que cuando queramos fusionar nuestro trabajo con la rama principal se pueden tener problemas.

Les comparto mis notas para la clase y el repo donde las llevo:## Ramas Para ver las ramas y en que rama te encuentras```sh> git branch``` Para crear una nueva rama y cambiarte hacia dicha rama```sh> git branch``` Para crear una archivo y poderlo editar desde Nano```sh> nano testingdave.txt``` \### Archivo con Nano Para guardar un archivo con arbol```sh> ctr + o> enter``` Para cerrar el archivo```sh> ctr + x``` \## Ramas Un nuevo metodo para cambiar de rama es:```sh> git switch \*\*\*``` Ejemplo:```sh> git switch main``` Para hacer merge de las ramas o fucionarlas:```sh> git marge daves``` para ver el historial de los archivos creados, modificados, etc.```sh> git log``` para cerrar un git log, usar:```sh> q``` ya que se unifico la rama individual con la secundaria, ya no se necesita tener la rama secundaria por lo que se requiere eliminar. asi evitamos tener ramas duplicados o evitar problemas Para eliminar:```sh> git branch -D dave``` Repo: <https://github.com/dr1602/git> Notas ````txt ## Ramas Para ver las ramas y en que rama te encuentras ```sh > git branch ``` Para crear una nueva rama y cambiarte hacia dicha rama ```sh > git branch ``` Para crear una archivo y poderlo editar desde Nano ```sh > nano testingdave.txt ``` ### Archivo con Nano Para guardar un archivo con arbol ```sh > ctr + o > enter ``` Para cerrar el archivo ```sh > ctr + x ``` ## Ramas Un nuevo metodo para cambiar de rama es: ```sh > git switch *** ``` Ejemplo: ```sh > git switch main ``` Para hacer merge de las ramas o fucionarlas: ```sh > git marge daves ``` para ver el historial de los archivos creados, modificados, etc. ```sh > git log ``` para cerrar un git log, usar: ```sh > q ``` ya que se unifico la rama individual con la secundaria, ya no se necesita tener la rama secundaria por lo que se requiere eliminar. asi evitamos tener ramas duplicados o evitar problemas Para eliminar: ```sh > git branch -D dave ``` ````

### 🔥 **Conflictos en Git: Qué pasa cuando dos personas editan el mismo archivo en diferentes ramas** Si dos personas trabajan en el mismo archivo, en diferentes ramas, y hacen cambios que entran en conflicto entre sí, **Git no puede fusionarlos automáticamente**. En este caso, ocurre un **conflicto de fusión (merge conflict)**, y Git te pedirá que resuelvas manualmente qué cambios quieres conservar. ### 🛑 **Ejemplo de un conflicto en Git** 1️⃣ **Tú y otro compañero trabajan en** `index.html` * Tú creas la rama `rama-A` y modificas el título:\

Bienvenidos a mi página\

* Tu compañero crea `rama-B` y cambia el mismo `h1`:\

Hola Mundo\

2️⃣ **Ambos hacen** `commit` **en sus respectivas ramas** * `git commit -m "Cambio en el título en rama-A"` * `git commit -m "Cambio en el título en rama-B"` 3️⃣ **Al fusionar (**`merge`**) las ramas, Git detecta un conflicto** * Si primero fusionas `rama-B` en `main`, no hay problema. * Pero cuando intentas fusionar `rama-A` en `main`, **Git no sabe qué versión del título usar** y muestra un mensaje como este: Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result. ### 🔧 **Cómo resolver un conflicto en Git** 1️⃣ Git marca el archivo con secciones especiales como esta: <<<<<<< HEAD \

Bienvenidos a mi página\

\======= \

Hola Mundo\

\>>>>>>> rama-B 2️⃣ Debes **editar manualmente** el archivo y elegir qué versión conservar, o combinar ambas: \

Bienvenidos a mi página - Hola Mundo\

3️⃣ Una vez resuelto, guardas los cambios y ejecutas: git add index.html git commit -m "Resolviendo conflicto en el título" 4️⃣ Finalmente, haces `push` para actualizar el repositorio con la versión corregida. ### 💡 **Consejos para evitar conflictos en Git** ✅ **Comunicación en equipo** → Asigna secciones específicas del código a cada persona. ✅ **Hacer** `pull` **antes de trabajar** → Siempre ejecuta `git pull origin main` antes de hacer cambios. ✅ **Dividir el trabajo en archivos separados** → Si cada persona edita archivos distintos, hay menos conflictos. ✅ **Usar** `git rebase` **en lugar de** `merge` **en algunos casos** → Esto mantiene un historial más limpio. 🚀 *Cortesía Gpt*

## **Ramas y Fusión de Cambios en Git** Las **ramas** en Git permiten trabajar en diferentes versiones de un proyecto sin afectar la rama principal. Esto es útil para desarrollar nuevas funcionalidades o corregir errores sin modificar el código estable. Los comandos más importantes para manejar ramas son: * `git branch` → Crear y listar ramas. * `git switch` y `git checkout` → Cambiar entre ramas. * `git merge` → Fusionar cambios entre ramas. ## **1. Listar y Crear Ramas:** `git branch` ### **Ver ramas existentes:** git branch 🔹 **Ejemplo de salida:** \* main nueva\_funcionalidad El asterisco (\*) indica la rama en la que estás trabajando. ### **Crear una nueva rama:** git branch nombre\_rama 🔹 **Ejemplo:** git branch nueva\_funcionalidad Esto crea la rama `nueva_funcionalidad`, pero **no cambia a ella**. ## **2. Cambiar de Rama:** `git switch` **y** `git checkout` Para cambiar de rama, puedes usar: ### **Usando** `git switch` **(Recomendado desde Git 2.23)** git switch nombre\_rama 🔹 **Ejemplo:** git switch nueva\_funcionalidad ### **Usando** `git checkout` **(Método antiguo, aún válido)** git checkout nombre\_rama ### **Crear y cambiar a una nueva rama en un solo paso:** git switch -c nueva\_rama O con `checkout` (versión antigua): git checkout -b nueva\_rama ## **3. Fusionar Cambios entre Ramas:** `git merge` Cuando terminas de trabajar en una rama, puedes fusionar sus cambios en la rama principal. ### **Pasos para fusionar ramas:** 1️⃣ Cambiar a la rama donde se quiere fusionar (por ejemplo, `main`): git switch main 2️⃣ Ejecutar el merge: git merge nueva\_funcionalidad 🔹 **Ejemplo:** Si trabajaste en `nueva_funcionalidad` y quieres fusionarla en `main`: git switch main git merge nueva\_funcionalidad ### **Posibles resultados al hacer** `merge`**:** ✅ **Fusión rápida (**`Fast-forward`**)** Si no hubo otros cambios en `main`, Git moverá directamente la referencia: main --> nueva\_funcionalidad ✅ **Fusión con commit de merge** Si hay cambios en ambas ramas, Git creará un **nuevo commit de merge**. ⚠️ **Si hay conflictos, Git pedirá resolverlos manualmente.** Para ver los archivos en conflicto: git status Después de resolverlos, hacer: git add archivo\_con\_conflicto git commit -m "Resuelto conflicto en archivo.txt" ## **Resumen de Comandos** ComandoDescripción`git branch`Muestra todas las ramas`git branch nueva_rama`Crea una nueva rama`git switch nueva_rama`Cambia a otra rama (nuevo método)`git checkout nueva_rama`Cambia a otra rama (método antiguo)`git switch -c nueva_rama`Crea y cambia a una nueva rama`git checkout -b nueva_rama`Crea y cambia a una nueva rama (método antiguo)`git merge nombre_rama`Fusiona una rama en la actual`git status`Muestra el estado del repositorio ### 🚀 **Flujo de Trabajo con Ramas** 1️⃣ Crear una nueva rama: git branch feature\_x 2️⃣ Cambiar a la nueva rama: git switch feature\_x 3️⃣ Hacer cambios y confirmarlos: git add . git commit -m "Agregada nueva funcionalidad" 4️⃣ Volver a `main` y fusionar los cambios: git switch main git merge feature\_x Con este flujo, puedes trabajar en diferentes funcionalidades sin afectar la rama principal.

Existe un comando bien especial, y que mucha gente no conoce 😏. Se trata del comando **cherry-pick** (`https://git-scm.com/docs/git-cherry-pick`)  Cherry pick nos permite aplicar un commit específico de una rama a otra sin fusionar todo el historial. Imágina que corriges un bug en la rama `feature/new-ui` con el commit `abc1234` y necesitas urgentemente llevarlo a la rama `main`, pero si usas **git merge** podrias comprometer el proyecto ya que agregarias todos los commits hechos a la rama `main`. Para solucionarlo, podemos simplemente integrar el commit individual así: ```js git checkout main git cherry-pick abc1234 git push origin main ```

Gracias

Si creaste el archivo en la rama `amin`, luego te pasaste a `main` y realizaste un commit sin hacer un merge, los cambios que hiciste en `amin` no estarán reflejados en `main`. Esto significa que el commit en `main` solo incluirá los cambios que hayas hecho directamente en esa rama. Para incorporar los cambios de `amin` a `main`, debes realizar un merge, usando el comando `git merge amin` después de asegurarte de estar en la rama `main`. Sin el merge, los cambios en `amin` estarán aislados y no se verán en la rama principal.

muchas cosas por aprender gracias por la explicación muy clara para alguien que no sabe nada de git

¡¡Buen curso!!

El comando `git merge` solo fusiona la rama que mencionas en el comando con la rama actual en la que te encuentras. No afecta a otras ramas, incluyendo `main`, a menos que estés en `main` y fusiones otra rama hacia ella.

Las diferencias son: 1. **branch**: Crea una nueva rama para trabajar en paralelo sin afectar la rama principal. 2. **checkout**: Cambia a una rama específica o recupera archivos de un commit. Permite alternar entre ramas. 3. **merge**: Combina cambios de una rama en otra, integrando los commits realizados. Cada comando tiene un propósito específico en el manejo de versiones.

Tal vez es porque no sabía yo, pero cuando consulté el git branch no me daba ninguna respuesta, yo creé el proyecto git\_testing y luego corrí adentro el git init, por si a alguien le sirve tuve que hacer un commit con un nuevo archivo para que se creara la rama main, no sé si eso debería funcionar así o me perdí algo de la clase, pero hasta que lo hice pude avanzar, espero que a alguien le sirva.

Durante una fusión con `git merge`, pueden surgir conflictos si los cambios en la rama que intentas fusionar (en este caso, `amin`) afectan las mismas líneas de código que en la rama principal (generalmente `main`). Para resolver esto, debes: 1. Cambiar a la rama principal: `git checkout main` 2. Intentar la fusión: `git merge amin` 3. Si hay conflictos, Git te indicará los archivos afectados. 4. Abre esos archivos y resuelve los conflictos manualmente. 5. Luego, agrega los cambios resueltos con `git add <archivo>`. 6. Finaliza la fusión con `git commit`. Recuerda que siempre puedes usar `git status` para ver el estado de tus archivos y los conflictos.