Linux: Introducción Al Shell

02 Linux
Introducción al Shell
Linux 02
• Índice
• OBJETIVOS.......................................................................................................... 3
• INTRODUCCIÓN .................................................................................................. 4
2.1. Funcionamiento de la línea de comandos ................................................ 5
2.1.1. Introducción........................................................................................... 5
2.1.2. Las diferentes Shell en Linux ................................................................ 8
2.1.3. Cómo cambiar de shell ....................................................................... 10
2.1.4. Introducción a ficheros especiales y caracteres especiales................ 12
2.1.5. Otros aspectos importantes ................................................................ 15
2.2. Comandos básicos ................................................................................... 18
2.2.1. Para obtener ayuda............................................................................. 19
2.2.2. Comandos para moverse por el terminal ............................................ 21
2.2.3. Comandos para apagar y reiniciar el sistema ..................................... 21
2.2.4. Moverse en el sistema de archivos ..................................................... 24
2.2.5. Trabajar con archivos y directorios ..................................................... 26
2.2.6. Comandos para obtener información del sistema.............................. 28
2.2.7. Operaciones con ficheros y directorios ............................................... 30
2.2.8. Comprimir y descomprimir archivos .................................................... 36
2.3. Redirecciones............................................................................................ 38
2.4. Expresiones regulares.............................................................................. 45
2.5. Filtros ......................................................................................................... 51
2.6. Editores de texto ....................................................................................... 58
2.6.1. Editor vi ............................................................................................... 58
2.6.2. Editor EMACS ..................................................................................... 61
• RESUMEN .......................................................................................................... 65
Introducción al Shell 1
Linux 02
• Objetivos
• Comprender el funcionamiento de la línea de comandos.
• Aprender a realizar tareas sencillas de un modo alternativo al entorno gráfico.
• Profundizar en los conocimientos sobre algunos de los comandos más

importantes.
• Comprender el concepto de redirecciones en entrada y salida de procesos.
• Introducción al uso de expresiones regulares y filtros.
• Conocer los principales editores de Unix y realizar operaciones básicas con

ellos.
Formación Abierta
• Introducción
En esta unidad se pretende realizar una introducción a los diferentes tipos de shell y
en particular a la shell por defecto de GNU/Linux, la shell Bash. Una shell
simplemente es otro programa de GNU/Linux que va a proporcionar una interfaz de
intermediación entre el usuario y el sistema interpretando de esta forma lo que el
usuario introduce desde la línea comandos para que el sistema pueda llevar a cabo
las funciones solicitadas.
Se explicarán los comandos más útiles para realizar funciones básicas de usuario y
se presentarán organizados por diferentes categorías de funcionalidades.
También explicará cómo poder redireccionar la entrada y la salida de la información

para que pueda ser utilizada por otros comandos. Estas operaciones las se podrán
realizar con los denominados operadores de redirección y mediante comandos tipo
filtros.
Para optimizar y potenciar el uso de estos comandos se detallan el uso de las

expresiones regulares que nos permitirán realizar operaciones basadas en patrones
para de esta forma poder implicar a un conjunto de archivos y/o información
diferente.
Por último, se darán a conocer los principales editores de texto de GNU/Linux que
ayudarán en las tareas sencillas de edición de archivos.
4 Introducción al Shell
Linux 02
2.1. Funcionamiento de la línea de

comandos
Al igual que en los sistemas operativos Windows, Linux por norma general como se
ha visto en el proceso de instalación de Ubuntu, arrancará en modo gráfico
solicitándo un usuario y contraseña. Una vez se haya alcanzado el escritorio se
podrá ejecutar la línea de comandos. Pero, ¿qué hay detrás de todo esto?
En cuanto al entorno gráfico se puede decir a modo de introducción que es una

combinación de varias aplicaciones. Como ya se ha explicado en la unidad 1, el
sistema ejecuta X Window System que va a proporcionar un entorno de ventanas.
No todas las distribuciones instalan por defecto X Window System y en tal caso si
interesa se tendría que instalar manualmente.
Por encima del sistema de ventanas, se instala un entorno de escritorio, con barras
de herramientas, botones y otras opciones. Los dos más conocidos son GNOME y
KDE. Por ejemplo, en la distribución de Ubuntu se encuentra con GNOME, al igual
que en las distribuciones Debian, Red Hat y Fedora. KDE lo podemos encontrar en
la distribución paralela de Ubuntu, denominada Kubuntu.
Esto en cuanto al entorno gráfico, pero el tema que este capítulo ocupa es el Shell
de Linux.
2.1.1. Introducción
Cuando Linux es iniciado por el usuario, se pone en marcha una aplicación que
realizará las funciones de interfaz entre nosotros y el kernel de Linux. A este
programa se le llama el Shell de Linux. Cuando se ejecuta y aparece la ventana de
terminal mostrará un indicador y estará esperando a que se introduzcan las órdenes
oportunas en forma de comandos. Por esta razón, también se le suele llamar el
intérprete de comandos de Linux.
Si se está utilizando Ubuntu, se puede encontrar un emulador de terminal desde el

menú Aplicaciones->Accesorios->Terminal (figura 2.1) y aparecerá una pantalla
el GNOME Terminal como se puede ver en la figura 2.2.
Formación Abierta
Figura 2.1. Emulador de terminal.
Figura 2.2. GNOME terminal.
Si se estuviera trabajando con una distribución KDE, se podría utilizar la aplicación

Konsole desde Aplicaciones->Herramientas del Sistema-> y desde allí ejecutar
Konsole.
En la pantalla del emulador de terminal que se ha abierto, encontramos un prompt

en el que aparece algo parecido a lo siguiente:
usuario@host directorio$
Linux 02
En la mayoría de las distribuciones, este prompt se construye desde la izquierda

con el nombre de usuario con el que se ha accedido al sistema y a continuación iría
el nombre del host, el directorio actual se puede observar y el símbolo $.
El resultado por partes que se puede observar en la figura 2.2 es el siguiente:
En nuestro caso, "usuario" es el nombre del usuario con el que se realiza la

instalación de Ubuntu y con el que se ha accedido al sistema.
A continuación el símbolo @ para separar del nombre del host.
Nuestro nombre de host sería usuario-virtual-machine.
A continuación se observa el símbolo ~, que es una forma abreviada para
decir que es nuestro directorio inicial (home). Ya se ha explicado que el
directorio /home se crea para cada uno de los usuarios que utilizan nuestro
equipo y es el lugar donde se guardan nuestros documentos, imágenes y el
resto de configuraciones de los programas que se utilicen.
Por último, el símbolo $ que va a indicar qué tipo de usuario es, por defecto,
un usuario sin especiales privilegios tendrá $ como prompt de inicio. Pero
hay un usuario root, que tiene como símbolo #. El usuario root es el
superusuario, que puede controlarlo y administrarlo todo. Pero de usuario se
hablará en la unidad 3.
En este capítulo se hablará de su funcionamiento básico pero es muy importante

que se preste especial atención porque es una de las herramientas más potentes
con las que se va a poder trabajar ya que desde aquí se podrán realizar numerosas
tareas administrativas. Es más, en algunas ocasiones puede encontrarse ante una
situación en la que solo se disponga de la línea de comandos para trabajar.
Los comandos que se pueden introducir a través de la Shell pueden ser internos o
externos:
Los comandos internos están compuestos de un código que forma parte del
proceso de una shell.
Los comandos externos tienen el código para ser ejecutado en un archivo,
bien en formato binario ejecutable o como guión de la propia shell.
La shell interpretará nuestras órdenes suponiendo que la primera palabra de la

línea de comandos en la orden a ejecutar y que cualquier otra palabra que empiece
con guión ( - ) es una opción. El resto de palabras serán los parámetros adicionales
o necesarios para ejecutar dicho comando.
Formación Abierta
De forma resumida, las tareas de shell serían las siguientes:
Interpretar las variables de entorno. Las variables de entorno son regiones

de memoria a las que se les asigna un valor.
Interpretar los metacaracteres. Comodines como ‘*’ o ‘?’.
Manejar la entrada y salida estándar de comandos.
Buscar alias, e interpretarlos.
Interpretar los comandos introducidos diferenciándolos en comandos
internos de la shell, o binarios ejecutables utilizando la variable de entorno
$PATH, donde se guardan las principales rutas del sistema.
Una característica a tener en cuenta con respecto a usuarios procedentes de

Windows, es que en nuestro intérprete de comandos sí que se va a diferenciar
entre mayúsculas y minúsculas a la hora de introducir cualquier comando. Por
ejemplo, el comando ls no sería igual a LS.
2.1.2. Las diferentes Shell en Linux

En cualquier sistema Linux se puede encontrar con una variedad de shell. Las más
comunes suelen ser Bash, TC y Z. Cada usuario tiene una shell por defecto suele
ser Bash pero existen instrucciones que pueden permitir cambiarla como por
ejemplo: tcsh o chsh.
En la siguiente tabla se puede observar nombres, las shell más comunes y sus
ubicaciones:
Nombre Comando Ubicación
Bourne Again Bash /bin/Bash
Bourne sh /bin/sh
Shell de TC tcsh /bin/tcsh
Shell de C csh /bin/csh
Shell de Korn ksh /bin/ksh
Shell de Z zsh /bin/zsh
Figura 2.3. Shells y ubicaciones.
La selección de una shell es una cuestión no solo de gustos sino también de

necesidad. Por ejemplo, la shell Bash está más preparada para todo aquello
relacionado con la programación, pero se encontraría al mismo nivel de la shell TC
en cuestiones de interactividad. Por lo tanto, se usará la shell Bash como guía en
todas nuestras explicaciones y ejemplos ya que suele ser la más común en
sistemas Linux.
Linux 02
A continuación, algunas de las razones principales de porqué bash suele ser la

shell más extendida:
Gran número de estructuras de lenguaje de alto nivel: if, while, select, etc.
Soporte de examen de archivos y carpetas.
Soporte de aritmética de enteros.
Desarrollo de programas más rápido que comparado con lenguajes como C.
Mecanismo de historial interactivo de comandos que emula a uno de los dos
editores más usado en GNU Linux por defecto.
Soporte de funciones.
Estructuras avanzadas para igualar patrones y la habilidad de procesar
cadenas de caracteres complejos.
Presencia en la mayoría de las distribuciones GNU Linux y otros sistemas
operativos.
Es el shell por defecto de GNU Linux.
El shell va a interpretar los scripts preparados para dicha shell con lo cual nos se
van a ahorrar las tareas de compilación y la de vinculación (link). Existe la
disponibilidad de estructuras y de comparaciones avanzadas de patrones de
caracteres, formas de examinar archivos y directorios, aritmética de enteros y
soporte de funciones así como un mecanismo que permitirá revisar el historial de
comandos para poder ser editado en vi o emacs, los dos editores de texto más
característicos de GNU/Linux.
Formación Abierta
2.1.3. Cómo cambiar de shell

Para saber cuál es la Shell que se está utilizando en este momento se puede
utilizar el comando echo $SHELL. Si no es con el usuario root habrá utilizar el
comando sudo por delante para tener permisos de ejecución. El resultado sería el
siguiente:
Figura 2.4. Pantalla con comando echo $Shell.
Como se puede nuestro ejemplo, la shell que se está utilizando es Bash.
En ocasiones puede que sea interesante cambiar de shell. Por ejemplo, se puede
encontrar por Internet un guión de una shell para TC que interesa muchísimo por
cuestiones de programación por ejemplo, pero no sirve para Bash.
Se puede cambiar nuestra shell de tres formas distintas según sean nuestras
necesidades:
Cambiando nuestra shell por defecto pero solo para nuestra sesión actual.
Pasando a una nueva configuración para todo conexión subsiguiente a
nuestro sistema.
Creando sesiones adicionales de shell que se ejecutarán de forma
concurrente a nuestra shell por defecto o por encima de ella.
Linux 02
Se puede ver todas las shell que hay instaladas en nuestro sistema con el comando
more /etc/shells, como se puede ver a continuación:
Figura 2.5. Comando more /etc/shells.
Para cambiar el shell desde nuestra consola de comandos se deberá de utilizar el

