Comandos Linux 2015

whoami que nos dice quines somos nosotros

w que muestra qu usuarios se encuentran conectados
pwd En cualquier momento podemos saber el directorio en el que nos encontramos
el tabulador nos permite completar lneas
ALT+Fx cambiar de una consola virtual a otra
cp [-i] <ficheros> <fichero> | <directorio>. Copia uno o varios ficheros

Comandos:

if

estructura:
if condicin
then
comando1
elif condicin
then
comando
elif condicin
then
...
Fi

-z

#! /bin/bash
clear
read -p "Cual es tu nombre " respuesta
echo
if [ -z ${respuesta} ]
then
echo "No has escrito nada"
sleep 2
else
echo "Te llamas ${respuesta} y tu nombre
tiene ${#respuesta} letras"
fi

Cadena
Verdadero si la longitud de la cadena es igual a cero.

-n Cadena
Verdadero si la longitud de la cadena es distinto de cero.
Cadena1 !

= Cadena2

Verdadero si las cadenas no son iguales.

- d archivo
Verdadero si el archivo es un directorio.

-e archivo

#! /bin/bash
clear
if [ -d ${directorio} ]
then
read -p "Qu directorio ? "
directorio
read -n 2 -p "El directorio existe.
Quieres cambiarte a l ? "
respuesta
if [ "${respuesta}" != "si" ]
then
break
else
echo
cd ${directorio}
fi
else
echo "El directorio no existe"
fi

Edad de archivos
fecha de modificacin del fichero .

Verdadero si el archivo existe.

- w archivo
Verdadero si el archivo tiene permisos de escritura .

- x archivo

archivo1-nt archivo2
Verdadero si archivo1 es ms reciente
que archivo2 .

Verdadero si archivo es ejecutable.

- h archivo
- L fichero
Verdadero si archivo es un enlace simblico

archivo2 ot archivo1
Verdadero si archivo1 es ms antiguo
que archivo2 .

chmod 755 /ruta_del_script Para el usuario propietario

chmod 777 /ruta_del_script Para cualquier usuario
Una vez hecho todo lo anterior, usaremos:
nombredelscript.sh
Pero tambin podemos usar si es un shell script:
sh nombredelscript.sh

nombredelscript.sh

Lee por teclado las variables

El uso del archivo /dev/null como archivo

vaco para comprobar algunas
condicionales.
#! /bin/bash
clear
if `cd /tmp/prueba/ >/dev/null`
then
echo Pues si, es un directorio y contiene
ls -l
else
echo Pues va a ser que no es un directorio
fi

read .

read [opciones] nombre_variable1 nombre_variable2 nombre_variableN

Por ejemplo:
read -p Escribe tu nombre y tus apellidos nombre apellidos
-n num_car : Nmero mximo de caracteres que puedes introducir por teclado
-p frase : Te muestra por pantalla una frase para tu saber que debes introducir
-d delimitador : Especificas cual va a ser el delimitador
IFS es una variable de entorno que determina el delimitador de campos

comparaciones numrica
-eq - son iguales

#! /bin/bash
clear
# IFS es una variable de entorno que determina el delimitador de
#campos
# (que por defecto vale ),en este script queremos
# cambiarlo a , para escribir por teclado nombre,apellidos
IFS=,
read -p Introduce el nombre,apellidos : nombre apellidos
echo El nombre es $nombre y los apellidos son $apellidos

-ne - no son iguales

-lt menor que
-gt mayor que
-le - es menor o igual a
-ge es mayor o igual a

VARIABLES
$var: valor de var si est definida, si no nada.
${var}: igual que el anterior excepto que las llaves contienen el nombre de la
variable a ser evaluada.
${var-algo}: valor de var si est definida, si no algo.
${var=algo}: igual que el anterior excepto cuando var no est definida en cuyo caso
el valor de var pasa a ser algo.
${var?mensaje}: valor de var si est definida, si no escribe el mensaje en el terminal.
${var+algo}: algo si var est definida, si no nada.

EJEMPLO_
$ var1=4 # Le asigna el valor 4
$ echo El valor de var1 es ${var1}
El valor mostrado ser 4
$ echo El valor de la variable es ${var1+5}
Al estar definida, se utiliza el valor 5
$ echo El valor es $var1
Su valor sigue siendo 4

= (Cadena) Iguales
!= (Cadena) Diferentes

Array
La sintaxis para crear e inicializar un array es la siguiente:
nombre_array=(val1 val2 val3 ...) # Crea e inicializa un array
nombre_array[x]=valor # Asigna un valor al elemento x
Para acceder a un elemento del array se utiliza la siguiente sintaxis:
${nombre_array[x]} # Para acceder al elemento x
${nombre_array[*]} # Para consultar todos los elementos// crea una nica palabra con todos los elementos del array
${nombre_array[@]} # Para consultar todos los elementos // crea palabra distintas para cada elemento del array
Case

WHILE

La sintaxis de la orden case es

la siguiente:

while [ expresin ] # Mientras la

expresin sea cierta...
do
...
done
until [ expresin ] # Mientras la
expresin sea falsa...
do
...
done

case $var in
v1) ..
..
;;
v2|v3) ..
..
;;
*) .. # Caso por defecto
;;
esac

Un ejemplo del funcionamiento

de ambas rdenes sera:

ejemplo:
Un ejemplo de su funcionamiento
podra ser:

case $var in
1) echo La variable var es un uno ;;
2) echo La variable var es un dos ;;
*) echo La variable var no es ni un
uno ni un dos;;
esac
orden

select podemos solicitar al

usuario que elija una opcin de una lista

select opcin in [ lista ] ;

do
# bloque de rdenes
Done
mientras no se termine, bien con break o
bien con EOF. ser igual al valor de la
ltima orden ejecutada.
select
respuesta in "Ver contenido
directorio actual" \"Salir"
do
echo
Ha
seleccionado
la
opcin:
$respuesta
case $REPLY in
1) ls .
;;
2) break
;;
esac
done

En pantalla aparecera:
1) Ver contenido directorio actual
2) Salir

# Muestra todos los parmetros

while [ ! -z $1 ]
do
echo Parmetro: $1
shift
done
# Tambin muestra todos los
parmetros
until [ -z $1 ]
do
echo $1
shift
done

Las rdenes break y continue

