No tienes acceso a esta clase

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

Comandos de búsqueda

14/23
Recursos

A veces necesitas localizar varios archivos del mismo tipo que ocupan espacio innecesario en tu disco duro.

Por ejemplo, algunos programas que funcionan desde la consola, como npm, guardan sus errores en archivos de extensión ".log" y si no estás pendiente de eliminarlos se van acumulando en tu disco duro.

¿Cuáles son los comandos de búsqueda en la terminal?

Para encontrar archivos de forma efectiva, usa el comando find, el cual buscará en la ruta que le indiques el tipo de archivos que necesitas. Su sintaxis es:

find [rutaDesdeDondeEmpezarBuscar] [opciones]

Segmentar por el nombre (-name)

Veamos un ejemplo, voy a buscar en mi carpeta home todos los archivos que tenga una extensión ".png".

find ./ -name *.png

ejemplo-comando-name.png

El punto indica que debe empezar desde la carpeta en la que está y la opción -name es para especificar el nombre que debe buscar.

Segmentar por el tipo (-type)

También puedes segmentar por el tipo, si es un archivo o si es un directorio utilizando la opción -type, el cual acepta f para archivos, d para directorios y l para enlaces simbólicos.

Si quieres usar más de una opción lo separas por comas.

find ./ -type f -name "f*"

usar-comando-type-terminal.png

Esto me muestra todos los archivos que comiencen con la letra "f".

Veamos un ejemplo buscando archivos y directorios.

find ./ -type f,d -name "D*"

buscar-archivos-direcorios-con-comando-type-terminal.png

Segmentar por tamaño (-size)

Con la opción -size podemos segmentar por tamaño ingresando el peso que queremos buscar. Esta opción tiene un uso un tanto especial. Primero que todo hay que colocar la unidad de peso c para byte, k para Kilobyte, M para Megabyte y G para Gygabyte.

Entonces, si escribes en la terminal: find ./ -size 4k

Buscará los archivos que pesen exactamente 4kb. Pero claro, atinar el peso exacto de un archivo no es para nada sencillo, así que podemos especificar que sea ese peso en adelante con el símbolo + o de ese peso para abajo con el símbolo -.

find ./ -size +4k

Busca los archivos que pesen 4kb o más.

find ./ -size -4k Busca los archivos que pesen 4kb o menos.

Buscar vacíos (-empty)

Para buscar los archivos vacíos usamos la opción empty que es fácil de usar, no tienes que especificarle nada, solo escribirla.

Por ejemplo, si quisiera buscar todas las carpetas vacías, habría que escribir:

find ./ -type d -empty como-buscar-carpetas-vacias-en-la-terminal.png

Limitar la búsqueda (-maxdepth -mindepth)

Puede que no queramos buscar en absolutamente todas las carpetas del sistema, sino que queremos únicamente un pedacito. Para eso limitamos la profundidad de carpetas a la que el comando debe buscar, esto se hace con la opción -maxdepth seguido de la profundidad.

find ./ -type d -maxdepth 2

Continuando, a veces ya conocemos más o menos la estructura de nuestras carpetas, así que nos queremos saltar niveles, por lo que le asignamos una profundidad mínima al comando.

find ./ -type d -mindepth 2

Una última cosa, es recomendable pasar el output al comando less, así:

find ./ | less

De esta forma podrás usar esa interfaz de less para buscar tus archivos.

Tabla de comandos de búsqueda

| Opción | Función | | --- | --- | | -size | Busca por el peso | | -mindepth | Asigna una profundidad mínima | | -maxdepth | Asigna una profundidad máxima | | -type | Busca por el tipo de archivo | | -name | Busca por el nombre del archivo |

Ejercicio de práctica

El abito hace al monje y la terminal al buen programador.

Crea el comando find para cada uno de estos casos: 1. Busca tus archivos mayores a 100Mb, con una profundidad máxima de 4, que comiencen por la letra d. 2. Busca los archivos que tengan extensión ".pdf" con una profundidad mínima de 2. 3. Busca todas las carpetas que comiencen por la letra "A" con una profundidad máxima de 5, que estén vacías. 4. Busca todo lo que tenga una letra "j" que pese más de 1b. Luego guarda la salida en un archivo llamado "LosArchivosJ.txt" y cuando termine de hacer todo eso imprime un mensaje que diga "Comando terminado con éxito".

