● Docente: Carmine Fernando

● Correo: fcarmine@udc.edu.ar
● Duración: Cuatrimestral
● Ciclo Lectivo: 2021
● 2° Cuatrimestre
 Contenidos de la unidad

Unidad 1. Repaso de comandos. Scripting en GNU/Linux.

Administración de usuarios y grupos. Comandos: useradd, usermod,

userdel, groupadd, groupmod, groupdel. Administración de permisos de
usuario.
Comandos: chmod, chown, chgrp. Manipulación de archivos.

Comandos: mv, cp, rm, file, du, less, more, grep, cat, tail, head, cut,
diff, grep. Empaquetado y desempaquetado de archivos. Comando: tar.

Compresión y descompresión de archivos. Comandos, gzip, gunzip, rar,

unrar, zip, unzip, gzip2, tar. Administración de filesystem.

Comandos: fdisk, mkfs, fsck, mount, umount. Pipelines de comandos.

Lenguajes compilados y lenguajes interpretados. Conceptos y bondades

del Scripting. Intérpretes de comandos. Scripting en bash: variables,
estructuras condicionales y repetitivas, funciones, librerías. Scripts
como herramienta para el administrador.
 Administración de usuarios y grupos

GNU/Linux es un sistema:

● Multiusuario: varias personas pueden trabajar con el sistema, que

proporciona mecanismos de protección de datos de cada usuario.

● Multitarea: varios procesos (de varios usuarios) pueden ejecutarse a

la vez

● De tiempo compartido: los procesos se ejecutan todos todo el tiempo

– Cuenta de usuario: datos e información de cada usuario.

Cada usuario posee un nombre de usuario y una clave para acceder
al sistema.

– Grupo de usuarios: cada usuario puede pertenecer a uno o varios

grupos

– Permisos: sistema de protección de datos de un usuario respecto

de otros.
 Administración de usuarios y grupos

Características de las cuentas de Usuario:

– Nombre de usuario (“username”)

Identifica al usuario dentro del sistema (cada usuario lleva
asociado un número de identificación)

– Clave (password)
para acceder al sistema

– Grupo principal del usuario

En Ubuntu “por defecto” se crea un grupo de mismo nombre que el
“username”

– Carpeta personal
Donde el usuario guarda sus propias carpetas y archivos (por
defecto en /home/username)

– Otros grupos a los que pertenezca el usuario

 Administración de usuarios y grupos

Configuración del sistema → Cuentas de usuario

– Configuración del usuario propio

– Configuración básica de otros usuarios (administrador)
– Añadir/eliminar usuarios
 Administración de usuarios y grupos en
interfaz de comandos

● Añadir usuarios:
– # adduser <username>

● Asignar un usuario a un grupo

– # adduser <username> <groupname>

● Borrar usuarios:
– # userdel <username>

● Añadir grupos:
– # addgroup <groupname>

● Borrar grupos:
– # groupdel <groupname>
 Administración de usuarios y grupos en
interfaz de comandos

Modificando propiedades de los usuarios y grupos

(usermod, groupmod). Ejemplos:

# usermod -d /home/profes/pepe -m
cambia la carpeta del usuario pepe a /home/profes/pepe.
-m hace que se mueva todo el contenido.

# usermod -l joseg pepe:

cambia nombre de usuario pepe por joseg.

# usermod -g profes pepe

cambia grupo principal del usuario pepe a profes.

# groupmod -n profesores profes

cambia el nombre del grupo profesores a profes
 Cambios de propietario/grupo

● Desde el administrador de archivos

– Menú contextual -> Propiedades -> Permisos

● Cambiar propietarios de archivos/carpetas

– chown [-R] <usuario> <ruta>
– chown [-R] <usuario>:<grupo> <ruta>

● Cambiar grupo de un archivo/carpeta

– chgrp [-R] <grupo> <ruta>
 Gestión de usuarios y grupos.
Archivos de configuración

● Opciones por defecto al crear usuarios:

– /etc/adduser.conf

● Contenido inicial de las nuevas cuentas de usuarios:

– /etc/skel

● Ficheros con información sobre usuarios y grupos.

Normalmente no se editan “a mano”
– /etc/passwd: Usuarios, ID, grupo principal, carpeta inicio,
shell, etc.