sirven para interrumpir la
ejecucin secuencial del
cuerpo de un bucle
#
Muestra
todos
los
parmetros, si encuentra una
"f" finaliza
while [ $# -gt 0 ]
do
if [ $1 = "f" ]
then
break
// o continue
fi
echo Parmetro: $1
shift
done

FOR
for var in lista
do
uso de $var
done
ejemplo:
for i in 10 30 70
do
echo Mi nmero favorito es $i #
toma los valores 10, 30 y 70
done
a menudo lo que queremos es
generar secuencias de valores
numricos al estilo de la
instruccin for
for i in seq 0 5 25
do
# uso de $i que toma los
valores 0, 5, 10, 15, 20 y 25
done

stdin est asociado a la entrada,

es decir, al teclado
stdin es el 0
****************************
stdout (salida estndar): es el que
se escriben los mensajes que
imprime el programa
stdout es el 1
****************************
stderr (salida de error
stderr es el 2

> : redirecciona stdout a un fichero, si el fichero existe lo sobrescribe:

$ who > usuarios.txt; less usuarios.txt
>> : redirecciona stdout a un fichero, si el fichero existe aade los datos al final del mismo.
2 > : redirecciona stdderr a un fichero, si el fichero existe lo sobrescribe:
$ find / -type d -exec cat {} \; 2>errores.txt
2 >> : similar a >> pero para la salida de error.
n>&m : redirecciona el descriptor de fichero n al descriptor de fichero m, en caso de que n se omita,
se
sobrentiende un 1 (stdout):
$ cat file directorio >salida.txt 2>&1
# Redirecciona stdout al fichero salida.txt, y stderr a stdout
< : lee la entrada estndar de un fichero:
$ grep cadena < fichero.txt # busca "cadena" dentro de fichero.txt
| : redirecciona la salida estndar de una orden a la entrada estndar de otra orden:
$ who | grep Nines
FILTROS

sort Ordena las lneas de la entrada estndar.

Opciones:
-n: emplear orden numrico.
-d: emplear orden alfabtico (por defecto).
-f: ignorar maysculas/minsculas.
-r: ordenacin inversa.
-c: no ordenar, simplemente chequear si ya hay orden o no en la entrada.
-k: ordenar por un determinado campo.
-t: define carcter de separacin de campo (un espacio por defecto).

cut Corta secciones de cada lnea de la entrada (por columnas)

Opciones:
-c: cortar por columnas de caracteres.
-f: cortar por campos (combinar con -d).
-d: define carcter de separacin de campo.
Las opciones -c y -f admiten rangos numricos bastante completos, como -c4-8,13,18, o -f1,8-, por ejemplo.

grep

Busca en la entrada que se le especifica lneas que concuerden o coincidan con un

determinado patrn (puede ser una expresin regular; ver ms adelante).
Opciones:
-i: ignorar maysculas/minsculas.
-n: numerar las lneas.
-c: no mostrar la salida, slo contar nmero de coincidencias.
-h: suprimir nombre de fichero coincidente (slo mostrar lnea).
-l: suprimir la lnea coincidente (slo mostrar nombres de ficheros).
-v: invertir la salida (buscar lneas NO coincidentes con el patrn).
-q: no mostrar nada en la salida, slo comprobar si existe coincidencia.

head Obtiene las primeras lneas (por defecto 10) de la entrada.

Opciones:
-n: obtener las primeras n lneas.

tail Obtiene las ltimas lneas (por defecto 10) de la entrada.

Opciones:
-n: obtener las ltimas n lneas.

tr Cambia, borra o comprime caracteres.

Opciones:
set1 set2: va cambiando cada carcter de set1 por el correspondiente de set2.
-d: borrar caracteres indicados.
-s: comprimir a uno slo secuencias repetidas de los caracteres indicados.
-c: complementar el conjunto de caracteres indicados.
Esta orden es muy til para comprimir espacios antes de usar cut -f -d .

wc Cuenta caracteres, palabras y/o lneas.

Opciones:
-w: contar palabras.
-c: contar caracteres.
-l: contar lneas.
uniq Elimina lneas repetidas.
Esta orden suele emplearse combinada con un sort previo.

tac Concatena e imprime archivos invertidos lnea a lnea.

tee Lee de la entrada estndar y escribe tanto en la salida estndar como en los ficheros que se le
indican.

od Convierte la entrada a formas octal y hexadecimal, entre otras.

Atributo

Significado

Dont update
Atime

No actualizar Un
tiempo

Synchronous
updates

actualizaciones
sncronas

Append only

Solo anexar

Compressed file

archivo
comprimido

Immutable file

archivo inmutable

No Dump

Secure deletion

Undeletable file

borrado seguro

Si lo que deseamos es visualizar

el estado de los diferentes
atributos, utilizaremos

lsattr

Carlos:~# chattr -sa

/tmp/fichero
Carlos:~# lsattr /tmp/fichero
---S---- /tmp/fichero

PROGRAMAR TAREAS

cron
El comando cron permite a los usuarios ejecutar, automticamente, comandos y scripts a una hora de una

se puede tambin revisar a travs del comando ps:

# ps -ef | grep cron
si por alguna razn, cron no esta funcionando:
#> /etc/rc.d/init.d/crond start
Starting crond:
[ OK ]
Si el servicio no estuviera configurado para arrancar desde un principio, bastara con
agregarlo con el comando chkconfig:
#> chkconfig --level 35 crond on
fecha concreta

Como segundo modo de ejecutar o usar cron es a travs de manipular directamente el

archivo /etc/crontab. En la instalacin por defecto de varias distribuciones Linux, este
archivo se ver a algo como lo siguiente:
#> cat /etc/crontab
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly

anacron es una aplicacin que ejecuta tareas programadas al igual que cron
Funcionamiento de anacron
Cuando anacron se ejecuta lee una lista de tareas definidas en el archivo /etc/anacrontab.
Cada entrada en este archivo especifica un perodo en das, un retardo en minutos, un
identificador de tarea nico y un comando a ejecutar.

Las primeras cuatro lneas son variables que indican lo siguiente:

SHELL es el 'shell' bajo el cual se ejecuta el cron. Si no se especifica, se tomar por
defecto el indicado en la lnea /etc/passwd correspondiente al usuario que este
ejecutando cron.
PATH contiene o indica la ruta a los directorios en los cuales cron buscar el
comando a ejecutar. Este path es distinto al path global del sistema o del usuario.
MAIL TO es a quien se le enva la salida del comando (si es que este tiene alguna
salida). Cron enviar un correo a quien se especifique en este variable, es decir,
debe ser un usuario vlido del sistema o de algn otro sistema. Si no se especifica,
entonces cron enviar el correo al usuario propietario del comando que se ejecuta.
HOME es el directorio raz o principal del comando cron, si no se indica entonces, la
raz ser la que se indique en el archivo /etc/passwd correspondiente al usuario que
ejecuta cron.
Los comentarios se indican con # al inicio de la lnea.
Resumiendo lo anterior y considerando otras opciones de crontab:
$> crontab archivo.cron (establecer el archivo.cron como el crontab del usuario)
$> crontab -e
(abrir el editor preestablecido donde se podr crear o editar el
archivo crontab)
$> crontab -l
(lista el crontab actual del usuario, sus tareas de cron)
$> crontab -r
(elimina el crontab actual del usuario)

#> echo ALL >>/etc/cron.deny

IMPide el uso al usurio q esta en esa lista
o para agregar un usuario mas a cron.allow
#> echo juan >>/etc/cron.allow

Convertir salida de man a pdf

$> man ls
$> man -t ls
usaremos la opcin -t de man que invoca a la vez al comando groff que es un poderoso
comando para formatear documentos
$> man -t ls | ps2pdf - > ls.pdf
ps2pdf toma como argumento (indicado por -) la salida del comando previo ya convertido en formato PS
y lo convierto a formato PDF, direccionando a la vez la salida al nombre de archivo indicado 'ls.pdf'.

FUNCIONES
function nombrefuncion
{
Cdigo
}
Llamar a la funcin es como llamar a otro programa, slo
hay que escribir su nombre.

#! /bin/bash
# Se define la funcin salir
function salir {
exit
}
# Se define la funcin hola
function hola {
echo Hola!
}
hola # Se llama a la funcin hola
salir # Se llama a la funcin salir
echo ASIR-2

Comando
apropos palabra

which comando

time comando

time cat

nice info

Descripcin
Ver comandos
relacionados
con palabra.
Ver la ruta
completa de
comando
Medir cunto
tarda
comando
Iniciar
cronmetro.
Ctrl-d para
detenerlo. Ver
tambin sw
Lanzar
comando con

renice 19 -p $$

Navegacin
cd -

cd

(cd dir && comando)

pushd .

Bsquedas de archivo
alias l='ls -l --color=auto'

ls -lrt

ls /usr/bin | pr -T9 -W$COLUMNS

find -name '*.[ch]' | xargs grep -E 'expre'

find -type f -print0 | xargs -r0 grep -F 'ejemplo'

prioridad baja
(info en este
ejemplo)
Darle
prioridad baja
al shell
(guin). Usar
para tareas no
interactivas
Volver al
directorio
anterior
Ir al directorio
personal
(home)
Ir a dir,
ejecutar
comando y
volver al
directorio
inicial
Guardar el
directorio
actual en la
pila para
luego, poder
hacer popd y
volver al
mismo
listado de
directorio
rpido
Listar
archivos por
fecha.
Imprimir 9
columnas en
ancho de la
terminal
Buscar 'expre'
en este
directorio y
subdirectorios
.
Buscar

find -maxdepth 1 -type f | xargs grep -F 'ejemplo'

find -maxdepth 1 -type d | while read dir; do echo $dir; echo cmd2;
done

find -type f ! -perm -444

find -type d ! -perm -111

locate -r 'file[^/]*\.txt'

look referencia

grep --color referencia /usr/share/dict/palabras

'ejemplo' en
todos los
archivos
regulares en
este directorio
y
subdirectorios
Buscar
'ejemplo' en
todos los
archivos
regulares de
este directorio
Procesar cada
elemento con
muchos
comandos
(con un bucle
while)
Hallar
archivos sin
permiso
general de
lectura (util
para sedes
web)
Hallar
directorios sin
permiso
general de
acceso (util
para sedes
web)
Buscar
nombres en
indice en
cache. Este re
es igual a glob
*file*.txt
Bsqueda
rpida
(ordenada) de
prefijo en
diccionario
Resaltar
ocurrencias de
expresin
regular en

diccionario
archivos
gpg -c file
gpg file.gpg
tar -c dir/ | bzip2 > dir.tar.bz2

bzip2 -dc dir.tar.bz2 | tar -x

tar -c dir/ | gzip | gpg -c | ssh user@remoto 'dd of=dir.tar.gz.gpg'

find dir/ -name '*.txt' | tar -c --files-from=- | bzip2 > dir_txt.tar.bz2

find dir/ -name '*.txt' | xargs cp -a --target-directory=dir_txt/ -parents

( tar -c /dire/de/copiame ) | ( cd /este/dir/ && tar -x -p )

( cd /dire/de/copiame && tar -c . ) | ( cd /este/dir/ && tar -x -p )

( tar -c /dire/de/copiame ) | ssh -C user@remoto 'cd /este/dir/ && tar

-x -p'

Encriptar
archivo
Desencriptar
archivo
Crear archivo
compacto de
dir/
Extraer
archivo
compacto
(usar gzip en
vez de bzip2
para archivos
tar.gz )
Crear
compactado
encriptado de
dir/ en equipo
remoto
Crear
compactado
de
subconjunto
de dir/ y
subdirectorios
Copiar
subconjunto
de dir/ y
subdirectorios
Copiar (con
permisos)
directorio
copiame/ a
directorio
/este/dir/
Copiar (con
permisos)
contenido del
directorio
copiame/ a
directorio
/este/dir/
Copiar (con
permisos)
directorio

dd bs=1M if=/dev/hda | gzip | ssh user@remoto 'dd of=hda.gz'

rsync (Usar la opcin --dry-run para probarlo)

rsync -P rsync://rsync.servidor.com/ruta/a/archivo archivo

rsync --bwlimit=1000 desdearchivo alarchivo

rsync -az -e ssh --delete ~/public_html/ remoto.com:'~/public_html'

rsync -auz -e ssh remote:/dir/ . && rsync -auz -e ssh . remote:/dir/

wget (herramienta de descargas multiuso)

(cd cmdline && wget -nd -pHEKk
http://www.pixelbeat.org/cmdline.html)

wget -c http://www.ejemplo.com/largo.archivo

wget -r -nd -np -l1 -A '*.jpg' http://www.ejemplo.com/

wget ftp://remoto/archivo[1-9].iso/

copiame/ a
directorio
remoto
/este/dir/
Respaldo de
disco duro en
equipo remoto
Obtenerr solo
diffs. Repetir
muchas veces
para descargas
conflictivas
Copia local
con taza
lmite.
Parecido a
nice para E/S
(I/O)
Espejo de
sede web
(usando
compresin y
encriptado)
Sincronizando
directorio
actual con uno
remoto
Guardar en
directorio
actual una
versin
navegable de
una pgina
web
Retomar
descarga de
un archivo
parcialmente
descargado
Descargar una
serie de
archivos en el
directorio
actual
FTP permite

wget -q -O- http://www.pixelbeat.org/timeline.html | grep 'a href' |

head
echo 'wget url' | at 01:00

wget --limit-rate=20k url

wget -nv --spider --force-html -i bookmarks.html

wget --mirror http://www.ejemplo.com/

Redes
ethtool interface
ip link show
ip link set dev eth0 name wan
ip addr add 1.2.3.4/24 brd + dev eth0

ip link set dev interface up

ip route add default via 1.2.3.254

tc qdisc add dev lo root handle 1:0 netem delay 20msec

globalizacione
s directas
Procesando
directamente
la salida
Descargar la
url a 1AM al
directorio en
que est
Hacer
descargas de
baja prioridad
(en este caso,
no exceder los
20KB/s)
Revisando los
enlaces de una
pgina
Actualizar
eficientemente
una copia
local de una
pgina web
(til si usamos
cron)
Listar estado
de interfase
Listar
interfases
Renombrar
eth0 a wan
Agregar ip y
mscara
(255.255.255.
0)
Subir (o bajar)
la interfase
Establecer
1.2.3.254
como valor
por omisin
para la puerta
de enlace.
Agregarle
20ms de

tc qdisc del dev lo root

host pixelbeat.org

hostname -i

netstat -tupl

netstat -tup

Windows
smbtree

nmblookup -A 1.2.3.4

smbclient -L windows_box

mount -t smbfs -o fmask=666,guest //windows_box/share

espera al
dispositivo de
retorno (para
hacer pruebas)
Quitar la
espera
agregada
antes.
Obtener la
direccin ip
para el
dominio o al
revs
Obtener la
direccin ip
local
(equivale al
anfitrin
`hostname`)
Listar los
servicios de
internet de un
sistema
Listar las
conexiones
activas
de/hacia un
sistema
Hallar equipos
windows. Ver
tambin
findsmb
Hallar el
nombre
(netbios) de
windows
asociado con
la direccin ip
Listar
archivos
compartidos
en equipos
windows o
servidor
samba
Montar un

/mnt/share
echo 'mensaje' | smbclient -M windows_box

math
echo '(1 + sqrt(5))/2' | bc -l

echo 'obase=16; ibase=10; 64206' | bc

echo $((0x2dec))

echo 'pad=20; min=64; (100*10^6)/((pad+min)*8)' | bc

echo 'pad=20; min=64; print (100E6)/((pad+min)*8)' | python

echo 'pad=20; plot [64:1518] (100*10**6)/((pad+x)*8)' | gnuplot persist

seq 100 | (tr '\n' +; echo 0) | bc

Manejo de textos
sed 's/cadena1/cadena2/g'

sed 's/\(.*\)1/\12/g'

directorio
compartido
Enviar
mensaje
emergente al
equipo
windows
(desactivado
por omisin
en XP sp2)
Cuentas
rpidas
(Calcular ).
Conversiones
de base
(decimal a
hexadecimal)
Conversiones
de base (hex a
dec)
((expansin
aritmtica del
shell))
Mas complejo
(int) x.ej.
Ejemplo: tasa
mxima de
paquetes
FastE
Python
maneja
notacin
cientfica
Graficar tasa
de paquetes
FastE vs.
tamao de
paquetes
Agregar una
columna de
nmeros.
Remplaza
cadena1 por
cadena2
Modificar

sed '/^ *#/d; /^ *$/d'

sed ':a; /\\$/N; s/\\\n//; ta'

sed 's/[ \t]*$//'

sed 's/\([\\`\\"$\\\\]\)/\\\1/g'

sed -n '1000p;1000q'
sed -n '10,20p;20q'

sed -n 's/.*<title>\(.*\)<\/title>.*/\1/ip;T;q'

sort -t. -k1,1n -k2,2n -k3,3n -k4,4n

echo 'Test' | tr '[:lower:]' '[:upper:]'

tr -dc '[:print:]' < /dev/urandom

grep 'processor' /proc/cpuinfo | wc -l

Definir operaciones
sort archivo1 archivo2 | uniq

sort archivo1 archivo2 | uniq -d

sort archivo1 archivo1 archivo2 | uniq -u

cualquiercade
na1 con
cualquiercade
na2
Quitar
comentarios y
lineas en
blanco
Concatenar
lineas con \ al
final
Quitar blancos
finales de las
lineas
Escapar
metacaractere
s activos del
shell dentro de
comillas
dobles
Listar la lnea
1000
Listar de la
linea 10 a la
20
Extraer titulo
de pgina web
en HTML
Sort de
direcciones ip
de tipo IPV4
Conversin de
cajas
Filtrando
caracteres no
imprimibles
Contar lineas
Union de
archivos sin
ordenar
Interseccin
de archivos
sin ordenar
Diferencia de
archivos sin

sort archivo1 archivo2 | uniq -u

comm archivo1 archivo2 | sed 's/^\t*//'

comm -12 archivo1 archivo2

comm -13 archivo1 archivo2

comm -3 archivo1 archivo2 | sed 's/^\t*//'

Calendario
cal -3
cal 9 1752

date -d fri
date --date='25 Dec' +%A

date --date '1970-01-01 UTC 1234567890 seconds'

TZ=':America/Los_Angeles' date

echo "mail -s 'tomar el tren' jcpedraz@iesriberadeltajo.com <

/dev/null" | at 17:45
echo "DISPLAY=$DISPLAY xmessage cooker" | at "NOW + 30
minutes"

ordenar
Diferencia
Simtrica de
archivos sin
ordenar
Unin de
archivos
ordenados
Interseccin
de archivos
ordenados
Diferencia de
archivos
ordenados
Diferencia
Simtrica de
archivos
ordenados
Mostrar
calendario
Mostrar
calendario
para mes y
ao
determinado
Que da cae
este viernes.
En que da
cae la
Navidad, este
ao?
Convertir total
de segundos
desde la poca
a una fecha
Que hora es
en la Costa
Oeste de
EEUU (usar
tzselect para
hallar TZ)
Recordatorio
por email
Recordatorio
emergente

Locale
printf "%'d\n" 1234

BLOCK_SIZE=\'1 ls l

echo "Yo vivo en `locale territory`"

LANG=en_IE.utf8 locale int_prefix

locale | cut -d= -f1 | xargs locale -kc | less

Recode
recode -l | less

recode windows-1252.. archivo_a_cambiar.txt

recode utf-8/CRLF.. archivo_a_cambiar.txt

recode iso-8859-15..utf8 archivo_a_cambiar.txt

Imprimir
numero
agrupado por
miles de
acuerdo a tu
locale
pedir que ls
agrupe por
miles de
acuerdo a tu
locale
Extraer
informacin
de la base de
datos del
locale
Buscar
informacin
de locale para
determinado
pas.
Listar campos
en base de
datos del
locale
Ver
conversiones
disponibles
(aliases en
cada lnea)
"ansi" de
Windows a
tabla de
caracteres
locales (auto
hace
conversin
CRLF)
utf8 de
Windows a
tabla de
caracteres
locales
Latin9
(Europa

recode ../b64 < archivo.txt > archivo.b64

recode /qp.. < archivo.txt > archivo.qp

recode ..HTML < archivo.txt > archivo.html

recode -lf windows-1252 | grep euro
echo -n 0x80 | recode latin-9/x1..dump

echo -n 0x20AC | recode ucs-2/x2..latin-9/x

echo -n 0x20AC | recode ucs-2/x2..utf-8/x

CDs
gzip < /dev/cdrom > cdrom.iso.gz

mkisofs -V NOMBRE -r dir | gzip > cdrom.iso.gz

mount -o loop cdrom.iso /mnt/dir

cdrecord -v dev=/dev/cdrom blank=fast

gzip -dc cdrom.iso.gz | cdrecord -v dev=/dev/cdrom -

oriental) a
utf8
Codificado
Base64
Decodificado
de citas
imprimibles
(qp)
Texto a
HTML
Buscar tabla
de caracteres
Mostrar
representacin
de un cdigo
en tabla de
caracteres
latin-9
Ver
codificado
latin-9
Ver
codificado
utf-8
Guardar una
copia de los
datos de
cdrom
Crear imagen
de cdrom con
el contenido
de dir
Montar la
imagen cdrom
en /mnt/dir
(solo lectura)
Limpiar un
CDRW
Grabar un
cdrom con
imagen (usar
dev=ATAPI scanbus para
confirmar ruta
dev)

cdparanoia -B

cdrecord -v dev=/dev/cdrom -audio *.wav

oggenc --tracknum='pista' pista.cdda.wav -o 'pista.ogg'

Espacio de disco
ls -lSr

du -s * | sort -k1,1rn | head

df -h

df -i
fdisk -l

rpm -q -a --qf '%10{SIZE}\t%{NAME}\n' | sort -k1,1n

dpkg -query -W -f='${Installed-Size;10}\t${Package}\n' | sort -k1,1n

Extraer pistas
de audio
desde un CD a
archivos wav
en directorio
actual
Armar un CD
de audio con
todos los wavs
en directorio
actual (ver
tambin
cdrdao)
Crear un
archivo ogg
con un
archivo wav
Mostrar
archivos, de
menor a
mayor
Mostrar
usuarios de
disco
principales en
el directorio
actual.
Mostrar
espacio libre
de disco
Mostrar
inodos libres
Mostrar
tamaos y
tipos de
particiones de
disco (pedir
como root)
Listar todos
los paquetes
por tamao
instalado
(Bytes) de
distribuciones
RPMs
Listar todos

dd bs=1 seek=2TB if=/dev/null of=ext3.test

Monitoreo/rastreo
strace -c ls >/dev/null

strace -f -e open ls >/dev/null

ltrace -f -e getenv ls >/dev/null

lsof -p $$

lsof ~

tcpdump not port 22

ps -e -o pid,args --forest

ps -e -o pcpu,cpu,nice,state,cputime,args --sort pcpu | sed '/^ 0.0 /d'

ps -e -orss=,args= | sort -b -k1,1n | pr -TW$COLUMNS

los paquetes
por tamao
instalado
(Kbytes) de
distribuciones
deb
Crear un gran
archivo de
prueba (sin
ocupar
espacio).
Resumir/perfil
de llamadas al
sistema
hechas con
comando
Listar
llamadas al
sistema
hechas con
comando
Listar
llamadas a
libreras
hechas con
comando
Listar las rutas
que abri el id
de proceso
Listar
procesos que
solicitaron
apertura de
rutas
Ver trfico de
redes excepto
ssh.
Listar
procesos de
una jerarqua
Listar
procesos por
% de uso de
cpu
Listar
procesos por

ps -C firefox-bin -L -o pid,tid,pcpu,state

ps -p 1,2

last reboot

free -m

watch -n.1 'cat /proc/interrupts'

Informacin del sistema

hdparm -i /dev/hda

hdparm -tT /dev/hda

badblocks -s /dev/hda

mount | column -t

cat /proc/partitions

grep MemTotal /proc/meminfo

uso de
memoria.
Listar todos
los hilos de un
proceso
determinado
Listar
informacin
de un ID
determinado
Ver historia
de
reencendido
del sistema
Ver cantidad
de RAM (que
queda) (-m
muestra en
MB)
Observar
continuamente
los datos que
van
cambiando
Ver informe
sobre
particin hda
Hacer una
prueba de
velocidad de
lectura en
particin hda
Hallar bloques
ilegibles en
particin hda
Ver
particiones
montadas en
el sistema (y
alinear la
salida)
Ver todas las
particiones
registradas en
el sistema
Ver el total de

RAM que
registra el
sistema
Ver informe
de CPU(s)
Ver informe
de PCI
Ver informe
de USB

grep "model name" /proc/cpuinfo

lspci -tv
lsusb -tv

Un nico punto (.) se utiliza para hacer referencia al directorio en el que ests actualmente.
Dos puntos ( .. ) se utilizan para hacer referencia al directorio padre del actual.
orden

ls son:

-C: mostrar el contenido en columnas.

-a: mostrar tambin los nombres que empiezan por . Ficheros ocultos).
-F: aadir un carcter / a los directorios y un carcter * a los ejecutables.
-R: mostrar el directorio actual y sus subdirectorios.
-i: mostrar el nmero de i-nodo del fichero.
-d: listar los directorios sin mostrar su contenido.
-r: listar de forma reversa
-- color: diferenciar los objetos con diferentes colores dependiendo de su tipo.

el contenido de un archivo es con la orden

cat:

..$cat .profile
Algunas opciones tiles de la orden cat son:
-n: numera las lneas del archivo.
-b: numera las lneas que no estn vacas.
-v: permite visualizar los caracteres de control
$ cat miarchivo > miarchivo.bak
$ cat new_info data

//copia el contenido de miarchivo a miarchivo. Bak

// Para aadir informacin al final de un archivo

$ cat > memo //crea archivo se debe pulsar CTRL-D. Esto termina la orden cat
$ cat memo // lo aadir al final del archivo memo

Comodines:
El comodn "?" slo expande un nico carcter.
El comodn [...] sustituye cualquier valor incluido entre los corchetes

Cambio de directorios
$ cd cartas
Copiar ficheros

cp [-i] <ficheros> <fichero> | <directorio>. Copia uno o varios ficheros.

La opcin -i nos pide confirmacin de sobreescritura
Mover ficheros
mv. Similar a cp pero para mover y/o cambiar de nombre
Borrar ficheros
rm [-i -r -f -v] <ficheros>. Borra ficheros

-i nos pide confirmacin,

- f no pide confirmacin
-r se utiliza para borrar un directorio y todo lo que contenga.
-v nos permite visualizar el nombre de cada fichero que se va borrando
Crear un directorio
crean con mkdir
se borran con rmdir si est vaco
rm r si contiene objetos
USUARIO ROOT

su

para cambiarnos en el terminal del usuario normal a root es con el comando

.
En este momento le asignaremos una contrasea a root para que nos permita el
acceso:

$ sudo passwd root

En caso de que queremos volver a desactivar la cuenta root
$ sudo passwd -l root o $ sudo usermod -p ! root

Atajos de teclado
consola virtual (Ctrl+Alt+F1) pero pulsando (Ctrl+Alt+F2) te llevar a la segunda consola virtual
el auto completado que se hace pulsando la tecla TAB.

ls -la puede darte un listado de ms de 24 lneas, para ver lo que se ha quedado en la parte de
arriba de la pantalla puedes usar: (SHIFT+PgUp) y (SHIFT+PgDown)
Presionando la flecha hacia arriba te muestra el ltimo comando que has escrito, si lo haces
ms veces vers una lista de todos los comandos que has usado.
Todos tus ltimos comandos se guardan en un fichero en tu directorio home llamado:
.bash_history

PROMT
Para cambiar el aspecto del prompt, hay que cambiar la variable PS1.
carlos@ubuntu:~$ SAVE=$PS1
carlos@ubuntu:~$
El prompt ms sencillo sera el de un solo carcter, tal cual hemos hecho en clase:
carlos@ubuntu:~$ PS1=-->
-->ls

Para restaurar el prompt original, basta con llamar a la variable almacenada:

PS1=$SAVE

\a carcter de campana ASCII(07)

\d la fecha en formato "da mes ao"
\e carcter de escape ASCII(033)
\h el nombre del host hasta el primer `.'
\H el nombre del host
\n carcter de nueva lnea
\r retorno de carro
\s el nombre del shell, el nombre base de $0
(el fragmento que sigue a la ltima barra)
\t la hora actual en formato 24-horas HH:MM:SS
\T la hora actual en formato 12-horas HH:MM:SS
\@ la hora actual en formato 12-horas am/pm
\u el nombre de usuario actual
\v la versin del <tt/bash/ (p.e., 2.0)
\V la versin del paquete del <tt/bash/, version + patchlevel
(p.e., 2.00.0)
\w el directorio actual de trabajo
\W el nombre base del directorio actual de trabajo
\! el nmero del comando actual en el histrico
\# el nmero de comando del comando actual
\$ si el UID efectivo es 0, una #, sino, un $
\nnn el carcter correspondiente al nmero octal nnn
\\ una contrabarra
\[ inicio de una secuencia de caracteres no imprimibles, que pueden usarse
para incrustar una
secuencia de control del terminal en el prompt.
\] fin de una secuencia de caracteres no imprimibles
Continuando donde lo habamos dejado:
carlos@ubuntu:~$ PS1="\u@\h \W> "

find
El comando find sirve para buscar ficheros y directorios pero es muy complejo y
tiene muchas opciones
el nombre (-name xxx)
find . -name tureceta*
Si es un archivo o carpeta (-type f -type d)
find . -type f -name tureceta*
find . -type d -name tureceta*
Los permisos que tiene (-perm nnn)
find . -type d -perm 777
El usuario al que pertenece (-user usuario1)
find . -type f -user usuario1
El grupo al que pertenece (-group grupo1)
find . -type f -group grupo1
Si el fichero est vacio (-empty)
find . -type f empty
El tamao (-size n[cwbkMG]) siendo
b para bloques de 512-byte (este es el de por defecto)
c para bytes
w para two-byte words
k para Kilobytes (1024 bytes)
M para Megabytes (1048576 bytes)
G para Gigabytes (1073741824 bytes)
find . -size 21k
Modificados los datos en las ltimas X*24h (- dtime n)
find . -tipe f -dtime 2 (en las ltimas 48h = 2*24)
Accedidos en las ltimas X*24h (- atime n)
find . -tipe f -atime 2 (en las ltimas 48h = 2*24)
Recuerdar que con la ayuda y con el man del comando tendrs toda la
informacin
find --help
man find
whereis
Buscar la localizacin de un fichero binario, fuente o man
Carlos2014@ubuntu ~$ whereis grep

which
Buscar la localizacin de un fichero binario o ejecutable
Carlos2014@ubuntu ~$ which grep
hash
Muestra la ruta a los comandos utilizados en las ltimas sesiones
Carlos2014@ubuntu ~$ which grep

Commando Find
Se utiliza para buscar archivos dentro de una jerarqua de directorios.
Find utiliza las opciones -name y -print por defecto, es decir, si ejecutamos find a secas,
listar el contenido del directorio donde estemos situados de forma recursiva.

find [ruta] [expresin]

ruta: indica el punto de partida desde donde se deber iniciar la bsqueda.

expresin: indica un conjunto de opciones como la especificacin del archivo a buscar,
Expresin comparaciones, operaciones y acciones sobre el resultado.

carlos2014@ubuntu:~$ find . -name *.log -maxdepth 2

find: atencin: ha especificado la opcin maxdepth
-maxdepth n. Find buscar de forma recursiva hasta un mximo de n niveles de subdirectorios
por debajo del especificado.
con -maxdepth 1 buscaremos en el directorio actual de forma no recursiva (no "bajaremos" a los
subdirectorios).
-mindepth n. Similar a maxdepth pero comenzar a buscar a partir de n niveles
con -mindepth 2 buscaremos sin tener en cuenta el directorio actual. Realizar la bsqueda a
partir de los subdirectorios y de forma recursiva.
-mount. No descender a directorios montados en otros sistemas de ficheros
Patrn
Muchas veces realizaremos bsquedas que cumplan un patrn

La sintaxis correcta del patrn es la siguiente:

*: engloba cualquier o ningn carcter.
?: cualquier carcter sencillo, justamente uno.
[cadena]: coincidencia exactamente en uno de los caracteres contenidos en la cadena.
Tambin la cadena puede contener rangos como por ejemplo incluir todas las letras minsculas y los
nmeros [a-z0-9].
[!cadena]: no coincidencia con ninguno de los caracteres de la cadena. Es la negacin de [cadena].
*[1]*.txt: igual que el ejemplo anterior.

[0-9]?rt*.??q: coincidiran por ejemplo los archivos 03rt.44q y 1trtexample.exq

ES aconsejable que el patrn vaya ente comillas.

Lista de comparaciones
-amin n: bsqueda de ficheros que han sido ledos hace n minutos.
carlos2014@ubuntu:~$ find . -amin -10
./.bash_history
Como vemos, find aplica por omisin las acciones -name (especificar el patrn de bsqueda,
en este caso todos los ficheros *) y -print (el resultado lo imprime por la salida estndar).
-atime n: bsqueda de ficheros que han sido ledos por ltima vez hace nx24 horas.
carlos2014@ubuntu:~$ find . -atime -1
./scripts
./.bash_history
-cmin n: bsqueda de ficheros cuyos permisos se han cambiado hace n minutos.
carlos2014@ubuntu:~$ find . -cmin -10
./.bash_history
-ctime n: bsqueda de ficheros cuyos permisos se han cambiado por ltima vez hace nx24
horas.
carlos2014@ubuntu:~$ find . ctime -1
./.bash_history
-mmin n: bsqueda de ficheros que han sido modificados (su contenido) hace n minutos.
carlos2014@ubuntu:~$ find . -mmin 4
./sqlnet.log
-mtime n; bsqueda de ficheros que han sido modificados por ltima vez hace nx24h.
carlos2014@ubuntu:~$ find . -mtime +1
./.gtkrc
-empty: bsqueda de ficheros o directorios vacos. Muy til para "hacer limpieza" del disco duro.
-fstype tipo: especificamos el tipo de sistema de archivos donde queremos realizar la bsqueda
(en /proc/filesystems podemos ver la lista de todos los sistemas de ficheros registrados en el
sistema).
carlos2014@ubuntu:~$ find . -fstype ntfs
-gid n: buscamos ficheros que pertenezcan al grupo con identificador igual a n.
-uid n: busca ficheros cuyo propietario tenga el uid especificado.
-user usuario: busca fichero cuyo propietario del mismo es el usuario.
-group nombre: igual que la expresin anterior, pero esta vez buscamos por el nombre del
grupo.
-lname patrn: buscamos enlaces simblicos que coincidan con el patrn.
Con ilname ignoramos las maysculas o minsculas.
-name patrn: buscamos los ficheros que coincidan con el patrn.
Con iname ignoramos las maysculas o minsculas.

-links n: buscamos ficheros con n enlaces.

-nouser: buscamos ficheros que no pertenezcan a ningn usuario. Es decir, el uid del fichero no
coincide con el UID de ningn usuario.
-nogroup: igual que la expresin anterior pero con gid (identificador de grupo).
-path patrn: bsqueda del patrn que coincida con el path o ruta.
carlos2014@ubuntu:~$ find . -path *reg*
./.gstreamer-0.10/registry.i486.xml
Con ipath ignoramos las maysculas y minsculas.
-perm modo: buscamos los ficheros que coincidan exactamente con los permisos en

representacin octal (de 0 a 7) o en representacin simblica ( para lectura,

x para ejecucin,

w para escritura).
carlos2014@ubuntu:~$ find . -perm 744
./prueba
./mbox
-size n[ckMG]: buscamos los ficheros que tengan como tamao de bloque el valor n, es decir, el
nmero bloques que utiliza el fichero en disco.
-type tipo: especificamos el tipo de fichero a buscar

-d: directorio
-f: fichero regular
-l: enlace simblicos
-b: fichero especial de bloques*
-c: fichero especial de caracteres*

Acciones
-exec orden: ejecutar una orden sobre el resultado de la bsqueda

COMANDO SED
Sed es considerado un editor de texto
sed comandos_sed archivo
"comandos_sed" corresponde a una o ms especificaciones acerca de qu hacer con las
lneas que se leen desde "archivo".

Borrar una lnea:

sed 'n_de_lnead' fichero
Podemos indicar un nmero de lnea concreto. Por ejemplo:
sed '1d' fichero

Modificar lneas
sed 's/cadena1/cadena2/' fichero
Al ejecutar el comando anterior, se sustituye la primera cadena que encuentra por la segunda.
Por otra parte, tambin podemos hacer que sustituya la cadena1 por la cadena2 en un nmero
de lnea concreto:
sed '5 s/USUARIO/usuario/g' fichero
Supongamos que queremos cambiar la palabra "Debian" por "Ubuntu" dentro de un
documento.
sed s/Debian/Ubuntu/g documento.txt > salida.txt
La "s" significa "substituya".
La "g" significa que la accin se realizar en todo el documento.
La opcin "-e" significa "ejecute".
sed -e 'comando 1' -e 'comando 2' archivo.txt > archivo2.txt
Comando tr
El comando tr, es un filtro de datos que nos permite modificarlos sustituyendo y/o borrando
caracteres.
tr [OPCIN] ... SET1 [SET2]
Donde [OPCIN] pueden ser cualquiera de las siguientes.

-d Borrar los caracteres indicados en SET1

-s Elimina o reemplaza los caracteres repetidos indicados en SET1
-c Todos los caracteres que no sean los indicados en SET1 los convierte en SET2
-t Trunca SET1 a la longitud de SET2

$ echo murcielago | tr aeiou AEIOU

mUrcIElAgO

Borrar
El borrado de caracteres es ms fcil de usar. En este caso solo necesitamos SET1, para indicar
que caracteres queremos borrar.
En el siguiente ejemplo borraremos las letras 'a' y 'e' de la palabra 'murcielago'.
$ echo murcielago | tr -d ae
murcilgo

GREP
grep -E(extended grep), una herramienta que analiza una entrada suministrada y la compara
con nuestra expresin regular
Corchetes
Sirven para hacer coincidir cualquier carcter (pero slo uno) que se encuentre entre ellos:
$ ls | grep -E "[ab]00sor
Cuantificadores

* Coincide con cualquier carcter que le preceda cero o ms veces

$ ls | grep -E "na*uto"
naaauto

? Coincide con cualquier carcter cero o ms veces

$ ls | grep -E "?sor"
a00sor

+ Coincide con cualquier carcter que lo preceda una o ms veces

$ ls | grep -E "a0+sor"
a00sor

{ } Establecen el nmero de veces que se repetir el carcter que lo precede en la expresin

$ ls | grep -E ".0{2}sor"
a00sor
Metacarcteres

| Coincide con cualquier carcter o caracteres a cada lado de la barra (Yo no lo uso)
$ ls | grep -E "[a|b]00*"
a00sor
b00sor
[^] Coincide con cualquier carcter no listado despus del circunflejo
grep -E "^." demo2
$touch huevo hu3vo hueeevo // crear varios ficheros

Anclas

Se utilizan para especificar en qu posicin se da el patrn.

^ Especifica que el patrn debe estar en el principio de la lnea

$ ls | grep -E "^h.*"
hu3vo
hueeevo
huevo

Especifica que el patrn debe de estar al final de la lnea

\< Especifica que el patrn debe de estar al principio de una palabra

\> Especifica que el patrn debe de estar al final de una palabra
\b Especifica que el patrn debe de estar al principio o al final de una palabra
\B Especifica que el patrn no debe de estar al principio ni al final de una palabra

COMANDO useradd
useradd - Aade nuevo usuario al sistema linux,
crea en los archivos /etc/passwd, /etc/group y /etc/shadow.
SINTAXIS: La sintaxis es useradd [opciones] [nombre_de_usuario]
OPCIONES:
-d
Especifica el directorio inicial del usuario
-s
Especifica el shell del usuario
-g

Especifica el grupo primario del usuario

-G

Especifica los grupos secundarios del usuario

-M

Especifica que no se cree un directorio de inicio para el usuario

-e

Especifica la fecha de expiracin del usuario

-uid

Especifica el identificador de usuario para el usuario

Para aadir un nuevo usuario:

useradd pruebasAsir2

Este comando aadir un nuevo usuario con nombre pruebasAsir2.

2. Para aadir un usuario pero no permitirle acceder al sistema:
useradd -s /bin/nologin pruebasAsir2

Enlace simblico

/etc/passwd: contiene informacin sobre cada usuario: ID, grupo principal,

Es un tipo de enlace que no es real, sino que supone un atajo a
descripcin, directorio de inicio, shell, etc. Tambin contiene el password encriptado,
un archivo o carpeta, sera parecido a los accesos directos.
salvo que se usen shadow passwords.

/etc/shadow: contiene los passwords encriptados de los usuarios cuando se emplean

shadow passwords.

/etc/group: contiene los miembros de cada grupo, excepto para el grupo principal,
que aparece en /etc/passwd.

/etc/skel: directorio que contiene el contenido del directorio de los nuevos usuarios.

Windows cmd

Enlace simblico
Es un tipo de enlace que no es real, sino que supone un atajo a un
archivo o carpeta, sera parecido a los accesos directos.
Si quisiramos recrear este enlace simblico de forma manual
tendramos que teclear el comando:
mklink /d C:\documents and setting

C:\users

PREGUNTAS LINUX Aparte:

1. Cmo asignar una IP a mi ordenador? ifconfig [interface] n de IP

2Cmo hago para ver los archivos del directorio
anterior? ls ../
3Cmo s en qu directorio estoy? pwd

4Cmo puedo crear archivos en Unix? Con el comando "touch" seguido del nombre de archivo
que quiero crear.

Cmo puedo crear uno o varios directorios? Con el comando mkdir seguido del nombre o nombres,
separados por espacio, de los directorios que quiero crea

1. En que directorios se guardan generalmente los

programas? -

Generalmente en /bin /sbin y /usr/sbin, aunque

depende tambin de la distribucin.

1. Con denomina Unix a los disco duros IDE? Los denomina como hd (de Hard Disk). Canal Primario:
hda (Maestro) y hdb (Esclavo) Canal Secundario: hdc
(Maestro) y hdd (Secundario)

1. Cmo puedo obtener un listado de los procesos que

tengo en ejecucin? Con el comando ps y varias opciones (por ejemplo axf). Tambin, de forma interactiva con el comando
top.

1. De qu forma puedo averiguar el uso de memoria que

consume mi ordenador? Comando free.

1. Cmo puedo saber el orden de ejecucin de mis

procesos? Mediante el comando ps y observando el n que
aparece al lado del proceso (PID)

1. Cmo puedo ver el contenido de un archivo sin

abrirlo? Utilizando el comando cat

1. Puedo tener ms de una consola abierta? S. Y se puede alternar entre ellas con el atajo de
teclado alt +f1, f2, f3 segn a la consola que queramos
cambiar

Cmo s los usuarios conectados a mi mquina? who

1. Cmo creo un enlace? con ln

1. En consola, cmo puedo autocompletar? Con la tecla TAB

Cmo puedo matar un proceso? con ki

1. Cmo se que versin del kernel tengo? -

uname -r
1. Dnde se guardan los archivos de configuracin del
sistema? en /etc
1. Cmo diferencio entre ruta absoluta y ruta relativa? Si hay una / delante de la ruta

1. Cmo puedo ver los detalles de un archivo? con ls -i

1. Cmo ejecuto un proceso en 2 plano? comando &
1. Cmo traer un proceso en 2 plano al 1? con fg %n proceso
1. Cmo puedo buscar la ubicacin de un comando
determinado? whereis comando

1. Qu letra significa permiso de ejecucin? x

1. Cmo consulto el historial de comandos? Con los cursores (flechas arriba y abajo)
1. Cmo se los grupos a los que pertenezco? utilizando el comando groups
1. Cmo puedo saber en que consola me encuentro? con el comando tty
1. Cmo se hace un enlace simblico? ln -s origen nombre_enlace
1. Cmo hago un enlace en el directorio dir a un archivo
en el directorio actual? ln -s archivo.ejemplo dir/ Si no pongo el nombre de
archivo el enlace tendr el mismo nombre
1. Cmo s cual es el nombre de la mquina en la que
estoy conectado? -

hostname . Tambin vale uname -n

1. Cmo muestro el contenido de la variable PATH? echo $PATH . Un ejemplo tpico es:
/usr/local/bin:/usr/bin:/bin:/usr/bin/X11 , observa que
hay varios directorios separados por el caracter
delimitado ':'

1. Cmo hago para copiar archivo1 a archivo2 que est

en el directorio dir? cp archivo1 ./dir/
1. Estoy perdido en el rbol de directorios, cmo vuelvo a
mi HOME? cd o tambin cd ~ . El home est en la variable de
entorno HOME, o en el caracter ~

CMO CONSTRUIR SHELL SCRIPTS EN UNIX-LINUX?

Los shell scripts son programas escritos con comandos UNIX y son equivalentes a los batch de DOS aunque mucho
ms potentes, pues admiten ejecuciones en segundo plano y tienen un conjunto de expresiones mucho ms amplio.
Para realizar una shell script en condiciones, al igual que para realizar un programa en cualquier lenguaje de
programacin, es necesario tener claro lo que se quiere obtener y de que situacin se parte. Es mejor perder un poco
de tiempo en realizar un desarrollo mental del programa que dedicarse a teclear y probar cosas, pues lo ms seguro es
que no se consiga el objetivo, y si se consigue la estructura del programa no ser la adecuada.
Una de las ventajas que presentan los shell scripts es que pueden ser portadas de una mquina UNIX a otra sin
problemas, sin necesidad de retocar nada, salvo que se utilicen llamadas a programas muy concretos especficos de
una versin de UNIX, mientras que los programas compilados (desarrollados en C, Pascal, etc.) deben ser
recompilados, pues el cdigo se generar en funcin del microprocesador de cada mquina. Otra ventaja es la
facilidad de lectura e interpretacin.
El principal inconveniente que presentan respecto a los programas compilados es la lentitud de ejecucin, que se
puede paliar usando las utilidades built-in incluidas en el propio kernel en lugar de llamar a comandos externos que
han de ser leidos de disco. Otro inconveniente es que el cdigo resulta visible a cualquier usuario que lo pueda
ejecutar.
Se deben aadir comentarios con el fin de facilitar la lectura del programa. Los comentarios se insertan anteponiendo
el carcter "#" al comentario, que se extender hasta el final de la lnea.
Los scripts suelen encabezarse con comentarios que indican el nombre de archivo y lo que hace el script. Se colocan
comentarios de documentacin en diferentes partes del script para mejorar la comprensin y facilitar el
mantenimiento. Un caso especial es el uso de "#" en la primera lnea, seguido del carcter admiracin y el path de la
subshell, para indicar el intrprete con que se ejecutar el script, como por ejemplo:

#!/bin/ksh
#!/bin/sh
#!/bin/bash

Es interesante saber que muchos comandos devuelven un valor despus de ejecutarse, y que este valor indicar si la
ejecucin ha sido buena o si ha habido algn fallo y que tipo de fallo se ha producido. Para conocer si un comando
devuelve o no un valor y qu es lo que devuelve en cada caso se deber consultar la documentacin, pero por lo
general en caso de una ejecucin correcta devolvern el valor 0, y en caso de fallo otro numero, positivo o negativo.
Para poder ejecutar un archivo de comandos es necesario que tenga activados, al menos, los permisos de lectura y
ejecucin. A continuacin vamos a ver unos ejemplos, comenzando por cosas muy sencillas.

Ejemplo1:
# Programa que cambia de directorio y nos muestra donde estamos en cada
# momento. Cambia directorio en un subshell, no altera ambiente original
#
echo SUBSHELL.
DIRACT=`pwd`
echo Directorio actual $DIRACT
echo Cambiando directorio en el subshell...
cd /etc
echo Ahora en directorio `pwd`
cd
echo Ahora estoy en mi directorio, que es `pwd`
# fin subsh.cmd

El programa mostrara lo siguiente:

SUBSHELL.
Directorio actual /home/dvarela
Cambiando directorio en el subshell...
Ahora en directorio /etc
Ahora estoy en mi directorio, que es /home/dvarela

Ejemplo 2:
# Programa que muestra la hora del sistema cada segundo durante 1 minuto
Cont=0
while [ $Cont -le 60 ]
do
date
((Cont=$Cont + 1))
sleep 1
done

Ejemplo 3:
# Programa que nos dice el dia de la semana que fue ayer
HOY=$(date +%w)

#En la variable HOY almacenamos el numero de dia para hoy.

AYER=$(expr $HOY - 1)

# y en ayer, el valor de HOY menos 1

echo "Ayer fue \c"

case $AYER in
-1) echo "Sabado";;
0) echo "Domingo";;
1) echo "Lunes";;

# date +%w devuelve el da de la semana

# en formato numerico, con valores

2) echo "Martes";;
3) echo "Miercoles";;
4) echo "Jueves";;

# comprendidos entre 0 (domingo) y 6

# (sabado). En nuestro caso, ayer tomara
# valores entre -1 y 5.

5) echo "Viernes";;
*) echo "un dia raro, pues no existe";;
esac

Ejemplo 4:
#!/bin/ksh
# Programa que pide al usuario que introduzca una cadena de caracteres y
# la muestra, por pantalla del derecho y del revs.
#
echo "Introduce una cadena: \c"
read NOMBRE
LONGITUD=${#NOMBRE}
while [ $LONGITUD -gt 0 ]
do
NOMBREALREVES="$NOMBREALREVES"`echo $NOMBRE | cut -c$LONGITUD`
LONGITUD=`expr $LONGITUD - 1`

# ((LONGITUD=LONGITUD+1)) seria mejor

done
echo "\n$NOMBRE\n$NOMBREALREVES"

El programa mostrara en pantalla:

Introduce una cadena: Hola que tal?
Hola que tal?
lat euq aloH

Ejemplo 5:
#!/bin/ksh
# Programa que simula una papelera de reciclaje, mediante el cual en lugar de
# borrar un archivo, lo que hace es guardarlo en un subdirectorio, con el fin
# de evitar borrados accidentales.
#
if [ $# -gt 0 ]
then
for i in $*
do
echo "Moviendo $i al directorio $HOME/borrados"
if [ `mv $i $HOME/borrados 2> /dev/null` = 0 ]
then
echo "Error, no se puede mover $i"
fi

done
else
echo "Error: hay que especificar argumentos"
echo "$0 archivo1 [archivo2] ..."
return 1
fi
return 0

Ejemplo 6:
# Programa que ejecuta un proceso largo, y mientras tanto va mostrando un punto en la pantalla,
# simulando que el proceso va progresando.
function puntos ()
{
if [ $1 ]

# Si se ha pasado algun argumento

then
INTERVALO=$1

# Considerar el intervalo como tal

else
INTERVALO=5

# Si no se ha pasado, considerar 5

fi
while true

# Ejecutar siempre, sin fin.

do
echo ".\c"

# Imprimir un punto si salto de linea

sleep $INTERVALO

# Esperar el intervalo especificado

done
}
# Programa principal
# Lo que sea
puntos 2 &

# Se llama a la funcion puntos, con intervalos de 2 sg

[ programa que tarda mucho ]

kill -9 $!

# Se mata el ultimo proceso lanzado en background

# Lo que sea
# Fin del programa

Ejemplo 7:
# Programa encargado de comprobar la hora de los diferentes sistemas conectados
# a un sistema determinado
# En la variable SISTEMAS_TOT se definen los sistemas de los que se intentara
# obtener la hora.
SISTEMAS_TOT="maquina1 maquina2 maquina3 maquina4 maquina5 maquina6 maquina7"
# La funcion hora se encarga de pedir la hora al sistema especificado,
# filtrarla y mostrarla por pantalla.
hora()
{

hora=telnet $1 daytime 2> /dev/null | grep ":"

echo "$hora -----> $1"
}
# Comprobar si el sistema esta accesible, y si lo esta, anadirlo a la variable
# SISTEMAS, que sera la que contiene los sistemas accesibles.
for SISTEMA in $SISTEMAS_TOT
do
/usr/sbin/ping $SISTEMA -n 1 | grep " 0% packet loss" > /dev/null
if [ $? = 0 ]
then
SISTEMAS="$SISTEMAS $SISTEMA"
else
echo "$SISTEMA no esta accesible"
fi
done
#Para los sistemas accesibles comprobar la hora de los mismos en background
#para minimizar diferencias.
for SISTEMA in $SISTEMAS
do
hora $SISTEMA &
done
#Esperar a que finalice la ejecucion de todas las tareas en background.
wait
#Fin de programa

Procesamiento de Opciones (getopts)

Normalmente las opciones son precedidas por los signos - (activa la opcin) o + (la desactiva). Las opciones as
marcadas pueden ser tratadas mediante getopts.
Sintaxis:
getopts [:]opciones [argumentos] variables
Donde:
* : Se emplea para el tratamiento de errores, establece el valor de variables a ? y establece el valor de la variable de
entorno OPTARG al nombre de la opcin invlida.
* opciones son los caracteres vlidos que espera el script como opciones desde la lnea de comandos.
* argumentos son los argumentos (opcionales) que pueden requerir las opciones
* variables es el nombre de cuyo valor es una opcin de la lnea de comandos si la opcin es uno de los caracteres
vlidos.

Ejemplos:
while getopts abc opcion
do
case $opcion in
a) print "Opcion -a";;
b) print "Opcion -b";;
c) print "Opcion -c";;
+a) print "Opcion +a";;
+b) print "Opcion +b";;
+c) print "Opcion +c";;
esac
done
#funcionara con llamadas como
#

script -a -b +c

script -ac +b

#
USAGE="Sintaxis: $0 -a -b
while getopts :ab opcion
do
case $opcion in
a) print "Opcion -a";;
b) print "Opcion -b";;
+a) print "Opcion +a";;
+b) print "Opcion +b";;
\?) echo "$OPTARG no es una opcion valida.\n $USAGE";;
esac
done

Cuando una opcin debe ir seguida de un argumento se indica aadiendo : despus de la opcin, con lo que OPTARG
tomar el valor del argumento. Tambin se aade una opcin : al case para tratar la falta de argumento.
Ejemplos:
USAGE="Sintaxis: $0 -ac [-b argumento]
while getopts :ab:c opcion
do
case $opcion in
a) print "Opcion -a";;
b) programa $OPTARG;;

# La opcion -b debe llevar un argumento

c) print "Opcion -c";;

\?) echo "$OPTARG no es una opcion valida.\n $USAGE";;
:) echo "La opcion $OPTARG requiere un argumeno.\n $USAGE";;
esac
done

Como emular el DOSKEY en UNIX (Esc-K)?

En el archivo $HOME/.profile deber exitir, si no existe habr que aadir en un punto por el que siempre se pase generalmente el principio- lo siguiente:
HISTFILE=$HOME/.history
HISTSIZE=64
EDITOR=/usr/bin/vi # el PATH correcto donde se encuentre ubicado el comando vi
export HISTFILE HISTSIZE EDITOR
Antes de usar $HOME, por supuesto que debe estar definido. El tamao 64 es recomendado, puedes poner el que
quieras. El nombre del archivo en principio puede ser cualquiera, pero eligelo con lgica.
Si trabajas bajo una plataforma con entorno grficos, es posible que no fucione, para ello debers localizar el .profile
equivalente, o habilitar algn parmetro definido en dicho profile, que permita correr el .profile. Bajo la plataforma
HP-UX, en el archivo .dtprofile, bajo tu directorio, hay que activar el parmetro DTSOURCEPROFILE=TRUE
(quitale el comentario (#)). Por supuesto debes reiniciar la sesin en cualquiera de los casos.

Una Papelera de Reciclaje. No borres tus archivos de forma definitiva. Recuperalos!!!

( No es aplicable a root por motivos de seguridad en sistemas multiusuario ! )
Crea un directorio (en tu directorio de usuario) con un nombre cualquiera, pero significativo (p.e. trash). En tu
$HOME o en el directorio en que tengas tus ejecutables, create un archivo llamado rm, e inserta en l:
/bin/mv $* $HOME/trash # /bin se debe sustituir por la ubicacin real de mv
Deber tener permiso, al menos, de ejecucin y lectura para el propietario:
chmod 700 rm
En tu archivo .profile debers cambiar PATH=..., de modo que aparezca antes el directorio que contiene el nuevo rm
que el directorio que contiene el rm real (/bin o /usr/bin, depende del sistema), con el fin de que sea localizado antes
el nuevo rm que el original.
Con esto lo que se consigue es mover los archivos que se quieren borrar a un subdirectorio, por si interesara
recuperarlos. Debers limpiar este directorio de forma peridica, para lo cual te puedes generar un archivo en el
mismo directorio que el anterior que contenga una instruccin como:
/bin/rm $HOME/trash/*
o en el .profile:
find $HOME/trash -atime [DIAS] -exec /bin/rm {} \;

Backgrounds activos

Si ejecutas un shell script que tarda algn tiempo, lo suficiente como para mosquear al usuario, y quieres que el
usuario se crea que todo va bien, prueba a incluir lo siguiente en tu shell script (puedes cambiar el punto que se
imprime por cualquier carcter o smbolo, pero cuidado con las secuencias de escape):
function puntos ()
{
if [ $1 ]
then
tiempo = $1

# Lo que le indiques

else
tiempo = 5

# 5 segundos por defecto

fi
while true
do
echo ".\c"
sleep $tiempo
done
}
Programa principal:
puntos 1 & # Cada segundo imprimir un punto
PROGRAMA

# programa a ejecutar

kill -9 $! # Finaliza el ltimo programa lanzado en background presenta los resultados como quieras
if [ -f $out ] # Si se gener el archivo de salida. Prueba a insertar otras funciones
then
echo "Los resultados estan en $SALIDA"
else
echo "Algo ha fallado"
fi

Aliases o Funciones?
Habitualmente los aliases se guardan en un archivo cuyo nombre suele ser .aliases, o .env, se puede comprobar
visualizando la variable de entorno $ENV. En otras ocasiones puede estar almacenado en el propio .profile. Los
aliases vienen a tener la siguiente estructura:
alias ll="ls -l"

alias ll=ls -l

alias fcore="find / -name core -print -exec rm{} \;"

pero podemos comprobar que no admiten variables como argumentos. Para solucionar esta carencia lo que podemos
usar son funciones, teniendo en cuenta que $1, $2, etc. Son los argumentos que se pasan a la funcin. Evidentemente,
al tratarse de funciones, las podemos construir tan complejas como deseemos, pudiendo llegar a ser autnticos
programas.
Como ejemplo veamos la siguiente funcin que busca una cadena de caracteres en todos los archivos que cuelgan de
un subdirectorio determinado, y en los subdirectorios que a su vez cuelgan de l, es decir, en el rbol descendente del
subdirectorio que elijamos.

function Ffind ()
{
if [ $2 ]

# Se comprueba si existe 1 o 2 argumentos

then
DIR_INICIAL=$1
CADENA=$2
else
if [ $1 ]
DIR_INICIAL=.
CADENA=$1
else
echo "Sintaxix: Ffind <directorio> <cadena>"
return 0
fi
fi
# Ahora obtenemos el rbol de directorios sobre el que hay que buscar
DIRECTORIOS=find $DIR_INICIAL -depth -type d -print
for i in $DIRECTORIOS
do
echo "Buscando $CADENA en $i"
grep $CADENA $i/*

# Puedes usar las opciones que quieras del comando grep

done
}
Esta funcin estara en el archivo de aliases y sera de uso exclusivo del propietario, invisible a los dems.
La puedes mejorar con ms opciones, emplear recursividad, etc., el caso es que debe ser til y lo ms rpida posible,
para lo cual debe consumir el mnimo de recursos. La sintaxis que se empleara, en el caso expuesto, sera:
Ffind <directorio> <cadena>
Un ejemplo de alias dinmico, que cambie el directorio de acceso en funcin del ao en que nos encontremos puede
ser del tipo:
alias cdano="ANO=`date +%Y` ; cd /home/user/$ANO
El resto es cuestin de imaginacin.

Borrar archivos que contienen metacaracteres en su nombre.

En ocasiones se generan archivos, por error o no, que continen caracteres extraos o metacaracteres como ?, *,^C
,^H, etc. y que no pueden ser borrados habitualmente con el comando rm. Para eliminar estos archivos se puede
emplear el siguiente mtodo:
1. Listar el directorio en el que se encuentre con el comando ls -li, con el fin de anotar el i-nodo que le corresponde.
ls -li [directorio]
2. Buscar en ese directorio el archivo con el nmero de i-nodo que le corresponde y borrarlo:

find [directorio] -inum [i-nodo] -ok -exec rm {} \;

La opcin -ok se incluye para que pida confirmacin.

Ejecucin de comandos en otra mquina sin tener que acceder explcitamente.

Para ello puedes realizar un rsh (remote shell, no restricted shell) o remsh indicando el nombre de la mquina, pero si
generas un archivo con el nombre de la mquina en tu directorio de ejecutables, y lo linkas al rsh o remsh podras
realizar la misma operacin tecleando simplemente el nombre de la mquina y el comando a ejecutar. Esto viene
documentado, solo tienes que hacer un man rsh (o remsh, dependiendo del UNIX que tengas cargado) y leer por el
medio.
Por supuesto debes tener tener cuenta en dicha mquina y el acceso habilitado mediante el archivo .rhosts bajo tu
directorio.

Visualizar los procesos ejecutados por todos los usuarios conectados al sistema (whodo).
Este script, que simula el comando whodo, permite visualizar los programas que tiene cada usuario en ejecucin, as
como su direccin IP, tiempo de inactividad, terminales asociados, etc.
#!/usr/bin/ksh
usuarios=`who -u`
usu=`echo "$usuarios" | cut -f1 -d " " | sort -u`
for i in $usu
do
echo "$usuarios" |grep $i
ps -x -u $i
done

EJERCICIO
1. Realiza un script que compruebe si el usuario actual del sistema es manolo, si es as saldalo, sino te
despides de l amigablemente.

2. Realiza un script que compruebe si estamos a 25 de este mes, si es as mostrar el texto 25 de

octubre FU FU FU.

3. En un fichero tengo una palabra clave. Haz un script que muestre si dicha palabra es myfpschool
o no.

4. Realiza un script que compruebe si la segunda columna de un fichero que contiene solamente una
lnea contiene la palabra myfpschool.

5. Realiza un script que compruebe si las tres primeras columnas de un fichero (que contiene solamente
una lnea) son iguales o diferentes.

6. Realiza lo mismo pero teniendo en cuenta que el fichero est comprimido con gzip.

7. Tengo un tar con tres ficheros. Se pide realizar un script que genere un fichero toatoa.gz con las
lneas de los tres primeros ficheros que contengan la cadena te nesecito.

8. Tengo un fichero personahes.gz que contiene dos columnas <pas de procedencia>. Se desea saber el
nombre de los ciudadanos de chiquitistan. Ejemplo de fichero:
Juan holanda
Pedro chiquitistan

Ramiro rusia
Josue dinamarca

9. Se pide realizar un script que muestre las lneas de un fichero cualquiera que contengan las palabras
uno y dos sin importar sin van en maysculas y minsculas.

10. Idem que el fichero anterior pero que contengan la palabra a al comienzo de las frases.

3. Variables en bash
Una variable es un contenedor donde poder guardar informacin. Las variables se almacenan en
memoria y nos pueden servir en los shell script para guardar el nombre del usuario que lo ha
ejecutado, la fecha actual, el nombre de un directorio, etc.

Veamos un ejemplo de variable en un shell script:

#!/bin/bash
FECHA=`date +%d-%m-%y`
echo $FECHA

En la variable FECHA almaceno el resultado de ejecutar el comando date +%d-%m-%y. Para esto
utilizo el smbolo de acento ` al principio y al final del comando para delimitarlo. Para crear este
smbolo pulsa la tecla del acento y le das un espacio en blanco. De esa manera aparece ese
smbolo.
Has notado?
Que cuando asigno un valor a la variable no le pongo el smbolo $ delante y cuando la utilizo s.
Al ejecutar este script en mi terminal me aparece lo siguiente:

$ ./script.sh
21-03-14
Podemos utilizar los script para almacenar ms informacin como por ejemplo:

USER=usuario
En este caso en la variable USER almacenaremos la palabra usuario.
Veamos un ejemplo ms completo en el que se hace un backup del directorio home de un usuario
concreto:

#!/bin/bash
FECHA=`date +%d-%m-%y`
USER=usuario
echo 'Comenzando el backup...'
tar cvzf /tmp/$USER-$FECHA.tgz /home/usuario
echo 'Backup terminado'

Como puedes ver en las variables FECHA y USER vamos a guardar informacin que luego se
utilizarn en el comando tar para realizar el backup.
Recuerda.
En shell script hay que tener cuidado con las maysculas y minsculas. FECHA y fecha son para
shell script variables diferentes. Acostmbrate por ejemplo a escribir las variables en mayscula y no
tendrs problemas.
Ejercicio propuesto.
Modifica el ejemplo anterior para que haga el backup de un directorio de prueba que crees al efecto.
Prueba a realizar un backup del directorio, borrarlo y restaurarlo para comprobar que tu script
funciona correctamente.

4. Funciones en bash
En primer lugar tenemos que tener en cuenta qu es una funcin y para qu se utiliza. Imagina
que tienes que hacer una tarea con comandos de forma repetitiva. Lo primero que piensas es en
hacer un script para automatizar dichas tareas. Cierto, yo pensara lo mismo.

Imagina ahora tambin que vas a hacer (adems de esa) otro tipo de tareas repetitivas pero hay
algunas partes de esas tareas que son iguales (se van a repetir). Tienes dos opciones, copiar y
pegar esa parte del cdigo con lo cual esa parte del cdigo se va a reproducir en muchos script, o
mejor, crear una funcin que pueda ser utilizada por todos los script.

Las funciones en bash nos permiten agrupar comandos y tienen la ventaja que las podemos
comprobar y verificar que son eficientes. Si queremos modificar algo solamente tendremos que
modificar la funcin. Es ms, si falla algo el error lo tendremos tambin ms localizado y ser ms
fcil de corregir.

Veamos a continuacin un ejemplo de hola holita con funciones:

#!/bin/bash
HOLA=hola

#asigno hola a la variable HOLA

function hola {
funcin

#me creo la funcin hola, los corchetes delimitan la

local HOLA=holita #creo una variable local HOLA que solamente va a

funcionar DENTRO de la funcin
echo $HOLA #muestro el contenido de la variable local HOLA que
contendr "holita"
}
echo $HOLA #mostrar el contenido de la variable HOLA de la segunda
lnea
hola

#llamo a la funcin que mostrar por pantalla holita

echo $HOLA #muestro de nuevo el contenido de la variable HOLA de la

segunda lnea
Ejercicio propuesto.
1. Copia y ejecuta el contenido del script anterior. Prueba que funciona.
2. Crea una segunda funcin con el nombre que quieras y modifica el script para que ejecute la
segunda funcin tambin.

1. Sentencias condicionales
Imagina que ests vendiendo entradas de cine. Si te viene alguien hablando en espaol tu le
contestas en espaol y si te habla en otro idioma tu le contestas en ingls porque imagnate que es
el nico idioma que conoces adems del espaol.

Eso traducido a rdenes en shell script sera algo parecido a lo siguiente:

if [ habla_en_espaol]; then

contesto_en_espaol
else
contesto_en_ingls
fi

En realidad contesto_en_espaol y contesto_en_ingls no existe en shell script pero en vez de eso

que me he inventado podramos preguntar por el valor de alguna variable o preguntar si alguna
variable tiene algn valor o es nula, etc.

En shell script existen tres tipos diferentes de sentencias condicionales:

Condicionales

if expresin then sentencia

if expresin then sentencia1 else sentencia2
if expresin then sentencia1 else if expresin2 then sentencia2 else sentencia3
Veamos a continuacin algunos ejemplos de sentencias condicionales en shell script:

#!/bin/bash
# Este es un ejemplo de if expresin then sentencia
if [ "alboran" = "alboran" ]; then
echo "Cierto, alboran == alboran"
fi
Este es otro ejemplo pero utilizando el patrn if expresin then sentencia1 else sentencia2
#!/bin/bash

if [ "alboran" = "alboran" ]; then

echo "Cierto, alboran == alboran"
else
echo Era falsa
fi

Recuerda.
Ten cuidado con los espacios en blanco. Intenta respetar los espacios en blanco en las expresiones
porque de lo contrario al ejecutar tu shell script puedes tener problemas.
Veamos otro ejemplo utilizando ahora variables y sentencias condicionales:

#!/bin/bash
T1="mar de"
T2="alboran"
if [ $T1 = $T2 ]; then
echo "Cierto, " $T1 " == " $T2
else
echo "No es cierto"
fi
Ejercicios propuestos.
1. Copia y ejecuta el ejercicio anterior. Comprueba que funciona y modifcalo para que T1 sea igual
a T2. Comprueba ahora que dice Cierto..
2. Crea un nuevo shell script que diga si el usuario que lo est ejecutando es root o no (recuerda
que con el comando echo $USER puedo conocer el nombre del usuario actual).

2. Sentencias repetitivas. Los bucles

En shell script hay tres sentencias repetitivas bastante tiles. La sentencias for, while y until.
Veamos detenidamente cada una de estas sentencias:

for La sentencia for se utiliza cuando se quieren ejecutar una serie de sentencias un
nmero determinado de veces. La sentencia for en shell script es un poco diferente a la
sentencia for de otros lenguajes de programacin. Una ventaja del for de shell script es que se
puede iterar sobre cadenas (ya veremos ms adelante cmo se hace).
while Esta sentencia ejecuta un trozo de cdigo si una condicin se cumple, y para cuando
dicha condicin es falsa
until Muy parecida a la anterior. La sentencia until ejecuta un pedazo de cdigo hasta que
una expresin sea falsa. La diferencia con la anterior es que mientras que while pregunta y
luego ejecuta, until primero ejecuta y luego pregunta. Ten en cuenta que toda sentencia until
se puede convertir en una sentencia while.
Veamos un ejemplo de la sentencia for:

En este caso se muestran todos los ficheros del directorio desde donde se ejecuta el script
anterior. La variable i va tomando como valor uno a uno el nombre de los archivos del directorio
actual. Como puedes ver, dentro del for (desde el do hasta el done) se muestra el contenido de la
variable i.
Ejercicio propuesto.
Copia y ejecuta el ejercicio anterior. Comprueba que funciona y modifcalo para que muestre otro
directorio a tu eleccin.
Veamos otro ejemplo. El ejemplo anterior no es muy parecido a los bucles for de otros lenguajes
como java, C, etc. El siguiente ejemplo s se asemeja al for de dichos lenguajes:

El comando seq 1 10 genera una secuencia que va del 1 al 10. Si te fijas lo que har este script es
mostrar por pantalla los nmeros del 1 al 10 ambos incluidos.
Ejercicio propuesto.
Copia y ejecuta el ejercicio anterior. Comprueba que funciona y modifcalo para que muestre los
nmeros del 5 al 50.
Seras capaz de hacer que solamente se muestren los nmeros pares?
Bueno, ya que sabemos cmo funciona el bucle for pasemos a ver cmo funcionan los bucles
while y until. Si has entendido el for no te costar nada aprender estos otros. Veamos
primeramente cmo funciona el bucle while con un ejemplo:

En este ejemplo tenemos una variable que se llama CONTADOR que al principio vale 0 y luego se
va incrementando uno a uno hasta llegar a 10. El resultado de ejecutar el script anterior es el
siguiente:
El
El
El
El
El
El
El
El
El
El

contador
contador
contador
contador
contador
contador
contador
contador
contador
contador

es
es
es
es
es
es
es
es
es
es

0
1
2
3
4
5
6
7
8
9

No llega a mostrar el valor 10 porque la condicin es CONTADOR -lt 10 (lt es less than). Ya
veremos ms adelante cmo funcionan las condiciones.

Veamos ahora un ejemplo con until:

Ejemplo del until

El resultado de ejecutar el script anterior es el siguiente:

CONTADOR: 20
CONTADOR: 19

CONTADOR:
CONTADOR:
CONTADOR:
CONTADOR:
CONTADOR:
CONTADOR:
CONTADOR:
CONTADOR:
CONTADOR:

18
17
16
15
14
13
12
11
10

Ejercicios propuestos.
1. Realiza un script que muestre los nmeros pares del 0 al 100 con while.
2. Realiza el mismo ejercicio de forma descendente pero utilizando until.
Si te ha gustado este post o lo has encontrado interesante no dejes de continuar aprendiendo shell
script en la tercera entrega.

1. Volviendo a las funciones

Ya vimos en un post anterior los fundamentos de las funciones. Las funciones no solo nos van a
servir para hacer los programas ms ordenados, sino para reusar el cdigo o incluso hacer
recursividad (aunque con shell script no es lo suyo).
Veamos ejemplos de un uso algo ms avanzado sobre funciones:

No se si te has percatado en el ejercicio anterior, pero TATACHAN nunca aparecer por pantalla. Si
te das cuenta, la funcion salte hace que el script termine en ese mismo instante.

Una caracterstica fundamental de las funciones son los argumentos. Los argumentos nos sirven
para parametrizar las funciones y que estas sean ms genricas.
A continuacin se muestra un ejemplo de funciones con argumentos:

Si te das cuenta, la funcin mostrar admite un parmetro que es $1. Si se le quisiesen pasar dos
parmetros seran $1 para el primero y $2 para el segundo (y as sucesivamente). Esta funcin de
momento solamente muestra el parmetro por pantalla pero podra hacer muchas ms cosas con
l.
Realiza un script con una funcin factorial que muestre por pantalla el factorial del nmero que se le
pasa como parmetro. No utilices recursividad, utiliza los bucles vistos con anterioridad.

2. Argumentos pasados a un shell script.

Los argumentos son los parmetros que le pasamos a un comando para parametrizarlo. Por
ejemplo, cuando tecleo ps -ef, el -ef son los parmetros que le paso a ps para que realice lo que
yo quiero. Tambin cuando ejecuto mv fichero.txt fichero2.txt, a mv le paso dos parmetros que
son el nombre del fichero a renombrar y el nombre que queremos ponerle.

Dentro de un script podemos referenciar los argumentos pasados al mismo mediante las
siguientes variables:

$0 nombre del script

$1 primer argumento
$2 segundo argumento
Y as sucesivamente

 $# numero de argumentos pasados

$* todos argumentos pasados
Para ver cmo funcionan los parmetros veamos un programa que comprueba si se le ha pasado
al menos un parmetro:

Como puedes ver al principio del script compruebo con [ -z "$1" ] que al menos existe el primer
parmetro y en caso contrario muestra los mensajes que ves y sale con el comando exit. De esa
manera termina y no se sigue ejecutando el script.

El script anterior puede servirnos para crear un script algo ms complejo como el siguiente:

Como puedes ver, he reutilizado el script anterior para hacer uno ms completo. Este script
establece unos directorios origen y destino del backup y un fichero (FICH) donde se va a realizar el
backup el cual tiene como nombre backup- y la fecha en que se realiz.

Copia y ejecuta el cdigo anterior. Comprueba que funciona y modifica el cdigo para cambiar el
nombre del fichero y que almacene los backup en otro directorio.

3. Interaccin con el usuario.

Los script por regla general no suelen ser muy interactivos pero en algunos casos como en los
mens es necesario pedir al usuario que elija una opcin, pedirle informacin, etc.

Esas lecturas interactivas con los usuarios las hacemos mediante la orden read. Veamos un
ejemplo muy sencillo de script con una orden read:

#!/bin/bash
echo Por favor, introduzca su nombre
read NOMBRE
echo " Hola $NOMBRE, cmo estas? "

Incluso si quieres, puedes poner varias lecturas en una misma orden read:

#!/bin/bash
echo Por favor, introduzca su nombre y apellido
read NOMBRE APELLIDO
echo " Hola $NOMBRE $APELLIDO, cmo estas? "

Existe una forma de lectura de variables un poco ms profesional y es meterle la opcin -n.
echo -n Introduzca un parmetro :
read VAR
echo El valor del parmetro es $VAR

De esta manera lee el parmetro en la misma lnea que escribe el texto y no en la siguiente.

Si te ha gustado este post o lo has encontrado interesante no dejes de continuar aprendiendo shell
script en la cuarta entrega.

Doblamos un nmero?
#!/bin/bash
clear
read -p Inserta un nmero: numero
until [ $numero -eq 0 ]; do
let numero=numero*2
echo El doble es $numero.
read -p Quieres doblar? respuesta
if [ $respuesta = no ] || [ $respuesta = NO ]; then
numero=0
else
echo Interpretaremos que has dicho que s
fi
done
echo Adis
Dejar un comentario

19 OCTUBRE, 2012

Mximo divisor de un nmero pedido por pantalla

#!/bin/bash
function mcd {
resto=1
let i=numero-1
while [ $resto -ne 0 ]; do
let resto=numero%i
if [ $resto -eq 0 ]; then
echo El mximo divisor de $numero es $i
fi
let i=i-1
done
}
read -p Introduce un nmero: numero
mcd
Dejar un comentario

19 OCTUBRE, 2012

Variable Local
#/!bin/bash
function saludo {

local NOMBRE=Jose Antonio

echo Hola seor $NOMBRE encantado de conocerle
}
NOMBRE=Juana
saludo
echo En el script principal, mi nombre es $NOMBRE
Dejar un comentario

19 OCTUBRE, 2012

Variable Global
#/!bin/bash
function saludo {
NOMBRE=Jose Antonio
echo Hola seor $NOMBRE encantado de conocerle
}
NOMBRE=Juana
saludo
echo En el script principal, mi nombre es $NOMBRE

Dejar un comentario

19 OCTUBRE, 2012

Calculadora
#Primero duplica el nmero (3 en este caso), despus lo triplica y finalmente vuelve a mostrar el nmero
original

#/!bin/bash
function doble {
echo voy a doblar el valor de numero
let NUMERO*=2
}
function triple {
echo voy a triplicar el valor de numero
let NUMERO*=3
}
function reset {
echo voy a resetear el valor de numero
let NUMERO=3
}
NUMERO=3
echo $NUMERO vale: $NUMERO
doble
echo $NUMERO vale: $NUMERO
triple
echo $NUMERO vale: $NUMERO
reset
echo $NUMERO vale: $NUMERO
Dejar un comentario

17 OCTUBRE, 2012

Mostrar IP
#Muestra por pantalla la IP del equipo
#!/bin/bash
clear
echo Mi IP es: $(ifconfig eth0 | grep inet | cut -d: -f2 | cut -d -f1)
Dejar un comentario

17 OCTUBRE, 2012

Crear fichero con un tamao variable

#El script te pide que introduzcas un nombre de fichero y un tamao. Se crear un archivo con el tamao
establecido.

#!/bin/bash
clear
read -p Introduce una nombre fichero: nombre
read -p Introduce su tamao: tamano
if [ -n $nombre ]; then
nombre=vacio
fi
if [ -n $tamano ]; then
tamano=1
fi
dd if=/dev/zero of=$nombre count=$tamano bs=1024
Dejar un comentario

17 OCTUBRE, 2012

Contador de vocales y consonantes

#Introduce por teclado una palabra y la longitud de dicha palabra. El algoritmo indica si hay el mismo
nmero de vocales y consonantes o te indica cul tiene ms.
#!/bin/bash
clear
read -p Introduce una palabra: palabra
read -p Introduce la longitud: longitud
pila=0
contador=1
while [ $contador -le $longitud ]; do
aux=$(echo $palabra | cut -c $contador)
if [ $aux = a ]; then
let pila=pila+1
elif [ $aux = e ]; then
let pila=pila+1
elif [ $aux = i ]; then
let pila=pila+1
elif [ $aux = o ]; then

let pila=pila+1
elif [ $aux = u ]; then
let pila=pila+1
else
let pila=pila-1
fi
let contador=contador+1
done
if [ $pila -eq 0 ]; then
echo La palabra $palabra tiene el mismo numero de vocales que consonantes
elif [ $pila -gt 0 ]; then
echo La palabra $palabra tiene ms vocales que consonantes
else
echo La palabra $palabra tiene menos vocales que consonantes
fi

Dejar un comentario

17 OCTUBRE, 2012

Par o impar
#Introduce un nmero y te indicar si es par o impar.
#!/bin/bash
read -p Introduce un numero para saber si el numero es par o impar: numero
let resto=numero%2
if [ $resto -eq 0 ]; then
echo El numero $numero es par
else
echo El numero $numero es impar
fi
Dejar un comentario

17 OCTUBRE, 2012

Case Zodiaco
# Introduce el ao que naciste y te dir el signo del zodiaco que eres.
#!/bin/bash
clear
read -p Inserta el ao que naciste: ano
let zodiaco=ano%12
case $zodiaco in
0) signo= el Mono ;;
1) signo= el Gallo ;;
2) signo= el Perro ;;
3) signo= el Cerdo ;;
4) signo= el Rata ;;
5) signo= el Buey ;;
6) signo= el Tigre ;;
7) signo= el Conejo ;;
8) signo= el Dragon ;;
9) signo= el Serpiente ;;