comando chsh. Tiene dos formas de ser ejecutado:
De forma interactiva para la cual solo se tendría que introducir el comando y

pulsar la tecla enter y a continuación se pondrá en modo de espera para
que se introduzca la Shell a la que queremos se quiera cambiar.
Introduciendo el comando completo acompañado directamente por la shell
que se haya elegido, por ejemplo chsh -s /bin/sh (figura 2.6). Como
siempre, si no es con el usuario root, pedirá la contraseña de root para
poder ejecutarlo.
Si se cierra el emulador de terminal o se reinicia el sistema, se vuelve a tener una

shell Bash por defecto.
Formación Abierta
Figura 2.6. Ejemplo chsh -s /bin/sh.
2.1.4. Introducción a ficheros especiales y caracteres

especiales
En la unidad 4 de este libro se tratarán en profundidad todo aquello relacionado con
la estructura del sistema de archivos en Linux y los diferentes tipos de archivos que
se pueden encontrar.
Pero antes de empezar con los comandos básicos, es necesario tener una serie de
conocimientos mínimos de estos ficheros y algunos caracteres especiales que se
van a poder usar precisamente con estos comandos y por lo tanto ya resulte más
familiar.
El sistema de ficheros de Linux y de Unix es una organización jerárquica de ficheros

y directorios que parten del directorio raíz, para el cual se utiliza el símbolo de la
barra ( / ). Un fichero será un conjunto de datos internos representado por su
nombre de fichero y un directorio será un fichero especial que contendrá un
conjunto de estos ficheros. Cada uno de estos ficheros tendrá una serie de
características únicas como su tamaño, el tipo de fichero que es, quien es su
propietario, los permisos que tiene asignados, etc.
De entre todos los directorios, hay algunos especiales porque son propiedad del
sistema operativo, como por ejemplo podría ser el directorio /bin, que se usa para
almacenar todas las órdenes que se pueden enviar a la shell, o el directorio /etc
donde se podrían encontrar determinadas órdenes para la administración del
sistema.
Linux 02
Grosso modo, podría encontrarse con tres tipos de ficheros:
Ficheros ordinarios
Directorios
Especiales, es decir, los dispositivos físicos.
Aunque un directorio al fin y al cabo también es un fichero, las funciones que tiene
asignadas son diferentes a las de un fichero ordinario pues de hecho la primera
diferencia fundamental es que un directorio va a contener a un conjunto de ficheros
ordinarios.
En cuanto a ficheros ordinarios, podrán encontrarse diferentes tipos:
textual (contienen caracteres ascii y no son ejecutables).

código fuente (tampoco es ejecutable).
órdenes de la shell (sí que son ejecutables).
código binario (también es ejecutable).
Los ficheros especiales son desde el punto de vista práctico igual que los ficheros
ordinarios pero suelen ser utilizados para relacionar diferentes dispositivos físicos.
Por ejemplo:
/dev/tty Pantalla del superusuario

/dev/tty8 Pantalla número 8
/dev/console La consola
/dev/mem Acceso a la memoria física
/dev/null Periférico nulo donde irán salidas indeseadas
/dev/fd0 Disquetera
/dev/sda Primer disco duro instalado
/dev/sda1 Primera partición del primer disco duro
/dev/sdb Segundo disco duro
Existen otros ficheros especiales que también se usarán frecuentemente y que

serían los siguientes:
/ El directorio raíz
. El directorio actual
.. El directorio padre del directorio actual
~ El directorio de entrada
Formación Abierta
En cuanto a los caracteres especiales hay algunos que nos van a ser muy útiles
para utilizar con los comandos y para localizar e identificar ficheros. Los llamamos
comodines:
* Describe una cadena con cero o más caracteres.

? Describe cualquier carácter, pero solo uno.
[-] Describe un conjunto de caracteres comprendidos entre otros dos.
Con los siguientes ejemplos se verá un poco más claro:
cat *.f
Aunque no se ha visto aún, el comando cat visualiza por pantalla el contenido de

ficheros. En nuestro caso visualizaría por pantalla todos aquellos ficheros con
extensión .f
cat [A-B]* .c
En nuestro caso, visualizaría por pantalla todos los ficheros con extensión .c cuyo
nombre sea A o B, o empiezan por A o B.
cat ?[A-D]
En este ejemplo visualizaría por pantalla todos los ficheros que tengan solo dos
caracteres, de los cuales el primero es arbitrario y el segundo carácter tiene que
estar comprendido entre las letras A y D, es decir, puede ser A, B, C o D.
Se podría utilizar también para realizar operaciones con ficheros. Por ejemplo:
cp data* /home/datos
Con este comando se van a copiar todos los ficheros cuyo nombre empiece por
data al directorio /home/datos.
Sino se hubiera podido disponer del asterisco se habría tenido que añadir todos los
ficheros uno a uno en el comando de la siguiente forma:
cp data01,data02,data03 /home/datos
En realidad esta operación la realiza internamente Linux, es decir, la operación que

realiza es la de transformar el patrón que se ha proporcionado en la línea de
comandos, sustituyéndolo por el conjunto de ficheros que han cumplido nuestras
necesidades.
Linux 02
Estos comodines se pueden utilizar para todo tipo de comandos. Por ver otro
ejemplo distinto, se podría usar el comando echo, cuya misión consiste en producir
un eco en la pantalla de lo que se introduzca por teclado:
echo hola mundo
Simplemente mostraría este mensaje en la pantalla. Pero si se empleará la misma

orden para listar archivos nuestra opción preferida será el comando ls desde un
directorio se podría escribir:
Figura 2.7. Ejemplo del comando echo utilizando el comodín *.
Como resultado se mostrarían los ficheros o subdirectorios que ha encontrado en

nuestro directorio activo que comienzan por la letra D.
Además de estos metacaracteres que son utilizados directamente por nuestra shell,
existen otros que se utilizan para definir patrones de búsqueda de texto y que son
denominados expresiones regulares y pueden ser utilizados para comandos de
búsqueda tipo grep o para usar en editores de texto como vi pero estos se explican
más adelante.
2.1.5. Otros aspectos importantes

Todos los sistemas Linux tienen un archivo de arranque que por norma general se
puede localizar en /etc/profile.
Este archivo contiene los valores de unas variables importantes para la shell
denominadas variables de entorno de shell. Además, se ejecutan los archivos de
arranque de la shell que son unos archivos ocultos y se encuentran en el directorio
de cada usuario (~/.profile).
A continuación, se muestran dos tablas (figuras 2.8 y 2.9) donde aparecen las
principales variables de entorno y los archivos de arranque de las shell Bash y TC.
Formación Abierta
Variable Función
CDPATH Nombres de alias de directorios a los que se accede mediante el comando cd
EDITOR Editor predeterminado que utilizan los diferentes programas
HOME Directorio inicial de cada usuario
MAIL Nombre del archivo que contiene el buzón de correo del sistema
PWD,cwd Muestra el directorio actual
ENV Ruta donde se buscan los archivos de configuración
PATH Directorios en los que la shell busca los programas o comandos
TERM Tipo de terminal de consola que utiliza el usuario
Figura 2.8. Variables de entorno de la Shell.
Archivo Función
/etc/profile Se ejecuta de forma automática
~/.bash_profile, ~/.bash_login, ~/.profile Se ejecuta de forma automática
~/.bashrc Se ejecuta de forma automática
~/.bash_logout Se ejecuta de forma automática al desconectar
~/.bash_history Guarda las órdenes de la última sesión
Fuente de directorios iniciales para abreviaturas

/etc/passwd
del tipo ~nombre
~/.cshrc o ~/.tcshrc Se ejecuta siempre que arranca una shell
~/.cshdirs Se ejecuta después de .login en tcsh
Se ejecuta después de la desconexión en csh o

~/.logout
tcsh
Figura 2.9. Archivos de arranque de las Shell Bash y TC.
Si se está utilizando Bash, cuando se establece la conexión primero se ejecutan las

órdenes del archivo /etc/profile, si es que existe. A continuación, buscaría el
archivo ~/.bash_profile, ~/. bash_login o ~/.profile, por este orden ejecutando los
comandos que contengan.
Cuando se finaliza un Bash de conexión se ejecutaran los comandos encontrados

en ~/.logout.
Cuando se pone en marcha una Shell Bash en modo interactivo, se ejecutan las
órdenes del archivo ~/.bashrc, si es que el archivo existe.
Por último, antes de empezar a explicar los comandos en el siguiente capítulo se

hablará del comando su.
Linux 02
Una de las recomendaciones generales que se hacen a los usuarios que están
comenzando con Linux, es que nunca trabajen de forma habitual con el usuario
administrador (root) y que solo lo utilicen cuando sea realmente necesario.
Mientras tanto, trabajar con el usuario con derechos limitados.
Con esta medida de precaución seguramente se evitarán muchos problemas que

puedan causar por uso indebido, incorrecto o sin intención de determinados
comandos que pueden causar daños irreparables al sistema. Además, hay que
recordar que Linux es un sistema operativo multiusuario, con lo cual el peligro es
exponencial.
Una vez dicho todo esto, se debe saber que en la línea de comandos, cuando sea
nuestro usuario normal se podrían obtener permisos de root con el comando su.
Por ejemplo, con el comando sudo kedit /etc/fstab el sistema preguntará por la
contraseña de root, y una vez se haya introducido la correcta permitirá editar el
archivo /etc/fstab.
Con el comando sudo se permite ejecutar la instrucción con permisos de root pero
solo para esta línea de comandos. Para ganar privilegios de root durante toda la
sesión de la consola habrá que escribir simplemente su e introducir el password de
root.
Esto cambiará el prompt de la línea de comandos despareciendo el $ y mostrado en

#.
Formación Abierta
2.2. Comandos básicos

En la anterior introducción a la shell y la línea de comandos ya se ha ejecutado
algún comando para realizar operaciones muy concretas que han ayudado a
comprender un poco mejor lo que se estaba aprendiendo.
Pero ahora ha llegado la hora de empezar a probar comandos que partiendo de

nuestro nivel sencillo de conocimientos nos van a empezar a resultar útiles.
El comando podría ser un ejecutable binario (como un archivo .EXE de los sistemas
Windows) o podría ser un comando que formara parte de la consola.
Se escribe nuestro primer comando de ejemplo, el comando whoami, y se ejecuta

pulsando la tecla Intro, primero de forma correcta y a continuación de forma
incorrecta introduciendo por ejemplo whoammi para ver qué es lo que ocurre:
Figura 2.10. Comando whoami.
Con el comando correcto se ha devuelto el nombre del usuario para conectar al

iniciar sesión.
Con el comando incorrecto Bash se está queriendo decir que no hay ningún
comando llamado whoammi.
Bash tiene una utilidad de histórico de comando a la que se podrá acceder pulsado
la tecla con la flecha hacia arriba y de esta forma por ejemplo, en este caso se
podría corregir rápidamente nuestro error.
Linux 02
En nuestro caso el error es producido porque se ha tecleado mal el comando pero

podría ser que el comando no estuviera localizado entre los directorios configurados
en la variable temporal $PATH que contiene los directorios más habituales donde
se encontrarán los binarios ejecutables.
En las próximas páginas se explican una serie de comandos básicos organizados

en las operaciones más comunes que se suelen realizar.
2.2.1. Para obtener ayuda

