viernes, 29 de mayo de 2015

Redireccionando la entrada estándar

Hasta ahora, no hemos encontrado ningún comando que haga uso de la entrada estándar (en realidad sí lo hemos hecho, pero revelaremos la sorpresa un poco más tarde), así que necesitamos presentar uno.

jueves, 28 de mayo de 2015

/dev/null en la cultura Unix

El cubo de bits es un antiguo concepto de Unix y, debido a su universalidad, ha aparecido en muchas partes de la cultura Unix. Cuando alguien dice que está enviando tus comentarios a /dev/null, ahora ya sabes lo que significa. Para ver más ejemplos, lee el artículo de la Wikipedia sobre "/dev/null".

Eliminando salidas innecesarias

Algunas veces “el silencio es oro”, y no queremos la salida de un comando, sólo queremos ignorarla. Esto se aplica particularmente a los mensajes de estado y de error. El sistema proporciona una forma de hacerlo redireccionando la salida a un archivo especial llamado “dev/null”. Este archivo es un dispositivo del sistema llamado un cubo de bits (bit bucket) que acepta entradas y no hace nada con ellas. Para suprimir los mensajes de error de un comando, hacemos esto:

[me@linuxbox ~]$ ls -l /bin/usr 2> /dev/null

miércoles, 27 de mayo de 2015

Redirigiendo la salida estándar y el error estándar a un archivo

Hay casos en que querremos capturar toda la salida de un comando a un archivo. Para hacerlo, debemos redirigir tanto la salida estándar como el error estándar al mismo tiempo. Hay dos formas de hacerlo. Primero, la forma tradicional, que funciona con versiones antiguas del shell:

[me@linuxbox ~]$ ls -l /bin/usr > ls-output.txt 2>&1

Utilizando este método, conseguiremos dos redirecciones. Primero redirigimos la salida estándar al archivo ls-output.txt y después redirigimos el descriptor de archivo 2 (error estándar) al descriptor de archivo 1 (salida estándar) usando la notación 2>&1.

Fíjate que el orden de las redirecciones es fundamental. La redirección del error estándar siempre debe ocurrir después de redirigir la salida estándar o no funcionará. En el ejemplo anterior,

>ls-output.txt 2>&1

se redirige el error estándar al archivo ls-output.txt, pero si cambiamos el orden a

2>&1 >ls-output.txt

el error estándar es redirigido a la pantalla.

Versiones recientes de bash proporcionan un segundo, y más eficiente método para realizar esta redirección combinada:

[me@linuxbox ~]$ ls -l /bin/usr &> ls-output.txt

En este ejemplo, usamos la notación simple &> para redirigir tanto la salida estándar como el error estándar al archivo ls-output.txt. Podrías también añadir la salida estándar y el error estándar a un archivo existente así:

[me@linuxbox ~]$ ls -l /bin/usr &>> ls-output.txt

martes, 26 de mayo de 2015

Redirigiendo el error estándar

Redirigir el error estándar carece de la facilidad de un operador de redirección dedicado. Para redirigir el error estándar debemos referirnos a su descriptor de archivo (file descriptor). Un programa puede producir salidas en una secuencia de varios archivos numerados. Aunque nos hemos referido a los tres primeros de esta secuencia de archivos como entrada estándar, salida estándar y error estándar, el shell se refiere a ellos internamente con los descriptores de archivo 0, 1 y 2 respectivamente. El shell proporciona una notación para redirigir archivos utilizando el número de descriptor de archivo. Como el error estándar es el mismo que el descriptor de archivo número 2, podemos redirigir el error estándar con esta notación:

[me@linuxbox ~]$ ls -l /bin/usr 2> ls-error.txt

El descriptor de archivo “2” se coloca inmediatamente antes del operador de redirección para realizar la redirección del error estándar al archivo ls-error.txt.

lunes, 25 de mayo de 2015

Redirigiendo la salida estándar

La redirección I/O nos permite redefinir dónde va la salida estándar. Para redirigir la salida estándar a otro archivo en lugar de a la pantalla, usamos el operador de redirección “>” seguido del nombre del archivo. ¿Para qué querríamos hacer esto? A menudo es útil almacenar la salida de un comando en un archivo. Por ejemplo, podríamos decirle al shell que mande la salida del comando ls al archivo ls-output.txt en lugar de a la pantalla:

[me@linuxbox ~]$ ls -l /usr/bin > ls-output.txt

Aquí, hemos creado un largo listado del directorio /usr/bin y hemos mandado los resultados al archivo ls-output.txt. Examinemos la salida redirigida del comando:

[me@linuxbox ~]$ ls -l ls-output.txt
-rw-rw-r-- 1 me me 167878 2008-02-01 15:07 ls-output.txt

Bien, un bonito y largo archivo de texto. Si vemos el archivo con less, veremos que el archivo ls-output.txt en efecto contiene el resultado del nuestro comando ls:

[me@linuxbox ~]$ less ls-output.txt

Ahora, repitamos nuestra prueba de redirección, pero esta vez con un giro. Cambiaremos el nombre del directorio a uno que no exista:

[me@linuxbox ~]$ ls -l /bin/usr > ls-output.txt
ls: cannot access /bin/usr: No such file or directory

Recibimos un mensaje de error. Esto tiene sentido ya que hemos especificado el directorio /bin/usr que no existe, pero ¿por qué ha mostrado el mensaje de error en la pantalla en lugar que ser redirigido al archivo ls-output.txt? La respuesta es que el programa ls no manda sus mensajes de error a la salida estándar. En lugar de eso, como la mayoría de los programas bien escritos de Unix, manda sus mensajes de error al error estándar. Como sólo hemos redirigido la salida estándar y no el error estándar, el mensaje de error todavía es enviado a la pantalla. Veremos  como redirigir el error estándar en un minuto, pero primero, veamos que ha ocurrido a nuestro archivo de salida:

[me@linuxbox ~]$ ls -l ls-output.txt
-rw-rw-r-- 1 me me 0 2008-02-01 15:08 ls-output.txt

¡El archivo ahora tiene tamaño cero! Esto se debe a que, cuando redirigimos la salida con el operador de redirección “>”, el archivo de destino siempre se sobreescribe desde el principio. Como nuestro comando ls no generó resultados  y sólo un mensaje de error, la operación de redirección comenzó a reescribir el archivo y paró a causa del error, lo que provocó que se truncase. De hecho, si alguna vez necesitamos realmente un archivo truncado (o crear un archivo nuevo vacío) podemos usar un truco como este:

[me@linuxbox ~]$ > ls-output.txt

Simplemente usando el operador de redirección con ningún comando precediéndolo truncará un archivo existente o creará un archivo nuevo vacío.

Pero, ¿cómo podemos añadir la salida redirigida a un archivo en lugar de sobrescribir el archivo desde el principio? Para eso, usamos el operador de redirección “>>”, así:

[me@linuxbox ~]$ ls -l /usr/bin >> ls-output.txt

Usando el operador “>>” tendremos como resultado que la salida se añadirá al archivo. Si el archivo no existe, se creará igual que como con el operador “>” que hemos estado usando. Probémoslo:

[me@linuxbox ~]$ ls -l /usr/bin >> ls-output.txt
[me@linuxbox ~]$ ls -l /usr/bin >> ls-output.txt
[me@linuxbox ~]$ ls -l /usr/bin >> ls-output.txt
[me@linuxbox ~]$ ls -l ls-output.txt
-rw-rw-r-- 1 me me 503634 2008-02-01 15:45 ls-output.txt

Hemos repetido el comando tres veces resultando un archivo de salida tres veces más grande.

viernes, 22 de mayo de 2015

Entrada, salida y error estándar

Muchos de los programas que hemos usado hasta ahora producen algún tipo de salida. Esta salida, a menudo es de dos tipos. Primero, tenemos los resultados del programa; es decir, los datos que el programa está diseñado para producir, y segundo, tenemos mensajes de estado y de error que nos dicen cómo va el programa. Si observamos un comando como ls, podemos ver que muestra sus resultados y sus mensajes de error en la pantalla.

