- Estréllate y Arde - https://www.estrellateyarde.org -
Lo más básico en la terminal de Linux
Veamos lo más básico en la terminal de Linux:
- ¿Cómo le damos órdenes a la máquina
en modo texto?
- ¿Qué ocurre cuando tecleamos un comando?
- Entrada y Salida estándar
- Historial de comandos ejecutados
- Autocompletar
- Caracteres comodín
- Escapar caracteres especiales
- Comillas
- Agrupar comandos
- Limpiar la pantalla
- Visualizar el contenido de un archivo de texto
- Capturar una sesión de terminal
- Variables
Usando comandos. La sintaxis de un comando es:
$ orden <opciones> <argumentos>
Normalmente, los comandos que admiten opciones suelen tener una opción por defecto que corresponde a su forma de uso habitual y facilita su empleo.
Algunos comandos, una vez ejecutados, quedan en modo interactivo esperando entradas por el teclado. En este caso, con <Ctrl+D> (fin de entrada de datos, carácter EOT, End Of Text, fin de texto) le diremos al sistema que deje de leer la entrada y continue procesándo el comando.
Con el carácter "\" indicamos que el comando continúa en la línea siguiente, en la que aparece el prompt secundario (>) para que sigamos tecleando el comando.
$ cat \ > file1 aceitunas berenjenas castañas
Cuando se teclea una orden, el intérprete de comandos hace varias cosas:
$ help
$ alias
$ echo $PATH
y obtendremos algo similar a:
/bin:/usr/bin:/usr/local/bin:/usr/bin/X11
El PATH de root es distinto al de un usuario normal. Además de los directorios anteriores incluye los directorios sbin:
/sbin:/usr/sbin:/usr/local/sbin
Esto explica que si un usuario normal intenta ejecutar el comando:
$ ifup
el sistema no lo encuentra, ya que está en /sbin/ifup y esa ruta no figura en su PATH. Debe ejecutar:
$ /sbin/ifup
Para ejecutar programa, que está en el directorio actual, suponiendo que su ruta no figura en el PATH, haremos:
$ ./programa
Directorio actual y directorio padre
En Linux "." representa el directorio actual y ".." el directorio padre.
command not found
Veremos a menudo este mensaje de error si el directorio donde está el programa a ejecutar no figura en el PATHsi nos equivocamos al teclear una orden o . Debemos tener en cuenta que los nombres de comandos (igual que ocurre con los archivos y directorios) son case-sensitive y distinguen entre mayúsculas y minúsculas). Por ejemplo, el comando make es diferente a Make o MAKE.
En Linux cada proceso abre tres canales de comunicación:
Por ejemplo, el comando cat tiene como entrada estándar el teclado y como salida estándar 1 el monitor. Si lo ejecutamos sin argumentos leerá datos del teclado y los enviará al monitor, de manera que cada línea que el usuario teclea es inmediatamente enviada al monitor, hasta la señal de fin de entrada de datos (<Ctrl+D>).
$ cat
Hola caracol
Hola caracol
Adios
Adios
<Ctrl+D>
En cambio, el comando para copiar archivos cp tiene como entrada estándar un archivo (file1) y como salida estándar 1 otro archivo (file2):
$ cp file1 file2
Veamos los operadores que nos permiten redireccionar la entrada y salida estándar:
$ cat > lista
Hola caracol
Adios
<Ctrl+D>
Para almacenar el contenido del archivo file1 en file2 haremos:
$ cat file1 > file2
$ gcc prueba.c 2> errores &
$ ls > dummy
Pero si hacemos eso con un directorio inexistente, el sistema no enviará nada a dummy, pero mandará el mensaje de error a la pantalla, ya que hemos redireccionado la salida estándar 1 pero no la salida estándar 2, la salida estándar para errores:
$ ls directorio_inexistente > dummy
ls: directorio_inexistente: No existe el archivo o el directorio.
Para que el error tampoco aparezca por pantalla redireccionaremos ambas salidas:
$ ls directorio_inexistente > dummy 2> dummy
$ cat file2 >> file1
$ gcc prueba.c 2>> errores &
Podemos redireccionar la entrada estándar usando el operador "<":
$ sort < cosas.txt
aceitunas
berenjenas
castañas
$ ls | sort -r
tesis
notas
historia
Podemos conectar tantos comandos como queramos:
$ ls /usr | sort -r | more
$ ls | tee file
Para que la salida de ls se añada al final de file usaremos la opción -a:
$ ls | tee -a file
Si se escribe en una tubería con nombre, el proceso que escribe en la tubería no finaliza hasta que la información escrita es leída de la tubería.
Si se lee de una tubería con nombre, el proceso de lectura espera hasta que exista algo para leer antes de finalizar.
El tamaño de la tubería es siempre cero: no almacena datos, sólo vincula dos procesos. No obstante, puesto que la tubería tiene nombre, los dos procesos no tienen que estar en la misma línea de comandos ni tampoco ser ejecutados por el mismo usuario.
Veamos un ejemplo. Creamos una tubería con nombre:
$ mkfifo mi_tuberia
Escribimos en la tubería con nombre en segundo plano:
$ echo "hola" > mi_tuberia & [1] 5952
Listamos la tubería con nombre para comprobar que su tamaño es cero:
$ ls -l mi_tuberia prw-r--r-- 1 francis francis 0 2003-11-06 23:18 mi_tuberia
Leemos la tubería con nombre:
$ cat mi_tuberia hola [1]+ Done echo "hola" > mi_tuberia
El shell de Linux guarda en la memoria el historial de comandos ejecutados y podemos acceder a ellos
simplemente pulsando las flechas del cursor. Si cerramos la sesión adecuadamente el historial de
comandos ejecutados quedará guardado en el archivo:
~/.bash_history
cuyo contenido se puede controlar desde ~/.bashrc, por ejemplo:
# no guardar duplicados export HISTCONTROL=ignoreboth # numero de comandos a guardar export HISTSIZE=1000 # guardar los comandos al ejecutarlos PROMPT_COMMAND='history -a'
Linux tiene implementada una función de autocompletar que funciona en dos casos:
Los llamados comodines nos permiten referirnos a, por ejemplo, grupos de archivos que tienen algún tipo de coincidencia.
$ ls precios presupuestos notas $ ls *r* precios presupuestos
Utilizando este comodín no obtendremos los archivos que comiencen con un punto ("."). A estos archivos, llamados "ocultos" (porque no son mostrados en un listado normal de ls) o "dot files" (por comenzar por un punto), no les afecta el uso del comodín "*". Para verlos debe usarse la opción -a:
$ ls -a
.config .gnome2 precios presupuestos notas
$ ls ?resupuestos
presupuestos
$ ls nota1 nota2 nota3 note3 $ ls nota[13] nota1 nota3 $ ls not[ae]3 nota3 note3 $ ls nota[1-3] nota1 nota2 nota3 $ ls nota[!12] nota3
Cuando escribimos caracteres especiales (wildcards) el sistema los interpreta como tales. Por ejemplo, si ejecutamos el comando:
$ echo *
precios presupuestos notas
Si queremos utilizar caracteres especiales ("*" asterisco, ">" mayor que, "&" ampersand...) y que el sistema los interprete como caracteres normales tenemos que usar una "secuencia de escape", y diremos que los hemos "escapado". Lo que haremos será preceder dicho carácter con la barra invertida (\), que impide la interpretación del carácter siguiente (sólo uno). Por ejemplo, para escribir un asterisco haremos:
$ echo \*
*
Si queremos escribir tres asteriscos haremos:
$ echo \*\*\*
***
$ echo '***'
$ VAR=hola
y queremos sacar por pantalla el valor de VAR haremos:
$ echo $VAR
hola
o bien:
$ echo "$VAR"
hola
mientras que para sacar por pantalla la cadena "$VAR" haremos:
$ echo '$VAR'
$VAR
$ echo "Soy el usuario `whoami`"
Soy el usuario francis
Linux permite agrupar comandos por medio de operadores:
$ orden1 ; orden2 ; orden3
$ orden1 && orden2
$ orden1 || orden2
$ clear
$ cat <archivo_binario>
debemos ejecutar (aunque probablemente no podamos ver lo que escribimos):
$ reset
Para visualizar el contenido de un archivo de texto usaremos:
$ cat file
$ less file
El comando script permite guardar una transcripción de una sesión de terminal en un archivo de texto. Se suele utilizar para capturar la actividad de la terminal durante la ejecución de comandos como dpkg o apt-get. La sintaxis es:
$ script <archivo>
Para iniciar la transcripción y guardarla en el archivo /home/francis/type.txt haremos:
$ script /home/francis/type.txt
Script iniciado: el fichero es /home/francis/type.txt
El comando script genera un sub-shell, de manera que a partir de ese momento, todas las órdenes ejecutadas y sus salidas por pantalla se guardarán en el archivo /home/francis/type.txt. Para terminar la ejecución de script haremos:
$ exit
Script terminado: el fichero es /home/francis/type.txt
Si no especificamos <archivo>, la captura de la sesión se guardará en el archivo /<directorio_actual>/typescript (si el archivo existe lo sobreescribirá).
$ env
Para ver la lista de variables locales haremos:
$ set
$ A=playa
Nota
No debemos dejar espacios entre el nombre, el igual (=) y el valor.
Si una variable contiene espacios debe llevar comillas simples (') o dobles ("):
$ FECHA="31 de diciembre de 1986"
Para ver el contenido de una variable hay que precederla con el carácter "$".
Ahora podemos usar esta variable desde el prompt o en scripts, pero sólo podremos acceder a su valor en el shell en que se han definido, ya que es una variable local:
$ echo $A playa $ bash $ echo $A
Primero comprobamos su valor y está correcto, pero después hemos lanzado un nuevo sub-shell con el comando bash y aquí la variable A no aparece: sólo es "visible" en el shell donde fue definida.
$ export A $ bash $ echo $A playa
Ahora el valor de la variable A puede ser leído desde cualquier shell o script.
$ export
Article printed from Estréllate y Arde: https://www.estrellateyarde.org
URL to article: https://www.estrellateyarde.org/so/lo-mas-basico-terminal-linux
Click here to print.
Copyright © 2010 Estrellate y Arde