Desde el entorno gráfico, la primera ayuda que se pueden encontrar es pulsando la
tecla F1, que en función de si se está trabajando con un escritorio GNOME o KDE
mostrará el texto de ayuda de la interfaz respectiva.
Hay que centrarse en la línea de comandos donde se encuentran herramientas

preparadas para explicar el funcionamiento y diferentes opciones de los comandos,
o a encontrar el comando que se necesite.
El comando man va a ayudar a saber qué posibilidades ofrece el comando que se

ponga a continuación. Un ejemplo típico sería: $ man ls
Este comando se explica en el capítulo siguiente pero básicamente sería para el

contendido de un directorio. Así pues, el comando man nos ofrecerá información
sobre las posibilidades del comando ls.
Por lo general, todos los comandos dispondrán de página man, pero si alguno no lo
tuviera, se recibirá el aviso correspondiente y nuestra siguiente opción sería utilizar
el modificador --help para obtener la información que deseamos: $ ls –help.
El comando man también puede resultar útil para conocer Linux en general y
bastaría con escribir simplemente: $ man intro.
Se puede utilizar también el modificador –K para buscar una palabra dentro de

todas las páginas man de nuestro host: $ man –K user
Buscará la palabra clave user dentro de todas las páginas man disponibles y nos
devolverá un listado que contienen dicha palabra.
Si se quiere hacer una búsqueda más rápida (man puede resultar muy lento en
ocasiones puesto que tiene que buscar en todo el host) hay dos comandos más
sencillo que se pueden utilizar.
Con el comando whatis se buscarán palabras completas en una base de datos

resumida de comandos y disponible en la mayoría de distribuciones Linux. En la
figura 2.11 se puede observar el resultado de introducir el comando whatis ls
donde da información de las funciones del comando ls, concretamente listar
contenidos de los directorios.
Formación Abierta
Con el comando apropos también se puede buscar en la misma base de datos

pero se buscan cadenas en vez de palabras completas. En la figura 2.11 se puede
observar el resultado de ejecutar el comando apropos whoami donde dice que
después de haber buscado en toda la base de datos solo ha encontrado un
comando junto con la función que realiza.
Figura 2.11. Comando apropos whoami.
Por último, el comando info puede dar una información mucho más detallada de la
funcionalidad y las opciones de los comandos. Si por ejemplo se ejecuta el
comando info ls para conocer más a fondo el comando ls se encontraría el
siguiente resultado:
Figura 2.12. comando info ls.
Mostrará una información muy extensa del comando ls. Casi se podría decir que es
un pequeño manual de este comando.
Linux 02
Por último, un comando muy importante que cabe destacar sería el comando clear
que borrará el contenido de la pantalla.
Comandos utilizados en este capítulo:
F1
man (-K)
--help
whatis
apropos
info
clear
2.2.2. Comandos para moverse por el terminal

No todo van a ser comandos para ejecutar en la terminal, también existen una serie
de combinaciones de teclas que nos van a ayudar en nuestras tareas de trabajo
diario con nuestro emulador de terminal. A continuación, algunos de los más
importantes:
Ctrl + a Mueve el cursor al principio de la línea de comandos

Ctrl + e Mueve el cursor al final de la línea de comandos
Ctrl + c Mata el proceso que se esté ejecutando
Ctrl + u Elimina la línea donde esté el cursor
Alt + f Mueve el cursor una palabra hacia adelante
Alt + B Mueve el cursor una palabra hacia atrás
Ctrl + w Elimina la palabra que esté delante del cursor
Ctrl + l Borra todo el contenido del terminal
Shift +Ctrl + c Copia el fragmento seleccionado al portapapeles
Shift +Ctrl + v Pega el fragmento del portapapeles
Flecha arriba/abajo Recupera comandos escritos
2.2.3. Comandos para apagar y reiniciar el sistema

Para detener correctamente un sistema, el superusuario dispone de varios
comandos para poder realizar dichas tareas: shutdown, halt y reboot. Tanto halt
como reboot detienen el sistema, la diferencia es que reboot lo reinicializa.
Formación Abierta
Comando shutdown
El comando shutdown va a detener la máquina de una forma ordenada, mediante

una serie de pasos. Primero notifica a todos los usuarios conectados y bloquea el
proceso de acceso. Después se irán matando todos los procesos que estén en
ejecución, desmontar los sistemas de ficheros que existan, desactivar el área de
intercambio (swap) y a continuación se procede con lo que se haya especificado en
la orden, o reiniciarlo o detenerlo.
• shutdown [opciones] tiempo [mensaje]
El comando shutdown se utiliza para apagar el equipo. Las siguientes son las
opciones más utilizadas:
-t: indica la cantidad de tiempo que esperará para apagar el sistema

expresado en segundos.
-r: reiniciará el equipo.
-f: reinicio rápido.
-h: detener o apagar el equipo después de un shutdown.
-H: detener el equipo después de un shutdown.
-P: apagar el equipo después de un shutdown.
-k: envía el mensaje de aviso de apagado pero sin apagarlo realmente.
Las órdenes de reinicio o apagado pueden ser programadas en el tiempo. Si este

tiempo lo se quiere expresar en minutos habrá que poner por delante el signo + y si
lo se quiere hacer a una hora en concreto habrá que ponerlo con formato de reloj
de 24 horas. Si se quiere que la orden se ejecute de forma inmediata habrá que
poner un 0 o now.
Si queremos que nuestro equipo se reinicie rápidamente:

shutdown - r now.
Linux 02
Si se quiere apagar el equipo a las 23:00 y enviar un mensaje de aviso se podría

escribir lo siguiente:
Figura 2.13. Orden de apagado programado.
Para cancelar esta orden desde la misma consola habría que pulsar Ctrl+C y si se
hace desde otra consola basta con escribir el comando: sudo shutdown-c
No obstante, para consultar más información se puede escribir: shutdown –help.
Comando halt
El comando halt se utiliza para apagar el equipo. Las siguientes son las opciones
más utilizadas:
-h: detiene el sistema para apagado. No reinicia.

-r: nos reiniciará el equipo.
-f: reinicio rápido. No se comprobarán lo sistemas de archivos al
reinicializar.
-q: silencioso. No se solicita mensaje.
-s: reinicio en modo monousuario. Muy útil en algunas ocasiones.
Comando reboot
Dispone de las mismas opciones que el comando halt pero reboot simplemente
reinicia el equipo.
shutdown
halt
reboot
Formación Abierta
2.2.4. Moverse en el sistema de archivos

Las instrucciones básicas para moverse por el sistema de archivos serían: pwd y
cd.
Comando pwd
El comando pwd (print working directory) permite conocer el directorio en el que se

encuentra actualmente. Sobre todo cuando se descubre un sistema operativo como
Linux y su interfaz de comandos, donde puede pasar que no se sepa con exactitud
donde se encuentran. Este comando ayudaría a centrar nuestra posición. Por
ejemplo, si se utiliza el comando nada más abrir el emulador de terminal se
encuentra con lo siguiente: /home/usuario que indicará que se encuentra en el
directorio personal.
Comando cd
El comando cd (change directory) permite cambiar de directorio. Linux denomina

ruta (path) a los pasos que se dan para recorrer nuestro sistema de archivos. Se
pueden encontrar dos tipos de rutas:
Las rutas absolutas comienzan con el símbolo /, que representa el directorio

raíz y especifica la ubicación explícita del directorio donde se quiere
acceder. Por ejemplo /var/locals es una ruta absoluta.
Las rutas relativas nos permiten definir una ubicación relativa a donde se
encuentra o un punto de inicio. Por ejemplo, cd imágenes intentaría
acceder a un subdirectorio de nuestro directorio actual llamado imágenes.
Si no existiera daría un error.
Como se acaba de decir, al abrir el terminal se encuentra en nuestro directorio

personal pero si por ejemplo quisiera desplazar hasta el directorio bin habría que
introducir cd /bin.
De la misma forma se podrían realizar las siguientes operaciones:
Para ir a nuestro directorio personal, teclear cd

Para ir al directorio raíz, teclear cd /
Para ir un directorio superior cd..
Para ir al directorio anterior cd –
Para ir a una ruta en concreto cd /var/local, por ejemplo
Si estamos acostumbrados a trabajar con Windows nos habremos percatado que la

barra que separa los directorios se escribe al revés, utilizando la barra invertida. Al
principio cuesta un poco habituarse, pero después de un tiempo la extraña es la
barra de Windows.
Linux 02
A continuación mostraremos varios ejemplos en pantalla:
Figura 2.14. Ejemplo de navegación con el comando cd.
También se pueden hacer referencia a los archivos o directorios que estén en un

directorio utilizando rutas relativas como por ejemplo: $ ./make
Al escribir el ./ antes del comando, el make se ejecute en nuestro directorio actual.
Nuestras únicas limitaciones las marcarán los permisos que existan y que
permitirán o denegarán mover por determinados directorios.
pwd
cd
cd ..
cd -
cd /
cd /ruta_completa
Formación Abierta
2.2.5. Trabajar con archivos y directorios

Para poder copiar, mover, eliminar, listar archivos, crear directorios o modificar
permisos se podría utilizar los siguientes comandos:
Comando cp: se utiliza para copiar archivos. El funcionamiento es el mismo

que en cualquier sistema operativo. Por ejemplo:
cp archivo1 archivo2
Se está creando una copia exacta del archivo1 en el archivo2.
Comando mv: Se utiliza para mover un archivo a otra ubicación o para

renombrar un archivo. Los siguientes ejemplos:
mv archivo1 nombrecambiado para renombrar el

archivo1.
mv archivo1 /var/locals para mover el archivo a otro

directorio.
Comando rm: con este se eliminaría un archivo en concreto de un directorio.

Por ejemplo:
rm archivo1
Linux 02
Si se quiere eliminar un directorio con todo su contenido escribiríamos el

siguiente comando:
rm –rf directorio
Comando mkdir: servirá para crear directorios. Por ejemplo:
mkdir imágenes
Comando rmdir: servirá para borrar un directorio vacío. Por ejemplo:
rmdir imágenes
Comando chmod: se pueden cambiar los permisos de los archivos que

interese. Los permisos se pueden establecer para usuario, grupo y para
todo el mundo y para cada uno de ellos podremos especificar si se pueden
leer, escribir y ejecutar. Pero este tema se verá en profundidad más
adelante. Como muestra un ejemplo:
chmod g+r archivo
Formación Abierta
Estaríamos dando permisos de lectura a este archivo.

Comando chwon: permitirá cambiar a un archivo su propietario y su grupo.
Por ejemplo:
chown usuario2 archivo
Cambiaría la propiedad del archivo al usuario2.

Comando ln: permitirá realizar copias enlazadas de archivos. Es decir,
cuando un archivo se actualice, el otro lo hará de forma automática.
Comando In: ln archivo1 /directorio/archivo2
cp
mv
rm
mkdir
rmdir
chmod
chown
ln
2.2.6. Comandos para obtener información del sistema

Con las siguientes instrucciones, hay que estar preparados para obtener
información del sistema que nos pueda ser de utilidad en un momento dado:
Comando df: nos va a dar información sobre el espacio de disco del sistema
de archivos en las particiones que tengamos configuradas. Si se añade el
operador –h aún será más útil. Mostrará información sobre el tamaño total,
el usado y el disponible.
Linux 02
Figura 2.15. Ejemplo de comando df.
Comando top: proporcionará información de Linux en cuanto a los procesos

que están ejecutando, recursos, uso de la CPU, RAM, etc.
Figura 2.16. Ejemplo comando top.
Comando free: Dará información sobre la memoria libre que existe