– /etc/shadow: contiene los passwords encriptados de los

usuarios.

– /etc/group: Grupos, miembros de cada grupo.

– Se usa “vipw” y “vigr” para editarlos con seguridad

 Usuarios y grupos especiales

● Usuarios y/o grupos empleados por el sistema para realizar tareas

concretas con privilegios restringidos
– cupsys: administrador de impresoras
– mail: gestor de correo
– www-data: servidor web
– ...

● Grupos para el control de privilegios

– cdrom: control de las unidades de cd o dvd
– floppy: control de las unidades de diskette
– audio: control de los dispositivos de audio
– admin: dota de permisos de administrador del sistema a sus
miembros (a través de sudo)
 Usuarios y grupos especiales.
Superusuario

● Superusuario = administrador = root

● Superusuario -> privilegios ilimitados

● Los sistemas GNU/Linux se configuran para realizar el mínimo de

tareas empleando el superusuario

● Convertirse en otro usuario

– $ su [-] <nuevo_usuario>

● Ejecutar un comando como superusuario (sólo usuarios grupo “sudo”)

– $ sudo ...

● Convertirse en root permanentemente

– $ sudo -s
– $ sudo su
 Permisos

● Cada archivo/carpeta tiene un propietario y está asignado a un

grupo (al que normalmente pertenece el propietario)

● Cada archivo/carpeta posee tres conjuntos de permisos que

controlan el acceso de:

– El propietario (user)
– Miembros del grupo al que pertenece el archivo (group)
– Otros usuarios (other)
Permisos
 Permisos

El primer bit indica el tipo de archivo. Generalmente pueden darse los

siguientes casos:

- | Se trata de un archivo regular

d | Se trata de un directorio
l | Se trata de un enlace simbólico
b | Se trata de un archivo especial de bloques

El resto de los 9 bits que vienen a continuación representan los permisos

del propietario del fichero o directorio, los del grupo al que pertenece
este usuario, y los del resto de usuarios. Aquí tienes el significado:

r | Se dan permisos de lectura

w | Se dan permisos de escritura
x | Se dan permisos de ejecución
- | No se da el permiso de lectura, escritura o ejecución
Permisos
 Permisos

Notación simbólica o nemónica de permisos

Sintaxis:

chmod [ugoa] [-+=] [rwx]

Ejemplos:

chmod u+x archivo.txt

chmod u-w archivo.txt
chmod a+x archivo.txt
chmod g-rw archivo.txt
 Permisos

Cambiar de propietario:
sudo chown <usuario> (archivo o carpeta)
sudo chown <usuario> -R <carpeta> (carpeta y todo su contenido)

Si queremos cambiar de Grupo:

sudo chgrp <grupo> <carpeta> (archivo o carpeta)
sudo chgrp <grupo> -R <carpeta> (carpeta y todo su contenido)

Si queremos cambiar de Usuario y Grupo a la vez emplearemos:

sudo chown usuario:grupo <carpeta> (archivo o carpeta)
sudo chown usuario:grupo -R <carpeta> (carpeta y todo su contenido)

Si deseamos cambiar los Privilegios de algún directorio o carpeta

tenemos:
sudo chmod <permisos> <opciones> <archivo o carpeta>
sudo chmod +x foo.sh (dar permisos de ejecución)
Permisos
Empaquetado de archivos
 Programación - Repaso

Lenguaje de Programación C

● Acceso a memoria de bajo nivel (punteros)

● Interrupciones al procesador
● Conjunto reducido de palabras clave
● Paso de parámetros por valor
● Paso por referencia, pasando direcciones de memoria
● Punteros a funciones y variables estáticas
● Tipos de datos primitivos
● Tipos de datos agregados (struct)
 Programación - Repaso

Características de C

● Núcleo del lenguaje simple, con funciones añadidas mediante

bibliotecas
● Funciones matemáticas
● Funciones de manejo de archivos
● Funciones de manejo de cadenas
● Lenguaje flexible. Permite programar con múltiples estilos
● Sistema de tipos que impide operaciones sin sentido
● Lenguaje preprocesado
 Programación - Repaso

/* Programa en Lenguaje C. Imprime un texto en pantalla

*/
#include <stdio.h>
#include <stdlib.h>