Siguiendo con el tema Unix de “todo es un archivo”, programas como ls en realidad mandan sus resultados a un archivo especial llamado standard output o salida estándar (a menudo expresado como stdout) y sus mensajes de estado a otro archivo llamado standard error o error estándar (stderr). Por defecto, tanto la salida estándar como el error estándar están vinculados a la pantalla y no se guardan en un archivo en el disco.

Además muchos programas toman la entrada de una característica llamada standard input o entrada estándar (stdin) que está, por defecto, asociada al teclado.

La redirección I/O nos permite cambiar dónde va la salida y de dónde viene la entrada. Normalmente, la salida va a la pantalla y la entrada viene del teclado, pero con la redirección I/O, podemos cambiarlo.

jueves, 21 de mayo de 2015

Redirección

En esta lección vamos a desvelar la que podría ser la mejor característica de la línea de comandos. Se llama redirección I/O. I/O significa input/output y con esta característica puedes redirigir la salida y entrada de los comandos hacia o desde archivos, así como conectar múltiples comandos juntos con poderosos “conductos” o pipelines (Tuberías) de comandos. Para mostrar esta característica introduciremos los siguientes comandos:
  • cat – Concatena archivos
  • sort – Ordena líneas de texto
  • uniq – Reporta u omite líneas repetidas
  • grep – Imprime lineas que coincidan con un patrón
  • wc – Imprime el número de líneas, palabras y bytes para cada archivo
  • head – Imprime la primera parte de un archivo
  • tail – Imprime la última parte de un archivo
  • tee – Lee de la entrada estándar y escribe en la salida estándar y en archivos

miércoles, 20 de mayo de 2015

Para saber más

Hay muchas fuentes de documentación online para Linux y la línea de comandos. Aquí tienes algunas de las mejores:
  • El Bash FAQ contiene respuestas a preguntas frecuentes sobre bash. Esta lista está dirigida a usuarios de nivel intermedio a avanzado, pero contiene un montón de buena información.
    http://mywiki.wooledge.org/BashFAQ
  • El Proyecto GNU provee una extensa documentación para sus programas, los cuales forman el corazón de la experiencia con la línea de comandos de Linux. Puedes ver una lista completa aquí:
    http://www.gnu.org/manual/manual.html

martes, 19 de mayo de 2015

Resumiendo

Ahora que hemos aprendido cómo encontrar documentación sobre los comandos, échale un vistazo a la documentación de todos los comandos que hemos visto hasta ahora. Estudia qué opciones adicionales están disponibles y ¡prúebalas!

lunes, 18 de mayo de 2015

Creando tus propios comandos con alias

¡Ahora para nuestra primera experiencia con la programación! Crearemos un comando propio usando el comando alias. Pero antes de empezar, necesitamos desvelar un pequeño truco de la línea de comandos. Es posible poner más de un comando en una línea separando cada comando con un punto y coma. Funciona así:

comando1; comando2; comando3...

Aquí tenemos el ejemplo que usaremos:

[me@linuxbox ~]$ cd /usr; ls; cd -
bin  games   kerberos lib64   local share tmp
etc  include lib      libexec sbin  src
/home/me
[me@linuxbox ~]$

Como podemos ver, hemos combinado tres comandos en una línea. Primero hemos cambiado el directorio a /usr luego hemos listado el directorio y finalmente hemos vuelto al directorio original (usando 'cd -') con lo que hemos terminado donde empezamos. Ahora convirtamos esta secuencia en un nuevo comando usando alias. La primera cosa que tenemos que hacer es inventarnos un nombre para nuestro nuevo comando. Probemos “test”. Antes de hacerlo, sería una buena idea averiguar si el nombre “test” ya está siendo usado. Para averiguarlo, podemos usar el comando type de nuevo:

[me@linuxbox ~]$ type test
test is a shell builtin

Ups! El nombre “test” ya está cogido. Probemos “foo”:

[me@linuxbox ~]$ type foo
bash: type: foo: not found

¡Genial! “foo” no está cogido. Así que creemos nuestro alias:

[me@linuxbox ~]$ alias foo='cd /usr; ls; cd -'

Fíjate en la estructura de este comando:

alias name='string'