Profundiza tus conocimientos: ¿qué es un comando?

Contribución creada por: Miguel Gonzalez.

Aportes 1027

Preguntas 113

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Hay otro comando que no se vio en esta clase MUY interesante 👀.
.
Este es el comando whereis (en español: ¿dónde está?), este comando es algo similar a which, pero mucho mejor. Este comando localiza los ficheros binarios, fuentes y páginas del manual de un programa, es decir, podemos decir que hace algo así como una “búsqueda mucho más profunda”, me encanta porque puedes saberlo casi todo sobre la ubicación de un programa 😄.
.
Adicionalmente, find es uno de esos comandos que más amo con toda mi vida, ya puse un ejemplo usando find en una clase anterior, pero es que es un comando muy bueno! A modo de anécdota, una vez me pasaron un archivo… escondido entre un montón de carpetas, sí, una carpeta dentro de otra, dentro de otra, y al lado otras 10 carpetas más… ¿qué hice? usé el comando find 👀. Ventajas se saber usar la terminal, ¡y ahora tú también sabes usarla! 😄

<h3>Reto:</h3>
find ~ -type f -name '*.txt' > ./Developer/term/misarchivosdetexto.txt && cowsay "Archivos guardados exitosamuuuuuente" | lolcat
// Y para abrirlo 
cat Developer/term/misarchivosdetexto | lolcat

Banderas del comando find
Banderas básicas:

  • -name: Realiza una búsqueda por nombre de archivo.
  • -iname: Realiza una búsqueda por nombre de archivo sin tomar en cuenta las mayúsculas o minúsculas.
  • -type: Realiza una búsqueda por tipo de archivo, f(files) y d(directories) que son los más comunes.
  • -size: Realiza una búsqueda por el tamaño de archivo y/o directorio.

Banderas de tiempo⏰

  • mmin: Búsqueda por tiempo en minutos.
  • mtime: Búsqueda por tiempo en días.

Más banderas👀

  • -maxdepth: Después de está bandera se pone el número de niveles de profundidad en los que queremos realizar la búsqueda
  • -empty: Realiza una búsqueda de archivos y/o directorios vacíos.
  • -perm: Búsqueda de archivos por permisos.
  • -not: Retorna los resultados que no coinciden con la búsqueda.
  • -delete: Está bandera se coloca al final del comando, eliminara los resultados de la busqueda(⚠️Hay que tener mucho cuidado al usarla).

Hay muchas más banderas, pero esas son las que me parecieron más útiles.
.
Ejemplos:
A continuación pondré unos cuantos ejemplos de las banderas mencionadas anteriormente.
.

Búsqueda de todos los archivos con el permiso 644 a partir del directorio actual con una profundidad de 2 niveles.

find . -perm 644 -maxdepth 2

.
Búsqueda de archivos vacíos a partir del directorio actual.

find . -type f -empty

.
Búsqueda de todos los archivos .log, todos los resultados serán eliminados.

find . -type d -iname "*.log" -delete   

.
Para este aporte use como referencia algunas clases y aportes del curso pasado, así como también conocimientos propios, dejo los link de referencia por si quieren verlo más a fondo(están en inglés):
Link 1
Link 2
Espero que les sea de ayuda, 💚 si te ayudo.

find ./ -name '*.txt' > text_docs.txt && echo "Files saved succesfully"

Para los que usan zsh deben ingresar el wildcard entre comillas:

'*.txt'

Notas 😄
Comandos de búsqueda

  • Es una de las partes mas interesantes de la terminal, ya que nos permite buscar archivos de manera eficiente y específica 💫.
  • which <programa> Busca en todas las rutas del PATH para encontrar donde está alojado algún archivo binario 🔢.
  • find <ruta inicial> -name <archivo> Nos permite encontrar un archivo a partir de una ruta inicial, y dentro de todas las carpetas que surjan de ese inicio 🌲.
    • Algo muy cool es que podemos usar wildcards para hacer mas eficiente la búsqueda 🔍.
    • find <ruta inicial> -type <tipo> -name <nombre> podemos especificar el tipo de archivo, d → directorio, f → documento.
    • find <ruta inicial> -size <tamaño><unidad> podemos buscar tamaños mayores a un determinado tamaño, por ejemplo, de 20M (megas).
  • Solución al reto: find ./ -name *.txt -type f -size 1M > mis_archivos_texto.txt | echo "archivos guardadados exitosamente"

