├── .DS_Store ├── 00_instalacion.md ├── 01_comandos_basicos.md ├── 02_branchs.md ├── 03_historial-y-cambios.md ├── 04_remote-y-conflictos.md ├── LICENSE ├── README-EN.md └── README.md /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SoftwareLibre-UPS/fs-git-workshop-content/0f06fffd29ab4da677cc3145c668f7f7bcc57b0e/.DS_Store -------------------------------------------------------------------------------- /00_instalacion.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Instalación de Git 4 | 5 | Git se puede instalar en diferentes sistemas operativos de forma sencilla. A continuación, te mostramos los pasos para instalar Git en **Windows**, **Linux** y **Mac**. 6 | 7 | ## Instalación de Git en Windows 8 | 9 | 1. Descarga el instalador de Git desde [git-scm.com](https://git-scm.com/download/win). 10 | 2. Ejecuta el archivo descargado y sigue las instrucciones del asistente de instalación. 11 | 3. Durante la instalación, puedes aceptar la mayoría de las configuraciones por defecto. 12 | 13 | ### Opciones importantes: 14 | 15 | - **Editor predeterminado de Git**: Puedes elegir el editor de texto que prefieras (por ejemplo, Vim, Nano, o Visual Studio Code). 16 | - **Configuración del PATH**: Selecciona la opción "Git from the command line and also from 3rd-party software". 17 | - **Opciones de clonación HTTPS**: Selecciona "Use Git from the Windows Secure Channel library". 18 | - **Convertir finales de línea**: Elige "Checkout Windows-style, commit Unix-style line endings" si trabajas en equipos con distintos sistemas operativos. 19 | 20 | ## Instalación de Git en Linux (Debian/Ubuntu) 21 | 22 | 1. Abre una terminal. 23 | 2. Actualiza los paquetes e instala Git con los siguientes comandos: 24 | 25 | ```bash 26 | sudo apt update 27 | sudo apt install git 28 | ``` 29 | 30 | ## Instalación de Git en Mac 31 | 32 | 1. Abre una terminal. 33 | 2. Instala Git utilizando **Homebrew** (si no tienes Homebrew, puedes instalarlo desde su [sitio web](https://brew.sh/)). 34 | 3. Una vez instalado Homebrew, ejecuta el siguiente comando para instalar Git: 35 | 36 | ```bash 37 | brew install git 38 | ``` 39 | -------------------------------------------------------------------------------- /01_comandos_basicos.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Comandos Básicos de Git 4 | 5 | # Índice 6 | 7 | 1. [Configuración: `$git config`](#1-configuración-git-config) 8 | 2. [Inicialización: `$git init`](#2-inicialización-de-un-repositorio-git-init) 9 | 10 | 3. [Cambios y guardar versiones: `$git add` y `$git commit`](#3-añadir-cambios-y-guardar-versiones-git-add-y-git-commit) 11 | 12 | 13 | ## 1. Configuración: `$git config` 14 | 15 | ### 1.1 Concepto 16 | El comando `git config` permite configurar ajustes de Git a nivel de sistema, usuario o repositorio. Es utilizado para establecer la identidad del usuario y preferencias generales que Git utilizará. 17 | 18 | Git permite dos tipos de configuración: 19 | - **Local**: específica para cada repositorio. 20 | - **Global**: aplicada por defecto a todos los repositorios del usuario. 21 | 22 | La configuración local puede diferir de la global. A continuación se detalla cómo configurar Git desde la terminal, cómo acceder a la configuración global y cómo asignar un nombre de usuario y correo electrónico. 23 | 24 | #### Archivos de Configuración Global 25 | 26 | Dependiendo del sistema operativo, el archivo de configuración global se encuentra en distintas ubicaciones: 27 | - **Linux**: `~/.gitconfig` 28 | - **Windows**: `C:\Users\\.gitconfig` 29 | - **MacOS**: (Buscar ruta específica) 30 | 31 | --- 32 | ### Comandos de Configuración 33 | 34 | - **Ver la configuración**: 35 | 36 | ```bash 37 | git config --list # Muestra toda la configuración 38 | git config --global --list # Muestra solo la configuración global 39 | git config list --global # Nueva forma de mostrar la configuración global 40 | ``` 41 | 42 | - **Verificar un valor específico**: 43 | 44 | ```bash 45 | git config --global . 46 | git config --global --get . 47 | git config get --global . # Nueva forma 48 | ``` 49 | 50 | **Ejemplo**: 51 | ```bash 52 | git config --global rerere.enabled 53 | # Salida esperada: 54 | > true 55 | ``` 56 | 57 | - **Borrar un valor**: 58 | 59 | ```bash 60 | git config --global --unset . # Forma deprecada 61 | git config unset --global rerere.enabled # Nueva forma 62 | ``` 63 | 64 | **Ejemplo**: 65 | ```bash 66 | git config --local --unset rerere.enabled 67 | git config unset --global rerere.enabled 68 | ``` 69 | 70 | - **Agregar valores**: 71 | 72 | ```bash 73 | git config --global --add . # Forma deprecada 74 | git config set --local . # Nueva forma 75 | ``` 76 | 77 | ### 1.2 Comandos más usados 78 | 79 | - Configuración del nombre de usuario: 80 | 81 | ```bash 82 | git config --global user.name "" 83 | ``` 84 | 85 | - Configuración del correo electrónico del usuario: 86 | 87 | ```bash 88 | git config --global user.email "" 89 | ``` 90 | 91 | - Verificación de la configuración actual: 92 | 93 | ```bash 94 | git config --list 95 | ``` 96 | 97 | - **`--global`**: Aplica la configuración a nivel de usuario (global). 98 | - **`--system`**: Configura Git a nivel de todo el sistema. 99 | - **`--local`**: Aplica los ajustes solo en el repositorio actual. 100 | 101 | 102 | 103 | ### 1.3 Ejercicio Práctico - Configuración de Git (Global) 104 | 105 | 106 | 107 | 108 | 109 | > Verifica la configuración de Git. Si no tienes asignado el nombre de usuario y correo electrónico, agrégalos ahora. 110 | 111 | - Para agregar el nombre de usuario y correo electrónico globalmente: 112 | 113 | ```bash 114 | git config --global --add user.name "" 115 | git config --global --add user.email "" 116 | ``` 117 | 118 | - **Verificar la configuración**: 119 | 120 | Comprueba que los valores se hayan configurado correctamente con `git config --global --list`. 121 | 122 | ```bash 123 | git config --global --list` 124 | ``` 125 | 126 | 127 | 128 | --- 129 | 130 | ## 2. Inicialización de un repositorio: `$git init` 131 | 132 | ### 2.1 Concepto 133 | El comando `git init` se utiliza para crear un nuevo repositorio de Git en el directorio actual. Este comando configura las carpetas y archivos necesarios para comenzar a controlar versiones en el proyecto. 134 | 135 | ### 2.2 Comandos más usados 136 | 137 | - Inicializar un nuevo repositorio en el directorio actual: 138 | 139 | ```bash 140 | git init 141 | ``` 142 | 143 | - Inicializar un repositorio en una carpeta específica: 144 | 145 | ```bash 146 | git init 147 | ``` 148 | - Iniciar con otra rama principal 149 | ```bash 150 | git init -b 151 | git init --initial-branch= 152 | ``` 153 | Ejemplo 154 | 155 | git init -b trunk 156 | git init -b master 157 | git init -b main 158 | 159 | 160 | ### 2.3 Ejercicio Práctico 161 | 162 | - Crea una nueva carpeta en tu equipo y ejecuta `git init` para convertirla en un repositorio de Git. 163 | 164 | ```bash 165 | git init -b main 166 | ``` 167 | 168 | - Verifica que el directorio `.git` haya sido creado en la carpeta. 169 | 170 | 171 | --- 172 | 173 | 174 | ## 3. Añadir cambios y guardar versiones: `$git add` y `$git commit` 175 | 176 | ### 3.1 Concepto 177 | El comando `git add` añade archivos al área de preparación (staging area), preparándolos para ser confirmados en el historial del repositorio. El comando `git commit` guarda esos cambios en el repositorio. 178 | 179 | #### Visualizar el Historial de Commits 180 | 181 | Revisar el historial de commits es útil para conocer los cambios realizados y quién los hizo. 182 | 183 | 1. **Ver el historial completo de commits**: 184 | 185 | ```bash 186 | git log 187 | ``` 188 | 189 | 2. **Ver un historial compacto**: 190 | 191 | ```bash 192 | git log --oneline 193 | ``` 194 | 195 | 3. **Ver el historial en formato gráfico**: 196 | 197 | ```bash 198 | git log --graph 199 | ``` 200 | 201 | También puedes combinar ambos: 202 | 203 | ```bash 204 | git log --oneline --graph 205 | ``` 206 | 207 | Estos comandos muestran los commits realizados, la fecha y hora, y el nombre de quien realizó los cambios. 208 | 209 | > **Conceptos Importantes**: 210 | > - **HEAD**: Refleja el commit en el que estás actualmente. 211 | > - **HASH del Commit**: Es el identificador único de cada commit. 212 | > - **git blame**: Muestra el historial de cambios por línea, permitiendo ver quién hizo cada cambio. 213 | 214 | 215 | ### 3.2 Comandos más usados 216 | 217 | - Añadir un archivo específico al área de preparación: 218 | 219 | ```bash 220 | git add 221 | ``` 222 | 223 | - Añadir todos los archivos modificados al área de preparación: 224 | 225 | ```bash 226 | git add . 227 | ``` 228 | 229 | - Confirmar (commit) los cambios en el repositorio con un mensaje descriptivo: 230 | 231 | ```bash 232 | git commit -m "Descripción de los cambios" 233 | ``` 234 | 235 | - Confirmar todos los cambios con una descripción interactiva: 236 | 237 | ```bash 238 | git commit 239 | ``` 240 | 241 | - Listar los commits realizados: 242 | 243 | ```bash 244 | git log --oneline 245 | ``` 246 | 247 | ### 3.3 Ejercicio Práctico 248 | 249 | - Crea un archivo nuevo en tu repositorio inicializado. 250 | - Añade el archivo al área de preparación con `git add `. 251 | - Confirma los cambios usando `git commit -m "Añadido archivo inicial"`. 252 | - Verifica el historial de commits usando `git log`. 253 | 254 | 255 | ### 3.3 Ejercicio Práctico - Agregar Archivos y Guardar Cambios 256 | 257 | Para esta práctica, trabajaremos con archivos Markdown para mayor simplicidad, pero ten en cuenta que estos comandos aplican para cualquier tipo de archivo y directorio. 258 | 259 | ### Agregar Archivos al Repositorio 260 | 261 | 1. **Crear un archivo** `archivo_1.md` y agregar texto usando cualquier editor. 262 | 2. **Ver el estado del repositorio**: 263 | 264 | ```bash 265 | git status 266 | ``` 267 | 268 | Verás que el archivo aparece como "no rastreado" (untracked), lo que significa que aún no forma parte del repositorio. 269 | 270 | 3. **Agregar el archivo al área de preparación (staging area)**: 271 | 272 | - Para agregar un archivo específico: 273 | 274 | ```bash 275 | git add archivo_1.md 276 | ``` 277 | 278 | - Para agregar todos los archivos en el directorio actual: 279 | 280 | ```bash 281 | git add . 282 | ``` 283 | 284 | - Para agregar archivos por tipo o extensión usando expresiones regulares: 285 | 286 | ```bash 287 | git add *.md # Agrega todos los archivos con extensión .md 288 | git add carpeta/*.txt # Agrega todos los archivos .txt dentro de la carpeta "carpeta" 289 | ``` 290 | 291 | 292 | 293 | 294 | #### Primer Commit 295 | 296 | El comando `git commit` permite registrar los cambios agregados al área de preparación en el historial del repositorio. Es obligatorio acompañarlo de un mensaje breve y descriptivo sobre los cambios. 297 | 298 | 1. **Realizar un commit con mensaje**: 299 | 300 | ```bash 301 | git commit -m "Add: file archivo_1.md has been added" 302 | ``` 303 | 304 | Esto crea un "punto de guardado" en el repositorio con el mensaje que describiste. 305 | 306 | 2. **Agregar texto adicional y verificar el estado**: 307 | 308 | - Agrega más texto al archivo `archivo_1.md`. 309 | - Ejecuta `git status` nuevamente para ver la diferencia con el archivo antes del cambio. 310 | 311 | 3. **Commit Rápido para Archivos Modificados**: 312 | 313 | Para agregar y hacer commit de todos los archivos modificados directamente: 314 | 315 | ```bash 316 | git commit -am "Add: file archivo_1.md has been added" 317 | ``` 318 | 319 | > **Consejo**: Evita realizar commits por cada pequeño cambio, ya que esto puede llenar el historial de commits y dificultar la revisión de cambios cuando surgen problemas en el proyecto. 320 | 321 | 322 | 323 | -------------------------------------------------------------------------------- /02_branchs.md: -------------------------------------------------------------------------------- 1 | 2 | # Manejo de Ramas en Git 3 | 4 | # Índice 5 | 6 | 1. [Creación de Ramas](#1-creación-de-ramas) 7 | 2. [Cambio entre Ramas](#2-cambio-entre-ramas) 8 | 3. [Fusión de Ramas](#3-fusión-de-ramas) 9 | 4. [Eliminación de Ramas](#4-eliminación-de-ramas) 10 | 11 | --- 12 | 13 | ## 1. Creación de Ramas 14 | 15 | ### 1.1 Concepto 16 | En Git, las ramas permiten desarrollar características, realizar pruebas o trabajar en correcciones de errores de manera aislada. Cada rama representa una línea de tiempo de desarrollo independiente, lo que facilita la colaboración y el desarrollo paralelo. 17 | 18 | ### 1.2 Comandos más usados 19 | 20 | - **Crear una rama** sin cambiar a ella: 21 | 22 | ```bash 23 | git branch 24 | ``` 25 | 26 | - **Crear y cambiar a una nueva rama**: 27 | 28 | ```bash 29 | git checkout -b 30 | ``` 31 | 32 | - **`-b`**: Crea y cambia a la nueva rama. 33 | 34 | ### 1.3 Ejercicio Práctico 35 | 36 | 1. Crea una nueva rama llamada `archivo_2.md` y cámbiala de inmediato: 37 | 38 | ```bash 39 | git checkout -b dev 40 | ``` 41 | 42 | 2. En esta nueva rama, crea un archivo `login.md` y agrega texto de ejemplo: 43 | 44 | ```bash 45 | echo "Funcionalidad de creada en desarrollo" > archivo_2.md 46 | git add archivo_2.md 47 | git commit -m "Add: file archivo_2.md" 48 | ``` 49 | 50 | --- 51 | 52 | ## 2. Cambio entre Ramas 53 | 54 | ### 2.1 Concepto 55 | El cambio entre ramas en Git permite moverse de una línea de desarrollo a otra. Este proceso es útil para revisar cambios en diferentes partes del proyecto o para trabajar en varias características a la vez. 56 | 57 | ### 2.2 Comandos más usados 58 | 59 | - **Ver la lista de ramas** en el repositorio: 60 | 61 | ```bash 62 | git branch 63 | ``` 64 | 65 | - **Cambiar a otra rama existente**: 66 | 67 | ```bash 68 | git checkout 69 | ``` 70 | 71 | ### 2.3 Ejercicio Práctico 72 | 73 | 1. Verifica las ramas disponibles en tu repositorio con `git branch`. 74 | ```bash 75 | git branch 76 | ``` 77 | 2. Cambia a la rama `main` (o según el nombre de tu rama principal): 78 | 79 | ```bash 80 | git checkout main 81 | ``` 82 | 83 | 3. Observa el contenido del repositorio y nota que no verás los cambios realizados en `archivo_2.md`. Este archivo no deberia existir. 84 | 85 | 4. Volvemos ala rama `dev` 86 | 87 | ```bash 88 | git checkout dev 89 | ``` 90 | 91 | --- 92 | 93 | ## 3. Fusión de Ramas 94 | 95 | ### 3.1 Concepto 96 | La fusión (merge) de ramas permite combinar cambios de una rama en otra. Este proceso es común al incorporar una rama de características en la rama principal, consolidando todo el trabajo en una sola línea de desarrollo. 97 | 98 | ### 3.2 Comandos más usados 99 | 100 | - **Fusionar cambios de una rama en la rama activa**: 101 | 102 | ```bash 103 | git merge 104 | ``` 105 | 106 | - Este comando fusiona `` en la rama en la que estás actualmente. 107 | 108 | ### 3.3 Ejercicio Práctico 109 | 110 | 1. Cambia a la rama `main` y fusiona los cambios de la rama dev `dev`: 111 | 112 | ```bash 113 | git checkout main 114 | git merge dev 115 | ``` 116 | 117 | 2. Revisa el historial de commits para confirmar que los cambios de `archivo_2.md` ahora están en `main`: 118 | 119 | ```bash 120 | git log --oneline 121 | ``` 122 | 123 | --- 124 | 125 | ## 4. Eliminación de Ramas 126 | 127 | ### 4.1 Concepto 128 | Una vez que los cambios de una rama han sido fusionados o si ya no es necesaria, la rama puede eliminarse. Esto ayuda a mantener el repositorio limpio y organizado. 129 | 130 | ### 4.2 Comandos más usados 131 | 132 | - **Eliminar una rama fusionada**: 133 | 134 | ```bash 135 | git branch -d 136 | ``` 137 | 138 | - **Eliminar una rama sin fusionar** (forzado): 139 | 140 | ```bash 141 | git branch -D 142 | ``` 143 | 144 | ### 4.3 Ejercicio Práctico 145 | 146 | 1. Elimina la rama `archivo_2.md` después de verificar que ha sido fusionada en `main`: 147 | 148 | ```bash 149 | git branch -d dev 150 | ``` 151 | 152 | 2. Revisa la lista de ramas para asegurarte de que `dev` ha sido eliminada: 153 | 154 | ```bash 155 | git branch 156 | ``` 157 | 158 | -------------------------------------------------------------------------------- /03_historial-y-cambios.md: -------------------------------------------------------------------------------- 1 | 2 | # Manejo del Historial y Cambios en Git 3 | 4 | # Índice 5 | 6 | 1. [Rebase (Reorganizar el historial)](#1-rebase-reorganizar-el-historial) 7 | 2. [Stash (Guardar cambios temporales)](#2-stash-guardar-cambios-temporales) 8 | 3. [Reverse (Revertir cambios)](#3-reverse-revertir-cambios) 9 | 4. [Reset (Restablecer cambios)](#4-reset-restablecer-cambios) 10 | 11 | --- 12 | 13 | ## 1. Rebase (Reorganizar el historial) 14 | 15 | ### 1.1 Concepto 16 | El comando `git rebase` reorganiza el historial de commits moviendo una rama a otra base. Es útil para mantener un historial más limpio y lineal, evitando "commits de merge" en exceso. 17 | 18 | ### 1.2 Comandos más usados 19 | 20 | - **Rebase interactivo**: 21 | 22 | ```bash 23 | git rebase -i 24 | ``` 25 | 26 | - **`-i`**: Modo interactivo para editar, combinar, o reordenar commits. 27 | 28 | - **Rebase de una rama**: 29 | 30 | ```bash 31 | git checkout 32 | git rebase 33 | ``` 34 | 35 | - **Cancelar un rebase en progreso**: 36 | 37 | ```bash 38 | git rebase --abort 39 | ``` 40 | 41 | ### 1.3 Ejercicio Práctico 42 | 43 | 1. Crea una nueva rama `rebase-demo` y realiza dos commits: 44 | 45 | ```bash 46 | git checkout -b rebase-demo 47 | echo "Primer commit" > rebase1.txt 48 | git add rebase1.txt 49 | git commit -m "Add: Primer commit en rebase-demo" 50 | 51 | echo "Segundo commit" > rebase2.txt 52 | git add rebase2.txt 53 | git commit -m "Add: Segundo commit en rebase-demo" 54 | ``` 55 | 56 | 2. Cambia a la rama principal y realiza un commit en `main`: 57 | 58 | ```bash 59 | git checkout main 60 | echo "Commit en main" > main.txt 61 | git add main.txt 62 | git commit -m "Add: Cambios en main" 63 | ``` 64 | 65 | 3. Vuelve a la rama `rebase-demo` y haz un rebase contra `main`: 66 | 67 | ```bash 68 | git checkout rebase-demo 69 | git rebase main 70 | ``` 71 | 72 | 4. Revisa el historial para confirmar el rebase: 73 | 74 | ```bash 75 | git log --oneline 76 | ``` 77 | 78 | --- 79 | 80 | ## 2. Stash (Guardar cambios temporales) 81 | 82 | ### 2.1 Concepto 83 | El comando `git stash` guarda los cambios en un área temporal, permitiendo trabajar en otra tarea sin perder el progreso actual. 84 | 85 | ### 2.2 Comandos más usados 86 | 87 | - **Guardar cambios en el stash**: 88 | 89 | ```bash 90 | git stash 91 | ``` 92 | 93 | - **Aplicar el stash más reciente**: 94 | 95 | ```bash 96 | git stash apply 97 | ``` 98 | 99 | - **Listar los stashes almacenados**: 100 | 101 | ```bash 102 | git stash list 103 | ``` 104 | 105 | - **Eliminar el stash más reciente**: 106 | 107 | ```bash 108 | git stash drop 109 | ``` 110 | 111 | ### 2.3 Ejercicio Práctico 112 | 113 | 1. Realiza un cambio sin hacer commit y guárdalo en el stash: 114 | 115 | ```bash 116 | echo "Cambio temporal" > temporal.txt 117 | git add temporal.txt 118 | git stash 119 | ``` 120 | 121 | 2. Cambia a la rama `main` y revisa que el cambio ya no está: 122 | 123 | ```bash 124 | git checkout main 125 | ``` 126 | 127 | 3. Vuelve a aplicar el stash y haz un commit: 128 | 129 | ```bash 130 | git stash apply 131 | git commit -m "Add: Cambio temporal recuperado" 132 | ``` 133 | 134 | --- 135 | 136 | ## 3. Reverse (Revertir cambios) 137 | 138 | ### 3.1 Concepto 139 | El comando `git revert` permite deshacer un cambio de un commit específico, creando un nuevo commit que lo anula. Es ideal para revertir cambios en un entorno compartido. 140 | 141 | ### 3.2 Comandos más usados 142 | 143 | - **Revertir un commit específico**: 144 | 145 | ```bash 146 | git revert 147 | ``` 148 | 149 | - **Revertir múltiples commits (interactivo)**: 150 | 151 | ```bash 152 | git revert -n 153 | ``` 154 | 155 | ### 3.3 Ejercicio Práctico 156 | 157 | 1. Haz un commit con un cambio erróneo: 158 | 159 | ```bash 160 | echo "Cambio erróneo" > error.txt 161 | git add error.txt 162 | git commit -m "Add: Cambio erróneo" 163 | ``` 164 | 165 | 2. Reviértelo con `git revert`: 166 | 167 | ```bash 168 | git revert 169 | ``` 170 | 171 | 3. Verifica que el nuevo commit anula el cambio: 172 | 173 | ```bash 174 | git log --oneline 175 | ``` 176 | 177 | --- 178 | 179 | ## 4. Reset (Restablecer cambios) 180 | 181 | ### 4.1 Concepto 182 | El comando `git reset` restablece cambios en el historial de commits o en el área de trabajo. Dependiendo del modo utilizado, puede descartar cambios o eliminar commits. 183 | 184 | ### 4.2 Comandos más usados 185 | 186 | - **Restablecer al último commit (hard reset)**: 187 | 188 | ```bash 189 | git reset --hard 190 | ``` 191 | 192 | - **Mover el HEAD sin alterar el área de trabajo (soft reset)**: 193 | 194 | ```bash 195 | git reset --soft 196 | ``` 197 | 198 | - **Descartar cambios en el área de trabajo**: 199 | 200 | ```bash 201 | git reset HEAD 202 | ``` 203 | 204 | ### 4.3 Ejercicio Práctico 205 | 206 | 1. Haz un commit y restablécelo con `--soft`: 207 | 208 | ```bash 209 | echo "Cambio temporal para reset" > reset.txt 210 | git add reset.txt 211 | git commit -m "Add: Cambios para reset" 212 | git reset --soft HEAD~1 213 | ``` 214 | 215 | 2. Observa que los cambios siguen en el área de preparación (`staging`). 216 | 217 | 3. Realiza un hard reset: 218 | 219 | ```bash 220 | git reset --hard 221 | ``` 222 | 223 | 4. Verifica que los cambios se han eliminado. 224 | 225 | -------------------------------------------------------------------------------- /04_remote-y-conflictos.md: -------------------------------------------------------------------------------- 1 | # Trabajando con Repositorios Remotos y Resolución de Conflictos 2 | 3 | # Índice 4 | 5 | 1. [Trabajando con Repositorios Remotos](#1-trabajando-con-repositorios-remotos) 6 | 2. [Resolución de Conflictos](#2-resolución-de-conflictos) 7 | 8 | --- 9 | 10 | ## 1. Trabajando con Repositorios Remotos 11 | 12 | ### 1.1 Concepto 13 | Un repositorio remoto es una copia de tu repositorio local que está alojada en un servidor externo (como GitHub, GitLab, o Bitbucket). Estos repositorios permiten la colaboración entre desarrolladores y sirven como respaldo del proyecto. 14 | 15 | ### 1.2 Comandos más usados 16 | 17 | - **Agregar un repositorio remoto**: 18 | 19 | ```bash 20 | git remote add origin 21 | ``` 22 | 23 | - **Ver los repositorios remotos configurados**: 24 | 25 | ```bash 26 | git remote -v 27 | ``` 28 | 29 | - **Actualizar tu repositorio local con cambios remotos**: 30 | 31 | ```bash 32 | git fetch origin 33 | git pull origin 34 | ``` 35 | 36 | - **`fetch`**: Obtiene los cambios sin aplicarlos automáticamente. 37 | - **`pull`**: Obtiene y aplica los cambios directamente. 38 | 39 | - **Enviar cambios locales al remoto**: 40 | 41 | ```bash 42 | git push origin 43 | ``` 44 | 45 | - **`-u`**: Configura la rama actual para rastrear la rama remota. 46 | 47 | ### 1.3 Ejercicio Práctico 48 | 49 | 1. **Configurar un repositorio remoto**: 50 | - Crea un repositorio nuevo en GitHub y copia la URL HTTPS o SSH. 51 | - Enlázalo con tu repositorio local: 52 | 53 | ```bash 54 | git remote add origin 55 | ``` 56 | 57 | 2. **Subir tu proyecto a GitHub**: 58 | - Asegúrate de que el proyecto tiene commits. 59 | - Sube los cambios: 60 | 61 | ```bash 62 | git push -u origin main 63 | ``` 64 | 65 | 3. **Actualizar cambios desde el remoto**: 66 | - Realiza un cambio en GitHub (por ejemplo, edita un archivo desde la web). 67 | - Actualiza tu repositorio local: 68 | 69 | ```bash 70 | git pull origin main 71 | ``` 72 | 73 | --- 74 | 75 | ## 2. Resolución de Conflictos 76 | 77 | ### 2.1 Concepto 78 | Un conflicto ocurre cuando Git no puede fusionar automáticamente los cambios de dos ramas, ya sea al hacer un merge o un pull. Esto sucede cuando ambos cambios afectan las mismas líneas de un archivo. 79 | 80 | ### 2.2 Comandos más usados 81 | 82 | - **Detectar conflictos**: 83 | 84 | Al intentar un `merge` o `pull`, Git notificará si hay conflictos. 85 | 86 | ```bash 87 | git merge 88 | ``` 89 | 90 | - **Ver archivos en conflicto**: 91 | 92 | ```bash 93 | git status 94 | ``` 95 | 96 | - **Resolver un conflicto manualmente**: 97 | - Edita el archivo para mantener los cambios deseados. 98 | - Marca el conflicto como resuelto: 99 | 100 | ```bash 101 | git add 102 | ``` 103 | 104 | - **Completar el proceso de fusión**: 105 | 106 | ```bash 107 | git commit 108 | ``` 109 | 110 | - **Cancelar la fusión en progreso** (si no deseas continuar): 111 | 112 | ```bash 113 | git merge --abort 114 | ``` 115 | 116 | ### 2.3 Ejercicio Práctico 117 | 118 | 1. **Crear un conflicto**: 119 | - Desde la rama `main`, crea un archivo y haz un commit: 120 | 121 | ```bash 122 | echo "Contenido en main" > conflicto.txt 123 | git add conflicto.txt 124 | git commit -m "Add: contenido en main" 125 | ``` 126 | 127 | - Cambia a una nueva rama `conflicto-demo` y edita el mismo archivo: 128 | 129 | ```bash 130 | git checkout -b conflicto-demo 131 | echo "Contenido en conflicto-demo" > conflicto.txt 132 | git add conflicto.txt 133 | git commit -m "Edit: contenido en conflicto-demo" 134 | ``` 135 | 136 | - Vuelve a `main` e intenta fusionar `conflicto-demo`: 137 | 138 | ```bash 139 | git checkout main 140 | git merge conflicto-demo 141 | ``` 142 | 143 | 2. **Resolver el conflicto**: 144 | - Edita el archivo `conflicto.txt` y elige qué cambios conservar. 145 | - Marca el conflicto como resuelto: 146 | 147 | ```bash 148 | git add conflicto.txt 149 | ``` 150 | 151 | 3. **Completar la fusión**: 152 | 153 | ```bash 154 | git commit -m "Resolve: conflicto en conflicto.txt" 155 | ``` 156 | 157 | 4. **Verificar el resultado**: 158 | - Revisa que el archivo `conflicto.txt` contenga los cambios esperados. 159 | - Confirma que el historial refleja el merge: 160 | 161 | ```bash 162 | git log --oneline --graph 163 | ``` 164 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2024 SoftwareLibre UPS 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README-EN.md: -------------------------------------------------------------------------------- 1 | # Introduction to Git 2 | 3 | Git is a distributed version control system designed to handle everything from small to large projects with speed and efficiency. It was created by **Linus Torvalds** in 2005 for the development of the Linux kernel. Unlike some other version control systems, Git is open-source and free to use, making it a popular choice for developers worldwide. 4 | 5 | ## Key Features of Git 6 | 7 | - **Distributed Version Control**: Every user has a full copy of the repository, including its history. This provides redundancy and allows for faster operations. 8 | - **Branching and Merging**: Git allows users to create branches for individual tasks, enabling parallel development and easy merging of changes. 9 | - **Data Integrity**: Git ensures the integrity of data through checksums, preventing corruption and providing a reliable version history. 10 | - **Performance**: Git is optimized for performance, handling both small and large repositories with ease. 11 | 12 | Git is especially effective for managing software projects where multiple contributors are involved, and changes need to be tracked and managed effectively over time. 13 | 14 | ## History Behind the Name 15 | 16 | The term "Git" does not have a specific meaning as an acronym. In British slang, "git" is a derogatory term used to describe an unpleasant or incompetent person. Linus Torvalds humorously chose the name because it was short and had a dictionary meaning, which he found amusing. 17 | 18 | ## Why Use Git? 19 | 20 | 1. **Collaboration**: Git enables multiple developers to work on the same project simultaneously without conflicting changes. 21 | 2. **Version Control**: With Git, you can track every change made to the project, ensuring that you can always revert back to previous versions if necessary. 22 | 3. **Backup and Restore**: Since every contributor has a full copy of the repository, there’s always a backup available. 23 | 24 | Visit the official Git website [git-scm.com](https://git-scm.com) for more details and documentation. 25 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Git & GitHub 2 | 3 | [![Git](https://img.shields.io/badge/Git-2.37+-f14e32?style=for-the-badge&logo=git&logoColor=white&labelColor=101010)](https://git-scm.com/) 4 | [![GitHub](https://img.shields.io/badge/GitHub-Web-blue?style=for-the-badge&logo=github&logoColor=white&labelColor=101010)](https://github.com/) 5 | 6 | 7 | Git es un sistema de control de versiones distribuido diseñado para manejar proyectos desde pequeños hasta muy grandes, con rapidez y eficiencia. Fue creado por **Linus Torvalds** en 2005 para el desarrollo del kernel de Linux. A diferencia de otros sistemas de control de versiones, Git es de código abierto y gratuito, lo que lo convierte en una opción popular entre los desarrolladores de todo el mundo. 8 | 9 | ## Características Clave de Git 10 | 11 | - **Control de versiones distribuido**: Cada usuario tiene una copia completa del repositorio, incluyendo su historial. Esto proporciona redundancia y permite operaciones más rápidas. 12 | - **Ramas y fusiones**: Git permite a los usuarios crear ramas para tareas individuales, facilitando el desarrollo en paralelo y la fusión de cambios. 13 | - **Integridad de los datos**: Git asegura la integridad de los datos mediante sumas de verificación, lo que previene la corrupción y proporciona un historial de versiones confiable. 14 | - **Rendimiento**: Git está optimizado para el rendimiento, manejando repositorios pequeños y grandes con facilidad. 15 | 16 | Git es especialmente eficaz para gestionar proyectos de software donde están involucrados varios colaboradores, y los cambios deben ser rastreados y gestionados de manera efectiva a lo largo del tiempo. 17 | 18 | ## Historia detrás del nombre 19 | 20 | El término "Git" no tiene un significado específico como acrónimo. En la jerga británica, "git" es un término despectivo que se utiliza para describir a una persona desagradable o incompetente. Linus Torvalds eligió el nombre humorísticamente porque era corto y tenía un significado en el diccionario, lo cual le resultaba divertido. 21 | 22 | ## ¿Por qué usar Git? 23 | 24 | 1. **Colaboración**: Git permite que varios desarrolladores trabajen en el mismo proyecto simultáneamente, sin que los cambios entren en conflicto. 25 | 2. **Control de versiones**: Con Git, puedes rastrear cada cambio realizado en el proyecto, asegurando que siempre puedas volver a versiones anteriores si es necesario. 26 | 3. **Respaldo y restauración**: Dado que cada colaborador tiene una copia completa del repositorio, siempre hay un respaldo disponible. 27 | 28 | Visita el sitio oficial de Git [git-scm.com](https://git-scm.com) para más detalles y documentación. 29 | 30 | 31 | ## Temas 32 | [Instalacións de Git](./00_instalacion.md) 33 | 34 | [Comandos Básicos de Git](./01_comandos_basicos.md) 35 | - [Configuración: `$git config`](./01_comandos_basicos.md#1-configuración-git-config) 36 | - [Inicialización: `$git init`](./01_comandos_basicos.md#2-inicialización-de-un-repositorio-git-init) 37 | - [Cambios y guardar versiones: `$git add` y `$git commit`](./01_comandos_basicos.md#3-añadir-cambios-y-guardar-versiones-git-add-y-git-commit) 38 | 39 | [Manejo de Ramas en Git](./02_branchs.md) 40 | - [Creación de Ramas](./02_branchs.md#1-creación-de-ramas) 41 | - [Cambio entre Ramas](./02_branchs.md#2-cambio-entre-ramas) 42 | - [Fusión de Ramas](./02_branchs.md#3-fusión-de-ramas) 43 | - [Eliminación de Ramas](./02_branchs.md#4-eliminación-de-ramas) 44 | 45 | 46 | 47 | [Manejo del Historial y Cambios en Git](./03_historial-y-cambios.md) 48 | - [Rebase (Reorganizar el historial)](./03_historial-y-cambios.md#1-rebase-reorganizar-el-historial) 49 | - [Stash (Guardar cambios temporales)](./03_historial-y-cambios.md#2-stash-guardar-cambios-temporales) 50 | - [Reverse (Revertir cambios)](./03_historial-y-cambios.md#3-reverse-revertir-cambios) 51 | - [Reset (Restablecer cambios)](./03_historial-y-cambios.md#4-reset-restablecer-cambios) 52 | 53 | [Repositorios Remotos y Resolución de Conflictos](./04_remote-y-conflictos.md) 54 | - [Trabajando con Repositorios Remotos](./04_remote-y-conflictos.md#1-trabajando-con-repositorios-remotos) 55 | - [Resolución de Conflictos](./04_remote-y-conflictos.md#2-resolución-de-conflictos) 56 | 57 | --------------------------------------------------------------------------------