La fusión en Git es la forma en que este sistema une un historial bifurcado. El comando git merge permite integrar líneas de desarrollo independientes generadas por git branch en una sola rama. Con este comando, podemos crear un nuevo commit que combina dos ramas o branches: la rama actual y la rama que se indica después del comando.
Estos comandos de fusión del merge afectan solo a la rama actual y no a la rama de destino. Por lo tanto, te recomendamos utilizar git checkout para seleccionar la rama actual y git branch -d para eliminar la rama de destino obsoleta.
Funcionamiento de Git merge
Git merge fusiona secuencias de confirmaciones en un solo historial, generalmente para combinar dos ramas. Busca una confirmación de base común y genera una confirmación de fusión que representa la combinación de las dos ramas hasta el resultado final.
¿Cómo unir dos ramas en git?
Ahora bien, para combinar ramas en tu repositorio local, usa git checkout para cambiar a la rama donde deseas fusionar. Por lo general, esta es la rama principal. Luego, emplea git merge y especifica el nombre de la otra rama que deseas traer a esta rama. Ten en cuenta que esto es una combinación de avance rápido.
¿Cómo realizar un merge en git?
Para hacer un merge en Git, primero asegúrate de estar en la rama correcta. Después, usa el comando git merge seguido del nombre de la rama que quieres combinar. Por ejemplo, si quieres crear un nuevo commit en la rama master con los cambios de la rama cabecera, usa este comando:
git checkout master
git merge cabecera
Es importante tener en cuenta que en caso de haber conflictos, debes guardar tus cambios antes de hacer git checkout para evitar perder tu trabajo. También es recomendable emplear los comandos básicos de GitHub, como git fetch, git push y git pull, para mantener actualizado tu repositorio.
En este ejemplo, vamos a crear un nuevo commit en la rama master combinando los cambios de una rama llamada cabecera: Otra opción es crear un nuevo commit en la rama cabecera combinando los cambios de cualquier otra rama:
Git es asombroso porque puede saber cuáles cambios deben conservarse en una rama y cuáles no. En casos de conflictos, asegúrate de guardar tus cambios antes de hacer git checkout para evitar perder tu trabajo.
Comandos básicos de GitHub
git init: crear un repositorio.
git add: agregar un archivo a staging.
git commit -m “mensaje”: guardar el archivo en git con un mensaje.
git branch: crear una nueva rama.
git checkout: moverse entre ramas.
git push: mandar cambios a un servidor remoto.
git fetch: traer actualizaciones del servidor remoto y guardarlas en nuestro repositorio local.
git merge: tiene dos usos. Uno es la fusión de ramas, funcionando como un commit en la rama actual, trayendo la rama indicada. Su otro uso es guardar los cambios de un servidor remoto en nuestro directorio.
git pull: fetch y merge al mismo tiempo.
git checkout “codigo de version” “nombre del archivo”: volver a la última versión de la que se ha hecho commit.
git reset: vuelve al pasado sin posibilidad de volver al futuro, se debe usar con especificaciones.
git reset --soft: vuelve a la versión en el repositorio, pero guarda los cambios en staging. Así, podemos aplicar actualizaciones a un nuevo commit.
git reset --hard: todo vuelve a su versión anterior
git reset HEAD: saca los cambios de staging, pero no los borra. Es lo opuesto a git add.
git rm: elimina los archivos, pero no su historial. Si queremos recuperar algo, solo hay que regresar. se utiliza así:git rm --cached elimina los archivos en staging pero los mantiene en el disco duro.git rm --force elimina los archivos de git y del disco duro.
git status: estado de archivos en el repositorio.
git log: historia entera del archivo.
git log --stat: cambios específicos en el archivo a partir de un commit.
git show: cambios históricos y específicos hechos en un archivo.
git diff “codigo de version 1” “codigo de version 2”: comparar cambios entre versiones.
git diff: comparar directorio con staging.
Aporte creado con los aportes de: Pedro Alejandro Silva.
es absurdo lo buen profesor que es freddyyyy que haga mas cursoooos
Dios te oiga :,v
Porfavor fredy !
Comparo mis apuntes hasta el momento
Muy organizados tus apuntes!!!
Hola, como haces para tener los apuntes así digitalizados? Usas una tablet?
Dejo esto por aquí. Nota relacionada al tema de la clase:
¡Nunca pares de aprender! (Y practicar)🦄
Excelente aporte :D
Gracias, Excelente aporte
Quiero mostrarles esta extensión de Vistual Studio Code donde se ve graficamente todo el proceso de merge y las diferentes ramas.
La extensión se llama git Graph
gracias <3
**Comparto mis apuntes **:)
Slds,
Woow esto esta genial, cómo lo hiciste?
Probablemente lo hace un un ipad con aplicaciones de apuntes como goodnotes (y el estilo y organizacion de apuntes es notas de Cornel) puedes ver ese estilo y aprender a hacer apuntes en el curso de estrategias para aprender en linea efectivamente @ernesto Valencia
un tip
git log --graph
eso nos da una vision de grafico de las ramas y como se fusionaron, recomiendo hacer eso despues de fusionar
Grandee bro!!!
excelente aporte
Chicos, utilicen el comando "gitk", les mostrará de forma gráfica los commits realizados hasta el momento.
Buen dato, no lo sabia
Gracias diana, muy buen dato.
Este es un pdf bien chido con los comandos de Git para imprimirlo y tenerlo a la mano.
Cuando Freddy ve que no estás practicando lo que aprendes en las clases
Posdata: Nunca pares de aprender
😂😂😂
xD
Estoy utilizando VSC y al hacer el merge me sale esto en el código, alguien mas le sale?
Es un conflicto al momento en la siguiente clase Freddy lo explica, ya quede tranquilo :)
cuando vas a hacer merge y hay codigo que se chocan , git te muestra en donde chocan:
HEAD (current change) ---- lo que esta en verde te muestra tu codigo actual
cabecera (incoming change) -- es los cambios que haras al codigo actual
ahora tu solo tienes que borrar el que no quieras
Mis apuntes :)
Extructuta
Directorio de trabajo | preparacion o staing | repositirio local || repositirio remoto
git init [iniciar el repositorio]
git add biografia.txt [añadir el archivo]
git commit -m "version 1" [guardar en la base de datos del repositorio]
git add . [añadir todos los cambios hechos a la base de datos del repositorio]
git commit -m "Cambios a v1" [guadar los cambios en la db del repositorio]
git status [muestra el estado de los archivos de la base de datos]
git show [cambios que se han hecho]
git log biografia.txt [muestra el historial de cambios de un archivo]
git push [enviar hacia otro repositorio remoto lo que yo estoy haciendo]
git pull [permite traer de cualquier repositorio remoto combinando dos comandos 28. y 29.]
git status [estado del proyecto en este momento]
git rm historia.txt [devolver el comando 2. y 13. ]
git rm --cached historia.txt [descachearlo lo de debaja en la ram "ya no :)" ligado al comando 12.]
git commit -m "primer commit" [realizar un cambio, ya para guardar]
git config [todas las configuraciones de git]
git config --list [ver la configuracion de git]
git config --list --show-origin [ver donde esta ubicado los archivos de configuracion]
git config --global user.name "Andres Leon" [colocarle un nombre para saber quien esta haciendo cambios]
git config --global user.email "dandresleon64@gmail.com" [colocarle un email para saber quien esta haciendo cambios]
git log historia.txt [ver el historial de este archivo]
git show historia.txt [ver las modificaciones que han existido]
git commit [cuando se va sin mensaje el lo pide y la forma de salir es "comandos 17. " y para empezar a escribir dentro de "vi" 18. ]
git diff 3f9221603091ac205cea6fa2f88710da3857a482 e549b6799aa407cfbb7034c22b817577c85c44dc [compara dos commit]
git reset effa0d5de0734e75a7aa0186a36d36b218c45865 --hard [la version a la que quiero volver]
git log --stat [ver los cambios del historial mas detallado, con la letra "q me pueda salir si lo que se muestra es muy largo"]
git checkout e549b6799aa407cfbb7034c22b817577c85c44dc historia.txt [checar un commit anterior y se quiere se hace un reeemplazo con el comando 04. y 05.]
git checkout master [checar el ultimo commit]
git fetch [actualizar mi repositirio local con los cambios subidos en el remoto]
git merge [combinar lo del repositorio remoto con mi directorio de trabajo || combinar ramas]
git commit -a -m "se modifico algo" [aplicar 04. y 05. en un solo comando]
git branch cabecera [crear una rama]
git checkout cabecera [cambiar entre ramas]
git branch [saber que ramas existen]
------------------------comandos en la consola y navegacion----------------------
01. pwd [en donde estoy parado]
02. mkdir [crear una carpeta]
03. cat nombre_del_archivo.txt [ver el contenido de un archivo]
04. cd [navegar entre carpetas]
05. rm [borrar una carpeta o archivo]
06. ls [listar todo en donde este parado en el sistema]
07. ls -al [listar con argumentos]
08. clear [limpiar la consola de git]
09. cd [entrar a una carpeta]
10. cd .. [devolverme o salir de esta carpeta]
11. cd /c [ir a un disco en especifico]
12. history [ultimos comandos que he ingresado]
13. para escoger alguno de la lista que aparece !25
14. touch vacio.txt [crear un archivo vacio]
15. rm --help [ayuda de como funciona cada comando "rm" puede ser diferente]
16. code historia.txt [iniciar este archivo con vs]
17. esc pausa y ingresar shif + z + z [para guardar y salir de "vi"]
18. espace + i [para poder empezar a escribir en "vi"]
Muchas gracias!
Muy completo :)
Amigos hice un resumen bien chido con emojis y todo
Link de resumen
Gracias por el aporte :)
muy bueno gracias
Estos son mis apuntes un resumen, una referencia corata para repasar
Muchas gracias, muy útiles.
muy util.
buen aporte.
que super esfuerzo, muy buenos apuntes, enhorabuena
Sin conocimientos de html, traté de hacer un pequeño html con todos los comandos, a continuación les dejo la imagen de como queda y un poco más abajo el código tanto html como css.
.
- git merge: También usamos el comando git fetch con servidores remotos. Lo necesitamos para combinar los últimos cambios del servidor remoto y nuestro directorio de trabajo.
- git pull: Básicamente, git fetch y git merge al mismo tiempo.
- git reset HEAD: Este es el comando para sacar archivos del área de Staging. No para borrarlos ni nada de eso, solo para que los últimos cambios de estos archivos no se envíen al último commit, a menos que cambiemos de opinión y los incluyamos de nuevo en staging con git add, por supuesto.
- git reset --soft: Borramos todo el historial y los registros de Git pero guardamos los cambios que tengamos en Staging, así podemos aplicar las últimas actualizaciones a un nuevo commit.
- git reset --hard: Borra todo. Todo todito, absolutamente todo. Toda la información de los commits y del área de staging se borra del historial.
- git rm --cached: Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro.
- git rm --force: Elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder al registro de la existencia de los archivos, de modo que podremos recuperarlos si es necesario (pero debemos usar comandos más avanzados).
- git checkout master nombredearhivo.extensión: Ver la versión del master, y ya no la primera versión. Es decir la última versión
**- git checkout "código log" nombredearhivo.extensión: **Ver primera versión del archivo, si no se hace commit no se graba el cambio, pero lo puedo visualizar mientras
- git log --stat: Para observar cambios específicos que se hicieron y en cuales archivos a partir del commit (se ve los cambios en bite y/o carpeta)
- git reset "Código de un log" --hard: Para volver a una versión del archivo de forma literal a como estaba antes. Se borran las otras modificaciones
- git reset "Código de un log" --soft: Para volver a una versión del archivo dejando lo que que está en el staging (comando add, ubicado en la RAM)
- git reset "Código de un log": Para volver a una versión anterior.
- git diff "código de un log" "código de otro log": Es para identificar los cambios que hay entre una versión y otra. El código del log se ubica con git log nombredearchivo.extensión. El orden importa, según el orden en que coloque el log me va a indicar si se agrega una línea o si se quita. El primero en colocar es el que va a tomar como original
- VIM: El editor de texto, la pantalla que aparece cuando se hace commit sin comentar
**- Esc + shift + zz **(para salir y guardar de la pantalla que aparece cuando no se hacen comentarios) + zq (para salir sin guardar de la pantalla que aparece cuando no se hacen comentarios)
- git show nombredearchivo.extensión:: Muestra todos los cambios realizados al archivo
- git log nombredearchivo.extensión: Trae todos los commit realizados en el archivo
- git add . : Añadir todos los cambios al stage (RAM)
- git config --global user.email "tu@email.com": Para identificar el nombre y el correo de la ersona que va a hacer los cambios
- git config --global user.name "Tu Nombre"
Con un solo- se usan las letras, con dos -- se usan palabras
- git config: Ver toda la configuración de git
- git config --list: La lista de los elementos configurados
- git config --list --show-origin: Para ver donde están las configuraciones guardadas
****- git commit -m "": para subir un commit con un mensaje
- git rm --cached: Para borrar un archivo cuando ha sido añadido sólo con el comando add rm --cached nombrearchivo.extensión saca al archivo de la ram que la mantiene si no hay commint
- git status: Para chequear el estado de una carpeta respecto a los cambios del control de versiones
**- git ini: **Para iniciar una carpeta con el control de versiones de repositorio
**- pwd: **Nos muestra la ruta de carpetas en la que te encuentras ahora mismo.
- mkdir: Nos permite crear carpetas (por ejemplo, mkdir Carpeta-Importante).
- touch: Nos permite crear archivos (por ejemplo, touch archivo.txt).
- rm: Nos permite borrar un archivo o carpeta (por ejemplo, rm archivo.txt). Mucho cuidado con este comando, puedes borrar todo tu disco duro.
- cat: Ver el contenido de un archivo (por ejemplo, cat nombre-archivo.txt).
- ls: Nos permite cambiar ver los archivos de la carpeta donde estamos ahora mismo. Podemos usar uno o más argumentos para ver más información sobre estos archivos (los argumentos pueden ser -- + el nombre del argumento o - + una sola letra o shortcut por cada argumento).
- ls -a: Mostrar todos los archivos, incluso los ocultos.
- ls -l: Ver todos los archivos como una lista.
cd: Nos permite navegar entre carpetas.
- cd /: Ir a la ruta principal:
- cd o cd ~: Ir a la ruta de tu usuario
- cd carpeta/subcarpeta: Navegar a una ruta dentro de la carpeta donde estamos ahora mismo.
- cd .. (cd + dos puntos): Regresar una carpeta hacia atrás.
Si quieres referirte al directorio en el que te encuentras ahora mismo puedes usar cd . (cd + un punto).
history: Ver los últimos comandos que ejecutamos y un número especial con el que podemos repetir su ejecución.
! + número: Ejecutar algún comando con el número que nos muestra el comando history (por ejemplo, !72).
clear: Para limpiar la terminal. También podemos usar los atajos de teclado Ctrl + L o Command + L.
Éste resumen debería estar más arriba.
Hasta este punto estaba un poco perdido con los comandos y la lógica de las ramas cuando me movía en el tiempo con los checkout, pero con algo de práctica y repetición logré tenerlo un poco más claro. También me ayudó descubrir que dentro de git existe una interfaz que permite ver de forma gráfica cual ha sido el historial de cambios, en que punto me encuentro y cuales ramas existen junto con todos los detalles que brinda el mismo comando log.
Dejo una imagen de como se puede acceder a ella por si a alguien le interesa y no la ha descubierto.