¿Te gustaría enterarte de cuando lanzamos descuentos al Máximo o Nuevos Cursos?
Los Alias
Un alias puede utilizarse para asignar comandos más largos a secuencias más cortas. Cuando el shell ve un alias ejecutado, sustituye la secuencia más larga antes de proceder a interpretar los comandos. Por ejemplo, el comando ls -l comúnmente tiene un alias l o ll. Ya que estos comandos más pequeñas son más fáciles de introducir, también es más rápido ejecutar la línea de comandos ls -l. Puedes determinar qué alias se definen en el shell con el comando alias:
sysadmin@localhost:~$ alias
alias alert='notify-send —urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -alF'
alias ls='ls --color=auto'Los alias que ves en los ejemplos anteriores fueron creados por los archivos de inicialización. Estos archivos están diseñados para hacer automático el proceso de creación de los alias. Los nuevos alias se pueden crear introduciendo alias name=command, donde nombre es el nombre que quieres dar a el alias y comando es el comando que quieres que se ejecute cuando se ejecuta el alias.
Puedes crear un alias de tal manera que lh muestre una lista larga de archivos, ordenados por tamaño con un tamaño “human friendly” con el comando alias lh='ls -Shl'. Introduciendo lh debe ahora dar lugar a la misma salida que introduciendo el comando ls -Shl:
sysadmin@localhost:~$ alias lh='ls -Shl' sysadmin@localhost:~$ lh /etc/ppp total 0 drwxr-xr-x 1 root root 10 Jan 29 2015 ip-down.d drwxr-xr-x 1 root root 10 Jan 29 2015 ip-up.d
Los alias creados de esta manera sólo persistirán mientras el shell esté abierto. Una vez que el shell es cerrado, los nuevos alias que hayas creado, se perderán. Además, cada shell posee sus propios alias, así que si creas un alias en un shell y luego lo abres en otro shell, no verás el alias en el nuevo shell.
Globbing
Los caracteres de globbing se denominan a menudo como “comodines”. Estos son símbolos que tienen un significado especial para el shell. A diferencia de los comandos que ejecutará el shell, u opciones y argumentos que el shell pasará a los comandos, los comodines son interpretados por el mismo shell antes de que intente ejecutar cualquier comando. Esto significa que los comodines pueden utilizarse con cualquier comando.
Los comodines son poderosos porque permiten especificar patrones que coinciden con los nombres de archivo en un directorio, así que en lugar de manipular un solo archivo a la vez, puedes fácilmente ejecutar comandos que afectarán a muchos archivos. Utilizando comodines es posible manipular todos los archivos con una cierta extensión o con una longitud de nombre de archivo determinado. Ten en cuenta que estos comodines pueden utilizarse con cualquier comando, ya que es el shell, no el comando que se expande con los comodines a la coincidencia de nombres de archivo.
Asterisco (*)
El asterisco se utiliza para representar cero o más de cualquier carácter en un nombre de archivo. Si quieres visualizar todos los archivos en el directorio /etc que empiecen con la letra t:
sysadmin@localhost:~$ echo /etc/t* /etc/terminfo /etc/timezone sysadmin@localhost:~$
El patrón t* significa “cualquier archivo que comienza con el carácter t y tiene cero o más de cualquier carácter después de la letra t“.
Puedes usar el asterisco en cualquier lugar dentro del patrón del nombre de archivo. El siguiente ejemplo coincidirá con cualquier nombre de archivo en el directorio /etc que termina con .d:
sysadmin@localhost:~$ echo /etc/*.d
/etc/apparmor.d /etc/bash_completion.d /etc/cron.d /etc/depmod.d /etc/fstab.d /etc/init.d /etc/insserv.conf.d /etc/ld.so.conf.d /etc/logrotate.d /etc/modprobe.d /etc/pam.d /etc/profile.d /etc/rc0.d /etc/rc1.d /etc/rc2.d /etc/rc3.d /etc/rc4.d /etc/rc5.d /etc/rc6.d /etc/rcS.d /etc/rsyslog.d /etc/sudoers.d /etc/sysctl.d /etc/update-motd.dEn el ejemplo siguiente se mostrarán todos los archivos en el directorio /etc que comienzan con la letra r y terminan con .conf:
sysadmin@localhost:~$ echo /etc/r*.conf /etc/resolv.conf /etc/rsyslog.conf
Signo de Interrogación (?)
El signo de interrogación representa cualquier carácter único. Cada carácter de signo de interrogación coincide con exactamente un carácter. Si quieres visualizar todos los archivos en el directorio /etc que comienzan con la letra t y que tienen exactamente 7 caracteres después del carácter de t:
sysadmin@localhost:~$ echo /etc/t??????? /etc/terminfo /etc/timezone sysadmin@localhost:~$
Los comodines pueden utilizarse juntos para encontrar patrones más complejos. El comando echo /etc/*???????????????????? imprimirá sólo los archivos del directorio /etc con veinte o más caracteres en el nombre del archivo:
sysadmin@localhost:~$ echo /etc/*???????????????????? /etc/bindresvport.blacklist /etc/ca-certificates.conf sysadmin@localhost:~$
El asterisco y el signo de interrogación también podrían usarse juntos para buscar archivos con extensiones de tres letras ejecutando el comando echo /etc/*.???:
sysadmin@localhost:~$ echo /etc/*.??? /etc/blkid.tab /etc/issue.net sysadmin@localhost:~$
Corchetes [ ] y Exclamación (!)
Los corchetes se utilizan para coincidir con un carácter único representando un intervalo de caracteres que pueden coincidir con los caracteres.
Por ejemplo, echo /etc/[gu]* imprimirá cualquier archivo que comienza con el carácter g o u y contiene cero o más caracteres adicionales:
sysadmin@localhost:~$ echo /etc/[gu]* /etc/gai.conf /etc/groff /etc/group /etc/group- /etc/gshadow /etc/gshadow- /etc/ucf.conf /etc/udev /etc/ufw /etc/update-motd.d /etc/updatedb.conf sysadmin@localhost:~$
Los corchetes también pueden ser utilizados para representar un intervalo de caracteres. Por ejemplo, el comando echo /etc/[a-d]* mostrará todos los archivos que comiencen con cualquier letra entre e incluyendo a y d:
sysadmin@localhost:~$ echo /etc/[a-d]*
/etc/adduser.conf /etc/adjtime /etc/alternatives /etc/apparmor.d
/etc/apt /etc/bash.bashrc /etc/bash_completion.d /etc/bind /etc/bindresvport.blacklist /etc/blkid.conf
/etc/blkid.tab /etc/ca-certificates /etc/ca-certificates.conf /etc/calendar /etc/cron.d /etc/cron.daily /etc/cron.hourly /etc/cron.monthly /etc/cron.weekly /etc/crontab /etc/dbus-1 /etc/debconf.conf /etc/debian_version /etc/default
/etc/deluser.conf /etc/depmod.d /etc/dpkg
sysadmin@localhost:~$El comando echo /etc/*[0-9]* mostrará todos los archivos que contienen al menos un número:
sysadmin@localhost:~$ echo /etc/*[0-9]* /etc/dbus-1 /etc/iproute2 /etc/mke2fs.conf /etc/python2.7 /etc/rc0.d /etc/rc1.d /etc/rc2.d /etc/rc3.d /etc/rc4.d /etc/rc5.d /etc/rc6.d sysadmin@localhost:~$
El intervalo se basa en el cuadro de texto de ASCII. Esta tabla define una lista de caracteres disponiéndolos en un orden estándar específico. Si proporcionas un orden inválido, no se registrará ninguna coincidencia:
sysadmin@localhost:~$ echo /etc/*[9-0]* /etc/*[9-0]* sysadmin@localhost:~$
El signo de exclamación se utiliza en conjunto con los corchetes para negar un intervalo. Por ejemplo, el comando echo [!DP]* mostrará cualquier archivo que no comienza con D o P.
Las Comillas («)
Hay tres tipos de comillas que tienen significado especial para el shell Bash: comillas dobles ", comillas simples ' y comilla invertida `. Cada conjunto de comillas indica al shell que debe tratar el texto dentro de las comillas de una manera distinta a la normal.
Las comillas dobles
Detendrán al shell de la interpretación de algunos metacaracteres, incluyendo los comodines. Dentro de las comillas dobles, el asterisco es sólo un asterisco, un signo de interrogación es sólo un signo de interrogación y así sucesivamente. Esto significa que cuando se utiliza el segundo comando echo más abajo, el shell BASH no convierte el patrón de globbing en nombres de archivos que coinciden con el patrón:
sysadmin@localhost:~$ echo /etc/[DP]* /etc/DIR_COLORS /etc/DIR_COLORS.256color /etc/DIR_COLORS.lightbgcolor /etc/PackageKit sysadmin@localhost:~$ echo "/etc/[DP]*" /etc/[DP]* sysadmin@localhost:~$
Esto es útil cuando quieres mostrar algo en la pantalla, lo que suele ser un carácter especial para el shell:
sysadmin@localhost:~$ echo "Los comodines son *, ? y [ ]" Los comodines son *, ? y [ ] sysadmin@localhost:~$
Las comillas dobles todavía permiten la sustitución de comando, sustitución de variable y permiten algunos metacaracteres de shell sobre los que aún no hemos hablado. Por ejemplo, en la siguiente demostración, notarás que el valor de la variable PATH es desplegada:
sysadmin@localhost:~$ echo "path es $PATH" path es /usr/bin/custom:/home/sysadmin/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games sysadmin@localhost:~$
Las comillas simples
Evitan que el shell interprete algunos caracteres especiales. Esto incluye comodines, variables, sustitución de comando y otro metacarácter que aún no hemos visto. Si quieres que el carácter $ simplemente signifique un $, en lugar de actuar como un indicador del shell para buscar el valor de una variable, puedes ejecutar el segundo comando que se muestra a continuación:
sysadmin@localhost:~$ echo esto cuesta $100 Esto cuesta 00 sysadmin@localhost:~$ echo 'Esto cuesta $100' Esto cuesta $100 sysadmin@localhost:~$
Las comillas invertidas
Se utilizan para especificar un comando dentro de un comando, un proceso de sustitución del comando. Aunque puede sonar confuso, un ejemplo debe hacer las cosas más claras. Para empezar, fíjate en la salida del comando date:
sysadmin@localhost:~$ date Mon Nov 2 03:35:50 UTC 2015
Ahora fíjate en la salida de la línea de comandos echo Today is date:
sysadmin@localhost:~$ echo Hoy es date Hoy es date sysadmin@localhost:~$
En el comando anterior la palabra date es tratada como texto normal y el shell simplemente pasa date al comando echo. Pero, probablemente quieras ejecutar el comando date y tener la salida de ese comando enviado al comando echo. Para lograr esto, deberás ejecutar la línea de comandos echo Today is `date`:
sysadmin@localhost:~$ echo Hoy es `date` Hoy es Mon Nov 2 03:40:04 UTC 2015 sysadmin@localhost:~$
Puedes utilizar una técnica alternativa para citar un carácter con comillas simples. Si que quieres imprimir lo siguiente: “Esto cuesta $100 y path es $PATH“. Si pones esto entre las comillas dobles, $1 y $PATH se consideran variables. Si pones esto entre las comillas simples, $1 y $PATH no son variables. Pero ¿qué pasa si quieres tener $PATH tratado como una variable y no a $1?
La diagonal Inversa (\)
Si colocas una barra diagonal invertida \ antes del otro carácter, tratará al otro carácter como un carácter de “comillas simples”. El tercer comando más abajo muestra cómo utilizar el carácter \, mientras que los otros dos muestran cómo las variables serían tratadas si las pones entre las comillas dobles y simples:
sysadmin@localhost:~$ echo "Esto cuesta $100 y path es $PATH" Esto cuesta 00 y path es /usr/bin/custom:/home/sysadmin/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games sysadmin@localhost:~$ echo 'Esto cuesta $100 y path es $PATH' Esto cuesta $100 y path es $PATH sysadmin@localhost:~$ echo Esto cuesta \$100 y path es $PATH Esto cuesta $100 y path es /usr/bin/custom:/home/sysadmin/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games sysadmin@localhost:~$
Instrucciones de Control
Las instrucciones de control te permiten utilizar varios comandos a la vez o ejecutar comandos adicionales, dependiendo del éxito de un comando anterior. Normalmente estas instrucciones de control se utilizan en scripts o secuencias de comandos, pero también pueden ser utilizadas en la Shell.
El punto y coma puede utilizarse para ejecutar varios comandos, uno tras otro. Cada comando se ejecuta de forma independiente y consecutiva; no importa el resultado del primer comando, el segundo comando se ejecutará una vez que el primero haya terminado, luego el tercero y así sucesivamente.
Si quieres imprimir los meses de enero, febrero y marzo de 2022, puedes ejecutar cal 1 2022; cal 2 2022; cal 3 2022 en la línea de comandos.
El símbolo de ampersand doble &&
Actúa como un operador “y” lógico. Si el primer comando tiene éxito, entonces el segundo comando también se ejecutará. Si el primer comando falla, entonces el segundo comando no se ejecutará. Los comandos tienen éxito cuando algo funciona bien y fallan cuando algo sale mal. Por ejemplo, considera la línea de comandos ls /etc/xml. El comando tendrá éxito si el directorio /etc/xml es accesible y fallará cuando no es accesible. El primer comando tendrá éxito porque el directorio /etc/xml existe y es accesible mientras que el segundo comando fallará porque no hay un directorio /junk:
sysadmin@localhost:~$ ls /etc/xml catalog catalog.old xml-core.xml xml-core.xml.old sysadmin@localhost:~$ ls /etc/junk ls: cannot access /etc/junk: No such file or directory sysadmin@localhost:~$
La manera en que usarías el éxito o fracaso del comando ls junto con && sería ejecutando una línea de comandos como la siguiente:
sysadmin@localhost:~$ ls /etc/xml && echo success catalog catalog.old xml-core.xml xml-core.xml.old success sysadmin@localhost:~$ ls /etc/junk && echo success ls: cannot access /etc/junk: No such file or directory sysadmin@localhost:~$
En el primer ejemplo el comando echo fue ejecutado, porque tuvo éxito el comando ls. En el segundo ejemplo, el comando echo no fue ejecutado debido a que el comando ls falló.
La línea vertical doble ||
Es un operador lógico “o”. Funciona de manera similar a &&; dependiendo del resultado del primer comando, el segundo comando se ejecutará o será omitido. Si el primer comando se ejecuta con éxito, el segundo comando es omitido. Si el primer comando falla, entonces se ejecutará el segundo comando. Le estás diciendo al shell, “O bien ejecuta este primer comando o bien el segundo”. En el ejemplo el comando echo se ejecutará sólo si falla el comando ls:
sysadmin@localhost:~$ ls /etc/xml || echo failed catalog catalog.old xml-core.xml xml-core.xml.old sysadmin@localhost:~$ ls /etc/junk || echo failed ls: cannot access /etc/junk: No such file or directory failed sysadmin@localhost:~$
Aprende Linux desde 0
Si quires aprender todo, en video, totalmente práctico para desarrollarte en el ambiente profesional y aprobar el examen de la Certificación LPIC-1 te recomendamos iniciar por este curso: Aprende Linux desde 0 y prepara la Certificación LPIC-1. Inicia desde 0 en Linux. Prepara la Certificación LPIC-1 con todo el contenido Teórico, practica y modelos de Examen.
¿Te gustaría enterarte de cuando lanzamos descuentos al Máximo o Nuevos Cursos?