Introducción a Git

1

¿Por qué usar un sistema de control de versiones como Git?

2

¿Qué es Git?

3

Instalando Git y GitBash en Windows

4

Instalando Git en OSX

5

Instalando Git en Linux

6

Editores de código, archivos binarios y de texto plano

7

Introducción a la terminal y línea de comandos

Comandos básicos en Git

8

Crea un repositorio de Git y haz tu primer commit

9

Analizar cambios en los archivos de tu proyecto con Git

10

¿Qué es el staging y los repositorios? Ciclo básico de trabajo en Git

11

¿Qué es branch (rama) y cómo funciona un Merge en Git?

12

Volver en el tiempo en nuestro repositorio utilizando reset y checkout

13

Git reset vs. Git rm

Flujo de trabajo básico en Git

14

Flujo de trabajo básico con un repositorio remoto

15

Introducción a las ramas o branches de Git

16

Fusión de ramas con Git merge

17

Resolución de conflictos al hacer un merge

Trabajando con repositorios remotos en GitHub

18

Cambios en GitHub: de master a main

19

Uso de GitHub

20

Cómo funcionan las llaves públicas y privadas

21

Configura tus llaves SSH en local

22

Conexión a GitHub con SSH

23

Tags y versiones en Git y GitHub

24

Manejo de ramas en GitHub

25

Configurar múltiples colaboradores en un repositorio de GitHub

Flujos de trabajo profesionales

26

Flujo de trabajo profesional: Haciendo merge de ramas de desarrollo a master

27

Flujo de trabajo profesional con Pull requests

28

Utilizando Pull Requests en GitHub

29

Creando un Fork, contribuyendo a un repositorio

30

Haciendo deployment a un servidor

31

Hazme un pull request

32

Ignorar archivos en el repositorio con .gitignore

33

Readme.md es una excelente práctica

34

Tu sitio web público con GitHub Pages

Multiples entornos de trabajo en Git

35

Git Rebase: reorganizando el trabajo realizado

36

Git Stash: Guardar cambios en memoria y recuperarlos después

37

Git Clean: limpiar tu proyecto de archivos no deseados

38

Git cherry-pick: traer commits viejos al head de un branch

Comandos de Git para casos de emergencia

39

Git Reset y Reflog: úsese en caso de emergencia

40

Reconstruir commits en Git con amend

41

Buscar en archivos y commits de Git con Grep y log

Bonus sobre Git y Github

42

Comandos y recursos colaborativos en Git y GitHub

43

Tu futuro con Git y GitHub

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Git Clean: limpiar tu proyecto de archivos no deseados

37/43
Recursos

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

Git clean tiene muchísimas opciones adicionales, que puedes explorar al ver su documentación oficial.

Aporte creado por: Alex Camacho.

Aportes 218

Preguntas 25

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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!

Git Clean tiene un montón de opciones.
Por ejemplo, si usas -q te mostrará solamente los errores que tuvo la ejecución, pero no los archivos que fueron borrados.
Si usas -x (En minúscula) borra las copias incluyendo las que están dentro de un .gitignore
En cambio, si usas -X (En mayúscula) borra solamente los archivos ignorados por git
Hay muchas opciones más! Y las puedes ver en la documentación de Git Clean

Limpiar el Repositorio

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 

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.

Por qué es necesario usar -f ?
-f es la forma resumida de –force y es necesario usarlo si la variable de configuración de Git clean.requireForce no está establecida en false (POR DEFECTO ES TRUE).
Si usas git clean sin argumentos y clean.requireForce está en true, entonces git se negará a borrar los archivos, tal como sucedió en el video; mostrando el siguiente mensaje:

fatal: clean.requireForce defaults to true and neither -i, -n, nor -f given; refusing to clean

-f/–force fuerza a git a limpiar estos archivos.

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 😂😂😂

Apuntes 🙂

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

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

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 --dry-run: Para saber qué archivos vamos a borrar cuando estan repetidos o no son de nuestro proyecto
  • git clean -f: Para borrar todos los archivos listados (No borra las carpetas y lo que esta en .gitignore)

Yo pensé que no borraba las imagenes porque son archivos binarios.

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 permite eliminar los archivos sin seguimiento en un directorio de trabajo del repositorio.