Para los que no les funcione el comando find por algo como:

find: paths must precede expression: `Developer'
find: possible unquoted pattern after predicate `-name'?

Deben de poner el nombre entre comillas dobles o simples '' o "" como el siguiente ejemplo

find ./ -type d -name "[[:upper:]]*"

Para encontrar todos los directorios los cuales sus nombres comiencen con mayúscula

Para los usuarios que usen zsh:

El archivo o directorio que desean buscar, debe estar entre comillas simples:

find ./ -name ' *.txt '

✨ Las herramientas de búsqueda de archivos, son de gran utilidad a medida que pasa el tiempo.

Reto:

find ./home/ *.txt > my_txt_documents.txt && echo 'my_txt_documents.txt created'

Para buscar en que carpeta tenemos más archivos pesados mediante una interfaz grafica desde la terminal, pueden instalar Ncdu, a mi me facilito mucho la administración de archivos:
(Recomiendo ponerle un alias, ya que el nombre ncdu para mi me es difícil de recordar)
url: https://dev.yorhel.nl/ncdu/man
![](

13. Comandos de búsqueda:

Les comparto los comandos aprendidos en clase:

  1. which : Busca la ubicacion de un archivo.
  2. find : Para encontrar archivos.

Ejemplos con find:

  1. find ./ -type d -name Documents
  2. find ./ f -type f -name *.log
  3. find ./ -size 20M

Cuidado porque cuando usé el comando busco literalmente en todo mi disco xD (estoy usando WSL).

Desconocía el poder de find.

Podríamos encontrar por ejemplo directorios vacíos:

$ find ./ -type d -empty

Fuente

Usé este comando para borrar todos los node_modules en el directorio donde pongo mis proyectos y funcionó.
Creo que hay que tener cuidado de no ejecutarlo en la raíz porque creo que pueden borrar las dependencias instaladas de forma global

find . -type d -name node_modules -exec rm -rf {} \;

Les comparto mis apuntes, espero le sirva. 😄

Comandos de búsqueda

Estos nos ayudan a buscar archivos o directorios (se pueden filtrar) dependiendo su extensión, nombre, ubicación, etc.

.log

Son archivos de texto plano que recopilan normalmente la información de un archivo en ejecución.

Por ejemplo cuando Google Chrome se está ejecutando crea un archivo .log para ver las páginas que visitamos, si hay errores en el sistema, etc.

Estos archivos llegan a ser molestos y hay que borrarlos.

Buscar archivos .log en la terminal

$ find [punto de partida] -type f -name *.log

which

Nos ayuda buscar la ruta de nuestros binarios, lo busca en toda la ruta del path.

$ witch [comando o ejecutable]

find

Nos permite encontrar un archivo, lo primero que recibe es la ruta desde donde va a buscar el archivo.

El comando find es uno de los más versátiles que podemos encontrar en la terminal, a través de sus diferentes opciones podemos realizar diferentes tipos de búsquedas.

Tiene una opción especial que es exec una vez terminada la búsqueda, nos permite ejecutar un comando.

Funciona bien el shell bash tal como en la clase en zsy hay que colocarle '' a lo que tratamos de buscar.

En caso de que no funcione el comando tratemos de colocarle comillas simple a lo que se está buscando

$ find [punto de partida] [opcion] [archivo o directorio]
$ find [punto de partida] [opcion] '[archivo o directorio]'

-name: Va a buscar por nombre.

Ejemplo

$ find . -name file

Wildcards

$ find . -name *.txt 

Pipes operator

$ find . -name *.txt | less

Operadores

-type: Busca por tipos y este tiene dos argumentos.

f: Solamente busca files o archivos.

d: Solamente busca directorios.

$ find [punto de partida] -type [argumentos de type] [opcion] [archivo o directorio]

#Ejemplo
$ find . -type d -name Platzi

-size: Busca por tamaño de archivo.

$ find [punto de partida] -size tamaño

#Ejemplo
$ find . -size 20M

Les comparto mis apuntes del mismo curso pero del 2019

locate

Es una herramienta que nos permite hacer una búsqueda en todo nuestro sistema de archivos simplemente diciendo el nombre de un archivo que buscamos.

Instalar locate

$ sudo apt install mlocate # si no funciona usamos solamente "locate" en vez de "mlocate"

Actualizar la base de datos

locate funciona mediante una base de datos que tiene que ser explícitamente actualizada periódicamente, caso contrario los archivos no se encuentran.

$ sudo updatedb

Usando locate

locate archivoABuscar

whereis

Este se usa para ubicar archivos binarios o sea comandos.

$ whereis comando

Nos muestra la ruta en donde se ubica el comando que buscamos también podemos encontrar las máquinas del manual del comando.

find

Lo que hace es buscar dentro de un árbol de directorios, de donde le indiquemos que comience, utilizando una serie de criterios.

-perm xxx: quiere decir con los permisos xxx.

$ find lugarDeBusqueda -user nombreDelUsuario -perm permisosEnNumeros

# Ejemplo
find . -user galeedgutierrez -perm 700

Este ejemplo que acabamos de ver nos muestra los archivos que pertenezcan al usuario X, ubicados en cierto directorio con los permisos que le indiquemos.

Buscar solamente archivos

-type f: quiere decir que solo busque archivos.

-mtime Xtime: quiere decir cierta cosa que se halla modificado en un tiempo X.

$ find lugarDeBusqueda -type f -mtime tiempoEnDias

Hacer algo con los archivos encontrados ejemplo

$ find . -type f -mtime +7 -exec cp {} ./backup/ \;

Este comando copia todos los archivos encontrados, cuya última modificación fue hace más de 7 días, al directorio backup.

$ find /home -type f -name '*.txt' | tee 'Mis archivos de texto en home.txt' && echo "Archivos guardados con exito"

Encontrar la ruta de nuestros archivos binarios con “which”

$ which <mi binario>

$ which ping
/usr/bin/code
$ which code
/usr/bin/code
$ which vi
/usr/bin/vi

Encontrar un directorio con “find”

- Buscar todos los directorios que se llamen file:
	$ find ./ -name file

- Buscar todos los archivos que se llamen file.txt:
	$ find ./ -name file.txt

- Buscar todos los archivos con extensión .html:
	$ find ./ -name *.html

Buscar solo directorios llamados “sandbox”

$ find ./ -type d -name sandbox

Buscar solo archivos llamados “data”

$ find ./ -type f -name data
$ find ./ -type f -name data.* # si tiene extensión

Buscar solo archivos de extension “.log”

$ find ./ -type f *.log

Buscar archivos por tamaño:

$ find ./ -size 20M

coloco esto porque veo que muchos entendieron mal el find (no queda muy claro en el video), por eso siempre hay qué hacer pruebas con cada comando y leer otros foros:
la definición de find está mala, find no comienza a buscar desde la ruta inicial, busca desde el directorio actual pero la dirección que devuelve está escrita desde la ruta inicial. la solución al reto que muchos han publicado solo funciona si la ubicación actual es el home
en mi github estoy guardando toda la información con las pruebas que he hecho para quienes quieran leerla, también están los enlaces de donde saqué alguna información. tienen qué tener cuidado porque en el tiempo que llevo en platzi he visto que a los cursos les falta mucha profundidad. si no buscan por cuenta propia van a quedar con conceptos malos y muy al aire. la única forma de entender como funciona cada comando es usandolo y haciendo pruebas.
https://github.com/koyomi-san/terminal/blob/main/comandos.txt

Comandos de búsqueda
Nos sirven para encontrar archivos y directorios, dependiendo su ext. Nombre, ubicación, etc.

  • which ‘archivo’ : nos busca los archivos binarios en la ruta de PATH

  • find ‘rutaInicialDeBusqueda’ -name ‘nombreDelArchivo’: nos permite encontrar un archivo según la ruta indicada y el nombre.

  • find ‘rutaInicialDeBusqueda’ -name *.’extencion’ : nos permite buscar los archivos según la extencion desde la ruta indicada, en este caso se usa wildcards

  • find ‘rutaInicialDeBusqueda’ -type ‘fd’ name’nombreDelArchivo’ : type nos permite segmentar por f (files) o d (directorios)

  • find ‘rutaInicialDeBusqueda’ -size ‘tamañoYUnidadDeMedida’: busqueda por tamaño del archivo

Reto:

find /Users/bri/Documents -type f -name "*.txt" > txtarchivos.txt && echo "archivos guardados exitosamente" >echo.txt

Al ejecutar find ./ -name *.txt si tuvieron el siguiente error:

find: paths must precede expression: `archivo.txt'
find: possible unquoted pattern after predicate `-name'?

Solo tienen queue agregar comillas a la wildcard, o sea, ejecutarlo así:
find ./ -name "*.txt"
Pueden leer un poco más aquí: https://stackoverflow.com/questions/6495501/find-paths-must-precede-expression-how-do-i-specify-a-recursive-search-that

Hola a todos, fui recopilando todos los comandos de la Terminal y sus descripciones, las compartí en Github para que puedas verlas, copiarlas y/o modificarlas
https://github.com/SuKuShaing/ComandosDeGit/blob/main/ComandosTerminalLinux.txt

Reto

 find ~ -name "*.txt" > archivosDeTexto.txt && cowsay "Se guardaron los archivos :)"|lolcat
cat archivosDeTexto.txt|lolcat

🔨 Mi solución al reto:

find ./ -type f -name "*.txt" | tee misArchivos.txt && echo "Archivos guardados"

Los ejercicios de RECURSOS

  1. Busca tus archivos mayores a 100Mb, con una profundidad máxima de 4, que comiencen por la letra d.
    find /mnt/c/Users/kboss/ -maxdepth 4 -type f -size +100M -name 'd*'
    find /mnt/c/Users/kboss/ -maxdepth 4 -type f -size +10M -name 'd*'
    
    Lo busque con menos peso por que no encontraba nada 😅
  2. Busca los archivos que tengan extensión “.pdf” con una profundidad mínima de 2.
    find /mnt/c/Users/kboss/ -mindepth 2 -type f -name '*.pdf'
    
  3. Busca todas las carpetas que comiencen por la letra “A” con una profundidad máxima de 5, que estén vacías.
    find /mnt/c/Users/kboss/ -maxdepth 5 -type d -name 'A*' -empty
    
  4. Busca todo lo que tenga una letra “j” que pese más de 1b. Luego guarda la salida en un archivo llamado “LosArchivosJ.txt” y cuando termine de hacer todo eso imprime un mensaje que diga “Comando terminado con éxito”.
    find /mnt/c/Users/kboss/Documents/ -size +1b -name '*j*' > /mnt/c/Users/kboss/Documents/Github/intro-termial/04-find/LosArchivosJ.txt && echo 'Comando terminado con éxito'
    

El reto

El reto cumplido

Cuando el profesor menciona que buscara todos los archivos mayoras a 20 MB, en realidad esta buscando los archivos que pesan 20 Mb aprox, para los mayores a 20 MB seria

find ./ -size +20M

y para archivos menores a 20 MB

find ./ -size -20M

En Ubuntu, si tienen algún problemas de permisos denegados se puede realizar el reto usando sudo como lo dejo a continuación:

sudo find $HOME -type f -name “*.txt” > my-search.txt && echo “Archivos guardados con éxito”

Mi solución al reto:

find /home -name *.txt && touch misDocumentosDeTexto.txt | echo "archivos guardados exitosamente"```

en zsh la wildcard en el find no funciona si no se pone entre comillas deberia quedar asi el comando en zsh

find ./ -name '*.js'

la explicacion a esto esta en esta imagen ya que no pude poner la url de la pagina al no ser un sitio seguro

por si quieren buscar la pagina esta es la url

el nombre a buscar debe estar entre comillas simples en algunas versiones de ubuntu la sintaxis seria find ./ -name ‘file’

solucion al reto

find ./ -name ‘*.txt’ > archivostext.txt && echo “Archivos guardados exitosamente”

idky@SM:~$ sudo find ./ -type f -name *.txt > ~/Escritorio/outputfind.txt; echo ¡Archivo creado exitosamente!

> ¡Archivo creado exitosamente!


idky@SM:~$ head -n 1 ~/Escritorio/outputfind.txt 
./.config/BraveSoftware/Brave-Browser/Default/Service Worker/CacheStorage/3fb5937a/index.txt```

Tuve este error
find: paths must precede expression: misachivos.txt' find: possible unquoted pattern after predicate-name’?

Se necesita agregar comillas y cambiar el patrón
find . -name ‘*.txt’

Gente logre esto tan raro.

esto fue lo que hice

find ./ -name *txt | tee files_conTXT.txt && echo files guardados

Esta es mi solucion:

find . -type f -name '*.txt' | > myDocuments.txt && echo 'archivos guardados exitosamente' && bat myDocuments.txt

Busca todos los archivos y los exporta a mydocuments.txt y muestra un mensaje que los archivos fueron guardados exitosamente y los muestra con bat, que es como cat pero con alas.

 find ./ -type f -name "*.txt" > /home/user/misdocumentosdetexto.txt && echo "El programa se ha ejectuado correctamente"


Reto cumplido 😃

¿Cumple este comando con el reto?

find ./ -type f -name *.txt > mytxtfiles.txt | echo "search completed"

Les comparto esto panitas…

find ./ -type f -name *.txt | tee text.txt && echo deadmau5 nd chill

Hay comandos que nos ayudan a encontrar archivos e incluso podemos filtrarlos dependiendo su extension, su nombre o ubicación.

wich cd

Este comando nos ayuda a encontrar la ubicación de nuestros binarios en las rutas que tengamos guardadas en el PATH.

find ./ -name file

Este comando lo que hace es primero buscar EN LA RUTA QUE SELECCIONEMOS por el nombre (-name) todos los archivos que se llamen “file”. Pero también podemos utilizar wildcards

find ./ -name *.txt

Otro modificador de Find es que podemos de buscarlos por el tipo de archivo donde tenemos 2 tipos de archivos, “f” & “d” files o directories

find ./ -type d -name Documents

En este comando vemos como busca en la carpeta home todos los directorios de tipo Documents.

Tambien podemos buscar por tamaño, si queremos buscar los mayores a 20MB podemos usar

find ./ -size 20M

Reto:

find Documents/ -type f -name "*.txt" > documentos_texto.txt && echo "Archivos guardados exitosamente" 

pdta: Empecé la busqueda desde el directorio Documents

find ./ -name *.txt > misDocumentosDeTexto.txt && echo “archivos guardados exitosamente”

find ./ -type f -name *.txt > file.txt && cowsay "Archivos guardados"
 ____________________
< Archivos guardados >
 --------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Listo, reto cumplido!

find ./ -name "*.txt" > misDocumentosDeTexto && echo "guardado con exito"

Aunque no entendí por qué hay que usar las comillas para que funcione, sin ellas no me arrojaba nada, por lo menos con los .txt

find ./ -type f -name "*.txt" > misarchivos.txt ; echo "Tipos de a
rchivo guardados con exito"

Buscar archivos mayores a 100Mb, con profundidad máxima de 4, que comiencen con la letra “d”:

find . -type f -size +100M -maxdepth 4 -name "d*"
Buscar archivos con extensión ".pdf" y profundidad mínima de 2:
find . -type f -name "*.pdf" -mindepth 2
Buscar carpetas que comiencen con la letra "A", con profundidad máxima de 5 y estén vacías:

find . -type d -maxdepth 5 -name "A*" -empty
Buscar archivos y carpetas que contengan la letra "j" y pesen más de 1 byte, y guardar la salida en el archivo "LosArchivosJ.txt":
find . -type f -size +1c -or -type d -size +1c -name "*j*" > LosArchivosJ.txt
Después de cada comando, puedes agregar la siguiente línea para imprimir el mensaje "Comando terminado con éxito" cuando se complete la ejecución:
echo "Comando terminado con éxito"
Recuerda ejecutar estos comandos en el directorio correcto según tu estructura de archivos.

Para los que usen bash ( parece raro porque es la misma shell que se usa en clase, pero me paso). Deben validar la busqueda con comillas. Si no, no les toma los parametros de busqueda.

Asi:
find ./ -name “*.txt”

Igual para -type

A veces, dudas de ti mismo, y de repente te ponen un reto en platzi… Y lo superas, y te quedas como “¿yo hice eso?”… Me pasa mucho… y lo peor es que lo hago, y vuelve y me pasa XD

En WSL sino uso “” al usar name. no funciona.
Un ejemplo de como usarlo si presentan el mismo error

find ./ -name "*.log"

Por algun motivo, estando en ubuntu, cuando el profe le da a buscar por el nombre a todos los archivos .txt lo tuve que poner entre comillas y ahi si funciono, no se si les pasara lo mismo 🤔

Excelente explicación

para el caso de linux ubuntu 22.04, los comandos cambian, en mi caso quiero buscar todos los archivos que tengo con la wildcard *.php:

find / -iname *.php

find ./ -name *.txt ./User/Documentos/busquedas/logbusqueda.log && echo "ya esta loco"

Mi solución al reto!

<find  ./ -type f -name *.txt > ./Escritorio/Platzi/misDocumentosDeTexto.txt && echo "Archivos guardados exitosamente"> 

Aqui mi aporte del ejercicio

Realizando el reto, pero en lugar de echo, con el adornito aprendido

Solucion del reto:

find ./ -type f -name *.txt > ArchivosDeTexto.txt; echo "Archivos guardados exitosamente"

Lo pude hacer y se crea el archivo con el nombre de cada uno de los archivos terminados en .txt

find ./ -type f -name *.txt > archivostexto.txt | echo trabajo hecho 

find ./ *.txt | ls > misarchivosdehtml.txt | echo archivos guarda
dos exitosamente | cowsay | lolcat

Acá mi solución al reto:

find ~ -name *.txt > archivosencontrados.txt && echo "Archivos guardados"
 find ./ -name *.txt | tee misDocumentos.txt | echo "Archivos Guardados exitosamente"

Aqui va mi humilde aporte, aunque cambie el echo por la vaquita parlanchina ♥ XD

find $HOME -name "*.txt" | tee "Mis documentos de texto.txt" | echo "Archivos guardados exitosamente" 

Aqui mi solucion al reto!

find ./ -type f -name *.txt | tee output.txt && echo "text files saved successfully"

Encuentra todos los elementos de tipo “file” que terminen con “.txt”, luego pasa el output al siguiente comando que escribira este mismo en un archivos llamado “output.txt”, si y solo si la ejecucion del pipe line fue exitosa, entonces imprime un mensaje “text files saved successfuly”

find ./ -type f -name *.txt > misArchivos.txt && echo "Archivos guardados exitosamente"
cedetb-Blade : /home/vi04877$  echo "Archivos guardados exitosamente"        <
Archivos guardados exitosamente
cedetb-Blade : /home/vi04877$ ls -l misArchivos.txt
-rw-rw-rw-    1 D1537.VI04877      D1537         11 Apr 23 16:09 misArchivos.txt
cedetb-Blade : /home/vi04877$ cat misArchivos.txt
./hola.txt
find ~ -type f -name "*.txt" > txt_files.txt && echo "Archivo guardado"; less txt_files.txt  


:~$ find ./ -name '*.txt' | tee DocumentosTextos.txt ; echo "Archivos creados existosamente"
:~$ less DocumentosTextos.txt
find ./ -type f -name *txt > misarchivos.txt && echo "Archivo creado"

Creo que lo hice bien 😅😃

  • Reto

find ./ -type f -name *.txt > actividad.txt; cowsay “archivos guardados exitosamente” | lolcat


< archivos guardados exitosamente >

    \   ^__^
     \  (oo)\_______
        (__)\       )\/\
            ||----w |
            ||     ||

