Guía rápida de Git (Completa y Visual)

¿Qué es Git?

Git es un sistema de control de versiones que te permite:

• Guardar cambios en tu código
• Volver atrás si algo falla
• Trabajar en equipo
• Crear versiones de tu proyecto

Git trabaja con 3 zonas

1. Working Directory --> Donde editas archivos
2. Staging Area --> Lo que vas a guardar
3. Repository --> historial de commits

Flujo básico de Git

1º Modificas archivos

2º Los añades

3º Guardas cambios

4º Los subes

Fichero .gitignore

Es un archivo que le dice a Git qué cosas NO debe incluir en el repositorio.

Sirve para evitar subir ficheros y cosas no relevantes o cosas sensibles q no deben estar como:

• dependencias instalabres (node_modules, venv)
• archivos temporales o compilados (dist, build, logs)
• configuraciones personales del editor (.vscode, .idea)
• y sobre todo, secretos (.venv, claves API, tokens)

git rm --cached archivo

git rm -r --cached .
git add .

COMANDOS

Configuración Básica Global

Para empezar a utilizar git debemos hacer una configuración global que mínimo tiene que incluir 2 cosas:

• Nombre de Usuario
• Email

1. Configurar Nombre que salen en los commits

git config --global user.name "[Nombre]"

Nota: el archivo que modificamos con este comando se encuentra en /home/[usuario]/.gitconfig

2. Configurar el Email

git config --global user.email "tu_email@mail.com"

3. Configurar Alias (Opcional)

git config --global alias.[nombre_alias] "Comando para el álias"

[GIT INIT] Iniciar nuestro repositorio

Para ello debemos estar en nuestra carpeta del "Proyecto" que vayamos a realizar

Puedes moverte hacia ella con 'cd /ruta/del/proyecto'

Una vez ahí ya puedes lanzar el siguiente comando:

git init

Con esto te aparecerá en la carpeta del Proyecto una carpeta oculta llamada ".git"

Podemos ver con el comando 'git status' el nombre que tiene antes de cambiarlo

Para cambiarlo usaremos este comando:

git branch -m "main"

[GIT STATUS] Visualizar el estado (Staging Area)

Este comando te va a servir para cuando realizes cambios, ver en que estado se encuentran esos cambios.

git status

[GIT ADD] Añadir archivos

En tu editor de código favorito, puedes empezar a crear tus archivos de código para tu Proyecto pero hasta que tu no los añadas al staging area, no podrás crear tus commits.

Commit: "foto" o captura instantánea del estado de tu proyecto en un momento específico, actuando como un punto de guardado seguro.

Por eso para añadirlos está el comando:

git add [Nombre_del_archivo]

git add .

[GIT COMMIT] Crear imágenes

Suele utilizarse después del add, no es obligatorio. Sirve para realizar la imagen.

La forma más cómoda de realizarlo es con el atributo -m para escribir directamente el texto que hace referencia al commit sin tener que abrir ningún editor de texto.

git commit -m "Texto que identifique por qué se hizo el commit"

| Tipos de commits

Hay distintos tipos de commits que podemos encontrarlos en esta url conventionalcommits.org

Principalmente hay 2:

• fix: para cambios pequeños
• feat: para cambios más grandes

Se suelen asociar a las versiones. Su apariencia es la siguiente:

git commit -m "fix: texto que identifique por qué se hizo el commit"

[GIT LOG] Visor de eventos de Git

Con este comando lo que puedes hacer es ver que cambios se han ido haciendo sobre los commits, es decir, que commits hay, en cual estoy, que hash identificador tienen...

git log

| Atributos importantes del 'git log'

Hay ciertos atributos que se pueden utilizar junto al log para que nos sea más visual dependiendo de que queramos hacer, algunos de los ejemplos son:

1. Para verlo con línea gráfica.

git log --graph

2. Para verlo en una línea sin autor y ni fecha.

git log --pretty=oneline

git log --graph --decorate --all --oneline

[GIT SWITCH] Para cambiar de rama

Simplemente te ayuda a cambiar de rama sin hacer nada más.

git switch [nombre_rama]

[GIT CHECKOUT]