10) signo= el Caballo ;;

11) signo= el Cabra ;;
esac
echo Tu signo chino es $signo
Dejar un comentario

17 OCTUBRE, 2012

Case Colores
#!/bin/bash
#pedir al usuario doce colores de una paleta de 4: rojo, verde, azul, negro y mostrar cuntas veces ha
introducido dichos colores.

clear
function comprobar {
case $color in
rojo) let rojo=rojo+1 ;;
verde) let verde=verde+1 ;;
azul) let azul=azul+1 ;;
negro) let negro=negro+1 ;;
*) let invalido=invalido+1 ;;
esac
}
rojo=0
verde=0
azul=0
negro=0
invalido=0
for (( i = 1 ; i <= 12; i++ )) do
read -p Inserta un color entre rojo, verde, azul y negro: color
comprobar
done
echo Has introducido $rojo veces el color rojo \
Has introducido $verde veces el color verde \
Has introducido $azul veces el color azul \
Has introducido $negro veces el color negro \
y has introducido $invalido errores.

Dejar un comentario

17 OCTUBRE, 2012

Capica
#Pide al usuario un nmero de tres digitos y nos dice si es capica o no
#!/bin/bash
read -n 3 -p Introduce un numero de 3 digitos: numero
echo
if [ $numero -lt 100 ]; then
echo El numero no tiene 3 cifras
else
primeracifra=$(echo $numero | cut -c 1)
terceracifra=$(echo $numero | cut -c 3)
if [ $primeracifra -eq $terceracifra ]; then
echo El nmero es capica

