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

Cómo Resolver Conflictos de Ramas en Git

7/42
Recursos

Cuando trabajamos en equipo, el manejo de conflictos de ramas en Git es esencial para evitar problemas y asegurar una integración fluida de cambios en los archivos compartidos. Aquí te mostramos cómo se genera un conflicto de ramas y la forma efectiva de resolverlo paso a paso.

¿Qué es un conflicto de ramas en Git?

En un entorno colaborativo, es común que varias personas realicen modificaciones en archivos compartidos. Esto puede llevar a conflictos de ramas cuando intentamos fusionar cambios y estos alteran las modificaciones previas realizadas por otro colaborador. En estos casos, se debe elegir qué cambios se mantendrán en la rama principal.

¿Cómo crear un conflicto de ramas para aprender a resolverlo?

Para experimentar y entender cómo resolver un conflicto, podemos crear uno intencionalmente. Aquí están los pasos básicos:

  • Verifica tu rama actual con git branch. Si solo tienes la rama main, estás listo para iniciar.
  • Crea un archivo, por ejemplo, conflict.txt, añade contenido inicial (e.g., “línea original”) y realiza un commit:
    git add conflict.txt
    git commit -m "Archivo de conflicto creado"
    
  • Crea una nueva rama con git checkout -b developer y modifica el archivo con nuevos cambios, como “cambios desde la rama dev”, realiza un commit.
  • Vuelve a la rama main con git checkout main y modifica el mismo archivo en esta rama, por ejemplo, añadiendo “segundo cambio desde main”, y realiza otro commit.

Al regresar a main y realizar la fusión de developer, verás el conflicto.

¿Cómo resolver un conflicto de ramas en Git?

Cuando Git detecta un conflicto, te indicará las diferencias entre las ramas con etiquetas que facilitan la identificación de cambios:

  • Abre el archivo en conflicto. Verás secciones como <<<<< HEAD y >>>>>, que marcan los cambios en main y en la rama que intentas fusionar (developer).
  • Edita el archivo eliminando las líneas de marcación y decide cuáles cambios deseas conservar, combinar o incluso reescribir.
  • Guarda el archivo sin las señalizaciones de conflicto y realiza un commit para registrar la resolución:
    git add conflict.txt
    git commit -m "Conflicto resuelto"
    

¿Qué hacer después de resolver un conflicto?

Una vez resuelto el conflicto y unificada la versión final en main, considera eliminar la rama developer para evitar conflictos futuros. Esto ayuda a mantener el historial de cambios limpio y reduce la posibilidad de cometer errores en el futuro.

Aportes 13

Preguntas 3

Ordenar por:

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

nunca supe que era lo que había que hacer cuando el file aparecía con ese monton de lineas!! Al parecer solo era borrar las lineas y dejar el file como quisiese!!
Aquí voy con un step-by-step porque así lo entendí (espero les sirva y agradezco algún tip u observación): 1\. Creo archivo propenso a conflictos y lo edito. \----- 2.Se crea una nueva rama donde: 2.1 Se edita archivo de conflicto. 2.2 git status, git add . , git commit -m "mensaje". 2.3 Cambiamos la rama a main. \----- 3.En rama main se modificó una vez más el archivo de conflicto y se le aplicó: 3.1 git status, git add . , git commit -m "mensaje". \----- 4.Fusionamos la rama de cambios local con la rama main -> git merge \[2nd branch]. \----- 5.Obtenemos mensaje de conflicto/error en las ramas por parte de Git al fusionar. 5.1Abrimos archivo de conflicto y se decide que se conserva/descarta. 5.2 git status, git add . , git commit -m "mensaje" -> commit de cambios "aprobados" donde ya no hay conflictos <3 \----- 6.De nuevo hacemos el merge/fusionamos la rama de cambios local/alterna con la rama main. \----- 7.Por buena practica eliminamos la rama donde se hicieron los cambios inicialmente. -> git branch -D \[branch]
Para resolver conflictos de ramas en Git, sigue estos pasos: 1. Realiza cambios en ambas ramas. 2. Intenta fusionar (merge) las ramas. Git te avisará si hay conflictos. 3. Abre el archivo en conflicto; verás secciones marcadas con `<<<<<<<`, `=======`, y `>>>>>>>`. 4. Edita el archivo para seleccionar o combinar cambios. 5. Guarda el archivo, agrega los cambios con `git add`, y realiza un commit. Finalmente, continúa trabajando en tu proyecto.
Estuvo super buena la clase, estuve practicando con un código de python y pues, Visual Studio Code te da por defecto las opciones de: 1. Aceptar el cambio actual que tienes y descartar el cambio que viene. 2. Aceptar el cambio que viene y descartar el cambio actual. 3. Conservar ambos cambios. 4. Comparar los dos cambios. En la última opción te abre una nueva ventana en la que puedes navegar mejor y mirar que cosas son diferentes. Luego de eso, pues hice el commit, hice el merge y he eliminado la otra rama. Recomiendo mucho la practica, ya que con eso a uno se le quedan las cosas
### SOLUCION DE CONFLITOS AL MOMENTO DE MERGEAR * Realiza cambios en ambas ramas. * Intenta fusionar (merge) las ramas. Git te avisará si hay conflictos. * Abre el archivo en conflicto * Edita el archivo para seleccionar o combinar cambios. * `git commit -am "Mensaje commit"` > Este simplifica al git add y git commit del archivo que a sido modificado.
como tip, si queremos agregar un cambio de un archivo que ya se encuentra trackeado, podemos usar el siguiente comando: `git commit -am "Mensaje commit"` Este simplifica al git add y git commit del archivo que a sido modificado.
El error que mencionas se debe a un error tipográfico en el comando. Deberías utilizar `git merge` en lugar de `gir merge`. Asegúrate de que el sistema tenga Git instalado. Si no está instalado, puedes hacerlo con el comando: ```bash sudo apt install git ``` Después de instalar Git, prueba nuevamente con el comando correcto `git merge`. Esto debería resolver el problema y permitirte fusionar ramas sin inconvenientes.
![](https://static.platzi.com/media/user_upload/GIT%20%284%29-fe1dc18e-aac7-4469-8e85-51b0af4df421.jpg)
El merge en Git tiene como función combinar cambios de diferentes ramas. Si decides borrar todos los cambios y crear uno único nuevo, estás esencialmente ignorando la historia de los cambios previos. Esto puede ser útil para simplificar el historial, pero también elimina la trazabilidad de las modificaciones realizadas por otros. La fusión es más valiosa cuando se preserva el contexto de los cambios de cada contribuyente, permitiendo colaborar de manera efectiva y resolver conflictos en el código.
buenisimo
Al trabajar con ramas en Git, la rama `main` representa la versión principal de tu proyecto. Cuando se produce un conflicto al fusionar otra rama (como `developer`), debes resolver dicho conflicto antes de que los cambios sean aplicados a `main`. En el proceso de resolución, seleccionas entre los cambios de ambas ramas, asegurándote de que `main` contenga la versión final deseada del archivo. Una vez resuelto y confirmado el merge, `main` refleja el estado unificado del proyecto. Si deseas mantener el flujo de trabajo limpio, es recomendable eliminar la rama adicional después de la fusión.
![](https://static.platzi.com/media/user_upload/image-0232406b-add9-421f-8472-c358b29e2213.jpg)
hola! tambien puedes escribieron git marge -- continue, y con esto se autogenera el commit con el mensaje descriptivo.