actualmente. Añadiéndole el operador –m el resultado lo mostrará en
Megabytes.
Comando uname –a: este comando se suele utilizar sobre todo para saber
la versión del kernel que se está utilizando.
ifconfig: Dará información sobre las interfaces de red de nuestro sistema.
Este comando forma parte de la unidad donde las configuraciones de redes
en Linux.
Figura 2.17. Ejemplo de comando ifconfig.
Formación Abierta
iwconfig: Información sobre los adaptadores de red inalámbricos.

lsusb: Información sobre los buses USB y los dispositivos que estén
conectados a ellos. Cámaras digitales, memorias USB, etc.
df -h
top
free
uname -a
ifconfig
iwconfig
lsusb
2.2.7. Operaciones con ficheros y directorios

Comando ls
El comando ls merece una mención especial porque va a ser de los comandos que
más se van a utilizar. Su función es la de listar archivos de los directorios. Su
análogo en Windows sería el comando MS-DOS dir pero en Linux podemos sacar
más partido de este comando.
Como todos los comandos de Linux admite parámetros. A continuación, una lista de
ellos:
ls –a: muestra todos los archivos, incluyendo los ocultos.

ls –A: igual que el anterior pero sin mostrar los archivos . y ..
Figura 2.18. Diferencia de ls –a y ls -A
Linux 02
ls –B mostrará todos los archivos menos los utilizados para backup.

ls –color permitirá visualizar el contenido de los directorios con diferentes
colores de tal forma que así se podrá diferenciar los directorios (azul), los
links (turquesa), etc. El parámetro admite uno de estos tres sub parámetros:
ls --color=never: no usa colores nunca
ls --color=always: usa colores siempre.
ls--color=auto: usa colores solo cuando la salida es la estandar.
Figura 2.19. Diferencias al utilizar ls –color.
ls –l: mostrará toda la información sobre los archivos: sus permisos, usuario
y grupo al que pertenece, tamaño, cuando fue su último acceso, fecha y
hora de creación y por supuesto nombre del archivo. En la figura 2.20 se
puede ver un ejemplo.
ls –s: mostrará el tamaño de los archivos listados.
ls –t: ordena el listado mostrando en primer lugar los ficheros que
recientemente fueron creados o modificados. El resultado se observa mejor
si se añade el parámetro –l de tal forma que quedará ls-lt.
Figura 2.20. Diferencias entre ls –l y ls –lt.
Formación Abierta
ls –r: muestra el resultado en orden inverso, alfabética (ls –lr) o por tiempo
(ls –ltr).
ls –m: se muestran los ficheros ordenados horizontalmente y separados por
comas.
ls –x: se muestran los ficheros en columnas ordenados horizontalmente.
Figura 2.21. Diferencias entre ls –m y ls –x.
ls –R: mostrará el contenido de los directorios de forma recursiva con todos

sus subdirectorios.
Es conveniente explicar en este punto de forma introductoria cuál es la información

que se esltá ofreciendo el shell sobre los ficheros.
Cuando se ejecuta la orden ls –l para cada uno de los ficheros, la información que
ofrece empezando desde la izquierda a la derecha es la siguiente:
d indica un directorio; si la primera columna es un -, ello indica un fichero

ordinario.
rwx indica los permisos de escritura (w), lectura (r) y ejecución (x). Si por
ejemplo se tuvieran permisos rx serían permisos de lectura y ejecución,
pero no de escritura.
el nº que aparece a continuación es el número de enlaces (links) para el
fichero en cuestión.
El nombre del usuario y después el grupo de usuarios al que pertenece
dicho usuario.
Una cifra que viene a ser el número de bytes que ocupa el fichero
La fecha de creación o última actualización.
Comando cat
En Linux vamos a encontrar gran cantidad de archivos de texto y de configuración

que se va a tener que examinar para ver su contenido sin tener que editarlos, para
ello herramientas como cat van a ser útiles.
Por supuesto, para poder leer o consultar un fichero se tiene que tener permisos de
lectura como se acaba de ver unos párrafos más arriba.
El comando cat sirve para concatenar e imprimir ficheros.
Linux 02
Si por ejemplo escribiéramos en el terminal lo siguiente:
Figura 2.22. Ejemplo de utilización del comando cat.
Habría visualizado en pantalla el contenido del fichero examples.desktop.
Pero esta herramienta es muy sencilla y si el fichero tuviera un contenido muy

extenso, el texto seguiría volcándose en pantalla y desplazando esta, por lo que si
se quisiera ver alguna información anterior se tendría que volver atrás en la pantalla
mediante las combinaciones de teclas Mayus-Av Pag y Mayus-Re Pag.
Comando more
Al igual que el comando cat, el comando more nos permite visualizar en pantalla el
contenido de un fichero, con la particularidad de que more sí que permite hacer una
pausa entre pantalla y pantalla pudiendo avanzar entre ellas pulsando la barra
espaciadora.
También puede especificarse el número de líneas que se quiere mostrar y otras

opciones. Se puede obtener más información con la página man del comando.
Comando less
El comando less es el más avanzando respecto a opciones en comparación con los

comandos cat y more.
Este comando permitirá desplazar hacia delante o hacia atrás por los ficheros de
pantalla en pantalla. Cada vez que se termine una página preguntará si se quiere
ver la siguiente.
En nuestro ejemplo, el fichero tenía poco contenido pero si tuviéramos que pasar a
la siguiente página valdría con pulsar la barra espaciadora y para avanzar una
línea la tecla Intro. Para movernos hacia arriba tendríamos que utilizar la tecla B.
Formación Abierta
Para terminar con el comando se tendría que pulsar la tecla Q. Se puede aprender
más sobre este comando como siempre a través de la página man del comando.
Comandos head y tail
Como sus nombres en inglés indican, estos dos comandos van a permitir visualizar
el principio o el fin de uno o más archivos. Se podrá usar el modificador -n para
designar cuantas líneas se quieren desplegar. El número por defecto son 10.
También se puede utilizar la opción -v para imprimir siempre el nombre del archivo
como cabeza de la impresión en pantalla. El comando head es muy útil para
identificar las primeras líneas de más de un archivo. Si se escribe la siguiente orden
en la línea de comandos: head -5 /home/usuario/doc* visualizará las primeras
cinco líneas de todos los archivos en el directorio /home/usuario que empiecen con
el nombre doc.
El comando tail no será útil para leer los archivos log por ejemplo cuando se
quieran ver las nuevas entradas agregadas que obviamente siempre van al final:
tail -7 /var/log/messages visualizará las últimas 7 líneas del archivo
/var/log/messages.
También se puede usar la opción +n con el comando tail de la siguiente forma: tail
+15 /var/log/messages de tal forma que la sentencia comienza en la línea 15 y
despliega cada línea hasta el final del archivo.
Si se usa la opción -f con tail, podremos supervisar de forma interactiva como los
nuevos mensajes son añadidos al archivo log: tail -f /var/log/messages.
Para que se muestre cada nuevo mensaje al momento de ser escrito al log. Habrá
que pulsar CTRL+C para finalizar el despliegue de la pantalla.
Comando touch
El comando touch se usa para cambiar la fecha y la hora de acceso y la

modificación del archivo. Su sintaxis es la siguiente: touch [opciones] [fecha]
nombre_de_archivo.
Si el archivo no existe será creado un archivo vacío. Si no se especifica ni fecha ni

tiempo, el tiempo actual del sistema le será aplicado. Para cambiar la fecha y hora
habrá que utilizar las siguientes que se ponen a continuación:
-a cambia solamente la fecha de acceso.

-c no crea ningún fichero.
-d, --date=CADENA examina y utiliza CADENA en lugar de la fecha actual.
-m cambia solamente la fecha de modificación.
-t FECHA utiliza [[SS]AA]MMDDhhmm[ss] en lugar de la fecha actual.
Linux 02
touch fichero.log
Con este comando podríamos o crear el fichero si no existe o actualizarlo a la hora

existente. Suele ser muy útil a la hora de actualizar los ficheros de backup.
Comando du
A través de este comando se podrá conocer el tamaño de un directorio y la

jerarquía que ocupa dentro de ella.
Se va a aprender más sobre este comando mediante los siguientes ejemplos:
du –h: Nos visualizará el tamaño de los directorios

du -h dir: Visualiza los tamaños que contiene el directorio dir.
du –ah: Visualiza los tamaños del directorio actual
du -ah dir: Visualiza los tamaños del directorio dir.
du –sh: Visualiza el tamaño total del directorio actual
du- sh dir: Visualiza el tamaño total del directorio dir
Figura 2.23. Ejemplos del comando du.
ls
cat
MORE
less
head
tail
touch
du
Formación Abierta
2.2.8. Comprimir y descomprimir archivos