Tras el comando “alias” le damos a alias un nombre seguido inmediatamente (sin espacios en blanco) por un signo igual, seguido inmediatamente por una cadena entre comillas simples conteniendo los comandos que se asignarán al nombre. Después de definir nuestro alias, puede ser usado donde quiera que el shell acepte comandos. Probemos:

[me@linuxbox ~]$ foo
bin  games   kerberos lib64   local share tmp
etc  include lib      libexec sbin  src
/home/me
[me@linuxbox ~]$

También podemos usar el comando type de nuevo para ver nuestro alias:

[me@linuxbox ~]$ type foo
foo is aliased to `cd /usr; ls ; cd -'

Para eliminar un alias, se usa el comando unalias, así:

[me@linuxbox ~]$ unalias foo
[me@linuxbox ~]$ type foo
bash: type: foo: not found

Aunque evitamos a propósito nombrar nuestro alias con un nombre de comando existente, no es raro que se haga. Generalmente se hace para aplicar una opción que se utilice a menudo en cada invocación de un comando común. Por ejemplo, vimos antes que el comando ls a menudo es un alias con soporte para colores:

[me@linuxbox ~]$ type ls
ls is aliased to `ls –color=tty'

Para ver todos los alias definidos en nuestro entorno, utiliza el comando alias sin argumentos. Aquí tienes algunos de los alias definidos por defecto en un sistema Fedora. Pruébalo e imagina para qué sirve cada uno:

[me@linuxbox ~]$ alias
alias l.='ls -d .* --color=tty'
alias ll='ls -l --color=tty'
alias ls='ls –color=tty'

Hay un pequeño problema con la definición de alias en la línea de comandos. Se esfuman cuando la sesión de shell se cierra. En próximos capítulos, veremos cómo añadir nuestros alias a archivos que establecen el entorno cada vez que iniciamos sesión, pero por ahora, disfruta del hecho de que hemos dado nuestro primer paso, aunque sea pequeño, ¡en el mundo de la programación en shell!

domingo, 17 de mayo de 2015

README y otros archivos con documentación de programas

Muchos paquetes de software instalados en tu sistema tienen archivos de documentación localizados en el directorio /usr/share/doc. La mayoría de ellos están en formato de texto plano y pueden ser leídos con less. Algunos de estos archivos están en formato HTML y se pueden abrir con un navegador web. Encontraremos algunos archivos que terminan con la extensión “.gz”. Esto indica que han sido comprimidos con el programa de compresión gzip.  El paquete gzip incluye una versión especial de less llamada zless que mostrará el contenido de los archivos de texto comprimidos con gzip.

sábado, 16 de mayo de 2015

info – Muestra un archivo de información de un programa

El Proyecto GNU proporciona una alternativa a las man pages para sus programas, llamada “info”. Las páginas info se muestran con un programa lector llamado, muy apropiadamente, info. Las páginas info están hiperenlazadas como las páginas web. Aquí tenemos un ejemplo:

File: coreutils.info, Node: ls invocation, Next: dir invocation,
Up: Directory listing

10.1 `ls': List directory contents
==================================


The `ls' program lists information about files (of any type, including directories). Options and file arguments can be intermixed arbitrarily, as usual.


   For non-option command-line arguments that are directories, by default `ls' lists the contents of directories, not recursively, and omitting files with names beginning with `.'. For other non-option arguments, by default `ls' lists just the filename. If no non-option argument is specified, `ls' operates on the current directory, acting as if it had been invoked with a single argument of `.'.


    By default, the output is sorted alphabetically, according to the 
--zz-Info: (coreutils.info.gz)ls invocation, 63 lines –Top-----------

El programa info lee archivos info, que tienen una estructura de árbol con nodos individuales, cada uno de los cuales contiene un asunto concreto. Los archivos info contienen hipervínculos que permiten movernos de un nodo a otro. Un hipervínculo puede identificarse por su asterisco delante, y se activa colocando el cursor encima y presionando la tecla enter.

Para invocar a info, escribe “info” seguido opcionalmente del nombre de un programa. A continuación tienes una tabla de comandos usados para controlar el lector mientras muestra una página info:

Tabla 5-2: Comandos info
Comando Acción
? Muestra la ayuda de un comando
RePág o Retroceso Muestra la página previa
AvPág o Espacio Muestra la siguiente página
n Siguiente – Muestra el siguiente nodo
p Previo – Muestra el nodo anterior
u Up – Muestra el nodo padre del nodo mostrado actualmente, normalmente un menú.
Enter Sigue el hipervínculo que está bajo el cursor
q Salir

La mayoría de los programas de la línea de comandos que hemos visto hasta ahora son parte del paquete “coreutils” del Proyecto GNU, así que escribiendo:

[me@linuxbox ~]$ info coreutils

mostrará una página con un menú con hipervínculos a cada programa contenido en el paquete coreutils.

viernes, 15 de mayo de 2015

La man page más brutal de todas

Como hemos visto, las man pages proporcionadas por Linux y otros sistemas tipo Unix están pensadas como una documentación de referencia y no como tutoriales. Muchas man pages son duras de leer, pero pienso que el gran premio a la dificultad tiene que ir a la man page de bash. Cuando estaba haciendo mi investigación para este libro, la revisé cuidadosamente para asegurarme que estaba cubriendo la mayoría de sus temas. Cuando se imprime, son más de 80 páginas extremadamente densas, y su estructura no tiene absolutamente ningún sentido para un usuario nuevo.

Por otra parte, es muy precisa y concisa, además de ser extremadamente completa. Así que échale un vistazo si te atreves e imagínate el día en que puedas leerla y tenga sentido.

jueves, 14 de mayo de 2015

whatis – Muestra una descripción muy breve de un comando

El programa whatis muestra el nombre y una descripción de una línea de una man page coincidente con una palabra especificada:

[me@linuxbox ~]$ whatis ls
ls               (1) - list directory contents

miércoles, 13 de mayo de 2015

apropos – Muestra comandos apropiados

También es posible buscar en el listado de las man pages posibles coincidencias basadas en un término de búsqueda. Es muy tosco pero a veces ayuda. Aquí tienes un ejemplo de una búsqueda en las man pages utilizando el término de búsqueda “floppy”:

[me@linuxbox ~]$ apropos floppy
create_floppy_devices (8) - udev callout to create all possible floppy device based on the CMOS type
fdformat              (8) - Low-level formats a floppy disk
floppy                (8) - format floppy disks
gfloppy               (1) - a simple floppy formatter for the GNOME
mbadblocks            (1) - tests a floppy disk, and marks the bad blocks in the FAT
mformat               (1) - add an MSDOS filesystem to a low-level formatted floppy disk 

El primer campo de cada línea es el nombre de la man page, el segundo campo muestra la sección. Fíjate que el comando man con la opción “-k” ofrece exactamente la misma función que apropos.

martes, 12 de mayo de 2015

man – Muestra el manual de un programa

La mayoría de los programas ejecutables pensados para usarse en la línea de comandos proveen un documento llamado manual page o man page. Se usa un programa de paginación especial llamado man para verlos. Se usa así:

man programa

donde “programa” es el nombre del comando que queremos ver.

Las man pages varían algo en formato pero generalmente contienen un título, una sinopsis de la sintaxis del comando, una descripción del propósito del comando y una lista y descripción de cada opción del comando. Las man pages, de todas formas, no suelen incluir ejemplos, y están pensadas como una referencia, no como un tutorial. Como ejemplo, probaremos a ver la man page para el comando ls:

[me@linuxbox ~]$ man ls

En la mayoría de los sistemas Linux, man usa less para mostrar la man page, así que todos los comandos de less que nos son familiares funcionan cuando está mostrado la página.

El “manual” que man muestra está dividido en secciones y no sólo cubre los comandos de usuario sino también los comandos del administrador de sistema, interfaces de programación, formatos de archivo y más. La tabla siguiente describe la estructura del manual:

Tabla 5-1: Organización de la man page
Sección Contenido
1 Comandos de usuario
2 Interfaces de programación para llamadas del sistema al kernel
3 Interfaces de programación para la biblioteca C
4 Archivos especiales como nodos de dispositivos y controladores
5 Formatos de archivo
6 Juegos y pasatiempos como protectores de pantalla
7 Miscelánea
8 Comandos de administración del sistema

