Borrar un archivo.
Para borrar un archivo del árbol de trabajo podríamos usar el comando "rm" sobre el mismo. Sin embargo aún tendríamos que usar git add [archivo_borrado] para que está modificación quedara registrada y luego ya podríamos hacer el commit.
chema@lenovo:~/proyecto$ rm main.py
chema@lenovo:~/proyecto$ git status
On branch master
Changes not staged for commit:
(use "git add/rm <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
deleted: main.py
no changes added to commit (use "git add" and/or "git commit -a")
chema@lenovo:~/proyecto$ git add main.py
chema@lenovo:~/proyecto$ git status
On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
deleted: main.py
chema@lenovo:~/proyecto$ git commit -m "Pasos para borrar un archivo."
[master 5a2eea1] Pasos para borrar un archivo.
1 file changed, 2 deletions(-)
delete mode 100644 main.py
Sin embargo con;
$ git rm [archivos]
No solo borramos los archivos del árbol de trabajo sino que también lo preparamos para hacer el commit.
chema@lenovo:~/proyecto$ git rm main.py
rm 'main.py'
chema@lenovo:~/proyecto$ git status
On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
deleted: main.py
chema@lenovo:~/proyecto$ git commit -m "borrado de un archivo."
[master e86a317] borrado de un archivo.
1 file changed, 0 insertions(+), 0 deletions(-)
delete mode 100644 main.py
Mover o Renombrar un Archivo.
Lo mismo ocurre si queremos mover un archivo de un directorio a otro dentro del árbol de trabajo. Para ahorrar tener que confirmar la modificación con git add, directamente tecleamos:
$ git mv [archivo] [nuevo_nombre]
y así podemos mover los archivo entre directorios o bien también lo podemos usar para cambiar el nombre de los archivos y tener estas modificaciones registradas y listas para hacer el commit.
chema@lenovo:~/proyecto$ git status
On branch master
nothing to commit, working tree clean
chema@lenovo:~/proyecto$ git mv main.py ./MOVER/
chema@lenovo:~/proyecto$ git status
On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
renamed: main.py -> MOVER/main.py
Ignorar Cambios.
Git ve cada archivo en el árbol de trabajo como una de estas tres cosas:
- Rastreado. Un archivo que se ha preparado o confirmado previamente.
- Sin seguimiento. Un archivo que no se ha preparado ni confirmado.
- Ignorado. Un archivo que se le ha dicho explícitamente a git que ignore cualquier cambio que se produzca.
Esos archivos o directorios son aquellos que no suelen formar parte del proyecto tales como archivos de compilación o archivos temporales generados por el ordenador.
Los archivos a ignorar se buscan en un archivo especial llamado .gitignore, un archivo oculto que hay que crear en la raíz del repositorio. Este archivo debe crearse y editarse a mano cuando tengas nuevos archivos que quieras ignorar. Los archivos .gitignore contienen patrones que se comparan con los nombres de los archivos de los repositorios para determinar si deben ignorarse o no.
Se pueden usar patrones globales dentro del archivo para ampliar los casos en los que determinados archivos no deban ser incluidos. Puedes ver una buena explicación del uso de los mismos en esta página.
Ejemplo de archivo .gitignore
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
El propio archivo .gitignore necesita ser comprometido "commit" al igual que el resto.
¿Cómo evitar el rastreo de archivos a los que previamente les has hecho "commit" ?
$ git rm --cached nombre-del-archivo
Establece un archivo como "untracked file", sin seguimiento.
Saca los archivos de nuestro repositorio local y del área de staging, pero los mantiene en el disco duro, no los borra. Básicamente le dice a Git que deje de trackear el historial de cambios de estos archivos, por lo que pasaran a un estado untracked o Sin seguimiento. Si no queremos que git les vuelva a hacer seguimiento los añadiríamos al archivo .gitignore.
Revertir Cambios.
Tenemos que distinguir entre dos posibles escenarios.
A) Revertir cambios antes de que los archivos pasen al Stage.
B) Revertir cambios cuando los archivos ya están en el Stage.
- Revertir cambios antes del Stage.
$ git checkout [archivos]
Revierte cambios en archivos antes de que sean confirmados, antes de que se haga un commit nuevo y siempre que no los hayamos añadido al Stage, usando un git add.
Se vuelve a la versión del último commit o confirmación realizada. Es decir, descartamos las modificaciones que hayamos hecho en el archivo y lo devolvemos a como estaba anteriormente, en la confirmación o commit previo.
Veámoslo con un ejemplo.
Imaginemos que iniciamos un repositorio, creamos un archivo y dentro escribimos un comentario. Después lo pasamos al stage y realizamos un commit.
chema@lenovo:~/proyecto$ git init
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: git branch -m <name>
Initialized empty Git repository in /home/chema/proyecto/.git/
chema@lenovo:~/proyecto$ echo "# Primera linea del archivo" > main.py
chema@lenovo:~/proyecto$ git add main.py
chema@lenovo:~/proyecto$ git commit -m "primer commit"
[master (root-commit) ef8ab09] primer commit
1 file changed, 1 insertion(+)
create mode 100644 main.py
Ahora, imaginemos que añadimos más código al archivo. Como es un ejemplo para mostrar como funciona el comando, solamente voy a añadir dos líneas más, pero funciona igual si has tecleado miles de líneas de código.
chema@lenovo:~/proyecto$ echo "#Segunda linea añadida" >> main.py
chema@lenovo:~/proyecto$ echo "#Tercera linea añadida" >> main.py
chema@lenovo:~/proyecto$ cat main.py
# Primera linea del archivo
#Segunda linea añadida
#Tercera linea añadida
Ahora me doy cuenta de que en el archivo hay un error y no recuerdo como estaba originalmente cuando funcionaba. Lo que necesito es deshacer lo que he hecho desde la última vez que guarde los cambios.
Lo único que hay que hacer es usar, el comando $ git checkout main.py
chema@lenovo:~/proyecto$ git checkout main.py
Updated 1 path from the index
chema@lenovo:~/proyecto$ cat main.py
# Primera linea del archivo
Y volvemos al estado original.
Otro ejemplo. Supongamos que tenemos un programa con un montón de archivos y directorios. Como todo funciona bien hacemos un commit del repositorio y seguimos programando. Cuando llevamos algunas líneas de código lo volvemos a probar y algo no va. No sabemos donde puede estar el bug pero si sabemos que la ultima versión que teníamos funcionaba. Decidimos empezar otra vez y volvemos a la anterior versión que era estable. Para ello usamos:
$ git checkout .
(no se si se ve pero al final hay un punto.)
Al escribir este comando de esta forma le decimos que vuelva a la última versión, a la versión previa.
En git esto es volver al commit previo.
- Revertir los cambios cuando ya hemos añadido esos archivos al Stage.
$ git reset HEAD <archivos>
Así como el comando anterior nos permitía revertir cambios a archivos modificados antes de que pasaran al Stage, este comando nos permite deshacer cambios que ya estén en el Stage bien porque ya hayamos hecho, por ejemplo un git add . o un git add *.
Es decir lo que nos permite es pasar archivos, que ya estaban en el Stage preparados para hacer un commit, al árbol de trabajo de nuevo. En definitiva sacar esos archivos del Stage.
Veámoslo con un ejemplo.
Partimos del ejemplo anterior y le añadimos un cuarto comentario al archivo. Después, aunque solamente tenemos un archivo, lo añadimos al stage. Entonces nos damos cuenta de que queremos cambiar algo antes de hacer el commit con lo que usamos este comando para devolver el archivo, al árbol de trabajo.
chema@lenovo:~/proyecto$ echo "Cuarta linea añadida" >> main.py
chema@lenovo:~/proyecto$ git add *
chema@lenovo:~/proyecto$ git status
On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
modified: main.py
chema@lenovo:~/proyecto$ git reset HEAD main.py
Unstaged changes after reset:
M main.py
chema@lenovo:~/proyecto$ cat main.py
# Primera linea del archivo
Cuarta linea añadida
chema@lenovo:~/proyecto$ git status
On branch master
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: main.py
no changes added to commit (use "git add" and/or "git commit -a")Que quede claro que no se modifica el archivo, simplemente lo saca del Stage y lo devuelve al árbol de trabajo para que podamos trabajar con el. (Aunque si coges ese archivo y lo modificas antes de hacer un commit también lo sacarás del Stage porque habrás hecho una modificación que no has confirmado)
Comandos equivalentes son:
$ git restore --staged <archivos>
$ git reset -p En este caso nos pedirá confirmación paso a paso de las acciones a realizar.
- Revertir los cambios si ya hemos hecho un commit.
Si ya hemos realizado una instantánea del repositorio al realizar un commit y queremos anularlo, podemos hacerlo de diversas formas dependiendo de lo que queramos conseguir.
A) Cambiando el último commit:
$ git commit --amend
Es la forma conveniente de modificar la confirmación más reciente. Sobrescribe el commit previo, es decir, se añade lo que ya tengamos en esa instantánea con lo que tengamos actualmente en el Stage. Si no hemos añadido o modificado nada, se puede utilizar simplemente para editar el mensaje de confirmación anterior sin cambiar su instantánea.
SOLAMENTE USALO EN COMMITS LOCALES porque borra el historial del último commit que en proyectos en grupo podría haber realizado otra persona. Las confirmaciones modificadas son en realidad confirmaciones completamente nuevas y la confirmación anterior ya no aparecerá.
Por ejemplo. Digamos que acabamos de realizar una confirmación (commit) y cometimos un error en el mensaje de confirmación. Ejecutar este comando cuando no hay nada todavía nuevo preparado, que esté en el Stage, nos permite modificar el anterior mensaje de confirmación anterior sin alterar su instantánea.
chema@lenovo:~/proyecto$ git log
commit 2f08687ba8e43dbd7d40d0405108a841c97c69a9 (HEAD -> master)
Author: usuario <usuario@correo.es>
Date: Thu Sep 22 19:33:06 2022 +0200
primer commit. Contiene un error.
chema@lenovo:~/proyecto$ git commit --amend -m "primer commit. Error Subsanado."
[master c5ecfed] primer commit. Error Subsanado.
Date: Thu Sep 22 19:33:06 2022 +0200
1 file changed, 1 insertion(+)
create mode 100644 main.py
chema@lenovo:~/proyecto$ git log
commit c5ecfed30cff8625efd54e1ea136906ef2cca50d (HEAD -> master)
Author: usuario <usuario@correo.es>
Date: Thu Sep 22 19:33:06 2022 +0200
primer commit. Error Subsanado.
Si te fijas es cierto que hemos modificado el mensaje de la confirmación, pero si miras bien verás que el número del commit (en negrita) también es distinto.
Otro ejemplo habitual. Digamos que hemos editado algunos archivos que nos gustaría confirmar en una sola instantánea, pero luego nos damos cuenta de que se nos ha olvidado añadir uno de los archivos la primera vez. Bastará con prepara el nuevo archivo, añadirlo al Stage y usar este comando.
chema@lenovo:~/proyecto$ git log
commit 2ebf529db3565c2c9a26f9fa65ef5ffcc6fc3d5d (HEAD -> master)
Author: usuario <usuario@correo.es>
Date: Fri Sep 23 17:33:07 2022 +0200
primer commit
chema@lenovo:~/proyecto$ > archivo_añadir
chema@lenovo:~/proyecto$ git add archivo_añadir
chema@lenovo:~/proyecto$ git commit --amend -m "Primer commit con archivo olvidado añadido"
chema@lenovo:~/proyecto$ git show
commit 1b9aa03962422e4cf73c5496ec66557901c81e8f (HEAD -> master)
Author: usuario <usuario@correo.es>
Date: Fri Sep 23 17:33:07 2022 +0200
primer commit. Con archivo olvidado añadido
B) Revertir un commit por completo. (ROLL BACK)
$ git revert HEAD
Crea un nuevo commit que es justo la inversa del último, con lo que volvemos al estado del anterior. Sin embargo esta acción no sobrescribe el commit previo ni lo elimina del historial.
* Estado del archivo en la última instantánea.
chema@lenovo:~/proyecto$ cat main.py
# Primera linea del archivo
#!/usr/bin/env python3
import math
* Deshacemos los cambios
chema@lenovo:~/proyecto$ git revert HEAD
[master 7d7e430] Revert "muevo commit"
1 file changed, 2 deletions(-)
chema@lenovo:~/proyecto$ cat main.py
# Primera linea del archivo
* El último commit es el inverso del anterior.
chema@lenovo:~/proyecto$ git log
commit 7d7e43071d1b48ea76ba6f0ab99e0e1732e688ea (HEAD -> master)
Author: usuario <usuario@correo.es>
Date: Fri Sep 23 19:53:05 2022 +0200
Revert "nuevo commit"
This reverts commit 7b0418f9029abea87808f019f0683bc6b70ec709.
commit 7b0418f9029abea87808f019f0683bc6b70ec709
Author: usuario <usuario@correo.es>
Date: Fri Sep 23 19:51:59 2022 +0200
muevo commit
C) Revertir un commit por completo que no sea el último.
El Id es el código alfanumérico muy largo que aparece al lado de la palabra commit. Lo calcula el programa con el algoritmo SHA1. Sirve para garantizar que la integridad del commit y que ese commit es único.
En el ejemplo anterior el ID del primer commit es 7b0418f9029abea87808f019f0683bc6b70ec709
$ git revert <ID del commit>
Este comando desharía los cambios de esa instantánea en concreto, pero ojo que esto nos puede dar dolores de cabeza el revertir cambios anteriores que ya estaban consolidados.
Borrar todos los commits posteriores a uno previo.
$ git reset --hard <id o sha del commit>
Se BORRAN PARA SIEMPRE todos los commits más nuevos y se recupera el repositorio al estado del que hemos ido.
Movernos entre distintos commits.
En ocasiones nos interesa movernos atrás en el tiempo para ver como estaba un repositorio en un momento concreto.
Considera este repositorio con 4 confirmaciones.
chema@lenovo:~/Prueba$ git log --oneline
0face9c (HEAD -> main) Añadido archivo de instrucciones
e624744 añadido nuevo comando a main.py
ad3b242 Segundo commit.
5011475 Primer commit del repositorio.
Si quisiera volver, a ver como estaba el proyecto en el segundo repositorio (ad3b242) se puede usar:
$ git checkout <id del commit>
git checkout ad3b242
Note: switching to 'ad3b242'.
You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by switching back to a branch.
If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -c with the switch command. Example:
git switch -c <new-branch-name>
Or undo this operation with:
git switch -
Turn off this advice by setting config variable advice.detachedHead to false
HEAD is now at ad3b242 Segundo commit.
chema@lenovo:~/Prueba$ ls
main.py
Pero OJOOOO, que si realizas alguna modificación y la confirmas no volverás a la rama main o master que es en la que estas trabajando, si no que crearemos una nueva rama. Aunque el concepto de ramas lo veremos en los siguientes capítulos voy a hacer una modificación al repositorio y un commit para ver lo que ocurre.
Luego, si le pregunto a git cuantas ramas tengo y donde estoy, veo lo siguiente:
chema@lenovo:~/Prueba$ git branch
* (HEAD detached from ad3b242)
main
El asterisco indica en donde estoy. Para volver a donde estaba trabajando, tengo que desplazarme al último commit de mi rama principal que en mi caso se llama main (también puede aparecerte como master)
$ git checkout <rama a donde nos queremos mover>
chema@lenovo:~/Prueba$ git checkout main
Warning: you are leaving 1 commit behind, not connected to
any of your branches:
327aad6 prueba de checkout
If you want to keep it by creating a new branch, this may be a good time
to do so with:
git branch <new-branch-name> 327aad6
Switched to branch 'main'
chema@lenovo:~/Prueba$ git log --oneline
* 0face9c (HEAD -> main) Añadido archivo de instrucciones
* e624744 añadido nuevo comando a main.py
* ad3b242 Segundo commit.
* 5011475 Primer commit del repositorio.
y volvemos a donde estabamos.