else
echo El nmero no es capica
fi
fi

2. Escribe un script que te pida por teclado el nombre, despus los dos apellidos,
permanezca esperando durante 5 segundos y despus muestre por pantalla un
mensaje Tu nombre completo es ., .., ..
#!/bin/bash
#uso del comando read con varios parmetros y varios read
echo "Cul es tu nombre?"
read nombre
echo "Cules son tus apellidos?"
read apellido1 apellido2
sleep 5 # dormimos la terminal 5 segundos
echo " Tu segundo apellido es $apellido2 "
echo " Tu nombre completo es $nombre $apellido1 $apellido2"
echo " Hola $nombre"
Como veremos en la salida podemos llamar a las variables introducidas
en el orden en que queramos. Solo he usado el comando sleep para
que podis apreciar la salida del script diferenciada de la entrada de
parmetros.

2 El cuadrado de un numero el Vie Mayo 11, 2012 5:46 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Escribe un script que pida por teclado un nmero y despus muestre por pantalla.
El resultado del cuadrado de (nmero introducido) es (numero al cuadrado).
La funcin a utilizar para generar el cuadrado es `expr $num \* $num`
#!/bin/bash
#Ejemplo de expr (el cuadrado de un numero)
echo "Dame un nmero."
read numero
resultado=`expr $numero \* $numero` # declaramos la variable