A veces necesitamos buscar en una sección específica del manual para encontrar lo que estamos buscando. Esto es particularmente cierto si estamos buscando un formato de archivo que también es el nombre de un comando. Sin especificar un número de sección, siempre obtendremos el primer resultado, probablemente en la sección 1. Para especificar un número de sección, usamos man así:

man sección término_buscado

Por ejemplo:

[me@linuxbox ~]$ man 5 passwd

Esto mostrará la man page describiendo el formato de archivo del archivo /etc/passwd.

lunes, 11 de mayo de 2015

--help – Muestra información de uso

Muchos programas ejecutables soportan una opción “--help” que muestra una descripción de la sintaxis y las opciones soportadas por el comando. Por ejemplo:

[me@linuxbox ~]$ mkdir --help
Usage: mkdir [OPTION] DIRECTORY...
Create the DIRECTORY(ies), if they do not already exist.

    -Z, --context=CONTEXT (SELinux) set security context to CONTEXT Mandatory arguments to long options are mandatory for short options too.
    -m, --mode=MODE   set file mode (as in chmod), not a=rwx – umask
    -p, --parents     no error if existing, make parent directories as needed
    -v, --verbose     print a message for each created directory
        --help        display this help and exit
        --version     output version information and exit


Report bugs to <bug-coreutils@gnu.org>.

Algunos programas no soportan la opción “--help”, pero pruébalo de todas formas. A menudo el resultado es un error que revelará la misma información de uso.

domingo, 10 de mayo de 2015

help – Ofrece ayuda sobre los shell builtins

bash tiene una ayuda integrada disponible para cada shell builtin. Para usarla, escribimos “help” seguido del nombre del shell builtin. Por ejemplo:

[me@linuxbox ~]$ help cd
cd: cd [-L|[-P [-e]]] [dir]
Change the shell working directory.

Change the current directory to DIR. The default DIR is the value of the HOME shell variable.

The variable CDPATH defines the search path for the directory containing DIR. Alternative directory names in CDPATH are separated by a colon (:). A null directory name is the same as the current directory. If DIR begins with a slash (/), then CDPATH is not used.

If the directory is not found, and the shell option `cdable_vars' is set, the word is assumed to be a variable name. If that variable has a value, its value is used for DIR.

Options:
-L   force symbolic links to be followed
-P   use the physical directory structure without following symbolic links
-e   if the -P option is supplied, and the current working directory cannot be determined successfully, exit with a non-zero status

The default is to follow symbolic links, as if `-L' were specified.

Exit Status:
Returns 0 if the directory is changed, and if $PWD is set successfully when -P is used; non-zero otherwise.

Una nota sobre la notación: Cuando aparecen corchetes en la descripción de la sintaxis de un comando, indican opciones adicionales. Una barra vertical indica que son elementos excluyentes entre ellos. En el caso del comando cd que vimos antes:

cd [-L|[-P[-e]]] [dir]

Esta notación dice que el comando cd podría ir seguido opcionalmente por una “-L” o una “-P” y después, si la opción “-P” está especificada, la opción “-e” podría también ser incluida seguida por el argumento opcional “dir”.

Si bien la salida de help para el comando cd es concisa y precisa, de ninguna manera es un tutorial y, como podemos ver, también parece mencionar muchas cosas de las que aún no hemos hablado. No te preocupes. Llegaremos a ello.

sábado, 9 de mayo de 2015

Obteniendo la documentación de un comando

Ahora que sabemos qué es un comando, podemos buscar la documentación disponible para cada tipo de comando.

viernes, 8 de mayo de 2015

which – Muestra la localización de un ejecutable

A veces hay más de una versión de un programa ejecutable instalada en un sistema. Aunque no es muy usual en los sistemas de escritorio, sí es más frecuente en grandes servidores. Para determinar la localización exacta de un ejecutable dado tenemos el comando which:

[me@linuxbox ~]$ which ls
/bin/ls

which sólo funciona con programas ejecutables, ni con builtins ni con alias que son sustitutos de los verdaderos programas ejecutables. Cuando intentamos usar which en un shell builtin, por ejemplo, cd, no tendremos respuesta o nos dará un mensaje de error:

