ventas@monarcacomputer.com.co (+57) 320 951 3095
Git básico

Tu primer repositorio

Lección 2 de 8 · 14 min

Convertir una carpeta en repositorio

Vamos a trabajar sobre algo real, no sobre un ejemplo de laboratorio. Escoge una carpeta tuya: las plantillas de cotización, unos scripts, la documentación de un procedimiento. Cualquier cosa que ya tenga archivos de texto.

Convertirla en repositorio es un comando y no toca tus archivos: Git solo añade una subcarpeta oculta .git donde va a guardar el historial.

Entrar en la carpeta e iniciar el repositorio
cd ~/plantillas-cotizacion
git init
Resultado
Initialized empty Git repository in /home/ana/plantillas-cotizacion/.git/

La palabra empty del mensaje es correcta y despista: el repositorio está vacío de historial, no de archivos. Tus archivos siguen donde estaban; lo que aún no existe es ni un solo commit.

Los tres sitios donde puede estar un archivo

Aquí está la idea que hay que entender de verdad, porque todo lo demás del curso se apoya en ella. En un repositorio, cada archivo está en uno de tres sitios, y pasar de uno a otro es una decisión tuya.

Del disco al historial, en dos saltos

1. Árbol de trabajo

La carpeta tal como la ves en el explorador de archivos. Aquí editas, borras y creas.

Git ve estos cambios y te los cuenta, pero no los guarda en ningún historial.

2. Área de preparación

Una lista donde tú apartas los cambios que quieres que entren en el próximo commit. Se llena con git add.

Sirve para armar un commit limpio: tocaste seis archivos, pero solo tres pertenecen al mismo asunto.

3. Historial

Lo que ya quedó guardado con git commit, para siempre y con su mensaje.

Es lo único que se puede recuperar, comparar o compartir.

Este es el malentendido número uno de quien empieza: «hice commit y no guardó mis cambios». Casi siempre significa que faltó el add. Git no guarda lo que hay en la carpeta: guarda lo que tú pusiste en el área de preparación.

El comando que se escribe más veces al día

git status te dice en qué sitio está cada archivo. Se consulta constantemente, antes y después de cada cosa, y es el hábito que más errores evita.

Ver el estado antes de hacer nada
git status
Resultado
On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	cotizacion-servicios.md
	cotizacion-hardware.md
	notas-internas.txt

nothing added to commit but untracked files present (use "git add" to track)

Antes del primer commit: decidir qué NO entra

Fíjate en notas-internas.txt. Antes de guardar nada, la pregunta correcta no es «¿qué añado?» sino «¿qué no debe entrar nunca?».

Eso se declara en un archivo llamado .gitignore, con un patrón por línea. Git deja de proponer esos archivos y no los guarda jamás.

Un .gitignore mínimo, y sensato
# Credenciales y configuracion con datos sensibles
.env
*.key
*.pem
credenciales.txt

# Archivos que genera el sistema o el editor
.DS_Store
Thumbs.db
.vscode/

# Cosas pesadas o que se regeneran solas
node_modules/
*.log
temporales/

Este es el único error del curso que no se arregla con un comando. Si un archivo con contraseñas entra al historial, borrarlo después no lo quita: sigue estando en todos los commits anteriores, y si alguien ya clonó el repositorio, en su copia también.

La contraseña queda quemada y hay que cambiarla, no esconderla. Por eso el .gitignore se escribe antes del primer commit y no cuando ya hace falta.

Ahora sí: preparar y guardar

Con el .gitignore puesto, se prepara lo que va a entrar y se confirma con un mensaje.

El ciclo completo, paso a paso

  1. Preparar los archivos elegidos

    git add cotizacion-servicios.md cotizacion-hardware.md

    También existe git add ., que prepara todo lo pendiente. Es cómodo y por eso es peligroso: úsalo solo después de mirar git status, o acabarás guardando algo que no querías.

  2. Comprobar qué quedó preparado

    git status otra vez. Los archivos preparados aparecen bajo Changes to be committed. Lo que siga fuera de esa lista no va a entrar.

  3. Confirmar con un mensaje

    git commit -m "Plantillas de cotizacion de servicios y hardware"

    La opción -m es el mensaje. Sin ella, Git abre un editor de texto para que lo escribas allí, que es donde se atasca mucha gente la primera vez.

  4. Verificar que existe

    git log --oneline tiene que mostrar tu commit con su identificador. Si aparece, ya está en el historial y se puede recuperar.

El ciclo entero, tal como se ve en pantalla
git add cotizacion-servicios.md cotizacion-hardware.md
git commit -m "Plantillas de cotizacion de servicios y hardware"
git log --oneline
Resultado
[main (root-commit) 8f2a1c9] Plantillas de cotizacion de servicios y hardware
 2 files changed, 84 insertions(+)

8f2a1c9 Plantillas de cotizacion de servicios y hardware

Ese 8f2a1c9 es el identificador del commit. Git lo calcula solo y es único: con él puedes referirte a esa fotografía exacta del proyecto en cualquier momento, incluso dentro de tres años.

Cuatro situaciones que te van a pasar esta semana

Hice commit y me faltó un archivo

No hace falta deshacer nada: haz el add del archivo que faltaba y un commit nuevo. Un historial con dos commits pequeños es perfectamente normal.

Si prefieres que quede uno solo, existe git commit --amend, que rehace el último. Úsalo solo mientras no lo hayas compartido: en la lección 5 se explica por qué.

Añadí sin querer un archivo al área de preparación

git restore --staged archivo.txt lo saca de la lista sin tocar su contenido. El propio git status te sugiere ese comando cuando toca.

Puse el archivo en .gitignore y Git lo sigue mostrando

El .gitignore solo afecta a lo que Git todavía no sigue. Si el archivo ya entró en un commit, hay que decírselo: git rm --cached archivo.txt y confirmar.

Eso lo saca de los commits futuros, pero sigue en los anteriores. Si eran credenciales, hay que cambiarlas igual.

git status escupe demasiadas líneas

git status -s da la versión corta, de una línea por archivo. Son dos columnas: la de la izquierda es el área de preparación y la de la derecha el árbol de trabajo. Así, M es «modificado y preparado» y M es «modificado y sin preparar».

Coloca cada comando en su sitio

Arrastra cada comando a lo que hace, o toca uno y luego su espacio.

  1. Convierte la carpeta actual en un repositorio, creando la subcarpeta .git.
  2. Dice en qué sitio está cada archivo: sin seguir, modificado, o preparado.
  3. Pasa un cambio al área de preparación, para que entre en el próximo commit.
  4. Guarda en el historial lo que estaba preparado, con un mensaje que lo explica.
  5. Declara los archivos que Git no debe seguir nunca, como los que llevan credenciales.

Compruébalo tú mismo

Editas tres archivos, haces git add de uno solo y luego git commit. ¿Qué quedó en el historial?

Un archivo con la contraseña de la base de datos entró en un commit de la semana pasada. Lo borras y haces commit. ¿Está resuelto?

¿Para qué sirve el área de preparación?

Lo que sigue

Ya tienes historial. En la siguiente lección lo vas a leer: ver qué cambió, cuándo y por qué, comparar dos versiones línea por línea, y escribir mensajes que le sirvan a quien los lea dentro de un año -que casi siempre eres tú.

Siguiente: Leer el historial

Continuar ← Por qué existe Git