Hasta este momento se han visto los entornos gráficos existentes para //Linux// más importantes, no obstante cualquier usuario de //Linux// acabará antes o después relacionándose con el sistema empleando el modo texto. Este modo se basa en la ejecución de una serie de comandos, que son interpretados por un programa o //shell//. //Linux// dispone de varios de estos programas pero el más habitual es conocido como //bash// o //Bourne Shell//. Si //Linux// se ha arrancado en modo texto el sistema arranca de forma directa el //shell //y queda a la espera de introducción de nuevos comandos. Si se ha arrancado en modo gráfico se puede acceder al //shell// de dos formas:
Esto hace que el sistema salga del modo gráfico y acceda a alguna de las seis consolas virtuales de //Linux//, a las cuales también se puede acceder cuando se arranca en modo de texto. Para volver al modo gráfico hay que presionar //++// o //++//.
La segunda forma es más cómoda y menos radical permitiendo acceder al shell desde el mismo entorno gráfico. Para esto hay que abrir un programa llamado terminal o consola, por ejemplo: //kconsole //(en el entorno //KDE//)//, xterm, gnome-terminal //(en //GNOME//), etc como se ha visto anteriormente.
Introducción
Existen una serie de nociones básicas que hay que tener en cuenta a la hora de introducir los comandos. En primer lugar citaremos las siguientes:
· Los comandos hay que teclearlos exactamente.
· Las letras mayúsculas y minúsculas se consideran como diferentes.
· En su forma más habitual (los //shells //de Bourne o de Korn), el sistema operativo utiliza un signo de //$// como //prompt //para indicar que está preparado para aceptar comandos, aunque este carácter puede ser fácilmente sustituido por otro u otros elegidos por el usuario. En el caso de que el usuario acceda como administrador este signo se sustituye por //#//.
· Cuando sea necesario introducir el nombre de un fichero o directorio como argumento a un comando, //Linux//, permite escribir las primeras letras del mismo y realiza un autorrellenado al presionar la tecla del //tabulador//. Si no puede distinguir entre diversos casos rellenará hasta el punto en el que se diferencien. Por ejemplo, supongamos una carpeta con los siguientes directorios:
· //Programas //
· //Documentos_proyecto //
· //Documentos_privados //
Al escribir //cd Pr Linux// rellenará el resto del contenido hasta escribir //cd Programas//. Por el contrario al escribir //cd D// escribirá //cd Documentos_ //
Algunos Comandos Sencillos de //LINUX //
Para efectuar el cambio o la introducción de un //password// o //contraseña// se utiliza el comando //passwd//. El proceso a seguir es el siguiente:
//passwd (current) UNIX password//: (se teclea la contraseña actual; no aparece en pantalla)
//New UNIX password//: (se teclea la nueva contraseña; no aparece en pantalla)
//Retype new UNIX password//: (se teclea de nuevo la nueva contraseña comprobando que se ha tecleado bien. Si no coincide no se cambia produce el cambio).
A continuación se describen algunos comandos sencillos de que pueden ser útiles para familiarizarse con los comandos del sistema.
//date //Muestra por pantalla el día y la hora.
//cal 1949 //Muestra el calendario del año 1949.
//cal 05 1949 //Muestra el calendario de mayo de 1949.
//who //Indica qué usuarios tiene el ordenador en ese momento, en qué terminal están y desde qué hora.
//whoami //Indica cuál es la terminal y la sesión en la que se está trabajando.
//man comando //Todos los manuales de //Linux// están dentro del propio sistema operativo, y este comando permite acceder a la información correspondiente al comando //comando//. Por ejemplo con //man who //aparecerá por pantalla y de forma formateada por páginas, la explicación del comando //who//. Se puede navegar a través de estas páginas con los cursores del teclado, y presionando q para salir.
//clear //Este comando limpia la consola
Directorio Personal
Como se ha visto anteriormente el directorio personal es un directorio con un determinado nombre asignado a un usuario. Los directorios personales habitualmente son subdirectorios de ///home// (en algunos casos se utiliza //mnt//, u otro subdirectorio de orden inferior). Generalmente el nombre coincide con el del //nombre de usuario//, aunque puede no ser así, y varios usuarios pueden estar trabajando en el mismo directorio. Cada usuario de //Linux// puede crear una estructura en árbol de subdirectorios y archivos tan compleja como desee bajo su directorio personal pero normalmente nunca fuera de él.
Listado del contenido de directorios: comando ls
Una de las acciones más habituales a la hora de trabajar es mostrar el contenido de un directorio, como se ha visto existen herramientas gráficas con este fin, no obstante el //shell// incluye un programa con este mismo fin: //ls//,
|| //ls// || Muestra los nombres de los ficheros y subdirectorios contenidos en el directorio en el que se está. Sólo se obtienen los nombres de los ficheros, sin ninguna otra información. ||
|| //ls -a// || Muestra todos los ficheros incluyendo algunos que ordinariamente están ocultos para el usuario (aquellos que comienzan por un punto). Se recuerda que el fichero punto. Indica el directorio actual y el doble punto .. El directorio padre, que contiene, al actual. ||
|| //ls -l// || Esta es la opción de lista larga: muestra toda la información de cada fichero incluyendo: protecciones, tamaño y fecha de creación o del último cambio introducido,... ||
|| //ls -c// || Muestra ordenando por día y hora de creación. ||
|| //ls -t// || Muestra ordenando por día y hora de modificación. ||
|| //ls -r// || Muestra el directorio y lo ordena en orden inverso. ||
|| //ls subdir// || Muestra el contenido del subdirectorio //subdir//. ||
|| //ls -l filename// || Muestra toda la información sobre el fichero. ||
|| //ls --color// || Muestra el contenido del directorio coloreado. ||
Las opciones anteriores pueden combinarse. Por ejemplo:
//ls -cr //Muestra el directorio ordenando inversamente por fechas.
El comando //ls// admite los caracteres de sustitución o metacarácteres (//*//)y (//?//). El carácter //* //representa cualquier conjunto o secuencia de caracteres. El carácter //?// representa cualquier carácter, pero sólo uno. Por ejemplo:
//ls *.gif //Muestra todos los nombres de ficheros que acaben en //.gif//, por ejemplo //dib1.gif, a.gif//, etc.
//ls file? //Muestra todos los ficheros cuyos nombres empiecen por //file// y tengan un nombre de cinco caracteres, por ejemplo: //file1, file2, filea//, etc.
Creación de subdirectorios. Comando mkdir
El comando //mkdir// (//make directory//) permite a cada usuario crear un nuevo subdirectorio:
//mkdir subdir1 //donde //subdir// es el nombre del directorio que se va a crear.
Borrado de subdirectorios. Comando rmdir
Este comando borra uno o más directorios del sistema (//remove directory//), siempre que estos subdirectorios estén vacíos. Por ejemplo:
//rmdir subdir1 //donde //subdir// es el nombre del directorio que se va a eliminar.
Cambio de directorio. Comando cd
Este comando permite cambiar de directorio a partir del directorio actual de trabajo. Por ejemplo,
//cd /home/Pedro //En este ejemplo pasamos del directorio actual de trabajo al nuevo directorio ///home/Pedro//, que será desde ahora nuestro nuevo directorio.
//cd dire //Nos traslada al subdirectorio //dire// (que deberá existir como subdirectorio en el directorio actual).
//cd .. //Retrocedemos un nivel en la jerarquía de directorios. Por ejemplo, si estamos en ///home/Pedro// y usamos este comando, pasaremos al escalafón inmediatamente superior de la jerarquía de directorios, en este caso a ///home//. Nota: al contrario que en //MS-DOS// en //Linux// no existe la forma cd.. sin espacio entre cd y los dos puntos.
//cd //Nos sitúa nuevamente en el directorio personal del usuario.
Situación actual. Comando pwd
El comando //pwd// (//print working directory//) visualiza o imprime la ruta del directorio en el que nos encontramos en este momento. Este comando es uno de los pocos que no tiene opciones y se utiliza escribiendo simplemente //pwd//.
Acceso a unidades de disco
//Linux// a diferencia de //Windows //no utiliza letras ("a:", "c:", "d:", ...) para acceder a las distintas unidades de disco de un ordenador. En //Linux// para acceder al contenido de una unidad de disco o de un CD-ROM este tiene que haber sido previamente "//montado//". El //montado// se realiza mediante el comando //mount//, con lo que el contenido de la unidad se pone a disposición del usuario en el directorio de //Linux// que se elija. Por ejemplo para acceder al CD-ROM se teclearía el siguiente comando:
//mount -t iso9660 /dev/cdrom /mnt/cdrom //
donde //-t iso9660 //indica el tipo de sistema que usa la unidad de disco para guardar los ficheros (las más usuales son: //iso9660 //en el caso de un CD-ROM, //vfat// en el caso de //Windows//, y //ext2// en el caso de //Linux//), ///dev/cdrom //indica el dispositivo que se va a montar. Todos los dispositivos están representados por un fichero del directorio ///dev//, por ejemplo en el caso de un disquete será seguramente ///dev/fd0//, por último ///mnt/cdrom// es el directorio en el que se pondrá a disposición del usuario el contenido del CD-ROM. Para montar disquetes se suele utilizar el directorio ///mnt/floppy//. De todas formas el usuario siempre puede crear un directorio vacío con el nombre que el elija para montar las unidades de disco que desee donde desee.
Cuando el usuario haya dejado de usar ese disco deberá "//desmontarlo//" mediante el comando //umount// antes de sacar el disquete o el CD-ROM. En este último caso debería escribir:
//umount /mnt/cdrom //
Para utilizar el comando //mount// de la forma anterior hace falta ser administrador o //root//. Para que un usuario común pueda utilizar disquetes, CD-ROM, etc. hay que editar el fichero ///etc/fstab// Por ejemplo para que cualquier usuario pueda acceder a un disquete habrá que indicar la siguiente línea:
///dev/fd0 /mnt/floppy vfat user,noauto 0 0 //
También habrá que asegurarse de que el directorio ///mnt/floppy// sea accesible por todos los usuarios.
Una vez seguidos los pasos anteriores cualquier usuario podrá "montar" un disquete escribiendo el siguiente comando:
//mount /mnt/floppy //
Al igual que antes el usuario deberá ejecutar el comando //umount /mnt/floppy// antes de sacar el disquete.
Nota: Existen en la actualidad distribuciones (p. ej. //Linux Mandrake//) que realizan este proceso de forma automática por lo que las unidades de disquete y CD-ROM quedan accesibles a todos los usuarios de una forma sencilla, empleando los comandos:
//mount /mnt/floppy //
//umount /mnt/floppy //
siempre que ///mnt/floppy// sea la ruta adecuada.
Copia de ficheros. Comando cp
Este comando tiene la siguiente forma,
//cp file1 file2 //
y hace una copia de //file1// y le llama //file2//. Si //file2// no existía, lo crea con los mismos atributos de //file1//. Si //file2// existía antes, su contenido queda destruido y es sustituido por el de //file1//. El fichero //file2// estará en el mismo directorio que //file1//. Tanto file1 como file2 indican el nombre de un archivo, que puede incluir el la ruta al mismo si alguno de ellos no se encuentra en el directorio actual. Otra posibilidad es:
//cp file1 file2 namedir //que hace copias de //file1// y //file2 //en el directorio //namedir//.
8.3.8 Traslado y cambio de nombre de ficheros. Comando mv
Este comando tiene una forma similar al anterior ,
//mv file1 file2 //
El comando //mv// realiza la misma función que el anterior (//cp//) pero además destruye el fichero original. En definitiva traslada el contenido de //file1// a //file2//; a efectos del usuario lo que ha hecho es cambiar el nombre a //file1//, llamándole //file2//. De igual forma,
//mv file1 file2 namedir //
traslada uno o más ficheros (//file1//, //file2//,...) al directorio //namedir// conservándoles el nombre. El comando,
//mv namedir1 namedir2 //cambia el nombre del subdirectorio //namedir1 //por //namedir2//. Hay que recalcar que el comando //mv// sirve así mismo para cambiar el nombre de los ficheros.
Enlaces a ficheros. Comando ln
En //Linux //un mismo fichero puede estar repetido con más de un nombre, ya que con el comando //cp //se pueden realizar cuantas copias se desee del fichero. Pero, a veces, es más práctico tener un mismo fichero con varios nombres distintos, y lo que es más importante, poder acceder a él desde más de un directorio. En //Linux// esto recibe el nombre de enlaces múltiples a un fichero. El ahorro de espacio de disco es importante al poder compartir un fichero más de un usuario. Estos enlaces son muy prácticos a la hora de utilizar ficheros que pertenecen a directorios distintos. Gracias a los enlaces se puede acceder a muchos ficheros desde un mismo directorio, sin necesidad de copiar en ese directorio todos esos ficheros. La forma de este comando es,
//ln file1 file2 //
A partir de este momento el fichero //file1// tiene dos nombres: //file1 //y //file2//. A diferencia de los comandos //cp //y //mv//, este comando toma más precauciones, ya que advierte previamente si el nombre //file2// está ocupado, y en este caso no se ejecuta.
//ln panacea subdir/panacea //
Después de este comando el fichero //panacea// tendrá el mismo nombre, pero a efectos del usuario estará colocado en dos sitios distintos: en el directorio actual y en el subdirectorio //subdir//.
Los ficheros enlazados a otro se borran como los ficheros normales. Si se borra el fichero original permanece su contenido en los ficheros enganchados.
Borrado de ficheros. Comando rm
Este comando tiene las formas siguientes,
//rm file1 file2 //
Este comando elimina uno o más ficheros de un directorio en el cual tengamos permiso de escritura. Con este comando resulta facilísimo borrar ficheros inútiles, y desgraciadamente, también los útiles. Por eso es conveniente y casi imprescindible emplear lo opción //-i//, de la forma siguiente:
//rm -i file1 file2 //
Con esta opción, //Linux// pedirá confirmación para borrar cada fichero de la lista, de si realmente se desea su destrucción o no. Se recomienda usar siempre este comando con esta opción para evitar el borrado de ficheros útiles. Por ejemplo, si se teclea,
//rm -i superfluo //
aparecerá en pantalla el aviso siguiente:
//remove superfluo? //y habrá que contestar //y //(yes) o //n// (not). En este comando se pueden utilizar los caracteres de sustitución (//* //y //?//), como por ejemplo, //rm fich* //que borraría todos los ficheros del directorio actual que comiencen por //fich//. El comando //rm * //borrará todos los ficheros del directorio actual, mientras que
//rm -i * //
realiza una labor análoga, pero con previa confirmación.
Características de un fichero. Comando file
Este comando realiza una serie de comprobaciones en un fichero para tratar de clasificarlo. Su formato es:
//file fich //
Tras su ejecución este comando muestra el tipo del fichero e información al respecto del mismo.
Cambio de modo de los ficheros comandos chmod, chown y chgrp
Los permisos de cada fichero se pueden ver con el comando //ls -l//. Para cambiar los permisos de un fichero se emplea el comando //chmod//, que tiene el formato siguiente:
//chmod [quien] oper permiso files //
//quien //Indica a quien afecta el permiso que se desea cambiar. Es una combinación cualquiera de las letras //u// para el usuario, //g// para el grupo del usuario, //o// para los otros usuarios, y //a// para todos los anteriores. Si no se da el //quien//, el sistema supone //a//.
//oper //Indica la operación que se desea hacer con el permiso. Para dar un permiso se pondrá un //+//, y para quitarlo se pondrá un //-//.
//permiso //Indica el permiso que se quiere dar o quitar. Será una combinación cualquiera de las letras anteriores : //r,w,x,s//.
//files //Nombres de los ficheros cuyos modos de acceso se quieren cambiar.
Por ejemplo, para quitar el permiso de lectura a los usuarios de un fichero el comando es:
//chmod a -r fichero.txt //
Los permisos de lectura, escritura y ejecución tienen un significado diferente cuando se aplican a directorios y no a ficheros normales. En el caso de los directorios el permiso //r// significa la posibilidad de ver el contenido del directorio con el comando //ls//; el permiso //w// da la posibilidad de crear y borrar ficheros en ese directorio, y el permiso //x //autoriza a buscar y utilizar un fichero concreto.
Por otra parte, el comando //chown// se emplea para cambiar de propietario (“//ch//ange //own//er”) a un determinado conjunto de ficheros. Este comando sólo lo puede emplear el actual propietario de los mismos. Los nombres de propietario que admite //Linux// son los nombres de //usuario//, que están almacenados en el fichero ///etc/passwd//. La forma general del comando //chown// es la siguiente:
//chown newowner file1 file2 ... //
Análogamente, el grupo al que pertenece un fichero puede ser cambiado con el comando //chgrp//, que tiene una forma general similar a la de //chown//,
//chgrp newgroup file1 file2... //
Los grupos de usuarios están almacenados en el fichero ///etc/group//.
Espacio ocupado en el disco Comandos du y df
El comando //du// permite conocer el espacio ocupado en el disco por un determinado directorio y todos los subdirectorios que cuelgan de él. Para usarlo basta simplemente colocarse en el directorio adecuado y teclear, //du//, éste comando da el espacio de disco utilizado en bloques. Para obtener la información en bytes se debe emplear el comando con la opción //–h//: //du -h //
El comando //df //por el contrario informa del espacio usado por las particiones del sistema que se encuentren montadas.
Visualización sin formato de un fichero. Comando cat
Este comando permite visualizar el contenido de uno o más ficheros de forma no formateada. También permite copiar uno o más ficheros como apéndice de otro ya existente. Algunas formas de utilizar este comando son las siguientes,
//cat filename //Saca por pantalla el contenido del fichero //filename//.
//cat file1 file2... //Saca por pantalla, secuencialmente y según el orden especificado, el contenido de los ficheros indicados.
//cat file1 file2 >file3 //El contenido de los ficheros //file1// y //file2// es almacenado en //file3//.
//cat >file1 //Acepta lo que se introduce por el teclado y lo almacena en //file1// (se crea //file1//). Para terminar se emplea //d//
Comando head
//head -7 filename //
escribe las 7 primeras líneas del fichero filename
Visualización de ficheros con formato. Comando pr
Este comando, a diferencia de //cat//, imprime por consola el contenido de los ficheros de una manera formateada, por columnas, controlando el tamaño de página y poniendo cabeceras al comienzo de las mismas. Está muy en relación con el comando //lp// de salida por impresora. Las formas más importantes que admite son las siguientes:
//pr file //Produce una salida estándar de 66 líneas por página, con un encabezamiento de 5 líneas (2 en blanco, una de identificación y otras 2 líneas en blanco).
//pr -ln file //Produce una salida de n líneas por página (cuando el tamaño de papel de impresora, por ejemplo, tiene un número de líneas distinto de 66)
//pr -p file //Hace una pausa para presentar la página, hasta que se pulsa para continuar
//pr -t file //Suprime las 5 líneas del encabezamiento y las del final de página.
//pr -wn file //Ajusta la anchura de la línea a n posiciones.
//pr -d file //Lista el fichero con espaciado doble.
//pr -h `caracteres` file //el argumento o cadena de caracteres //`caracteres`// se convertirán en la cabecera del listado.
//pr +n file //Imprime el fichero a partir de la página n.
Además de los ejemplos anteriores, se pueden combinar varias opciones en un mismo comando, como por ejemplo en:// pr -dt file l//a salida de este comando es por la consola, pero puede redireccionarse a otro fichero, por ejemplo, si ejecutamos el comando: //pr file1 > file2 //se crea un fichero nuevo llamado //file2// que es idéntico a //file1//, pero con formato por páginas y columnas.
Visualización de ficheros pantalla a pantalla. Comandos more y less
Estos comandos permiten visualizar un fichero pantalla a pantalla. El número de líneas por pantalla es de 23 líneas de texto y una última línea de mensajes, donde aparecerá la palabra more. Cuando se pulsa la barra espaciadora (el espacio en blanco), se visualizará la siguiente pantalla. Para salir de este comando (terminar la visualización) se pulsa //d// o //q//. Por ejemplo: //more file //
El comando //less// es muy similar al anterior pero permite el desplazamiento a lo largo del texto empleando las teclas de cursores pudiendo desplazarse hacia arriba o abajo de un fichero.