[me@linuxbox ~]$ which cd
/usr/bin/which: no cd in (/opt/jre1.6.0_03/bin:/usr/lib/qt-3.3/bin:/usr/kerberos/bin:/opt/jre1.6.0_03/bin:/usr/lib/ccache:/usr/local/bin:/usr/bin:/bin:/home/me/bin)

que es una forma elegante de decir “comando no encontrado”.

jueves, 7 de mayo de 2015

type – Muestra de qué tipo es un comando

El comando type es un shell builtin que muestra el tipo de comando que el shell ejecutará, indicándole el nombre de un comando en particular. Funciona así:

type comando

donde "comando" es el nombre del comando que quieres examinar. Aquí tienes algunos ejemplos:

[me@linuxbox ~]$ type type
type is a shell builtin
[me@linuxbox ~]$ type ls
ls is aliased to `ls --color=tty'
[me@linuxbox ~]$ type cp
cp is /bin/cp

Aquí vemos los resultados para tres comandos diferentes. Fíjate en el de ls (realizado sobre un sistema Fedora) y en cómo el comando ls es realmente un alias del comando ls con la opción “--color=tty” añadida. ¡Ahora sabemos porqué la salida de ls se muestra en color!

miércoles, 6 de mayo de 2015

Identificando comandos

A menudo es útil saber exactamente cual de los cuatro tipos de comandos estamos usando y Linux proporciona un par de formas de averiguarlo.

martes, 5 de mayo de 2015

¿Qué son exactamente los comandos?

Un comando puede ser una de estas cuatro cosas:
  1. Un programa ejecutable como todos esos archivos que vimos en /usr/bin. Dentro de esta categoría, los programas pueden ser binarios compilados como programas escritos en C y C++, o programas escritos en lenguajes de script como el shell, perl, python, ruby, etc.
  2. Un comando contenido en el propio shell. bash soporta gran número de comandos internos llamados shell builtins. El comando cd, por ejemplo, es un shell builtin.
  3. Una función del shell. Estos son pequeños scripts de shell incorporados en el entorno. Veremos cómo configurar el entorno y cómo escribir funciones del shell en próximos capítulos, pero por ahora, sólo ten en cuenta que existen.
  4. Un alias. Comando que podemos definir nosotros mismos, construidos a partir de otros comandos.

lunes, 4 de mayo de 2015

Trabajando con comandos

Hasta este punto, hemos visto una serie de misteriosos comandos, cada uno con sus misteriosas opciones y argumentos. En este capítulo, intentaremos resolver algunos de estos misterios e incluso crear algunos comandos propios. Los comandos presentados en este capítulo son:
  • type – Indica cómo se interpreta el nombre de un comando
  • which – Muestra qué programa ejecutable será ejecutado
  • help – Ofrece ayuda para los comandos shell builtins
  • man – Muestra el manual de un comando
  • apropos – Muestra una lista de comandos apropiados
  • info – Muestra información sobre un comando
  • whatis – Muestra una descripción muy breve de un comando
  • alias – Crea un alias para un comando

sábado, 2 de mayo de 2015

Resumiendo

Hemos abarcado mucho terreno y tardaremos un tiempo en asimilarlo todo. Realiza el ejercicio del terreno de juego una y otra vez hasta que tenga sentido. Es importante entender bien los comandos básicos de manipulación de archivos y los comodines. Siéntete libre para ampliar el ejercicio del terreno de juego añadiendo más archivos y directorios, usando comodines para especificar archivos para varias operaciones. El concepto de enlace es un poco confuso al principio, pero tómate tiempo para aprender cómo funcionan. Pueden ser un verdadero salvavidas.

viernes, 1 de mayo de 2015

Creando enlaces simbólicos con la GUI

Los gestores de archivos, tanto en GNOME como en KDE, proporcionan un método fácil y automático para crear enlaces simbólicos. Con GNOME, presionando las teclas Ctrl+Shift mientras arrastramos un archivo se creará un enlace en lugar de copiar (o mover) el archivo. En KDE un pequeño menú aparece donde arrastremos el archivo, ofreciendo la opción de copiarlo, moverlo o enlazarlo.