Shell de Linux para Principiantes: Comandos Básicos de Línea de Comando

Es importante decir que incluso con un entorno gráfico bonito, práctico y diversificado, es en la línea de comandos donde reside la fuerza de Linux. Para los usuarios avanzados, es en el shell del sistema operativo donde ocurre la magia, pues, Linux permite que el usuario haga lo que quiera, con la facilidad de alterar un archivo. La concatenación de comandos también permite crear verdaderos cuchillo suizos computacionales.

El acceso al terminal es simple y rápido. Solo debes buscar la aplicación Terminal en el entorno gráfico, o presionar la secuencia de teclas Ctrl-Alt-F1...F2...F3... para tener acceso al terminal.

Shell de Linux para Principiantes: La Línea de Comandos

Ingresar comandos en el shell es más que simplemente escribirlos.

Primero, el comando debe ser válido y estar en los directorios listados en la variable PATH o con su ubicación explícita. El comando también puede requerir opciones, generalmente precedidas por el símbolo "-" o "--" y por argumentos. Lo importante es que cada comando tiene su sintaxis única y puede haber variaciones dependiendo de la distribución de Linux.

Veamos algunos ejemplos simples con el comando ls:

$ ls

Este comando lista los archivos en el directorio actual. No requiere ninguna opción o argumento para ejecutarse. El argumento –l puede agregarse para generar una lista de archivos detallada:

$ ls –l

También podemos agregar más opciones para el comando ls:

$ ls –l –a –t

O

$ ls –lta

En el caso del comando ls, las opciones pueden pasarse por separado o combinadas. La opción –a muestra todos los archivos incluyendo los ocultos. La opción –t muestra los archivos ordenados por la última fecha de modificación. El orden de las opciones no es importante para ls.

Para ocultar un archivo en Linux, su nombre debe comenzar necesariamente con el símbolo "." (punto). Ej: .bash_history

Para algunos comandos, las opciones deben ir precedidas por dos guiones "--" en lugar de uno. Además, algunos comandos ofrecen formas alternativas de indicar una misma opción. En el caso de ls, las opciones –a y --all producen el mismo efecto. El detalle es que las opciones que se llaman con dos guiones no pueden combinarse.

$ ls –lt --all

Y no:

$ ls --lalllt

Algunos comandos pueden aceptar argumentos como opcionales. Para otros comandos, los argumentos son necesarios. Los argumentos son los parámetros que los comandos aceptan o necesitan. Veamos el comando ls:

$ ls –l *.txt

En el ejemplo anterior, el comando ls recibió la opción –l y el argumento *.txt que filtra los archivos terminados con la extensión  .txt.

Otra variación posible son los comandos que necesitan obligatoriamente de una opción para ejecutar una tarea que generalmente no va precedida por el guion. Es común para este tipo de comando que sus opciones sean seguidas por argumentos. Vea como ejemplo el comando dd:

$ dd if=bootdisk.img of=/dev/fd0

El comando dd copia y convierte archivos de acuerdo con las opciones pasadas. En el ejemplo, el comando leerá una imagen de un disco de boot (opción if=bootdisk.img) y grabará esta imagen en la unidad a: (opción of=/dev/fd0).

Casi todos los comandos aceptan la opción –-help que muestra una ayuda simple de las opciones y argumentos aceptados por el comando.

Es importante que tengas en mente que Linux únicamente ejecutará los comandos que sean internos del intérprete, o comandos cuya ubicación esté en la variable PATH o comandos llamados con su ruta explícita.

$ ls 

O

$ /bin/ls

En el examen es muy importante que estés bien familiarizado con los comandos listados en este capítulo y su sintaxis. Por lo tanto, necesitas saber cuándo el comando acepta opciones con un guion, dos guiones o ningún guion.

Bash también permite que ingreses una secuencia de comandos en una misma línea. Para esto, debes separar los comandos con el símbolo ; (punto y coma).

$ echo $PS1; echo $PS2

