Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 1 of 13

Preparación para el examen 101 de LPI: Comandos

GNU y UNIX
Tema 103 del examen de Administración de Nivel Junior (LPIC-1)

Uso de la línea de comandos

Esta sección cubre materiales correspondientes al tema 1.103.1 del examen 101 de Administración de Nivel Junior (LPIC-1).
Este tema tiene un valor de ponderación de 5.
Esta sección tratará los siguientes temas:

Interacción con shells y comandos usando la línea de comandos

Comandos y secuencias de comandos válidos

Definición, referenciación y exportación de variables de entorno

Historial de comandos y facilidades de edición

Invocación de comandos dentro y fuera de la ruta

Uso de la sustitución de comandos

Aplicación recursiva de comandos a través de un árbol de directorios

Uso de páginas man (manuales) para aprender sobre comandos

Esta sección proporciona una breve introducción a algunas de las principales características del shell bash y se detiene
especialmente en las características más importantes a fines de la certificación. Sin embargo, shell es un entorno muy rico y se
recomienda explorarlo con mayor profundidad. Existen muchos manuales excelentes dedicados a shells de UNIX y Linux y al
shell bash en particular.

El shell bash
El shell bash es uno de los numerosos shells disponibles para Linux. También recibe el nombre de Bourne-againshell, en
honor a Stephen Bourne, creador del shell inicial (/bin/sh). Bash es básicamente compatible con sh pero además proporciona
varias mejoras tanto en las capacidades de funciones como en las de programación. Bash incorpora características del shell
Korn (ksh) y del shell C (csh) y está diseñado en conformidad con el estándar POSIX.
Antes de ahondar en bash, recuerde que un shell es un programa que acepta y ejecuta comandos. También soporta
construcciones de programación que permiten la construcción de comandos complejos a partir de partes más pequeñas. Estos
comandos complejos, o scripts, pueden guardarse como archivos para convertirse en comandos en sí mismos. De hecho,
muchos de los comandos dentro de un típico sistema Linux son scripts.
Los shells tienen una serie de comandos incorporados como cd,breakyexec. Otros comandos son externos.

Los shells también usan tres flujos de entrada/salida estándar:

stdin es el flujo de entrada estándar y proporciona los datos de entrada a los comandos.

stdout es el flujo de salida estándar y muestra los datos de salida de los comandos.

stderr es el flujo de error estándar y muestra datos de salida de error de los comandos.

Los flujos de entrada proporcionan datos de entrada a los programas, normalmente a partir de la pulsación de teclas de la
terminal. Los flujos de salida imprimen caracteres de texto, normalmente a una terminal. La terminal originalmente era un
typewriter ASCII o una terminal de visualización, pero en la actualidad es más frecuente que se trate de una ventana en un
escritorio gráfico. En una sección posterior de este tutorial, Flujos, canalizaciones y redireccionamientos, se analiza con
mayor profundidad el redireccionamiento de estos flujos de entrada/salida estándar. A continuación, esta sección se centrará
en el redireccionamiento en el nivel superior.
En adelante, este tutorial considerará que usted sabe cómo obtener un shell prompt. De lo contrario, consulte el artículo de
developerWorks "Basic tasks for new Linux developers" que le explicará éste y muchos temas más.
Si usted usa un sistema Linux sin escritorio gráfico o si abre una ventana de terminal en un escritorio gráfico, visualizará un
prompt igual o similar a alguno de los mostrados en el Listado 1.

Listado 1. Algunos prompts de usuario típicos

[db2inst1@echidna db2inst1]$ ian@lyrebird:~>
$

Si inicia sesión como usuario root (o superusuario), su prompt probablemente sea como el mostrado en el Listado 2.

Listado 2. Ejemplos de prompt en superusuario o usuario root

Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 2 of 13

[root@echidna root]# lyrebird:~ #

#