resultado, como resultado de expr

echo "El resultado del cuadrado de $numero es $resultado"

3 IFS el Vie Mayo 11, 2012 6:29 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Explica lo que realiza este script
#!/bin/bash
IFS=$','
vals='/mnt,/var/lib/vmware/Virtual Machines,/dev,/proc,/sys,/tmp,/usr/portage,/var/
tmp'
for i in $vals; do echo $i; done
unset IFS
Output:
/mnt
/var/lib/vmware/Virtual Machines
/dev
/proc
/sys
/tmp
/usr/portage
/var/tmp
En este caso el separador usado es la coma, despus se carga en la variable
vals, la lista de directorios que se indica en el ejemplo. Posteriormente
se trabaja con esa variable vals, mostrando por pantalla cada uno de los
directorios que se encuentran separados por comas hasta llegar al final de
dicha variable.

Modifica estas dos lneas de cdigo para que en ambos casos, muestra el ao, mes y da.
echo "2010 10 12" | read y m d
r=$(echo '2010-10-12' |(IFS='-'; read y m d; echo $y $m $d))
Para que ambas lneas de comando muestren lo mismo por pantalla, en la primera
lnea hay que incluir lo siguiente.
echo "2010 10 12" | (IFS= ; read y m d; echo $y $m $d)
Si queremos que salte de lnea
echo "2010 10 12" | (IFS= ; read y m d; echo $y; echo $m; echo $d)