Bash escribe en un archivo llamado .bash_history ubicado en el directorio home de cada usuario el historial de todos los comandos digitados por los usuarios. La posibilidad de recuperar los comandos digitados es fabulosa. Esto puede ser muy útil para fines de auditoría, recordar la memoria o simplemente economizar los dedos.

Podrás ver los comandos que digitiste visualizando el contenido del archivo .bash_history. 

$ cat ~/.bash_history

El comando cat, entre otras cosas, sirve para visualizar el contenido de los archivos. 

El símbolo "~" hace referencia al directorio home del usuario conectado.

Variables de Shell

El primer contacto del usuario con el shell de Linux es el prompt de comandos.

Cómo se presenta este prompt de comandos puede cambiar en cada distribución, desde el más simple, con un simple "$" o con información de usuario, nombre del servidor e incluso el directorio actual:

[uira@server1 ~]$

El prompt de comandos puede personalizarse a través de la configuración de una variable que el shell de Linux mantiene llamada PS1.

Las variables se cargan al inicio de la ejecución de bash y también pueden configurarse manualmente en cualquier momento.

La primera variable que abordaremos es la PS1 o simplemente Prompt String 1.

Esta variable guarda el contenido del prompt de comandos de bash cuando está listo para recibir comandos.

También existe la variable PS2 que guarda el contenido del prompt de comandos cuando se necesitan múltiples líneas para completar un comando.

Estas dos variables del shell no afectan cómo el intérprete procesará los comandos recibidos, pero pueden ser de gran ayuda cuando cargan información extra como nombre del usuario, directorio actual, etc.

Se ha convenido que las variables se escriben todas en mayúsculas. Pero es importante que sepas que $nombre y $NOMBRE son dos variables diferentes para el shell.

El contenido de cualquier variable del Shell podrá visualizarse con el comando echo seguido por el símbolo $ más el nombre de la variable:

$ echo $PS
\$

El carácter\ \ indica que cualquier otro carácter que le sigue debe ser interpretado exactamente como es y no procesado por el shell. Es lo que llamamos metacarácter.

Es común que el prompt de comandos predeterminado del bash venga en el formato:\ \u@\h:\W\$

Los comandos y variables en Linux son sensibles a las letras mayúsculas y minúsculas. Cada uno de estos caracteres es interpretado de forma especial.

El\ \u\ se utiliza para representar el nombre del usuario, el\ \h\ se utiliza para representar el nombre del sistema (hostname) y el\ \W\ es el directorio actual.

Un ejemplo para este prompt es:\ uira@notebook:home\$

Otra variable importante del Shell es el\ PATH. El path guarda una lista de los directorios que contienen los programas que podrás ejecutar sin necesidad de escribir la ruta completa en la línea de comandos.

$ echo $PATH
/sbin:/bin:/usr/sbin:/usr/bin

Es importante que sepas que el intérprete de comandos del bash sigue el siguiente orden para encontrar y ejecutar los comandos escritos:

1. ¿El comando escrito es un comando interno del intérprete de comandos?
2. Si no lo es, ¿el comando es un programa ejecutable ubicado en algún directorio listado en la variable PATH?
3. ¿La ubicación del comando fue declarada explícitamente?

Un consejo interesante es incluir ":." al final de la variable\ PATH\ para que el bash incluya el directorio actual en su lista de búsqueda de programas ejecutables.

A diferencia de MS-DOS, el directorio actual no está incluido en la lista de búsqueda predeterminada. Sin incluir el ":." en PATH es necesario informar la ruta relativa al llamar programas en el directorio actual con "./nombredelprograma".

Esto es un problema para usuarios novatos en Linux que no entienden por qué al escribir un comando o intentar ejecutar un programa que está en la carpeta actual no funciona la mayoría de las veces. Simplemente es la falta que hace el ":." en \$PATH.

Una lista completa de las variables del shell se puede obtener con el comando:

$ set

También podrás modificar o crear una nueva variable del shell a través del comando:

$ LIVRO=”Certificação Linux”

Preferiblemente las variables deben declararse en mayúsculas y no coloques espacios entre el nombre de la variable, el símbolo = y su contenido.

Si el contenido es alfanumérico es deseable que esté entre comillas simples o dobles.

Cuando el texto de una variable es una secuencia común de letras y números, poco importa si vas a usar comillas simples o dobles.

$ FRASE1=”Este é um teste”
$ FRASE2='de direfença entre aspas'
$ echo $FRASE1 $FRASE2
Este é um teste de diferença entre aspas

Pero si vas a utilizar las variables entre comillas, hay diferencia:

$ echo “$FRASE1 $FRASE2”
Este é um teste de diferença entre aspas
$ echo '$FRASE1 $FRASE2'
$FRASE1 $FRASE2

Entonces las comillas dobles expanden el contenido de las variables, mientras que las comillas simples no. Esto hace diferencia si quieres, por ejemplo, incluir un directorio en la variable PATH:

$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/opt/aws/bin:/home/ec2-user/bin
$ PATH="$PATH:/ora/oracle/admin/bin"
$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/opt/aws/bin:/home/ec2-user/bin:/ora/oracle/admin/bin 

En este caso las comillas simples no funcionarían.

Después de crear una variable del shell, es necesario exportarla al entorno con el comando\ export.

Cuando una variable es exportada al entorno queda disponible para todos los procesos hijos del shell (todos los programas y aplicaciones que ejecutes en el bash).

Cada vez que un programa es ejecutado por el shell, este solo recibirá las variables creadas por el shell si han sido exportadas con el comando export.

Así el proceso hijo (el programa que queremos ejecutar) heredará del proceso padre (el shell) las variables creadas.

Ve el ejemplo abajo, donde creamos una variable llamada LIVRO:

$ LIVRO=”Certificação Linux”
$ echo $LIVRO
Certificação Linux

Si ejecutamos el bash nuevamente en la misma terminal, para crear un proceso hijo, verás que la variable LIVRO no existe, porque no fue exportada a los procesos hijo:

$ bash
$ echo $LIVRO

Uso de comodines

Cuando estamos trabajando con archivos y directorios en el shell es muy común necesitar trabajar con varios archivos a la vez. Para hacer este tipo de tarea más simple, Linux ofrece el recurso de comodín para los nombres de archivos y directorios.

Al igual que en la baraja de cartas, los comodines son símbolos que pueden significar muchas cosas. En Linux permiten que los utilices como parte del nombre de los archivos y directorios. Ve la tabla abajo:

Símbolo	Descripción
*	Significa "vale cualquier cosa" y puede sustituir uno o más caracteres de un nombre. Por ejemplo "Certifi*" puede significar "Certificado", "Certificación" o cualquier otra combinación de nombres de archivos que inicie con "Certifi".
?	Significa que puede sustituir un carácter solamente de un nombre. Por ejemplo: "?ertificado" puede\ \ sustituir "Certificado", "certificado" o cualquier otra combinación de nombres de archivos que inicie con un carácter cualquiera y termine con "ertificado".
{texto1, texto2...}	Sustituye la parte dentro de las llaves por texto1, luego por texto2, y así sucesivamente. Por ejemplo: "parte_{a,b,c}" resultará en "parte_a", "parte_b" y "parte_c".

Ejemplos:

$ ls *.txt

Lista todos los archivos con el sufijo .txt

$ cat doc??? >> documentos

Concatena todos los archivos iniciados con "doc" que tengan 6 caracteres de tamaño en el archivo documentos.

Veamos los comandos para listar los comandos escritos, exportar variables y verificar si algo es un comando.

Si quieres saber cómo copiar archivos en Linux, échale un vistazo a este post.

Aprende mucho más sobre Linux en nuestro curso en línea. Puedes realizar la inscripción aquí. Si ya tienes una cuenta, o quieres crear una, simplemente ingresa o crea tu usuario aquí.

¿Te gustó? Comparte