Existen varios comandos para descomprimir y comprimir archivos en GNU/Linux.
Los más comunes son tar, gzip, gunzip y compress. El comando zcat permite ver
el contenido de un archivo comprimido sin descomprimirlo. Para un verdadero
dominio de GNU/Linux conocer estos comandos es imprescindible.
En este capítulo se explicará el comando tar.
Comando tar
El comando tar se usa para combinar múltiples archivos en un solo archivo, pero
retiene la estructura de directorio original. Aunque fuera creado para guardar los
archivos originalmente en cintas, puede ser utilizado en cualquier medio de
almacenamiento.
Al crear un archivo tar, se tienen que usar las rutas relativas. Si la posición en el
sistema de archivos es /home/usuario y se desea guardar todos los archivos en el
directorio /home/usuario/prueba se deberá escribir la ruta como /prueba/*.
Si se intentan utilizar las rutas absolutas, las barras que preceden al nombre de los
directorios serán eliminadas. Esta medida previene que se sobrescriban los
archivos cuando se vaya a descomprimir el archivo.
Realmente el comando no comprime archivos en el sentido de ahorrar espacio en

disco sino lo que realmente hace es crear una entidad de datos de almacenamiento
que contendrá todos los archivos y su estructura jerárquica de los directorios. Esto
puede ser muy útil para hacer backups.
Por ejemplo, para crear un archivo tar conteniendo todos los archivos en el pwd
sería necesario escribir lo siguiente: tar -cf archivo.tar .
Este comando causaría que el contenido del pwd sea comprimido a un archivo tar
llamado archivo. La opción -c crea el archivo tar y la opción -f da el nombre al
nuevo archivo creado. El punto final es para expresar el directorio actual.
Se podrá ver el contenido del archivo tar usando el siguiente comando: tar -tf
archivo.tar
La opción -t causa que tar imprima los nombres de los archivos contenidos en el
paquete tar. El comando tar no solo permite crear el archivo tar, también nos
permitirá restaurar el contenido del archivo. Para extraer su archivo tar, habría que
escribir: tar -xvf archivo.tar
Aquí la opción -x le dirá a tar que tiene que extraer el contenido del archivo. La
opción -v determinará que tar imprima los archivos en pantalla en el momento que
son extraídos y la opción -f nombra el archivo tar que va a ser extraído.
Linux 02
Existen dos maneras diferentes de restaurar un archivo único. Se pueden elegir

cuáles de los archivos van a ser extraídos desde una lista de contenidos del archivo
tar: tar -xvwf archivo.tar.
La opción -w activa a tar en modo interactivo y entonces preguntará archivo por

archivo si se desea extraer o no.
Formación Abierta
2.3. Redirecciones
Cuando se ejecutan comandos en Linux, se obtienen los datos que necesitan
mediante tres archivos estándar:
• Standard Input (entrada estándar). Los programas pueden leer datos desde
su archivo estándar input, de forma abreviada denominado stdin. Por defecto,
suele ser el teclado. Los caracteres escritos a un programa, por ejemplo, editor
de textos van directos al stdin.
• Standard Output (salida estándar). Los programas pueden escribir datos a su

standard output, escrito de forma abreviada stdout. Por defecto suele ser el
terminal.
• Standard Error. Es similar al stdout pero es utilizado para los mensajes de

errores y las advertencias. De forma abreviada se escribe stderr y suele muy útil
para separar la salida de un programa de la salida de sus errores. Por defecto
escribe también en la pantalla para poder mezclar con la salida estándar y
poder hacer un seguimiento de los errores.
Otra forma de ver estos flujos de texto es que con

valores numéricos donde stdin= 0, stdout= 1 y stderr = 2.
A estas redirecciones se les llama descriptores de
archivo.
Redireccionar la salida
Esta opción la se escoge cuando se quiere que los resultados de nuestras

operaciones no se muestren por la pantalla sino que vayan dirigidas a otro destino
diferente. Por ejemplo, se podría enviar la salida del resultado de ejecutar un
comando sobre un fichero en concreto. Todas las operaciones de salida se
expresan utilizando el carácter > . Por ejemplo:
Figura 2.24. Ejemplo de redirección de salida a un fichero.
Linux 02
Con este comando se habría listado el contenido del directorio y en lugar de

mandar la salida directamente a la pantalla se ha enviado al fichero prueba.txt que
es creado en este momento para recoger los resultados. A continuación, mediante
el comando cat se muestra su contenido para comprobar que efectivamente ha
recogido la salida del comando.
El fichero prueba.txt se ha creado si es que no existía antes, ya que en este caso

el fichero hubiera sido sobrescrito sin preguntar si realmente se deseaba realizar tal
operación.
Mediante el comando >> existe la posibilidad de añadir al final del fichero y así nos
aseguraríamos que no se va a borrar nada.
ls –l >> prueba.txt
Podemos también por ejemplo volcar el contenido de un fichero en otro mediante el

comando
cat fichero1 > fichero2
En realidad, esta operación tendría los mismos resultados que
cp fichero1 fichero2
Pero nos sirve de introducción para comprobar que también podemos concatenar
varios ficheros y almacenarlos en otro:
cat fichero1 fichero2 > fichero3
También podríamos aprovechar esta característica para crear nuestros propios

ficheros con lo que escribamos directamente desde el teclado mediante el siguiente
comando
cat > fichero1
Al ejecutar este comando, permitirá escribir en pantalla hasta que se introduzca

Ctrl+d para acabar con la introducción de información y guardando la información
en el fichero que se ha puesto como parámetro.
Figura 2.25. Ejemplo de entrada de datos con redirección a un fichero.
Formación Abierta
Redireccionar la entrada
Estas operaciones por norma general se van a realizar para decirle a un comando
que no recoja la información desde el teclado, sino de un fichero. Este
redireccionamiento de entrada se expresa mediante el carácter <. No será muy
frecuente puesto que la mayoría de los comandos permiten especificar el fichero
sobre el cual operar.
Por ejemplo, si se quisieran ordenar las líneas del fichero prueba.txt se podría
escribir: sort < prueba.txt pero en realidad sería lo mismo que poner sort
prueba.txt.
Otro ejemplo más práctico podría ser el de buscar un nombre en un fichero que
contiene la agenda de contactos: grep "Cristian" < teléfonos, aquí la orden grep
toma su entrada del archivo teléfonos que se encuentra almacenado en nuestro
directorio actual, y no del teclado. El resultado se mostrará en pantalla así como si
hubiera un error.
Redireccionar la salida de errores
La salida de errores por defecto, puede ser redireccionada de forma independiente

a los otros dos. Para poder redireccionarla, hay que preceder al carácter > del
número 2, como se pone a continuación: 2 > errores.txt.
Con este comando se está ordenando que los mensajes de error y de diagnóstico,
junto con cualquier otra información que el comando esriba a su salida de error
estándar será escrita a un archivo de nombre errores.txt. La salida estándar aún
seguirá siendo la pantalla, por lo tanto la información de salida seguirá mostrando a
través del terminal.
En realidad se puede redireccionar cada flujo de salida de forma independiente si

se utiliza más de un operador de redirección en nuestras órdenes en la línea de
comandos. En el proceso de lectura de la línea de comandos, nuestro shell va a
relacionar cada símbolo de redirección y abrirá y preparará ambos archivos para
que puedan ser escritos por los respectivos flujos de información del comando.
Se puede encontrar con ocasiones en las que se desee redireccionar las salidas
stdout y stderr al mismo sitio de la primera (stdout). Se conseguiría de la siguiente
forma: 2 > &1.
De esta forma se ordena a nuestra shell que la salida 2 (stderr) la redirija al mismo
sitio donde va la salida 1 (stdout). El archivo de destino contendrá la salida
estándar del comando y los posibles errores.
Un uso corriente en la redirección de las salidas de error es enviarlas al directorio

/dev/null. El dispositivo nulo cuando es utilizando como entrada solo genera un
fin de archivo pero cuando es usado para la salida, lo que hace es eliminar
cualquier información que sea redireccionada hacia él.
Linux 02
grep configure /etc/* 2>/dev/null
Con esta sentencia grep es usado para realizar una búsqueda de todas las líneas
de los archivos que se encuentren bajo el directorio /etc y que contengan la cadena
configure. Como se ejecuta el comando con un usuario sin privilegios seguramente
se van a producir mensajes de error tipo permiso denegado. De esta forma, al
haber redireccionado la salida de errores al dispositivo nulo, solo se verán las
salidas con resultados válidos.
Por último, habría que comentar que todas las redirecciones nuestra shell las va a
interpretar por orden desde la izquierda. Es decir, si se tuviese el siguiente
comando ls –l directorio1 directorio2 2>&1 >archivo esta orden conectaría la
salida estándar de errores al mismo sitio donde va dirigida la salida estándar antes
de que fuera redireccionada hacia archivo, que en este caso era la pantalla, pero
bien podría ser a otro sitio diferente, por ejemplo, cuando más adelante se
desarrollen scripts.
Tuberías (pipes)
Como se ha podido comprobar, se utiliza el redireccionamiento de la entrada y

salida estándar para indicarle a un comando que los datos que van a ser utilizados
se obtengan o se almacenen en un fichero en lugar de utilizar la estándar. Pero se
podría ir un poco más allá y preguntarse como se podría hacer para utilizar datos
de entrada o de salida producidos por otro comando.
Como ejemplo, se puede mostrar el contenido del fichero prueba.txt y el resultado

pueda ser ordenado como se ha visto en el ejemplo de unas líneas más arriba.
Para ello, con los conocimientos que se tienen hasta ahora no habría más remedio
que ejecutar dos comandos:
cat prueba.txt
sort prueba.txt
Pero en realidad estas operaciones podrían realizarse en una conjunta puesto que
la entrada del comando sort es la salida del comando cat. Aquí es donde se
introduce el carácter | (tubería) que va a ser el que nos ayude a conectar ambas
instrucciones:
cat prueba.txt | sort

cat prueba.txt |sort –r
Formación Abierta
Figura 2.26. Ejemplos de tubería.
Se prueba la opción de la tubería con el comando sort en su forma normal de

ordenación y en la de ordenación inversa para que se puedan comprobar las
diferencias.
Por seguir utilizando ejemplos lo más prácticos posibles para una mejor
comprensión del concepto de tubería se puede usar también el siguiente: who|wc-l.
En este caso, la tubería le está indicando al shell que conecte la salida stdout del
comando de la izquierda (who) a la entrada estándar (stdin) del comando a la
derecha (wc –l). Por lo tanto, la salida del comando who es pasado al comando
wc-l.
Como resultado de este comando se podrá saber el número de personas que se

encuentran ingresadas ya que el comando who va a mostrar todas las que estén
conectadas y el comando wc va a contar las líneas de dicho resultado.
Las tuberías solo trabajan en los flujos de la salida estándar de los comandos.
Pueden ser usadas para conectar dos o más comandos con conexiones múltiples
tuberías, algo bastante frecuente en programación Linux gracias a los denominados
filtros que se estudiarán más adelante, pero como adelanto se puede comentar
que un filtro es un programa que va a leer los datos de la entrada estándar y
escribe sus resultados en la salida estándar y llevando así a cabo un filtrado a
través del sistema de tuberías.
Se amplía el ejemplo anterior para tener un comando con 2 tuberías: who | grep
ttyp | wc-l.
En este caso la salida del comando who va a ser la entrada del comando grep que
va a filtrar todas las líneas que no contengan la cadena ttyp. Por último, la salida
del grep pasará por la tubería del comando wc, que contará el número de líneas
que ha encontrado en los resultados que en nuestro caso vendrá a significar el
número de usuario que tenemos conectados en este momento a nuestra red.
Para redondear este capítulo se va a ver algún ejemplo como mezclar las
redirecciones con las tuberías para conseguir nuestros propósitos en forma de
comandos. grep "Silvia" < trabajadores | lpr -Pspr
Linux 02
En este ejemplo, el comando grep va a buscar la cadena Silvia del fichero

trabajadores que recibe como parámetro de entrada mediante la redirección.
Como resultado, envía todas las líneas que contengan dicha cadena y las recibe la
impresora mediante la tubería para que las pueda imprimir una impresora llamada
spr.
Comando tee
En muchas ocasiones se va a necesitar que la salida de un comando se realice al

mismo tiempo a la pantalla pero también a un fichero.
En el ejemplo que se observa a continuación el comando tee leerá la entrada del

teclado y a continuación la enviará a la pantalla y a los archivos fichero1 y
fichero2:
Figura 2.27. Ejemplo simple del comando tee.
Para comprobarlo, se utiliza el comando cat para visualizar los dos archivos. Hay
que recordar que para finalizar este tipo de comandos con entrada desde teclado
hay que pulsar Ctrl+D.
El comando tee seguramente se empleará para poder leer el resultado de otra

orden a través de una tubería, en lugar de coger la información del teclado.
Además, este resultado se guardará en los archivos indicados y se redirigirá a otra
orden, en lugar de sacar este resultado por pantalla.
Ejemplo del comando tee:
cat archivo1 | tee archivo2
Formación Abierta
Con este comando estaría mostrando el contenido del fichero 1 que lo recibiría
como entrada mediante la tubería el comando tee que a su vez lo muestra por
pantalla mientras lo guarda en un fichero.
Pero en este ejemplo se plantearía el siguiente problema: si hubiera algún tipo de

error se perdería en determinadas circunstancias. Para solucionar este posible
problema, y poniendo en práctica lo que se acaba de aprender con las
redirecciones anteriores: cat archivo1 2>&1 | tee archivo2
Con la opción 2>&1 conseguiremos que los mensajes de error vayan a la salida
estándar, es decir, a la pantalla.
Si se quiere evitar perder el contenido del fichero2 se tendría que añadir el siguiente
modificador del comando tee: cat archivo1 2>&1 | tee -a archivo2
A continuación se puede ver como efectivamente el resultado del comando cat es

añadido al final del archivo2:
Figura 2.28. Ejemplos con el comando tee.
Linux 02
2.4. Expresiones regulares

Las expresiones regulares se van a usarlas para poder realizar búsquedas
avanzadas dependientes del contexto. No son solo un buscador de cadenas de
texto sino que son la descripción formal de un patrón de texto.
Las expresiones regulares nos se pueden encontrar en editores de texto que se

explicará en el próximo capítulo como vi o emacs, pero también en comandos
como grep. En cuanto a lenguajes de programación se podrán utilizar en algunos
como awk, perl y sed.
Son muchas las situaciones cotidianas como usuarios o administradores un sistema

operativo Linux donde se pueden utilizar estas expresiones. Los programadores
tendrán que realizar tareas como las de comprobar si una cadena de texto es o no
una dirección de correo electrónico, una URL, una cuenta bancaria, etc. Con la
ayuda de las expresiones regulares se podrá conseguir que estas tareas sean más
llevaderas.
Al principio suele costar mucho aprender a usar este tipo de expresiones regulares
pero pronto se comprenderá todo el trabajo que nos puede ahorrar en futuras
situaciones.
Como definición se podría decir que una expresión

regular es una plantilla compuesta por unos
metacaracteres que tienen significado propio y que se
utiliza para especificar patrones regulares en operaciones
sobre cadenas de texto.
Uno de los casos más comunes y sencillos es cuando se quiere buscar por ejemplo
todos los ficheros Word en un directorio en concreto y se ha utilizado la expresión
*.doc para decirle al sistema que esos son el tipo de fichero que se está deseando
buscar. Pero una expresión regular formal es algo más complejo.
Formación Abierta
En el siguiente ejemplo se muestran las siguientes extensiones telefónicas de

compañeros dentro de una empresa:
Ext. Nombre ID. Empleado
1234 Cristina 031
2393 Silvia 084
8403 Pedro 043
1239 Jorge 033
.. .. ..
3847 Javier 083
Todos estos datos están guardados en un fichero denominado extensiones.txt.

Las registros de personas cuya extensión comience con 1 trabajarán en la oficina 1,
las que comiencen por 2 en la oficina 2 y así sucesivamente. ¿Cómo se podría
saber qué personas trabajan en la oficina 2?
Mediante una expresión regular se podría escribir el siguiente comando:
grep '^1' extensiones.txt
El resultado del comando grep utilizando expresiones regulares sería que iría a
buscar todas las líneas que empiecen por el carácter 1.
Linux 02
En una expresión regular se puede encontrar caracteres genéricos, rangos de

caracteres o exclusión de los mismos, literales y otras características adicionales.
Por ejemplo:
Metacarácter Función
. Concuerda con cualquier carácter (salvo fin de línea)
() Subexpresión o grupo
[] Conjunto de caracteres
[-] Rango de caracteres
[^] Excepto este grupo de caracteres
() Para introducir patrones de repetición
| Pode elegir entre dos expresiones
// Delimitar una expresión regular
\ Proteger el siguiente metacarácter
\w Cualquier carácter alfanumérico
\W Cualquier carácter no alfanumérico
\d Cualquier dígito
\D Cualquier carácter no dígito
\S Cualquier carácter que no sea un espacio en blanco
i Modificador para que no distinga entre mayúsculas y minúsculas
Figura 2.29. Tabla de metacaracteres.
Y ahora se ponen unos cuantos ejemplos para ver de forma práctica lo que se
acaba de explicar:
"[a-z]" El significado sería una letra en minúsculas ya que el "-"

indica un rango, que empieza por "a" y termina en "z".
"[0-9]" Lo mismo pero solo para dígitos.
"[A-Za-z]" Una letra.
"[A-Z][a-z]" Una mayúscula seguida de una minúscula.
"[^c]" Cualquier carácter excepto "c".
"[âeiou]" Una consonante.
"[a|b]" "a" o "b".
"\w" Equivale a [a-zA-Z0-9_]
"\w" Equivale a [â-zA-Z0-9_]
"/hola/i" Busca "hola" sin distinguir entre mayúsculas y minúsculas.
"\d" Equivale a [0-9]
Formación Abierta
A continuación, se explican las anclas (posición de la cadena) y los

multiplicadores (cuántas veces aparece en la cadena):
Ancla Posición de la cadena
^ comienzo de la línea
$ final de la línea
\b principio o final de una palabra
\B que no sea ni el principio ni el fin de la palabra
<> concuerda con una palabra
Figura 2.30. Tabla de anclas.
Multiplicadores Cuántas veces aparece en la cadena
* repetición de cero o más veces el carácter o subexpresión previos
+ repetición de una o más veces el carácter o subexpresión previos
? repetición de cero o una vez el carácter o subexpresión previos
{n} repetición de "n" veces el carácter o subexpresión previos
{n,m} repetición de entre "n" y "m" veces el carácter o subexpresión previos
{n,} repetición de al menos "n" veces el carácter o subexpresión previos
Figura 2.31. Tabla de multiplicadores.
Y ahora se añaden unos cuantos ejemplos:
"^[aeiou]" El significado sería una vocal al comienzo de la línea.

"[aeiou]$" Una vocal al final de la línea.
"hola$" "hola" al final de la línea.
"^$" Una línea vacía.
"\balon" "balon" al principio o final de la línea.
"hola*" "hol","hola","holaa".
"[a-z]*" Una palabra en minúsculas.
"Ûna vez.*arbol$" Una línea que comienza por "Una vez" y termina con "arbol".
"Ûna vez.*[Aa]rbol$" Una línea que comienza por "Una vez" y termina con "arbol" o "Arbol".
"hola+" "hola","holaa","holaaa"
"a{4}" "aaaa""
"a{2,4}" "aa","aaa","aaaa"
"a{2,}" "aa","aaa","aaaa",…
Linux 02
A partir de estos conocimientos se puede empezar a construir expresiones

regulares algo más complejas. Por ejemplo, para construir una expresión regular
que nos verifique el formato de las fechas escribiríamos lo siguiente:
"[0-9]{2}\/[0-9]{2}[0-9]{2}\/[0-9]{2}"
Se usa como separador de la expresión regular el carácter " / " y para ello tenemos
que protegerlo con el metacarácter " \ ". Con el resto de la expresión le se indica
que tiene dos dígitos y valdría para fecha con formato 13/06/09. Se podría mejorar
indicándole que los dígitos del día y del mes puedan tener uno o dos dígitos:
"[0-9]{1,2}\/[0-9]{1,2}[0-9]{2}\/[0-9]{2}"
No obstante aún se podría caer en errores como 9/99/07, así que en nuestro afán
de perfeccionar la expresión habría que escribir algo para que el mes no fuera
mayor de 12 y el día de 31.
En el caso del mes se escribiría:
"([1-9]|1[012])"
Con lo que se conseguiría tener un solo dígito que va del 1 al 9 o tener dos dígitos
donde el primero es un 1 fijo y el segundo puede ser 0,1 o 2.
De forma parecida, se construye una expresión para el día de la siguiente forma:
"([1-9]|[12][0-9]|3[01])"
Con lo que se dice, el día podría ser de una de las 3 siguientes formas:
un solo dígito del 1 al 9.

dos dígitos donde el primero es 1 o 2 y el segundo cualquiera entre el 9 y el
9.
dos dígitos donde el primero puede ser un 3 y el segundo sería 1 o 2.
Todo junto quedaría de la siguiente forma:
"([1-9]|[12][0-9]|3[01])\/\/([1-9]|1[012])\/[0-9]{2}"
Por último, si se tuviese que trabajar con fechas 01/01/10 habría que añadir "0?"
donde se dice que el "0" puede estar presenta o no:
"(0?[1-9]|[12][0-9]|3[01])\/\/(0?[1-9]|1[012])\/[0-9]{2}"
Formación Abierta
Para trabajar con un ejemplo donde se manejen letras y signos de puntuación

vamos a elegir la construcción de una expresión regular para comprobar una
dirección de correo electrónico. Como se debe saber, una dirección de correo tiene
un formato parecido al siguiente: nombre@dominio.extensión
(perico.perez@gmmail.com)
Bien, si se comienza con la parte que queda a la izquierda de la "@" puede estar
compuesta por caracteres alfanuméricos con posibilidad de encontrar "-", "_" o "."
: (aa.bb / abc / abc_de_fg).
Por lo tanto, para empezar esta expresión regular quedaría de la siguiente forma:
([0-9a-zA-Z]+)([._-]([0-9a-zA-Z]+))*
Que si se descompone se podría analizar lo siguiente:
([0-9a-zA-Z]+) repetición de una o más veces (+ al final) de cualquier

carácter alfanúmerico.
([._-]([0-9a-zA-Z]+) repetición de una o más veces (+al final) de una
expresión que puede ser que tenga o no los tres signos de puntuación
seguidos de cualquier carácter alfanumérico.
Con el "*" del final se está indiciando que la expresión anterior puede
repetirse 0 o más veces.
A continuación, habría que escribir la parte que queda a la derecha de la "@" . En

cuanto a la construcción del usuario sería como se acaba de ver pero habría que
añadir el "." seguido de 2 a 4 caracteres para indicar la extensión:
([0-9a-zA-Z]+)([._-]([0-9a-zA-Z]+))*[.]([0-9a-zA-Z]){2,4}
Que si se descompone se podría analizar lo siguiente:
([0-9a-zA-Z]+)([._-]([0-9a-zA-Z]+))* la misma expresión que la vista para la

construcción del usuario.
[.] un punto que va a separar el dominio de la extensión.
([0-9a-zA-Z]){2,4} una repetición de 2 a 4 veces de la expresión anterior que
pueden ser caracteres alfanuméricos.
La expresión final, añadiéndole la "@" quedaría de la siguiente forma:
"^([0-9a-zA-Z]+)([._-]([0-9a-zA-Z]+))*@([0-9a-zA-Z]+)([._-]([0-9a-zA-
Z]+))*[.]([0-9a-zA-Z]){2,4}$"
Linux 02
2.5. Filtros
Se les da el nombre de filtros al grupo de comandos que reciben alguna entrada,
realizan alguna transformación y escriben una salida.
A continuación, se explican algunos de los más utilizados.
Comando grep
Permite buscar las líneas que contienen un determinado patrón de búsqueda dentro
de uno o varios archivos y mostrar aquellas líneas donde se encuentra alguna
coincidencia. Para ello, se hace uso de las denominadas expresiones regulares que
se han comentado previamente.
Se pueden utilizar entre otros los siguientes modificadores:
• -i (ignore case) para que no tenga en cuenta la distinción entre mayúsculas y

minúsculas.
• -n para que muestre el número de línea dentro del archivo que se haya
especificado.
• -v para que muestre las líneas que no concuerdan con el patrón que se ha
suministrado.
• -c para que indique el número de ocurrencias encontradas con el patrón.
Por ejemplo, si se quiere buscar la cadena domain dentro del archivo /etc/hosts se
escribía lo siguiente:
Figura 2.32. Ejemplo de grep sencillo.
Se podrían ver los resultados obtenidos en color rojo.
Hay que tener en cuenta que como ya se ha explicado con anterioridad, se

distinguen entre mayúsculas y minúsculas. Si se quiere cambiar esta opción y que
no realice la distinción habrá que incluir el modificador –i al comando.
Formación Abierta
También se puede buscar no solo en uno sino en varios archivos utilizando el

asterisco:
Figura 2.33. Ejemplo de grep sobre un directorio.
En este caso, se ha realizado la búsqueda directamente sobre el directorio /etc y

por lo tanto en todos sus archivos de los cuales nos muestra las coincidencias.
Si se quiere que además de buscar en ese directorio buscara también en todos los
subdirectorios tendría que utilizar el modificador –r, como por ejemplo de la
siguiente forma:
grep –r domain /etc
Pero el comando grep puede hacer mucho más que estas búsquedas sencillas
haciendo uso de las mencionadas expresiones regulares:
grep “buscar.*linea” archivo1
Con este comando se buscararía la cadena buscar y luego de cualquier texto que
continúen con linea.
Para buscar las líneas que no coincidan habría que utilizar el modificador –v
grep –iv “domain” archivo1
Para contar el número de ocurrencias encontradas el parámetro –c
grep –c “domain” archivo1
Linux 02
Se contaría el número de ocurrencias de la cadena domain dentro del archivo1.
Hasta aquí se ha estado explicando el uso del comando grep para buscar cadenas
de texto pero el verdadero potencial de este comando se desarrolla a través de las
expresiones regulares.
Como ya se ha explicado anteriormente las expresiones regulares, se van a

comentar directamente algunos ejemplos:
who | grep "ûsuario"
Devolvería todas las líneas del comando who que empiezan por un patrón, en este
caso, comienzan por el nombre de usuario en concreto "usuario".
Otro ejemplo:
ls -l | grep "^…….rw"
Permitiría visualizar solo aquellos archivos procedentes del comando ls-l que
tengan permisos de lectura y escritura para el grupo otros. Como ya se ha visto con
anterioridad buscaba al principio y los puntos indican que no le importa el carácter
en esa posición.
Buscar la cadena java en el archivo compiladores. Visualizar las líneas que

igualan el patrón y su número de línea en la pantalla:
grep -n 'java' compiladores
Visualizar las líneas que terminen con kernel en el archivo milibro:
grep "kernel$" milibro
Guardar en el archivo milistado.txt todas las líneas del archivo log que empiezan
con error o dump:
grep 'êrror' log > milistado.txt
grep '^dump' log >> milistado.txt
Estas son solo algunas de las posibilidades del comando grep que además tiene
una versión avanzada de filtros en los comandos egrep y fgrep.
Como principales diferencias comentar que egrep tiene un conjunto de expresiones

regulares más completo y fgrep está optimizado para trabajar con archivos más
grandes, pero solo busca literales.
Formación Abierta
Como siempre se indica, esta es solo una aproximación de las posibilidades de este
comando. Para una visión completa habría que acudir a la página man del
comando:
man grep
Comando find
Se ha estudiado cómo se puede hacer para visualizar el contenido de un fichero o

para buscar cadenas de texto en ficheros o grupo de ficheros. Pero a través del
comando find se pueden buscar archivos de forma concreta.
El comando find es sencillo de utilizar. Un ejemplo sencillo para ver su uso.
find /etc/ -type f –iname pp*
• Se dice donde se van a buscar los ficheros. En nuestro caso en concreto, la ruta
es el directorio /etc/
• Se puede hacer uso del modificar –type para especificarle el tipo de archivo que
se está buscando. En nuestro caso se ha usado el modificador f para indicarle
que son ficheros ordinarios, pero se podría especificar una d para directorios.
• La opción –iname se utilizará para buscar un patrón independiente de

mayúsculas y minúsculas. En nuestro caso, que empiece por pp.
Estas son solo algunas de las opciones de búsqueda posible ya que también se
podrían buscar por propietario, por grupo, por permisos, fechas, etc. En todos los
casos el comando find buscará en la ubicación que se le diga y visualizará una
lista de todos los archivos que coinciden con nuestro patrón de búsqueda.
Por explicar alguna de sus propiedades más particulares, este comando también
nos puede servir para encontrar directorios o ficheros que no tienen propiedad
alguno, ni de usuarios ni a grupos:
find / -nouser –o –nogroup
Con este comando se buscaría en todo el árbol de directorios todos aquellos

ficheros que no pertenecen ni a grupo ni a usuario alguno.
Linux 02
Comando sort
El comando sort es uno de los más utilizados a la hora de crear scripts.
Su función es la de ordenar los registros o líneas de uno o más archivos. Esta

ordenación la puede realizar por el primer carácter, el primer campo de la línea o
por un campo distinto al primero en el caso de ficheros estructurados.
Se podría ordenar el contenido de un fichero de la siguiente forma:
Figura 2.34. Ordenación simple con comando sort.
Se realizaría la ordenación en nuestro caso de fichero elegido (examples.desktop)

y el resultado final se visualizaría por la pantalla.
Pero si lo que se quiere es que el resultado de la ordenación se vuelque a un

fichero habría que realizar la siguiente orden:
Figura 2.35. Ordenación con salida a otro fichero.
Si lo que se quiere es ordenar varios ficheros y guardar el resultado final en un

último fichero, el modo de operar sería idéntico salvo que habría que añadirle todos
los ficheros a continuación de la llamada al comando:
sort fichero1 fichero2 fichero3 > fichero4
Formación Abierta
Por último, si lo que se quiere es que el resultado de la ordenación se nos guarde

en el mismo fichero, habría que recurrir al primero de los modificadores que se va a
comentar para este comando: el modificador –o:
sort –o fichero1 fichero1
A continuación, se comentarán otros modificadores que pueden ser útiles cuando

se quiera usar este comando:
• -f: Este modificador servirá para convertir en mayúsculas las minúsculas.
• -n: Este modificador servirá para ordenar los campos numéricos por su valor
numérico.
• -r: Con este modificador se podrá realizar una ordenación inversa, de mayor a
menor.
• -m: Este modificador servirá para combinar aquellos archivos ya ordenados.
• -b: Este modificador servirá para descartar las espacios en blanco que
encuentre al principio.
• -d: Con este modificador la ordenación se realizará teniendo en cuenta

exclusivamente los caracteres alfanuméricos y los espacios en blanco.
Estos serían algunos de los modificadores más importantes, el resto como siempre
se puede consultar con la ayuda en línea a través del comando sort –help.
Comando tr
El comando tr va a permitir cambiar caracteres, es decir, cambiar unos caracteres

por otros.
Este comando exige que los parámetros tengan la misma cantidad de caracteres o
bien que el segundo sea un solo carácter. En este caso, reemplazará todos los
caracteres del primero por el del segundo.
Se pueden utilizar los siguientes modificadores:
• -d: Este modificador servirá para eliminar los caracteres de la primera cadena
pasada como parámetro.
• -s: Este modificador servirá para eliminar los caracteres repetidos de la primera
cadena pasada como parámetro.
• -c: Este modificador servirá para eliminar los caracteres que no coincidan con la
primera cadena pasada como parámetro.
Linux 02
A continuación, algunos ejemplos:
tr "a-z" "A-Z" < archivo
Transformará todas las minúsculas en mayúsculas.
Otro ejemplo:
cat archivo | tr -c ’a-zA-Z’ ’\n’ | tr ’A-Z’ ’a-z’ | sort -u
En primer lugar el comando convertirá todo aquello que no sean letras en "\n" que
es el salto de línea. A continuación, todas las mayúsculas en minúsculas y por
último, el comando sort las ordenará alfabéticamente eliminando las que sean
iguales con lo que se obtendrá finalmente una línea por cada palabra original del
archivo "archivo".
grep
sort
find
tr
Formación Abierta
2.6. Editores de texto

Como se ha podido apreciar, gran parte de la administración del sistema operativo
Linux la se va a poder realizar mediante la elaboración de comandos más o menos
especializados. Para ello, podemos crear un archivo de guión donde se pueda
incluir todos los comandos que se quiera ejecutar dentro de un solo fichero. Para
ello se necesitarán los editores de texto.
Obviamente también servirán para la función de editar un fichero de texto y poder

realizar modificaciones.
Los editores de texto que se van a explicar a continuación basan su funcionamiento

en acciones introducidas mediante órdenes de teclado, que pueden ser, tanto teclas
pulsadas de forma individual o por combinaciones de teclas que se pulsan
simultánea o secuencialmente. Es obligatorio emplear una sintaxis correcta para
estas órdenes y aunque al principio sea un poco complejo al final se acaba
acostumbrando a emplearlas.
Cada uno deberá elegir el editor con el que más a gusto se sienta a la hora de
trabajar. Desde un punto de vista práctico, los dos editores más populares son vi y
emacs, adecuados para realizar tareas más complejas de edición. Pero para
aprovechar esa potencia habrá que aprenderse las órdenes necesarias para
realizar esas tareas.
2.6.1. Editor vi
El editor vi de Linux tiene la gran mayoría de opciones habituales de un editor de
textos y destaca por la gran flexibilidad a la hora de crear archivos de texto. Es más
complejo que otros editores un tanto más simples pero va a dar la posibilidad de
trabajar con ficheros de tamaño más grande.
La mejor manera de explicar un editor de texto es mediante un ejemplo guiado.
Se va a crear un archivo de guión, que como ya se ha comentado es un archivo que

va a contener órdenes de la shell que se irán ejecutando una detrás de otra para
que luego puedan ser procesadas todas de una vez.
1. Desde la sesión actual de terminal, se arranca el editor vi escribiendo

directamente el nombre del archivo que se va a crear o modificar: vi
programa.
2. Pulse A, escriba ls -la y pulse INTRO.
3. Escriba who y después pulse INTRO.
4. Escriba pwd y después pulse INTRO.
Linux 02
5. Escriba: wq y antes de pulsar INTRO compruebe que está viendo lo mismo

que en la figura 2.37.
Figura 2.36. Ejemplo de edición con vi.
6. Ya en la línea de comandos, escriba sh programa, pulse intro y compruebe

como se ejecutan todos sus comandos.
Las operaciones que se pueden realizar con el editor vi son de dos categorías:
• Modo de edición, que permitirán introducir el texto.
• Modo comando, que constaran de una sucesión de combinación de teclas para

dar órdenes al editor para que realice operaciones.
Del modo edición al modo comando, se pasa con la tecla ESC. Del modo comando
al modo de edición se puede pasar con alguno de los siguientes caracteres
(i,I,a,A,o,O). Por defecto, al entrar en el editor vi se entra en modo comando.
Una cosa a tener en cuenta es que conviene estar el máximo tiempo posible en
modo comando ya que con esto se pueden evitar modificaciones no deseadas en
el texto. Cuando se quiera dejar de escribir, por tanto, una buena práctica será
pulsar ESC.
Para invocar al editor vi se puede hacer de las siguientes formas:
• $vi, editaremos un texto sin nombre.
• $vi archivo, editaremos un archivo (nuevo o no).
• $vi archivo1 archivo2, editaremos una lista de archivos.
• $vi +n archivo, editaremos el archivo en la línea n.
• $vi +/txt archivo, editaremos el archivo en la 1ª línea donde aparece el texto

"txt"
Formación Abierta
Para poder realizar movimientos con el cursor:
i Pasar a modo edición 0 Inicio de línea
h Desplazará el cursor una posición a la izquierda $ Fin de línea
j Desplazará el cursor a una línea inferior w Avanza palabra
k Desplazará el cursor a una línea superior b Retrocede palabra
l Desplazará el cursor una posición a la derecha e Final de la palabra
H Esquina superior izquierda ctrl+u Subir ventana
l Esquina inferior izquierda ctrl+d Bajar ventana
ctrl+b Retroceder página ctrl+f Avanzar página
Para poder insertar y borrar texto:
i Insertar delante del cursor I Insertar al principio de la línea
a Añadir detrás del cursor A Añadir al final de la línea
o Insertar una línea debajo O Insertar una línea encima
x Borrar carácter actual X Borrar carácter anterior
dd Borrar línea actual D Borrar hasta final de línea
dw Borrar palabra
Para poder copiar y pegar texto:
yy Copiar en el buffer la línea actual nyy Copiar n líneas desde la actual
p Pegar el buffer detrás del cursor P Pegar el buffer delante del cursor
Para poder realizar operaciones con los archivos:
Graba las modificaciones

:w :q Salir (si no hay cambios)
efectuadas
:q! Salir sin grabar :wq Guardar cambios y salir
Cierra vi, guardando el archivo solo si se han

:w! Escribe el texto encima del
ZZ hecho cambios desde la última vez que se ha
archivo que hubiera en el archivo
guardado el archivo
Otro ejemplo para practicar algunos de los comandos anteriormente citados.
1. Desde la sesión actual de terminal, se arranca el editor vi escribiendo

directamente el nombre del archivo que se va a crear o modificar: vi
programa2
2. Introduzca el siguiente texto:
Linux 02
3. Esto es la primera línea
4. Esto es la tercera línea
5. Ahora se quiere incluir una línea en medio de las dos que diga Esto es la
segunda línea. Para insertar la línea que falta se podría hacer de tres
formas:
{ Ir a la primera línea. Ir al final de ella con $ o pulsando l hasta llegar al

final. Pulsar A para añadir. Pulsar intro. A escribir
{ Ir a la primera línea y pulsar o. Esto inserta una línea debajo y pone el
cursor en ella y ya se puede escribir.
{ Ir a la segunda línea y pulsar O. Esto insertará una línea encima y
pondrá el cursor en ella y ya se puede escribir.
En definitiva, esta solo es una aproximación al editor de texto vi. Solo el manejo
diario de esta herramienta llevará a utilizarlo con soltura.
2.6.2. Editor EMACS

El editor emacs es el más completo y con más posibilidades de personalización de
los editores de texto para LINUX y va a permitir una gran flexibilidad y control sobre
nuestros archivos de texto.
Algunas de las características por las que destaca sobre el resto son las siguientes:
Reconocimiento de formatos. Posibilidad de detectar que cierto fichero

sigue determinada sintaxis de tal forma que, una vez reconocido el formato
al que se ajusta se pueda proporcionar ciertos comandos útiles para este
tipo de documentos, así como resaltar mediante procedimientos tráficos la
sintaxis del documento, distinguiendo entre instrucciones y datos.
Facilidad de configuración y personalización. Se pueden crear mandatos
nuevos, crear combinaciones de teclas diferentes a las que vienen por
defecto, modificar variables propias de Emacs, etc.
Extensibilidad. Existen numerosos paquetes de ampliación para emacs
que permitirán reconocer nuevos formatos haciendo que sirva para casi
todo: paquetes para convertir a Emacs en un lector de correo electrónico,
lector de noticias, calendario, etc.
Formación Abierta
La sintaxis de órdenes que se pueden introducir por teclado es distinta a la utilizada

por vi y más compleja, ya que hace uso de caracteres antepuestos. Los conceptos
de posición de punto y de cursor propios de este editor son más específicos y
depurados que los de vi. En emacs, el punto es el lugar del búfer donde de está
realizando la operación de edición en cada momento: se supone que el cursor se
encuentra a la izquierda del cursor, o que está siempre entre letras o espacios en
blanco.
Esta diferencia pasa a ser una cuestión muy importante cuando se quieren emplear
opciones de cortar, pegar y copiar. Por ejemplo, en vi, quitar elimina el texto del
búfer principal mientras que emacs es más parecido a pegar en el búfer principal.
Es un editor de texto de pantalla completa, en el cual se van a utilizar órdenes del

teclado que van a estar precedidas o por la tecla Ctrl o por la tecla ESC. La pantalla
típica constará de una zona de introducción del texto con una zona pequeña en la
parte inferior de la pantalla que recibe el nombre de línea de modo donde se
mostrará información referida al editor.
Las opciones de arranque serían las siguientes:
+n Empezar a editar en la línea n del archivo
-nw Ejecutar sin abrir una ventana
Si no se pasa ninguna opción o archivo como parámetro al llamar al editor,

directamente se abre el programa emacs y empezará a editarse un nuevo búfer.
En el siguiente cuadro, se ven algunas de las órdenes más importantes en relación

al funcionamiento propio del editor emacs:
Ctrl-X+Ctrl-C Salir de emacs Ctrl-G Cancelar la orden actual
Guardar un búfer que no se haya

Ctrl-X+Ctrl-W Ctrl-X+Ctrl-S Guarda el búfer
guardado previamente
Deshacer la última opción. Se puede Visualiza la información

Ctrl-X+U Ctrl-H
utilizar múltiples veces si es necesario de ayuda
Inserta el texto de un archivo en la Borra todas las ventanas

Ctrl-X+I Ctrl-X+1
posición actual del cursor menos esta
Además de las órdenes de propósito general, emacs va a ofrecer órdenes

importantes de edición y de desplazamiento del cursor, que van a permitir
movernos rápida y fácilmente por el texto y de esta forma poder realizar
modificaciones sobre él.
Linux 02
En el siguiente cuadro se van a ver algunas de estas órdenes de edición y

desplazamiento:
Desplazar el cursor al principio del Desplazar el cursor hacia el final del

Esc-< Esc->
búfer búfer
Desplazar el cursor hasta el principio Desplazar el cursor hasta el final de

Ctrl-A Ctrl-E
de la línea actual la línea actual
Desplazar el cursor hacia delante Desplazar el cursor hacia atrás

Esc-F Esc-B
palabra por palabra palabra por palabra
Borrar el carácter en el que se Borrar la palabra en la que se

Ctrl-D Esc-D
encuentra el cursor encuentra el cursor
Esc- Borrar la palabra que precede al Borrar desde el cursor hasta el final
Ctrl-K
Retroceso cursor de la línea en curso
Devolver al búfer lo que se había

Ctrl-Y
borrado
Una vez explicados los comandos más habituales de funcionamiento y de edición

se ponen en práctica con ejemplo guiado.
En el siguiente ejercicio se crea un archivo de texto:
1. Desde la sesión actual de terminal, vamos a arrancar emacs mediante el

comando emacs mifichero y después pulsar INTRO.
2. Comience a escribir alicia dir/w="ls"
3. Mantenga pulsadas las teclas CTRL y A. El cursor se desplaza al principio

de la línea.
4. Mantenga pulsadas las teclas ESC y D. La palabra ALICIA se ha borrado del

búfer.
5. Escriba alias.
6. Mantenga pulsadas simultáneamente las teclas ESC y B. El cursor se

desplaza hasta el principio de la palabra alias.
7. Utilice las teclas de la flecha para moverse hasta la siguiente línea en blanco.
8. Mantenga pulsadas las teclas CTRL y Y. La palabra cortada ALICIA se

pondrá al principio de la línea.
9. Utilice las teclas de flecha para situar el cursor al final de la palabra ALICIA
si todavía no está allí.
Formación Abierta
10. Utilice la tecla RETROCESO para borrar las letras C,I y A de la palabra
ALICIA.
11. Escriba as copy="cp"
12. Mantenga pulsadas simultáneamente las teclas CTRL y X y después

mantenga pulsadas simultáneamente las teclas CTRL y C para salir de
emacs y volver al shell.
Este solo ha sido un ejemplo muy sencillo de introducción al editor de textos emacs
puesto que el objetivo de este capítulo no es conocer a fondo todas las
posibilidades que pueda ofrecer emacs sino darlo a conocer al lector para que
pueda comparar de forma simple con el editor de textos vi.
Linux 02
• Resumen
• Las diferentes shell de GNU/Linux y cómo se puede cambiar de una a otro

según nuestros gustos personales.
• Ejemplos, prácticos con los principales comandos para realizar diferentes

operaciones en un entorno doméstico.
• Los conceptos de redirección de la información y los diferentes comandos con

los que se pueden realizar estas funciones.
• El conocimiento de las expresiones regulares para ayudar a poder realizar

instrucciones más complejas con objetivos más ambiciosos.
• Los editores de texto vi y emacs para poder editar textos de una forma sencilla e
interactiva.

Linux: Introducción Al Shell

Cargado por

Copyright:

Formatos disponibles

Linux: Introducción Al Shell

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Linux: Introducción Al Shell

Cargado por

Copyright:

Formatos disponibles

02 Linux

• Comprender el funcionamiento de la línea de comandos.

• Aprender a realizar tareas sencillas de un modo alternativo al entorno gráfico.

• Profundizar en los conocimientos sobre algunos de los comandos más

• Comprender el concepto de redirecciones en entrada y salida de procesos.

• Introducción al uso de expresiones regulares y filtros.

• Conocer los principales editores de Unix y realizar operaciones básicas con

También explicará cómo poder redireccionar la entrada y la salida de la información

Para optimizar y potenciar el uso de estos comandos se detallan el uso de las

2.1. Funcionamiento de la línea de

En cuanto al entorno gráfico se puede decir a modo de introducción que es una

Si se está utilizando Ubuntu, se puede encontrar un emulador de terminal desde el

Figura 2.1. Emulador de terminal.

Figura 2.2. GNOME terminal.

Si se estuviera trabajando con una distribución KDE, se podría utilizar la aplicación

En la pantalla del emulador de terminal que se ha abierto, encontramos un prompt

En la mayoría de las distribuciones, este prompt se construye desde la izquierda

El resultado por partes que se puede observar en la figura 2.2 es el siguiente:

 En nuestro caso, "usuario" es el nombre del usuario con el que se realiza la

En este capítulo se hablará de su funcionamiento básico pero es muy importante

La shell interpretará nuestras órdenes suponiendo que la primera palabra de la

De forma resumida, las tareas de shell serían las siguientes:

 Interpretar las variables de entorno. Las variables de entorno son regiones

Una característica a tener en cuenta con respecto a usuarios procedentes de

2.1.2. Las diferentes Shell en Linux

Nombre Comando Ubicación

Bourne Again Bash /bin/Bash

Shell de TC tcsh /bin/tcsh

Shell de C csh /bin/csh

Shell de Korn ksh /bin/ksh

Shell de Z zsh /bin/zsh

Figura 2.3. Shells y ubicaciones.

La selección de una shell es una cuestión no solo de gustos sino también de

A continuación, algunas de las razones principales de porqué bash suele ser la

2.1.3. Cómo cambiar de shell

Figura 2.4. Pantalla con comando echo $Shell.

Como se puede nuestro ejemplo, la shell que se está utilizando es Bash.

Figura 2.5. Comando more /etc/shells.

Para cambiar el shell desde nuestra consola de comandos se deberá de utilizar el

 De forma interactiva para la cual solo se tendría que introducir el comando y

Si se cierra el emulador de terminal o se reinicia el sistema, se vuelve a tener una

Figura 2.6. Ejemplo chsh -s /bin/sh.

2.1.4. Introducción a ficheros especiales y caracteres

El sistema de ficheros de Linux y de Unix es una organización jerárquica de ficheros

Grosso modo, podría encontrarse con tres tipos de ficheros:

En cuanto a ficheros ordinarios, podrán encontrarse diferentes tipos:

 textual (contienen caracteres ascii y no son ejecutables).

 /dev/tty Pantalla del superusuario

Existen otros ficheros especiales que también se usarán frecuentemente y que

 * Describe una cadena con cero o más caracteres.

Con los siguientes ejemplos se verá un poco más claro:

Aunque no se ha visto aún, el comando cat visualiza por pantalla el contenido de

En realidad esta operación la realiza internamente Linux, es decir, la operación que

echo hola mundo

Simplemente mostraría este mensaje en la pantalla. Pero si se empleará la misma

Figura 2.7. Ejemplo del comando echo utilizando el comodín *.

Como resultado se mostrarían los ficheros o subdirectorios que ha encontrado en

2.1.5. Otros aspectos importantes

CDPATH Nombres de alias de directorios a los que se accede mediante el comando cd

En nuestro caso, "usuario" es el nombre del usuario con el que se realiza la

Interpretar las variables de entorno. Las variables de entorno son regiones

De forma interactiva para la cual solo se tendría que introducir el comando y

textual (contienen caracteres ascii y no son ejecutables).

/dev/tty Pantalla del superusuario

* Describe una cadena con cero o más caracteres.

Ctrl + a Mueve el cursor al principio de la línea de comandos

-t: indica la cantidad de tiempo que esperará para apagar el sistema

-h: detiene el sistema para apagado. No reinicia.

Las rutas absolutas comienzan con el símbolo /, que representa el directorio

Para ir a nuestro directorio personal, teclear cd

Comando cp: se utiliza para copiar archivos. El funcionamiento es el mismo

Comando mv: Se utiliza para mover un archivo a otra ubicación o para