Explica lo que genera este script, si realizsemos un $login $pw $uid $gid
grep asir /etc/passwd | IFS=":" read login pw uid gid gecos home sh
Busca el usuario asir en el fichero /etc/passwd, despus carga en las
variables login pw uid gid gecos home sh, el valor de esa lnea.
Pero no muestra nada por pantalla.

4 Case ANIMALES el Vie Mayo 11, 2012 6:36 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Crea un programa que pida por pantalla el nombre de un animal (caballo, perro, gato,
canguro, gallina). Si se introduce uno de los tres primeros, mostrara por pantalla el
siguiente mensaje es una animal de 4 patas, si son los dos ltimos, mostrara por pantalla es
un animal de 2 patas.
#!/bin/bash
read -p "Introduce el nombre de un animal (caballo, perro, gato, canguro, gallina): " animal
case $animal in
caballo|perro|gato) echo "Es un animal de 4 patas";;
canguro|gallina) echo "Es un animal de 2 patas";;
*) echo "No has introducido ningun animal anterior";;
esac

5 CADENAS IGUALES IF el Vie Mayo 11, 2012 7:09 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Crear un programa que meta dos cadenas de caracteres en dos variables. Y las compare, si
son iguales mostrara por pantalla las cadenas son iguales y si no lo son mostrara el mensaje
contrario.
read -p "introduce una cadena: " cadena1
read -p "Introduce otra cadena: " cadena2
if [ $cadena1 = $cadena2 ]
then echo "son iguales"
else echo "son distintas"
fi

6 USUARIO Y GRUPO EXISTENTES el Vie Mayo 11, 2012 7:36 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Este script es un claro ejemplo de cmo comprobar si un usuario y un grupo existen en el
sistema, vemos tambin el uso que se le da al elif.
#! /bin/bash
clear
read -p Introduce usuario user
read -p Introduce grupo group
if `grep -e $user:.* /etc/passwd >/dev/null`
then
if `grep -e $group:.* /etc/group >/dev/null`
then
echo Usuario y grupo ya existen en el sistema
fi
elif `grep -e $group:.* /etc/group >/dev/null`
then
echo usuario no existe, grupo si!!
else
echo Ni grupo ni usuario existen
fi

7 cual es el mayor o si son iguales (ELIF) el Vie Mayo 11, 2012 7:42
am
Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Crear un script que pida dos nmeros por teclado, compruebe que se han cargado con un
valor, una vez asegurado de ello. Compruebe si son iguales, y muestre por pantalla, dichos
nmeros son iguales, si un numero es mayor que el otro, y si un numero es menor que otro.
read -p "introduce un numero:" cadena1
read -p "introduce otro numero:" cadena2
if [ $cadena1 -eq $cadena2 ]
then echo "los dos numeros son iguales"
elif [ $cadena1 -gt $cadena2 ]
then echo "el primer numero es mayor"
else "el segundo numero es mayor"
fi

8 UTILS el Vie Mayo 11, 2012 8:25 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
x=1
until [ $x -ge 10 ]
do
echo $x
x=`echo "$x + 1" | bc`
done

9 copiar ficheros directorios el Vie Mayo 11, 2012 8:27 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Crear un script que reciba un directorio como primer parmetro, y a continuacin una lista
de archivos. El script debe validar que los parmetros recibidos sean realmente archivos y
luego copiarlos al directorio recibido.
if [ -d $1 ]; then
nombre_dir=$1
shift
for i in $*; do
if [ -f $i ]; then
cp $i $nombre_dir
else
echo "El archivo $i no es vlido"
fi
done;
else
echo "El primer parmetro debe ser un directorio"
fi

10 INTRODUCIR TEXTO A UN ARCHIVO el Vie Mayo 11, 2012 8:29

am
Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
read -p "Desea aadir una nueva direccin (s/n): " CONF
case $CONF in
[sS]*) read -p "Introduce la direccin:" DIRECCION
echo $DIRECCION >> Fichero_Datos.txt
;;
*) echo "El fichero no se modifica"
;;
esac

11 CASE REALIZAR COMANDOS el Vie Mayo 11, 2012 8:31 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
echo Por favor seleccione P, D o Q para
echo [P]rint Imprime un archivo
echo [D]elete Borra un archivo
echo [Q]uit Sale del programa
read response
case $response in
P|p) echo Nombre del archivo a imprimir?
read filename
lp $filename;;
D|d) echo Nombre del archivo a eliminar?
read filename
rm $filename;;
*) echo Salir ahora;;
esac

12 ORDENAR ARCHIVOS RECIENTES el Vie Mayo 11, 2012 8:33 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Se pueden hacer selecciones segn el nmero de parmetros (representado por el shell como
$#).Interprete, pruebe y comente el siguiente archivo de comandos:
# Nombre: recent
case $# in
0) ls lt |head ;;
1) case $1 in
[0-9]) ls lt |head -$1 ;;
*) echo Uso: nmero de archivos recientes;;
esac;;
*) echo Uso: nmero de archivos recientes;;
esac

13 CASE WHO O IF el Vie Mayo 11, 2012 8:38 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
case `who | grep $1>/dev/null` in
0) echo "$1 est conectado" ;;
*) echo "$1 no est aqu. Intntelo ms tarde" ;;
esac
echo "Pase un buen dia."
-----------------------------------------------------------------------if who | grep $1>/dev/null

then echo $1 est conectado

else echo $1 no est aqu. Intntelo ms tarde
fi
echo Pase un buen dia.

14 COPIAR TEST el Vie Mayo 11, 2012 8:47 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
2. El comando test le permite realizar todo tipo de comprobaciones muy tiles antes de
ejecutar un
determinado comando. Consulte la pgina del man para este comando y a continuacin
interprete,
pruebe y comente los siguientes archivos de comandos:

Sobran puntos y comas en todas menos en las case;el script testea las opciones hasta que le
pones
Si quieres copiar el archivo no , si es no sale si es si lo copia donde tu le ordenes el destino.
# Nombre: safcopy
case $# in
2) if test ! r $1;;
then
exit(1)
fi
if test f $2
then
if test w $2
then
echo $2 existe Desea una copia an? (Y|N)
read resp
case $resp in
Y|y) cp $1 $2
*)
exit(1);;
esac
else
exit(1)
fi

else
cp $1 $2
fi
*) echo Uso: safcopy <origen><destino>
exit(1)
esac

15 HORARIO BUENOS DIAS el Vie Mayo 11, 2012 8:49 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
hour=`date +%H`
if test $hour lt 12
then echo Buenos das, $LOGNAME
else
if test $hour lt 17
then echo Buenas tardes, $LOGNAME
else echo Buenas noches, $LOGNAME
fi
fi

Reiniciar si es un usuario el Vie Mayo 11, 2012 8:51 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
#!/bin/bash
if [ "$(whoami)" = 'root' ] then
shutdown -r +1
else
echo "El script no se ejecutar porque usted no es usuario 'root'"
fi