int main() {

printf(“Hola mundo!!\n”);
system("pause");
return 0;
}
 Compilación vs. Interpretación

Lenguajes compilados

● Su código fuente necesita ser compilado.

● El proceso de compilación crea un archivo binario traducido a
código máquina.
● Este archivo binario será el ejecutable (programa).

Lenguajes interpretados

● Su código no necesita ser preprocesado mediante un compilador.

● Un programa (intérprete) traduce cada instrucción a código
máquina.
● El intérprete lee una instrucción y la traduce. Así hace con
cada una.
● El archivo de código fuente y el ejecutable son el mismo.
 Compilados vs. interpretados:
características

Compilados

● Son más rápidos pues están totalmente traducidos a código máquina.

● Los errores sintácticos se detectan en tiempo de compilación.
● Para ejecutarlo solo es necesario contar con el binario o ejecutable.
● Para compilarlos es necesario contar con un programa compilador.
● Deben ser compilados para cada plataforma.

Interpretados

● No ocultan el código fuente. Siempre debe ser accesible.

● Necesitan del programa intérprete en la máquina en la que se van a
ejecutar.
● Suelen ser más lentos que los compilados.
Algunos lenguajes interpretados
 ¿Qué es Shell?

● Es el intérprete de comandos o intérprete de órdenes

● Es la interfaz entre el usuario y el sistema operativo.
● Shell significa "caparazón"
● Actúa como intermediario entre el sistema operativo y el
usuario
● Interpreta comandos, los transmite al sistema y arroja
resultados
● Existen varios tipos de shells en Linux
● Nosotros usaremos bash
 Algunos shells en Linux

Las diferentes distribuciones de Linux incorporan variedad de

terminales. Lo
tipos principales son los siguientes:

● Shell Bourne (sh)

● C-Shell (csh)
● Shell job (jsh)
● Shell Korn (ksh)
● Bourne Again Shell (bash)
 Hola mundo en bash

# Programa en Lenguaje bash. Imprime un texto en pantalla

#!/bin/bash

echo Hola Mundo!

$ chmod +x script.sh
 Bash scripting

Es la técnica de uso y escritura de scripts. Nos centraremos en

scripts
bash:

● Variables
● Estructuras selectivas
● Estructuras repetitivas
● Funciones
● Librerías
 Bash: Uso de variables

Definiendo una variable:

#!/bin/bash

MENSAJE=" \”Hola Mundo...\” "

echo $MENSAJE

Usando variables de entorno:

#!/bin/bash
echo “Soy el usuario $USER”

Asignado resultados de comandos a variables:

#!/bin/bash
MIS_ATRIBUTOS=`/bin/ls -l $0`
echo "Los atributos del script son: $MIS_ATRIBUTOS”
 Bash: Uso de variables

Las variables son NO TIPADAS: es un lenguaje débilmente tipado:

VARIABLE_1=Hola
Variable_1=”Hola mundo”
N=127 N=$Variable1

Las variables son globales por defecto. Para declarar variables locales
se antepone la palabra reservada local:

local NOMBRE="Jose"
echo "Hola señor $NOMBRE.
 Asignado Resultados De Comandos A
Variables

#!/bin/bash

ATRIBUTOS_SCRIPT=`/bin/ls -l $0`

echo "El usuario '$USERNAME' ha ejecutado el script $0, en el ordenador

'$HOSTNAME'. "

echo "Los atributos del script son: "

echo $ATRIBUTOS_SCRIPT
 Variables Numéricas

#!/bin/bash

let A=100
let B=200
let C=$A+$B

echo "A: $A | B: $B | C: $C"

 Usando Caracteres Especiales En
Variables

#!/bin/bash

MENSAJE="\"Hola Mundo ...\""

echo "El valor de la variable \$MENSAJE es $MENSAJE"

tendremos que usar el simbolo '\' delante de las variables

 Parámetros de un script

Un Script puede recibir argumentos por línea de

comando

Estos argumentos son llamados “parámetros”

Veamos dos categorías de ellos:

Parámetros posicionales
Parámetros especiales.
 Parámetros posicionales

Podemos pasarle a un script parámetros cuando es invocado:

Parámetro Contenido
---------------------------------------------------------------------------
$0
Nombre del script tal como es invocado
$1
Primer parámetro
$2
Segundo parámetro
$3
Tercer parámetro
$4
Cuarto parámetro
$5
Quinto parámetro
...
$9
Noveno parámetro
${10}
Décimo parámetro
 Parámetros posicionales: ejemplos

#!/bin/bash
# muestra algunos de los parámetros recibidos
echo "El 1er parámetro es: $1"
echo "El 3er parámetro es: $3"
echo "El 9no parámetro es: $9"
Invocación:
./muestra_param.sh 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
El 1er parámetro es: 1
El 3er parámetro es: 3
El 9no parámetro es: 9
 Parámetros especiales

Parámetro Uso
------------------------------------------------------------
$0 Contiene el nombre del script tal como es invocado
$* El conjunto de todos los parámetros en un solo argumento
$@ El conjunto de argumentos, un argumento por parámetro
$# El número de parámetros pasados al script
$? El código de retorno del último comando
$$ El PID del shell que ejecuta el script
$! El PID del último proceso ejecutado en segundo plano
 Parámetros especiales: Ejemplos
#!/bin/bash
#params.sh
#muestra el nombre del script
#y la cantidad de parámetros
echo "El nombre del script es: $0"
echo "He recibido $# parámetros"
Invocado:
./params.sh 1 2 3 cuatro 5 seis
El nombre de mi script es: ./params.sh
He recibido 6 parámetros
./params.sh hola mundo
El nombre de mi script es: ./params.sh
He recibido 2 parámetros
./params.sh “hola mundo”
El nombre de mi script es: ./params.sh
He recibido 1 parámetros
 Parámetros especiales: Ejemplos

#!/bin/bash Invocado:
#mi_ping.sh
#utilizo parámetro especial $? ./mi_ping.sh localhost
IP=$1 Ok, host activo
ping $IP
if [ $? -eq 0 ];then
echo “OK, host activo” ./mi_ping.sh 192.168.0.1
else Alerta, host no responde
echo “Alerta, host no responde”
fi
 Parámetros especiales: Ejemplos

Comillas simples ' Comillas dobles “

#!/bin/bash #!/bin/bash
#Lo que contiene literalmente #Sustituye lo que contiene
MENSAJE= ‘Hola $USER’ MENSAJE= “Hola $USER”
echo $MENSAJE echo $MENSAJE