Este comando tiene muchas funciones y hay tener varias cosas en cuenta. Sirve principalmente para moverte dentro del repositorio.

1. Uso principal: Cambiar de rama.

Aquí hay que tener clara una cosa

El commando es:

git checkout [nombre_rama]

2. Crear o cambiar de rama

git checkout -b [nombre_nueva_rama]

• Crea la rama (-b)
• Se mueve a ella

3. Recuperar archivos

Restaura el archivo a su último commit.

git checkout archivo.txt

4. Ir a un commit concreto

Te mueves a un commit específico

git checkout [hash]

Nota: el hash puede ser completo o la versión simplificada, podemos verlo con 'git log'

Sirve para:

• Probar versiones antiguas
• Revisar código viejo
• Debuggear

Para volver a la normalidad:

git checkout main

[GIT RESET] ¡CUIDADO! "Volver atrás"

Es un comando peligroso porque puede afectar a 3 cosas: 1. Historial (commits) 2. Staging area 3. Archivos (working directory)

Se encarga de mover el puntero HEAD (donde estás en el historial)

git reset

• Quita el archivo del 'git add'
• NO bora cambios

GIT RESET --HARD

Este es otro tipo que es el más peligroso

git reset --hard

• Elimina el commit
• Elimina cambios en archivos
• Limpia staging

Nota: si la liamos podemos utilizar 'git reflog'

[GIT BRANCH] Ver, Crear y Gestionar Ramas

1. Ver ramas.

git branch

2. Crear una rama.

git branch [nombre_rama]

3. Borrar una rama.

git branch -d [nombre_rama]

[GIT REBASE] Mover el trabajo

Reaplica los commits encima de otra rama, reescribiendo el historial. Es primo hermano de "merge"

Rebase = "mover el trabajo como si hubiera empezado más tarde"

git rebase [nombre_rama]

Nota: Rebase NO mueve commits, los recrea. Por eso:

• Cambian los IDs
• Se "reescribe" la historia

Ejemplo visual:

A ---- B ---- C ---- D' ---- E'

[GIT MERGE] Fusionar una rama con otra

Sirve para unir (fusionar) una rama con otra. Es primo hermano de "rebase"

Merge = juntar historiales sin borrar nada

git merge [nombre_rama]

[GIT DIFF] Ver diferencias de versiones

Sirve para ver las diferencias entre versiones de archivos.

1. Cambios sin añadir (Más común).

git diff

2. Cambios ya añadidos.

git diff --staged

3. Comparar commits.

git diff commit1 commit2

4. Comparar ramas

git diff rama1 rama2

5. Ver cambios en un archivo

git diff archivo.txt

[GIT FETCH] Descarga cambios SIN aplicarlos

Sirve para descargar cambios del repositorio remoto SIN aplicarlos en nuestro código

git fetch

[GIT PUSH] SUBIR commits

Sirve para subir commits al respositorio remoto (por ejemplo, GitHub)

git push -u origin [rama (ej.main)]

git push --set-upstream origin [rama (ej.develop)]

Esto hace:

• sube la rama
• la conecta con el remoto

Después ya puedes usar solo

git push

[GIT PULL] BAJAR commits

Sirve para traer cambios del repositorio remoto a nuestro ordenador y además mezclarlos automáticamente con nuestra rama actual.

Idea principal:

git pull= git fetch + git merge

Hace 2 cosas: - Descarga cambios (fetch) - Los mezcla con nuestro código (merge)

git pull

GIT PULL --REBASE

Hay otra opción muy buena que es la de juntar En lugar de mezclar, reordena los commits encima del remoto

git pull --rebase

[GIT REMOTE] Conexión con repos externos

Sirve para conectar tu git con repositorios externos como: GitHub, Azure, DevOps, GitLab, etc.

git remote -v

Para subir un git a remoto haremos el siguiente comando

git remote add origin <URL>

Cuando es la primera vez que subes código a tu repo en remoto debemos hacer este comando

git push -u origin main

También podemos cambiar la URL del remoto

git remote set-url origin <Nueva_URL>

Para eliminar el remoto

git remote remove origin

Para ver info detallada

git remote show origin