17 ORDENAR DE A a Z el Vie Mayo 11, 2012 8:57 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
if [ $# -eq 2 ]
then echo "Se deben pasar dos argumentos. Formato correcto $0 archivo A o Z"
if [ -f $1 ]
then
if [ $2 = "A" ]
then cat |sort $1
elif [ $2 = "Z" ]
then cat |sort -r $1
else echo "Error. $2 no es ni A ni Z."
fi
else echo " $1 no es un fichero"
fi
else echo "Se necesitan dos parametros.Sintaxis : archivo A o Z"
fi

18 INFINITO el Vie Mayo 11, 2012 8:58 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
while :
do echo "Hola mundo"
sleep 1
done

19 ENTRAR DENTRO DEL DIRECTORIO Y BUSCAR UN ARCHIVO el Vie

Mayo 11, 2012 9:04 am
Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
if test $# -lt 2
then

echo "Error. No se proporcionaron argumentos. La sintaxis es la siguiente:"

echo "$0 nombre_directorio nombre_archivo"
elif test -d $1
then
cd $1
file * | grep $2
fi

20 TIPO DE ARCHIVO el Vie Mayo 11, 2012 9:05 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
if test $# -lt 1
then echo "Error. No se proporcionaron argumentos. La sintaxis es la siguiente:"
echo "$0 nombre_directorio"
elif test -f $1
then echo "Error. $1 no es un directorio. La sintaxis del script es la siguiente:"
echo "$0 nombre_directorio"
elif test -d $1
then cd $1
file *
else echo "Error. $1 no es ni directorio ni archivo. La sintaxis del script es la siguiente:"
echo "$0 nombre_directorio"
fi

21 SESION 7 listar y copiar el Vie Mayo 11, 2012 9:09 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
Con un bucle for podr especificar un conjunto de archivos o valores para que se utilicen con
algunos comandos. Por ejemplo, para copiar todos los archivos cuyos nombres terminen por
.txt al directorio textdir utilice el siguiente bucle for:

#!/bin/bash
mkdir textdir
for i in $(ls *.sh)
do
cp $i textdir/$i
done

El shell interpreta la expresin anterior y hace que la variable i tome en cada iteracin el valor
de cada uno de los ficheros de la lista que sigue a in.

22 IMPRESORA + MAIL SESION 7 el Vie Mayo 11, 2012 9:10 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
for i in $*
do
if [ lp -t $i 2>/dev/null ]
then
echo $i >> printed
else
echo $i >> notprinted
fi
done
if test -s printed
then
echo "Estos archivos fueron enviados a la impresora">mes
cat printed>>mes
mail $LOGNAME < mes
#rm mes printed
fi
if test -s notprinted
then echo "Estos archivos no fueron enviados a la impresora">mes
cat notprinted>>mes
mail $LOGNAME < mes
#/var/mail
#rm mes notprinted
fi

23 Correo nuevo el Vie Mayo 11, 2012 9:12 am

Demichelis

Mensajes: 32
Fecha de inscripcin:11/05/2012
cp $MAIL omail
while diff omail $MAIL>/dev/null
do
cp $MAIL omail
sleep 30
done
echo "Correo Nuevo !!!" | write $LOGNAME

Ejercicios resueltos sobre ficheros y directorios

Guion de shell que genere un fichero llamado listaetc que contenga
los ficheros con permiso de lectura que haya en el directorio /etc:
for F in /etc/*
do
if [ -f $F -a -r $F ]
then
echo $F >> listaetc
fi
done

Hacer un guion de shell que, partiendo del fichero generado en el

ejercicio anterior, muestre todos los ficheros del directorio /etc que
contengan la palagra ?procmail?:
while read LINEA
do
if grep procmail $L >/dev/null 2>&1
then
echo $L
fi
done <listaetc

Hacer un guion de shell que cuente cuantos ficheros y cuantos

directorios hay en el directorio pasado como argumento:
DI=0
FI=0
for I in $1/*
do
if [ -f $I ]
then
let FI=FI+1
fi
if [ -d $I ]
then
let DI=DI+1
fi
done

Hacer un guion de shell que compruebe si existe el directorio pasado

como argumento dentro del directorio activo. En caso de que exista,
que diga si no est vaco.
if [ -d $1 ]
then
echo ?$1 existe?
N=$(ls | wc -l)
if [ $N -gt 0 ]
then
echo ?S1 no est vacio, contiene $N ficheros no
ocultos?
fi
fi

Hacer un guion de shell que copie todos los ficheros del directorio
actual en un directorio llamado csg. Si el directorio no existe el guion lo
debe de crear.
if [ ! -d csg ]
then
mkdir csg
fi
cp * csg

Hacer un script que muestre el fichero del directorio activo con ms

lneas:
NLIN=0
for I in *
do
if [ -f $I ]
then
N=$(wc -l $I)
if [ $N -gt $NLIN ]
then
NOMBRE=$I
NLIN=$N
fi
fi
done
echo ?$NOMBRE tiene $NLIN lineas?

SCRIPTS de LINUX
Scripts bsicos de frmulas matemticas.
Notas:
- Los signos ` son acentos, NO son ' apstrofes.
- Cuando la variable est a la izquierda de la igualdad o con el read,
no lleva $. Cuando se opera con ella o va con el echo s lleva $
a=12356
read b
resul=`expr $a + $b`
echo Solucion $resul
- Cuidado, segn la orden el signo = deber estar junto o separado:
a=12345
while [ $b = "hola" ]

El = va junto
El = va separado

- No olvides que para ejecutar un script debemos darle permiso de

ejecucin.

chmod +x trian
- Para ejecutar un script nos situamos en la carpeta en donde est
guardado y escribimos ./trian
- Para evitar tener que escribir ./ y poder ejecutarlo desde cualquier
carpeta, hacemos lo siguiente...
--- Creamos una carpeta llamada losscripts en donde guardaremos
todos nuestros scripts
mkdir /home/juan/losscripts
Ahora aadimos esa carpeta al PATH; para que siempre reconozca
el PATH, editamos el archivo...
/home/juan/bashrc o bien el /home/juan/.bash_profile, depende de la
versin y aadimos...
PATH="$PATH:/home/juan/losscripts"
A partir de ahora para ejecutar un script slo tenemos que escribir
su nombre... trian

Aqu estan los scripts siguientes comprimidos: scripts.zip (10 KB)

Realizacin de scripts en donde los valores se introducen mediante
parmetros ($1 $2)
1.- Realiza un script llamado trian, al cul haya que suministrarle
dos parmetros que sern la base y altura de un tringulo. Nos dar
como resultado el rea del tringulo.
re=`expr $1 \* $2 / 2`
echo "El area del triangulo cuya base es $1 y cuya altura es $2 vale $re"
Lo ejecutaremos as:
./trian 24 36
$1 ser el primer nmero que introducimos, en este caso el 24
$2 ser el segundo nmero que introducios, en este caso el 36
2.- Realiza un script llamado opera, al cul haya que suministrarle
dos parmetros.
Nos dar la suma, resta, multiplicacin y divisin de los dos nmeros
introducidos.
sum=`expr $1 + $2`
echo $1 + $2 = $sum
res=`expr $1 - $2`
echo $1 - $2 = $res
mul=`expr $1 \* $2`
echo $1 x $2 = $mul
div=`expr $1 / $2`
echo $1 / $2 = $div
Lo ejecutaremos as:
./opera 46 52
3.- Realizar un script llamado faren, al cul haya que suministrarle
un parmetro que ser grados centgrados. Nos dar grados
Farenheit.
F = 1,8 * C + 32
(Puedes ver un ejemplo de convertidor de centigrados a faren en Visual
Basic 22visualbasic2.htm)
a=`expr 2 \* $1`
far=`expr $a + 32`

echo $1 grados Farenheit son $far grados Centigrados

Notas:
- Debido a que la orden expr no actua con nmero decimales, en vez
de poner 1.8 se ha puesto 2
- La orden expr realiza: suma +, resta -, multiplicacin \*, divisin /,
resto %
- La multiplicacin lleva \ para que el * no sea comodn: \*
Lo ejecutaremos as:
./faren 36
4.- Realizar un script llamado media, al cul haya que suministrarle
4 parmetros.
Nos dar la media de esos 4 nmeros.
a=`expr $1 + $2 + $3 + $4`
med=`expr $a / 4`
echo La media de estos numeros es $med
Lo ejecutaremos as:
./media 36 42 64 28
Notas:
- Otra forma de hacerlo:

med=`expr \( $1 + $2 + $3 + $4` \) / 4

- Se ha puesto parntesis, pero hemos tenido que poner \ para anular

el significado especial del carcter parntesis: \(
\)
5.- Realizar un script llamado archi, al cul haya que suministrarle
un parmetro que ser la direccin absoluta de un archivo.
- SI el archivo existe
- ENTONCES lo presentar en pantalla (cat )
- SINO lo crear y aadir la frase "Esto es un archivo nuevo"
if [ -f $1 ]
then
cat $1
else
echo "Esto es un archivo nuevo" > $1
fi
Lo ejecutaremos as:
./archi /home/utele12/mifichero
6.- Realizar un script llamado dire, al cul haya que suministrarle

un parmetro que ser la direccin absoluta de un directorio.

- SI el directorio existe
- ENTONCES lo listar (ls -ali $1)
- SINO indicar que "No existe" y lo crear (mkdir $1)
if [ -d $1 ]
then
ls -ali $1
else
echo "No existe"
mkdir $1
echo "El directorio ha sido creado"
fi
Lo ejecutaremos as:
./dire /home/utele12/micarpeta
7.- Realizar un script llamado carnet, al cul haya que suministrarle
dos parmetros. Uno sera un nombre de persona y el otro la edad.
- SI es mayor o igual (-ge) de 18
- ENTONCES escribir el nombre y que es mayor de edad
- SINO escribir el nombre y que no es mayor de edad
if [ $2 -ge 18 ]
then
echo $1 eres mayor de edad, tienes $2
echo Puedes sacarte el carnet
else
echo $1 eres menor de edad, tienes $2
echo No puedes tener carnet
fi
Lo ejecutaremos as:
./carnet juan 23
En este caso:
$1 es juan
$2 es 23
8.- Realizar un script llamado bisiesto, al cul haya que
suministrarle un parmetro que ser un ao. El script nos dir si ese
ao es bisiesto o no.
Un ao es bisiesto cuando al dividirlo entre 4 nos d de resto 0.
Para obtener el resto de una divisin, se utiliza $1 % 4

bisi=`expr $1 % 4`

if [ $bisi -eq 0 ]
then
echo El $1 es bisiesto.
else
echo El $1 no es bisiesto.
fi
Lo ejecutaremos as:
./bisiesto 2012
9.- Realizar un script llamado calcu, al cul haya que suministrarle
tres parmetros, los dos primeros sern nmeros y el tercer
parmetro la letra: s, r, m, d.
Segn la letra sea s, r, m, d, as sumar, restar, multiplicar o
dividir los dos nmeros.
if [ $3 = "s" ]
then
sum=`expr $1 + $2`
echo $1 + $2 = $sum
fi
if [ $3 = "r" ]
then
res=`expr $1 - $2`
echo $1 - $2 = $res
fi
if [ $3 = "m" ]
then
mul=`expr $1 \* $2`
echo $1 x $2 = $mul
fi
if [ $3 = "d" ]
then
div=`expr $1 / $2`
echo $1 / $2 = $div
fi
if [ $3 != "s" -o $3 != "r" -o $3 != "m" -o $3 != "d" ]
then
echo "La letra no existe"
fi
Lo ejecutaremos as:
./calcu 42 26 m
Realizacin de scripts en donde los valores se introducen mediante
variables (read a)

10.- Realizar un script llamado area, que

solicite el valor de la base de un tringulo,
luego solicite el valor de la altura,
y calcule el rea del tringulo.
echo "Cuanto vale la base"
read base
echo "Cuanto vale la altura"
read altura
area=`expr $base \* $altura / 2`
echo "El area de este triangulo vale $area"
11.- Realizar un script llamado fiche, que solicite la direccin
absoluta de un fichero
- SI el fichero existe
- ENTONCES lo presentar en pantalla (cat )
- SINO presentar la frase "El fichero no existe"
echo "Introduce la direccion absoluta de un archivo"
read ruta
if [ -f $ruta ]
then
cat $ruta
else
echo "El archivo no existe"
fi
12.- Realizar un script llamado calcula, que solicite un nmero,
luego otro nmero y luego una letra: s, r, m, d. Segn la letra elegida
as har una operacin con los nmeros introducidos.
echo "Introduce primer numero"
read a
echo "Introduce segundo numero"
read b
echo "suma ............. s"
echo "resta .............. r"
echo "multiplica ...... m"
echo "division ......... d"
echo"_____________"
echo "Introduce operacion"
read operacion
if [ $operacion = "s" ]
then
sum=`expr $a + $b`
echo $a + $b = $sum
fi
if [ $operacion = "r" ]
then

res=`expr $a - $b`
echo $a - $b = $res
fi
if [ $operacion = "m" ]
then
mul=`expr $a \* $b`
echo $a x $b = $mul
fi
if [ $operacion = "d" ]
then
div=`expr $a / $b`
echo $a / $b = $div
fi
13.- Realizar un script llamado dia, el cul solicite que introduzca un
dia de la semana: lunes, martes, miercoles, jueves, viernes, sabado,
domingo
Segn el da introducido saldr una frase.
echo "Introduzca un dia de la semana"
read dia
case $dia in
lunes) echo "El lunes es una lata" ;;
martes) echo "El martes es el segundo dia de la semana" ;;
miercoles) echo "Hoy es miercoles" ;;
jueves) echo "Siempre en medio" ;;
viernes) echo "Ya es finde" ;;
sabado) echo "A sali" ;;
domingo) echo "Domingo pingo" ;;
esac
14.- Realizar un script llamado figura; saldr un men y el usuario
eligir una letra segn la figura a la que quiera calcular el rea.
Segn la figura elegida solicitar los factores necesario y calcular
su rea.
echo "Area del cuadrado......c"
echo "Area del rectangulo.....r"
echo "Area del triangulo........t"
echo "Area del circulo..........s"
echo "------------------------"
echo "Introduzca una letra"
read letra
case $letra in
c) echo "Introduzca el lado del cuadrado"
read lado
ac=`expr $lado \* $lado`
echo El area del cuadrado es $ac ;;

r) echo "Introduzca la base del rectangulo"

read bas
echo "Introduzca la altura del rectangulo"
read alt
ar=`expr $bas \* $alt`
echo El area del rectangulo es $ar ;;
t) echo "Introduzca la base del triangulo"
read base
echo "Introduzca la altura del triangulo"
read altu
at=`expr $base \* $altu / 2`
echo El area del triangulo es $at ;;
s) echo "Introduzca el radio del circulo"
read radio
as=`expr $radio \* $radio \* 3`
echo El area del circulo es $as ;;
*) echo "LA OPCION ES ERRONEA"
esac
Nota: El rea del crculo es 3.1416 * r * r, pero debido a que la orden
expr no trabaja con decimales, se ha tomado a PI como el valor 3.
15.- Realizar un script llamado clave, el cual solicite continuamente
una clave.
Mientras la palabra introducida no sea "secreto", continuamente
pedir la clave. Cuando se introduzca la palabra "secreto" saldr
del bucle y dar la bienvenida.
a="0"
while [ $a != "secreto" ]
do
echo "Introduce la clave"
read a
done
echo BIENVENIDO
16.- Realizar un script llamado mayor, el cul solicitar
continuamente se introduzca un nmero. Cuando se introduzca la
letra f, terminar el script.
Cada vez que se introduzca un nmero el script mostrar el mayor y
el menor de los nmeros introducidos.
x=0
mayor=0
menor=999999
while [ $x != "f" ]

do
echo "Introduce un numero, f para salir"
read x
if [ $x -gt $mayor ]
then
mayor=$x
fi
echo El numero mayor es $mayor
if [ $x -lt $menor ]
then
menor=$x
fi
echo El numero menor es $menor
done
17.- Realizar un script llamado siguientes, el cul solicite un nmero
y nos responda mostrndonos los 6 siguientes
echo Introduce un numero
read a
tope=`expr $a + 6`
while [ $a -le $tope]
do
a=`expr $a + 1`
echo $a
done
18.- Realizar un script llamado tabla, que solicite un nmero.
Responder mostrando la tabla de multiplicar de ese nmero.

echo "Introduce un numero"

read numero
mul=1
while [ $mul -lt 10 ]
do
pro=`expr $numero \* $mul`
echo $numero x $mul = $pro
mul=`expr $mul + 1`
done
19.- El script anterior debe poder solicitar un nuevo clculo despus
de realizar la tabla de un nmero.
otro="s"
while [ $otro = "s" ]
do
echo "Introduce un numero"

read numero
mul=1
while [ $mul -lt 10 ]
do
pro=`expr $numero \* $mul`
echo $numero x $mul = $pro
mul=`expr $mul + 1`
done
echo "Quieres hacer otro calculo"
read otro
done
echo "ADIOS"
20.- Realizar un script llamado pitagora, el cul solicite la entrada
de un cateto, luego la entrada de otro cateto y luego calcule la
hipotenusa de un tringulo rectngulo.
El comando bc -l se utiliza para realizar operaciones matemticas +
- * / seno coseno tangente raizcuadrada (sqrt) exponente ^, se
pueden utilizar nmeros decimales.

resultado=$(echo "oooooperacionnnnn" | bc -l )
clear
echo "----------------------------"
echo "-- Teorema de Pitagoras --"
echo "----------------------------"
echo "Introduce el cateto a"
read a
echo "Introduce el cateto b"
read b
c=$(echo "sqrt($a^2 + $b^2)" |bc -l)
echo La hipotenusa vale $c
21.- Realizar un script llamado lamedia, el cul nos solicitar
continuamente que introduzcamos nmeros. Cuando introduzcamos
la letra f, saldremos de un bucle y calcular la media de los nmeros
introducidos.
num=0
c=-1
suma=0
while [ $num != f ]
do
echo "Introduce un numero, f para salir"
read num
suma=$(echo "$suma + $num" | bc -l)
c=$(echo "$c + 1" | bc -l)

done
med=$(echo "$suma / $c" | bc -l)
echo "La media vale $med"
22.- Realizar un script llamado facto, el cul solicite que se
introduzca un nmero. Calcular el factorial del nmero
introducido
c=0
f=1
echo "Introduce un numero"
read num
while [ $c != $num ]
do
c=$(echo "$c + 1" | bc -l)
f=$(echo "$f * $c" | bc -l)
done
echo "El factorial de $num es $f"
23.- Realizar un script llamado radian, el cul solicite que
introduzca grados. Se debern convertir a radianes.
rad = (g * 2 * 3.1416) / 360
echo "Introduce el angulo en grados"
read g
rad=$(echo "($g * 2 * 3.1416) / 360" | bc -l)
echo "En radianes vale $rad"
24.- Realizar un script llamado proyecta, el cul pedir un mdulo y
un ngulo, en grados, de un vector. Calcular la componente
horizontal y la componente vertical.
h = m * cos (alfa)
v = m * sen (alfa)
Nota: el ngulo debe ir en radianes. Coseno es c($rad) y el seno es
s($rad)
echo "Introduce el modulo"
read m
echo "Introduce el angulo en grados"
read g
rad=$(echo "($g * 2 * 3.1416) / 360" | bc -l)
h=$(echo "$m * c($rad)" | bc -l)
v=$(echo "$m * s($rad)" | bc -l)
echo "La componente horizontal vale $h"

echo "La componente vertical vale $v"

25.- Realizar un script llamado capital. Solicitar un capital, un
inters y unos aos. Calcular cuanto ha rendido el capital al cabo
de esos aos.
Total = C * ( 1 + i ) ^ a

[ ^ significa elevado a ]

Nota: el inters lo pedimos en nmero real, pero luego lo trabajamos

en tanto por ciento.
Es decir, cuando pida el inters escribimos 6, pero en la frmula se
debe expresar como 0.06, por eso lo dividimos entre 100.
echo "Que capital vas a invertir"
read c
echo "A que interes"
read i
echo "Por cuantos aos"
read a
i=$(echo "$i / 100" | bc -l)
t=$(echo "$c * ( 1 + $i )^$a" | bc -l)
echo "El total es $t"
26.- Realizar un script llamado euro, el cul presente un men en
donde podamos eligir pasar de pesetas a euros o de euros a pesetas.
Segn la opcin elegida convertir una moneda en otra.
otro="s"
while [ $otro = "s" ]
do
clear
echo "-----------------------------"
echo "-- De pesetas a euros....p --"
echo "-- De euros a pesetas....e --"
echo "-----------------------------"
echo "Introduce valor"
read v
echo "Introduce opcion (p/e)"
read o
case $o in
p) eu=$(echo "scale=2; $v / 166.386" | bc -l )
echo "$v pesetas son $eu euros" ;;
e) pe=$(echo "scale=2; $v * 166.386" | bc -l )
echo "$v euros son $pe pesetas" ;;
*) echo "Esa opcin no existe"
esac
echo "Quieres otro calculo (s/n)"

read otro
done
echo "ADIOS"
27.- Realizar un script llamado adivina. El ordenador generar un
nmero aleatorio del 0 al 99 que debemos de adivinar.
x=$((RANDOM%100))
mio=200
c=0
while [ $mio -ne $x ]
do
echo "Introduce un numero"
read mio
c=$(echo "$c + 1" | bc -l )
if [ $mio -gt $x ]
then
echo "El numero $mio es mayor que el del ordenador"
fi
if [ $mio -lt $x ]
then
echo "El numero $mio es menor que el del ordenador"
fi
done
echo "Has acertado de $c intentos"
28.- Realizar un script llamado quiniela, que presente los 14 signos
de una quinela.
Deber de sacar un nmero aleatorio del 1 al 6.
Si sale el 1 o el 2 o el 3, deber poner "1"
Si sale el 4 o el 5, deber poner "X"
Si sale el 6 deber poner "2"
c=0
while [ $c -le 14 ]
do
d=$((RANDOM%6 ))
d=`expr $d + 1`
if [ $d -eq 1 -o $d -eq 2 -o $d -eq 3 ]
then
echo "1"
if
if [ $d -eq 4 -o $d -eq 5 ]
then
echo "X"
fi
if [ $d -eq 6 ]
then
echo "2"

# Saca un nmero del 0 al 5

# Convierte el nmero del 1 al 6

fi
c=`expr $c + 1`
done
29.- Realizar un script llamado divisores que calcule los divisores de
un nmero.
#Divisores
echo Introduce un nmero
read a
n=$a
echo Los divisores de ese numero son:
while [ $n -ge 1 ]
do
d=$(echo " scale=0; $a%$n" | bc -l)
if [ $d -eq 0 ]
then
echo $n
fi
n=$(echo "$n-1" | bc -l)
done
30.- Realizar una script llamado paralelo, en donde se solicite
introducir el valor de dos resistencia. Se calcular el equivalente
paralelo de ellas.
# Solicitud de datos
echo "Introduce R1"
read r1
echo "Introduce R2"
read r2
# Calculos
numerador=$(echo "$r1 * $r2" | bc -l )
denominador=$(echo "$r1 + $r2" | bc -l )
total=$(echo "$numerador / $denominador" | bc -l )
# Presentacion del resultado
echo "La resistencia equivalente vale $total"
31.- Realizar un script llamado decibelios, en donde se solicite
introducir el valor de la tensin de entrada y salida de un
amplificador. Se calcular su ganancia en decibelios.
echo -n "Introduce tension de entrada .... "
read ve
echo -n "Introduce tension de salida ....... "
read vs
ganancia=$(echo "$vs / $ve" | bc -l )
decibelios=$(echo "(20 * l($ganancia)) / l(10)" | bc -l )

echo "La ganancia es de $decibelios decibelios"

Nota: La ganancia en decibelios es: 20 * log (ganancia)
Pero con la orden bc no tenemos la operacin log, as que debemos
hacer el log a partir del logaritmo neperiano (ln). Para pasar de
logaritmo neperiano a decimal utilizamos esta frmula:
log (x) = ln(x) / ln(10)
32.- Realizar en script llamado convierte, en donde se solicite que se
introduzca un nmero. Luego, una letra indicando en qu base est
el nmero introducido.
El script pasar ese nmero a otras bases.
ibase es la base inicial
obase es la base final
echo Introduce un numero
read x
echo "En decimal ........... d"
echo "En binario ............ b"
echo "En hexadecimal .... h"
echo "En que base esta el numero anterior"
read base
case $base in
d)
hexa=$(echo "obase=16; ibase=10; $x" | bc -l)
bin=$(echo "obase=2; ibase=10; $x" | bc -l)
echo El numero Decimal $x vale $hexa en Hexadecimal
echo El numero Decimal $x vale $bin en Binario ;;
b)
hexa=$(echo "obase=16; ibase=2; $x" | bc -l)
deci=$(echo "obase=10; ibase=2; $x" | bc -l)
echo El numero Binario $x vale $hexa en Hexadecimal
echo El numero Binario $x vale $deci en Decimal ;;
h)
x=`echo $x | tr [a-f] [A-F]`
deci=$(echo "obase=10; ibase=16; $x" | bc -l)
bin=$(echo "obase=2; ibase=16; $x" | bc -l)
echo El numero Hexadecimal $x vale $deci en Decimal
echo El numero Hexadecimal $x vale $bin en Binario ;;
esac
Nota: x=`echo $x | tr "a-f" "A-F"` convierte las letras del nmero
hexadecimal en maysculas, por ejemplo si introducimos: 4f2a se
convierte en 4F2A
33.- Realizar un script llamado codifica, que solicite la direccin
absoluta de un archivo, y convierta todas sus vocales minsculas a

maysculas.
echo Introduce la direccin absoluta de un archivo
read archi1
cat $archi1
cat $archi1 | tr "aeiou" "AEIOU" > archi2
cat archi2
Nota: Tambin se podra haber puesto
tr "aeiou" "AEIOU" < $archi1 > archi2
34.- Realizar un script llamado ecuacion, en donde se solicite los
parmetros a, b y c de una ecuacin de 2 grado. El script calcular
las dos raices de la ecuacin.
ax2 + bx + c = 0

echo Introduce el parametro a

read a
echo Introduce el parametro b
read b
echo Introduce el parametro c
read c
ra=$(echo "$b^2 - 4 * $a * $c" | bc -l)
if [ $ra -lt 0 ]
then
echo EL RADICANDO ES NEGATIVO
else
x1=$(echo "((-1) * $b + sqrt($ra)) / (2 * $a)" | bc -l)
x1=$(echo "((-1) * $b - sqrt($ra)) / (2 * $a)" | bc -l)
echo x1 = $x1
echo x2 = $x2
fi
35.- Realiza un script llamado comprime, el cul solicite que escriba
la direccin absoluta de un archivo.
SI el archivo existe
ENTONCES
SI la carpeta "comprimidos" existe
ENTONCES guarda el archivo comprimido en esa carpeta
SINO crea la carpeta "comprimidos" y guarda el archivo
SINO sale un aviso de que ese archivo no existe
Nota: al comprimirlo no se debe eliminar el archivo original.
echo Introduce la direccin absoluta de un archivo

read archi
if [ -f $archi ]
then
if [ -d /home/utele/comprimidos ]
then
gzip -c $archi > /home/utele/comprimidos/abc.gz
else
mkdir /home/utele/comprimidos
gzip -c $archi > /home/utele/comprimidos/abc.gz
fi
else
echo EL ARCHIVO $archi NO EXISTE.
fi
36.- Realizar un script llamado nombre, el cual solicite el nombre de
un archivo que est en el mismo directorio que el script, luego
solicite una palabra y copie el archivo indicado con el nombre que
tenia adems de la nueva palabra.
echo Introduce un archivo que este en el mismo directorio que el script
read archi
echo Introduce una palabra
read pala
cp $archi $arci$pala
37.- Realizar un script llamado ordena, que reciba una serie de
palabras y las muestres en pantalla ordenadas alfabticamente.
Utilizar un archivo auxiliar.
palabra="o"
> archi
while [ $palabra != "f" ]
do
echo "Introduce una palabra, f para salir"
read palabra
clear
echo $palabra >> archi
sort archi
done
38.- Realiza un script llamado multi, en donde tengamos que
introducir como parmetro un nmero del 1 al 9. Luego nos pida
que introduzcamos un nmero y luego otro mayor. Nos presentar
la tabla de multiplicar del parmetro introducido, entre los dos
nmeros lmites.
Ejemplo: ./multi 4
Introduce lmite inferior: 6
Introduce lmite superior: 11
4 x 6 = 24

4 x 7 = 28
4 x 8 = 32
4 x 9 = 36
4 x 10 = 40
4 x 11 = 44
echo Introduce limite inferior
read i
echo Introduce limite superior
read s
while [ $i -le $s]
do
m=`expr $1 \* $i`
echo $1 x $i = $m
i=`expr $i + 1`
done
39.- Juego de dados. Se tiran dos dados, si la suma de ambos es 7,
GANAS, si es distinto de 7 PIERDES.
otro="s"
while [ $otro == "s" ]
do
x=$((RANDOM%6))
y=$((RANDOM%6))
x=`expr $x + 1`
1a6
y=`expr $y +1`
1a6
echo Dado1: $x
echo Dado2: $y

# Saca un nmero de 0 al 5
# Saca un nmero de 0 al 5
# Le suma 1 para convertirlo de
# Le suma 1 para convertirlo de

suma=`expr $x + $y`
if [ $suma -eq 7 ]
then
echo LA SUMA ES 7
else
echo NO ES 7
fi
echo Quieres otra tirada s,n
read otro
done
40.- Realizar un script que genere 3 nmero aleatorios del 1 al 3 (
1,2,3).
Si los tres nmeros generados son iguales: GANAS

Si no son iguales: PIERDES

otro="s"
while [ $otro == "s" ]
do
x=$((RANDOM%3))
y=$((RANDOM%3))
z=$((RANDOM%3))
x=`expr $x + 1`
y=`expr $y + 1`
z=`expr $z + 1`
echo $x " " $y " " $z
if [ $x -eq $y -a $y -eq $z ]
then
echo Los tres numeros son iguales
else
echo Los numeros no son iguales
fi
echo Quieres otra tirada s,n
read otro
done

Scripts BASH ejercicios

Ejercicios de Scripts

A tener en cuenta:

LESS (nombre fichero):

Nos muestra el contenido de un fichero en su totalidad
MORE (nombre fichero):
Nos muestra el contenido del fichero paginndolo
Para salir de estos comandos WQ
Less (fichero) | head n 5 nos muestra las primeras 5 lineas
Less (fichero)| tail n 5 nos muestra las ultimas 5 lineas
Less (fichero) |grep (palabra) muestra las lneas donde se encuentra esta palabra

Para utilizar nmero utilizamos:

-eq
-me
-lt

=
=
<

-gt

>

-le

<=

-ge

>=

Para utilizar ficheros:

-a

Si existe

-d
-f

Existe es un
directorio
Existe es un fichero

-r

Es de lectura

-w

Es de escritura

-x

Es ejecutable

Para dar permiso de ejecucin utilizamos el comando CHMOD

Ejemplo
Chmod u +x expresin-logica.sh
U= permiso a usuario
+= agregar
X= ejecutable
As podemos ejecutar el fichero sin utilizar el bash inicial.

CASE se suele utilizar para menus cuando hay varias opciones.

Sintaxis:
Case $variable in
Valor1)
Se ejecuta si variable tiene valor 1
;;
Valor2)
Se ejecuta si variable tiene valor 2
;;
*)Se ejecuta su variable no tiene ninguno de los valores anteriores
ESAC

Expresiones lgicas
If [Expresion]; Then
Realiza expresin si es verdadera
FI Cierra la estructura
If [Expresion]; Then
Realiza expresin si es verdadera
Else
Realiza expresin si es falsa
FI
-n utilizamos para variables si no es nula
-z Utilizamos para variables nulo, vacia o no definida
Cuando hay ms de dos opciones utilizamos ELIF
If [Expresion]; Then
Realiza expresin si es verdadera
elif [Expresion]; Then
Realiza expresin si es verdadera
elif [Expresion]; Then
Realiza expresin si es verdadera
Else
Realiza expresin si es falsa
FI

------------------------------------------------------#!/bin/bash
#primer programa
Echo Hola mundo
Guardamos con extensin .SH

- primer-programa.sh

Nos vamos al terminal y ejecutamos

bash primer-programa.sh
-----------------------------------------------------------#!/bin/bash
#Movimiento de fichero de una ruta a otra
Mv /home/asir/ASO/TEMA1/ejercicios/tema1 /home/asir/SRI/TEMA1/DHCP/ejercicios
Echo Contenido de la carpeta ASO/TEMA1/ejercicios/
Ls /home/asir/ASO/TEMA1/ejercicios/tema1
Echo Contenido de la carpeta destino /SRI/TEMA1/DHCP/ejercicios
Ls /home/asir/SRI/TEMA1/DHCP/ejercicios
Guardamos como movimiento-fichero.sh
Ejecutamos.
------------------------------------------------------------

#!bin/bash
#Muestra nombre y apellidos por parmetros
Echo Hola $1, tienes $2 aos
Guardamos como parmetros.sh
Desde terminal ejecutamos
Bash parmetros.sh Jhon 35
------------------------------------------------------------Fichero que solicita nombre y edad por pantalla
#!bin/bash
#Muestra nombre y apellidos por parmetros
Echo Introduzca su nombre
Read nombre
Echo introduzca su edad
Read edad
Echo Hola eres $nombre y tienes $edad aos
Guardamos como introduce-parametros.sh
Desde terminal ejecutamos
Bash inbtroduce-parmetros.sh Jhon 35
Aqu el introduzca su nombre hace un salto de lnea para introducir el nombre, si queremos que se haga
en la misma lnea ponemos -n
Echo n: Nos deja poner el nombre y la edad en la misma linea
------------------------------------------------------------#!bin/bash
#Muestra nombre y apellidos por parmetros
Echo -n Introduzca su nombre:
Read nombre
Echo -n introduzca su edad:
Read edad
Echo Hola eres $nombre y tienes $edad aos
READ P: nos muestra todo con una sola lnea de comando eliminamos el echo
------------------------------------------------------------#!bin/bash
#Muestra nombre y apellidos por variable
read p Introduzca su nombre: nombre
read -p introduzca su edad: edad
Echo Hola eres $nombre y tienes $edad aos
Introducimos nombre y ao de nacimiento, que muestre el nombre y la edad.
------------------------------------------------------------#!bin/bash
#Muestra nombre y apellidos por parmetros
Actual=2011
Echo Te llamas $1 y tienes $(expr $actual - $2) aos.

Ejecutamos parametros1.sh jhon 1976

------------------------------------------------------------#!bin/bash
#Pasando por parmetro, especificamos fichero y donde moverlo
Echo Movemos el fichero $1 a la carpeta $2
Mv $1 $2
Echo nos muestra el contenido del fichero
Ls $2
--------------------------------------------------------------#!/bind/bash
#programa que compara el nombre y nos da mensaje si somo o no
Name=jhon
Echo n introduce tu nombre:
Read nombre
If [ $nombre = $name ]; then
Echo Hola, eres $nombre
Else
Echo Hola, Tu no eres $name
fi
guardamos como parmetros.sh
Ejecutamos bash parmetros.sh
---------------------------------------------------------------Creamos script con parmetros
#!/bind/bash
#programa que compara el nombre y nos da mensaje si somo o no
Name=jhon
If [ $1 = $name ]; then
Echo Hola, eres $1 buenos dias
Else
Echo Hola, Tu no eres $name
fi
guardamos como parmetros1.sh
Ejecutamos bash parmetros1.sh jhon
----------------------------------------------------------------#!/bind/bash
#programa que compara el ao de nacimiento
Anho=1976
Read p introduce tu nao de nacimiento: anio
If [ $anio -eq $anho ]; then
Echo Hola, naciste $anho
Else
Echo Hola, Tu no naciste $anho
fi

Guardamos como parmetros2.sh

Ejecutamos bash parmetros2.sh
---------------------------------------------------------#!/bind/bash
#pasados 2 valores por parametro, indique cual de lo dos es mayor o si son iguales
read -p "introduce un valor: " num1
read -p "Introduce valor a comparar: " num2
if [ $num1 -lt $num2 ]; then
echo $num2 " Es mayor que " $num1
elif [ $num1 -eq $num2 ]; then
echo $num1 " Es igual a " $num2
else
echo $num2 " Es menor que " $num1
fi
-------------------------------------------------------#!/bind/bash
#Mirar si el directorio pasado por parametro ya existe si es si, que muestre un mensaje. Si es no lo debe
crear y decir que lo ha creado
read -p "introduce un directorio: " dir1
if [ -a $dir1 ]; then
echo " El directorio existe "
ls
else
echo "El directorio no existe"
mkdir $dir1
echo "Se ha creado el directorio " $dir1
ls
fi
----------------------------------------------------#!/bind/bash
#Nos pide la edad y nos dice si es mayor de edad o menor
read -p "introduce tu edad: " edad
if [ $edad -lt 18 ]; then
echo " Eres menor de edad "
elif [ $edad -gt 18 ]; then
echo "Eres mayor de edad"
else
echo "Eres mayor de edad"
fi
----------------------------------------------------------#!/bind/bash

#Script que mire si el fichero por parametro, existe. si existe mostrar mensaje con el nombre del fichero. Si
no existe crearlo y decir que lo ha creado con el nombre quese ha puesto.
if [ -a $1 ]; then
echo "El fichero existe se llama "$1
else
touch $1
echo "Se ha creado el fichero con el nombre "$1
fi
---------------------------------------------------------#!/bind/bash
#Script que mire si el fichero pedido, existe. si existe mostrar mensaje con el nombre del fichero. Si no
existe crearlo y decir que lo ha creado con el nombre quese ha puesto.
read -p "Introduzca ruta del fichero: " f1
if [ -a $f1 ]; then
echo "El fichero existe se llama "$f1
else
touch $f1
echo "Se ha creado el fichero con el nombre "$f1
fi
---------------------------------------------------------#!/bind/bash
#Script que reciba un nombre de fichero, verifique que existe y que es un fichero comun (lectura-escritura)
lo convierta en ejecutable para el usuario y el grupo y muestre el estado final de los permisos.
if [ -f $1 ]; then
echo "El parametro introducido es un fichero"
ls -l $1
if [ -r $1 ];then
echo " Tiene permisos de Lectura"
if [ -w $1 ];then
echo "Tiene permisos de escritura "
chmod ug+x $1
ls -l $1
else
echo "No es un fichero comun"
fi
else
echo "No es un fichero comun"
fi
else
echo "El fichero no existe "
fi
------------------------------------------------------------

#!/bind/bash
#Script que reciba un nombre de fichero, verifique que existe y que es un fichero comun (lectura-escritura)
lo convierta en ejecutable para el usuario y el grupo y muestre el estado final de los permisos.
if [ -f $1 ]; then
echo "El parametro introducido es un fichero"
more $1
elif [ -d $1 ]; then
cd $1
ls
else
echo " ERROR!!! no es fichero ni directorio "
fi
-----------------------------------------------------------#/!bin/bash
#Script que nos muestra un menu para elegir una opcion, y nos da un mensaje despues de la eleccion.

echo "1. Opcion uno"

echo "2. Opcion dos"

read -p "introduzca opcion:" op

case $op in
1)
echo "Ha pulsado opcion 1"
;;
2)
echo "Ha pulsado opcion 2"
;;
*)
echo "La opcion es incorrecta"
;;
esac
--------------------------------------------------------#/!bin/bash
#Script que nos muestra un menu para elegir la operacion a realizar

echo ""
echo "Realiza una operacion matematica segun las opciones"
echo ""
echo "a.Suma"
echo "b.Resta"
echo "c.Multiplicacin"
echo "d.Division entera"
echo "e.Resto"
echo "f.Es un numero par?"

read -p "Seleccione la operacion a realizar y pulse intro: " op

read -p "introduzca operando 1:" num1
if [ $op != f ]; then
read -p "introduzca operando 2:" num2
fi

case $op in
a)
suma=`expr $num1 + $num2`
echo "Ha pulsado opcion a, el resultado de la suma es "$suma
;;

b)
resta=`expr $num1 - $num2`
echo "Ha pulsado opcion b, el resultado de la resta es "$resta
;;

c)
multiplicacion=`expr $num1 \* $num2`
echo "Ha pulsado opcion c, el resultado de la multiplicacion es "$multiplicacion
;;

d)
division=`expr $num1 / $num2`
echo "Ha pulsado opcion d, el resultado de la division es "$division
;;

e)
resto=`expr $num1 % $num2`
echo "Ha pulsado opcion e, el resto es "$resto
;;

f)
res=`expr $num1 % 2`
if [ $res -eq 0 ]; then
echo " el numero introducido es " $num1 " es par"
else
echo " el numero introducido es " $num1 " No es par"
fi
;;
esac
--------------------------------------------------#/!bin/bash
#Script que nos diga al pulsar una tecla, si es letra, numero o caracter especial

read -n 1 tecla
case $tecla in
[a-z,A-Z]) echo "ha introducido una letra"
;;
[0-9]) echo "Ha introducido un numero"
;;
*) echo "Ha introducido un caracter especial"
;;
esac
-----------------------------------------------------#!/bin/bash
#realizar un scrip que reciba varios parametros y nos diga cuantos de esos parametros son de directorios
y cuantos son archivos. $# contador que indica cuantos parametros se pasan.
cont=0
contf=0
for var in $*; do
if [ -d $var ]; then
cont=`expr $cont + 1`
elif [ -f $var ]; then
contf=`expr $contf + 1`
else
echo "$var no es fichero ni directorio"
fi
done
echo "Ha introducido $cont directorios y $contf ficheros."
echo "Se han introducido $# parametros"
---------------------# Mostramos menu, con productos para vender, luego nos pide que introduzcamos la opcion. luego
mensaje que indica que introduzca moneda. Si ponemos precio exacto nos da mensaje, "Gracias buen
provecho", si ponemos menos, nos diga falta.
Si poner mas valor, nos indique el cambio con mensaje.
echo """"
echo "Bienvenido a la tienda On-line - CEPAL"
echo ""
echo "1. Refresco 1 euro"
echo "2. Sandiwch 3 euros"
echo "3. Tabaco 5 euros"
echo ""
read -p "Introduzca opcion:" op
read -p " Introduzca importe: " mon
case $op in
1)
precio=1
;;
2)
precio=3
;;
3)
precio=5
;;
*)

echo "Opcion incorrecta"

esac
while [ $mon -lt $precio ]; do
falta=`expr $precio - $mon`
read -p " Introduzca $falta euros, por favor introduzcalos" mas
mon=`expr $mon + $mas`
done
if [ $mon -gt $precio ]; then
cambio=`expr $mon - $precio`
echo "Gracias por su compra, su cambio es de $cambio euros"
else
echo "Gracias por su compra. Buen provecho"
fi
--------------#!/bin/bash
#Realizar un script que pida introducir la ruta de un directorio por teclado (Hay que validar que la variable
introducida sea un directorio) nos diga cuantos archivos y cuantos directorios hay dentro de ese directorio.

read -p "Introduzca la ruta de un directorio :" dir

until [ -d $dir ]; do
read -p "Introduzca la ruta de un directorio :" dir
done
cont=0
contf=0
for var in `ls $dir`; do
if [ -d $var ]; then
cont=`expr $cont + 1`
elif [ -f $var ]; then
contf=`expr $contf + 1`
fi
done
echo "Ha introducido $cont directorios y $contf ficheros."
echo "Se han introducido $# parametros"

-------------------------------------

#/!bin/bash
#Realiza un script que introduzca numero por parametro y muestre tabla de multiplicar
echo " la tabla de multiplicar de $1 es: "
numerador=1
while [ $numerador -lt 11 ]; do
resul=`expr $1 \* $numerador`
echo "$1 x $numerador = $resul"
numerador=`expr $numerador + 1`
done

------------------

#!/bind/bash
#apertura carpeta contenido ASIR
ls /home/asir

-----------------------#/!bin/bash
#Realiza un script que muestre por pantalla los numeros del 1 al 20
num=1
while [ $num -lt 21 ]; do
echo "$num"
num=`expr $num + 1`
done
---------------------------