Comillas invertidas `

#!/bin/bash
#Devuelve la salida del comando entre las comillas invertidas
USUARIOS=`who | wc -l`

echo $USUARIOS
 Funciones

Sirve para organizar un script en unidades lógicas de manera que sea más
fácil mantenerlo y programarlo.

En Bash las funciones se pueden definir de la siguiente manera:

function nombre_de_funcion(){
comandos_del_shell
}
 Funciones

Un ejemplo de función en un script:

#!/bin/bash

let A=100
let B=200

# Suma los variables A y B

function suma(){
let C=$A+$B
echo "Suma: $C"
}

# Resta los variables A y B

function resta(){
let C=$A-$B
echo "Resta: $C"
}

suma
resta
 Comparación de cadenas

Operador Verdad (TRUE) si:

-----------------------------------------------------------------------
cadena1 = cadena2 cadena1 es igual a cadena2
cadena1 != cadena2 cadena1 no es igual a cadena2
cadena1 < cadena2 cadena1 es menor que cadena2
cadena1 <= cadena2 cadena1 es menor o igual que cadena2
cadena1 > cadena 2 cadena1 es mayor que cadena 2
cadena1 >= cadena 2 cadena1 es mayor o igual que cadena 2
-n cadena1 cadena1 no tiene valor nulo (longitud > 0)
-z cadena1 cadena1 tiene un valor nulo (longitud = 0)
 Comparación de valores numéricos

Operador Verdad (TRUE) si:

------------------------------------------------------------------------------------------------------------------
x -eq y x equal than y x igual que y
x -ne y x not equal than y x no igual que y
x -lt y x less than y x menor que y
x -le y x less or equal than y x menor o igual que y
x -gt y x grather than y x mayor que y
x -ge y x grather or equal than y x no igual que y
 Parámetros especiales: Ejemplos

Operador Verdad (TRUE) si:

--------------------------------------------------------------------------------------------------------------------------------------
-d archivo archivo existe y es un directorio
-e archivo archivo existe
-f archivo archivo existe y es un archivo regular (no es especial)
-r archivo hay permiso de lectura en archivo
-s archivo archivo existe y no está vacío
-w archivo hay permiso de escritura en archivo
-x archivo hay permiso de ejecución en archivo (o de búsqueda si es d)
-O archivo quien ejecuta es dueño del archivo
-G archivo el grupo del archivo es igual al grupo de quien ejecuta
archivo1 -nt archivo2 archivo1 es más reciente que archivo2
archivo1 -ot archivo2 archivo1 es más antiguo que archivo2
 Comparaciones lógicas

Operador Ejemplo de Uso

---------------------------------------------------------------------------------------------------------------------------------
&& and lógico if [[ $1 = $2 && $# = 2 ]]; then
|| or lógico if [[ $# = 1 || $# = 2 ]]; then

OTRA OPCIÓN PARA EXPRESAR LO MISMO

---------------------------------------------------------------------------------------------------------------------------------
-a and lógico if [ $1 -eq $2 -a $# -eq 2 ]; then
-o or lógico if [ $# -eq 1 -o $# -eq 2 ]; then
 Comentarios en bash

Símbolo Ejemplo de uso:

--------------------------------------------------------------------------------------------------------
# #Esto es una línea comentada
: ‘’ : ‘ Esto es un bloque comentado
Más de una línea ‘
 Operadores

Operador Ejemplo de uso:

----------------------------------------------------------------------------------------------
+ SUMA=$(( A + B ))
- DIF=$(( A - B ))
* PROD=$(( A * B ))
/ DIV=$(( A / B ))
% MOD=$(( A % B ))
 Bash scripting

Para controlar el flujo de ejecución de un script:

Selectivas:

● if / else: Ejecuta una serie de comandos dependiendo de una condición

● case: Ejecuta una serie de comandos dependiendo del valor de una variable.

Repetitivas:

● for: Ejecuta una serie de comandos un número determinado de veces.

● while: Ejecuta una serie de comandos mientras una condición se cumpla.

● until: Ejecuta una serie de comandos hasta que una condición se cumpla.

● select: Permite al usuario elegir una opción de un menú de opciones.

 Bash: Estructuras selectivas

● Implica la ejecución selectiva de código.

● Se puede elegir entre ejecutar una porción de código u otra, dependiendo de

determinada condición.

● Las condiciones tienen determinado valor de verdad (verdadero o falso).

● La ejecución condicional, les da potencia y dinamismo a los scripts.

● En bash tenemos if y sus variantes y case.

 Estructuras selectivas: if / then / else

Sintaxis: Sintaxis:

if [ condicion ]; then if [ condicion ]

#si condicion es VERDADERA then
fi #si condicion es VERDADERA
fi
-------------------------------------------------------- --------------------------------------------------------
if [ condicion ]
if [ condicion ]; then then
#si condicion es VERDADERA #si condicion es VERDADERA
else else
#si condicion es FALSA #si condicion es FALSA
fi fi
 Estructuras selectivas: if / then / else

#!/bin/bash
#
# Comprobando terminación de un comando
#

DIRECTORIO="/tmp/test"

COMANDO="/bin/mkdir $DIRECTORIO"

if $COMANDO then
echo "$DIRECTORIO ha sido creado"
else
echo "$DIRECTORIO no pudo ser creado"
fi
 Estructuras selectivas: if / then / else

#!/bin/bash
#
# Comparacion de cadenas alfanuméricas
#

CADENA1="uno"
CADENA2="dos"
CADENA3=""

if [ $CADENA1 = $CADENA2 ]; then

echo "\$CADENA1 es igual a \$CADENA2"

elif [ $CADENA1 != $CADENA2 ]; then

echo "\$CADENA1 no es igual a \$CADENA2"

if [ -z $CADENA3 ]; then
echo "\$CADENA3 esta vacia"
fi
 Estructuras selectivas: if / then / else

#!/bin/bash
#
# Comparacion de valores numericos
#

let NUM1=1
let NUM2=2
let NUM3=3

if [ $NUM1 -ne $NUM2 ] && [ $NUM1 -ne $NUM3 ]; then

echo "\$NUM1 es diferente a \$NUM2 y \$NUM3"
fi

if [ $NUM1 -lt $NUM3 ]; then

echo "\$NUM1 es menor que \$NUM3"
fi
 Estructuras repetitivas: for

Ejemplo 1: Ejemplo 2:

#!/bin/bash #!/bin/bash #!/bin/bash #!/bin/bash

for i in $( ls ); do for nro in `seq 1 10`; do

echo item: $i echo $((nro * 5))
done done
 Estructuras repetitivas: for

#!/bin/bash

for HOST in www.google.com www.altavista.com www.yahoo.com

do
echo "-----------------------"
echo $HOST
echo "-----------------------"

/usr/bin/host $HOST
echo "-----------------------"

done
 Estructuras selectivas: case

Ejemplo 1: Ejemplo 2:

read x read color

case $x in case $COLOR in

1)echo "uno";; azul) echo "Es azul";;
2)echo "dos";; rojo) echo "Es rojo";;
*)echo "no sé";; verde) echo "Es verde";;
esac *) echo "no sé";;
esac
 Estructuras repetitivas: while

Ejemplo 1: Ejemplo 2:

#!/bin/bash #!/bin/bash
c=1 c=1
while [ $c -le 5 ]; do
echo "Bienvenido $c veces" while [ $c -le 5 ]; do
c=$(( $c + 1 )) echo "Bienvenido $c veces"
done c=$(( $c + 1 ))
done
 Estructuras repetitivas: until

Ejemplo 1: Ejemplo 2:

#!/bin/bash #!/bin/bash #!/bin/bash

contador=20
read -p "Ingrese un valor: " a
until [ $contador -lt 10 ]; do until [ $a -le 0 ]
echo valor actual $contador do
contador= $(( contador - 1 )) echo "a is ${a}"
done a=$((a-1))
done
 Estructuras repetitivas: select

Ejemplo 1:

#!/bin/bash
OPCIONES="Hola Salir"

select opt in $OPCIONES; do

case $x in
"Hola" ) echo "Hola Mundo";;
"Salir" ) echo "Saliendo"; exit;;
*) echo "Opción incorrecta";;
esac
done
 Funciones en Bash

Ejemplo 1: Ejemplo 2:

#!/bin/bash #!/bin/bash

function salir { function mensaje {

exit echo $1
} }

function hola {
echo ¡Hola! mensaje “hola a todos”
mensaje “Chau adios”
}
hola salir
salir
 Librerías en Bash

Ejemplo 1: Ejemplo 2:

#!/bin/bash #!/bin/bash
# mi_libreria.sh
source mi_libreria.sh
function mensaje { mensaje “hola a todos”
echo $1 mensaje “Chau adios”
} salir

function hola {
echo ¡Hola!
}

function salir {
exit
}
 Archivos de configuración de bash

Existen, eventualmente, tres archivos en el directorio home

.bas_profile
.bas rc
.bas_logout

Se utilizan para definir variables y/o ejecutar comandos al ingresar al sistema, cuando se invoca un nuevo
shell o al cerrar la sesión

Pueden existir o no dependiendo de como se creo la cuenta de usuario.

Si no existen, el usuario utilizará sólo el archivo de sistema
/etc/profile, o puede optar por editarlos él mismo

El más importante es .bas_profile, el cual es leído por el shell para ejecutar los comandos que contiene cada
vez que se ingresa al sistema
 Archivos de configuración de bash

Algunas líneas de .bas_profile

PATH=/sbin:/usr/sbin:/bin:/usr/bin:/usr/local/bin
SHELL=/bin/bas
MANPATH=/usr/man:/usr/X11/man
EDITOR=/usr/bin/vi
PS1='\ :\w\ '
PS2='S '
set -o ignoreeof
export EDITOR

Si se agregan nuevas líneas no serán consideradas hasta que el archivo .bas_profile sea leído/ejecutado
nuevamente, reingresando al sistema, por ejemplo

Comando source: Ejecuta los comandos en el archivo especificado

source .bas_profile

Alternativa para source comando, utilizar el comando punto (.)

./bas_profile
 Archivos de configuración de bash

bash admite dos sinónimos para .bas_profile:

-.bas _login, derivado del archivo .login de C shell
-.profile, derivado del archivo .profile del Bourne shell y el Korn shell

Se lee sólo uno de estos al ingresar al sistema

Orden: .bas _profile → .bas _login → .profile

.bas rc puede o no existir

AI iniciar un nuevo sheII (un subsheII) se Ieerán Ios comandos de .bas rc

Separación de comandos de inicio y de personalización de shell

Si .bas rc no existe entonces no se ejecutarán cuando se inicia un subshell

 Archivos de configuración de bash

•.bas _logout es leído y ejecutado cada vez que se sale del login
shell

• Brinda la capacidad de ejecutar comandos, como eliminar archivos

temporarios

• Generalmente hay que definirlo mediante edición manual

• Si no existe, no se ejecutarán comandos extra a la salida

 Alias

• A veces la sintaxis de los comandos es difícil de recordar, especialmente si se utilizan

con varias opciones y argumentos
• Alias = sinónomo enriquecido
• Los alias pueden definirse en línea de comandos, en el .bas_profile, o en .bas
rc, mediante:
alias [name=command] // sin espacios entre el signo =

• Ejemplos: $ alias lf='ls -F'

$ alias revsort='ls [0-9]* | sort -v'
• Notas:
- Se permite definir un alias de un alias
- No están permitidos los alias recursivos $ alias ls='ls -la'
- Los alias sólo pueden usarse al principio de un comando (existen excepciones)
$ alias pkgs=/var/sadm/pkg
$ alias cd='cd '
 Caracteres especiales

• Conocidos también como metacaractes

• Los metacaracteres poseen significado especial para el shell

• Existen diversas categorías de acuerdo a la funcionalidad con que estén

relacionados

• Ejemplos:
$ cd -/libros
$ rm *.bck
$ find / -name a* &
Caracteres especiales
 El carácter de escape

• Es el carácter \ (backslash)
• Evita que el siguiente carácter sea interpretado por el shell

$ echo $1234
234
$ echo \$1234
$1234

• Excepción: \newline, esta secuencia se interpreta como continuación de línea eliminando

posteriormente esta secuencia de la entrada del comando

• Ejemplo:
$ echo Texto escrito en \
> mas de una linea
Texto escrito en mas de una linea
 Comillas dobles

• Los caracteres encerrados entre comillas dobles preservan su valor literal

• También se conoce como Weak quoting o Partial quoting
• Los caracteres * y @ tienen un significado especial cuando se encierran con
comillas dobles

• Excepciones:
- $ y ' siguen manteniendo sus significados especiales
- \ sigue manteniendo su significado especial sólo si antecede los caracteres
, ', “, \ o newline.

• Ejemplos:
$ echo “El reloj tiene un valor de $123”
El reloj tiene un precio de 23

$ echo “El reloj tiene un valor de \$123”

El reloj tiene un precio de $123

$ echo “Es un vino con buen 'bouquet'”

Es un vino con buen 'bouquet'
 Comillas simples

• Los caracteres encerrados entre comillas simples preservan su valor literal

• No se permite la desreferencia de variables entre comillas simples
• No puede aparecer una comilla simple entre dos comillas simples
• También se conoce como Strong quoting o Full quoting

• Excepción: \newline

• Ejemplos:
$ VAR=10
$ echo '$VAR'
$VAR

$ echo 'd* = el carácter <d> seguido de cualquier cadena, \ inclusive la vacía'

$ echo 'La comilla simple (') también es llamado aopostrofo'

 ANSI-C Quoting

• Las cadenas de la forma 'texto' son consideradas de manera especial

La cadena se expande a texto con los caracteres de escape \
reemplazados como lo especifica el estándar ANSI-C

\a alerta (alerta)
\b retroceso (backspace)
\n nueva línea (new line)
\t tab horizontal (horizontal tab)
\v tab vertical (vertical tab)
\\ barra invertida (backslash)

• Ejemplos:
$ echo Barra invertida = $'\\'
Barra invertida = \

$ echo Se oye .... $'\a'

Se oye .... (beep)

$ echo Hola '$\n' Mundo

Hola
Mundo
 Ejemplos combinados

$ echo <-$1250.**>; (update?) [y|n]

$ echo \<-\$1250.\*\*\>\; \(update\?\) \[y\|n\]
$ echo '<-$1250.**>; (update?) [y|n]'

$ echo La variable '$UID' contiene el valor --\> "$UID"

La variable $UID contiene el valor --> 1002
 Variables

• Es posible almacenar en una variable el resultado de la ejecución de un comando.

- Con (...): anidable

$ lista_de_archivos=$(ls)
$ lista_de_archivos=$(ls $(cat directorios.txt))

• Referencia indirecta: Si el valor de una variable es el nombre de una segunda podemos recuperar el
valor de la segunda a través la primera
$ dosmil=numero
$ numero=2000
$ echo $dosmil #referencia directa
numero

$ eval echo \$$dosmil #referencia indirecta

2000
 Variables de shell y entorno

• Variables Locales
- Presentes en la instancia actual del shell
- No disponibles para programas iniciados desde el shell (no exportadas)

• Variables de Entorno
- Disponibles por todo proceso hijo del shell
- Muy útiles para la escritura de scripts y programas
- Pueden visualizarse mediante el comando env
- Se pueden agregar variables al entorno mediante export
- Nombres en mayúsculas por convención

• Variables de Shell
- Establecidas y utilizadas por el shell para su funcionamiento
- Algunas son variables de entorno otras son locales
- Pueden visualizarse mediante el comando set
- Convencionalmente tienen nombres en mayúsculas

PWD UID SHLVL PATH

HOME IFS (Internal Field Separator)
 Variables enteras

• Las variables enteras en Bash son enteros con signo (32 bits)

• Posibilidad de overflow

• Bash por sí mismo no comprende la aritmética de punto flotante

•Bash considera a los números conteniendo punto decimal como cadenas

•Utilizar el lenguaje bc en los scripts si es necesario realizar cálculos de punto flotante o emplear funciones
matemáticas de bibliotecas

• Ejemplos:
$ echo "2.35 + 56.90" | bc > 59.25
$ echo "sqrt(2)" | bc > 1
$ echo "sqrt(2.0)" | bc > 1.4
 Arrays

• Un array es una serie de casillas, cada una conteniendo un valor

• Casilla = elemento, los elementos se acceden mediante índices
• Los índices comienzan en 0 hasta más de 5 mil billones
• En bash son únicamente uni-direccionales
• Asignaciones:
$ colores[0]=rojo
$ colores[2]=verde
$ colores[1]=amarillo
$ colores=([2]=verde [0]=rojo [1]=amarillo)
$ colores=(rojo amarillo verde)
$ colores=(rojo [10]=amarillo verde)
• Los arrays se pueden declarar vacíos explicitamente mediante
$ declare -a colores
• Los atributos establecidos para el array (read-only) se aplican a todos los elementos
• Para referenciar un elemento: ${array[i]}
$ echo 'No pasar' es ${colores[0]}
• Para referenciar todos los elementos ${name[*]} o ${name[@]}
$ echo ${colores[*]}
 Comando set

• El comando set despliega las variables de shell junto a sus valores

• Permite definir el comportamiento del bash (opciones)

• Sintaxis:
set [-abdefkmntuvxBCHP] [(-|+)o opcion] [argumento...]

-n Lee comandos pero no los ejecuta, útil para depurar sintácticamente scritps
-v Muestra las líneas de entrada del shell tal cual son leídas
-x Muestra una traza de un comando y sus argumentos luego de aplicar expansiones

• Su uso habitual en shell scripts es para establecer los parámetros posicionales

$ set `date`
$ echo Hora actual: $4
Hora actual: 08:40:25
 Comando getopts

• bash provee getopts para tratar con opciones múltiples y complejas

• puede utilizarse como una condición en un bucle while, dada la especificación del formato de
opciones (validez y argumentos), en el cuerpo del while se procesan
• Sintaxis:
getopts cadena variable
- cadena conteniendo letras (opciones) y :'s (argumentos)
- variable que almacena el argumento de la opción que está analizándose

• Ejemplo:
while getopts ":ab:c" opt; do
case $opt in
a ) procesar la opción -a ;;
b ) procesar la opción -b
$OPTARG es el argumento de la opción ;;
c ) procesar la opción -c ;;
\? ) echo 'usage: alice [-a] [-b barg] [-c] args...'
exit 1
esac
done