find ./ -type f -name *.txt >> mis-archivos-txt.txt | echo archivos guardados con éxito

.log es la extensión para un archivo generado de manera automática que contiene un registro de los eventos de cierto software. Ahora entiendo por qué cuando genero pdfs con el comando pdflatex se crean estos archivos en la carpeta.

$ find ./ -name *.txt

Reto con colorcitos

Búsqueda por fecha
Si quieres buscar archivos en función de su fecha de acceso y las registros de fecha de modificación, Linux te ofrece las herramientas para hacerlo. Hay 3 registros de tiempo de los cuales Linux realiza seguimiento en los archivos:

  • Tiempo de acceso (-atime) – Fecha más reciente en que el archivo fue leído o escrito.

  • Tiempo de modificación (-mtime) – Fecha más reciente en que se modificó el archivo.

  • Hora de cambio (-ctime) – Fecha más reciente en que se actualizaron los metadatos del archivo.

Búsqueda por tamaño
Linux te brinda la opción de buscar archivos según sus tamaños. La sintaxis básica para buscar archivos por tamaño es:

find <startingdirectory> -size <size-magnitude> <size-unit>

Puedes especificar las siguientes unidades de tamaño:

c – bytes
k – kilobytes
M – megabytes
G – gigabytes
b – trozos de 512 bytes

