Linux Notas - Notas
1. Seguimos con comandos interesantes
find
-> touch a.txt c.txt
-> find test/ -name "*.txt" -> Para buscar todos los archivos
-> rm *
-> mkdir A B C D E
-> touch A/a.txt
-> touch B/b.txt
-> find test/ -name "encontrar.txt"
->Test/C/encontrar.txt
--------------------------------------------------------
sudo apt install tree
-> tree Test/ -> Jerarquía de escritorios
--------------------------------------------------------
copiar un fichero
->Origen
->Destino
-> cp -r Test/ Copia
-> cp -r Test/ ..
-> ls
-> cp -r Test/ ../CopiaPadre
-> rm -r ../CopiaPadre Test/ -> Borramos
--------------------------------------------------------
Renombrar un fichero
-> mv Copia/ Test
--------------------------------------------------------
-> nano fichero.txt
teclados
tartas
ratones
libretas
-> grep ^t fichero.txt -> Nos busca los ficheros que empiezan con t
-> grep txt prueba.txt -> Sin expresiòn regular, busca todos los txt
2. Permisos y enlaces en directorios
Creamos un directorio de prueba llamado Test
-> mkdir Test
->ln Test Link
No se permite enlaces fuertes/duros para directorios
-> ln -s Test Link
Si se permiten enlaces blandos, softlink o simboliclink
-> ls -l
Serà un directorio que enlaza a otro
-> cd Link
-> touch fichero.txt
-> ls ../Test
-> fichero.txt
->mkdir otrodir
-> ls ../Test
->fichero.txt otrodir
*Por lo cual Link sera un reflejo de Test, está enlazado
Cuando servimos una página web en el servidor, enlazamos desde el directorio con una carpeta que enlaza (Como lo hace git o dropbox)
--------------------------------------------------------
Permisos en Directorios
-> ls -l Test/ -> Ver los permisos
-> chmod 666 Test/ -> Sin permiso de ejecuciòn en Test
-> chmod 777 Test/ -> Todos los permisos
-> cd Test/ ->Ahora si, podemos acceder a Test
-> chmod 555 Test/ -> Nos da permiso de lectura y ejecuciòn, quitamos el de escritura
-> cd Test/ -> Podemos acceder pero..
-> touch fichero -> No podremos crear un fichero, no tenemos el permiso, de escritura en directorios
-> chmod 333 Test/ -> Deja con lectura y escritura, no ejecuciòn.
-> cd Test/
-> ls ->Permiso Denegado, no podemos listarlo
-> rm -r Test/ ->Tampoco podemos borrar, permiso deneado
-> chmod 775 Test/ ->Permisos por defecto, tenemos todos menos escritura para el grupo others
-> rm -r Test/ ->Borramos el fichero.
3. Redirecciones y Pipes (Tuberías)
stdin -> standard input 0
stdout -> standard output 1
stderr -> standard error 2
Por defecto, los procesos como input tendràn el teclado.
-> stdout ->
Teclado -> stdin -> PROCESO ->Pantalla
-> stderr ->
Podemos redirigir la salidas donde deseemos
*Ejemplo
echo "Hola Mundo" -> Es una salida que sale por stdout, y se imprime en pantalla
-> La salida stdout la podemos redirigir a un fichero.
-> echo "Hola Mundo" > fichero.txt
-> tendra el "Hola Mundo" como contendio por el signo >
*Se pueden redigir las salidas de cualquier programa a un fichero.
-> ls -l > fichero.txt -> Redirigimos la salida del comando ls a un fichero, listamos en él
-> cat fichero.txt -> Vemos su contenido
-> rm fichero.txt
*Redigirmos la entrada
-> nano fichero.txt
teclados 5
etx..
-> grep teclados fichero.txt
> salida
< entrada
-> grep teclados < fichero.txt
*los comandos que aceptan ficheros como paràmetros
-Redireccionamos la entrada de cualquier comando
Teclado
fichero -> stdin PROCESO -> stdout -> pantalla
*tuberias-> Combina la redirecciòn de entrada y la redirecciòn de salida.
->apt list ->Nos saca una lista de todos los paquetes instalados en el sistema.
->apt list > list.txt -> Redireccionamos la salida, toda la lista de paquetes instalados (apt)
*Si quisieramos buscar una paquete en concreto..
-> grep alacritty < list.txt -> Le redireccionamos la entrada, nos muestra donde se encuentra.
*o bien.. en una sola lina
-> apt list | grep alacritty -> | redirige la salida de list como entrada de grep
stdout stdin
PROCESO 1 -> TUberìa -> Proceso 2
*Que es lo mismo que.. Con las tuberìas comunicamos procesos.
-> apt list > fichero.txt
-> grep alacritty < fichero.txt
*Tambièn.. Si queremos buscar el fichero Documentos
-> ls -l | grep Documentos
*Equivalente a..
-> ls -l > dir.txt
-> grep Documentos < dir.txt
--------------------------------------------------------
Otros ejemplos..
-> nano productos.txt
-> productos1 20 40
-> productos2 15 25
-> productos3 17 18
-> cut -d " " -f 3 productos.txt -> cut cortar, -d delimiter (delimitador), -f fill (campo)
-> 40
-> 25
-> 18
*Es similar a redirigirle la entrada
Si le pasamos un fichero lo lee de ahí..
Si no le pasamos un fichero, lee de la dentrada
Pero si le redigirimos la entrada como el fichero, entonces lee el fichero.
-> cut -d " " -f 3 < productos.txt -> Se usa mucho en tuberìas.
-> 40
-> 25
-> 18
-> ls -l -> listamos los permisos
-> ls -l > fichero.txt
-> nano fichero.txt
-> control + k -> nos borra la primera linea
-> control + o -> nos guarda
-> cat fichero.txt
-> tendremos la misma salida del ls
-> sed "s/ */ /g" fichero.txt -> "sed" string editor, para editar con expresiones regulares.
-> g para global, de lo contrario solo lo modifica en la primera ocurrencia
-> s/ dosespacios */ /g"
-> * en este contexto indica cero o màs veces el caracter anterior ( el caracter es un espacio vacio")
-> Ahora solo tendremos un solo espacio entre cada campo
-> Cada vez que encuentra dos espacios, cumple la expresiòn regular.
-> sustimos por un solo espacio
-> sed "s/ */ /g" fichero.txt | cut -d " " -f 5 -> recordar que la posicion es 1, 2, 4, 5 (no emppieza con 0)
-> nos salen el campo de todos los bytes
-> podriamos calcular con un script el total de bytes que ocupa un directorio
-> sed "s/ */#/g" fichero.txt | cut -d "#" -f 5
-> Los campos se separan en funciòn del #
*Màs sencillo asì.. -> El nùmero es el fill
-> sed "s/ */ /g" fichero.txt | cut -d " " -f 5 -> Con el 5 obtenemos el campo de memoria
-> sed "s/ */ /g" fichero.txt | cut -d " " -f 7 -> Con el 7 obtenemos el campo de la hora
-> sed "s/ */ /g" fichero.txt | cut -d " " -f 9 -> Con el 9 obtenemos el campo de los nombres
*Tambièn
-> ls -l | sed "s/ */ /g" fichero.txt | cut -d " " -f 9
-> obtenemos los nombres de los directorios
*con tail podemos seleccionar el nùmero de lìnea desde donde veremos la salida.
-> ls -l | tail - n +2 -> Veremos la salida a partir de la lìnea 2 (con +2), eliminamos la primera lìnea.
-> Veremos la salida las últimas 2 líneas (con 2)
-> ls -l
-> ls -l | tail -n +2 | sed "s/ */ /g" | cut -d " " -f 9 -> Todo con comandos, POTENCIAL
--------------------------------------------------------
Número de bloques que ocupa el directorio en discos..
-> ls -l
-> total 40 -> Bloques
-> drwxr-xr-x 2... etc
-> ls -l | head -n 1 -> Sacamos la primra linea
-> total 40
-> ls -l | head -n 1 | cut -d " " -f 2
-> 40
*head cabeza, tail es cola
-> head -help
-> por defecto el head imprime las primeras 10 líneas
-> tail -help
o bien.. Para saber.
-> man tail
-> info con más detalles
--------------------------------------------------------
*Errores al momento de usar tuberìas.
-> cat productos.txt | grep producto1 -> Ineficiente, hacemos el doble de trabajo, no es necesario el | con grep ya que..
-> grep producto1 productos.txt -> Asì hace lo mismo, en realidad en este caso el grep lee el fichero, en el anterior lo hacia el cat
O bien..
-> cat productos.txt | cut -d " " -f 3
-> cut -d " " -f 3 productos.txt -> Hace lo mismo, el cut puede leer el fichero directamente..
-> Por lo cual no le pasamos la salida del cat por tuberìas |
4. Redirecciones y Pipes más complejos
Por lo tanto stdInt se puede redirigir con el signo < -> 0
stdout se puede redirigir con el signo > -> 1
stderr se puede redirigir
*Hacemos un programa que saca error
print("Standard Output")
raise Exception("Standard Output")
-> lo llamamos como error.py
--------------------------------------------------------
*Para ejecutar un programa con python en ubuntu
ejecutamos desde consola
-> python3 error.py
-> Imprime
-> Y saca el error
Por lo cual standar output es la pantalla
Y standard Error tambièn, pero podemos redireccionar la salida
-> python3 error.py > salida.txt -> Vemos el error no la salida
-> cat salida.txt
-> Standard Outpu -> Aquì encontramos la salida redirigida
-> python3 error.py 2> e.txt -> Vemos la salida pero no vemos el error
-> cat e.txt
-> Vemos el error dentro del archivo
-> python3 error.py 2> ficeroerror.txt > salida.txt -> Redirigimos tanto la salida como el error
-> cat ficheroerror.txt
-> vemos el error
-> cat salida.txt
-> vemos la salida
--------------------------------------------------------
*Modificamos el programa, error.py
print(input("Mensaje para la salida: "))
raise Exception("Standard Error")
-> python3 error.py
-> Mensaje para salida: stdout
-> Nos imprime el stdout
-> Sin redirecciones
-> python3 error.py 2> error.txt > salida.txt -> Redirigimos el error a error.txt, y la salida a salida.txt
-> -> Lo que metamos acà, aparecerà como salida en salida.txt
-> python3 error.py
Mensaje para la salida: -> El teclado continùa siendo la entrada en este caso
--------------------------------------------------------
*Ahora en entrada.txt desde nano (el editor)
->Entrada la que deseamos + enter (linea final)
Guardamos
-> python3 error.py 2> error.txt > salida.txt < entrada.txt -> *La entrada de salida serà lo de la entrada*
-> cat salida.txt
-> Entrada la que deseamos
Por lo tanto..
--> ->stdout -> salida.txt
entrada.txt -> stdin -> python3 error.py
--> ->stderr -> error.txt
*A cada proceso le podemos pasar una entrada, una salida y una salida del error.
Por lo tanto..
-> python3 error.py 2> error.txt > salida.txt < entrada.txt
Como entrada es el ficero entrada.txt
Como salida del error el fichero error.txt -> Acà re dirigimos tanto la entrada como las salida.
Como salida estandard el fichero salida.txt
Mientras que por defecto.. Standard.
Si no hacemos nada, la entrada es el teclado,
Y la salida standard es la pantalla como tambièn la salida del error.
--------------------------------------------------------
Redigirir las salidas.
-> echo "mensaje 1" > salidaecho.txt
-> echo "mensaje 2" > salidaecho.txt -> Se sobreescribe el mensaje anterior
-> echo "mensaje 1" > salidaecho.txt
-> echo "mensaje 2" >> salidaecho.txt -> >> Para añadir evitando que sobrescriba
-> echo "mensaje 3" >> salidaecho.txt -> Se añade otra linea màs, evitando sobreescribir
Ahora bien error.py con nano..
raise Exception("Error que querais")
-> python3 error.py -> No imprime el error
-> python3 error.py 2> fich.txt -> Redigirimos la salida del error
-> python3 error.py 2>> fich.txt -> Con >> Nos sale màs 1 de vez (2 veces), añadimos el error.
stdint
stdout
stderr
--------------------------------------------------------
Error comùn..
Escribir los mensajes de error en el stdout
Los mensajes de error van en el stderr
stdin 0 -> ENTRADA -> Standard input
stdout 1 -> SALIDA -> Standard output
stderr 2 -> SALIDA DEL ERROR -> Standard error
--------------------------------------------------------
Detalles extras..
*Para obtener exclusivamente las columnas 3 y 5 -> Individual
-> ls -l | sed "s/ */ /g" | cut -d " " -f 3,5
*Para obtener las columnas entre el 3 y 6 -> Rango
-> ls -l | sed "s/ */ /g" | cut -d " " -f 3-5
*Para obtener las columnas entre el 3 hasta el final -> A partir, sin delimitaciòn final
-> ls -l | sed "s/ */ /g" | cut -d " " -f 3-
5. Solucionando el ejercicio
Filtra la salida del comando ls -l para obtener únicamente los permisos de cada fichero/directorio y su nombre. La salida final debe ser similar a la siguiente:
drwxr-xr-x Descargas
drwxr-xr-x Documentos
...
-> ls -l
-> ls -l | tail -n +2 -> Eliminamos la la primera linea
-> ls -l | tail -n +2 | sed "s/ */ /g"
-> ls -l | tail -n +2 | sed "s/ */ /g" | cut -d " " -f 1,9 -> Obtenemos los campos del 1 al 9
-> ùnicamente los permisos de cada fichero/directorio y su nombre
6. Últimos detalles de las redirecciones y tuberías
Las redirecciones y tuberìas ademàs se pueden mezclar..
-> ls -l | tail -n +2 | sed "s/ */ /g" | cut -d " " -f 1,9 -> Como en el ejercicio anterior.
-> ls -l | tail -n +2 | sed "s/ */ /g" | cut -d " " -f 1,9 > mezclar.txt
-> cat mezclar.txt
la salida de sed -> | es la entrada de cut
-> ls -l | tail -n +2 | sed "s/ */ /g" | cut -d " " -f 1,9 > mezclar.txt
-> echo "producto1 20 25" > productos.txt
-> echo "producto2 30 18" >> productos.txt
-> cat productos.txt
->producto1 20 25
->producto2 30 18
*Ahora con nano armamos un programa en programa.py con el cual enviamos a la salida la entrada
-> print(input())
Ahora..
-> python3 programa.py < productos.txt -> Obtenemos la primera lìnea de productos.txt, sera la entrada de programa.py
->producto1 20 25
-> python3 programa.py < productos.txt | cut -d " " -f 3 -> Ahora ademàs la tuberìa le cambiara la salida, obtenemos 25
->25
-> python3 programa.py < productos.txt | cut -d " " -f 3 > salida.txt -> A salida.txt le redirigimos la salida
-> Por lo cual se pueden mezclar pero observando los in y out
-> cat salida.txt
-> 25
7. Cudi - Redirección e Intro a Bash Scripting
Cudi - Redirección e Intro a Bash Scripting (Parte 1)
Bash Script, son de tipo .sh
-> touch holaMundo.sh
-> vim holaMundo ->sudo apt vim install
echo "hola mundo"
-> ./holaMundo.sh ->Ejecutamos el archivo, pero debemos darle permisso.
-> chmod +x holaMundo.sh ->Le damos el permiso de ejecucion
-> ./holaMundo.sh ->Lo ejecutamos con el permiso
->hola mundo
echo "hola mundo" > hola.txt ->Desde vim tambièn puedo mandarselos a otros archivos
-> cat hola.txt
->hola mundo ->Le pasamos la data de un archivo hacia otro.
echo "hola mundo" >> hola.txt ->con >> le agregamos uno al ultimo
-> cat hola.txt
->hola mundo
->hola mundo
control + c -> Salir de la ejecucion, romperla
control + e -> Salir màs relajadamente
Para comentar dentro del archivo desde la consola se usa #, para comentar en línea.
se usa :' ' para comentar en multipleslineas.
Podemos crear variables
->var=10
->if[ $var -eq 10 ]
then ->Entonces
echo "se cumplio"
else
echo"nO, la verdad que no es igual a 10"
->fi
Ejecutamos el archivo
-> vim holaMundo.sh
->var=10
->if[ $var -eq 9 ]
then ->Entonces
echo "se cumplio"
elif [$var -gt 9 ]
then
echo "no es el numero que esperabas, pero es mayor"
fi
*Al poner corchetes no se puede poner operadores logicos, solo en forma de etiqueta
-eq equal
-gt great than
-ne not equal
-lt lower than
->var=10
->if[ $var -eq 8 ]
then ->Entonces
echo "se cumplio"
elif [ $var -gt 9 ]
then
echo "no es el numero que esperabas, pero es mayor"
else
echo "no es el numero que esperabas, pero es menor"
fi
*Para usar operadores logicos debemos utilizar ()
->var=10
->if(( $var == 8 ))
then ->Entonces
echo "se cumplio"
elif (( $var > 9 ))
then
echo "no es el numero que esperabas, pero es mayor"
else
echo "no es el numero que esperabas, pero es menor"
fi
----------------------------------------------------------------------
num1=8 ->Sin espacio, las varaibles deben ir juntas
num2=7
if [ $num1 -eq 0 ] && [ $num2 -eq 7 ] ->Debe ir un espacio
then
echo "se cumplen las dos condiciones"]
fi
Es lo mismo que..
num1=8 ->Sin espacio, las varaibles deben ir juntas
num2=7
if [[ $num1 -eq 0 && $num2 -eq 7 ]]
then
echo "se cumplen las dos condiciones"]
fi
Cudi - Redirección e Intro a Bash Scripting (Parte 2)
Combinar los comandos y construir varios bloques
----------------------------------------------------------------------
Usuarios..
----------
Super usuario -> sudo ->Super usuario momentáneo.
-> sudo su ->Super usuario fijo, quedamos logueados
-> exit ->Para salir del usuario fijo
-> ls -l ->Para ver los permisos de todos los usuarios.
----------------------------------------------------------------------
APT -> Manejador de paquetes, conjunto de paquetes, que se encarga de hacer andar el programa que instalemos
apt ->Versiòn simplificada
apt-get ->
-> sudo apt update ->Actualiza los paquetes de la computadora
-> sudo apt upgrade ->Actualiza y descarga las actualizaciones en sì
-> sudo apt search rolldice ->Para buscar los paquetes
-> sudo apt install rolldice ->Instala un paquete, primero hacer el update y el upgrade antes de instalar. Màs el update.
-> sudo apt remove rolldice ->Desinstala
----------------------------------------------------------------------
Redirecciòn
-----------
String ->
Cada comando tiene dos string relacionados, uno de entrada y otro de salida.
El de entrada recibe valores y el de salida el que muestra lo que saca.
-> ls
->la salida muestra en pantalla, es el string de salida
Es como un "enchufe", lo que se inserta y lo que se
La entrada viene dada por el teclado, el valor en sì.
-> ls > archivo ->Lo que estaba por salir del ls, sale en este caso por archivo
-> cat archivo
->EjerciciosRedireccion
->archivo
-> Pipe | Enchufa los comandos, la entrada de uno con la entrada del otro, tuberìa.
-> >>
----------------------------------------------------------------------
Ejercicios
Iniciales
------------
1) Crear un archivo que se llame Mensaje y su contenido sea la palabra "hola"
Pista: usar >
2) Muestre los archivos del directorio actual que contengan "Numero" dentro de su nombre
Pista: Usar |
3) Agregar el 5 al final del archivo NumeroDel1al4
Pista: usar >>
Avanzados
-----------
4) Ordenar alfabeticamente el contenido del archivo LetrasDesordenadas y guardarlo en otro arcvhio que se llame LetrasOrdenadas
5) Armar un archivo indice que contenga los nombres de los archivos y los directorios que estàn en:
a) El directorio actual
b) El directorio actual y sus subdirectorios
6)Listar todas las Urls de los Links que estàn dentro de la pagina https://vid.puffyan.us/feed/popular
Ayuda: el siguiente comando recibe por entrada estándar lineas que contienen el texto href="" y las recorta para que quede solamente la URL
awk '{split($0, linea, "href=\""); print linea[2]}'| awk '{split($1, linea, "\">"); print linea[1]}'
7) Descargar todas las imágenes .jpg que están en la página https://www.imdb.com/chart/top/?ref_=nv_mv_250
Ayuda: el siguiente comando recibe por entrada estándar lineas que contienen el texto src=""
y las recorta para que quede solamente la URL
awk '{split($0, linea, "src=\""); print linea[2]}'| awk '{split($1, linea, "\""); print linea[1]}'
Se recomienda resolver este punto desde un directorio vacío,
Crear archivos..
-> touch numeros1al4.txt
1
2
3
4
-> touch letrasDesordenadas
a
z
a
l
-> mkdir Directorio
-> cd Directorio
-> touch a
-> cd .
-> cd ..
--------------------------------------
Seguimos con los ejercicios.
1) Crear un archivo que se llame Mensaje y su contenido sea la palabra "hola"
Pista: usar > -> ">" = Redirecciòn de la salida
La redirecciòn serà en el archivo no por pantalla
-> echo hola > Mensaje
-> cat Mensaje
->hola
*Separar el problema en partes
--------------------------------------
2) Muestre los archivos del directorio actual que contengan "Numero" dentro de su nombre
Pista: Usar |
filtros -> usar grep
-> ls | grep Numeros -> Grep lee lo que sale del ls, y filtra la palabraNumeros
->"Numeros"1al4 -> Filtramos entonces los archivos.
-> ls | grep um
->N "um" eros1al4 -> Matchea con el um de la palabra, y la filtra.
-> ls | grep -w Numeros1al4 -> Con -w DEBE enganchar toda la palabra
->Numeros1al4"
> -> Redirecciona la salida, ejemplo, este en cambio, solo cambia la salida de uno.
-> Un comando > Archivo
| -> Ademas de redigir la salida de un comando, redirige la entrada de otro comando, para que se conecten.
-> Un comando | otro comando
--------------------------------------
3) Agregar el 5 al final del archivo NumeroDel1al4
Pista: usar >>
Appendear.. Append, agregarlo al final >>
-> echo hola > Mensaje ->Agrega un ola, pisando todo
-> echo hola >> Mensaje ->Agrega un hola al final
-> hola
-> hola
-> echo 5 >> Numeros1al4 -> Con echo imprimimos un 5 que lo metemos en Numeros1al4
-> 1
-> 2
-> 3
-> 4
-> 5
-> Considerar el > en diferencia con el >>
Ya que podemos borrar data, osea, sobreescrbirla
--------------------------------------
4) Ordenar alfabeticamente el contenido del archivo LetrasDesordenadas y guardarlo en otro arcvhio que se llame LetrasOrdenadas
-> sort LetrasDesordenadas > LetrasOrdenadas
-> cat LetrasOrdenadas
-> a
-> b
-> c
--------------------------------------
5) Armar un archivo indice que contenga los nombres de los archivos y los directorios que estàn en:
a) El directorio actual
-> ls > Indice ->Armamos el indice en un archivo de los directorios
b) El directorio actual y sus subdirectorios
-> ls -R -> Muestra los directorios y los subdirectorios, con -R es recursivo.
-> ls -R > Indice -> Muestra el indice y subindice.
--------------------------------------
6) Listar todas las URLs de los links que están dentro de la página https://vid.puffyan.us/feed/popular
Ayuda: el siguiente comando recibe por entrada estándar lineas que contienen el texto href="" y las recorta para que quede solamente la URL
awk '{split($0, linea, "href=\""); print linea[2]}'| awk '{split($1, linea, "\">"); print linea[1]}'
-> curl https://vid.puffyan.us/feed/popular -> Muestra todo el html, ahora toca filtrarlo.
-> curl https://vid.puffyan.us/feed/popular | grep href
-> Obtenemos los url relativos, debemos convertirlos en Absolutos.
-> Y asì obtener el path completo.
-> curl https://vid.puffyan.us/feed/popular | grep href | awk '{split($0, linea, "href=\""); print linea[2]}'| awk '{split($1, linea, "\">"); print linea[1]}'
-> Con esto obtenemos los Links.
--------------------------------------
7) Descargar todas las imágenes .jpg que están en la página https://www.imdb.com/chart/top/?ref_=nv_mv_250
Ayuda: el siguiente comando recibe por entrada estándar lineas que contienen el texto src="" y las recorta para que quede solamente la URL
awk '{split($0, linea, "src=\""); print linea[2]}'| awk '{split($1, linea, "\""); print linea[1]}'
Se recomienda resolver este punto desde un directorio vacío,
Creamos un directorio..
-> mkdir Web
-> cd web/
-> curl https://www.imdb.com/chart/top/?ref_=nv_mv_250 | grep jpg
-> Encontramos toda las imagenes jpg
-> curl https://www.imdb.com/chart/top/?ref_=nv_mv_250 | grep jpg | awk '{split($0, linea, "src=\""); print linea[2]}'| awk '{split($1, linea, "\""); print linea[1]}'
->Quedan solo los links de las paginas..
-> curl https://www.imdb.com/chart/top/?ref_=nv_mv_250 | grep jpg | awk '{split($0, linea, "src=\""); print linea[2]}'| awk '{split($1, linea, "\""); print linea[1]}' | wget
->Es necesario ingresar "opciones" por teclado, como ls -l .. Informaciòn que modera lo que necesitemos.
con wget..
La entrada standard requiere de cierta informaciòn que està sujeta al teclado,
Con los pipes evitamos la entrada standard, sino que lo busca de donde lo necesitemos.
Cada comando tiene un comportamiento definido..
Con wget no escucha los datos que le obligamos a recibir por medio de un pipe..
-> curl https://www.imdb.com/chart/top/?ref_=nv_mv_250 | grep jpg | awk '{split($0, linea, "src=\""); print linea[2]}'| awk '{split($1, linea, "\""); print linea[1]}' | wget -i -
-> Con -i - "preconfiguramos" el comando wget para que acepte el uso del |
-> Es decir, la entrada serà otra diferente a lo que es la entrada standard
-> Descargamos todas las imagenes en la carpeta..
--------------------------------------
Separamos el problema general en partes..