El parametro -d ayuda con el borrado de carpetas untracked. Por ejemplo: git clean -df hubiera borrado la carpeta “css - copia”
Introducción a Git
¿Por qué usar un sistema de control de versiones como Git?
¿Qué es Git?
Instalando GitBash en Windows
Instalando Git en OSX
Instalando Git en Linux
Editores de código, archivos binarios y de texto plano
Introducción a la terminal y línea de comandos
Comandos básicos en Git
Crea un repositorio de Git y haz tu primer commit
Analizar cambios en los archivos de tu proyecto con Git
¿Qué es el staging?
¿Qué es branch (rama) y cómo funciona un Merge en Git?
Volver en el tiempo en nuestro repositorio utilizando reset y checkout
Git reset vs. Git rm
Flujo de trabajo básico en Git
Flujo de trabajo básico con un repositorio remoto
Introducción a las ramas o branches de Git
Fusión de ramas con Git merge
Resolución de conflictos al hacer un merge
Trabajando con repositorios remotos en GitHub
Cómo funcionan las llaves públicas y privadas
Configura tus llaves SSH en local
Uso de GitHub
Cambios en GitHub: de master a main
Tu primer push
Git tag y versiones en Github
Manejo de ramas en GitHub
Configurar múltiples colaboradores en un repositorio de GitHub
Flujos de trabajo profesionales
Flujo de trabajo profesional: Haciendo merge de ramas de desarrollo a master
Flujo de trabajo profesional con Pull requests
Utilizando Pull Requests en GitHub
Creando un Fork, contribuyendo a un repositorio
Haciendo deployment a un servidor
Hazme un pull request
Ignorar archivos en el repositorio con .gitignore
Readme.md es una excelente práctica
Tu sitio web público con GitHub Pages
Multiples entornos de trabajo en Git
Git Rebase: reorganizando el trabajo realizado
Cómo usar Git Stash: guarda cambios temporalmente
Git Clean: limpiar tu proyecto de archivos no deseados
Git cherry-pick: traer commits antiguos al head del branch
Comandos de Git para casos de emergencia
Git Reset y Reflog: úsese en caso de emergencia
Reconstruir commits en Git con amend
Buscar en archivos y commits de Git con Grep y log
Bonus sobre Git y Github
Comandos y recursos colaborativos en Git y GitHub
Tu futuro con Git y GitHub
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
No se trata de lo que quieres comprar, sino de quién quieres ser. Invierte en tu educación con el precio especial
Antes: $249
Paga en 4 cuotas sin intereses
Termina en:
Freddy Vega
Mientras estamos trabajando en un repositorio podemos añadir archivos a él, que realmente no forma parte de nuestro directorio de trabajo, archivos que no se deberían de agregar al repositorio remoto.
El comando clean
actúa en archivos sin seguimiento, este tipo de archivos son aquellos que se encuentran en el directorio de trabajo, pero que aún no se han añadido al índice de seguimiento de repositorio con el comando add
.
$ git clean
La ejecución del comando predeterminado puede producir un error. La configuración global de Git obliga a usar la opción force
con el comando para que sea efectivo. Se trata de un importante mecanismo de seguridad ya que este comando no se puede deshacer.
$ git clean --dry-run
$ git clean -f
Git clean tiene muchísimas opciones adicionales, que puedes explorar al ver su documentación oficial.
Aporte creado por: Alex Camacho.
Aportes 248
Preguntas 27
El parametro -d ayuda con el borrado de carpetas untracked. Por ejemplo: git clean -df hubiera borrado la carpeta “css - copia”
Apuntes!
Quiero dejar bien en claro ¿cuando funciona git clean?
Git clean solo detecta archivos nuevos, no es necesario que se trate de una copia de otro archivo, suficiente con que sea un archivo nuevo que ustedes hayan creado.
**git clean --dry-run **
Simula la eliminación de archivos, ¿tienes dudas de que archivos eliminará?, ejecuta git clean --dry-run, y cuando estes seguro de que desea eliminarlos, ejecutas git clean -f
Archivos que se hayan modificado o editados git clean no interviene aquí.
Hola! Practica esto en tu repositorio, no lo olvides!
Mientras estamos trabajando en un repositorio podemos añadir archivos a él, que realmente no forma parte de nuestro directorio de trabajo, archivos que no se deberían de agregar al repositorio remoto.
El comando clean
actúa en archivos sin seguimiento, este tipo de archivos son aquellos que se encuentran en el directorio de trabajo, pero que aún no se han añadido al índice de seguimiento de repositorio con el comando add
.
$ git clean
La ejecución del comando predeterminado puede producir un error. La configuración global de Git obliga a usar la opción force
con el comando para que sea efectivo. Se trata de un importante mecanismo de seguridad ya que este comando no se puede deshacer.
→ Revisar que archivos no tienen seguimiento.
$ git clean --dry-run
→ Eliminar los archivos listados de no seguimiento.
$ git clean -f
También borrar directorios pueden hacer:
git clean -f -d
Cuando Fredy pregunto ¿por que no se borraron las imágenes? respondí “por que estan dentro de una carpeta!!” quede asi 🤡 cuando dijo que fue por el git ignore 😂😂😂
Hay que tener en cuenta que el git clean solo va a tener en cuenta los archivos que estan pendientes por adicionar, si ya le diste git add + Archivo este no le aplicara el Clean aun asi no tenga el commit.
Apuntes 🙂
Acabo de descubrir estos comando nuevos. Aquí se los dejo por si los quieren probar.
Para hacer simulaciones:
$ git clean -fn //Archivos
$ git clean -dn //Directorios
$ git clean -xn //Archivos ignorados
Para eliminar de verdad:
$ git clean -f //Archivos
$ git clean -df //Directorios
$ git clean -xf //Archivos ignorados
También se pueden combinar:
$ git clean -xdf //Eliminar los tres tipos de archivos juntos
Yo pensé que no borraba las imagenes porque son archivos binarios.
JAJAJAJAJAJAJAJAJAJA esto me hubiese servido cuando estaba haciendo el pull request, tuve que hacer un hard reset, porque se habian creado varios archivos de vim por error xDDDDD
Revisando el manuel ebook de Git, explican un comando más reducido que hace lo mismo que --dry-run
$ git clean -n
realiza la misma función que:
$ git clean --dry-run
Con estos comando solo se pueden evidenciar los archivos untracked o que no han sido seguidos por Git
$ git clean -n -d
realiza la misma función que:
$ git clean --dry-run -d
Al agregar -d el comando ya identifica si hay directorios untracked, y cuales pueden ser borrados
$ git clean -fd
Al aplicar ahora -fd se fuerza el borrado de los archivos y de los directorios que están untraked o que no tienen seguimiento por parte de Git
git clean --dry-run
: Para saber qué archivos vamos a borrar cuando estan repetidos o no son de nuestro proyectogit clean -f
: Para borrar todos los archivos listados (No borra las carpetas y lo que esta en .gitignore)git clean: quitar archivos no trackeados
git clean --dry-run: prueba en seco revisa los archicos antes de borrarlos
git clean -f: borra los archivos que pasan por prueba en seco
No borra: carpetas y archivos ignorados por .gitignore
******************************************************
*************LIMPIAR ARCHIVOS NO DESEADOS*************
******************************************************
git clean --dry-run (ver que se va a borrar)
git clean -f (borrar)
******************************************************
*************LIMPIAR ARCHIVOS NO DESEADOS*************
******************************************************```
🐱💻 git clean permite eliminar los archivos sin seguimiento en un directorio de trabajo del repositorio.
Al momento de limpiar nuestro repositorio, una buena práctica siempre es ejecutar el git clean con la opción –dry-run y visualizar que archivos se van a eliminar.
git clean --dry-run
También se puede con la opción -n que es exactamente lo mismo
git clean -n
También si se desea puede usarse el stash, para de esa manera si llegamos a borrar algo que luego necesitemos, podremos recuperarlo sin problema.
git stash --all
Luego si ya estamos completamente seguros de lo que borramos, podremos hacer un clear al stash de git o borrar el stash con el identificador específico si se tienen más en esta área.
git stash clear
ó
git stash drop stash@{id}
Usas el comando git clean si tienes archivos que no has agregado y los quieres borrar.
Este comando funciona para detectar los archivos nuevos (Untracked) y eliminarlos. Este comando no detecta los archivos incluídos en el .gitignore.
yo que me habia re olvidado del .gitignore
Con los siguientes parametros puedes borrar folder y archivos que están dentro de gitignore:
git clean -f -d -x
-f – required when clean.requireForce is true (default)
-d – also remove untracked directories
-x – also remove ignored files
Un dato curioso es que por la misma funcionalidad de git que solamente le importan los archivos, en los frameworks se manejan scaffoldings, en los cuales es necesario que existan las carpetas aunque estas no contengan archivos, esto para respetar la estructura del framework.
La forma de respetar este scaffolding es creando un archivo, por buena practica, crean un archivo .gitkeep
que en realidad podria llamarse como sea y ser de cualquier tipo de extensión.
Clase #36
Git clean: limpiar mi proyecto de archivos no deseados.
Archivos que no deben ser agregados a los repositorios en el trabajo:
.log
Resultado de compilación
Imegenes sueltas
Ejemplo:
Ejecución en seco:
git clean
Nos va a simular que es lo que se va a borrar pero no lo borra totalmente, nos da como una idea de lo que se borrara
Con este comando lo borra de la carpeta:
git clean --dry-run
A git no le importan las carpetas, le importan los archivos, por ese motivo no elimino la carpeta css:
Esta carpeta se debe borrar a mano, ya que git no la eliminara.
Las imágenes no fueron borradas por que son ignoradas por git ya que son formato .jpg
No me acordaba del git ignore, pensé que era porque eran archivos binarios jaja, pero excelente saber que se puede usar para esto
aparte de mi, quien mas se sintió felíz de haber respondido la pregunta de freddy? salté de emoción xd
--------------------------git Clean---------------------------------------
Este comando es para borrar archivos que tiene muchas copias en una solo carpeta con el mismo nombre
git clean --dry-run : esto se trata en ejecución en seco lo que buscar y indicar los archivos que se van a borrar.
git clean -f : este comando borra todos los archivos que son copias.
“git clean -f” solo borra archivos sueltos. Si quieres borrar un archivo dentro de una carpeta, primero hay que entrar en esa carpeta y luego ejecutar el comando para borrarlo.
Genial!
Ya no tendré que borrar ciertos archivos de manera manual :’)
IMPORTANTE Estos comandos borran unicamente archivos a git no le importa los directorios que tengas en copia y todo lo demas sino que va diractamente a los archivos, Ademas git clean solamente borra las cosas que puede indexar lo que es decir si hay tipos de archivos que estan en .gitignore no los tomara.
-d
Normally, when no <path> is specified, git clean will not recurse into untracked directories to avoid removing too much. Specify -d to have it recurse into such directories as well. If any paths are specified, -d is irrelevant; all untracked files matching the specified paths (with exceptions for nested git directories mentioned under --force) will be removed.
-f
–force
If the Git configuration variable clean.requireForce is not set to false, git clean will refuse to delete files or directories unless given -f or -i. Git will refuse to modify untracked nested git repositories (directories with a .git subdirectory) unless a second -f is given.
-i
–interactive
Show what would be done and clean files interactively. See “Interactive mode” for details.
-n
–dry-run
Don’t actually remove anything, just show what would be done.
-q
–quiet
Be quiet, only report errors, but not the files that are successfully removed.
-e <pattern>
–exclude=<pattern>
Use the given exclude pattern in addition to the standard ignore rules
-X
Remove only files ignored by Git. This may be useful to rebuild everything from scratch, but keep manually created files.
Git clean: limpiar el proyecto de archivos no deseados
Permite borrar archivos innecesarios que no esten agregados a un commit, como por ejemplo archivos duplicados.
git clean --dry-run # "Correr en seco" Simula la ejecución del comando para ver que archivos va a borrar
git clean -f # Borra los archivos listados en el comando anterior
git clean -df # Pemite borrar también carpetas duplicadas
Comandos utiles de git clean:
git clean --dry-run
# Con este comando es como una simulación, donde te avisa que archivo va a eliminar si aplicas un clean completo.
git clean -n
#Versión abreviada de git --dry-run
git clean -f
#Eliminar todos los archivos untracked listados ahora si (que no sean carpetas o archivos ignorados)
git clean -f -d
# Eliminar los archivos untracked listados, agregando el -d le decimos que también las carpetas que se vuelvan vacias como resultado de eliminar los archivos con el argumento de -f
git clean -x
# Borra las copias incluyendo las que están dentro de un .gitignore
git clean -X
# Borra solamente los archivos ignorados por git
git clean -q
# Muestra los errores que tuvo la ejecución, pero no los archivos que fueron borrados
git clean -i
#Modo interactivo de git clean
git clean
lo usamos para eliminar los archivos repetidos. Sólo son borrados los archivos que están trackeados, y sólo se borra los archivos que puede indexar.git clean --dry-run
para simular los archivos la lista de archivos que eliminará.git clean -f
para realizar el borrado de los archivos repetidos.Para saber qué archivos vamos a borrar tecleamos git clean --dry-run
Para borrar todos los archivos listados (que no son carpetas) tecleamos git clean -f
esto va a ser muy util
git clean --dry-run : Simula lo que se va a Borrar
git clean -f :Se borra lo se simuló anteriormente
A git le importan los archivos!!! no las carpetas!!!
Para hacerlo es recomendable primero hacer una “simulación” de lo que se va a eliminar, en otras palabras mostrar la lista de archivos que se van a eliminar. Esto se realiza con uno de estos comandos:
git clean --dry-run
ogit clean -n
Para después eliminarlos con:
git clean --force
ogit clean -f
Estos comandos limpian nuestro directorio de trabajo de aquellos archivos que no han sido agregados al repositorio (untracked files) pero no elimina aquellas carpetas que sean nuevas en el repositorio.
Eliminar carpetas
Para eliminar carpetas que no han sido agregadas al repositorio se debe de agregar la bandera
-d
:Para ver la lista de lo que se eliminara incluyendo las carpetas se ejecuta:
git clean --dry-run -d
ogit clean -nd
para eliminar se ejecuta:
git clean --force -d
ogit clean -fd
Eliminar archivos ignorados
De igual manera para ver el listado se puede:
Listar únicamente los archivos ignorados
git clean -nX
Listar archivos untracked y los archivos ignorados
git clean -nx
Listar archivos untracked, los archivos ignorados y directorios
git clean -ndx
Para eliminar:
Eliminar únicamente los archivos ignorados
git clean -fX
Eliminar archivos untracked y los archivos ignorados
git clean -fx
Eliminar archivos untracked, los archivos ignorados y directorios
git clean -fdx
Eliminar sin imprimir en pantalla los archivos eliminados
git clean --force --quiet
ogit clean -fq
git clean
es un método útil para eliminar los archivos sin seguimiento en un directorio de trabajo del repositorio. Los archivos sin seguimiento son aquellos que se encuentran en el directorio del repositorio, pero que no se han añadido al índice del repositorio con git add
. De manera general, el efecto de git clean
se puede lograr usando git status
y las herramientas de eliminación nativas de los sistemas operativos. git clean
se puede usar junto con git reset
para deshacer por completo las incorporaciones y confirmaciones en un repositorio.
¿Para qué nos sirve el comando git clean --dry-run?
¿Para qué sirve el comando git clean -f?
¿git borra copias de carpetas previamente traqueadas con el comando git clean?
¿git clean borra archivos que cuya extensión se haya especificado en el archivo .gitignore?
Git Clean
git clean [-d] [-f] [-i] [-n] [-q] [-e <pattern>] [-x | -X] [--] <path>
Parámetros
- -d Elimine directorios sin seguimiento además de archivos sin seguimiento. Si un directorio sin seguimiento es administrado por un repositorio de Git diferente, no se elimina de forma predeterminada. Use la opción -f dos veces si realmente desea eliminar dicho directorio.
-f, --fuerza Si la variable de configuración de Git limpia. requireForceno está configurado como falso, git clean se negará a eliminar archivos o directorios a menos que se le proporcione -f, -n o -i. Git se negará a eliminar directorios con subdirectorio o archivo .git a menos que se proporcione una segunda -f.
-i, --interactivo Solicita de forma interactiva la eliminación de cada archivo.
-n, --ejecución en seco Solo muestra una lista de archivos que se eliminarán, sin eliminarlos realmente.
-q,--tranquilo Solo muestra errores, no la lista de archivos eliminados con éxito.
Git Clean: limpiar tu proyecto de archivos no deseados
En ocasiones tenemos ciertos archivos o carpetas nuevas en nuestro proyecto y queremos eliminarlas, git tiene un comando especial para ayudarnos a mantener nuestro proyecto limpio: git clean.
• git clean –dry-run: nos da una vista previa de cuales van a ser los archivos que van a ser eliminados de nuestro proyecto. Solamente muestra ARCHIVOS
• git clean –dry-run -d: hace lo mismo que el comando anterior pero aquí si se muestran también los directorios y no solamente los archivos.
• git clean -f: elimina todos los archivos nuevos del proyecto
• git clean -df: elimina todos los archivos y carpetas nuevas del proyecto.
Puedes aprender más opciones de los comandos o ver su atajo con
git [comando] --help
por ejemplo
git clean --help
en el cual te dara una descripcion del comando y podras aprender mas opciones como saber que puedes eliminar carpetas con el comando
git clean -df
así como puedes acortar el comando
git clean --dry-run
a un
git clean -n
asi como también te das cuenta que tambien puedes eliminar todos los archivos ignorados ojo todos los archivos ignorados con el comando
git clean -Xf
cuando has copiado una carpeta con archivos trackeados en ella, puedes llegar a ver un confusión, debido a que no se borra y en caso de que quieras hacer, la última desición que puedes tomar, es borrar los manualmente, ya que git no los reconoce como basura (porque están trackeados) sin importar si están en una carpeta diferente o no.
Muy divertida la clase, te anima para nunca parar de aprender.
Cuando queremos borrar archivos que no son de nuestro proyecto
(git clean --dry-run) nos dira que archivos seran borrados y despues (git clean -f) borrara los archivos excepto las carpetas y los que esten .gitignore y para borrar carpetas (git clean -df)
Y si esos archivos ya están en mi directorio local, o sea ya los “trakee”, hay alguna manera de poder borrarlos?
No se borraron porque con .gitignore se ignoraron los archivos .jpg
Nunca se me occurrio que no borro los archivos .jpg por el .gitignore
*Lista los archivos que serán eliminados.
git clean --dry-run
*Fuerza el borrado de los archivos que no deseas agregar.
git clean -f
Si alguna vez quieres ver que haría, puedes ejecutar el comando con la opción -n que significa ‘`haz un arranque en seco y dime que habrías eliminado '’.
Yo creí que no los habia borrado porque estaban en otra carpeta XD
Listo
git clean --dry-run
git clean -f
Comandos muy buenos. Vamos a Notion 😄
git clean solamente borra las cosas que puede indexar
Muy intersante, cada vez más herramientas.
Esta herramienta es especialmente útil para lenguajes compilados que generan estos archivos ejecutables que no es necesario que sean subidos en un commit. Impresionantes, una clase de 3 minutos con un comando tan útil.
git clean --dry-run muestras los archivos a borrar
git clean -f borra los archivos
nota: para borrar una carpeta cuyo contenido este vinculado con un .gitignore sera necesario hacerlo manualmente
que quiere decir con indexar
Freddy: Por qué no borró las copias de la foto?
yo: Porque es un archivo binario 😎
Freddy: Si dijiste que es por .gitignore estás en lo correcto 😄
mfw:
✅
que bien se sintio cuando responde que no se borro por .gitignore jejejeje
mi cara Cuando Fredy dijo: “tal vez pensaste que no vas a utilizar mucho el Git Stash, pero sin duda lo vas a necesitar”
git clean --dry-run
: Ejecucion en seco, --dry-run. Simula lo que se borrara sin borrarlogit clean -f
: Borra lo que te mostro que iba a borrar.Me emocione a lo que respondí correctamente por el git ignore que no borro las fotos copia
Dije en voz alta que era porque son archivos binarios xD
yo habia dicho que era por que eran binarios
git clean
se utiliza para eliminar archivos no rastreados en un repositorio. Estos archivos son aquellos que no están bajo control de versiones y no se han agregado al índice de Git.
.
Este comando no funciona solo. Por defecto, Git está configurado globalmente para requerir la opción “force” para que git clean inicie. Es un mecanismo importante de seguridad para evitar borrar archivos importantes por accidente.
.
Opciones comunes y usos:
• Dry run: con la opción -n
, git clean ejecuta una “ejecución en seco” que muestra únicamente los archivos que serán removidos.
.
• Force: con la opción -f
, git clean ejecuta el borrado forzado de los archivos no seguidos.
.
• Directory: con la opción -d
, git clean ejecuta el borrado de directorios no seguidos.
.
• All: con la opción -x
, git clean ejecuta el borrado de archivos, directorios y archivos ignorados no seguidos.
.
Estas opciones se pueden combinar para un mejor resultado como git clean -fn
que muestra que archivos serán removidos antes de borrarlos realmente.
excelente ya lo puse en practica
Mientras estamos trabajando en un repositorio podemos añadir archivos a él, que realmente no forma parte de nuestro directorio de trabajo, archivos que no se deberían de agregar al repositorio remoto.
El comando clean actúa en archivos sin seguimiento, este tipo de archivos son aquellos que se encuentran en el directorio de trabajo, pero que aún no se han añadido al índice de seguimiento de repositorio con el comando add.
git-clean
- Remove untracked files from the working tree
-n, --dry-run
- Don’t actually remove anything, just show what would be done.
-f, --force
- If the Git configuration variable clean.requireForce is not set to false, git clean
will refuse to delete files or directories unless given -f or -i. Git will refuse to modify untracked nested git repositories (directories with a .git subdirectory) unless a second -f is given.
-i, --interactive
- Show what would be done and clean files interactively. See “Interactive mode” for details.
-d
- Normally, when no <pathspec> is specified, git clean will not recurse into untracked directories to avoid removing too much. Specify -d to have it recurse into such directories as well. If a <pathspec> is specified, -d is irrelevant; all untracked files matching the specified paths (with exceptions for nested git directories mentioned under --force
) will be removed.
Este comando es una grasita
git clean -difx
Eliminara archivos y carpetas que se encuentren en untracked
de manera recursiva incluyendo a los archivos dentro del .gitignore
.
$ git clean -fn //Archivos
$ git clean -dn //Directorios
$ git clean -xn //Archivos ignorados
Recordar que hace:
git clean --dry-run
git clean -f
Es equivalente a hacer
git clean -fn
A mi también me suele pasar lo de que de puro error apreto ctrl v 7 veces
Freddy!!! Sos un Genio!!!
Este …si, por el .gitignore, si, lo tenia claro desde antes, si clarisimo. hahaha
El comando: git clean -n,
realiza la misma función que: git clean --dry-run
Excelente herramienta para la eliminación total de archivos indeseados.
Información resumida de esta clase
#EstudiantesDePlatzi
Git sabe cuál es la estructura de tu directorio de trabajo
Git clean es un comando que me ayuda a borrar archivo que no necesito en mi proyecto y por alguna razón los he creado por error
A git no le importan las carpetas, le importan los archivos
Git clean solamente borra las cosas que puede indexar
leyendo los acomentarios encontre una opinion de un compañero para borrar las carpetas, por lo tanto yo tambien descubri como hacer para mejorar el comando.
git clean -xdf
x -> es para no ignorar los archivos que estan en gitignore.
d -> para borrar las carpetas
f -> es para borrar los archivos que no tienen seguimiento (este es indispensable ponerlo)
si quieres ver los archivos que vas a eliminar usas este
git clean -xdf
n -> es para listar todos estos archivos
LIMPIAR TU PROYECTO DE ARCHIVOS NO DESEADOS
** Ver los archivos
$ git status
** Simular que se puede borrar
$ git clean --dry-run
** Borrar
$ git clean -f
*****************************************
NOTA: A git no le importa los directorios
ni imagenes solo los archivos.
*****************************************
Genial poder utilizar el git clean -df, para poder eliminar los directorios, gracias
/ clase 37 --> git clean /
git clean --> Limpia archivos no deseados.
--dry-run --> Parámetros para que funcione git clean.
-df --> Fuerza la limpieza de carpetas no deseados.
Esto es nuevo para mi, git clean muy util
git clean -f
ejecuta el borrado ya en serio.
no borrara los archivos
BORRAR ARCHIVOS CREADOS POR ERROR O QUE TE OLVIDASTE BORRAR Y PUES NO LOS ESTAS USANDO.
Y GIT SABE QUE NO ESTAN SIENDO CONECTADOS ,TRACKEADOS ,USADOS
git clean --dry-run
significa simular que lo vas a borrar
dry run significa correr en seco hace referencia a los barcos que se prueban
en seco (antes de hecharlos).
este comando te muestra los archivos que se van a borrar solo q te los
muestra como si los hubieran borrado ya.
Que interesante todo lo que se puede hacer con la consola 😃
Una función muy util es
git clean -i
con esto podemos limpiar poniendo ciertos parámetros. Mi favorita es la de filtrar por patrones
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?