Conceptos básicos de la terminal Bash
Variables de entorno (Path)
Comandos básicos de la terminal Bash
Referencias relativas
Comando cd
Archivos y directorios
Terminal o Shell
Una TERMINAL puede ser un SHELL, o un INTÉRPRETE DE COMANDOS. Probablemente muchos esten acostumbrados a usar ENTORNOS GRÁFICOS (de ventanas) como los interfaces de Windows o de MacOS, y si habéis empezado a investigar el escritorio de Linux después de instalar vuestra distribución, habran visto que hay varios escritorios para usar en Linux. Los entornos gráficos nos permiten ver colores, e interactuar con los botones de los programas para elegir opciones.
No obstante, la manera más habitual de administrar una máquina Linux (instalar paquetes, ver los registros de actividad, crear o modificar usuarios...) suele hacerse desde un terminal o intérprete de comandos, que es en modo texto, y generalmente nos muestra un PROMPT como ahora veremos. Un prompt es lo que el intérprete de comandos escribe automáticamente en cada lína antes de que nosotros podamos darle instrucciones mediante COMANDOS. Cada comando, generalmente , termina presionando la tecla INTRO para que éste sea recibido por la máquina y ejecutado.
Aparte de dar instrucciones a nuestra máquina, desde una terminal podremos editar textos, archivos de configuración, apagar y reiniciar el sistema, instalar nuevos programas, leer el correo, conectar al IRC, usar un navegador... y muchas cosas más. Aprenderemos que los sistemas gráficos no son imprescindibles, y lo que es mejor, al final te terminará gustando todo esto de los comandos (por mucho que ahora pienses que no). Para que te vayas haciendo una idea de cómo funciona todo esto y lo comprendas, vamos a pasar a explicar cómo funciona la terminal que usan por dfecto actualmente casi todos los sistemas Linux. En un capítulo posterior veremos detenidamente los sistemas gráficos en Linux.
Cuando arranquemos nuestra máquina con Linux y termine de cargar todos los procesos iniciales, o bien veremos una pantalla gráfica de login o una de texto. Vamos a aprovechar este hecho para saber cómo podemos cambiar de terminal (podemos usar varias a la vez e ir cambiando entre ellas). Pulsando las teclas Ctrl+Alt+F1 accedemos a la primera terminal, pulsando Ctrl+Alt+F2 accedemos a la segunda, y así sucesivamente hasta Ctrl+Alt+F6 (Podremos volver al escritorio gráfico con Ctrl+Alt+F7 o a veces Ctrl+Alt+F5). Es posible que no podamos acceder a la primera terminal porque quizás esté siendo utilizada por los procesos de login gráfico si es que ya hemos ingresado desde allí. Las terminales se suelen nombrar tty0 para la primera, tty1 para la segunda, y así sucesivamente. También es posible, como descrubriremos luego, abrir una terminal en otra máquina desde la nuestra, esto es, manejarla remotamente.
Siempre que estemos ante una nueva terminal, veremos que aparece ante nosotros algo como NOMBREDEMIMÁQUINA login:. En cada terminal se ejecuta el programa que produce esta salida para que nos AUTENTIFIQUEMOS en el sistema (esto es, para que demostremos que somos usuarios registrados en el sistema y que podemos usarlo). El programa se llama login, y es de momento sólo importante que recuerdes que hay un programa que se ejecuta en cada terminal y que se encarga de autentificarnos en el sistema. Como vamos a practicar, NO entraremos al sistema como root . Bien, entremos al sistema en una de las terminales para practicar:
NOMBREDEMIMÁQUINA login: minombredeusuario
Password: mipassword
Supongamos que minombredeusuario es nuestro nombre de usuario (recuerda que Linux distingue mayúsculas y minúsculas para los usuarios y las contraseñas). Después de introducirlo presionaremos INTRO, y después introduciremos nuestra contraseña. Observa que no aparecen asteriscos mientras introduces tu contraseña (esto es por seguridad, para que nadie vea cuántos caracteres tiene tu password), pero puedes borrar y escribir normalmente. Cuando hayas terminado, presiona INTRO de nuevo.
Se comprobará si nuestro usuario y contraseña son correctos. De no ser así aparecerá algo como Login incorrect. Please try again. Esto significa que nuestro nombre de usuario o/y contraseña son incorrectos, así que lo intentaremos de nuevo. Cuando hagamos un login satisfactorio en el sistema, se nos mostrará algo como:
User [miusuario] logged in. Last login was in [FECHA] from [hostremoto_o_terminallocal]
Donde [miusuario] es mi nombre de usuario en la máquina, [FECHA] es la fecha del último ingreso al sistema y [nombre_de_host_remoto_o_terminal_local] es el nombre de la máquina desde donde ingresamos la última vez en la nuestra, o el nombre de la terminal local si el último login; por ejemplo tty0. En algunos casos se nos indicará las veces que se ha fallado antes de conseguir entrar con nuestro nombre de usuario. Como veremos después, podremos saber si alguien intenta hacerse pasar por nosotros con esta información.
Además (como después veremos en detalle), la máquina nos informará de si tenemos correo o correo nuevo en nuestro buzón local. Puede ser algo como New mail for [misusuario] o Mail for [miusuario], dependiendo de si hay correo no leído o leído respectivamente. Si no lo hay o bien no se muestra nada o se muestra algo como No mail for [miusuario].
Una vez dentro de nuestro sistema Linux, usando BASH (justo después de hacer login, pues es BASH la terminal por defecto), se nos mostrará lo siguiente en cada línea antes de que podamos introducir ningún comando:
[miusuario@nombredemimáquina directorioactual]$
miusuario@nombredemimáquina /directorio/actual$
A esto que se muestra antes de que podamos introducir un comando le llamamos PROMPT. Aparecerá cada vez que pulsemos INTRO. También puedes apreciar que hemos puesto dos líneas de prompt. La primera de ellas es la que verás si usas una distribución RedHat o basada en RedHat (Mandrake, SuSE...). La segunda es la línea que verás si usas una distribución Debian o basada en Debian. Analicemos las distintas partes del prompt más detenidamente:
miusuario es el nombre de usuario con el que hemos entrado a la máquina.
nombredemimáquina es el nombre de nuestra máquina sin el dominio (por ejemplo, una máquina llamada maquina23.midominio.com, aparecería aquí como maquina23).
directorioactual es el nombre del directorio actual en el que estamos sin la ruta completa, sólo el directorio. Como nada más entrar al sistema, estaremos en /home/miusuario, lo más probable es que muestre solamente miusuario.
/directorio/actual la RUTA COMPLETA al directorio actual (explicación más abajo), que es lo que mostrarán las distribuciones basadas en Debian. Nada más entrar deberían mostrar /home/miusuario, pero ahora veremos por qué esto no es así.
$ indica que estamos en el sistema como un usuario normal, y no como root. Si entrásemos como root, en vez de un $ tendríamos un # en cada línea, lo cual debería recordarnos que "tecleemos con cautela" ;-)
Observaremos un ejemplo de lo que pasaría si entrásemos como root. Sería algo así:
[root@mimáquina root]#
root@mimáquina /root#
De nuevo, la segunda línea sería en distribuciones basadas en Debian. Recordamos que el DIRECTORIO PERSONAL (directorio donde cada usuario puede escribir y tiene sus archivos de configuración y su trabajo) de root es /root, mientras que para los usuarios normales es /home/nombredeusuario. Apreciamos que ahora la señal de "teclea con cautela" ;-) al final de la línea, #, somos root, tenemos la fuerza, pero debemos usarla para bien puesto que es nuestra máquina.
En cualquier momento, cerraremos nuestra sesión de terminal escribiendo logout o exit y presionaremos INTRO. El programa de login se lanzará automáticamente y podremos entrar de nuevo a la máquina como un usuario distinto o como root.
Variables de entorno (Path)
Lo primero que tienes que hacer es tranquilizarte, puesto que es realmente más sencillo de lo que su nombre aparenta. Estas variables se pueden llamar también VARIABLES DE SHELL. Y... ¿qué es un variable? Una VARIABLE es un nombre al que le asignamos un valor. Un ejemplo sería asignar al nombre "dias" el valor "7". Esto, en bash una vez iniciada la sesión podemos acerlo así:
[usuario@maquina usuario]$ dias=7
$ dias=7
A partir de ahora, para entrar comandos, lo representaremos de la segunda forma; presentaremos $ si los comandos han de ser ejecutados por un usuario normal o # si han de ser ejecutados por root, en lugar de mostrar en todos nuestros ejemplos todo el prompt completo. Debes recordar que el comando es lo que va detrás de $ o # según corresponda.
Sigamos. Lo que hemos hecho arriba ha sido ASIGNAR al nombre "dias" el valor de "7". Acabamos de crear una VARIABLE DE ENTORNO con nombre "dias" y valor "7". Sencillo, ¿no?. Podemos introducir texto como valor de una variable poniéndolo entre comillas. Para "referirnos" a las variables de entorno podemos usar el símbolo $. Para mostrar el contenido de una variable usaremos el COMANDO echo. Así, por ejemplo, para mostrar el valor de la variable dias que acabamos de crear, escribiríamos:
$ echo $dias
Lo cual nos daría como salida una nueva línea con el valor de dias, en este caso, 7. Nada más (por ahora) de todo esto, simplemente que nos vaya sonando.
Ahora debemos saber que BASH almacena algunas variables de entorno. Estas variables son necesarias, y contienen, por ejemplo, el tipo de sistema operativo que se está usando, la versión, el usuario activo, el directorio actual...
De todas ellas sólo nos interesa por ahora una llamada PATH (en mayúsculas, en Linux los nombres las distinguen, también en las variables). La variable PATH es muy importante. Puedes comprobar lo que contiene escribiendo:
$ echo $PATH
/bin:/usr/bin:/usr/X11R6/bin:/usr/local/bin:/home/usuario/bin
Como podemos observar, lo que contiene esta variable son rutas de directorios separadas por dos puntos. /bin, /usr/bin, y /usr/local/bin son ejemplos de rutas de directorios. ¿Para qué sirven? Es sencillo. Cuando introducimos un comando en BASH (como los que ahora vamos a ver, y como ya hemos visto con echo), se busca por el archivo del mismo nombre que ejecuta ese comando, en todos los directorios que la variable $PATH tiene asignados. Si encuentra el archivo (que se llama igual que el comando que tecleemos y contiene unas instrucciones) lo ejecutará. Si no lo encuentra, nos mostrará un mensaje de error. Todo esto puede parecer complicado, pero verás que no lo es en absoluto.
Notemos que si hacemos login como root y mostramos el contenido de PATH, ésta contiene algunas cosas más, como /usr/sbin y /sbin por ejemplo. Estos directorios sólo los tendremos si entramos desde la pantalla de login como root.
Pero podemos añadir más directorios a nuestra variable PATH. Bien porque trabajemos mucho con ellos o porque es necesario para la ejecución de algún programa. La forma de hacerlo es la siguiente:
$ PATH="$PATH:/home/usuario/programas"
¿Recordamos que la primera $ sólo indica que estamos trabajando como un usuario normal? Entonces perfecto. Lo que hace esta línea es simple. Al contenido de PATH añade unos dos puntos y a continuación añade el directorio que nosotros queramos a nuestra PATH. El resultado es que si mostramos haora el valor de PATH con echo obtendremos todo lo que teníamos anteriormente más el directorio que hemos añadido.
Referencias Comandos básicos de la terminal Bash
Ciertamente, todos estos conocimientos que estamos citando pueden casi siempre aplicarse a otras terminales como sh, pero nos referimos a BASH por ser la que viene por defecto con Linux. Ahora vamos a explicar el concepto de DIRECTORIO DE TRABAJO o directorio actual. En esta línea:
[usuario@maquina usuario]$
estamos trabajando en el directorio /home/usuario. ¿Qué quiere decir esto? Pues es fácil, que podemos "hacer referencia" a un archivo desde un comando simplemente con el nombre de archivo y no su ruta completa si éste está en /home/usuario porque es el directorio de trabajo actual. Un ejemplo rápido, vamos a editar un archivo para comprender esto, no te preocupes por el comando vim, puesto que lo veremos más adelante. Si estamos en /home/usuario y tenemos un archivo que se llama /home/usuario/mitexto, para editarlo, bastaría con hacer:
[usuario@maquina usuario]$ vim mitexto
Como estamos trabajando en el directorio /home/usuario y el archivo que queríamos editar también está en el directorio de trabajo, el editorlo encontraría sin problemas. Esto sería equivalente a hacer:
$ vim /home/usuario/mitexto
pero como acabas de ver, teclear la ruta completa no es en absoluto necesario si el objetivo de nuestro comando está en el directorio de trabajo.
Sugerencia: Puedes salir del editor pulsando: Esc :wq INTRO
Para mas información sobre VIM mira el capítulo 4 (VIM básico)
Este concepto es también sencillo. Partimos de que estamos otra vez en /home/usuario (de nuevo no te preocupes por vim, el comando del editor, lo usamos como un ejemplo para que veas las referencias, no es necesario que pruebes esto porque vamos a explicarlo más adelante), y queremos editar un archivo que está en /home/usuario/documentos/mitexto. Al estar en /home/usuario, bastaría con hacer:
$ vim documentos/mitexto
Lo cual sería equivalente a hacer:
$ vim /home/usuario/documentos/mitexto
Pero como ya hemos visto, con la referencia relativa al directorio en el que nos encontramos es suficiente. Por esto ya has podido observar que podemos referirnos a los archivos de dos formas distintas: mediante una referencia relativa al directorio actual en el que nos encontramos o mediante una REFERENCIA ABSOLUTA. Las referencias absolutas comienzan siempre desde la raíz del sistema de archivos, /, y por eso siempre empiezan con / e indican la RUTA COMPLETA al archivo al que nos estamos refiriendo.
Este sencillo comando, lo que nos va a permitir es cambiar nuestro directorio de trabajo (o directorio actual). Es una abreviatura (como muchos otros comandos) de lo que hace, en este caso de Change Directory. Podemos necesitar cambiar nuestro directorio de trabajo si vamos a trabajar con muchos archivos que estén en el direcotrio al que nos cambiamos, y no queremos teclear siempres su ruta completa por resultar esto demasiado incómodo y largo. Partimos de /home/usuario, y nos queremos cambiar a /usr/local, que es donde residen muchas cosas personalizadas de nuestro sistema. Se podría hacer de la siguiente forma:
[usuario@maquina usuario]$ cd /usr/local/
Y entonces ya estaríamos en /usr/local:
[usuario@maquina local]$
Si simplemente escribimos cd, sin ningún argumento (dato que necesita un comando para operar de una manera u otra, con un archivo u otro... como después veremos), lo que hará será llevarnos a nuestro directorio personal:
[usuario@maquina local]$ cd
[usuario@maquina usuario]$
Como puedes ver, ahora nuestro directorio de trabajo es /home/usuario, que es nuestro directorio personal.
Pero hay algunas cosas que no hemos contado de las referencias relativas. Es que dos puntos seguidos ... se refiere al directorio en el que nos encontramos (directorio actual). Si estando en /home/usuario escribes cd ., te darás cuenta de que no cambia de directorio, se queda en el actual, de la misma manera que si hubieras hecho cd .. te habría llevado a /home , el directorio inmediatamente superior. Estos dos comandos equivaldrían a cd ./ y cd ../; es lo mismo, pero es realente con la barra como deben utilizarse estos comandos (puesto que nos estamos refiriendo a directorios). Utilizarlos sin ella, puede dar lugar a confusión y equivocaciones (recuerda que los archivos y directorios ocultos comienzan su nombre por .). Ahora ya sabes que para poder ir a /home/usuario/documentos podríamos haber hecho: se refieren al directorio inmediatamente anterior (superior) al que nos encontramos, y un punto
$ cd ./documentos
Lo cual no es muy eficiente en este caso, pero como veremos más adelante, es de obligada utilización para ejecutar un comando en el directorio actual si este directorio actual no está en la PATH. Por ejemplo para ejecutar un programa (como veremos más adelante) que estuviese en /home/usuario, al no estar esta ruta en $PATH, necesitaríamos hacerlo así (estando en /home/usuario):
$ ./miprograma
Te habrás dado cuenta de que con una referencia relativa es más cómodo, más sencillo y más rápido. Si simplemente dijésemos desde /home/usuario miprograma a BASH, no lo encontraría, y nos devolvería que no ha encontrado el comando. ¿Por qué? Pues es fácil, /home/usuario, que es donde reside miprograma, no está en $PATH. Bueno, la ejecución para después, ahora sigamos:
Desde /home/usuario podríamos haber ido a /usr/local con una referencia relativa también:
[usuario@maquina usuario]$ cd ../../usr/local
Este comando sube dos niveles (al directorio inmediatamente superior a /home/usuario, que es /home, y luego al directorio inmediatamente superior a /home que es /; una ez allí busca mediate referencia relativa a / el directorio usr, y una vez dentro, mediante una referencia relativa al directorio usr, busca el directorio local. En este caso es más rápido introducir cd /usr/local que usar una referencia relativa al directorio actual. Generalmente, usaremos referencias absolutas (al sistema de archivos, /) cuando lo que queremos buscar (en este caso un directorio) se encuentre varios niveles por encima del directorio actual, o en una ruta distinta como en este ejemplo.
Ahora vamos a trabajar con archivos y directorios, vamos a crear directorios, los borraremos, listaremos archivos... Todo esto no es difícil de hacer. Si recordamos, es preferible que trabajemos como un usuario normal y no como root, para no dañar nuestro sistema por accidente intentando borrar un directorio importante. Empezaremos con obtener un listado de los contenidos del directorio /. Este se hace con el comando ls. Las opciones (indican al comando la forma en la que debe trabajar) que tiene el comando ls-a y -l. -a indica que se muestren todos los archivos, incluso los ocultos, y -l muestra un listado largo, con detalles como el usuario al que pertenece el archivo, los permisos de ese archivo y algunas cosas más. Los parámetros que toma ls principalmente es un directorio. Si no se especifica ninguno, saca un listado del directorio actual. Veamos algunos ejemplos: son principalmente
[usuario@maquina usuario]$ ls
Desktop Mail documentos kernelconfig programas proyectos
[usuario@maquina usuario]$
Esto es un listado de los archivos y directorios que contiene el directorio actual, en este caso /home/usuario. En algunas distribuciones, los directorios aparecen en color azul, los ejecutables en color verde, etc. pero muchas veces no hay distinción.
[usuario@maquina usuario]$ ls -l
total 44
drwx--S--- 3 usuario usuario 4096 Mar 28 10:51 Desktop
drwx--S--- 2 usuario usuario 4096 Mar 28 01:40 Mail
drwxr-sr-x 3 usuario usuario 4096 Mar 28 10:24 documentos
-rw-r--r-- 1 usuario usuario 18417 Mar 27 21:31 kernelconfig
drwxr-sr-x 4 usuario usuario 4096 Mar 28 10:28 programas
drwxr-sr-x 7 usuario usuario 4096 Mar 28 00:18 proyectos
Como puedes ver, la opción -l nos devuelve un listado largo, en el que apreciamos permisos (que explicaremos más adelante), dueño y grupo de archivo, fecha, nombre, tamaño, y algunos otros detalles.
[usuario@maquina usuario]$ ls -a
. .bash_logout .mcoprc Mail
.. .bash_profile .mozilla ccmsn
.DCOPserver_usuario .bashrc .ssh documentos
.DCOPserver_usuario_:0 .viminfo kernelconfig
.ICEauthority .gtkrc-kde .wmrc programas
.MCOP-random-seed .kde .xchat proyectos
.Xauthority .kderc .xsession-errors
.bash_history .mcop Desktop
Aquí puedes ver un listado de todos los archivos y directorios, incluidos los ocultos. Podríamos emplear las dos opciones juntas, como ls -la o ls -al, lo que nos devolvería un listado largo con todos los archivos, ocultos incluidos. Si tienes cualquier duda o quieres saber qué parámetros acepta un comando, simplemente escribee comando --help y verás una lista de opciones y argumentos que puedes usar con ese comando. En el caso de ls:
$ ls --help
Modo de empleo: ls [OPCIÓN]... [FICHERO]...
Muestra información acerca de los FICHEROs (del directorio actual por defecto).
Ordena las entradas alfabéticamente si no se especifica ninguna de las
opciones -cftuSUX ni --sort.
Los argumentos obligatorios para las opciones largas son también obligatorios
para las opciones cortas.
-a, --all no oculta las entradas que comienzan con .
-A, --almost-all no muestra las entradas . y .. implícitas
--author imprime el autor de cada fichero
-b, --escape imprime escapes octales para los caracteres no
gráficos
--block-size=TAMAÑO utiliza bloques de TAMAÑO bytes
-B, --ignore-backups no muestra la entradas que terminan con ~
-c con -lt: ordena por ctime y muestra ctime (fecha
de última modificación del fichero)
con -l: muestra ctime y ordena por nombre
en cualquier otro caso: ordena por ctime
-C muestra las entradas por columnas
--color[=CUÁNDO] especifica si se usará color para distinguir los
tipos de ficheros. CUÁNDO puede ser `never',
`always' o `auto'
-d, --directory muestra las entradas de los directorios en lugar
de sus contenidos
-D, --dired genera el resultado para el modo `dired' de Emacs
-f no ordena, utiliza -aU, no utiliza -lst
-F, --classify añade un indicador (uno de */=@|) a las entradas
--format=PALABRA across -x, commas -m, horizontal -x, long -l,
single-column -1, verbose -l, vertical -C
--full-time como -l --time-style=full-iso
-g como -l, pero no muestra el propietario
-G, --no-group no muestra la información del grupo
-h, --human-readable muestra los tamaños de forma legible
(p.e. 1K 234M 2G)
--si análogo, pero utilizando potencias de 1000,
no de 1024
-H, --dereference-command-line sigue los enlaces simbólicos en la línea de
órdenes
--indicator-style=PALABRA añade un indicador con estilo PALABRA a los
nombres de las entradas: none (predeterminado),
classify (-F), file-type (-p)
-i, --inode muestra el número de nodo-i de cada fichero
-I, --ignore=PATRÓN no lista las entradas que coincidan (encajen)
con PATRÓN de shell
-k como --block-size=1K
-l utiliza un formato de listado largo
-L, --dereference al mostrar la información de un fichero para un
enlace simbólico, muestra la información del
fichero al que apunta el enlace en lugar de la
del propio enlace
-m rellena el ancho con una lista de entradas
separadas por comas
-n, --numeric-uid-gid como -l, pero muestra los UIDs y GIDs numéricos
-N, --literal muestra los nombres literalmente (no trata p.ej.
los caracteres de control de forma especial)
-o como -l, pero no muestra el grupo
-p --file-type añade un indicador (uno de /=@|) a las entradas
-q, --hide-control-chars imprime ? en lugar de los caracteres no gráficos
--show-control-chars muestra los caracteres no gráficos tal y como
son (predeterminado a menos que el programa sea
`ls' y la salida sea un terminal)
-Q, --quote-name encierra los nombres de las entradas entre
comillas
--quoting-style=PALABRA utiliza el estilo de cita PALABRA para los
nombres de las entradas:
literal, locale, shell, shell-always, c, escape
-r, --reverse invierte el orden, en su caso
-R, --recursive muestra los subdirectorios recursivamente
-s, --size muestra el tamaño de cada fichero, en bloques
-S ordena los ficheros por tamaño
--sort=PALABRA extension -X, none -U, size -S, time -t, version -v
status -c, time -t, atime -u, access -u, use -u
--time=PALABRA muestra la fecha según PALABRA, en lugar de la
fecha de modificación:
atime, access, use, ctime ó status; utiliza
la fecha especificada como clave de ordenación
si --sort=time
--time-style=ESTILO muestra la fecha utilizando el estilo ESTILO:
full-iso, long-iso, iso, locale, +FORMATO
FORMATO se interpreta como en `date'; si FORMATO
es FORMATO1FORMATO2, FORMATO1 se
aplica a los ficheros no recientes y FORMATO2
a los ficheros recientes; si ESTILO está precedido
por `posix-', ESTILO surte efecto solamente fuera
del local POSIX
-t ordena por la fecha de modificación
-T, --tabsize=COLS establece los topes de tabulación a cada COLS
en lugar de 8
-u con -lt: ordena por atime y muestra atime (fecha
de último acceso al fichero)
con -l: muestra atime y ordena por nombre
en cualquier otro caso: ordena por atime
-U no ordena; muestra las entradas en el orden del
directorio
-v ordena por versión
-w, --width=COLS establece el ancho de la pantalla en lugar del
valor actual
-x muestra las entradas por líneas en vez de por
columnas
-X ordena alfabéticamente por la extensión de la
entrada
-1 muestra un fichero por cada línea
--help muestra esta ayuda y finaliza
--version informa de la versión y finaliza
TAMAÑO puede ser (o puede ser un entero seguido opcionalmente por) uno
de los siguientes: kB 1.000, K 1.024, MB 1.000.000, M 1.048.576, y así
en adelante para G, T, P, E, Z, Y.
Por defecto, no se emplea color para distinguir los tipos de ficheros. Esto
equivale a usar --color=none. Usar la opción --color sin el argumento opcional
CUÁNDO equivale a usar --color=always. Con --color=auto, sólo se muestran
los códigos de color si la salida estándar está conectada a un terminal (tty).
Comunicar bugs a .
(La ayuda puede no estar en castellano). Como puedes ver, la cantidad de opciones es impresionante. Te hemos citado las que de momento te pueden ser necesarias. Es obvio que no es necesario que recuerdes ninguna excepto las dos vistas, cuando el resto puedes obtenerlas mediante --help. Recuerda que puedes hacer esto con casi cualquier comando.
Podríamos listar los contenidos de otro directorio sin cambiarnos a él:
$ ls /usr/local/
bin include lib man sbin share src
Pasemos a ver ahora cómo podemos crear un directorio. Como pienso que habrás intuido, no puedes crear un directorio en un lugar en el que no tienes permiso para ello. Generalmente, un usuario normal sólo tendrá permiso para ello en su directorio de usuario, /home/usuario, así que cámbiate ahí si no es donde estás. Para crear directorios podemos utilizar tanto referencias relativas al directorio actual como referencias absolutas al sistema de archivos. Para crear directorios, basta con usar el comando mkdir. Crearemos un directorio en /home/usuario llamado pruebas, y otro dentro de este llamado pruebas1 como ejemplo:
$ cd /home/usuario
Primera forma de hacerlo:
$ mkdir pruebas
$ cd pruebas
$ mkdir pruebas1
Segunda forma de hacerlo:
$ mkdir pruebas
$ mkdir pruebas/pruebas1
Tercera forma de hacerlo:
$ mkdir /home/usuario/pruebas
$ mkdir /home/usuario/pruebas/pruebas1
Creo que ya lo has entendido, ¿verdad? Puedes moverte entre esos directorios con el comando cd como ya explicamos antes, así practicas un poco. Ahora vamos a mover y copiar archivos a esos directorios. Para mover archivos y directorios usaremos el comando mv. Date cuenta que este comando también nos permite renombrar un archivo. Supongamos que tenemos un archivo llamado miarchivo en /home/usuario. Vamos a renombrarlo a minuevoarchivo (es recomendable no usar espacios en los nombres de archivo, puedes usar guiones bajos (_) en sustitución de los espacios; asimismo es recomendable como ya tratabamos, no usar acentos en los nombres de archivo):
$ cd /home/usuario
Primera forma de hacerlo:
$ mv miarchivo minuevoarchivo
Segunda forma de hacerlo:
$ mv miarchivo /home/usuario/minuevoarchivo
Tercera forma de hacerlo:
$ mv /home/usuario/miarchivo minuevoarchivo
... y así algunas formas más, pero creo que ya lo has entendido, aquí también podemos emplear referencias relativas al directorio actual y referencias absolutas al sistema de archivos. Podemos renombrar directorios también, y moverlos unos dentro de otros. Para mover un directorio llamado programas y llevarlo dentro de otro llamado pruebas, haríamos algo como esto:
$ mv programas pruebas/
De esta forma el directorio programas se queda dentro de pruebas. Como ves, el comando mv toma como primer argumento el fichero o directorio origen, y como segundo argumento el destino; recuérdalo. Podríamos reestablecer el directorio programas al nivel anterior donde estaba:
$ cd pruebas/
$ mv programas ../
Como habrás podido apreciar y ya hemos dicho, el comando mvtoma primero lo que se quiere mover y después a dónde se quiere mover. Para dominarlo totalmente, lo mejor es que practiques, es la única forma de comprender cómo se comporta bajo determinadas situaciones este comando, y de que tú lo domines.
Para borrar un directorio, si este esta vacío, usaremos el comando rmdir. Por ejemplo vamos a borrar los directorios pruebas1 y pruebas que creamos anteriormente. Si recuerdas, pruebas1 estaba dentro de pruebas:
$ ls
pruebas
$ rmdir pruebas
rmdir: `pruebas': El directorio no está vacío / Directory not empty
# Como ves, no podemos borrarlo porque no está vacío
$ cd pruebas/
$ ls
pruebas1
$ rmdir pruebas1
# pruebas1 está vacío y por lo tanto se borra
$ cd ../
$ rmdir pruebas
# Ahora pruebas está vacío y también se borra
(Las líneas que comienzan por # son explicaciones del manual para que comprendas lo que pasa). Está claro que hacer todo esto para borrar un directorio y todo lo que éste contenga no es del todo cómodo. Unas líneas más adelante veremos cómo es posible borrar todo un directorio con todo lo que contenga por debajo de él (siempre que tengamos los permisos adecuados sobre todo lo que contiene y sobre el directorio mismo).
El comando rm nos permite borrar uno o varios archivos. Por ejemplo, borraremos el archivo minuevoarchivo:
$ rm minuevoarchivo
Si tenemos los permisos adecuados sobre él, minuevoarchivo será borrado, en la mayoría de los casos sin preguntarnos, por lo cual debemos tener bastante cuidado con lo que hacemos con los archivos de nuestro sistema, porque una vez borrados es imposible volver a recuperarlos (¿para que los borraríamos entonces si siguiesen estando ahí?). Al igual que todos los comandos anteriores, rm es muy potente y sobre todo muy flexible. Veremos cómo es capaz de borrar un directorio con todo lo que tenga por debajo.
Para esto se usa, principalmente, la opción -r. Esta opción le dice a rm (y a algunos otros comandos) que opere con recursividad, esto es, que se vaya adentrando nivel por nivel debajo del directorio que le hemos indicado y que vaya borrando todo lo que encuentre a su paso. De este modo, el directorio pruebas/ que teníamos antes, podríamos haberlo borrado así:
$ rm -rf pruebas/
La opción -r como hemos dicho irá borrando todo, terminando por borrar el directorio, y la opción -f es para que no nos pregunte si queremos que borre o no cada subdirectorio del que nosotros le indicamos. Recuerdo que el caracter * hace referencia a todos los archivos de un directorio por lo que si quisieramos haber borrado todo lo que tuviese dentro el directorio pruebas/ pero sin borrar éste, podríamos haber hecho:
$ rm -rf pruebas/*
La opción -r nos permite de igual forma copiar un directorio entero. Pogamos que queríamos copiar el directorio pruebas (con todo su contenido) a un nuevo directorio llamado pruebas2 que crearemos al mismo nivel que pruebas:
$ cp -rf pruebas/ pruebas2/
Más o menos ya tienes una idea de cómo se maneja el sistema de archivos desde la consola. Para entender y dominar todo esto no hay más que practicarlo. Si quieres saber cómo crear archivos, la sección del editor vim puede servirte, ahora vamos a comentar algunos detalles más para referirnos a archivos en BASH.
Piensa que tenemos un directorio que se llama mis libros. Como puedes observar, este nombre de directorio tiene un espacio, lo cual no es nada recomendable. La manera de "nombrarlo" desde la terminal es la siguiente: mis\ libros. El espacio se sustituye por \ (barra invertida y un espacio).
Piensa ahora que tenemos que referirnos a un archivo que tiene cinco letras pero que desconocemos cuál es la última (o cualquiera) de estas letras. Por ejemplo, un archivo que se llame maybe, nosotros desconocemos la letra "b". Podríamos referirnos a él usando may?e, y la terminal lo encontraría inmediatamente.
El asterisco * puede referirse a todos los archivos de un directorio si lo usamos solo. Por ejemplo, borramos todos los archivos de un directorio:
$ rm *
O bien puede referirse a archivos que contengan una cadena de caracteres o que empiecen o terminen por una determinada cadena de caracteres. Por ejemplo todos los archivos ocultos (que empiezan por "."):
$ rm .*
Otro ejemplo, borramos todos los archivos que contengan la cadena "so" en su nombre:
$ rm *so*
Todo esto es muy sencillo. Vamos a terminar con una función muy importante de BASH, que es completar el nombre de archivo o directorio por nosotros. Supongamos que queremos entrar en un directorio dentro del actual que se llama html_docs y que no hay ningún otro directorio que empiece de modo igual o parecido. Escribiremos:
$ cd html (presionamos el tabulador aquí)
# (entonces la línea se nos queda:)
$ cd html_docs/
Si pulsamos INTRO, nos habremos cambiado al directorio html_docs/. Mira lo que acabamos de descubrir. Si estamos escribiendo un nombre de archivo o de directorio y presionamos el tabulador, si ese nombre existe, BASH lo rellenará por nosotros. Cómodo, ¿no? De esta forma no tendremos que escribirlo entero. Ahora supongamos que además de html_docs hay otro directorio al mismo nivel que se llama html_includes. Si escribimos ahora cd html y presionamos el tabulador, no habrá salida porque no sabrá cuál de ellos elegir. La solución es pulsar el tabulador dos veces y nos mostrará las opciones que coinciden con lo que llevamos escrito, con lo cual podresmo seguir escribiendo hasta que hayamos eliminado una de las opcioens y pulsemos el tabulador de nuevo solo una vez, entonces sí que nos rellenará el nombre de archivo o directorio. Ten en cuenta que esto sirve con casi cualquier comando y es indiferente para referencias relativas al directorio actual o absolutas del sistema de archivos , es muy útil y permite ahorrar mucho tiempo y equivocaciones escribiendo nombres de ficheros o directorios en la línea de comandos. Sin duda, una importantísima característica para los que no nos sobra el tiempo :-)
Ya hemos dado un repasito a algunas cosas básicas de la terminal BASH. Por lo menos ya no estás perdido, practica todo esto un poco, y también léelo de vez en cuando, porque conforme vayas practicando, mejor comprenderás algunas cosas que ahora no eres capaz de comprender o asimilar sin haber visto otras primero. El dominio de la terminal BASH en un sistema Linux es imprescindible, porque (afortunadamente) no hay GUIs (interfaces de usuario gráficas) para todo lo que podemos hacer en nuestro sistema. Verás como aunque estás trabajando en modo gráfico dentro de unas horas o unos días, tendrás abierta casi siempre una ventan de la terminal en modo gráfico para hacer todas esas cosas que sólo es posible (y más eficiente) hacerlas desde una terminal o que son más flexibles desde la línea de comandos.
No hay comentarios:
Publicar un comentario