Linux Notas - Notas
1. Hola Mundo
Bash es un intérprete de comandos..
Y como lenguaje de programación además podemos agregarle lógica.
-> variable="Hola Mundo" -> Sin espacios, debemos colocarlo todo junto
-> echo $variable
->Hola Mundo
-> variable="otro valor" -> Cadenas de textos
-> echo $variable
->otro valor
-> a=2
-> b=3
-> expr $a + $b ->Antes se hacía así.
->5
-> (( c = a + b )) -> Forma de expresión más moderna, más recomendable
-> echo $c
->5
-> (( c = a * b ))
-> echo $c
->6
-> (( c = a - b )) -> Más entendible dejando espacios entre los operadores.
-> echo $c
->-1
-> expr $a+$b
->2+3 -> Concatena
-> expr $a + $b
-> 5
--------------------------------------------------------
Scripts
->cd Escritorio/
-> mkdir Scripts
-> cd Scripts/
->nano script.sh -> Extensiòn sh
->echo"Hola Mundo"
->echo"otro mensaje"
Ejecutar el script
-> bash script.sh -> Nos permite imprimir todo, el "lenguaje" es BASH, buscarlo asì al momento de consultar.
->Hola Mundo
->otro mensaje
*Los scripts son para darle lógica a los comandos, no tanto para hacer "programas"..
-> ls -l ->Vemos los permisos, debemos permitir la ejecuciòn.
-> nano script.s
#!/bin/bash -> Comentario
-> chmod u+x script.sh ->damos el permiso de ejecución
-> ./script.sh -> Ruta al programa con el ./
-> bash script.sh -> Es lo mismo a la lìnea anterior.
-> nano prueba.py
->#!/bin/python3
->print("Hola mundo con python")
-> chmod u+x prueba.py ->Permitimos la ejecuciòn
-> ./prueba.py
->Hola mundo con python
-> python3 prueba.py -> Lo mismo que ./
--------------------------------------------------------
-> nano programa.c
->#include -> std = standar, io es input y output
-> int main() {
prinf("Hola mundo con C\n"):
}
-> gcc programa.c -o compilado -> con -o le damos el nombre compilado
-> ./compilado -> Es binario, se ejecuta en el procesador, no como lo hace bash ni python
-> Hola mundo con C
*3 formas de ejecutar programas, que sean ejecutables..
Necesitamos permitir los permisos
Necesitamos un interprete que lo ejecute
O bien que sea un programa compilado
2. Lógica en bash
-> code Script/ -> Nos abre visual studio code en el directorio especificado.
*Material Theme como extensiòn -> Material Theme Darker High Contrast
#!/bin/bash
cadena="Un valor"
echo $cadena -> Contro + ' abrir terminal en visual studio code
-> ls -l ../../ -> Para ver los bytes
--------------------------------------------------------
#!/bin/bash
cadena="Otra cosa"
echo $cadena
-> ./script.sh -> Nos imprime el valor de la variable
-> Otra cosa
--------------------------------------------------------
-> el - es un guion, un dash
#!/bin/bash
echo -n "Escribe un mensaje: " -> man echo para ver en detalle, sirve para no imprimir la nueva línea
read resultado
echo "Tu mensaje es: $resultado"
-> ./script.sh
->Escribe un mensaje:
->Tu mensaje es: Curso Linux
--------------------------------------------------------
El Script es una secuencia de comandos.
#!/bin/bash
echo -n "Instalar programa? [s/n]"
read resultado
if [[ $resultado == "s" ]]; then -> En una línea para ahorrar una línea
echo "Instalando Programa.."
fi
-> ./script.sh
->Instalar programa? [s/n]: s
-> Instalando programa...
--------------------------------------------------------
#!/bin/bash
echo -n "Instalar programa? [s/n]"
read resultado
if [[ $resultado == "s" ]]; then
echo "Instalando Programa.."
else
echo "El programa no se va a instalar" -> Lo imprime ademàs con cualquier otro caracter que no sea una s
fi
-> ./script.sh
-> Instalar programa? [s/n]: n
-> El programa no se va a instalar
--------------------------------------------------------
#!/bin/bash
echo -n "Instalar programa? [s/n]"
read resultado
if [[ $resultado == "s" ]]; then
echo "Instalando Programa.."
elif [[ $resultado == "n" ]]; then
echo "El programa no se va a instalar"
fi
-> ./script.sh
-> Instalar programa? [s/n]: n
-> El programa no se va a instalar
-> ./script.sh
-> Instalar programa? [s/n]: s
-> Instalando Programa..
--------------------------------------------------------
#!/bin/bash
echo -n "Instalar programa? [s/n]"
read resultado
if [[ $resultado == "s" ]]; then
echo "Instalando Programa.."
elif [[ $resultado == "n" ]]; then
echo "El programa no se va a instalar"
else
echo "Opcion invalida"
fi
-> ./script.sh
-> Instalar programa? [s/n]: n
-> El programa no se va a instalar
-> ./script.sh
-> Instalar programa? [s/n]: s
-> Instalando Programa..
-> ./script.sh
-> Instalar programa? [s/n]: dasdas
-> Opcion invalida
--------------------------------------------------------
Expresiòn regular para invluir minúsculas y mayúsculas
#!/bin/bash
echo -n "Instalar programa? [s/n]"
read resultado
if [[ $resultado == [sS] ]]; then ->[sS]
echo "Instalando Programa.."
elif [[ $resultado == [nN] ]]; then ->[nN]
echo "El programa no se va a instalar"
else
echo "Opcion invalida"
fi
--------------------------------------------------------
-> Para cambiar el nombre al archivo
-> mv script.sh script1.sh
--------------------------------------------------------
-> touch script2.sh ->Nuevo archivo
-> chmod u+x script2.sh ->Permisos de EJecuciòn
Ahora usaremos operaciones aritméticas
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [[ $valor -gt 5]]; then -> gt -> greater than
echo "Tu numero es mayor que 5"
else
echo "Tu numero es menor o igual a 5"
fi
--------------------------------------------------------
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [[ $valor -lt 5]]; then -> lt -> lower than
echo "Tu numero es menor que 5"
else
echo "Tu numero es mayor o igual a 5"
fi
--------------------------------------------------------
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [[ $valor -le 5]]; then -> le -> lower or equal
echo "Tu numero es menor o igual que 5"
else
echo "Tu numero es mayor que 5"
fi
--------------------------------------------------------
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [[ $valor -ge 5]]; then -> ge -> greather or equal
echo "Tu numero es mayor o igual que 5"
else
echo "Tu numero es menor que 5"
fi
--------------------------------------------------------
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [[ $valor -eq 5]]; then -> eq -> equal
echo "Tu numero es igual a 5"
else
echo "Tu numero no es igual 5"
fi
--------------------------------------------------------
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [[ $valor -ne 5]]; then -> ne -> not equal
echo "Tu numero no es igual a 5"
else
echo "Tu numero es igual 5"
fi
-> En vs code control k c -> Comentario multilinea
Ejemplo completo
#!/bin/bash
echo -n "Instalar programa? [s/n]: "
read resultado
if [[ $resultado == [sS] ]]; then
echo "Instalando programa..."
elif [[ $resultado == [nN] ]]; then
echo "El programa no se va a instalar"
else
echo "Opcion invalida"
fi
3. Bucles y parámetros
para copiar ficheros -> cp script2.sh script3.sh
-> ls -l -> Para ver los permisos
--------------------------------------------------------
Ahora toca ver las operadores lògicos..
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [ $valor -ge 5 -a $valor -le 10 ] -> -a es and o && -> -o es or o ||
then
echo "Tu numero está en el rango [5,10]"
else
echo "Tu numero no está en el rango [5,10]"
fi
-> Con operaciones lógicas utilizar solo un par de []
-> Con los dobles [[ ]] Son usados para manipular cadenas de una mejor forma
-------------------------------------------------------
-> Por lo tanto usar [[]] para comparar cadenas
-> para comparar nùmeros usar []
#!/bin/bash
echo -n "Instalar programa?: [s/n]"
read resultado
if [ $resultado == "s" -o $resultado == "S" ] -> -o es or o ||
then
echo "Instalando programa..."
elif [[ $resultado == [nN] ]]
then
echo "El programa no se va a instalar"
else
echo "Opcion invalida"
fi
--------------------------------------------------------
-a es and
-o es or
--------------------------------------------------------
Bucles -> Comenzar desde 0
#!/bin/bash
echo -n "Escribe un número: "
read limite
for (( i = 0; i <= $limite; i++ )); do
echo $i
done
-> Imprimimos los números hasta el limite
--------------------------------------------------------
Parametros
#!/bin/bash
echo "Numero de parametros recibidos: $#"
-> ./script4.sh 1 1 2 2asas
-> Numero de parametros recibidos: 4
-> Cuando le pasamos valores a un script se llaman ARGUMENTOS
-> SIn embargo dentro del programa se llaman parámetros
--------------------------------------------------------
-> Con $num accedemos a cualuier parametro ingresado
#!/bin/bash
echo $1
echo $2
->./parametro.sh Hola a
->Hola -> Imprime los parametros que le pasamos
->a
--------------------------------------------------------
Ejemplos completos
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [[ $valor -ne 5 ]]; then
echo "Tu numero no es igual a 5"
else
echo "Tu numero es igual a 5"
fi
# -gt greater than
# -ge greater or equal
# -lt lower than
# -le lower or equal
# -eq equal
# -ne not equal
#!/bin/bash
echo -n "Escribe un número: "
read valor
if [ $valor -lt 5 -o $valor -gt 10 ]; then
echo "Tu numero está fuera del rango [5, 10]"
else
echo "Tu numero está en el rango [5, 10]"
fi
# -a and
# -o or
#!/bin/bash
echo -n "Escribe un número: "
read limite
for (( i = 20; i > $limite; i-- )); do
echo $i
done
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error: el directorio no existe"
exit 1
fi
total=0
for f in `ls $1`; do
name="$1/$f"
if [ -f $name ]; then
bytes=`ls -l $name | cut -d " " -f 5`
echo "Fichero $name ocupa $bytes" | tr -s /
(( total = $total + $bytes ))
fi
done
echo -e "\nTotal: $total"
Cudi - Parte 1
6 - Loop, Argumentos y Funciones (Parte 1)
touch loops.sh -> para que se puede correr, debemos modificar los permisos de ejecución.
vim loops.sh
#! /bin/bash -> Para ejecutar el archivo
num=$
if [ $num -eq 4 ] && [ $num -gt 3 ]
then
echo $num
fi
:wq
chmod +x loops.sh
ls
./loops.sh
4 -> Se cumplen las dos condiciones.
----------------------------------------------------------------------
&& And
Or
----------------------------------------------------------------------
num=4
->or
if [[ $ num -eq 5 // $num -gt 3 ]]
then
echo $num
fi
----------------------------------------------------------------------
#! /bin/bash
num=$
seq 1 20 -> Imprime números del 1 al 20
-----------
while mientras que
for por
until
----------------------------------------------------------------------
#! /bin/bash
num=4
while [ $num -lt 20 ] -> lt menor que, lower then
do
echo $num
num=$(( num + 1 )) ->Respetar la Sintaxis
done
->Imprime los números
----------------------------------------------------------------------
#! /bin/bash
num=4
while [ $num -lt 20 ] -> lt menor que, lower then
do
echo "numero : $num"
num=$(( num + 1 )) ->Respetar la Sintaxis
->Con el signo $ apuntamos o referenciamos a la variable en sí
done
----------------------------------------------------------------------
() -> Parentesis para una expresión aritmetica es decir > < = ! etc
[] -> Corchetes para una expresion más verbal lt gt eq etc
----------------------------------------------------------------------
#! /bin/bash
num=4
while [ $num -le 20 ] -> le _ menor o igual
do
if[ $((num % 2)) -eq 0] -> Si num divido dos me da iguala o, imprimime el numero
then
echo $num
fi
num=$(( num + 1 )) -> Le sumamos una unidad a la variable
done
->Imprimimos los números pares
----------------------------------------------------------------------
#! /bin/bash
num=4
while [ $num -le 20 ] -> le _ menor o igual
do -> % el resto
if[ $((num % 2)) -ne 0] -> Si num divido dos no da iguala o, imprimime el numero
then
echo $num
fi
num=$(( num + 1 )) -> Le sumamos una unidad a la variable
done
->Imprimimos los números impares
--------------------------------------
#! /bin/bash
num=4
while [ $num -le 20 ]
do
if[ $((num % 2)) -ne 0]
then
echo $(( num * 2))
fi
num=$(( num + 1 ))
done
-> Devuelve los numeros impares, multiplicados por 2 ( 2, 6, 10, 14, 18, 22, 26, etc)
--------------------------------------
#! /bin/bash
num=1
until [ $num -le 20 ] -> En vez de comprobar que lo de dentro sea verdadero, until, revisa que sea falsa
do
if[ $((num % 2)) -ne 0]
then
echo $(( num * 2))
fi
num=$(( num + 1 ))
done
-> No ejecuta, ya que until espera que se no se cumpla la condición.
--------------------------------------
#! /bin/bash
num=1
until [ $num -ge 20 ] -> En vez de comprobar que lo de dentro sea verdadero, until, revisa que sea falsa
-> Es una negación
do
if[ $((num % 2)) -ne 0]
then
echo $(( num * 2))
fi
num=$(( num + 1 ))
done
-> Se ejecuta, ya que until espera que se no se cumpla la condición.
-> El until pregunta lo contrario, casi que no que se usa.
--------------------------------------
For
#! /bin/bash
for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 199 18 19 20
do
if[ $((i % 2)) -ne 0 ]
then
echo $((i * 2))
fi
done
--------------------------------------
#! /bin/bash
for (( i=0; i<29 ; i++ )) -> Condicion inicial, condicion a cumplir y condicion de incremento
do
if[ $((i % 2)) -ne 0 ]
then
echo $((i * 2))
fi
done
----------------------------------------------------------------------
#! /bin/bash
for (( i=20; i>0 ; i-- )) -> Invirtiendo las condiciones
do
if[ $((i % 2)) -ne 0 ]
then
echo $((i * 2))
fi
done
----------------------------------------------------------------------
#! /bin/bash
for (( i=20; i>0 ; i-- )) -> Invirtiendo las condiciones
do
if[ $((i % 2)) -ne 0 ]
then
echo $((i * 2))
fi
done
--------------------------------------
#! /bin/bash
limite=0
inicio=20
for (( i=$inicio ; i>$limite ; i--))
do
if[ $((i % 2)) -ne 0 ]
then
echo $(( i * 2))
fi
done
----------------------------------------------------------------------
:colorscheme
:colorscheme darkblue ->Ejemplo
----------------------------------------------------------------------
Cudi - Parte 2
---- Desde Vim
#! /bin/bash
variable="hola"
echo $variable
-> sudo chmod u+x clase.sh -> Le damos permisos
-> ./clase.sh -> Ejecutamos
----------------------------------------------------------------------
Cuando colocamos el singo $ nos referimos al contenido de la variable
Cuando colocamos sin el signo $ nos referimos a la caja en sí, la variable
----------------------------------------------------------------------
$! /bin/bash
echo $@
-> ls -l -> Más información.
-> ./clase.sh a b c d l -> Nos imprime desde el echo $@
$@ es como una lista con todos los argumentos que pasamos
----------------------------------------------------------------------
$! /bin/bash
echo $1 -> con el numero indicamos la posicion
-> ./clase.sh a b c d l
a -> imprime el primer argumento.
----------------------------------------------------------------------
$! /bin/bash
echo $2 $3 -> con el numero indicamos la posicion
-> ./clase.sh a b c d l
b c -> imprime el segundo y el tercero
----------------------------------------------------------------------
->./clase.sh -1
-------------------------------------------------
#! /bin/bash
if [[ $1 = "-i" ]]
then
echo hola
fi
-> .clase.sh -i
hola -> imprime hola, si no le pasamos el -i no imprime nada
----------------------------------------------------------------------
Evitar el "Hardcodeo" de una variable, es decir, no almacenarla en una variable y escribir el valor literamente dentro de la función
----------------------------------------------------------------------
----------------------------------------------------------------------
#! /bin/bash
OPCION_IMPRIMIR="-i"
if [[ $1 = $OPCION_IMPRIMIR ]]
then
echo hola
fi
-> .clase.sh -i
hola
----------------------------------------------------------------------
Si se usan mayúsculas en una variable, será una variable que no será modificada en un futuro
----------------------------------------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
if [[ $1 = OPCION_IMPRIMIR ]]
then
echo hola
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 -> Segundo argumento $2, listamos el argumento indicado
else
echo algo
fi
-> ./clase.sh -l /home
----------------------------------------------------------------------
----------------------------------------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
if [[ $1 = OPCION_IMPRIMIR ]]
then
echo hola
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 -> Segundo argumento $2, listamos el argumento indicado
else
echo Error: Argumentos invalidos -> información para el usuario
fi
-> ./clase.sh -l /home
----------------------------------------------------------------------
Ahora no mostraremos por pantalla sino que guardaremos en un archivo indicado.
Redirreción
----------------------------------------------------------------------
#! /bin/bash
echo $# ->Nos devuelve la cantidad de argumentos que le pasamos al programa, de esta manera corroboramos en el ejemplo anterior la cantidad de argumentos esperados (2)
->sudo chmod -x a.sh
-> ./a.sh
->imprime 0
-> ./a.sh 1 2
->imprime 2
-> ./a.sh 1 2 f
->Imprimime 3
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
if [[ $1 = OPCION_IMPRIMIR ]]
then
echo hola
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 > $PATH_ARCHIVO -> Redireccionamos con >
else
echo Error: Argumentos invalidos
fi
-> ./clase.sh -l /home
-> cat archivo
mint
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
function imprimir(){
echo hola
}
if [[ $1 = OPCION_IMPRIMIR ]]
then
imprimir ->Llamamos la función
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 > $PATH_ARCHIVO
else
echo Error: Argumentos invalidos
fi
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
function imprimir(){
echo $1 -> Estos variables son propias de la función
-> Distinta al de afuera para el script
}
if [[ $1 = OPCION_IMPRIMIR ]]
then
imprimir "chau" ->Llamamos la función cona argumentos
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 > $PATH_ARCHIVO
else
echo Error: Argumentos invalidos
fi
./clase.sh -i
chau ->Imprime el primer argumento
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
function imprimir(){
echo $@ ->Imprime todos los argumentos
echo $2 ->Imprime el hola
}
if [[ $1 = OPCION_IMPRIMIR ]]
then
imprimir "chau" "hola" ->1° argumento, 2° argumento
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 > $PATH_ARCHIVO
else
echo Error: Argumentos invalidos
fi
./clase.sh -i
chau hola
hola
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
function imprimir(){
echo $@
}
if [[ $1 = OPCION_IMPRIMIR ]]
then
imprimir $@ -> Imprime todos los argumentos que reciba el script
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 > $PATH_ARCHIVO
else
echo Error: Argumentos invalidos
fi
./clase.sh -i hola chau
-i hola chau
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
function imprimir(){
echo $2 -> Tomará solo el segundo argumento
}
if [[ $1 = OPCION_IMPRIMIR ]]
then
imprimir $@ -> Imprime todos los argumentos que reciba el script
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 > $PATH_ARCHIVO
else
echo Error: Argumentos invalidos
fi
./clase.sh -i hola chau
hola ->Imprime el segundo
--------------------------------------
Mejor así, siendo lo mismo que lo anterior, el funcionamiento es distinto
Por lo general la función recibe lo que deseamos que haga..
En este caso llamamos a la función solo con el segundo argumento y ya.
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
function imprimir(){
echo $@ -> Recibe todos los argumentos
}
if [[ $1 = OPCION_IMPRIMIR ]]
then
imprimir $2 -> Imprime solo el segundo argumento
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 > $PATH_ARCHIVO
else
echo Error: Argumentos invalidos
fi
./clase.sh -i hola chau -> Pasamos argumentos
hola ->Imprime el segundo
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
function imprimir(){
echo $@ -> Recibe todos los argumentos, el @2 y el hola
}
if [[ $1 = OPCION_IMPRIMIR ]]
then
imprimir $2 "hola" -> Imprime solo el segundo argumento y hola
elif [[ #1 = $OPCION_LISTAR ]]
then
ls $2 > $PATH_ARCHIVO
else
echo Error: Argumentos invalidos
fi
./clase.sh -i hola chau
hola hola -> Imprime los dos
./clase.sh -i hola chau > archivo
cat archivo
hola hola
--------------------------------------
Organizando el código con una nueva función listar
--------------------------------------
#! /bin/bassh
OPCION_IMPRIMIR="-i"
OPCION_LISTAR="-l"
PATH_ARCHIVO="archivo"
function imprimir(){
echo $@
}
function listar(){
ls $l > $2 ->/home > archivo
}
if [[ $1 = OPCION_IMPRIMIR ]]
then
imprimir $2 $3
elif [[ #1 = $OPCION_LISTAR ]]
then
listar $2 $PATH_ARCHIVO -> Segundo argumento $2, es /home más el Path
else
echo Error: Argumentos invalidos
fi
./clase.sh -l /home
cat archivo
mint
--------------
4. Calculando cuánto ocupa un directorio
Para saber los bytes totales que ocupen los directorios
--------------------------------------------------------
-> Para testear si existe un fichero -f
#!/bin/bash
if [ -f $1 ]; then
echo "El fichero existe"
else
echo "El fichero no existe"
fi
-> ./script4.sh 1.txt
-> El fichero existe
--------------------------------------------------------
-> Para testear si existe un directorio -d
#!/bin/bash
if [ -d $1 ]; then
echo "El fichero existe"
else
echo "El fichero no existe"
fi
-> ./script5.sh prueba1 -> Al crearlo lo comprueba
-> El directorio existe
--------------------------------------------------------
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1 -> Con exit 1, indicamos que hay un error, si es exit 0, todo ok
fi
--------------------------------------------------------
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1
fi
names=`ls $1`
echo $names
--------------------------------------------------------
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1
fi
for f in `ls $1`; do
echo "Recorriendo el fihcero $f"
done
--------------------------------------------------------
-> En linux una ruta que tiene varias barras se interpreta como una sola /////// es igual a /
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1
fi
for f in `ls $1`; do
echo "$1/$f"
done
--------------------------------------------------------
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1
fi
for f in `ls $1`; do
name="$1/$f" -> Obtenemos la ruta completa del fichero, con
if [ -f $name ]; then
echo $name
fi
done
->./script6.sh ../Bash/
-> Nos imprime solo los ficheros
--------------------------------------------------------
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1
fi
for f in `ls $1`; do
name="$1/$f"
if [ -f $name ]; then
bytes=`ls -l $name` -> Imprime todo
echo $bytes
fi
done
--------------------------------------------------------
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1
fi
for f in `ls $1`; do
name="$1/$f"
if [ -f $name ]; then
bytes=`ls -l $name | cut -d " " -f 5` -> Imprime los bytes
echo $bytes
fi
done
-> ./script7.sh Pruebas/
->11
->9 -> Imprime los bytes
->18
--------------------------------------------------------
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1
fi
for f in `ls $1`; do
name="$1/$f"
if [ -f $name ]; then
bytes=`ls -l $name | cut -d " " -f 5` -> Imprime los bytes
echo "Fichero $name ocupa $bytes bytes"
fi
done
-> ./script7.sh Pruebas/
-> Fichero Pruebas//f1.txt ocupa 11 bytes
-> Fichero Pruebas//f2.txt ocupa 9 bytes
-> Fichero Pruebas//f3.txt ocupa 18 bytes
--------------------------------------------------------
Ahora para calcular el total
#!/bin/bash
if [ ! -d $1 ]; then
echo "Error : El directirio no existe"
exit 1
fi
total=0
for f in `ls $1`; do
name="$1/$f"
if [ -f $name ]; then
bytes=`ls -l $name | cut -d " " -f 5` -> Imprime los bytes
echo "Fichero $name ocupa $bytes bytes"
(( total = $total + $bytes ))
fi
done
-> ./script7.sh Pruebas/
-> Fichero Pruebas//f1.txt ocupa 11 bytes
-> Fichero Pruebas//f2.txt ocupa 9 bytes
-> Fichero Pruebas//f3.txt ocupa 18 bytes
-> Total: 38 bytes
--------------------------------------------------------
echo -e "\nTotal: $total bytes" -> echo -e interpreta los caracteres escapados, ejemplo para \n
--------------------------------------------------------
con tr se usa para borrar caracteres -> man tr
#!/bin/bash
if [ ! -d $1 ]; then -> Comprobamos por directorio
echo "Error : El directirio no existe"
exit 1
fi
total=0
for f in `ls $1`; do
name="$1/$f" -> Concatenamos la ruta completa
if [ -f $name ]; then -> Testeamos si hay ficheros
bytes=`ls -l $name | cut -d " " -f 5`
echo "Fichero $name ocupa $bytes bytes" | tr -s / -> Siempre saca una barra
(( total += $bytes )) -> Calculamos el total
fi
done
echo -e "\nTotal: $total bytes"
5. Automatiza tus tareas con bash
Haremos un script que reciba 4 parámetros..
-El nombre de los ficheros-
-La extensiòn-
-El número-
-La ruta-
--------------------------------------------------------
#!/bin/bash
error(){
echo $1
exit 1
}
if [ $# -ne 4 ]; then
error "Uso: script nombre extensión número ruta"
fi
if [ ! -d $4 ]; then
error "Error : El directorio no existe"
fi
if [ $3 -lt 1 ]; then
error "Error: El numero de ficheros no puede ser menor que 1"
fi
for (( i = 1; i<= $3; i++ )); do
name="$4/$1$i.$2"
if [ $i -lt 10 ]; then
name="$4/$10$i.$2"
fi
touch $name
echo "Fichero $name creado" | tr -s /
done
6. Añade prefijos a tus archivos de música
#!/bin/bash
error(){
echo $1
exit 1
}
#Comprobar que el número de parámetros es correcto
if [ $# -ne 2 ]; then
error "Uso: script prefijo ruta"
fi
#Comprobar que el directorio existe
if [ ! -d $2 ]; then
error "Error : El directorio no existe"
fi
#Recorrer cada fichero del directorio
for f in `ls $2`; do
# Guardar en una varaible el nombre actual con la ruta completa
name="$2/$f"
# Guardar en una variable el nombre nuevo
new_name="$2/$1$f" -> Más informaciòn
# Cambiar el nombre del fichero
mv $name $new_name
# Imprmir lo que está haciendo el script
echo "$nanme -> $new_name" | tr -s /
done
--------------------------------------------------------
Que es lo mismo que..
#!/bin/bash
error(){
echo $1
exit 1
}
#Comprobar que el número de parámetros es correcto
if [ $# -ne 2 ]; then
error "Uso: script prefijo ruta"
fi
#Comprobar que el directorio existe
if [ ! -d $2 ]; then
error "Error : El directorio no existe"
fi
#Recorrer cada fichero del directorio
for f in `ls $2`; do
mv "$2/$f" "$2/$1$f" -> Más simplificado
done
--------------------------------------------------------
#!/bin/bash
error(){
echo $1
exit 1
}
#Comprobar que el número de parámetros es correcto
if [ $# -ne 2 ]; then
error "Uso: $0 prefijo ruta" -> $0 Hacemos referencia al nombre propio script para mostrarlo
fi
#Comprobar que el directorio existe
if [ ! -d $2 ]; then
error "Error : El directorio no existe"
fi
#Recorrer cada fichero del directorio
for f in `ls $2`; do
mv "$2/$f" "$2/$1$f"
done
7. Sintaxis
# Declarar variable:
cadena=texto
cadena="Texto con espacios"
numero=5
# Para almacenar la salida de un comando en una variable
comando=`ls -l | tail -n +2`
# Se puede poner dobles comillas dentro de los backticks
comando=`ls -l | grep "Directorio Con Espacios"`
# Acceder al valor de la variable:
$variable
# Condicional if:
if [ $numero -eq 5 -o $numero -eq 7 ]; then
# Código
elif [ $numero -lt 3 ]; then
# Código
else
# Código
fi
# Usar [[ ]] Para comparar cadenas, permite expresiones regulares:
if [[ $cadena == [sS] ]]; then
# Código
fi
# Para comparar números:
# -gt => greater than
# -ge => greater or equal
# -lt => lower than
# -le => lower or equal
# -eq => equal
# -ne => not equal
# Operadores lógicos:
# -a => and
# -o => or
# Bucle for:
for (( i = 0; i < 5; i++ )); do
# Código, para acceder al valor de i se usa $i
done
# Si queremos que i se incremente con otro valor que no sea uno:
for (( i = 0; i < 10; i += 5 )); do
# Código
done
# Bucle for in:
for i in `ls`; do
# Código
done