El usuario root tiene mucho poder, por lo cual se recomienda ser cuidadoso al usarlo. Con privilegios root, la mayoría de los
prompts incluirán un signo numeral (#) añadido. Los privilegios de usuarios comunes suelen delinearse con un carácter
diferente, a veces un signo de moneda ($). Su prompt puede ser distinto a los ejemplos proporcionados en este tutorial. Su
prompt podría incluir su nombre de usuario, nombre de host, directorio actual, fecha u hora de impresión del prompt, etc.

Convenciones de este tutorial

Estos tutoriales de developerWorks acerca de los exámenes 101 y 102 de LPI incluyen ejemplos de código copiados y
pegados de sistemas Linux reales que usan los prompts predeterminados de dichos sistemas. Nuestros prompts root tienen un
# añadido y los prompts de usuarios comunes tienen un $ añadido. Esta convención se utiliza en muchos manuales acerca de
este tema. Observe con atención los prompts de ejemplo.

Comandos y secuencias
Ahora que tenemos el prompt, veamos qué podemos hacer con él. La principal función de shell es interpretar los comandos
para permitirle interactuar con su sistema Linux. En los sistemas Linux (e UNIX), los comandos tienen un nombre de
comando y cuentan con opciones y parámetros. Algunos comandos no tienen ni opciones ni parámetros, otros tienen opciones
pero carecen de parámetros, y otros carecen de opciones pero tienen parámetros.
Cuando una línea contiene un carácter #, todo el resto de los caracteres de la línea se ignoran. Entonces, el carácter # puede
estar indicando tanto un comentario como un prompt root. El contexto indicará claramente de qué caso se trata.
Echo
El comandoechoimprime sus argumentos (o hace eco de ellos) a la terminal, como muestra el Listado 3.

Listado 3. Ejemplos de Echo

[ian@echidna ian]$ echo Word Word [ian@echidna ian]$ echo A
phrase A phrase [ian@echidna ian]$ echo Where are my spaces? Where are my
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
spaces? [ian@echidna ian]$ echo "Here are my spaces." # plus comment Here are my
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
spaces.

En el tercer ejemplo del Listado 3, todos los espacios sobrantes se comprimieron en un único espacio en los datos de salida.
Para que esto no suceda, debe colocar comillas en las cadenas, ya sean dobles (") o simples ('). Bash usa el espacio en blanco,
como los espacios vacíos, las tabulaciones y los caracteres de nueva línea, para separar la línea de entrada en tokens, que
luego se pasan al comando. Colocar las cadenas entre comillas conserva el espacio vacío adicional y convierte a toda la
cadena en un único token. En el ejemplo anterior, cada token posterior al nombre de comando es un parámetro, por lo tanto,
tenemos los parámetros 1, 2, 4 y 1, respectivamente.
El comando echo tiene algunas opciones. Generalmente, echo anexará a los datos de salida un carácter de nueva línea
añadido. Use la opción-npara suprimirlo. Use la opción-epara permitir que ciertos caracteres de escape de barra invertida
tengan un significado especial. La Tabla 3 muestra algunos caracteres de este tipo.
Tabla 3. Caracteres echo y de escape

Secuencia Función
de escape
\a Alerta (campana)
\b Retroceso
\c Suprimir nueva línea añadida (cumple la misma función que la opción -n)
\f Avance de página (limpia la pantalla de un visor de video)
\n Nueva línea
\r Retorno de carro
\t Tabulación horizontal
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 3 of 13

Escapes y continuación de línea

El uso de barras invertidas en bash genera un pequeño problema. Cuando el carácter barra invertida (\) no se coloca entre
comillas, funciona como un escape para señalarle a bash que conserve el significado literal del carácter a continuación. Esto
resulta necesario en los metacaracteres shell especiales, a los que nos referiremos un poco más adelante. Existe una excepción
a esta regla: una barra invertida seguida por una nueva línea provoca que bash pase por alto ambos caracteres y trate a la
secuencia como si fuera una solicitud de continuación de línea. Esto puede resultar útil para separar líneas extensas,
especialmente en shell scripts.
Para que el comandoecho(o uno de los tantos otros comandos que usan caracteres de control con escape similares)
administren correctamente las secuencias antes descriptas deberá colocar entre comillas las secuencias de escape o incluirlas
en una cadena entre comillas, a menos que use una segunda barra invertida para que el shell conserve una de las barras para el
comando. El Listado 4 muestra algunos ejemplos de los distintos usos de la \.

Listado 4. Más ejemplos de echo

[ian@echidna ian]$ echo -n No new line No new line[ian@echidna
ian]$ echo -e "No new line\c" No new line[ian@echidna ian]$ echo "A line with a
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
typed > return" A line with a typed return [ian@echidna ian]$ echo -e "A
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
line with an escaped\nreturn" A line with an escaped return [ian@echidna ian]$
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
echo "A line with an escaped\nreturn but no -e option" A line with an
escaped\nreturn but no -e option [ian@echidna ian]$ echo -e Doubly
escaped\\n\\tmetacharacters Doubly escaped metacharacters [ian@echidna ian]$
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
echo Backslash \ > followed by newline \ > serves as line
continuation. Backslash followed by newline serves as line continuation.
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|

Obsérvese que bash muestra un prompt especial (>) cuando se ingresa una línea con comillas sin cerrar. El flujo de entrada
continúa en una segunda línea incluye el carácter de nueva línea.
Metacaracteres y operadores de control del shell bash
Bash tiene varios metacaracteres, que, cuando no aparecen entre comillas, sirven para separar los datos de entrada en
palabras. Además del espacio en blanco, estos son '|', '&', ';', '(', ')', '<' y '>'. Explicaremos algunos de estos caracteres con
mayor profundidad en otras secciones de este tutorial. Por el momento, considere que si desea incluir un metacarácter como
parte del texto, éste deberá aparecer o bien entre comillas o como carácter de escape, usando una barra invertida (\), como
muestra el Listado 4.
La nueva línea y ciertos metacaracteres o pares de metacaracteres también pueden usarse como operadores de control. Estos
son '||', '&&', '&', ';', ';;', '|'' '(' y ')'. Algunos de estos operadores de control permiten crear secuencias o listas de comandos.
La secuencia de comandos más sencilla se compone de tan solo dos comandos separados por un punto y coma (;). Cada
comando se ejecuta en secuencia. En entornos programables, los comandos devuelven una indicación de éxito o falla. Los
comandos Linux suelen devolver un valor cero en casos de éxito y un valor distinto a cero en casos de fallas. Puede ingresar
algún tipo de procesamiento condicional en su lista usando los operadores de control && y ||. Si separa dos comandos con el
operador de control &&, el segundo se ejecutará si y sólo si el primero devuelve un valor de salida de cero. Si separa los
comandos con ||, el segundo se ejecutará sólo si el primero devuelve un código de salida distinto a cero. El Listado 5 muestra
algunas secuencias de comandos que usan el comando echo. Estas primeras no son demasiado interesantes porque, en ellas,
echo devuelve 0. Más adelante mostraremos otros ejemplos que permiten usar una mayor variedad de comandos.

Listado 5. Secuencias de comandos

[ian@echidna ian]$ echo line 1;echo line 2; echo line 3
line 1 line 2 line 3 [ian@echidna ian]$ echo line 1&&echo line
2&&echo line 3 line 1 line 2 line 3 [ian@echidna ian]$ echo line
1||echo line 2; echo line 3 line 1 line 3

Exit
Un shell puede cerrarse usando el comandoexit. Puede proporcionar un código exit como parámetro, si así lo desea. Si está
ejecutando el shell en una ventana de terminal en un escritorio gráfico, la ventana se cerrará. Asimismo, si está conectado con
un sistema remoto usando, por ejemplo, ssh o telnet, su conexión finalizará. En el shell bash, también puede presionar la
teclaCtrljunto con la tecla d para salir.
Analicemos otro operador de control. Si adjunta un comando o una lista de comandos entre paréntesis, el comando o la
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 4 of 13

secuencia se ejecutará en un subshell, es decir que el comando exit saldrá del subshell en lugar de salir del shell en el que está
trabajando. El Listado 6 muestra un ejemplo simple de secuencias y de && y ||.

Listado 6. Subshells y secuencias

[ian@echidna ian]$ (echo In subshell; exit 0)
&& echo OK || echo Bad exit In subshell OK [ian@echidna ian]$
(echo In subshell; exit 4) && echo OK || echo Bad exit In
subshell Bad exit

Continue leyendo este tutorial para ver más secuencias de comandos.

Variables de entorno
Cuando se ejecuta en un shell bash, el entorno se constituye de varios elementos, como la forma del prompt, su directorio
principal, su directorio en funcionamiento, el nombre de su shell, los archivos que ha abierto, las funciones que ha definido,
etc. Su entorno incluye numerosas variables que pueden haber sido establecidas por bash o por usted. El shell bash también le
permite tener variables shell, que podrá exportar a su entorno para que sean usadas por otros procesos que se ejecutan en el
shell u otros shells que usted puede haber generado a partir del shell actual.
Tanto las variables de entorno como las variables de shell tienen un nombre. El valor de una variable se referencia usando '$'
antes del nombre. La Tabla 4 muestra algunas de las variables de entorno bash más comunes.
Tabla 4. Algunas variables de entorno bash comunes

Nombre Función
USER Nombre del usuario que inició sesión
UID Identificador de usuario numérico del usuario que inició sesión
HOME Directorio principal del usuario
PWD Directorio en funcionamiento
SHELL Nombre del shell
$ Identificador de proceso (o PID) del proceso de shell bash (u otro) en ejecución
PPID Identificador de proceso del proceso que inició este proceso (es decir, el
identificador del proceso primario)
? Código de salida del último comando
El Listado 7 muestra lo que probablemente verá en algunas de estas variables bash comunes.

Listado 7. Variables de entorno y shell

[ian@echidna ian]$ echo $USER $UID ian 500 [ian@echidna
ian]$ echo $SHELL $HOME $PWD /bin/bash /home/ian /home/ian [ian@echidna ian]$
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
(exit 0);echo $?;(exit 4);echo $? 0 4 [ian@echidna ian]$ echo $$ $PPID 30576
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
30575

Puede crear o activar una variable shell

ingresando un nombre seguido inmediatamente
por un signo igual (=). Las variables distinguen
mayúsculas de minúsculas, es decir que var1 y
VAR1 son variables diferentes. Por convención,
las variables (en especial las variables
exportadas) se ingresan en mayúsculas, pero esto
no es un requisito. En teoría, $$ y $? son
parámetros shell, no variables. Sólo pueden
referenciarse y no es posible asignarles un valor.
Cuando cree una variable shell, normalmente será
recomendable exportarla al entorno para que
quede disponible para otros procesos que se
inician desde este shell. Las variables que se
exportan no están disponibles para el shell
primario. Para exportar un nombre de variable, se
¿No usa bash?
El shell bash es el shell predeterminado en la mayoría de las
distribuciones Linux. Si usted no está ejecutando bajo el shell bash,
proceda de alguna de las siguientes maneras para poder practicar con el
shell bash:

Use el comando
chsh -s /bin/bash
para cambiar el shell predeterminado. La nueva forma
predeterminada se aplicará la próxima vez que inicie sesión.

Use el comando
su - $USER -s /bin/bash
para crear otro proceso como proceso secundario de su shell
actual. El proceso nuevo será un shell de inicio de sesión que usa
bash.

Cree un identificador con un shell bash predeterminado para usar
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 5 of 13

usa el comandoexport. Como atajo, con bash es durante la preparación para el examen de LPI.
posible asignar un valor y exportar una variable
en un sólo paso.
Para ejemplificar las operaciones de asignación y exportación, ejecutemos el comando bash en el shell bash y luego
ejecutemos el shell Korn (ksh) desde el nuevo shell bash. Usaremos el comandopspara visualizar información acerca del
comando que se encuentra en ejecución. Ampliaremos nuestros conocimientos depscuando expliquemos el estado de
procesos más adelante en este tutorial.

Listado 8. Más variables de entorno y shell

[ian@echidna ian]$ ps -p $$ -o "pid ppid cmd" PID
PPID CMD 30576 30575 -bash [ian@echidna ian]$ bash [ian@echidna ian]$ ps -p $$
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
-o "pid ppid cmd" PID PPID CMD 16353 30576 bash [ian@echidna ian]$ VAR1=var1
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
[ian@echidna ian]$ VAR2=var2 [ian@echidna ian]$ export VAR2 [ian@echidna ian]$
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
export VAR3=var3 [ian@echidna ian]$ echo $VAR1 $VAR2 $VAR3 var1 var2 var3
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
[ian@echidna ian]$ echo $VAR1 $VAR2 $VAR3 $SHELL var1 var2 var3 /bin/bash
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
[ian@echidna ian]$ ksh $ ps -p $$ -o "pid ppid cmd" PID PPID CMD 16448 16353 ksh
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
$ export VAR4=var4 $ echo $VAR1 $VAR2 $VAR3 $VAR4 $SHELL var2 var3 var4
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
/bin/bash $ exit $ [ian@echidna ian]$ echo $VAR1 $VAR2 $VAR3 $VAR4 $SHELL var1
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
var2 var3 /bin/bash [ian@echidna ian]$ ps -p $$ -o "pid ppid cmd" PID PPID CMD
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
16353 30576 bash [ian@echidna ian]$ exit [ian@echidna ian]$ ps -p $$ -o "pid
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
ppid cmd" PID PPID CMD 30576 30575 -bash [ian@echidna ian]$ echo $VAR1 $VAR2
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
$VAR3 $VAR4 $SHELL /bin/bash

Notas:
1. Al inicio de esta secuencia, el shell bash tenía el PID 30576.
2. El segundo shell bash tiene el PID 16353, y su shell primario es PID 30576, el shell bash original.
3. Creamos VAR1, VAR2 y VAR3 en el segundo shell bash, pero solamente exportamos VAR2 y VAR3.
4. En el shell Korn, creamos VAR4. El comandoechomostró valores únicamente para VAR2, VAR3 y VAR4;
confirmando que VAR1 no se exportó ¿Le sorprendió ver que el valor de la variable SHELL no cambió pese al cambio
del prompt? No siempre se puede esperar que SHELL le informe bajo qué shell está ejecutando, pero el comandopssí
le indicará el comando real. Observe quepscoloca un guión (-) enfrente del primer shell bash para indicar que se trata
del shell de inicio de sesión.
5. Volviendo al segundo shell bash, vemos a VAR1, VAR2 y VAR3.
6. Y, por último, al volver al shell original, vemos que ninguna de nuestras nuevas variables existe aún.

Anteriormente señalamos que se podían usar comillas simples o dobles. Hay una gran diferencia entre las dos. El shell
expande las variables shell que se encuentran entre comillas dobles ($quot;), y no realiza la expansion si se usan comillas
simples ('). En el ejemplo anterior, iniciamos otro shell dentro de nuestro shell y obtuvimos un nuevo identificador de proceso.
Con la opción-c, es posible pasar un comando al otro shell, el cual ejecutará el comando y volverá. Si pasamos una cadena
entre comillas como comando, el shell externo quitará las comillas y pasará la cadena. Si usamos comillas dobles, la
expansión de variables se realizará antes de que se pase la cadena, por lo cual los resultados pueden no ser los esperados.
Como el shell y el comando se ejecutarán en otro proceso, tendrán otro PID. El Listado 9 ejemplifica estos conceptos. El PID
del shell bash de nivel superior se encuentra resaltado.

Listado 9. Colocación entre comillas y variables shell

[ian@echidna ian]$ echo "$SHELL"
'$SHELL' "$$" '$$' /bin/bash $SHELL 19244 $$ [ian@echidna ian]$ bash -c
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
"echo Expand in parent $$ $PPID" Expand in parent1924419243 [ian@echidna
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 6 of 13

|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
ian]$ bash -c 'echo Expand in child $$ $PPID' Expand in child
1929719244

Hasta ahora, todas nuestras referencias de variables terminaron con espacio en blanco y esto nos indicó dónde terminaba el
nombre de variable. En realidad, los nombres de variables sólo pueden estar compuestos por letras, números o el carácter
guión bajo y, por consiguiente, el shell sabe que un nombre de variable ha terminado cuando encuentra un carácter de otro
tipo. A veces es necesario usar variables en expresiones cuyo significado resulta ambiguo. En estos casos, puede usar llaves
para delimitar un nombre de variable, como muestra el Listado 10.

Listado 10. Uso de llaves con nombres de variables

[ian@echidna ian]$ echo "-$HOME/abc-"
-/home/ian/abc- [ian@echidna ian]$ echo "-$HOME_abc-" -- [ian@echidna ian]$ echo
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
"-${HOME}_abc-" -/home/ian_abc-

Env
El comandoenvsin opciones ni parámetros muestra las variables del entorno actual. También puede usarse para ejecutar un
comando en un entorno personalizado. La opción-i(o simplemente-) limpia el entorno actual antes de ejecutar el comando,
mientras que la opción-udesactiva las variables de entorno que usted no desee pasar.

El Listado 11 muestra datos de salida parciales del comandoenvsin ningún parámetro y luego tres ejemplos de invocación de
diferentes shells sin el entorno primario. Observe con atención estos ejemplos antes de pasar a la explicación.

Listado 11. El comando env

[ian@echidna ian]$ env HOSTNAME=echidna TERM=xterm
SHELL=/bin/bash HISTSIZE=1000 SSH_CLIENT=9.27.89.137 4339 22 SSH_TTY=/dev/pts/2
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
USER=ian ... _=/bin/env OLDPWD=/usr/src [ian@echidna ian]$ env -i bash -c 'echo
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
$SHELL; env' /bin/bash PWD=/home/ian SHLVL=1 _=/bin/env [ian@echidna ian]$ env
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
-i ksh -c 'echo $SHELL; env' _=/bin/env PATH=/bin:/usr/bin [ian@echidna ian]$
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
env -i tcsh -c 'echo $SHELL; env' SHELL: Undefined variable.

Observe que bash estableció la variable SHELL pero no la exportó al entorno, aunque sí creó otras tres variables en el
entorno. En el ejemplo de ksh, tenemos dos variables de entorno, pero nuestro intento de hacer eco del valor de la variable
SHELL devuelve una línea en blanco. Finalmente, tcsh no creó ninguna variable de entorno y produce un error ante el intento
de referenciar el valor de SHELL.
Unset y set
El Listado 11 mostró distintos comportamientos de los shells en el manejo de variables y entornos. Si bien este tutorial se
centra en bash, cabe destacar que no todos los shells se comportan de la misma manera. Además, los shells se comportan de
diferentes maneras dependiendo de si se trata de shells de inicio de sesión o no. Por el momento, nos quedaremos con el
concepto de que un shell de inicio de sesión es el shell que se obtiene cuando se inicia sesión en un sistema; es posible iniciar
otros shells para que se comporten como shells de inicio de sesión si lo desea. Los tres shells que se iniciaron en el ejemplo
anterior usandoenv -ino eran shells de inicio de sesión. Pruebe pasar la opción-lal comando shell propiamente dicho para
ver las diferencias que obtendría con un shell de inicio de sesión.
Analicemos nuestro intento de visualizar el valor de la variable SHELL en estos shells que no son shells de inicio de sesión:
1. Cuando se inició bash, éste activó la variable SHELL, pero no la exportó automáticamente al entorno.
2. Cuando se inició ksh, éste no activó la variable SHELL. Sin embargo, la referenciación de una variable de entorno no
definida resulta equivalente a la referenciación de una variable con valor vacío.
3. Cuando se inició tcsh, éste no activó la variable SHELL. En este caso, el comportamiento predeterminado es diferente
al de ksh (y bash), ya que el error se informa ante el intento de usar una variable.

Puede usar el comandounsetpara desactivar una variable y quitarla de la lista de variables shell. Si la variable se exportó al
entorno, esta operación también la quitará del entorno. Puede usar el comandosetpara controlar varias facetas del
funcionamiento de bash (o de otros shells). Set es un comando incorporado a shell, por lo tanto, sus distintas opciones son
específicas para shell. En bash, la opción-uhace que bash informe un error en casos de variables no definidas en lugar de
tratarlas como variables definidas pero vacías. Puede activar las distintas opciones desetcon-y desactivarlas con+. Para
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 7 of 13

visualizar las opciones activadas, useecho $-.

Listado 12. Unset y set

[ian@echidna ian]$ echo $- himBH [ian@echidna ian]$ echo $VAR1
[ian@echidna ian]$ set -u;echo $- himuBH [ian@echidna ian]$ echo $VAR1 bash:
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
VAR1: unbound variable [ian@echidna ian]$ VAR1=v1 [ian@echidna ian]$
VAR1=v1;echo $VAR1 v1 [ian@echidna ian]$ unset VAR1;echo $VAR1 bash: VAR1:
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
unbound variable [ian@echidna ian]$ set +u;echo $VAR1;echo $- himBH

Si usa el comandosetsin opciones, éste mostrará todas las variables shell con sus valores (de haberlos). También se puede
usar otro comando,declare, para crear, exportar y visualizar valores de variables shell. Puede investigar el resto de las
opciones desety del comandodeclaremediante las páginas man. Nos referiremos a las páginas man más adelante en esta
sección.
Exec
El último comando que explicaremos en esta sección esexec. Puede usar el comandoexecpara ejecutar otro programa que
reemplace al shell actual. En el Listado 13 se inicia un shell bash secundario y luego se usaexecpara reemplazarlo por un
shell Korn. Luego de salir del shell Korn, se vuelve al shell bash original (en este ejemplo, PID 22985).

Listado 13. Uso de exec

[ian@echidna ian]$ echo $$ 22985 [ian@echidna ian]$ bash
[ian@echidna ian]$ echo $$ 25063 [ian@echidna ian]$ exec ksh $ echo $$ 25063 $
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
exit [ian@echidna ian]$ echo $$ 22985

Historial de comandos
Si usted está ingresando comandos mientras sigue este tutorial, probablemente habrá notado que se usó varias veces un mismo
comando, o un mismo comando con cambios mínimos. Una buena noticia es que el shell bash puede mantener un historial de
sus comandos. El historial está activado de manera predeterminada. Puede desactivarlo usando el comandoset +o
historyy volverlo a activar usandoset -o history. La variable de entorno denominada HISTSIZE le indica a bash la
cantidad de líneas a mantener en el historial. Otra serie de configuraciones controlan el funcionamiento y la gestión del
historial. Para obtener información completa acerca de este tema, consulte las páginas man de bash.
Algunos de los comandos que pueden usarse con la facilidad de historial son:

history
Muestra todo el historial
history N
Muestra las últimas líneasNde su historial
history -dN
Elimina una líneaNde su historial; puede usar este comando cuando, por ejemplo, una línea contiene una contraseña
!!
Muestra el comando más reciente
!N
Muestra el comando del historial en la posiciónN
!-N
Muestra el comando que se encuentraNcomandos atrás en el historial (!-1 es equivalente a !!)
!#
Muestra el comando actual que está ingresando en el momento
!string
Muestra el comando más reciente que comienza constring
!?string?
Muestra el comando más reciente que contienestring

Además, puede usar los dos puntos (:) seguidos por ciertos valores para acceder o para modificar una parte o un comando de
su historial. El Listado 14 muestra algunas capacidades del historial.

Listado 14. Manipulación del historial

Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 8 of 13

[ian@echidna ian]$echo $$22985 [ian@echidna

ian]$env -i bash -c 'echo $$'1542 [ian@echidna ian]$!!env -i
bash -c 'echo $$' 1555 [ian@echidna ian]$!ececho $$ 22985 [ian@echidna
ian]$!en:s/$$/$PPID/env -i bash -c 'echo $PPID' 22985 [ian@echidna
ian]$history 61097 echo $$ 1098 env -i bash -c 'echo $$' 1099 env -i
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
bash -c 'echo $$' 1100 echo $$ 1101 env -i bash -c 'echo $PPID' 1102 history 6
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
[ian@echidna ian]$history -d1100

Los comandos del Listado 14 realizan las siguientes operaciones:

1. Se hace eco del PID del shell actual
2. Se ejecuta un comando echo en un nuevo shell y se hace eco del PID de dicho shell
3. Se vuelve a ejecutar el último comando
4. Se vuelve a ejecutar el último comando que comienza con 'ec'; esto vuelve a ejecutar el primer comando de este
ejemplo
5. Se vuelve a ejecutar el ultimo comando que comienza con 'en'; pero, al sustituir '$PPID' por '$$', se visualiza el PID
primario
6. Se visualizan los últimos 6 comandos del historial
7. Se elimina la entrada de historial 1100, el último comando echo

También es posible editar el historial de forma interactiva. El shell bash usa la biblioteca readline para gestionar la edición y
el historial de comandos. Las teclas y combinaciones de teclas predeterminadas para desplazarse dentro del historial o las
líneas de edición son similares a las usadas en el editor Emacs de GNU. Las combinaciones de pulsación de teclas Emacs
suelen expresarse de la siguiente manera:C-x o M-x, donde x es una tecla común y C y M son las teclas Control y Meta,
respectivamente. En un sistema de PC típico, la tecla Ctrl funciona como la tecla Control de Emacs y la tecla Alt Funciona
como la tecla Meta. La Tabla 5 resume algunas de las funciones de edición del historial disponibles. Además de las
combinaciones de teclas mostradas en la Tabla 5, las teclas de movimiento del cursor (flechas derecha, izquierda, arriba y
abajo) y las teclas Home (Inicio) y End (Fin) generalmente están configuradas para funcionar de manera lógica. Consulte las
páginas man para obtener información acerca de funciones adicionales y de cómo personalizar estas opciones usando un
archivo readline init (generalmente, inputrc de su directorio principal).
Tabla 5. Edición del historial con comandos emacs

Comando Tecla común de Descripción

PC
C-f Flecha derecha Mueve el cursor un espacio hacia la derecha
C-b Flecha izquierda Mueve el cursor un espacio hacia la izquierda
M-f Alt-f Mover el cursor al comienzo de la siguiente palabra; los entornos GUI generalmente usan esta
combinación de teclas para abrir el menú File de la ventana
M-b Alt-b Mover el cursor al comienzo de la siguiente palabra
C-a Home Mover el cursor al comienzo de la línea
C-e End Mover el cursor al fin de la línea
Backspace Backspace Borrar el carácter anterior al cursor
C-d Del Borrar el carácter posterior al cursor (Las funciones Del y Backspace pueden configurarse de
manera inversa)
C-k Ctrl-k Borrar (kill) hasta el final de la línea y guardar el texto eliminado para su uso posterior
M-d Alt-d Borrar (kill) hasta el final de la palabra y guardar el texto eliminado para su uso posterior
C-y Ctrl-y Volver a insertar el texto eliminado con un comando kill
Si prefiere manipular el historial usando un modo de edición de tipo vi, use el comandoset -o vipara pasar a modo vi. Para
volver al modo emacs, useset -o emacs. Cuando se recupera un comando en modo vi, en principio estará en modo insert
(insertar) de vi. Nos referiremos al editor vi en la sección Edición de archivos con vi.

Rutas
Algunos comandos bash están incorporados, mientras que otros son externos. Analicemos ahora los comandos externos, cómo
ejecutarlos y cómo saber si un comando es interno.
¿Dónde encuentra los comandos el shell?
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 9 of 13

Los comandos externos son simplemente archivos que se encuentran dentro de su sistema de archivos. La sección posterior,
Gestión básica de archivos, de este tutorial y del tutorial para el Tema 104 abordan el tema en mayor profundidad. En sistemas
Linux y UNIX, se accede a todos los archivos como parte de un mismo gran árbol con raíz en /. En los ejemplos
proporcionados hasta el momento, nuestro directorio actual fue el directorio principal del usuario. Los usuarios no root suelen
tener un directorio dentro del /home directory (directorio principal), por ejemplo: /home/ian, en mi caso. El directorio
principal de root suele ser /root. Al ingresar un nombre de comando, bash busca dicho comando en suruta, la cual es una lista
de directorios separados por comas dentro de la variable de entorno PATH.
Si desea saber qué comando se ejecutará si ingresa una cadena en particular, use el comandowhichotype. El Listado 15
muestra mi ruta predeterminada junto con las ubicaciones de varios comandos.

Listado 15. Búsqueda de ubicaciones de comandos

[ian@echidna ian]$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/home/ian/bin [ian@echidna ian]$
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
which bash env zip xclock echo set ls alias ls='ls --color=tty' /bin/ls
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
/bin/bash /bin/env /usr/bin/zip /usr/X11R6/bin/xclock /bin/echo /usr/bin/which:
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
no set in (/usr/local/bin:/bin:/usr/bin:/usr/X11R6/b in:/home/ian/bin)
[ian@echidna ian]$ type bash env zip xclock echo set ls bash is /bin/bash env is
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
/bin/env zip is /usr/bin/zip xclock is /usr/X11R6/bin/xclock echo is a shell
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
builtin set is a shell builtin ls is aliased to `ls --color=tty'

Obsérvese que todos los directorios incluidos en la ruta terminan en /bin. Esta es una convención común, pero no es un
requisito. El comandowhichinformó que el comandolses unaliasy que no se pudo encontrar el comandoset. En este caso,
interpretamos que, o bien el comando no existe, o se trata de un comando incorporado. El comandotypeinforma que el
comandolses unaliaspero identifica al comandosetcomo un comando incorporado a shell. También informa que existe un
comandoechoincorporado además del quewhichencontró en /bin. Los dos comandos también producen datos de salida en
diferentes órdenes.
Vimos que el comandols, usado para listar el contenido de directorios, es unalias. Los alias son una forma práctica de
configurar algunos comandos para usar diferentes conjuntos de elementos predeterminados o para proporcionar un nombre
alternativo a un comando. En nuestro ejemplo, la opción--color=ttyhace que los listados de directorios aparezcan
codificados por colores en base al tipo de archivo o directorio. Pruebe ejecutardircolors --print-databasepara ver
cómo se controlan los códigos por color y qué color se usa para cada tipo de archivo.
Estos comandos tienen otras opciones adicionales. Elija el comando que mejor responda a sus necesidades. Personalmente,
suelo usarwhichcuando estoy casi seguro de que encontraré el ejecutable y solamente necesito obtener su especificación de
ruta completa. Creo quetypeproporciona información más precisa, que puede ser necesaria en un shell script.

Ejecución de otros comandos

Vimos en el Listado 15 que los archivos ejecutables tienen una ruta completa que comienza con /, el directorio root. Por
ejemplo, el programa xclock es realmente /usr/X11R6/bin/xclock, un archivo ubicado en el directorio /usr/X11R6/bin.
Aunque un comando no se encuentre en su especificación de ruta o PATH, podrá ejecutarlo si especifica una ruta y un
nombre de comando. Se pueden usar dos tipos de rutas:

Rutas absolutas, que comienzan con /, como las vistas en el Listado 15 (/bin/bash, /bin/env, etc).

Rutas relativas, que son relativas con respecto a sudirectorio en funcionamientocomo lo informa el comandopwd. Estos
comandos no comienzan con / pero contienen al menos una /.

Puede usar rutas absolutas sin importar cuál sea su directorio en funcionamiento, pero probablemente sólo pueda usar rutas
relativas cuando el comando esté cerca de su directorio actual. Supongamos que nos encontramos desarrollando una nueva
versión del clásico programa "Hello World!" en un subdirectorio de su directorio principal llamado mytestbin. Podría usar la
ruta relativa para ejecutar sus comandos comomytestbin/hello. Puede usar dos nombres especiales en una ruta; un sólo
punto (.) hace referencia al directorio actual, y dos puntos seguidos (..) hace referencia al directorio actual primario. Debido a
que su directorio principal no suele ni (por lo general) debe estar en su PATH, deberá explicitar una ruta para todo ejecutable
que quiera ejecutar desde su directorio principal. Por ejemplo, si tuviera una copia del programa hello en su directorio
principal, podría ejecutarlo usando el comando./hello. Puede usar tanto. como .. como parte de una ruta absoluta, aunque
un sólo . no resulta demasiado útil en un caso como éste. También puede usar una virgulilla (~) para referirse a su propio
directorio principal y ~usernamepara referirse al directorio principal del usuario llamadousername. El Listado 16 muestra
algunos ejemplos.
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 10 of 13

Listado 16. Rutas absolutas y relativas

[ian@echidna ian]$ /bin/echo Use echo command rather than
builtin Use echo command rather than builtin [ian@echidna ian]$ /usr/../bin/echo
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
Include parent dir in path Include parent dir in path [ian@echidna ian]$
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
/bin/././echo Add a couple of useless path components Add a couple of useless
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
path components [ian@echidna ian]$ pwd # See where we are /home/ian [ian@echidna
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
ian]$ ../../bin/echo Use a relative path to echo Use a relative path to echo
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
[ian@echidna ian]$ myprogs/hello # Use a relative path with no dots -bash:
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
myprogs/hello: No such file or directory [ian@echidna ian]$ mytestbin/hello #
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
Use a relative path with no dots Hello World! [ian@echidna ian]$ ./hello # Run
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
program in current directory Hello World! [ian@echidna mytestbin]$
~/mytestbin/hello # run hello using ~ Hello World! [ian@echidna ian]$ ../hello #
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
Try running hello from parent -bash: ../hello: No such file or directory
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|

Modificación del directorio en funcionamiento

Así como puede ejecutar programas de distintos directorios de su sistema, también es posible modificar el directorio en
funcionamiento mediante el comandocd. El argumento decddebe ser una ruta absoluta o relativa a un directorio. Con respecto
a los comandos, puede usar ., .., ~ y ~usernameen las rutas. Si usacdsin parámetros, el cambio se realizará en su directorio
principal. Como parámetro, un sólo guión (-) significa que el cambio se aplicará en el directorio anteriormente en
funcionamiento. Su directorio principal se almacena en la variable de entorno HOME y el directorio anterior se almacena en
la variable OLDPWD , por lo tanto,cdsólo es equivalente acd $HOMEycd -es equivalente acd $OLDPWD. Cuando
digamoscambiar el directorionos estaremos refiriendo acambiar el directorio en funcionamiento.
En cuanto a los comandos, también existe una variable de entorno, CDPATH, que contiene el conjunto de directorios
separados por dos puntos que deben buscarse al resolver rutas relativas (además del directorio en funcionamiento). Si en la
resolución se usa una ruta de CDPATH,cdimprimirá la ruta completa del directorio obtenido como datos de salida.
Normalmente, una modificación exitosa en un directorio genera como datos de salida solamente un prompt nuevo y
probablemente modificado. El Listado 17 muestra algunos ejemplos.

Listado 17. Modificación de directorios

[ian@echidna home]$ cd /;pwd / [ian@echidna /]$ cd
/usr/X11R6;pwd /usr/X11R6 [ian@echidna X11R6]$ cd ;pwd /home/ian [ian@echidna
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
ian]$ cd -;pwd /usr/X11R6 /usr/X11R6 [ian@echidna X11R6]$ cd ~ian/..;pwd /home
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
[ian@echidna home]$ cd ~;pwd /home/ian [ian@echidna ian]$ export CDPATH=~
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
[ian@echidna mytestbin]$ cd /;pwd / [ian@echidna /]$ cd mytestbin
/home/ian/mytestbin

Aplicación recursiva de comandos

Muchos comandos Linux pueden aplicarse recursivamente a todos los archivos que se encuentran en un árbol de directorio.
Por ejemplo, el comandolstiene una opción-Rpara listar directorios recursivamente y los comandoscp,mv,rmydifftienen una
opción-rpara su aplicación recursiva. La sección Gestión básica de archivos explica en profundidad la aplicación recursiva de
comandos.
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 11 of 13

Sustitución de comandos
El shell bash tiene una capacidad muy potente que permite usar los resultados de un comando como datos de entrada de otro
comando; esto se denominasustitución de comandos. La sustitución de comandos puede llevarse a cabo ingresando entre
acentos graves (`) el comando cuyos resultados se desean usar. Esta forma se sigue usando con frecuencia; sin embargo, una
opción que resulta más sencilla cuando se trabaja con comandos anidados múltiples es ingresar el comando entre $( y ).
En el tutorial anterior, "LPI exam 101 prep (topic 102): Linux installation and package management," vimos que el
comandorpmpodía indicar de cuál paquete proviene un comando; en ese caso, usamos la capacidad de sustitución de
comandos, que resultó una técnica práctica. Ahora realmente comprendemos lo que estábamos haciendo.
La sustitución de comandos es una herramienta muy valiosa en los shell scripts y también resulta útil en la línea de comandos.
El Listado 18 muestra un ejemplo de cómo obtener una ruta absoluta de un directorio desde una ruta relativa, cómo averiguar
qué RPM proporciona el comando /bin/echo y cómo listar (como root) los rótulos de tres particiones en un disco duro. Por
último, se usa el comandoseqpara generar una secuencia de números enteros.

Listado 18. Sustitución de comandos

[ian@echidna ian]$ echo '../../usr/bin' dir is $(cd
../../usr/bin;pwd) ../../usr/bin dir is /usr/bin [ian@echidna ian]$ which echo
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
/bin/echo [ian@echidna ian]$ rpm -qf `which echo` sh-utils-2.0.12-3 [ian@echidna
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
ian]$ su - Password: [root@echidna root]# for n in $(seq 7 9); do echo p$n
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
`e2label /dev/hda$n`;done p7 RH73 p8 SUSE81 p9 IMAGES

Páginas man
El último tema de esta sección del tutorial explica cómo obtener documentación de comandos Linux a través de páginas
manuales y otras fuentes de documentación.
Páginas y secciones manuales
La principal (y tradicional) fuente de documentación son laspáginas manuales, a las cuales se puede acceder usando el
comandoman. La Figura 1 muestra la página manual del comandoman. Use el comandoman manpara visualizar esta
información.

Figura 1. Página man del comando man

La Figura 1 muestra los elementos típicos de las páginas man:

Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 12 of 13

Un encabezado con el nombre del comando seguido por su correspondiente número de sección entre paréntesis

El nombre del comando y de todos los comandos relacionados que se describen en esta página man

Una sinopsis de las opciones y los parámetros aplicables al comando

Una breve descripción del comando

Información detallada de cada una de las opciones
Pueden existir otras secciones que proporcionen descripciones del uso, expliquen cómo informar errores y brinden
información acerca del autor y una lista de comandos relacionados (de haberlos). Por ejemplo, la página man demannos
informa que los comandos relacionados (y sus secciones manuales) son:

apropos(1), whatis(1), less(1), groff(1) y man.conf(5).

Existen ocho secciones de páginas manuales comunes. Las páginas manuales suelen instalarse con la instalación de un
paquete, por lo tanto, si usted no tiene instalado un paquete en particular, probablemente no tenga una página manual acerca
de dicho paquete. Asimismo, es posible que algunas de sus secciones manuales estén vacías o casi vacías. Las secciones
manuales comunes y los ejemplos proporcionados en ellas son:
1. Comandos de usuario (env, ls, echo, mkdir, tty)
2. Llamadas al sistema o funciones kernel (link, sethostname, mkdir)
3. Rutinas de bibliotecas (acosh, asctime, btree, locale, XML::Parser)
4. Información relacionada con dispositivos (isdn_audio, mouse, tty, zero)
5. Descripciones de formatos de archivos (keymaps, motd, wvdial.conf)
6. Juegos (obsérvese que, en la actualidad, muchos juegos son gráficos y proporcionan ayuda gráfica fuera del sistema de
páginas man)
7. Misceláneo (arp, boot, regex, unix utf8)
8. Administración de sistemas (debugfs, fdisk, fsck, mount, renice, rpm)
Otras secciones que podrían estar disponibles son:9, documentación del kernel Linux,n, documentación nueva,o,
documentación antigua yl, documentación local.
Algunas entradas se repiten en varias secciones. Nuestros ejemplos muestran que mkdir está incluido en las secciones 1 y 2,
mientras que tty aparece en las secciones 1 y 4. Es posible especificar una sección en particular, por ejemplo:man 4 ttyoman
2 mkdir, o especificar la opción-apara listar todas las secciones manuales pertinentes.

Al observar la figura anterior, probablemente haya notado quemantiene numerosas opciones. Puede estudiar dichas opciones
por su cuenta. Por el momento, nos referiremos a algunos de los comandos incluidos en "See also" (Ver también) que se
relacionan conman.

See also
Dos comandos importantes relacionados conmansonwhatisyapropos. El comandowhatisbusca páginas man con el nombre
por usted ingresado y muestra la información de nombres de las páginas manuales pertinentes. El comandoaproposrealiza
una búsqueda de palabras claves en las páginas manuales y lista las que contienen las palabras claves ingresadas. El Listado
19 muestra estos comandos.

Listado 19. Ejemplos de whatis y apropos

[ian@lyrebird ian]$ whatis man man (1) - format and
display the on-line manual pages man (7) - macros to format man pages man
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
[manpath] (1) - format and display the on-line manual pages man.conf [man] (5) -
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
configuration data for man [ian@lyrebird ian]$ whatis mkdir mkdir (1) - make
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
directories mkdir (2) - create a directory [ian@lyrebird ian]$ apropos mkdir
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
mkdir (1) - make directories mkdir (2) - create a directory mkdirhier (1x) -
|-------10--------20--------30--------40--------50--------60--------70--------80--------9|
|-------- XML error: La línea anterior es más larga que 90 caracteres ---------|
makes a directory hierarchy

Por cierto, si no logra encontrar la página manual de man.conf, inténtelo ejecutandoman man.config.

Los datos de salida de las páginas del comandomanse visualizan usando un programa de paginación. En la mayoría de los
sistemas Linux, suele ser el programaless. Otra posibilidad es un programa más antiguo llamadomore. Si desea imprimir la
página, especifique la opción-tpara dar formato de impresión a la página usando el programagroffotroff.

El paginador less tiene varios comandos para buscar cadenas dentro de los datos de salida mostrados. Useman lesspara
conocer más acerca de/(buscar hacia delante),?(buscar hacia atrás), yn(repetir última búsqueda), entre muchos otros
comandos.
Preparación para el examen 101 de LPI: Comandos GNU y UNIX Page 13 of 13

Otras fuentes de documentación

Además de las páginas manuales a las que se puede acceder desde una línea de comandos, la Fundación para el Software
Libre creó una serie de archivosinfoque se procesan con el programainfo. Estos archivos proporcionan una gran variedad de
facilidades de navegación, como la capacidad de saltar a otras secciones. Ingreseman infooinfo infopara obtener más
información. Como no todos los comandos están documentados en info, aunque se convierta en usuario info, deberá usar info
y man simultáneamente.
Además, las páginas man ofrecen algunas interfaces gráficas, comoxman(de XFree86 Project) yyelp(del navegador de ayuda
Gnome 2.0).
Si no logra encontrar ayuda con respecto a un comando, intente ejecutando el comando con la opción--help. De esta manera,
probablemente obtenga la ayuda del comando o se le informe cómo obtener la ayuda que necesita.
La próxima sección se refiere al procesamiento de flujos de texto con filtros.