Comandos GIT por Sinoe9891

Hola👋🏼, mi nombre es Danny Sinoé conocido como
Sinoe9891 en GitHub, hoy les dejo algunos
comandos git que normalmente uso. Espero les sea de provecho.
*Si algunas descripciones están mal escritas no duden en hacer un request.

---

Comandos Básicos

Una vez instalado en el servidor, para iniciar git en un proyecto:

git init

Si quieres obtener una copia de un proyecto que se encuentra en un repositorio público:

git clone [url]

Si se han hecho cambios en varios archivos, se pueden añadir todos juntos al staging:

git add .

Si se han hecho cambios en un archivo especifico, se pueden añadir al staging:

git add archivo.txt

Para ver los cambios que se han hecho en el proyecto:

git status

Para ver los cambios de forma más esquematizada:

git status -s

Ver el contenido modificado de los archivos:

git diff

Enmendar el commit antes de hacer push:

git commit --amend

Agrega archivos y commit al mismo tiempo:

git commit -am "<mensaje>"

Muestra los archivos que no pertenecen al repositorio (prueba antes de borrar):

git clean --dry-run

Elimina los archivos que no pertenecen al repositorio:

git clean -f

Elimina un archivo en especifico:

git clean -f <path>

Agrega todos los archivos con la misma extensión:

git add ./*svg

---

Git Stash Proceso

Guarda cambios sin commitear y vuelve a estado limpio:

git stash

Crea la rama con los cambios guardados (y te cambia a esa rama):

git checkout -b <nombrebranch>

Recupera los cambios guardados y borra el stash aplicado:

git stash pop

Lista los stashes:

git stash list

Elimina un stash (el más reciente si no especificas):

git stash drop

Elimina los archivos que están en staging (caché) pero los deja en tu carpeta (disco duro):

git rm --cached <ruta-archivo-o-carpeta>

Si quieres ignorar una carpeta ya subida y luego usar .gitignore, primero la sacas del índice:

git rm -r --cached <ruta-archivo-o-carpeta>

---

Fetch / Pull (Actualizar desde remoto)

Trae actualizaciones del repositorio remoto (NO modifica tu rama actual, solo actualiza referencias remotas):

git fetch

Trae actualizaciones de todos los remotos:

git fetch --all

Trae cambios y actualiza tu rama actual (pull). Recomendado usar fast-forward only para evitar merges inesperados:

git pull --ff-only

Si querés “actualizar todas las ramas locales” (pull en todas), lo más seguro es:
1) fetch a todo, 2) recorrer ramas locales y hacer pull en cada una.

git fetch --all --prune
for b in $(git for-each-ref --format='%(refname:short)' refs/heads/); do
  echo "==> Actualizando $b"
  git checkout "$b" >/dev/null 2>&1
  git pull --ff-only
done
git checkout main

Nota: si no querés cambiarte de rama, con git fetch --all --prune ya traés lo último de todo,
y luego haces pull únicamente en la rama que estés trabajando.

---

Ramas o Branches

Sincronizar las ramas que ya murieron en remoto y limpiar referencias:

git remote update origin --prune

Otra forma común de limpiar ramas remotas eliminadas:

git fetch -p

Muestra las ramas locales y remotas:

git branch -a

Cambia de rama:

git checkout <branch>

Crea y se cambia a la rama creada:

git checkout -b <branch>

Crea una rama nueva basada en main (recomendado para empezar limpio):

git checkout main
git pull --ff-only
git checkout -b feature/nueva-funcionalidad

Fusiona las ramas (ejecutar estando en la rama que recibirá cambios):

git merge <branch>

Borra una rama local (forzado):

git branch -D <branch>

Borra una rama remota (GitHub):

git push origin --delete <rama>

Envía una rama específica a repositorio remoto:

git push origin <branch>

Envía una rama específica a repositorio remoto y la deja trackeando (upstream):

git push -u origin <branch>

Si ya existe en remoto y querés configurar el tracking manualmente:

git branch --set-upstream-to=origin/<branch> <branch>

Envía todas las ramas al remoto:

git push origin --all

Muestra ramas con información:

git show-branch

Ver todas las ramas:

git branch --list

Renombrar rama (correcto):

git branch -m nombre-viejo nuevo-nombre

Muestra ramas con más información:

git show-branch --all

Abre plataforma visual de git (si la tienes instalada):

gitk

---

Reset duro (quedar igual al remoto) — Útil cuando hubo force push

Si querés descartar TODO lo local y dejar tu rama igual a la del remoto (ej: origin/main):

git fetch origin
git checkout main
git reset --hard origin/main
git clean -fd

(Opcional) Si querés alinear otras ramas a main (dejarlas clonadas de main) y reescribir remoto de forma segura:

git checkout main
git fetch origin
git reset --hard origin/main

git branch -f develop main
git branch -f hotfix main
git branch -f release main

git push --force-with-lease origin develop hotfix release

---

Eliminar y recrear ramas desde main (limpieza total)

1) Borrar ramas locales excepto main:

git checkout main
git branch | grep -v "^\* main$" | grep -v "^  main$" | xargs -n 1 git branch -D

2) Borrar ramas remotas excepto main (¡cuidado! elimina en GitHub):

git fetch --prune origin
for b in $(git branch -r | sed 's/origin\///' | grep -vE '^(HEAD|main)$'); do
  git push origin --delete "$b"
done

3) Recrear ramas desde main y subirlas:

git checkout main
git pull --ff-only

git branch develop main
git branch hotfix main
git branch release main

git push -u origin develop
git push -u origin hotfix
git push -u origin release

---

Git Reset y Reflog (usar con cuidado)

Git Reset y Reflog – Mala practica si no sabes lo que haces 😅

Elimina commit dejando el repo exactamente en ese estado:

git reset <commit> --hard

Sube rama con commits reescritos (cuidado):

git push --force-with-lease origin <rama>

Muestra todo, incluso lo eliminado (sirve para recuperar):

git reflog

Volver a un estado anterior usando reflog (ejemplo):

git reset --hard HEAD@{3}

Destruye el commit y vuelve al anterior:

git reset HEAD^ --hard

Mantiene staging (no destruye cambios staged):

git reset --soft HEAD@{3}

---

Git Log

Muestra los commits:

git log

Muestra todos los commits:

git log --all

Muestra los commits de una mejor manera:

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

Muestra específicamente los cambios que se hicieron en los archivos:

git log --stat

---

Búsqueda

Busca en todo el proyecto una palabra específica:

git grep <palabra>

Nos dirá en que línea está:

git grep -n <palabra>

Cuantas veces se repite cada palabra:

git grep -c <palabra>

Busca un commit por palabra:

git log -S <palabra>

---

Git Blame

Ver líneas específicas y quién las cambió:

git blame <archivo.ext> -L35,60 -c

Ver quién hizo exactamente ese cambio:

git blame -c <archivo.ext>