En en enlance se encuentra mejor detalla la información y la manera en la que se utliza los comandos https://www.hostinger.mx/tutoriales/como-usar-comando-find-locate-en-linux/

Reto de EXET (ni idea como se escribe)

find ./ -name *.txt > misDocumentosDeTexto.txt | echo “Archivo guardado con exito”

Hola, les comparto mi reto.

¡Reto cumplido amigos😊!

Paso para recordarles que para ver el manual de comandos pueden ayudarse del comando

man

por ejemplo

man find

te animo a probarlo, recuerda que no eres una maquina, siempre ocupa la logica para ayudarte con el propósito de resolver problemas, Saludos.

Así quedo mi versión del reto de la clase aplicando pipes, redirecciones y encadenamientos, espero les sirva!!

cowsay 'Lista de archivos' >> resultado.txt && find ./ -type f -name '*.txt' >> resultado.txt && cowsay 'Lista de archivos guardados exitosamente' | lolcat && less resultado.txt | lolcat

En UBUNTU 20.04 el comando que me funcionó en vez de:

find ./  -name  *.txt

fue este:

find . -name "*.txt"
find Documents/ *.txt > lista_archivos.txt | echo “Archivos guardados exitosamente” | cat lista_ar*

Reto:

find ./ -name ‘*.txt’ > archivos_de_texto2.txt && echo “Archivos guardados e
xitosamente…!!!”

