Cómo escribir un script de shell
Cómo escribir un script de shell
Este artículo combina una gran cantidad de ejemplos para explicar cómo escribir un script de shell.
Por qué programar shell
En los sistemas Linux, aunque existen varias herramientas de interfaz gráfica, vender sigue siendo una herramienta muy flexible. Shell no es sólo una colección de comandos, sino un excelente lenguaje de programación. Puede automatizar una gran cantidad de tareas utilizando el shell. El shell es particularmente bueno en tareas de administración del sistema, especialmente aquellas donde la facilidad de uso, el mantenimiento y la portabilidad son más importantes que la eficiencia.
Ahora, echemos un vistazo a cómo funciona el shell:
Crear un script
Hay muchos shells diferentes en Linux, pero normalmente usamos bash ( bourne again shell) para la programación de shell porque bash es gratuito y fácil de usar. Por lo tanto, todos los scripts proporcionados por el autor en este artículo usan bash (pero en la mayoría de los casos, estos scripts también se pueden ejecutar en el shell bourne, la hermana mayor de bash).
Al igual que otros lenguajes, utilizamos cualquier editor de texto, como nedit, kedit, emacs, vi, etc. para escribir nuestro programa shell.
El programa debe comenzar con la siguiente línea (debe ser la primera línea del archivo):
#!/bin/sh
El símbolo #! se utiliza Le dice al sistema que los parámetros que le siguen son los programas utilizados para ejecutar el archivo. En este ejemplo usamos /bin/sh para ejecutar el programa.
Cuando editas un script, si quieres ejecutarlo, también debes hacerlo ejecutable.
Para hacer ejecutable un script:
chmod +x filename
Luego puedes ejecutar tu script escribiendo: ./filename.
Comentarios
Al realizar la programación de shell, una oración que comienza con # indica un comentario hasta el final de la línea. Recomendamos sinceramente utilizar comentarios en sus programas. Si utiliza comentarios, podrá comprender rápidamente qué hace el script y cómo funciona, incluso si no lo ha utilizado durante mucho tiempo.
Variables
En otros lenguajes de programación hay que utilizar variables. En la programación de shell, todas las variables se componen de cadenas y no es necesario declarar variables. Para asignar un valor a una variable, puedes escribir:
Nombre de la variable=valor
Para obtener el valor de la variable, puedes agregar un signo de dólar ($) delante de la variable. :
#!/bin/sh
#Asignar un valor a una variable:
a="hola mundo"
# Ahora imprima el contenido de la variable a:
echo "A es:"
echo $a
Ingrese lo anterior en su editor y guárdelo como un archivo primero. Luego ejecute chmod +x primero
para hacerlo ejecutable y finalmente ingrese ./first para ejecutar el script.
Este script generará:
A es:
hola mundo
A veces, los nombres de las variables se confunden fácilmente con otro texto, por ejemplo. :
num=2
echo "este es el $numnd"
Esto no imprime "este es el segundo", solo imprime "este es el ", porque el shell buscará el valor de la variable numnd, pero esta variable no tiene valor.
Puedes usar llaves para indicarle al shell que lo que queremos imprimir es la variable num:
num=2
echo "this is the ${num}nd"
Esto se imprimirá: este es el segundo
Hay una serie de variables que el sistema configura automáticamente, que se analizarán más adelante cuando se utilicen estas variables.
Si necesita trabajar con expresiones matemáticas, entonces necesita utilizar un programa como expr (ver más abajo).
Además de las variables generales del shell que sólo son válidas dentro del programa, también existen variables de entorno. Las variables procesadas por la palabra clave export se denominan variables de entorno. No discutiremos las variables de entorno porque normalmente solo se usan en scripts de inicio de sesión.
Comandos de Shell y control de procesos
Se pueden utilizar tres tipos de comandos en los scripts de Shell:
1) Comandos de Unix:
Aunque Puede utilizar cualquier comando de Unix en un script de shell, pero existen algunos comandos relativamente más utilizados. Estos comandos se utilizan normalmente para operaciones de archivos y texto.
Sintaxis y funciones de comandos comunes
echo "algo de texto": imprime contenido de texto en la pantalla
ls: lista de archivos
wc -l filewc -w filewc -c file: Cuente el número de líneas en el archivo Cuente el número de palabras en el archivo Calcule el número de caracteres en el archivo.
cp sourcefile destfile: Copia del archivo.
mv oldname newname: cambie el nombre del archivo o mueva el archivo
rm file: elimine el archivo
grep 'pattern' file: busque una cadena en el archivo, por ejemplo: grep 'searchstring' file.txt
cut -b colnum file: especifique el rango de contenido del archivo que se mostrará y envíelo al dispositivo de salida estándar. Por ejemplo: envíe el quinto a. Corte del noveno carácter de cada línea -b5-9 file.txt Nunca se confunda con el comando cat, estos son dos comandos completamente diferentes
cat file.txt: envíe el contenido del archivo al dispositivo de salida estándar (pantalla)
archivo algún archivo: obtiene el tipo de archivo
leer var: solicita entrada al usuario y asigna la entrada a la variable
ordenar archivo.txt : Ordenar las líneas en el archivo file.txt
uniq: Eliminar las filas y columnas que aparecen en el archivo de texto Por ejemplo: ordenar file.txt
expr. operaciones matemáticas Ejemplo: sumar 2 y 3expr 2 "+" 3
buscar: buscar archivos como: buscar buscar según el nombre del archivo -name nombre de archivo -print
tee: Envíe datos al dispositivo de salida estándar (pantalla) y al archivo. Por ejemplo: somecommand | tee outfile
archivo de nombre base: Devolver Un nombre de archivo que no incluya una ruta, por ejemplo: nombre base /bin/tux. return tux
dirname file: devuelve la ruta al archivo, por ejemplo: dirname /bin/tux devolverá /bin
head file: imprime las primeras líneas de un archivo de texto
archivo final: imprime las últimas líneas de un archivo de texto
sed: Sed es un programa básico de búsqueda y reemplazo. Puede leer texto de la entrada estándar (como una canalización de comandos) y enviar los resultados a la salida estándar (la pantalla). Este comando utiliza expresiones regulares (ver Referencia) para buscar. No confundir con comodines en el shell.
Por ejemplo: reemplace linuxfocus con LinuxFocus: cat text.file | sed 's/linuxfocus/LinuxFocus/' > newtext.file
awk: awk se usa para extraer campos de archivos de texto. De forma predeterminada, el separador de campo es un espacio. Puede utilizar -F para especificar otros separadores. cat file.txt | awk -F, '{print $1 "," $3 }'Aquí usamos como separador de campos para imprimir el primer y tercer campo al mismo tiempo. Si el contenido del archivo es el siguiente: Adam Bor, 34, IndiaKerry Miller, 22, EE. UU., el resultado del comando es: Adam Bor, IndiaKerry Miller, EE. UU.
2) Concepto: canalización, redirección y acento grave
Estos no son comandos del sistema, pero son realmente importantes.
La tubería (|) toma la salida de un comando como entrada para otro comando.
grep "hello" file.txt | wc -l
Busque líneas que contengan "hello" en file.txt y cuente el número de líneas.
La salida del comando grep aquí se utiliza como entrada del comando wc. Por supuesto, puedes utilizar varios comandos.
Redirección: genera los resultados del comando en un archivo en lugar de la salida estándar (pantalla).
>Escribir en el archivo y sobrescribir el archivo antiguo
>>Agregar al final del archivo, conservando el contenido del archivo antiguo.
Barra invertida
Utilice la barra invertida para utilizar la salida de un comando como parámetro de línea de comando para otro comando.
Comando:
find . -mtime -1 -type f -print
Se utiliza para buscar las últimas 24 horas (-mtime –2 significa las últimas 48 horas) archivos modificados. Si desea empaquetar todos los archivos encontrados en un solo paquete, puede utilizar el siguiente script:
#!/bin/sh
# Las marcas son comillas invertidas (`), no comillas normales. ('):
tar -zcvf lastmod.tar.gz `find .mtime -1 -type f -print`
3) Control de procesos
La expresión "si" ejecuta la parte después de entonces si la condición es verdadera:
if ....; entonces
....
elif . ..; entonces
....
si no
....
fi
En en la mayoría de los casos, puede utilizar comandos de prueba para probar las condiciones. Por ejemplo, puede comparar cadenas, determinar si un archivo existe y es legible, etc.
Por lo general, "[ ]" se utiliza para representar pruebas condicionales. Tenga en cuenta que los espacios aquí son importantes. Asegúrese de que haya espacios entre corchetes.
[ -f "somefile" ]: determina si es un archivo
[ -x "/bin/ls" ]: determina si /bin/ls existe y tiene permisos ejecutables
[ -n "$var" ]: Determina si la variable $var tiene un valor
[ "$a" = "$b" ]: Determina si $a y $ b son iguales
Ejecute la prueba man para ver todos los tipos que se pueden comparar y juzgar mediante expresiones de prueba.
Ejecute el siguiente script directamente:
#!/bin/sh
if [ "$SHELL" = "/bin/bash" ]; / p>
echo "tu shell de inicio de sesión es bash (bourne again shell)"
else
echo "tu shell de inicio de sesión no es bash sino $SHELL"
fi
La variable $SHELL contiene el nombre del shell de inicio de sesión, que comparamos con /bin/bash.
Operadores de acceso directo
A los amigos que estén familiarizados con el lenguaje C les puede gustar la siguiente expresión:
[ -f "/etc/shadow" ] && echo "This la computadora usa contraseñas ocultas"
Aquí && es un operador de acceso directo. Si la expresión de la izquierda es verdadera, se ejecutará la declaración de la derecha. También puedes considerarlo como la operación AND en operaciones lógicas. El ejemplo anterior indica que si el archivo /etc/shadow existe, se imprimirá "Esta computadora usa contraseñas ocultas". La misma operación OR (||) también está disponible en la programación de shell. Aquí hay un ejemplo:
#!/bin/sh
mailfolder=/var/spool/mail/james
[ -r "$mailfolder" ] ' '{ echo "No se puede leer $mailfolder" ; salir 1;
echo "$mailfolder tiene correo de:"
grep "^De " $mailfolder
El script primero determina si la carpeta de correo es legible. Si es legible, imprima la línea "De" en el archivo. Si no es legible, la operación OR entra en vigor y el script se cierra después de imprimir un mensaje de error. Aquí hay un problema, es decir, debemos tener dos comandos:
-Imprimir mensaje de error
-Salir del programa
Usamos llaves para finalizar la función anónima El formulario junta dos comandos y los usa como un solo comando. Las funciones generales se mencionan a continuación.
También podemos usar expresiones if para hacer cualquier cosa sin los operadores AND u, pero es mucho más conveniente usar los operadores AND u.
Las expresiones entre mayúsculas y minúsculas se pueden utilizar para hacer coincidir una cadena determinada en lugar de un número.
caso... en
...) haz algo aquí ;;
esac
Veamos un ejemplo.
El comando file puede identificar el tipo de archivo de un archivo determinado, por ejemplo:
archivo lf.gz
Esto devolverá:
lf.gz: gzip datos comprimidos, desinflados, nombre de archivo original,
Última modificación: lunes 27 de agosto 23:09:18 2001, sistema operativo: Unix
Aprovechamos esto y escribimos un script llamado smartzip, cual El script puede descomprimir automáticamente archivos comprimidos de tipo bzip2, gzip y zip:
#!/bin/sh
ftype=`file "$1"`
case "$ftype" en
"$1: archivo Zip"*)
descomprimir "$1" ;;
"$1: comprimido gzip"*)< / p>
gunzip "$1" ;;
"$1: bzip2 comprimido"*)
bunzip2 "$1" ;;
*) error " El archivo $1 no se puede descomprimir con smartzip";;
esac
Puedes notar que aquí usamos una variable especial $1. Esta variable contiene el valor del primer parámetro pasado al programa. En otras palabras, cuando ejecutamos:
smartzip artículos.zip
$1 es la cadena artículos.zip
la expresión select es una extensión de bash, especialmente buena en uso interactivo. El usuario puede elegir entre un conjunto diferente de valores.
seleccione var en... ; do
break
hecho
.... ahora se puede usar $var. ..
Aquí tienes un ejemplo:
#!/bin/sh
echo "¿Cuál es tu sistema operativo favorito?"
seleccione var en "Linux" "Gnu Hurd" "BSD gratuito" "Otro"; do
break
done
echo "Has seleccionado $var"
El siguiente es el resultado de ejecutar el script:
¿Cuál es tu sistema operativo favorito?
1) Linux
2) Gnu Hurd
3) BSD gratuito
4) Otro
# 1
Has seleccionado Linux
También puedes usar la siguiente expresión de bucle en el shell:
mientras...; hacer
....
hecho
El bucle while se ejecutará hasta que la expresión sea verdadera. se ejecutará mientras la expresión que probamos sea verdadera. La palabra clave "break" se utiliza para salir del bucle. La palabra clave "continuar" se utiliza para saltar directamente al siguiente bucle sin ejecutar la parte restante.
La expresión del bucle for mira una lista de cadenas (cadenas separadas por espacios) y la asigna a una variable:
for var in ....; > p>
....
hecho
En el siguiente ejemplo, ABC se imprimirá en la pantalla respectivamente:
#!/bin / sh
for var in A B C ; do
echo "var is $var"
done
Lo siguiente es más útil El script showrpm, su función es imprimir información estadística de los paquetes RPM:
#!/bin/sh
# enumera un resumen del contenido de varios paquetes RPM
# USO: showrpm rpmfile1 rpmfile2 ...
# EJEMPLO: showrpm /cdrom/RedHat/RPMS/*.rpm
para paquete rpm en $*; p>
if [ -r "$rpmpackage" ];entonces
echo "=============== $rpmpackage ======== == ===="
rpm -qi -p $rpmpackage
else
echo "ERROR: no se puede leer el archivo $rpmpackage"
fi
hecho
Aquí aparece la segunda variable especial $*, que contiene los valores de todos los parámetros de línea de comando ingresados. Si ejecuta showrpm openssh.rpm w3m.rpm webgrep.rpm
En este momento $* contiene 3 cadenas, a saber, openssh.rpm, w3m.rpm y webgrep.rpm
Quotes.
El programa expande los comodines y las variables antes de pasar cualquier parámetro al programa. La llamada expansión aquí significa que el programa reemplazará los caracteres comodín (como *) con nombres de archivo apropiados y reemplazará las variables con valores de variable. Para evitar que el programa realice esta sustitución, puede utilizar comillas: Veamos un ejemplo, suponiendo que hay algunos archivos en el directorio actual, dos archivos jpg, mail.jpg y tux.jpg.
#!/bin/sh
echo *.jpg
Esto imprimirá el resultado de "mail.jpg tux.jpg".
Las comillas (simples y dobles) evitarán esta expansión comodín:
#!/bin/sh
echo "*.jpg"
echo '*.jpg'
Esto imprimirá "*.jpg" dos veces.
Las comillas simples son más restrictivas. Previene cualquier expansión variable. Las comillas dobles evitan la expansión con comodines pero permiten la expansión variable.
#!/bin/sh
echo $SHELL
echo "$SHELL"
echo '$SHELL'
El resultado de la ejecución es:
/bin/bash
/bin/bash
$SHELL
Finalmente, hay Una forma de evitar esta expansión es utilizar el carácter de escape: la barra invertida:
echo *.jpg
echo $SHELL
Esto generará:
*.jpg
$SHELL
Aquí documentos
Al pasar varias líneas de texto a un comando, aquí documentos (Nota del traductor: Todavía no he visto una traducción adecuada de esta palabra) es un buen método. Es útil escribir un texto útil para cada script. En este momento, si tenemos los documentos aquí, no tenemos que usar la función de eco para generarlos línea por línea. Un "documento aquí" comienza con <<, seguido de una cadena, que también debe aparecer al final del documento aquí. Aquí hay un ejemplo en el que cambiamos el nombre de varios archivos y usamos estos documentos para imprimir la ayuda:
#!/bin/sh
# tenemos menos de 3 argumentos Imprime el texto de ayuda:
if [ $# -lt 3 ] ; entonces
cat <
ren: cambia el nombre de varios archivos usando expresiones regulares sed
USO: ren 'regexp' archivos de 'reemplazo'...
EJEMPLO: cambiar el nombre de todos los archivos *.HTM en *.html:
ren 'HTM$' ' html' *.HTM
AYUDA
salir 0
fi
OLD="$1 "
NUEVO ="$2"
# El comando shift elimina un argumento de la lista de
# argumentos de la línea de comando.
shift
shift
# $* contiene ahora todos los archivos:
para el archivo en $*; do
if [ -f "$file" ] entonces
newfile=`echo "$file" | sed "s/${OLD}/${NEW}/g"`
if [ - f "$newfile" ]; /p>
echo "ERROR: $newfile ya existe"
else
echo "cambiando el nombre de $file a $newfile..."
mv "$file" "$newfile"
fi
fi
hecho
Este es un ejemplo más complejo. Analicemos esto en detalle. La primera expresión if determina si los parámetros de la línea de comando de entrada son menores de 3 (la variable especial $# representa el número de parámetros incluidos). Si los parámetros de entrada son inferiores a 3, el texto de ayuda se pasa al comando cat, que luego lo imprime en la pantalla. El programa se cierra después de imprimir el texto de ayuda.
Si los parámetros de entrada son iguales o mayores a 3 asignamos el primer parámetro a la variable ANTIGUO y el segundo parámetro a la variable NUEVO. A continuación, usamos el comando shift para eliminar el primer y segundo parámetro de la lista de parámetros, de modo que el tercer parámetro original se convierta en el primer parámetro de la lista de parámetros $*. Luego iniciamos el ciclo y la lista de argumentos de la línea de comando se asigna a la variable $file uno por uno. Luego determinamos si el archivo existe y, si existe, usamos el comando sed para buscar y reemplazar para generar un nuevo nombre de archivo. Luego asigne el resultado del comando dentro de la barra invertida a un nuevo archivo. De esta manera logramos nuestro objetivo: obtuvimos el nombre de archivo antiguo y el nombre de archivo nuevo. Luego use el comando mv para cambiar el nombre.
Función
Si escribe algunos programas un poco más complejos, encontrará que el mismo código puede usarse en varios lugares del programa y también encontrará que, si utilizar funciones, será mucho más conveniente. Una función se ve así:
nombredefunción()
{
# dentro del cuerpo $1 es el primer argumento dado a la función
# $2 el segundo...
cuerpo
}
Necesitas declarar la función al comienzo de cada programa.
Aquí hay un script llamado xtitlebar, usando este script puedes cambiar el nombre de la ventana del terminal. Aquí se utiliza una función llamada ayuda. Como puede ver, esta función definida se usa dos veces.
#!/bin/sh
# vim: set sw=4 ts=4 et:
help()
{
cat <
xtitlebar -- cambia el nombre de un xterm, gnome-terminal o kde konsole
USO: xtitlebar [-h] "string_for_titelbar "
OPCIONES: -h texto de ayuda
EJEMPLO: xtitlebar "cvs"
AYUDA
salir 0
}
# en caso de error o si se da -h llamamos a la función ayuda:
[ -z "$1" ] && ayuda
[ "$1" = "-h" ] && ayuda
# envía la secuencia de escape para cambiar la barra de título xterm:
echo -e "33]0;$107"
#
Es una buena práctica de programación proporcionar ayuda en sus scripts para que sea más fácil para otros usuarios (y para usted) usar y comprender el script.
Parámetros de la línea de comando
Ya hemos visto variables especiales como $* y $1, $2... $9. Estas variables especiales contienen parámetros ingresados por el usuario desde la línea de comando. Hasta ahora, sólo hemos analizado alguna sintaxis simple de la línea de comandos (como algunos parámetros obligatorios y la opción -h para ver la ayuda). Pero a medida que escribe programas más complejos, es posible que necesite más opciones de personalización. La convención habitual es anteponer todos los parámetros opcionales con un signo menos, seguido del valor del parámetro (como un nombre de archivo).
Hay muchas formas de analizar los parámetros de entrada, pero el siguiente ejemplo que utiliza expresiones de casos es una buena manera.
#!/bin/sh
help()
{
cat <
Esto es una demostración genérica de un analizador de línea de comandos.
EJEMPLO DE USO: cmdparser -l hola -f -- -algún archivo1 algún archivo2
AYUDA
salir 0
}
mientras [ -n "$1" ]; hacer
case $1 en
-h) ayuda;shift 1;; se llama
-f) opt_f=1;shift 1;; # la variable opt_f está configurada
-l) opt_l=$2;shift 2;; # -l toma un argumento - > desplazar en 2
--) shift;break;; # fin de las opciones
-*) echo "error: no existe esa opción $1. -h para ayuda";salir 1 ;;
*) break;;
esac
hecho
echo "opt_f es $opt_f"
echo "opt_l es $opt_l"
echo "el primer argumento es $1"
echo "el segundo argumento es $2"
Puedes ejecutar el script de esta manera :
cmdparser -l hello -f -- -somefile1 somefile2
El resultado devuelto es:
opt_f es 1
opt_l es hola
el primer argumento es -algún archivo1
el segundo argumento es algún archivo2
¿Cómo funciona este script? El script primero recorre todos los parámetros de la línea de comando de entrada, compara los parámetros de entrada con la expresión de caso, establece una variable y elimina el parámetro si hay una coincidencia. Según la convención de los sistemas Unix, primero se debe introducir el parámetro que contiene el signo menos.
Ejemplos
Pasos generales de programación
Ahora analizaremos los pasos generales para escribir un script. Cualquier buen script debe tener ayuda y parámetros de entrada. Y es una muy buena idea escribir un pseudo script (framework.sh) que contenga la estructura del marco requerida por la mayoría de los scripts. En este momento, al escribir un nuevo script, solo necesitamos ejecutar el comando de copia:
cp framework.sh myscript
Luego inserte nuestra propia función.
Veamos dos ejemplos más:
Conversión de binario a decimal
El script b2d convierte un número binario (como 1101) al número decimal correspondiente.
Este también es un ejemplo del uso del comando expr para realizar operaciones matemáticas:
#!/bin/sh
# vim: set sw=4 ts=4 et:
help()
{
cat <
b2h -- convertir binario a decimal
USO: b2h [-h ] binarionum
OPCIONES: -h texto de ayuda
EJEMPLO: b2h 111010
devolverá 58
AYUDA
salir 0
}
error()
{
# imprime un error y sale
echo "$1"
salir 1
}
lastchar()
{
# retorno el último carácter de una cadena en $rval
if [ -z "$1" ] entonces
# cadena vacía
rval=""
return
fi
# wc pone algo de espacio detrás de la salida, es por eso que necesitamos sed:
numofchar=`echo -n "$1 " | wc -c | sed 's/ //g' `
# ahora corta el último carácter
rval=`echo -n "$1" | cut -b $ numofchar`
}
chop()
{
# elimina el último carácter de la cadena y lo devuelve en $rval
if [ -z "$1" ]; entonces
# cadena vacía
rval=""
return
fi
# wc pone algo de espacio detrás de la salida, por eso necesitamos sed:
numofchar=`echo -n "$1" | /g' `
if [ "$numofchar" = "1" ] entonces
# solo un carácter en la cadena
rval=""
return
fi
numofcharminus1=`expr $numofchar "-" 1`
# ahora corta todos menos el último carácter:
rval=`echo -n "$1" | cut -b 0-${numofcharminus1}`
}
mientras [ -n "$1" ];
caso $1 en
-h) ayuda;shift 1;; # se llama a la función de ayuda
--) shift;break;;
-*) error "error: no existe esa opción $1. -h fo
r ayuda";;
*) descanso;;
esac
hecho
# El programa principal
sum=0
peso=1
# se debe dar un argumento:
[ -z "$1" ] && ayuda
binnum="$1"
binnumorig="$1"
mientras [ -n "$binnum" ]; hacer
lastchar "$binnum"
if [ "$rval" = "1" ]; entonces
sum=`expr "$peso" "+" "$sum"`
fi
# eliminar la última posición en $binnum
cortar "$binnum"
binnum="$rval"
weight=`expr "$weight" "*" 2`
done
echo "binary $binnumorig is decimal $sum"
#
El El algoritmo utilizado por el script utiliza pesos numéricos decimales y binarios (1,2,4,8,16,.... Por ejemplo, el "10" binario se puede convertir en decimal de esta manera:
0). * 1 + 1 * 2 = 2
Para obtener un único número binario, usamos la función lastchar. Esta función usa wc -c para contar el número de caracteres y luego usa el comando cut para eliminarlos. último carácter. Elimina el último carácter.
File Looper
Quizás eres una de esas personas que quiere guardar todos los correos electrónicos salientes en un archivo, pero después de unos meses. , este archivo puede llegar a ser tan grande que el acceso al archivo se vuelve lento. El siguiente script rotar archivo puede resolver este problema.
Este script puede cambiar el nombre del archivo guardado de correo (asumiendo que es outmail) a outmail.1, y para outmail.1 se convierte en outmail.2 y así sucesivamente...
#!/bin/sh
# vim: set sw=4 ts=4 et:
ver="0.1"
help()
{
cat <
rotatefile - rotar el nombre del archivo
USO: rotar archivo [-h] nombre del archivo
OPCIONES: -h texto de ayuda
EJEMPLO: rotar archivo de salida
Esto cambiará, por ejemplo, el nombre de out.2 a out.3, de out.1 a out.2, de out a out.1
y cree un archivo de salida vacío
El número máximo es 10
versión $ver
AYUDA
salida 0
p>}
error()
{
echo "$1"
salir 1
}
mientras [ -n "$1" ]; hacer
caso $1 en
-h) ayuda;cambio 1;;
--) break;;
-*) echo "error: no existe esa opción $1. -h para ayuda";salir 1;;
*) break;;
esac
hecho
# verificación de entrada:
if [ -z "$1" ] entonces
; error "ERROR: debe especificar un archivo, use -h para obtener ayuda"
fi
filen="$1"
# cambie el nombre de cualquier .1, . 2 etc archivo:
para n en 9 8 7 6 5 4 3 2 1; hacer
if [ -f "$filen.$n" ];
p=`expr $n + 1`
echo "mv $filen.$n $filen.$p"
mv $filen.$n $filen.$ p
fi
hecho
# cambiar el nombre del archivo original:
if [ -f "$filen" ]; p>
echo "mv $filen $filen.1"
mv $filen $filen.1
fi
echo touch $filen
touch $filen
¿Cómo funciona este script? Luego de detectar que el usuario ha proporcionado un nombre de archivo, realizamos un bucle de 9 a 1. El archivo 9 pasa a llamarse 10, el archivo 8 pasa a llamarse 9, y así sucesivamente. Una vez completado el ciclo, le asignamos al archivo original el nombre Archivo 1 y creamos un archivo vacío con el mismo nombre que el archivo original.
Depuración
El comando de depuración más simple es, por supuesto, el comando echo. Puede utilizar echo para imprimir cualquier valor de variable siempre que sospeche que algo salió mal. Esta es la razón por la que la gran mayoría de los programadores de shell dedican el 80% de su tiempo a depurar programas.
La ventaja del programa shell es que no es necesario volver a compilarlo y no lleva mucho tiempo insertar un comando de eco.
El shell también tiene un modo de depuración real. Si hay errores en el script "strangescript", puedes depurarlo así:
sh -x Strangescript
Esto ejecutará el script y mostrará los valores de todas las variables. .
El shell también tiene un modo que no requiere ejecutar el script sino que simplemente verifica la sintaxis. Se puede utilizar así:
sh -n your_script
Esto devolverá todos los errores de sintaxis.