Fundamentos de Git y control de versiones

1

¿Qué son Git y GitHub?

2

Configuración Inicial de Git: init y config

3

Comandos Básicos de Git: add, commit y log

4

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

5

Volviendo en el Tiempo en Git: reset y revert

6

Gestión de versiones: tag y checkout

7

Cómo Resolver Conflictos de Ramas en Git

8

Usando Git desde Visual Studio Code

Quiz: Fundamentos de Git y control de versiones

Introducción a GitHub

9

Por qué GitHub es clave para los Desarrolladores

10

Creación y configuración de cuenta de GitHub

11

¿Cómo integrar Git y GitHub en un flujo de trabajo profesional?

12

Gestión de Repositorios en GitHub

13

Productos de GitHub: precios, planes y apps

14

Cómo configurar SSH para GitHub: Guía paso a paso

15

Clone, fork y estrellas a repositorios

16

Trabajo con repositorios remotos: push, pull y fetch

17

Gestión de Issues y Discussions en GitHub

18

Colaboración sin errores: Pull Requests en GitHub

Quiz: Introducción a GitHub

Herramientas de colaboración en GitHub

19

Introducción a GitHub Projects

20

Automatización y Gestión de Proyectos en GitHub

21

Documentación en GitHub con Markdown

22

Personaliza tu Perfil de GitHub con Markdown

23

Uso de Wikis

24

Cómo usar GitHub Gist

25

Cómo usar GitHub Pages

Quiz: Herramientas de colaboración en GitHub

GitHub Codespaces

26

Cómo usar GitHub Codespaces: Configuración y Desarrollo en la Nube

27

Cómo configurar entornos de desarrollo avanzados en GitHub Codespaces

28

Pair Programming con Codespaces y Visual Studio Code

29

Cómo usar GitHub.dev Editor

Quiz: GitHub Codespaces

Seguridad y buenas prácticas en GitHub

30

Cómo Usar Tokens en GitHub para Acceso Seguro a Repositorios Privados

31

Gestión de Dependencias y Seguridad con Dependabot en GitHub

32

Mantenimiento de repositorios seguros

33

Gestión de datos sensibles y políticas de seguridad

Quiz: Seguridad y buenas prácticas en GitHub

Administración de GitHub

34

Administración de organizaciones en GitHub

35

Cómo personalizar tu perfil de GitHub con GitHub Actions

36

GitHub CLI para administración

Quiz: Administración de GitHub

Gestión de Cambios con Pull Requests

37

Importancia de los Pull Requests y Ramas en GitHub

38

Revisión y Fusión de Pull Requests

39

Git Rebase

Quiz: Gestión de Cambios con Pull Requests

GitHub Releases

40

Introducción a los GitHub Releases

41

Publicación de paquetes en GitHub y PyPI

Quiz: GitHub Releases

Cierre

42

ProTips: Mejora tu productividad diaria en GitHub

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

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

4/42
Recursos

El uso de ramas en Git permite trabajar en un entorno aislado sin interferir con otros, facilitando la organización y el control del proyecto. Aprender a crear, gestionar y fusionar ramas optimiza la colaboración y ayuda a mantener la limpieza en el historial de cambios.

¿Por qué son útiles las ramas en Git?

Las ramas son una herramienta que permite trabajar en tareas específicas sin alterar la rama principal. Entre sus ventajas se encuentran:

  • Aislamiento de cambios individuales.
  • Posibilidad de desechar una rama sin afectar la principal.
  • Organización de actividades múltiples en diferentes ramas.

¿Cómo verificar la rama actual?

Para saber en qué rama estás trabajando, ejecuta:

git branch

El asterisco (*) indica la rama activa. Inicialmente, suele ser main, pero al crear más ramas, la lista crecerá, permitiéndote ver todas las disponibles y cuál es la actual.

¿Cómo crear una nueva rama en Git?

La creación de ramas permite desarrollar sin riesgo en paralelo. Para crear y moverte a una nueva rama, usa:

git checkout -b 

Por ejemplo, git checkout -b Amin crea y mueve a la rama Amin. Puedes verificar que estás en esta rama ejecutando git branch.

¿Cómo agregar y confirmar cambios en una rama?

Dentro de una nueva rama, los archivos se editan y confirman sin que impacten otras ramas. Sigue estos pasos para agregar y confirmar:

  1. Crea o edita un archivo.
  2. Añádelo con:
    git add .
    
  3. Confirma el cambio:
    git commit -m "mensaje de confirmación"
    

Los cambios ahora son parte de la rama en la que trabajas y no afectan la principal.

¿Cómo fusionar cambios de una rama secundaria a la principal?

Para unificar el trabajo en la rama principal:

  1. Cambia a la rama principal:
    git switch main
    
    Nota: Puedes usar también git checkout main.
  2. Fusiona la rama secundaria:
    git merge 
    

Git indicará que el proceso fue exitoso y actualizará el contenido en la rama main con los cambios de la rama secundaria.

¿Por qué es importante eliminar ramas que ya no se usan?

Una vez fusionada una rama, es buena práctica eliminarla para evitar desorden. Hazlo con:

git branch -d 

Eliminar ramas que ya cumplieron su propósito previene conflictos y mantiene el entorno de trabajo limpio y organizado.

Aportes 28

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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.
![](https://static.platzi.com/media/user_upload/GIT%20%281%29-7d7bfbe8-d189-46cb-9eb7-a209b5db8f6c.jpg)
![](https://static.platzi.com/media/user_upload/imagen-5d026ecd-84e0-42e2-8a61-fb8c02371205.jpg)
![](https://static.platzi.com/media/user_upload/imagen-fd42e198-0518-427b-9ad8-b0ced72434bb.jpg)
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`.
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.
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.
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`. ![](https://static.platzi.com/media/user_upload/image-d8f13ba2-b116-4dee-a4b0-30f3521ec845.jpg) 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`) ![](https://static.platzi.com/media/user_upload/image-958d0676-069b-49cb-a06c-a1397e58e88a.jpg) 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 ```
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 ```
Lindo trabalenguas, "rama de amin no de main". Muy buen curso!!!
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.
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.