Aqui mi aporte


find ./Documents/user_files/  -name *.pdf > my_pdfs && cowsay 'Saved Successfully' | lolcat

find ./ -name *.txt > misArchivos.txt && echo “Archivos guardados con exito”

Me complace decir que este es un reto superado:

$ find ./ -type f -name "*.log" | tee ./Documents/LOG/backup.log; echo "Archivos Guardados Exitosamente"   

La ejecución consiste en tres instrucciones:

$ find ./ -type f -name “*.log”

  • tee ./Documents/LOG/Log.txt

echo “Archivos Guardados Exitosamente”

La primera instrucción pasa como parámetro a la 2da través de redirecion (stdinput / stdoutput).
La tercera instrucción espera la ejecución de la 2da por un operador de control “,” (asincronismo).

eduardo@eduardoHP:~$ find ./ -name *.txt >> mistxt.txt && echo "txt guardados exitosamente"
txt guardados exitosamente

Reto:

  1. Buscar todos los archivos .txt en el home
  2. Guardar el output en un archivo .txt
  3. Mostrar un mensaje que muestre “archivos guardados exitosamente”

Hacer 1, 2 y 3 en un comando es el reto de la clase

Solución:

find ./ -name *.txt > misArchivos.txt && echo "archivos guardados exitosamente"

Hola amigos, las siguientes instrucciones me funcionaron para vel reto:

# find *.txt > filesList.txt && echo "recopilacion correcta"

En donde *find .txt encontrara todos los .txt dentro del directorio > redirigira el output al archivo filesList.txt y && sera condicional AND para posteriormente ejecutar echo “recopilacion correcta” solo si el comando anterior no devuelve error

find ./ -name *.txt > ~/myTxt/mytxt | mv ~/myTxt/ && figlet Los archivos han sido guardados corrctamente | lolcat

![](

Cumpliendo el reto:

find $HOME -name *.txt | tee findText.txt && cowthink 'Búsqueda guardada con éxito'

Para practicar un poquito usamos variables de entorno, comando tee y el cowthink (que es su hermanito del cowsay)… 😉😉😉