Usas el comando git clean si tienes archivos que no has agregado y los quieres borrar.

  • git clean --dry-run: simula lo que se va a borrar sin borrar
  • git clean -f: borra los archivos listados en la ejecución dry-run
    Por supuesto, no tomará en cuenta los archivos en .gitignore. Porque son ignorados para todo lo que tenga que ver con git 😄
    git clean solo borra las cosas que puede indexar

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}

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

--------------------------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.

<h1>Git Clean</h1>

-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.
  • git clean --dry-run = este verifica y te indica que son los archivos que se van a borrar.
  • git clean -f = Borra los archivos
  • 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!!!

aparte de mi, quien mas se sintió felíz de haber respondido la pregunta de freddy? salté de emoción xd


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

Git Clean

  • Sintaxis
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 --dry-run -df : Muestra archivos y directorios que serán eliminados.

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

Notas 📒

✏️ Git clean

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 o git clean -n

Para después eliminarlos con:

git clean --force o git 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 -do git clean -nd

para eliminar se ejecuta:

git clean --force -d o git 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 o git clean -fq

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

Muy buena clase

Esa sonrisa que todos los que pensamos que era por el gitignore tuvimos cuando Freddy lo dijo 😎

Jjajajajaja, yo feliz pensando que había acertado y zas, no es por ser un directorio distinto, sino por .gitignore. Es la 1.000.000 vez que Freddy me trolea.

Para borrar todos los archivos listados (que no son carpetas) tecleamos git clean -f

Para saber qué archivos vamos a borrar tecleamos git clean --dry-run

buen comando para cuando ya tienes un tiradero

git clean --dry-run: Para saber qué archivos vamos a borrar cuando estan repetidos o no son de nuestro proyecto
git clean -f: Para borrar todos los archivos listados (No borra las carpetas y lo que esta en .gitignore)

Git clean solo detecta archivos nuevos, no es necesario que se trate de una copia de otro archivo

muchos programas son sencillos al saber como usarlos y de que se tratan

Gracias!!

Commands

  • Remove untracked files from the working tree

    git clean -f
    

    https://git-scm.com/docs/git-clean

  • Doesn’t actually remove anything, just shows what it will be done

    git clean --dry-run
    
  • If you want to simulate what it would happen when you execute a command add:

    --dry-run
    
  • Remove untracked files and untracked directories

    git clean -fd
    
  • Remove untracked files in an interactive way

    git clean -i
    
  • Show just the errors of the execution but not the deleted files

    git clean -q
    
  • Delete even the files and copies that are ignored due to a .gitignore

    git clean -X
    

Este comando clean
me sirvió para saber que archivos no necesito en mi repositorio

git clean solo borra las cosas que puede indexar

No pude borrar imagenes usando el [ git clean --dry-run ]
En cambio logre hacer usando [git clean -f]

Interesante

git clean no le veo mucha utilidad xd

No se eliminaron por el gitIgnore

git clean solo borra las cosas que puede indexar.

git clean -f para borrar lo que está en dry run.

el flag dry run, es hacer una simulación de la supreción de los elementos que no están en stage.

dry run, es una técnica que se utiliza para testear barcos y cohetes espaciales.

git clean --dry-run o ejecución en seco.

git clean, literalmente borra los archivos

El comando git clena necesita que le demos parámetros para que este funcione correctamente, debido a que tenemos que confirmar, los que queremos borrar.

Limpieza en seco de nuestro git: git clean dry-run

luego validas si corresponde y si tomas la desicion: git clean -f

Es normal que los proyectos, terminen con muchos archivos basura. que se nos escapan.

git clean --dry-run # “Correr en seco” Simula la ejecución del comando para ver que archivos va a borrar

git clean -d

“git clean --dry-run” es lo mismo que “git clean -n”?

Freddy: Aplaudiré tres veces y tu me dices porque no se borraron las imágenes.

Yo: Porque son archivos binarios… jaja, ke hacker soy

Freddy: Porque los enlistamos en .gitignore

Yo:

Buena clase, interesante para eliminar archivos no deseados

Por un momento creí que no funcionaban porque las imágenes eran archivos binarios…