| Ambos lados, revisión anteriorRevisión previaPróxima revisión | Revisión previa |
| tutorial_de_csh [2024/07/16 18:22] – [Ejemplo de guion de shell] peron | tutorial_de_csh [2026/04/21 16:09] (actual) – editor externo 127.0.0.1 |
|---|
| ======Una Introducción a la C Shell ====== | ======Una Introducción a la C Shell ====== |
| Este tutorial es una traducción cariñosamente wikificada por //~peron// del manual "An introduction to C Shell" redactado por Bill Joy, y publicado como segundo capítulo del "UNIX Programmer's Manual" de [[versiones de bsd#4.2bsd|4.2BSD "UNIX"]], volumen 2C, edición de agosto de 1983 de la Universidad de Berkeley. | |
| | Este tutorial es una traducción cariñosamente wikificada por //~peron// del manual "An introduction to C Shell" redactado por Bill Joy, y publicado originalmente por la Univeresidad de California Berkeley en agosto de 1983 como segundo capítulo de su "UNIX Programmer's Manual" de [[versiones de bsd#4.2bsd|4.2BSD "UNIX"]]. |
| |
| |
| =====Introducción===== | =====Introducción===== |
| Una //shell// es un [[intérpretes de comandos|intérprete de lenguaje de comandos]]. //Csh// es el nombre de un intérprete de comandos particular en el UNIX de la Universidad de Berkeley. El objetivo principal de csh es traducir líneas de comando escritas en una [[terminal de computadora|terminal]] en acciones del sistema, así como la invocación de otros programas. Csh es un programa de usuario como cualquiera que podrás escribir. Con suerte... csh será un programa muy útil para interactuar con el sistema UNIX. | |
| |
| Además de este documento, querrás consultar una copia del [[https://texto-plano.xyz/~peron/inst/unix/unixv7_principiantes.html|Manual del programador de UNIX]]. La documentación de csh en el manual proporciona una descripción completa de todas las características de la shell y es una referencia final para preguntas sobre la misma. Muchas palabras de este documento aparecen en //cursiva//. Éstas son palabras importantes; nombres de comandos. y palabras que tienen un significado especial al hablar de la shell y UNIX. Muchas de las palabras están definidas en un [[#glosario|glosario]] al final de este documento. Si no sabes lo que significa una palabra, debes buscarla en el glosario. | Una //shell// es un [[intérpretes de comandos|intérprete de lenguaje de órdenes]]. //Csh// es el nombre de un intérprete de órdenes particular de la Distribución de Software UNIX la Universidad de Berkeley (BSD). El objetivo principal de csh es traducir las órdenes escritas en la línea de comandos por medio de un [[terminal de computadora|terminal]] en acciones de cómputo o invocaciones a otros programas. Csh es realmente un programa de usuario similar a cualquier otro del sistema. Con suerte... csh será un programa muy útil para interactuar con el sistema UNIX. |
| | |
| | Junto a este documento, querrás consultar una copia del [[https://texto-plano.xyz/~peron/inst/unix/unixv7_principiantes.html|Manual del programador de UNIX]]. La documentación de csh en el manual ofrece descripción completa de todas las características de la shell y oficia de referencia para todas las interrogantes sobre la misma. Muchas palabras de este documento aparecen en //cursiva//; son palabras importantes como nombres de órdenes, y palabras que tienen un significado especial al hablar de la shell y UNIX. Muchas de las palabras están definidas en un [[#glosario|glosario]] al final de este documento. Si no sabes lo que significa una palabra, consulta el glosario. |
| |
| =====Reconocimientos===== | |
| |
| ===== 1. Uso de C shell en la Terminal ===== | ===== 1. Uso de C shell en la Terminal ===== |
| |
| Normalmente la shell que estarás usando cuando te loguees a texto-plano.xyz es ''[[ksh|/bin/ksh]]''. De hecho, la mayoría de la enseñanza que verás en este tutorial aplica a ella, así también como a ''[[sh|/bin/sh]]'', | Normalmente la shell que estarás usando cuando inicies sesión a texto-plano.xyz será ''[[ksh|/bin/ksh]]''. De hecho, la mayoría de lo dictado en este tutorial aplica a ella, así también como a ''[[sh|/bin/sh]]'', |
| |
| [[csh|C Shell]] ya no es el intérprete de comandos por defecto en texto-plano.xyz, pero podrás utilizarla para poder seguir este histórico tutorial. Ingresa a ella primero: | [[csh|C Shell]] ya no es el intérprete de órdenes por defecto en texto-plano.xyz, pero podrás utilizarla anidada en otra shell cualquiera para seguir este tutorial histórico. Ingresa a ella primero: |
| |
| <code bash> | <code bash> |
| ==== La noción básica de comandos ==== | ==== La noción básica de comandos ==== |
| |
| Una shell en UNIX actúa principalmente como un medio a través del cual se invocan otros //programas//. Si bien tiene un conjunto de //funciones integradas// que realiza directamente. la mayoría de los comandos provocan la ejecución de programas que, de hecho, son externos al shell. La shell se distingue así de los intérpretes de comandos de otros sistemas por el hecho de que es simplemente un programa de usuario. y por el hecho de que se utiliza casi exclusivamente como mecanismo para invocar otros programas. | Si bien tiene un conjunto de //funciones integradas// que puede realizar directamente, una shell en UNIX actúa principalmente como un medio a través del cual se invocan otros //programas//. La mayoría de las órdenes provocan la ejecución de programas que, de hecho, son externos al shell. La shell se distingue así de los intérpretes de comandos de [[multics|otros sistemas]] por el hecho de que es simplemente un programa de usuario. y por el hecho de que se utiliza casi exclusivamente como mecanismo para invocar otros programas. |
| |
| Los //comandos// en el sistema UNIX constan de una lista de cadenas o //palabras// interpretadas como el //nombre de comando// seguido de //argumentos//. De esta forma, el comando | Las órdenes del sistema UNIX - de ahora en más, llamadas //comandos// - constan de una lista de cadenas o //palabras// interpretadas como el //nombre de comando// seguido de //argumentos//. De esta forma, el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| consta de dos palabras. La primera palabra ''mail'' nombra el comando que se ejecutará, en este caso el programa de correo que envía mensajes a otros usuarios. La shell utiliza el nombre del comando para intentar ejecutarlo por usted. Buscará en varios //directorios// un archivo con el nombre ''mail'' que se espera que contenga el programa de correo. | consta de dos palabras. La primera palabra ''mail'' llama al comando que a ejecutar (en este caso el programa de correo que envía mensajes a otros usuarios). La shell recurre al nombre del comando para cargarlo en memoria e iniciar su respectiva ejecución por usted. En este caso, buscará en varios //directorios// un archivo con el nombre ''mail'', el cuaol usted espera que contenga el programa de correo electrónico. |
| |
| El resto de las palabras del comando se dan como //argumentos// del propio comando cuando se ejecuta. En este caso especificamos también el argumento ''bill'' que el programa de correo electrónico [[mail]] interpreta como el nombre de un usuario al que se le remitirá correo electrónico. En el uso normal de la terminal, podríamos usar el comando de ''mail'' de la siguiente manera: | Las demás palabras suministradas junto al comando se interpretan como sus //argumentos//, propicios para su ejecución específica. En este caso hemos también provisto el argumento ''bill'', el cual el programa de correo electrónico [[mail]] interpreta como un nombre de usuario al cual se remitirá una pieza de correspondencia. Atendiendo a la impresión regular del terminal, el empleo del comando ''mail'' podría aparecer de la siguiente manera: |
| |
| <code bash> | <code bash> |
| % mail bill | % mail bill |
| Tengo una pregunta referente a la documentación de csh. | Tengo una pregunta en lo que refiere a la documentación de csh. |
| A mi documento parecería faltarle la sección 5. | A mi documento parecería faltarle la sección 5. |
| Existe dicha sección? | Existe dicha sección? |
| Bill | |
| EOT | EOT |
| % | % |
| </code> | </code> |
| |
| Escribimos un mensaje para enviárselo a Bill, y concluímos dicho mensaje con un ''^D'' (que envió un mensaje de //fin de archivo// al programa de correo //mail//). | Aquí se mecanografió un mensaje para remitírselo a Bill, concluyéndoselo mediante un ''^D'' (lo que transmite un mensaje de //fin de fichero// al programa de correo //mail//). |
| |
| >Aquí y en todo este documento... la notación "''^x''" debe leerse "**Control+x**" y representa presionar la tecla x mientras se mantiene presionada la tecla control. | >De ahora en más... la notación "''^x''" debe leerse "**Ctrl+x**" y representa presionar la **tecla x** mientras se mantiene presionada la **tecla Ctrl**. |
| |
| Luego, el programa de correo hizo eco de los caracteres "EOT" y transmitió nuestro mensaje. La shell imprimió los caracteres ''% '' antes y después del comando de correo para indicar que se necesitaba entrada. | A consecuencia, el programa de correo hizo eco del [[caracteres de control|caracter de control]] "EOT" y remitió nuestro mensaje. Los caracteres ''% '' antes y después del comando de correo fueron impresos por la C shell para indicar una solicitud de entrada. |
| |
| Después de presentar el mensaje ''% '', la shell leerá la entrada del comando desde nuestra terminal. Escribimos un comando completo ''mail bill''. Luego, la shell ejecutó el programa de correo //mail// con el argumento ''bill'' y quedó inactiva esperando que se completara. Luego, el programa de correo leyó la entrada de nuestra terminal hasta que le indicamos //fin del archivo// escribiendo un **^D**, tras lo cual la shell notó que el correo se había completado y nos indicó que estaba lista para leer nuevamente desde la terminal, presentando inmediatamente otro ''% ''. | Tras presentar el mensaje ''% '', la shell leerá la entrada de órdenes desde nuestra terminal. Escribimos un comando completo ''mail bill''. Luego, la shell ejecutó el programa de correo //mail// con el argumento ''bill'' y permaneció inactiva a la espera de su cumplimiento. A continuación, el programa de correo leyó la entrada de nuestra terminal hasta que le indicamos //fin del fichero// mecanografiando un **^D**, tras lo cual la shell notó que el correo se había completado y nos indicó que se encontraba presta para leer nuevamente desde la terminal, presentando inmediatamente otro ''% ''. |
| |
| Este es el patrón esencial de toda interacción con UNIX a través del shell. Se escribe un comando completo en la terminal, la shell ejecuta el comando y cuando su ejecución fue completada... solicita un nuevo comando. Si usas el editor durante una hora, la shell esperará pacientemente que termine de editar y quedará a la obediente orden suya una vez que termine de editar. | El patrón esencial de toda interacción con UNIX a través del shell es éste ciclo: se escribe una orden completa completa en el terminal, la shell ejecuta el comando y cuando su ejecución fue cumplida, solicita un nuevo comando. Si usas el editor durante una hora, la shell esperará pacientemente que termine de editar y aguardará obedientemente nueva orden suya una vez que cumplida la edición. |
| |
| Un ejemplo de un comando útil que puede ejecutar ahora es el comando //tset// que establece los caracteres predeterminados para //borrar// y //eliminar// en su terminal: el carácter //borrar// borra el último carácter que escribió y el carácter de //eliminar// borra toda la línea que ha ingresado hasta el momento. Por defecto. el carácter borrar es ''#'' y el carácter eliminar es ''@''. La mayoría de las personas que usan pantallas CRT prefieren usar el carácter de retroceso (**^H**) como carácter de borrado, ya que así es más fácil ver lo que ha escrito hasta ahora. Puedes hacer que esto sea cierto escribiendo | Un comando útil que puede ejecutar ahora como ejemplo es el comando //tset//, encargado de establecer los caracteres predeterminados para //borrar// y //eliminar// en su terminal: el carácter de //borrar// borra el último carácter que escribió y el carácter de //eliminar// elimina toda la línea que ha ingresado hasta el momento. Por defecto. el carácter borrar es ''#'' y el carácter eliminar es ''@''. La mayoría de las personas que usan pantallas CRT prefieren usar el carácter de retroceso (**^H**) como carácter de borrado, ya que permite mayor facilidad para ver lo que ha escrito hasta ahora. Puede llevar a cabo este accionar mediante |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| que dice al programa //tset// configurar el caracter boorar, y su opción por defecto para este caracter es un caracter retroceder. | que ordena al programa //tset// configurar el caracter borrar, y su opción por defecto para este caracter es un caracter retroceder. |
| |
| ==== Argumentos Flag ==== | ==== Argumentos de Opción ==== |
| |
| Una noción útil en UNIX es la del argumento //flag//. Si bien muchos argumentos de comandos especifican nombres de archivo o nombres de usuario, algunos argumentos en lugar de aquellos, especifican una capacidad opcional del comando, la cual desearías invocar. Por convención, tales argumentos comienzan con el caracter guion medio ''-''. Por tanto, el comando | Una noción útil en UNIX es la del argumento de opción ("//flag//"). Si bien muchos argumentos de comandos especifican a nombres de archivo o nombres de usuario, existen ciertos argumentos capaces de especificar una capacidad opcional del comando (la cual desearías invocar en lugar de las opciones regulares). Por convención, tales argumentos //flag// comienzan con el caracter guion medio ''-''. Por tanto, el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| producirá un listado de archivos en el //directorio de trabajo// actual. la opcion ''-s'' es la opción de tamaño, y | producirá un listado de ficheros encontrados en el //directorio de trabajo// actual. El //flag// ''-s'' define a la opción de tamaño, por tanto |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| provoca que ls también de para cada fichero el tamaño de fichero en bloques de 512 caracteres. La sección de cada comando en el Manual de Referencia de UNIX proporciona las opciones disponibles para cada comando. El comando ls tiene una gran cantidad de opciones útiles e interesantes. La mayorías de los demás comandos no tienen opciones, o sólo tienen una o dos. No es fácil recordar las opciones de los comandos que no se usan frecuentemente, de modo que la mayoría de las utilidades de UNIX prefieren realizar sólo una o dos funciones en lugar de tener muchas difíciles de recordar. | ordena que //ls// también informe el tamaño (en bloques de 512 caracteres) de cada uno de los ficheros del listado. El Manual de Referencia de UNIX proporciona las opciones disponible para cada comando en su respectiva Sección. El comando //ls// - por ejemplo - consta de una gran cantidad de opciones útiles e interesantes. La mayoría de los demás comandos carecen de //flags//, o sólo disponen de una o dos. Como no resulta sencillo recordar las opciones de aquellos comandos que no se usan a menudo, la mayoría de las utilidades de UNIX suelen preferir realizar sólo una o dos funciones, evitando contar con muchas opciones difíciles de memorizar. |
| |
| ==== Salida a Ficheros ==== | ==== Salida a Ficheros ==== |
| |
| Los comandos que normalmente leen la entrada o escriben la salida en el terminal también se pueden ejecutar con esta entrada y/o salida realizada en un archivo. | Los comandos que normalmente leen su entrada o escriben se salida en el terminal, también pueden ejecutarse con esta entrada y/o salida suplida a/desde un fichero. |
| |
| Supongamos que deseamos guardar la fecha actual en un archivo llamado "ahora". | Supongamos que deseamos guardar la fecha actual en un archivo llamado "ahora". |
| |
| El comando ''date'' imprimirá la fecha actual en nuestra terminal. Esto se debe a que nuestra terminal es la //salida estándar// predeterminada para el comando de fecha y el comando de fecha imprime la fecha en su salida estándar. El shell nos permite //redirigir// la salida estándar de un comando a través de una notación usando el //metacarácter// ''>'' y el nombre del archivo donde se colocará la salida. Así el comando | La orden ''date'' imprime la fecha actual en el terminal. Esto se debe a que la //salida estándar// predeterminada para el comando //date// es nuestro terminal, por lo tanto, eso es lo que cumple. El shell nos permite //redirigir// la salida estándar de un comando por medio de una notación, si se recurre al //metacarácter// ''>'' y se invoca el nombre de fichero donde se colocará el resultado de salida. Por tanto, el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| ejecuta el comando de //date// de modo que su salida estándar sea el fichero ''ahora'' en lugar del terminal. Por lo tanto, este comando coloca la fecha y hora actuales en el archivo ''ahora''. Es importante saber que el comando date no sabía que su salida iba a un archivo en lugar de a la terminal. La shell realizó esta //redirección// __antes__ de que el comando comenzara a ejecutarse. | ejecuta el comando de //date// de modo que su //salida estándar// se dirija al fichero ''ahora'' en lugar de hacerlo al terminal. Por lo tanto, el resultado del comando cumple en colocar la fecha y hora actuales en el fichero ''ahora''. Es importante saber que el comando //date// no sabe que su salida irá a un fichero en lugar de hacerlo al terminal: la shell realiza la //redirección// __antes__ que el comando comience a ejecutarse. |
| |
| Otra cosa a tener en cuenta aquí es que no es necesario que el archivo ''ahora'' existiera antes de que se ejecutara el comando //date//; la shell habría creado el archivo si no existiera. ¿Y si el archivo existiera? Si hubiera existido anteriormente, ¡sus contenidos anteriores habrían sido descartados! Existe una opción de la shell llamado ''noclobber'' para evitar que esto suceda accidentalmente; se analiza en la [[#variables de la shell|sección 2.2]]. | Otra aspecto a tener en cuenta aquí es innecesario generar el fichero ''ahora'' previamente a la ejecución del comando //date//; si el fichero no existe, la shell lo crea. ¿Y si el archivo existiera? En tal caso, ¡sus contenidos previos habrían sido sido desechados! Existe una opción de shell llamada ''noclobber'' para evitar que esto accidentalmente suceda; se analiza en la [[#variables de la shell|sección 2.2]]. |
| |
| El sistema normalmente guarda los ficheros que usted crea con ''>'' y todos los demás ficheros. Por lo tanto, el valor predeterminado es que los ficheros sean permanentes. Si desea crear un archivo que se eliminará automáticamente. puede comenzar su nombre con un carácter ''#''. este carácter "numeral" denota el hecho de que el archivo será un archivo borrador. El sistema eliminará dichos archivos después de un par de días, o mas pronto si el espacio queda limitado. Por lo tanto, al ejecutar el comando //date// como se indicó anteriormente, no queremos realmente que almacene la salida para siempre, de manera que más probablemente usaríamos: | Normalmente, el sistema guarda los ficheros creados por usted con ''>'' junto a todos los demás ficheros. Por lo tanto, el resultado predeterminado es que los ficheros sean permanentes. Si desea crear un fichero para su eliminación automática, puede comenzar su nombre de fichero con un carácter ''#''. Dicho carácter "numeral" denota el hecho de que el fichero será un //fichero borrador//. El sistema eliminará dichos archivos tras un par de días (o mas pronto si el espacio resulta limitado). Por lo tanto, al ejecutar el comando //date// como se indicó anteriormente, no querríamos que almacene la salida para siempre realmente, de manera que más probablemente usaríamos: |
| |
| <code bash> | <code bash> |
| Como el caso del ''>'' indicado anteriormente, la shell tiene una gran variedad de [[#caracteres especiales|caracteres especiales]] que ordenan funcionalidades especiales. Decimos que para la shell, dichas notaciones guardan significado //sintáctico// y //semántico//. Por lo general, para la shell la mayoría de los caracteres que no son letras o dígitos guardan un significado especial. | Como el caso del ''>'' indicado anteriormente, la shell tiene una gran variedad de [[#caracteres especiales|caracteres especiales]] que ordenan funcionalidades especiales. Decimos que para la shell, dichas notaciones guardan significado //sintáctico// y //semántico//. Por lo general, para la shell la mayoría de los caracteres que no son letras o dígitos guardan un significado especial. |
| |
| Los metacaracteres normalmente surten efecto sólo cuando la shell está leyendo nuestra entrada. No debemos que preocuparnos si usamos metacaracteres en la redacción de una carta que enviaremos a través de //mail//, o cuando mecanografiamos texto o introducimos datos en cualquier otro programa. Debemos tener presente que la shell sólo lee entrada __cuando ha señalado el prompt__ ''% ''. | Los metacaracteres normalmente surten efecto sólo cuando la shell lee nuestra entrada [N.d.T. el teclado del terminal]. Como consecuencia, no debemos preocuparnos al usar metacaracteres en la redacción de una pieza que enviaremos a través de //mail//, o al mecanografiar textos o introducimos datos en cualquier otro programa. Debemos tener presente que la shell sólo lee entrada __cuando ha señalado su prompt__ ''% ''. |
| |
| Mas adelante habremos de aprender brevemente una manera de //citar// que nos permita utilizar //metacarecteres// sin que la shell los trate de forma especial. | Mas adelante habremos de aprender brevemente una manera de //citar// que nos permite recurrir a //metacaracteres// sin que la shell los trate de forma especial. |
| |
| ==== Entrada desde archivos; cañerías ==== | ==== Entrada desde archivos; cañerías ==== |
| Anteriormente aprendimos como //redirigir// la //salida estándar// de un comando a un fichero. También es posible redirigir la //entrada estándar// de un comando desde un fichero. Esto a método no es necesario ya que la mayoría de los comandos leerán desde un fichero cuyo nombre se provea como argumento. Podemos dar el comando | |
| | Ya hemos aprendido como //redirigir// la //salida estándar// de un comando __a__ un fichero. Es posible también redirigir la //entrada estándar// de un comando __desde__ un fichero. Esto a menudo es innecesario pues la mayoría de los comandos leen desde un fichero siempre que su nombre sea provisto como argumento. Podemos dar el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| para que ejecute el comando //sort// con la entrada estándar. Desde donde el comando leerá normalmente la entrada es desde el fichero ''datos''. Normalmente, recurriríamos a: | para ordenar ejecución del programa //sort// redirigiendo su //entrada estándar// - el lugar desde donde el comando leerá normalmente su entrada -- desde el fichero ''datos''. Normalmente, recurriríamos a: |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Dejando que el comando sort abra un fichero ''datos'' para proveerse el mismo la entrada, ya que es más fácil de mecanografiar. Debemos notar que si sólo miecanografiamos: | Dejando que el comando //sort// abra un fichero ''datos'' por sí mismo para proveerse la entrada que necesita (ya que esto es más fácil de mecanografiar). Debemos notar que si sólo mecanografiamos: |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| entonces el programa sor ordenaría las líneas desde la //entrada estándar//. Ya que no redirigimos la //entrada estándar//, ordenaría las líneas en la medida que las mecanografiamos en la terminal, hasta que ingresemos un **^D** para indicar //Fin de Fichero//. | entonces el programa //sort// ordenaría las líneas desde la //entrada estándar//. Como en tal caso no redirigimos la //entrada estándar//, el reordenamiento de líneas se producirá tras que mecanografiar las líneas consecutivamente en el terminal, al presionar **^D** para indicar //Fin de Fichero//. |
| |
| Una capacidad más útil es la posibilidad de combinar la salida estándar de un comando con la entrada estándar de otro, por ejemplo para ejecutar los comandos en una secuencia conocida como //cañería//. Por ejemplo, el comando | Una funcionalidad más útil es la posibilidad combinatoria que da redirigir la //salida estándar// de un comando con la entrada estándar de otro, por ejemplo para ejecutar los comandos en una secuencia conocida como //cañería//. Por ejemplo, el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| produce normalmente un listado de los ficheros de nuestro directorio, especificando el tamaño de cada uno en bloques de 512 caracteres. Si nos interesa aprender cuál de nuestros ficheros es el más grande, podríamos querer tener esta lista ordenada por tamaño, en lugar de hacerlo por nombre (la cual es la manera por defecto en la que ordena el listado el programa //ls//). Podemos observar las muchas opciones de //ls// para ver si existe alguna opción que haga esto, pero eventualmente descubriríamos que no existe ninguna [N.d.T., en la versión de 1983 de ls, claro, en la actual existe.]. En lugar de ello, podremos usar un par de opciones simples del comando //sort// combinándolas con //ls// para lograr lo que nosotros queremos. | produce normalmente un listado de los ficheros de nuestro directorio, especificando el tamaño de cada uno (en bloques de 512 caracteres). Si nos interesa aprender cuál de nuestros ficheros es el más grande, podríamos querer ordenar este listado según su tamaño, en lugar de hacerlo alfabéticamente según su nombre (la cual es la manera en la que ordena el listado el programa //ls// por defecto). Podemos observar las muchas opciones de //ls// para ver si consta de alguna opción que haga esto, pero eventualmente descubriríamos que no existe ninguna [N.d.T., en la versión de 1983 de //ls//; las versiones actuales la tienen, por supuesto]. En lugar de ello, podremos usar un par de //flags// simples del comando //sort// combinándolas con //ls// para lograr lo que nosotros queremos. |
| |
| La opción ''-n'' de //sort//, especifica un ordenamiento numérico en lugar de un ordenamiento alfabético. Por tanto | La opción ''-n'' de //sort//, especifica un ordenamiento numérico en lugar de un ordenamiento alfabético. Por tanto |
| |
| <code bash> | <code bash> |
| Is -s | sort -n | ls -s | sort -n |
| </code> | </code> |
| |
| especifica que la salida del comando //ls// argumentado con la opción ''-s'' deba ser //entubado// al comando //sort// argumentado con su opción de ordenamiento numérico. Esto nos proporcionará una lista de nuestros ficheros ordenada por tamaño (pero indicando al principio el más pequeño). Luego podremos utilizar la opción de ordenamiento inverso ''-r'' de //sort//, y el comando //head// en combinación con aquél, ingresando | especifica que la salida del comando //ls// argumentado con la opción ''-s'' deba ser //entubado// al comando //sort// argumentado según su opción de ordenamiento numérico. Esto nos proporcionará una lista de nuestros ficheros ordenada por tamaño (pero listando primero el más pequeño). Luego podremos utilizar la opción //flag// de ordenamiento inverso ''-r'' de //sort//, junto al comando //head// en combinación con aquél, ingresando: |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Aquí hemos tomado un listado de nuestros ficheros ordenados alfabéticamente (cada uno con su tamaño en bloques), hemos pasado esto a la entrada estándar del comando //sort// pidiéndole que las ordene de forma numérica invertida (la más grande primero). Esta salida ha sido luego entubada al comando //head//, que nos presenta las primeras pocas líneas (en este caso, solicitamos a //head// las primeras 5 líneas). Por lo tanto, este comando nos presenta los nombres y tamaño de nuestros 5 ficheros más grandes. | Hemos tomado aquí un listado de nuestros ficheros ordenados alfabéticamente (cada uno con su tamaño en bloques), hemos pasado esto a la entrada estándar del comando //sort// solicitándo que las ordene de forma numérica invertida (la más grande primero). Dicha salida ha sido vertida luego al comando //head//, encargado de presentar sólo las primeras pocas líneas (en este caso, las primeras ''5''). Como resultado, este comando cumple en presentar los nombres y tamaño de nuestros 5 ficheros más grandes. |
| |
| La notación introducida anteriormente se conoce como mecanismo de //caño//. Los comandos separados por caracteres ''|'' resultan conectados entre sí por la shell y la salida estándar de cada uno de ellos es pasado a la entrada estándar del siguiente. El comando más a la izquierda en la cañería normalmente toma su entrada estándar de la terminal, y el comando más a la derecha volcará su salida estándar en la terminal. Mas adelante daremos otros ejemplos de cañerías al discutir el mecanismo historial; un uso importante de cañería que se ilustra allí es el de redirigir información a la impresora de líneas. | La notación introducida anteriormente se conoce como mecanismo de //caño//. Los comandos separados por caracteres ''|'' resultan conectados entre sí por la shell y la //salida estándar// de cada uno de ellos es pasado a la //entrada estándar// del siguiente. El comando más a la izquierda en la cañería generalmente recibe su entrada estándar del teclado del terminal, y el comando más a la derecha volcará su salida estándar en el presentador del terminal. Mas adelante ofreceremos ejemplos de cañerías adicionales cuando discutamos el mecanismo historial; un uso importante de cañería allí ilustrado es el de redirigir información al impresor de líneas. |
| |
| ==== Nombres de Ficheros ==== | ==== Nombres de Ficheros ==== |
| |
| Para ser ejecutados, muchos comandos necesitan los nombres de fichero como argumentos. Los //nombres de ruta// de UNIX consisten en una cantidad de //componentes// separados por una ''/''. Cada componente excepto el último nombran un directorio en el cual reside el siguiente componente, especificando - en efecto - la //ruta// de directorios que debe serguirse para alcanzar el fichero. Por lo tanto, la ruta | Para ser ejecutados, muchos comandos necesitan estar argumentados con //nombres de fichero//. Los //nombres de ruta// de UNIX consisten en una cantidad de //componentes// separados por un caracter de barra ''<nowiki>/</nowiki>''. Con excepción del último componente, cada uno de ellos nombran un //directorio// en el cual reside el siguiente componente, denotando - en efecto - la //ruta// de directorios que debe seguirse para alcanzar el fichero en cuestión. Por lo tanto, la ruta |
| |
| /etc/motd | /etc/motd |
| |
| especifica un fichero en el directorio ''etc'' que es un subdirectorio del directorio //raíz// ''<nowiki>/</nowiki>''. Dentro de este directorio se encuentra el fichero denominado ''motd'' que significa "mensaje del día". Un //nombre de ruta// comenzado con una barra ''<nowiki>/</nowiki>'' se dice que es ''absoluto'' ya que está especificado desde la parte absolutamente superior de la jerarquía de directorios completa (la //raíz//). Los //nombres de ruta// que no comienzan con ''<nowiki>/</nowiki>'' se interpretan como el //directorio de trabajo// actual, el cual es, por defecto, su directorio //home// y puede cambiarse dinámicamente con el comando de cambio de directorio //cd//. Tales //nombres de ruta// se dicen que son //relativos// al directorio de trabajo, ya que se encuentra iniciando su búsqueda desde el directorio de trabajo,y descendiendo a los niveles inferiores de la jerarquía de directorio para cada //componente// del nombre de ruta. Si el nombre de ruta no contiene barra alguna, entonces el fichero está contenido en el directorio de trabajo actual, y la ruta simplemente consiste en el nombre de fichero en este directorio. Los nombres de ruta absolutos no tienen relación al directorio de trabajo. | especifica un fichero en el directorio ''etc'' que es un subdirectorio del directorio //raíz// ''<nowiki>/</nowiki>''. Dentro de este directorio se encuentra el fichero denominado ''motd'' (significa "mensaje del día"). Se dice que un //nombre de ruta// comenzado con una barra ''<nowiki>/</nowiki>'' es //absoluto// pues que cuenta con la definición jerárquica completa desde su //raíz//. En tanto, los //nombres de ruta// que no comienzan con ''<nowiki>/</nowiki>'' se interpretan como parte del //directorio de trabajo// actual - por defecto se trata de su directorio //home// aunque puede cambiarlo dinámicamente con el comando de cambio de directorio //cd//. Se dicen que estos //nombres de ruta// son //relativos// al directorio de trabajo, ya que se descubren iniciando una búsqueda desde el directorio de trabajo, descendiendo a los niveles inferiores de la jerarquía de directorio siguiendo cada //componente// del nombre de ruta. Si el nombre de ruta carece de ''/'' alguna, entonces el fichero está contenido en el directorio de trabajo (y la ruta simplemente consiste en el //nombre de fichero// en el directorio de trabajo). Los nombres de ruta //absolutos// no tienen relación al directorio de trabajo. |
| | |
| | La mayoría de los //nombre de ficheros// constan de una cantidad de caracteres alfanuméricos y puntos ''.''. De hecho, es posible usar todos los caracteres impresos exceptuando la barra ''<nowiki>/</nowiki>'' en los nombres de archivo. __Es inconveniente__ emplear la mayoría de los caracteres no alfabéticos en los nombres de fichero pues muchos de ellos guardan significado especial para la shell. El caracter punto ''.'' no es un metacaracter de la shell, y se utiliza a menudo para separar la //extensión// del nombre de archivo de la base del nombre. Por tanto |
| |
| La mayoría de los nombre de ficheros consisten en una cantidad de caracteres alfanuméricos y puntos ''.''. De hecho, en los nombres de archivo pueden usarse todos los caracteres impresos exceptuando la barra ''<nowiki>/</nowiki>''. __Es inconveniente__ usar la mayoría de los caracteres no alfabéticos en los nombres de fihero porque muchos de ellos tienen significado especial para la shell. El caracter punto ''.'' no es un metacaracter de la shell, y a menudo se utiliza para separar la //extensión// del nombre de archivo de la base del nombre. Por tanto | prog.c prog.o prog.errs prog.out |
| |
| prog.c prog.o prog.errs prog.output | son cuatro ficheros relacionados. Comparten la porción //base// (una porción base es la parte del nombre que queda por delante del ''.'' final, y que sigue a los caracteres que no sean ''.''). El fichero ''prog.c'' podría ser el código fuente de un programa de lenguaje C, el fichero ''prog.o'' podría el fichero de código objeto correspondiente, el fichero ''prog.errs'' los errores resultantes de una compilación del programa, y el fichero ''prog.output'' la salida de un programa compilado. |
| |
| son cuatro ficheros relacionados. Comparte la porción //base// (una porción base es la parte del nombre que queda por delante del ''.'' final, y que sigue a los caracteres que no sean ''.''. El fichero ''prog.c'' podría ser el código fuente de un programa de lenguaje C, el fichero ''prog.o'' podría el fichero de código objeto correspondiente, el fichero ''prog.errs'' los errores resultantes de una compilación del programa, y el fichero ''prog.output'' la salida de un programa ejecutado. | |
| Si deseamos referirnos a los cuatro ficheros a la vez en un comando, podríamos utilizar la notación | Si deseamos referirnos a los cuatro ficheros a la vez en un comando, podríamos utilizar la notación |
| |
| </code> | </code> |
| |
| Esta palabra __antes__ de que el comando del cual es un argumento sea ejecutado, resulta expandida por la shell en una lista de nombres que comienzan con ''prog'', El caracter ''*'' aquí coincide con cualquier secuencia de caracteres en un nombre de fichero (incluyendo un secuencia vacía). Los nombres que coinciden son ordenados alfabéticamente y puestos en la //lista de arguemntos// del comando. Por lo tanto el comando | Esta palabra __antes__ que el comando del cual es un argumento sea ejecutado, resulta formulaicamente //expandida// por la shell a una lista de nombres que comienzan con ''prog'', El caracter ''*'' aquí coincide con "cualquier secuencia de caracteres en un nombre de fichero" (incluyendo un secuencia vacía). Los nombres que coinciden resultan ordenados alfabéticamente y puestos en la //lista de argumentos// del comando. Por lo tanto el comando |
| |
| <code bash> | <code bash> |
| dará eco a los nombres | dará eco a los nombres |
| |
| prog.c prog.errs prog.o prog.output | prog.c prog.errs prog.o prog.out |
| |
| Note que los nombres están ordenados aquí, y en un orden distinto al que listamos arriba. El comando //echo// recibe cuatro palabras como argumentos, incluso aunque sólo mecanografiamos directamente una palabra como argumento. Las cuatro palabras fueron generados por la //expansión de nombre de fichero// de esa única palabra de entrada. | Note que los nombres están ordenados aquí, y en un orden distinto al que listamos arriba. El comando //echo// recibe cuatro palabras como argumentos, incluso aunque sólo mecanografiemos directamente una palabra como argumento. Las cuatro palabras fueron generados por la //expansión de nombre de fichero// a partir de una única palabra de entrada. |
| |
| También hay disponibles otras notaciones para //expansión de nombre de fichero//. El caracter ''?'' coincide con cualquier caracter único en un nombre de fichero. Por tanto | También hay disponibles otras notaciones para //expansión de nombre de fichero//. El caracter ''?'' coincide con "cualquier caracter único en un nombre de fichero". Por tanto |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Dará como eco una línea de nombres de fichero; primero aquellos con nombres de un solo caracter, luego aquellos con nombres de dos caracteres, y finalmente aquellos con nombres de tres caracteres. Los nombres de cada longitud serán independientemente ordenados. | Dará como eco una línea de nombres de fichero; primero aquellos con nombres de un solo caracter, luego aquellos con nombres de dos caracteres, y finalmente aquellos con nombres de tres caracteres. Los nombres de cada longitud de caracteres reciben un orden independiente. |
| |
| Otro mecanismo consiste en en //entrecorchetado//, usando una secuencia de caracteres entre ''['' y '']''. Esta metasecuencia coincide con cualquier caracter único del conjunto entre corchetes. Por tanto. | Otro mecanismo consiste en en //entrecorchetado//, esto es, una secuencia de caracteres entre ''['' y '']''. Esta metasecuencia coincide con "cualquier caracter único del conjunto entrecorchetado". Por tanto |
| |
| <code bash> | <code bash> |
| prog.c prog.o | prog.c prog.o |
| |
| del ejemplo anterior. También podemos poner dos caracteres rodeando un ''-'' en una notación que denota un rango. Por tanto | del ejemplo anterior. También podemos poner dos caracteres rodeando un ''-'' en una notación para "caracteres definidos por rango". Por tanto |
| |
| <code bash> | <code bash> |
| |
| si existiesen. Esto es la abreviación para | si existiesen. Esto es la abreviación para |
| | |
| <code bash> | <code bash> |
| cap.[12345] | cap.[12345] |
| </code> | </code> |
| | |
| y es, por ello, equivalente en todo sentido. | y es, por ello, equivalente en todo sentido. |
| |
| Otro punto importante a notar es que si una lista de palabras argumento de comando (una //lista argumental//) contiene sintaxis de expansión de nombre de fichero, y si esta sintaxis de expansión de nombre de fichero falla en hacer coincidir cualquier nombre de fichero existente, en tal caso la shell considerará esto como error y presentará un diagnóstico | Otro punto importante a notar es que si una lista de palabras argumento de comando (una //lista argumental//) contiene sintaxis de expansión de nombre de fichero, y si esta sintaxis de expansión de nombre de fichero falla en hacer coincidir cualquier nombre de fichero existente, en tal caso la shell considerará esto como error y presentará un diagnóstico "Sin coincidencia": |
| |
| No match. | No match. |
| |
| y no ejecutará el comando. | y no cumplirá la ejecución del comando. |
| |
| Otro punto muy importante es que los ficheros con el caracter ''<nowiki>\</nowiki>'' al comienzo del nombre son tratados especialmente. Ni el ''*'' ni el ''?'' o el mecanismo de entrecorchetado ''['' y '']'' encontrarán coincidencia. Esto impide coincidir accidentalmente los nombres ''.'' y ''..'' del directorio de trabajo - los cuales tienen significados especiales para el sistema - así como otros ficheros tales como ''[[.cshrc]]'', que no son visibles normalmente. Discutiremos el rol especial del fichero .cshrc más adelante. | Otro punto muy importante es que los ficheros con el caracter de barra invertida ''<nowiki>\</nowiki>'' al comienzo del nombre son tratados especialmente. Ni el ''*'' ni el ''?'' o el mecanismo de entrecorchetado ''['' y '']'' encontrarán coincidencia. Esto impide coincidir accidentalmente los nombres ''.'' y ''..'' del directorio de trabajo - los cuales tienen significados especiales para el sistema - así como otros ficheros tales como ''[[.cshrc]]'', que no son visibles normalmente. El rol especial del fichero .cshrc será discutido más adelante. |
| |
| |
| Otro mecanismo de expansión de nombre de fichero da acceso al nombre de ruta del directorio //home// de otros usuarios. Esta notación consiste en el caracter tilde ''~'', seguida por el nombre de login de otro usuario. Por ejemplo, la palabra ''~bill'' dirigirá al nombre de ruta ''/usr/bill'' (siempre que el directorio //home// del tal //Bill// sea ''/usr/bill'', claro está). Como en grandes sistemas, los usuarios pueden tener directorios de login distribuidos a lo largo de muchos volúmenes de disco diferentes, con diferente nombres de directorio prefijo, esta notación ofrece una manera confiable de acceder a los ficheros de otros usuarios. | Otro mecanismo de expansión de nombre de fichero ofrece acceso abreviado al nombre de ruta del directorio //home// de otros usuarios. Esta notación consiste en el caracter tilde ''~'', seguida por el nombre de login de otro usuario. Por ejemplo, la palabra ''~bill'' dirigirá al nombre de ruta ''/usr/bill'' (siempre que el directorio //home// del tal //Bill// sea ''/usr/bill'', claro está [N.d.T. actualmente, ''/home/bill'']). Como en grandes sistemas, los usuarios pueden contar con varios directorios de login distribuidos a lo largo de muchos volúmenes de disco diferentes, con diferente nombres de directorio prefijo, esta notación otorga una forma confiable de acceder a los ficheros de otros usuarios. |
| |
| Un caso especial que incumbe a esta notación es el de un tilde ''~'' aislado, por ejemplo ''~/mbox''. Esta notación resulta expandida por la shell para representar al fichero ''mbox'' en su propio directorio //home//, por ejemplo, en ''/usr/bill/mbox'' para mi en Ernie Co-vax, la máquina [[VAX]] del Dpto. de Ciencias del Cómputo de la universidad de California Berkeley, donde fue preparado este documento. Esto puede resultar muy útil si usted ha usado //cd// para cambiar a otro directorio, y ha encontrado un fichero que desea copiar con //cp//. Si doy el comando | Un caso especial que incumbe a esta notación es el de un tilde ''~'' aislado, por ejemplo ''~/mbox''. Esta notación resulta expandida por la shell para representar al fichero ''mbox'' en su propio directorio //home//, por ejemplo, en ''/usr/bill/mbox'' para mi en Ernie Co-vax, la máquina [[VAX]] del Dpto. de Ciencias del Cómputo de la universidad de California Berkeley, donde fue preparado este documento. Esto puede resultar muy útil si usted ha usado //cd// para cambiar a otro directorio, y ha encontrado un fichero que desea copiar con //cp//. Si doy el comando |
| ya que mi directorio //home// es ''/usr/bill''. | ya que mi directorio //home// es ''/usr/bill''. |
| |
| Existe también un mecanismo que usa los caracteres de abrir llave ''{'' y cerrar llave ''}'' para abreviar un conjunto de palabras que constan de partes comunes pero no pueden ser abreviadas a través de los mecanismos anteriormente nombrados ya que no son ficheros, o son nombres de ficheros que aún no existen y por lo tanto no pueden ser descriptos convenientemente aún. Tal mecanismo será descripto bastante mas adelante, en la [[#Llaves {...} en expansión de argumentos|sección 4.2]] ya que se usa con poca frecuencia | Existe también un mecanismo que usa los caracteres de abrir llave ''{'' y cerrar llave ''}'' para abreviar un "conjunto de palabras que constan de partes comunes" pero no pueden ser abreviadas a través de los mecanismos anteriormente nombrados ya que no son ficheros, o son nombres de ficheros que aún no existen y por lo tanto no pueden ser descriptos convenientemente aún. Tal mecanismo será descripto bastante mas adelante, en la [[#Llaves {...} en expansión de argumentos|sección 4.2]], pues se recurre a ellas con poca frecuencia. |
| |
| ==== Citado ==== | ==== Citado ==== |
| |
| Ya hemos visto cierta cantidad de metacaracteres utilizados por la shell. Estos metacaracteres tienen una complicación dificultosa: __no podemos usarlos directamente como partes de //palabras//__. Por lo tanto el comando | Ya hemos visto cierta cantidad de metacaracteres respetados por la shell. Dichos metacaracteres tienen una complicación dificultosa: __no podemos usarlos directamente como partes de //palabras//__. Por lo tanto el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| no dará como eco el caracter ''*''. O bien dará como eco una lista ordenada de nombres de ficheros del //directorio de trabajo// actual, o bien imprimirá el mensaje ''No match'' si no existen ficheros en el directorio de trabajo. | no dará como eco el caracter ''*''. O bien dará como eco una lista ordenada de nombres de ficheros del //directorio de trabajo// actual, o bien imprimirá el mensaje ''No match'' si en el directorio de trabajo no existen ficheros. |
| |
| El mecanismo recomendado para poner caracteres que no son números, dígitos ''<nowiki>/</nowiki>'', ''.'', o ''-'' en una palabra argumento de un comando es apostrofarlo (encerrarlo entre apóstrofos '''<nowiki>...</nowiki>'''.. Por ejemplo: | El mecanismo recomendado para poner aquellos caracteres que no son números, dígitos ''<nowiki>/</nowiki>'', ''.'', o ''-'' en una palabra argumento de un comando es apostrofarlo (encerrarlo entre apóstrofos '''<nowiki>...</nowiki>'''.. Por ejemplo: |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Existe un caracter especial signo cierre de admiración ''!'' que es es utilizado por el mecanismo //historial// de la shell y el cual __no puede__ ser anulado apostrofándo de esta manera ''<nowiki>'!'</nowiki>''. Para impedir su significado especial, tanto el signo de cierre de admiración ''!'' como el caracter apóstrofo ''<nowiki>'</nowiki>'' en sí deben ser precedidos por una único caracter de barra invertida ''<nowiki>\</nowiki>''. Por tanto | Existe un caracter especial signo cierre de admiración ''!'' que es es utilizado por el mecanismo //historial// de la shell que __no puede__ ser anulado apostrofándo de la forma anterior: ''<nowiki>'!'</nowiki>''. Para __anular__ su significado especial de la shell, tanto el signo de cierre de admiración ''!'' como el caracter apóstrofo ''<nowiki>'</nowiki>'' en sí __deben ser precedidos por un único caracter de barra invertida ''<nowiki>\</nowiki>''__. Por tanto |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Estos dos mecanismos resultan suficientes para poner cualquier caracter impreso en una palabra que es un argumento de un comando de la shell. Pueden combinarse, como en | Estos dos mecanismos resultan suficientes para poner cualquier caracter impreso en una palabra que sin que sean considerados un argumento de un comando de la shell. Pueden combinarse, como en |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| ya que la primer barra invertida ''<nowiki>\</nowiki>'' anuló el primer apóstrofo ''<nowiki>'</nowiki>'' y el asterisco ''<nowiki>*</nowiki>'' aparecía entre apóstrofos ''<nowiki>'</nowiki>''. | ya que la primer barra invertida ''<nowiki>\</nowiki>'' ha anulado el primer apóstrofo ''<nowiki>'</nowiki>'', mientras que el asterisco ''<nowiki>*</nowiki>'' aparecía entre apóstrofos ''<nowiki>'</nowiki>''. |
| |
| ==== Suspensión de Comandos ==== | ==== Suspensión de Comandos ==== |
| |
| Cuando ejecuta un comando y la shell aguarda su finalización, existen varias maneras de forzar su interrupción. Por ejemplo, si ingresa el comando | Existen varias maneras de forzar su interrupción tras ejecutar un comando y mientras la shell aguarda su cumplimiento. Por ejemplo, si ingresa el comando |
| |
| |
| </code> | </code> |
| |
| El sistema presentará en su terminal una copia de una lista de todos los usuarios del sistema. Es probable que esta presentación continúe por varios minutos, a no ser que la interrumpa [N.d.T en la VAX 11/750 de Berkeley no era particularmente veloz y tenía cientos de usuarios!]. Puede enviar una señal INTERRUPT al comando //cat// presionando la tecla DEL o RUBOUT de su terminal. Ya que //cat// no tiene precaución cierta de evitar o considerar dicha señal de otra forma, la señal INTERRUPT provocará su finalización. La shell nota que el comando //cat// ha finalizado y ofrecerá un prompt con ''% '' nuevamente. Si presiona INTERRUPT nuevamente, la shell simplemente repetirá su prompt ya que - en lugar de interrumpirse al igual que //cat//, lo que tendría el efecto de cerrar su sesión - la shell interpreta las señales INTERRUPT y escoge continuar ejecutando comandos en lugar de finalizar. | El sistema presentará en su terminal una copia de un listados de todos los usuarios del sistema. Es probable que esta presentación continúe por varios minutos, a no ser que la interrumpa [N.d.T en la VAX 11/750 de Berkeley no era particularmente veloz y tenía miles de usuarios!]. Puede enviar una señal INTERRUPT al comando //cat// presionando la tecla DEL o RUBOUT de su terminal. La señal INTERRUPT provocará su finalización, pues //cat// no ha sido implementado para considerar dicha señal de otra manera diferente. La shell nota que el comando //cat// ha finalizado y ofrecerá nuevamente un prompt ''% ''. Si presiona INTERRUPT nuevamente, la shell simplemente repetirá su prompt en lugar de interrumpirse (lo que tendría el efecto de cerrar su sesión, al igual que //cat//). La shell interpreta las señales INTERRUPT y escoge continuar ejecutando comandos en lugar de finalizar. |
| |
| Otra manera en la cual muchos programas pueden finalizar su ejecución es al recibir un mensaje de //fin-de-fichero// en su entrada estandar. Por este motivo el programa //mail// en el primer ejemplo anterior terminaba cuando presionábamos **^D**, lo que genera un ''fin-de-fichero'' desde la entrada estándar [N.d.T: el teclado]. La shell también finaliza cuando obtiene un ''fin-de-fichero'', a lo que presentará el mensaje ''logout''; UNIX entonces cierra su sesión de terminal. Esto significa que si ingresa demasiadas **^D**, podría accidentalmente desligarse del sistema, la shell cuenta con un mecanismo para impedirlo. Esta opción ''ignoreeof'' será discutida en la [[#variables de la shell|sección 2.2]] | Otra manera en la cual muchos programas pueden finalizar su ejecución es recibiendo un mensaje de //fin-de-fichero// a través de su entrada estándar. Este es el motivo por el cual el programa //mail// del primer ejemplo anterior terminaba cuando presionábamos **^D**, lo que genera un ''fin-de-fichero'' desde la entrada estándar [N.d.T: el teclado]. La shell también finaliza cuando obtiene un ''fin-de-fichero'', a lo que presentará el mensaje ''logout''; UNIX entonces cierra su sesión de terminal. Esto significa que si ingresa demasiadas **^D**, podría accidentalmente desligarse del sistema, la shell cuenta con un mecanismo para impedirlo. Esta opción ''ignoreeof'' será discutida en la [[#variables de la shell|sección 2.2]] |
| |
| Si la entrada estándar de un comando se haya redirigida desde un fichero, entonces por lo general finalizará cuando el fichero que funciona de entrada llegue al final. Por tanto, si ejecutamos | Si la entrada estándar de un comando se ha redirigido desde un fichero, entonces por lo general finalizará cuando el fichero que funciona de entrada llegue al final. Por tanto, si ejecutamos |
| |
| |
| </code> | </code> |
| |
| ya que el comando //cat// entonces habría presentado el texto a través del caño a la entrada estándar del comando //mail//. Cuando el comando //cat// hubiese terminado de presentarlo habría finalizado, clausurando la tubería y el comando //mail// habría recibido un //fin-de-fichero// desde él, finalizando como consecuencia. Si bien el resultado es el mismo, esta forma de utilizar un caño parece más complicado que refirigir la entrada de un fichero, de modo que es más probable usar la primer forma. Estos comando podrían también haber sido detenidos enviándoles un INTERRUPT. | pues el comando //cat// habría ofrecido el texto a través del entubado a la entrada estándar del comando //mail//. Una vez cumplido en presentar el fichero, el comando //cat// habría finalizado - clausurando la tubería - y el comando //mail// recibiría un //fin-de-fichero// desde él, finalizando su operación. Si bien el resultado es el mismo, esta forma de utilizar un caño parece más complicado que redirigir un fichero a la entrada, de modo que es más probable usar la primer forma. Estos comando podrían también haber sido detenidos enviándoles un INTERRUPT. |
| |
| Otra posibilidad para suspender un comando es suspender su ejecución temporalmente, lo que nos da la posibilidad de posteriormente continuar su ejecución. Esto se realiza enviando una señal STOP por medio de **^Z**. Esta señal provoca que todos los comandos en ejecución en la terminal - usualmente uno, pero pueden ser varios en caso de que la tubería se encuentre en ejecución - queden suspendidos, pero no son afectados por la señal STOP de otra manera de forma alguna. | Otra posibilidad para suspender un comando es suspender su ejecución de forma temporal, lo que nos posibilita continuar su ejecución posteriormente. Esto se realiza enviando una señal STOP por medio de **^Z**. Esta señal provoca que la suspensión de todos los comandos en ejecución en el terminal - usualmente uno, pero podrían ser varios en caso de haberse recurrido a la ejecución de una tubería. En otro aspecto, no resultan afectados de manera alguna por la señal STOP. |
| |
| Mientras el comando original permanezca suspendido, pueden ejecutarse otros comandos cualquiera. El comando suspendido puede ser continuado por medio del comando //fg// sin argumentos. La shell entonces informará cuál es el comando cuya ejecución continuará, y provocará que éste prosiga su anterior ejecución. La suspensión no afecta de manera alguna la ejecución del comando, a no ser que cualquier fichero de entrada en uso del comando suspendido sea alterado de alguna manera durante la suspensión. Esta funcionalidad puede resultar muy útil durante la edición, de necesitarse revisar otro fichero antes de continuar. A continuación, se da un ejemplo de una suspensión de comando: | Una vez que el comando original permanece suspendido, puede recurrirse a ejecutar otros comandos cualquiera. El comando suspendido puede ser continuado por medio del comando //fg// sin argumentos. La shell informa entonces cuál es el comando a continuar, y proseguirá con su ejecución. La suspensión no afecta de manera alguna la ejecución del comando, a no ser que cualquier fichero de entrada en uso del comando suspendido sea alterado de alguna manera durante la suspensión. Esta funcionalidad puede resultar muy útil durante la edición, de necesitarse revisar otro fichero antes de continuar. A continuación, se da un ejemplo de una suspensión de comando: |
| |
| |
| <code bash> | <code bash> |
| % mail harold | % mail haroldo |
| Alguien me acaba de copiar un fichero enorme en mi directorio de usuario. | Alguien acaba de copiar un fichero enorme a mi directorio de usuario. |
| El fichero se denomina | El fichero se denomina |
| ^Z | ^Z |
| % jobs | % jobs |
| [1] + Stopped | [1] + Stopped |
| mail harold | mail haroldo |
| % fg | % fg |
| mail harold | mail haroldo |
| "tremenda_broma". ¿Sabes quién lo hizo? | "tremenda_broma". ¿Sabes quién lo hizo? |
| EOT | EOT |
| </code> | </code> |
| |
| En este ejemplo, un usuario está enviando un mensaje a Harold pero olvida el nombre del fichero que quería mencionarle. Suspende el comando //mail// ingresando **^Z**. Una vez que la shell nota que el programa de correo está suspendido, presenta 'Stopped' y le ofrece su prompt, aguardando un nuevo comando. Luego el individuo ingresa el comando //ls// para recordar el nombre del fichero en cuestión. Usa el comando //jobs// para descubrir cuál comando se encuentra suspendido, y consecuentemente ingresa el comando //fg// para continuar la ejecución del único programa detenido, el //mail// a Harold. Luego continuó dando entrada a //mail//, y una vez concluída la redacción, la finalizó con **^D**, que indica el final del mensaje ante lo cual el programa //mail// presentó ''EOT'' de //fin-de-transmisión//. | En este ejemplo, un usuario está redactando una pieza de correo a haroldo pero olvida el nombre de un fichero que quería mencionarle. Suspende el comando //mail// ingresando **^Z**. Una vez que la shell nota la suspensión del programa de correo, presenta ''Stopped'' y le ofrece un prompt, aguardando un nuevo comando. Acto seguido el individuo ingresa el comando //ls// para recordar el nombre del fichero en cuestión. Usa el comando //jobs// para descubrir cuál comando se encuentra suspendido, y consecuentemente ingresa el comando //fg// para continuar la ejecución del único programa detenido, el //mail// a haroldo. Luego continua dando entrada a //mail//, y una vez concluida la redacción, la finalizó con **^D**, que denota el final del mensaje, ante lo cual el programa //mail// presenta ''EOT'' de //fin-de-transmisión//. |
| | ===jobs=== |
| | El comando //jobs// presenta un listado de los comandos se encuentran suspendidos. La orden **^Z** __solo debería mecanografiarse al comienzo de línea__, pues de enviarse dicha señal desde el teclado en cualquier otro lugar diferente al comienzo de línea, la shell descarta ("borra") toda la línea. Esto mismo sucede con las señales INTERRUPT y QUIT. Se ofrece mayor información sobre suspender trabajos y controlarlos se ofrece en la [[#trabajossegundo_plano_primer_plano_o_suspendido|seccion 2.6]]. |
| |
| El comando //jobs// presenta el listado de los comandos se encuentran suspendidos. La orden **^Z** __solo debería mecanografiarse al comienzo de línea__, pues si se envía una señal desde el teclado en en cualquier lugar distinto al comienzo de la línea, descarta ("borra") toda la línea. Esto mismo sucede con las señales INTERRUPT y QUIT también. Para más información sobre suspender trabajos y controlarlos se ofrece en la [[#trabajossegundo_plano_primer_plano_o_suspendido|seccion 2.6]]. | Puede ser necesario recurrir a una interrupción de manera poco ortodoxa si se escribe o ejecuta programas que no están completamente depurados. Tal medida puede lograrse mecanografiando **<nowiki>^\</nowiki>**, lo cual envía la señal QUIT. No resultaría extraño que esto provoque que la shell presente un mensaje similar a : |
| | |
| Si escribe o ejecuta programas que no están completamente depurados, puede ser necesaria su interrupción de manera poco ortodoxa. Esto puede lograrse enviando la señal QUIT, lograda mecanografiando **<nowiki>^\</nowiki>**. No sería extraño que esto provoque que la shell presente un mensaje similar a : | |
| |
| <code> | <code> |
| </code> | </code> |
| |
| indicando que un fichero ''core'' conteniendo información sobre el estado del programa ''a.out'' ha sido creadodo cuando la señal QUIT produjo la terminación. Puede examinar este fichero por sí mismo, o bien enviar información al autor del programa informándole dónde está el fichero ''core''. | denotando la creación de un fichero ''core'' conteniendo información sobre el estado del programa ''a.out'', hecho sucedido no bien la señal QUIT produjo la terminación. Podrá examinar este fichero por usted mismo, o bien enviar información al autor del programa informándole dónde está el fichero ''core''. |
| |
| Si corre comandos en //segundo plano// (según lo explicado en la [[#trabajossegundo_plano_primer_plano_o_suspendido|seccion 2.6]]), entonces dichos comandos ignorarán las señales INTERRUPT y QUIT en el terminal. Para detenerlas debe utilizar el comando //kill//. | Si corre comandos en //segundo plano// (según lo explicado en la [[#trabajossegundo_plano_primer_plano_o_suspendido|seccion 2.6]]), entonces dichos comandos ignorarán las señales INTERRUPT y QUIT del terminal. Para detenerlas debe utilizar el comando //kill//. |
| | ===more=== |
| Si desea examinar detenidamente la salida de un comando sin hacer que el mismo desaparezca de la pantalla como cuando recurrimos a interrumpir la salida del comando //cat /etc/passwd//, usted podrá usar el comando | Si desea examinar detenidamente la salida de un comando sin hacer que el mismo desaparezca de la pantalla (como cuando recurrimos a interrumpir la salida del comando //cat /etc/passwd//), podrá usar el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| El programa //more// pausa tras cada pantallazo, y presenta el mensaje ''- - More- -'', en cuyo momento usted podrá presionar la barra espaciadora para obtener otro pantallazo, o Retorno para obtener otra línea, o una **q** para finalizar el programa //more//. También puede usar //more// como filtro. Por ejemplo | El programa paginador //more// pausa tras cada pantallazo, presentando el mensaje ''- - More- -'', en cuyo momento usted podrá presionar la **barra espaciadora** para obtener otro pantallazo, o **Retorno** para obtener otra línea, o una **q** para finalizar el programa //more//. También puede usar //more// como filtro. Por ejemplo |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| funciona de forma similar al comando //more// de ejecución directa que se indicó anteriormente. | funciona de forma similar al comando //more// de ejecución directa indicado anteriormente. |
| | |
| | Para detener la presentación en el terminal de los comandos sin involucrar a //more//, podrá recurrir a las teclas **^S** para pausar la salida. Podrá continuar la presentación en el terminal mediante **^Q** (o cualquier otra tecla, si bien por lo general se utiliza **^Q** pues esta sólo reinicia la presentación de salida, sin convertirse en entrada de otros comandos posibles del programa que está usted ejecutando). |
| |
| Para detener la presentación en el terminal de la salida de comandos sin involucrar a //more//, puede usar la tecla **^S** para pausarla. Podrá continuar la presentación en el terminal al presionar **^Q** (o cualquier otra tecla, pero por lo general se utiliza **^Q** pues esta sólo reinicia la presentación de salida, y no se convierte en entrada de otros comandos posibles del programa que está usted ejecutando). | Podrá operar este método adecuadamente si usa terminales de baja velocidad, pero con 9600 baudios o más probablemente encontrará dificultoso ingresar **^S** y **^Q** lo suficientemente rápido como para pausar adecuadamente la salida. Este es el motivo por el cual por lo general se recurre al programa //more//. |
| |
| Podrá operar este método adecuadamente con terminales de baja velocidad, pero con 9600 baudios o más encontrará dificultoso ingresar **^S** y **^Q** lo suficientemente rápido como para paginar adecuadamente la salida. Este es el motivo por el cual se recurre por lo general al programa //more//. | Una posibilidad adicional es recurrir al caracter de //descartar-salida// **^O**. Al tipear este caracter, toda la salida del comando actual se descarta (rápidamente) hasta que se produzca la siguiente lectura de entrada, o bien hasta la aparición del siguiente prompt. Puede utilizar //descartar-salida// para permitir la finalización de un comando sin tener que cumplir la impresión de grandes cantidades texto de salida en un terminal lento. **^O** opera como un conmutador, de manera que es posible conmutar dicho descarte ingresando nuevamente **^O** mientras se produce el descarte de salida. |
| |
| Una posibilidad adicional es recurrir al caracter de ''descartar-salida'' **^O**. Al tipear este caracter, toda la salida del comando actual se descarta (rápidamente) hasta producirse la siguiente lectura de entrada, o hasta la aparición del siguiente prompt. Puede utilizar esto para permitir la finalización de un comando sin tener que sufrir grandes cantidades de salida en un terminal lento. **^O** opera como un comnutador, de manera que el descarte puede conmutarse ingresando nuevamente **^O** mientras se produce el descarte de salida. | |
| ==== ¿Ahora qué? ==== | ==== ¿Ahora qué? ==== |
| |
| Hasta ahora hemos visto varios mecanismos de la shell y aprendimos mucho sobre la forma en la cual esta funciona. Las secciones restantes avanzarán más en el funcionamiento interno de la shell, pero seguramente querrá probar usando la shell csh antes de continuar. | Hasta ahora hemos considerado varios mecanismos de la shell y aprendimos bastante sobre la manera en la cual esta funciona. Las secciones restantes avanzarán más en el funcionamiento interno de la shell, pero seguramente querrá probar usando la shell Csh antes de continuar. |
| |
| La siguiente sección introducirá muchas funcionalidades particulares a csh, de modo que debe cambiarse la shell a csh antes de comenzar a leerla. | La siguiente sección introducirá muchas funcionalidades particulares a Csh, de modo que debe cambiarse la shell a csh antes de comenzar a leerla. |
| |
| Ahora está listo para intentar usar csh. | Ahora está listo para intentar usar csh. |
| ==== Inicio de la shell y terminación ==== | ==== Inicio de la shell y terminación ==== |
| |
| Cuando inicie sesión en el sistema, éste iniciará una shell, que ingresará a su directorio //home// y comenzará por leer los comandos del un fichero llamado ''.cshrc'' localizado en dicho directorio. Todas las shells que eventualmente inicie durante su sesión de terminal leerán este fichero. Mas adelante veremos qué tipos de comandos es útil colocar allí, por ahora no es necesario contar con este fichero, y la shell no se quejará por su ausencia. | Al iniciar sesión en el sistema, éste comenzará la ejecución de una shell. Esta ingresará a su directorio //home// y comenzará por leer los comandos de un fichero llamado ''.cshrc'' localizado en dicho directorio. Todas las C shells que eventualmente inicie anidadas durante su sesión de terminal leerán este fichero también. Mas adelante veremos qué tipos de comandos es útil colocar allí, por ahora no es necesario contar con este fichero, y la C shell no se quejará por su ausencia. |
| |
| Una //shell de login//, ejecutada tras el inicio de su sesión al sistema - tras leer los comandos contenidos en ''.cshrc'' - leerá comandos contenidos en un fichero ''.login'' (también en su directorio //home//). Este fichero contiene aquellos comandos los cuales usted desea ejecutar cada vez que inicie sesión en el sistema UNIX. Mi fichero ''.login'' tiene el siguiente aspecto: | La //shell de login// - aquella que se ejecuta tras su inicio de sesión al sistema leerá los comandos contenidos en el fichero ''.cshrc'' ya mencionado - tras lo cual leerá comandos contenidos en un fichero ''.login'' (también en su directorio //home//). Este fichero contiene comandos que usted desea ejecutar cada vez que inicie una sesión del sistema UNIX. Mi fichero ''.login'' contiene lo siguiente: |
| |
| |
| echo "${prompt}users" ; users | echo "${prompt}users" ; users |
| alias ts \ | alias ts \ |
| 'set noglob ; eval `tset -s -m dialup:cl00rv4pna -m plugboard:?hp2621nl *`'; | 'set noglob ; eval `tset -s -m dialup:vt100 -m plugboard:?hp2621nl *`'; |
| ts; stty intr ^C kill ^U crt | ts; stty intr ^C kill ^U crt |
| set time=15 history=10 | set time=15 history=10 |
| msgs -f | msgs -f |
| if (-e $mail) then | if (-e $mail) then |
| echo "${prompt}maiI" | echo "Tiene correo! ${prompt}" |
| mail | mail |
| endif | endif |
| </code> | </code> |
| |
| Este fichero contiene varios comandos para que UNIX los ejecuta cada vez que inicio mi sesión de terminal. El primero de ellos es un //set//. Este comando es interpretado en forma directa por la Shell, y configura la variable de shell ''ignoreeof'', que provoca que la shell no me cierre la sesión si presiono **^D**. En lugar de ello utilizo el comando //logout// para cerrar la sesión del sistema. Al establecer la variable ''mail'', le pido a la shell que revise los correos entrantes por mí; cada 5 minutos la shell revisa este fichero y me informa si me llegó correo electrónico. Una alternativa en lugar de usar tal //set// es colocar en su lugar el comando | Este fichero contiene varios comandos para que UNIX los ejecuta toda vez que inicie mi sesión de terminal. El primero de ellos es un //set//. Este comando es interpretado en forma directa por la C Shell, y configura la variable de shell ''ignoreeof'', que impide que la C shell desligue sesión al presionar **^D**. En lugar de ello utilizo el comando //logout// para cerrar la sesión del sistema. Al establecer la variable ''mail'', le pido a la C shell que revise los correos entrantes por mí; cada 5 minutos la C shell revisa este fichero y me informa si me ha llegado correo electrónico. Una alternativa en lugar de usar tal //set// es colocar en su lugar el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| lo que hará que se me notifique inmediatamente al arribo de correo (mostrándoseme unas pocas primeras líneas del nuevo correo). | lo que hará que se me notifique inmediatamente al arribo de correo (mostrándome unas pocas primeras líneas del nuevo correo). |
| |
| Posteriormente configuré la variable de shell ''time'' a ''15'', lo que hace que la shell automáticamente imprima líneas de estadística para aquellos comandos cuya ejecución requiera al menos 15 segundos de tiempo de CPU. La variable ''history'' se configura a ''10'', indicando que deseo que la shell recuerde los últimos 10 comandos que mecanografié en su //listado de historial// (descripto mas adelante). | Posteriormente configuré la variable de shell ''time'' a ''15'', lo que hace que la shell imprima automáticamente líneas de estadística para aquellos comandos cuya ejecución requiera al menos 15 segundos de tiempo de CPU. La variable ''history'' se establece en ''10'', indicando que deseo que la C shell recuerde los últimos 10 comandos mecanografiados en su //listado de historial// (descripto mas adelante). |
| |
| Creé un //alias// "ts" que ejecuta un comando //tset// configurando los modos de terminal. Los parámetros de //tset// indican los tipos de terminal que uso a menudo cuando no estoy en el puerto normal de la VAX. Luego ejecuto ''ts'' y también uso el comando //stty// para cambiar el caracter de interrupción a **^C** y el caracter de eliminar línea a **^U**. | Creé un //alias// "ts" que ejecuta un comando //tset// estableciendo los modos de terminal. Los parámetros de //tset// indican los tipos de terminal que uso a menudo cuando no estoy en el puerto normal de la VAX. Luego ejecuto ''ts'' y también uso el comando //stty// para cambiar el caracter de interrupción a **^C** y el caracter de eliminar línea a **^U**. |
| |
| Luego corro el programa //msgs// que me provee cualquier mensaje de sistema que no hubiese visto antes; la opción ''-r'' le impide decirme cualquier cosa si no hay mensajes nuevos. Finalmente, si mi fichero de casilla de correo existe, entonces ejecuto el programa //mail// para procesar mi correo. | Luego corro el programa //msgs// que me provee cualquier mensaje de sistema que no hubiese visto antes; la opción ''-r'' le impide decirme cualquier cosa si no hay mensajes nuevos. Finalmente, de existir mi fichero de casilla de correo, entonces ejecuto el programa //mail// para procesar mi correspondencia. |
| |
| Cuando los programas //mail// y //msgs// terminan, la shell finalizará de procesar mi fichero ''.login'' y comenzará a leer comandos desde el terminal, saludando a cada uno de ellos con el prompt ''% ''. Cuando cierro sesión (ejecutando el comando //logout//) la shell imprimirá ''logout'' y ejecutará comandos del fichero ''.logout'' si éste está presente en mi directorio //home//. Luego de aquello, la shell terminará y UNIX me desconectará del sistema. Si el sistema no se apaga, recibiré un nuevo mensaje de inicio de sesión. En cualquier caso, luego del mensaje ''logout'' la shell estará conminada a terminar, y no tomará en cuenta otra entrada desde mi terminal. | Cuando los programas //mail// y //msgs// terminan, la shell finalizará de procesar mi fichero ''.login'' y comenzará a leer comandos desde el terminal, saludando a cada uno de ellos con el prompt ''% ''. Cuando cierro sesión (ejecutando el comando //logout//) la C shell imprimirá ''logout'' y ejecutará comandos del fichero ''.logout'' si éste está presente en mi directorio //home//. Cumplido aquello, la shell terminará y UNIX me desconectará del sistema. Si el sistema no se apaga, recibiré un nuevo mensaje de inicio de sesión. En cualquier caso, luego del mensaje ''logout'' la shell estará conminada a terminar, y no tomará en cuenta otra entrada desde mi terminal. |
| |
| ==== Variables de la Shell ==== | ==== Variables de la Shell ==== |
| shell /bin/csh | shell /bin/csh |
| status 0 | status 0 |
| term cl00rv4pna | term vt100 |
| user bill | user bill |
| % | % |
| </code> | </code> |
| |
| para que la shell se refresque, lo que provocará que recalcule la tabla interna de localizaciones de comandos, de forma que poder encontrar los comandos recientemente agregados. Como toda vez que ejecuta un comando, la shell debe buscar en el directorio actual ''.'', ponerlo al final de la especificación establecida en la //path// usualmente funciona de forma equivalente, reduciendo el tiempo de espera. | para refrescar que la shell, recalculando su tabla interna de locaciones de comandos, que se utiliza en la búsqueda de los comandos agregados recientemente. Ya que toda vez que ejecuta un comando, la shell pesquisa en el directorio actual ''.'', establecerlo en la //path// al principio de la especificación opera por lo general de forma equivalente, reduciendo los tiempos de espera. |
| |
| Otras variables incorporadas útiles son las variables ''home'' que muestra su directorio //home//, ''cwd'' que contiene su directorio de trabajo actual, y la variable ''ignoreeof'' (la cual puede ser configurada en su fichero ''.login'' para decirle a la shell que no salga cuando recibe un caracter //fin de fichero// desde un terminal, como se mencionó anteriormente). La variable ''ignoreeof'' es una de aquellas en las que la shell no le importa su valor asignado, sólo hace caso si dice //set// o //unset// para denotar q1ue están configuradas o no, respectivamente. Por lo tanto, para establecer esta variable usted simplemente indica | Otras variables incorporadas útiles consisten en las variables ''home'', que muestra su directorio //home//, ''cwd'' que contiene su directorio de trabajo actual, y la variable ''ignoreeof'' (que dice a la shell que no se desligue al recibir un caracter //fin de fichero// desde un terminal (como se mencionó anteriormente, lo cual puede establecerse en su fichero ''.login''). La variable ''ignoreeof'' es una de aquellas en las que la shell hace caso omiso de su valor asignado, sólo analiza si dice ''set'' o ''unset'' denotando si está establecida o no, respectivamente. Por lo tanto, para establecer esta variable se indica simplemente |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| y para desestablecerla, usted utiliza | y para desestablecerla, se indica |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Estos no le otorgan a la variable ''ignoreeof'' valor alguno, pero no se les requiere o desea en lo absoluto. | >Los comandos anteriores no otorgan valor alguno a la variable ''ignoreeof'', pues ésta no los requiere ni los desea en lo absoluto. |
| |
| Finalmente, algunas de las otras variables incorporadas de la shell en uso son las variables ''noclobber'' y ''mail''. | Finalmente, algunas de las otras variables incorporadas de la shell en uso son las variables ''noclobber'' y ''mail''. |
| </code> | </code> |
| |
| que redirige la salida estándar de un comando, sobrescribirá y destruirá los contenidos previos de ''fichero''. Acaso usted __podría sobrescribir accidentalmente un fichero que es valioso__. Si prefiere que la shell no sobrescriba ficheros de esta manera, puede indicar | que redirige la salida estándar de un comando, __sobrescribirá y destruirá__ los contenidos previos de ''fichero'', y como tal es posible sobrescribir accidentalmente un fichero valioso. Si prefiere que la shell no sobrescriba ficheros de esta manera tan liviana, puede indicar en su fichero ''.login'' |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| en su fichero ''.login''. Luego intente ordenar | Tras loguearse nuevamente, intente ordenar |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| lo que causará un //diagnóstico de error// si ''ahora'' ya existe. Podría mecanografiar | y comprobará un //diagnóstico de error// si ''ahora'' ya existe. Para producir la sobrescritura de ''ahora'' si __realmente__ lo desea, debe mecanografiar |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| si __realmente desea sobrescribir__ los contenidos de ''ahora''. El ''>!'' es una metasintaxis especial que indica que está bien "darle una paliza" a ''fichero'' [NdT: clobber significa "apalear", y es la jerga utilizada para denotar la sobrescritura inadvertida del ''fichero'']. | El ''>!'' es una metasintaxis especial que indica que está bien "darle una paliza" a ''fichero'' [NdT: clobber significa "apalear", y es la jerga utilizada para denotar la sobrescritura inadvertida del ''fichero'']. |
| |
| > El espacio en blanco entre el ''!'' y la palabra ''ahora'' es crítico, ya que ''!ahora'' invocaría las [[#historial de la shell|mecanismo de historial]], que tiene un efecto completamente distinto. | > El espacio en blanco entre el ''!'' y la palabra ''ahora'' es crítico, ya que ''!ahora'' invocaría las [[#historial de la shell|mecanismo de historial]], que tiene un efecto completamente distinto. |
| ==== Historial de la shell ==== | ==== Historial de la shell ==== |
| |
| La shell puede mantener una //lista de historial// en la cual pone las palabras de los comandos anteriormente ejecutados. Es posible utilizar una notación para reutilizar comandos o palabras de los comandos en la formación de nuevos comandos. Este mecanismo puede utilizarse para repetir comandos previos o corregir errores de mecanografiado menores en los comandos. | La C Shell puede mantener una //lista de historial// en la cual coloca las palabras de los comandos ya ejecutados. Es posible reutilizar comandos o palabras de los comandos en la formación de nuevos comandos a través de una notación. Tal mecanismo puede utilizarse para repetir comandos previos o corregir errores de mecanografiado menores en los comandos. |
| |
| La siguiente es una sesión de ejemplo que involucra el uso típico del mecanismo de historial de la shell. En este ejemplo tenemos un programa muy simple en lenguaje C que tiene un bug (o dos), en el fichero ''bug.c'', el cual revisamos con //cat// en nuestra terminal. Luego intentamos [[tutorial de compilación|correr el compilador CC]] con él, refiriendo el fichero nuevamente como ''!$'' (lo que significa el último argumento del comando anterior). Aquí el ''!'' es el metacaracter de invocación al mecanismo historial, mientras que el ''$'' refiere al "último argumento" (en analogía al uso de ''$'' en el editor ed, que significa "final de la línea"). La shell da eco del comando - tal como se hubiese mecanografiado sin recurrir al mecanismo de historial - y luego lo ejecuta. La compilación produjo un //diagnóstico de error// de manera que corremos el editor en el fichero que intentábamos compilar, corregimos el bug, y corrimos nuevamente el compilador de C, esta vez refiriendo a este comando simplemente como ''!c'' (lo que repite el último comando historiado que comenzaba con la letra ''c''). Si hubiesen existido otros comandos historiados que comenzaban con la letra ''c'', podríamos haber tenido que recurrí a especificar con mayor detalle ''!cc'' o incluso ''!cc:p'' (que hubiese impreso el último comando que comenzaba con ''cc'' pero sin ejecutarlo). | A continuación se ofrece una sesión de ejemplo que involucra el uso típico del mecanismo de historial de la C Shell. En tal ejemplo se recurre a un terminal para revisar con //cat// el contenido del fichero ''bug.c'', un programa muy simple en lenguaje C que contiene uno o dos bugs. Luego intentamos [[tutorial de compilación|correr el compilador CC]] con él, refiriendo el fichero nuevamente a través de la orden ''!$'' (lo que significa "el último argumento del comando anterior"). |
| | |
| | > Aquí, ''!'' es el metacaracter de invocación al mecanismo historial, mientras que ''$'' refiere al "argumento final", en analogía al uso de ''$'' en el editor ed, que significa "final de la línea"). |
| | |
| | La C Shell da eco del comando tal como se hubiese mecanografiado sin recurrir al mecanismo de historial, y luego lo ejecuta. Ya que la compilación produce un //diagnóstico de error//, se ejecuta el editor en el fichero que se intentó compilar, se corrige el bug, y se ordena repetir la ejecución del compilador de C con el mecanismo de historial. Para ello, esta vez se simplemente indicamos el comando ''!c'', que significa "repetir el último comando historiado que comenzaba con la letra ''c''"). De haber existido otros comandos historiados que comenzaban con la letra ''c'', se podría haber tenido que recurrir a especificar más detalladamente, ya sea con ''!cc'', o incluso ''!cc:p'' (que hubiese ordenado "imprime el último comando que comenzaba con ''cc'', sin ejecutarlo"). |
| |
| <code> | <code> |
| main () | main () |
| { | { |
| printf("hola) ~ | printf("hola); |
| } | } |
| |
| ed bug.c | ed bug.c |
| 30 | 30 |
| 4s/lo/lo\\n/p | 4s/la/la\\n/p |
| printf("hola\n"); | printf("hola\n"); |
| w | w |
| </code> | </code> |
| |
| Luego recompilar, corremos e fichero ''a.out'' resultante, y notamos que aún hay un bug, por lo que corremos nuevamente el editor. Tras corregir el programa corremos el compilador C nuevamente, pero asociado al comando un ''-o bug'' extra indicando al compilador que coloque el binario resultante en el fichero ''bug'' en lugar del nombre por defecto ''a.out''. El mecanismo de historial puede usarse en general en cualquier lugar de la formación de nuevos comandos y pueden colocarse otros caracteres antes y después de los comandos sustituidos. | Tras recompilar, se ejecutó el fichero ''a.out'' resultante, y se notó que un bug aún persistía, por lo cual se corrió nuevamente el editor. Tras corregir el programa se corrió el compilador C nuevamente, asociado esta vez al comando extra ''-o bug'', que indica al compilador colocar el binario resultante en un fichero ''bug'' (en lugar de utilizar el nombre ''a.out'' al que recurre el compilador por defecto). |
| |
| Podemos luego correr el comando //size// para ver cuán grande eran las imágenes de los programas binarios que habíamos creado, y luego un comando ''ls -l'' con la misma //lista argumental//, denotando la lista argumenta ''.''. Finalmente, corremos el programa ''bug'' para ver si su salida es de hecho correcta. | >El mecanismo de historial puede usarse por lo general en cualquier lugar de la formación de nuevos comandos y pueden colocarse otros caracteres antes y después de los comandos sustituidos. |
| |
| Para hacer un listado numerado del programa corremos el comando //num// en el fichero ''bug.c''. Para comprimir las líneas en blanco en la salida de //num// corremos la salida a través del filtro //ssp// pero lo mecanografiamos erróneamente, escribiéndolo como ''spp''. Para corregir esto usamos una sustitución de shell, colocando el viejo texto y el nuevo entre caracteres ''^''. Esto es similar al comando "sustituir" del editor ed. Finalmente, repetimos el mismo comando con ''!!'' pero enviamos su salida a la impresora de línea. | Luego se ejecutó el comando //size// para comprobar cuán grande eran las imágenes binarias resultantes de los programas compilados, y luego se recurrió al comando ''ls -l'' con la misma //lista argumental//, denotando la lista argumental ''.''. Finalmente, se ejecutó el programa ''bug'' para comprobar si su salida es de hecho correcta. |
| |
| Existen otros mecanismos disponibles para repetir comandos. El comando //history// imprime cierta cantidad de comandos previos con números a través de los cuales pueden ser referenciados. | Se ejecutó el comando //num// con el fichero ''bug.c'' para obtener un listado numerado del programa. Acto seguido se quiso entubar la salida de //num// a través del filtro //ssp// a fin de comprimir las líneas en blanco, pero se cometió un error de mecanografía, escribiendo erróneamente ''spp''. Para corregirlo el yerro se recurrió a un mecanismo de sustitución de shell, colocando la cadena errónea y la correcta entre caracteres ''^'' (pues opera de igual forma al comando "sustituir" del editor ed). Finalmente, se reiteró el mismo comando con ''!!'', pero enviando su salida a la impresora de línea. |
| |
| Hay una manera de referir a un comando previo buscándolo a por medio de una cadena que aparezca en el, y existe otra - menos útil - para seleccionar argumentos a incluir en un nuevo comando. Una descripción completa de todos estos mecanismos se da en las páginas [[man]] de csh, y en el Manual de Programador de UNIX. | Existen otros mecanismos para reiterar comandos. El comando //history// imprime cierta cantidad de comandos previos asociados a una numeración, por medio de la cual se los puede referenciar. |
| | |
| | Hay una manera de referir a un comando previo buscándolo a por medio de una cadena que aparezca en el, y existe otra - menos útil - para seleccionar argumentos a incluir en un nuevo comando. Se ofrece en las páginas [[man]] de csh una descripción completa de todos estos mecanismos, así como en el Manual de Programador de UNIX. |
| |
| ==== Alias ==== | ==== Alias ==== |
| |
| La shell cuenta con un mecanismo de //alias// que puede ser utilizado para efectuar transoframciones en los comandos de entrada. Tal mecanismo puede ser utilizado para simplificar los comandos que interesan, supliendo argumentos por defecto deseados a dichos comandos, o bien para operar transformaciones a los comandos y sus argumentos. La funcionalidad de alias es similar a una facilidad por macros. Algunas de las funcionalidades obtenidas utilizando alias puede obtenerse también usando ficheros de intérprete de comanods, pero estas tomarán lugar en otra instancia de la shell, y no pueden afectar directamente el ambiente actual de la sehll o involucrar comandos tales como //cd//, que deben correr en la shell actual. | La C shell cuenta con un mecanismo de //alias// que puede ser utilizado para efectuar transformaciones en los comandos de entrada. Puede utilizarse este mecanismo para simplificar los comandos que interesan, supliendo a dichos comandos los argumentos deseados por defecto, o bien para operar transformaciones a los comandos y sus argumentos. |
| | |
| | >La funcionalidad de alias es similar a una facilidad de macros. |
| | |
| | Algunas de las funcionalidades obtenidas por medio de alias también pueden lograrse usando ficheros de intérprete de comandos, pero estas se llevarán a cabo en otra instancia anidada de la C shell, y no podrán afectar directamente el ambiente de la shell actual o involucrar comandos tales como //cd// (que deben correr en la shell actual). |
| |
| Por ejemplo, supongamos que existe una nueva versión del programa de correo en el sistema que se llama //newmail//, la cual deseamos utilizar en lugar del programa de correo estándar //mail//. Si en su fichero ''.cshrc'' emplea el comando de shell | Por ejemplo, supongamos que existe una nueva versión del programa de correo en el sistema que se llama //newmail//, la cual deseamos utilizar en lugar del programa de correo estándar //mail//. Si en su fichero ''.cshrc'' dispone el siguiente comando de shell |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| la shell transformará una linea de entrada dada según la forma | la C shell transformará una linea de entrada dada según la forma |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| entonces la shell lo traducirá como | entonces la C shell lo traducirá como |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| De esta forma, el mecanismo de //alias// puede usarse para proveer nombres cortos a comandos, para proveer argumentos por defecto, y para definir nuevos comandos cortos en relación a otros comandos. También es posible definir alias que contengan múltiples comandos o cañerías, mostrando donde se encuentran los argumentos del comando original para sustituirlos por medio de las facilidades del mecanismo de historia. Por tanto la definición | De esta forma, el mecanismo de //alias// puede usarse para proveer nombres cortos a comandos, para proveer argumentos por defecto, y para definir nuevos comandos cortos en relación a otros comandos. También es posible definir alias que contengan múltiples comandos o cañerías, mostrando donde se encuentran los argumentos del comando original para sustituirlos por medio de las facilidades del mecanismo de historial. Por tanto la definición |
| |
| <code bash> | <code bash> |
| alias cd 'cd \!* ; Is ' | alias cd 'cd \!* ; ls ' |
| </code> | </code> |
| |
| haría un comando //ls// tras efectuado todo cambio de directorio con el comando //cd//. Apostrofamos entre caracteres ''<nowiki>'</nowiki>'' la definición entera del alias a fin de impedir que se produzcan la mayoría de las substituciones, y el caracter '':'' sea reconocido como un metacaracter. Aquí, el ''!'' resulta anulado con una ''<nowiki>\</nowiki>'' para impedir que sea interpretado al intruducir el comando de alias. El ''<nowiki>\!*</nowiki>'' sustituye aquí la //lista argumental// completa del comando //cd// previo al alias, sin dar un error si no tuviese argumentos. El '';'' que separa los comandos se usa aquí para indicar que un comando debe completarse, y luego el siguiente. De forma similar, la definición | haría un comando //ls// tras efectuar todo cambio de directorio con el comando //cd//. Apostrofamos entre caracteres ''<nowiki>'</nowiki>'' la definición entera del alias a fin de impedir que se produzcan la mayoría de las substituciones, y que el caracter '':'' sea reconocido como un metacaracter. En este caso, al introducir el comando de alias, este ''!'' resulta anulado con una ''<nowiki>\</nowiki>'' para impedir que resulte interpretado. Aquí, el ''<nowiki>\!*</nowiki>'' sustituye la //lista argumental// completa del comando //cd// previo al alias (sin dar un error si no tuviese argumentos). El '';'' que separa los comandos aquí se utiliza para indicar que se debe cumplir un comando, y luego el siguiente. De forma similar, la definición |
| |
| <code bash> | <code bash> |
| define un comando que busca su primer argumento en el fichero de contraseñas. | define un comando que busca su primer argumento en el fichero de contraseñas. |
| |
| __Cuidado__: La shell actualmente lee el fichero ''.cshrc'' cada vez que inicia. Si dispone allí una cantidad excesiva de comandos, las shells tenderán a tener un inicio lento. Un mecanismo útil que guarde el ambiente de la shell luego de leer el fichero ''.cshrc'' y restaurarlo rápidamente se encuentra en desarrollo, pero por ahora debe intentar limitar la cantidad de alias que tiene a un número razonable... 10 o 15 es razonable; 50 o 60 causarán retrasos notables de arranque en las shells, y el sistema se volverá lento cuando ejecuta comandos desde el interior del editor u otros programas. | __Cuidado__: La shell lee el fichero ''.cshrc'' cada vez que inicia. Si dispone allí una cantidad excesiva de comandos, las shells tenderán a tener un inicio lento. Se encuentra en desarrollo un mecanismo útil capaz de guardar el ambiente de la shell luego de leer el fichero ''.cshrc'' y restaurarlo rápidamente , pero por ahora debe intentar limitar la cantidad de alias establecidos a un número razonable... 10 o 15 es razonable; 50 o 60 serán casuales de notables retrasos de inicialización de las shells, con lo que el sistema se volverá lento al ejecutar comandos anidados desde el interior del editor u otros programas. |
| |
| ==== Mas redirecciones: >> y >& ==== | ==== Mas redirecciones: >> y >& ==== |
| |
| Existen varias notaciones adicionales útiles para el usuario de terminal que no fueron explicadas aún. | Aún existen varias notaciones adicionales útiles para el usuario de terminal que no fueron explicadas: las redirecciones adicionales. |
| |
| Además de la salida estándar, los comandos también tienen una //salida de diagnóstico// que normalmente está dirigida al terminal, incluso cuando la salida estándar está redirigida a un fichero o a un caño. En ocasiones es deseable dirigir la salida de diagnóstico junto con la salida estándar. Por ejemplo, si desea redirigir la salida de un comando de larga ejecución a un fichero, y desea tener un registro de cualquier diagnóstico de error que produzca, puede ingresar | Además de la salida estándar ya tratada, los comandos cuentan también con una //salida de diagnóstico// que normalmente está dirigida al terminal - incluso si la salida estándar está redirigida a un fichero o a un caño. En ocasiones es deseable dirigir la salida de diagnóstico junto con la salida estándar. Por ejemplo, si desea redirigir la salida de un comando de larga ejecución a un fichero, y desea contar con un registro de cualquier diagnóstico de error que produzca ("log"), puede ingresar |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Aquí el ''>&'' le dice a la shell que redirija tanto la salida de diagnóstico como la salida estándar en ''fichero''. | Aquí el ''>&'' le solicita a la C shell que redirija tanto la //salida de diagnóstico// como la //salida estándar// a ''fichero''. |
| |
| De manera similar, puede dar la orden comando | De manera similar, puede dar la orden comando |
| |
| <code bash> | <code bash> |
| comando | & lpr | comando |& lpr |
| </code> | </code> |
| |
| </code> | </code> |
| |
| para colocar la salida al final de un fichero existente. | para colocar la salida al final de un ''fichero'' existente. |
| |
| ==Noclober== | ==Noclobber== |
| |
| Existe una forma de comando | Existe una forma de comando |
| </code> | </code> |
| |
| Esta se usa cuando la [[#variables de la shell|variable noclobber]] está activada y ''fichero'' ya existe. Si ''noclobber'' está activada, entonces resultaría en error si ''fichero no existe''. De otro modo la shell creará ''fichero'' si este no existe. La forma | Esta se usa cuando la [[#variables de la shell|variable noclobber]] está activada y ''fichero'' ya existe. Sstri ''noclobber'' se encuentra activada, da como resultado un error ''fichero no existe''. De otro modo la shell creará ''fichero'' si este no existe. La forma |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| hará que no dé error si ''fichero'' es inexistente y la variable de shell ''noclobber'' está activada. | hará no dará error si ''fichero'' es inexistente y la variable de shell ''noclobber'' se encuentra establecida (activada). |
| |
| ==== Trabajos; Segundo Plano, Primer Plano, o Suspendido ==== | ==== Trabajos; Segundo Plano, Primer Plano, o Suspendido ==== |
| |
| Al introducir uno o más comandos juntos siguiendo la forma de //cañería// (separados por ''|'') o //secuencia de comandos// (separados por punto y coma '';''), la shell genera un único //trabajo// ("job"), que consiste en dichos comandos unificados. Un comando aislado sin ''|'' o '';'' genera un trabajo mas simple. Usualmente, cada línea mecanografiada a la shell genera un trabajo. Algunas de las líneas que generan trabajos (uno por línea) son | Al introducir uno o más comandos juntos siguiendo la forma de //cañería// (separados por ''|'') o //secuencia de comandos// (separados por punto y coma '';''), la shell genera un único //trabajo// ("job"), que consiste en dichos comandos unificados. Un comando aislado (sin ''|'' o '';'' genera) un trabajo simple. Por lo general, cada línea mecanografiada a la shell genera un trabajo. Algunas de las órdenes que generaron trabajos (uno por línea) fueron |
| |
| <code> | <code> |
| sort < data | sort < datos |
| ls -s | sort -n | head -5 | ls -s | sort -n | head -5 |
| mail harold | mail haroldo |
| </code> | </code> |
| |
| Si al final de los comandos se mecanografía el metacaracter ''&'', entonces el trabajo correspondiente se inicia como un //trabajo en segundo plano//. Esto significa que la shell no aguardará su finalización, sino que quedará lista y a la espera de otro comando inmediato. Tal trabajo se ejecutará //en el segundo plano//, al mismo tiempo que los trabajos normales - llamados //trabajos en primer plano// - siguen siendo leídos y ejecutados por la shell de uno a la vez. Por lo tanto | Toda vez que al final de la orden se mecanografíe el metacaracter ''&'', entonces la misma se iniciará en la forma de //trabajo en segundo plano//. Esto significa que la shell no aguardará su cumplimiento, sino que quedará inmediatamente a la espera de otro comando. Dicho trabajo se ejecutará //en segundo plano//. Esto guarda diferencia con aquellos trabajos normales - llamados //trabajos en primer plano// - que siguen siendo leídos y ejecutados por la shell de uno a la vez. Por lo tanto |
| |
| |
| </code> | </code> |
| |
| correrá el programa //du//, encargado de reportar el uso de disco de su directorio de trabajo (así como el de cualquier directorio por debajo de él), poner la salida en el fichero ''uso_de_disco'' y retornar inmediatamente con un prompt para eventual disposición de un comando ulterior (sin esperar a que //du// finalice). El programa //du// continuará su ejecución en el segundo plano hasta completarse, incluso aunque usted mientras tanto mecanografie y solicite ejecución de otros comandos. Justo antes del siguiente prompt, la shell presentará un mensaje cuando termine un trabajo en segundo plano, informando tal cosa. En el siguiente ejemplo, el trabajo //du// finalizó en cierto momento durante la ejecución del comando //mail//, y su finalización fue reportada justo antes de que el trabajo //mail// fuese finalizado. | corre el programa //du//, encargado de reportar el uso de disco de su directorio de trabajo (así como el de cualquier directorio por debajo de él), coloca su salida en el fichero ''uso_de_disco'' y vuelve inmediatamente la atención a usted indicando un prompt para eventual disposición de un ulterior comando nuevo (sin aguardar la finalización de //du//). Mientras tanto el programa //du// continuará su ejecución en segundo plano hasta finalizar, incluso aunque usted mecanografíe y solicite cumplimiento de otros comandos. Al finalizar un trabajo en segundo plano, la shell presentará un mensaje informando tal cosa justo antes de su prompt siguiente. |
| | |
| | En el siguiente ejemplo, el trabajo //du// finalizó en cierto momento durante la ejecución del comando //mail//, y su finalización se reportó justo antes de que el trabajo //mail// finalizase. |
| |
| <code bash> | <code bash> |
| % du > uso_de_disco & | % du > uso_de_disco & |
| [1] 503 | [1] 503 |
| | |
| % mail bill | % mail bill |
| ¿Cómo es posible saber cuando un trabajo en segundo plano ha finalizado? | ¿Cómo es posible saber cuando un trabajo en segundo plano ha finalizado? |
| EOT | EOT |
| [1] - Done du > uso_de_disco | [1] - Done du > uso_de_disco |
| | |
| % | % |
| </code> | </code> |
| |
| Ante una finalización anormal del trabajo, el mensaje ''Done'' podría verse reemplazado por algo distinto, como ''Killed''. Si desea que le sean reportadas las finalizaciones de programas en segundo plano al mismo momento de ocurrir (posiblemente interrumpiendo la salida de terminal de otros trabajos en primer plano), puede establecer la variable ''notify''. En el ejemplo anterior, esto podría implicar que el mensaje ''Done'' podría aparecer directamente en el medio de la redacción del correo a Bill. Los trabajos en segundo plano no resultan afectados por ninguna señal del teclado tales como las señales STOP, INTERRUPT, o QUIT mencionadas anteriormente. | Ante una finalización anormal de un trabajo, el mensaje ''Done'' podría intercambiarse por otro diferente, tal como ''Killed''. Si usted desea que se le reporten aquellas finalizaciones de programas en segundo plano al mismo momento en que se producen - eventualmente incluso interrumpiendo la salida de terminal de otros trabajos que pudiese tener en primer plano - puede establecer la variable ''notify''. Siguiendo el ejemplo anterior, podría implicar que el mensaje ''Done'' eventualmente aparezca directamente en medio de la redacción del correo a Bill. |
| |
| La C shell registra los trabajos en una //tabla de trabajos// incorporada hasta su finalización. La shell toma nota de los nombres de comando, argumentos y el //número de proceso// de todos los comandos en el listado de trabajos, así como el directorio de trabajo donde se inició el trabajo. Cada trabajo de la tabla puede estar ejecutándose //en primer plano// (con la shell aguardando su finalización), corriendo //en segundo plano//, o //suspendido//. Sólo puede correr en el primer plano un trabajo a la vez, pero es posible contar con varios trabajos suspendidos o corriendo en segundo plano a la vez. Los números de trabajo siguen siendo los mismos hasta que el trabajo finalice, y luego son reutilizados. | >Los trabajos en segundo plano no resultan afectados por ninguna señal del teclado tales como las señales STOP, INTERRUPT, o QUIT mencionadas anteriormente. |
| |
| Al iniciar la ejecución un trabajo en segundo plano por medio del sufijo ''&'', antes que la shell le presente un prompt para ingresar un nuevo comando, le informará el número de trabajo - así como los números de proceso de todos sus comandos de nivel superior - . Por ejemplo, | La C shell inicia el alta los trabajos en una //tabla de trabajos// incorporada, y finaliza su baja con su cumplimiento. En esta tabla de trabajos la C shell tabula el nombre de comando, argumentos, //número de identificador proceso// (PID) de todos los comandos, así como el directorio de trabajo donde se inició cada trabajo. Cada trabajo tabulado puede estar |
| | |
| | * En ejecución //en primer plano// (la C shell aguarda su finalización), |
| | * En ejecución //en segundo plano//, |
| | * //suspendido//. |
| | |
| | Sólo puede estar en ejecución en primer plano un trabajo por vez, pero es posible contar con varios trabajos suspendidos o corriendo en segundo plano a la vez. Los números de trabajo siguen siendo los mismos hasta que el trabajo finalice, y luego son reutilizados. |
| | |
| | Al ordenar ejecución de un trabajo en segundo plano por medio del sufijo ''&'', antes que la shell le presente un prompt para ingresar un nuevo comando le informará el //número de cola de trabajos// - así como los números de identificador de proceso de todos sus comandos de nivel superior - . Por ejemplo, |
| |
| |
| </code> | </code> |
| |
| ejecuta el programa //ls// con la opción ''-s'', entuba la salida resultante al programa //sort// con la opción ''-n'' que pone dicha salida en el fichero ''uso_de_disco''. Debido a que el ''&'' aparece como sufijo al final de la línea, ambos programas se iniciaron conjuntamente en la forma de un //trabajo en segundo plano//. Tras iniciar el trabajo, la shell presentó el //número de trabajo// entre corchetes - ''[2]'' en este caso - seguido por el //número de proceso// de cada programa iniciado en el trabajo. Inmediatamente después la shell presenta un prompt para ingresar un eventual nuevo comando, dejando al trabajo ejecutándose en simultáneo. | ejecuta el programa //ls// con la opción ''-s'', entuba su salida al programa //sort// con la opción ''-n'', y coloca la salida resultante en el fichero ''uso_de_disco''. Debido al sufijo ''&'' al final de la línea ambos programas se iniciaron conjuntamente en la forma de un //trabajo en segundo plano//. Una vez iniciado el trabajo, la shell presentó el //número de cola de trabajos// entre corchetes - ''[2]'' en este caso - seguido por el //número de proceso// de cada programa iniciado en el trabajo en cuestión. Inmediatamente después, la shell ofrece un prompt para ingresar eventualmente una nueva orden, dejando al trabajo en ejecución concurrente (en simultáneo). |
| |
| Como se mencionó en la [[#finalizando comandos|sección 1.8]], los trabajos en primer plano se suspenden mecanografiando **^Z**, lo cual envía una señal STOP al trabajo en ejecución en primer plano. Un trabajo en segundo plano puede ser suspendido utilizando el comando //stop// descripto adelante. Cuando los trabajos resultan suspendidos, su ejecución se detiene hasta ser iniciados nuevamente - ya sea en el primer o en el segundo plano. La shell nota cuando un trabajo se suspende e informa del hecho de manera bastante similar a los informes de finalización de trabajo en segundo plano. En el caso del trabajo en primer plano, esto guarda una apariencia similar a | Como se mencionó en la [[#finalizando comandos|sección 1.8]], los trabajos en //primer plano// se suspenden mecanografiando **^Z**, lo cual envía una señal STOP al trabajo en ejecución en primer plano. Puede suspender un trabajo en ejecución en segundo plano mediante comando //stop// que se describirá mas adelante. Una vez que los trabajos se suspenden, su ejecución se detiene hasta ser iniciados nuevamente - ya sea en el primer o en el segundo plano. La shell toma nota de la suspensión de un trabajo, e informa el hecho de manera bastante similar a los informes de finalización de trabajo en segundo plano. En el caso del trabajo en primer plano, esto guarda una apariencia similar a |
| |
| <code bash> | <code bash> |
| ^Z | ^Z |
| Stopped | Stopped |
| | |
| % | % |
| </code> | </code> |
| |
| cuando la shell nota que el programa //du// se ha detenido, presenta el mensaje ''Stopped''. Cuando usamos el comando //stop// para detener los trabajos en segundo plano, se presenta | en donde la shell presenta el mensaje ''Stopped'' al notar que el programa //du// se ha suspendido. Al usar el comando //stop// para detener los trabajos en segundo plano, se presenta |
| |
| <code bash> | <code bash> |
| % sort uso_de_disco & | % sort uso_de_disco & |
| [1] 2345 | [1] 2345 |
| | |
| % stop %1 | % stop %1 |
| [1] + Stopped (signal) sort uso_de_disco | [1] + Stopped (signal) sort uso_de_disco |
| | |
| % | % |
| </code> | </code> |
| |
| Si necesitamos temporalmente conmutar entre lo que estábamos haciendo, puede sernos útil detener los trabajos en primer plano, ejecutar otros comandos, y retornar al trabajo suspendido. Asimismo, es posible detener los trabajos en primer plano y continuar su ejecución en la forma de trabajos en segundo plano por medio del comando //bg//. Esto le permitirá continuar un trabajo distinto, poniéndo el segundo plano en espera hasta que el trabajo en primer plano finalice. Por tanto | De necesitar alternar temporalmente entre lo que estamos haciendo, puede ser útil suspender los trabajos en primer plano, ejecutar otros comandos, y retornar al trabajo suspendido. Asimismo, es posible suspender los trabajos en primer plano y continuar su ejecución en la forma de trabajos en segundo plano por medio del comando //bg//. Esto permite __continuar un trabajo distinto__, poniendo el segundo plano en espera hasta que el trabajo en primer plano finalice. Por tanto |
| |
| |
| ^Z | ^Z |
| Stopped | Stopped |
| | |
| % bg | % bg |
| [1] + uso_de_disco & | [1] + uso_de_disco & |
| | |
| % | % |
| </code> | </code> |
| |
| inicia //du// en el primer plano, lo detiene antes de finalizar, luego lo continúa en segundo plano permitiendo la ejecución en primer plano de eventuales nuevos comandos. Esto se presenta especialmente útil cuando un trabajo en primer plano demanda más tiempo de ejecución que el previsto, por lo que usted hubiese deseado iniciarlo en segundo plano desde un principio. | inicia //du// en el primer plano, lo detiene antes de finalizar, usa //bg// para pasarlo a ejecución en segundo plano, permitiendo así eventuales nuevos comandos de ejecución en primer plano. Esto se presenta especialmente útil cuando un trabajo en primer plano demanda un tiempo de ejecución mayor que el previsto, por lo que usted hubiese deseado iniciarlo en segundo plano desde un principio. |
| |
| Todos los //comandos de control de trabajos// pueden recibir un argumento que identifica el trabajo particular. Todos los //argumentos de nombre de trabajo// comienzan con el caracter ''%'', si bien alguno de los comandos de control del trabajo también aceptan números de proceso (presentados por el comando //ps//). El trabajo por defecto (si no se le proveen argumentos) es llamado //trabajo actual// y es identificado por un ''+'' in la salida del comando //jobs//, el cual muestra cuáles son los trabajos que tiene. Cuando sólo hay un trabajo en ejecución o detenido en el segundo plano (el caso usual) este siempre será el //trabajo actual//, y por tanto no necesita argumentos. Si un trabajo ha sido detenido en el primer plano, se transforma en el //trabajo actual// y el trabajo actual existente se convierte en el trabajo //previo//. Cuando es dado, el argumento es tanto ''%-'' (que denota //trabajo previo//; ''%#'' donde el ''#'' es el número de trabajo; ''%pref'' (donde pref es algun prefijo único del nombre de comando y argumentos de uno de los trabajos; o ''?%'' seguido por alguna cadena encontrada en solo uno de los trabajos. | ===Comandos de control de trabajos=== |
| |
| Los tipos de comandos de trabajos de la tabla de trabajos, dando el número de trabajo, comandos, y status (''Stopped'' or ''Running'') de cada trabajo en segundo plano o trabajo suspendido. Con la opción ''-l'' los números de proceso también son presentados. | ^ Comando de Control de Trabajos ^ Resultado ^ |
| | | jobs | Presenta la cola de trabajos | |
| | | fg | | Trae un trabajo en ejecución en segundo plano o suspendido a ejecución en primer plano | |
| | | bg | Pasa un trabajo suspendido a segundo plano | |
| | | stop, Ctrl+Z | Suspende un trabajo en ejecución en segundo plano | |
| | | kill | termina un trabajo suspendido o en segundo plano o | |
| | | notify | notifica inmediatamente cuando finalizan los comandos | |
| | |
| | Todos los //comandos de control de trabajos// de la C shell pueden recibir un argumento que identifica el trabajo particular. Los //argumentos de nombre de trabajo// deben indicarse con el caracter ''%'', si bien alguno de los comandos de control del trabajo también aceptan números de identificador de proceso PID (presentados por el comando //ps//). El trabajo por defecto (si no se le proveen argumentos) es llamado //trabajo actual// y es identificado por un ''+'' in la salida del comando //jobs//, el cual muestra cuáles son los trabajos que tiene. Cuando sólo existe un trabajo en ejecución o detenido en el segundo plano (el caso usual), el mismo siempre será el //trabajo actual//, y por tanto no necesita argumentos. Si un trabajo ha sido detenido en el primer plano, se transforma en el //trabajo actual// y el trabajo actual existente se convierte en el trabajo //previo//. Cuando es dado, el argumento es tanto ''%-'' (que denota //trabajo previo//; ''%#'' donde el ''#'' es el número de trabajo; ''%pref'' (donde pref es algún prefijo único del nombre de comando y argumentos de uno de los trabajos; o ''?%'' seguido por alguna cadena encontrada en solo uno de los trabajos, presenta la tabla de trabajos con los tipos de comandos de trabajos, los comandos, el número de trabajo, y estado de status (''Stopped'' o ''Running'') de cada trabajo en segundo plano o trabajo suspendido. Sumando la opción ''-l'' también presenta los números de identificador de proceso PID. |
| |
| <code> | <code> |
| % du > uso_de_disco & | % du > uso_de_disco & |
| [1] 3398 | [1] 3398 |
| | |
| % ls -s | sort -n > mifichero & | % ls -s | sort -n > mifichero & |
| [2] 3405 | [2] 3405 |
| | |
| % mail bill | % mail bill |
| ^Z | ^Z |
| Stopped | Stopped |
| | |
| % jobs | % jobs |
| [1] - Running du > uso_de_disco | [1] - Running du > uso_de_disco |
| [2] Running ls -s | sort -n > mifichero | [2] Running ls -s | sort -n > mifichero |
| [3] + Stopped mail bill | [3] + Stopped mail bill |
| % fg %ls | |
| 15 -s | sort -n > mifichero | % fg |
| | |
| | % ls |
| | ls -s | sort -n > mifichero |
| % more mifichero | % more mifichero |
| </code> | </code> |
| |
| El comando //fg// ejecuta un trabajo suspendido o en segundo plano en el primer plano. Se usa para reiniciar un trabajo previamente suspendido, o cambiar un trabajo suspendido para que corra en el primer plano (permitiendo señales o entrada desde la terminal). En el caso anterior usamos //fg// para cambiar el trabajo //ls// desde el segundo plano al primer plano, desde que queríamos esperar a que terminara antes de mirar su fichero de salida. El comando //bg// corre un trabajo suspendido en el segundo plano. Usualmente se utiliza luego de detener el trabajo actual en ejecución en el primer plano con la señal STOP. La combinación de la señal STOP y el comando //bg// cambian el trabajo en primer plano a un trabajo en segundo plano. El comando //stop// suspende un trabajo en segundo plano. | El comando //fg// pasa un trabajo suspendido o en segundo plano a ejecución en primer plano. Se utiliza para reiniciar un trabajo previamente suspendido, o cambiar un trabajo suspendido para que corra en el primer plano (permitiendo el arribo de señales o entrada desde el terminal). En el caso anterior, se utilizó //fg// para pasar el trabajo //ls// desde el segundo plano al primer plano pues se deseaba aguardar su finalización antes de estudiar su fichero de salida. El comando //bg// reinicia ejecución de un trabajo suspendido en el segundo plano. Usualmente se utiliza tras suspender con la señal STOP el actual trabajo en ejecución en primer plano (combinar la señal STOP con el comando //bg// conmuta un trabajo de ejecución en primer plano a un trabajo en ejecución en segundo plano). El comando //stop// suspende un trabajo en segundo plano. |
| |
| El comando //kill// termina inmediatamente un trabajo en segundo plano o trabajo suspendido. Además de los trabajos, puede recibir como argumento números de procesos, tal como son presentados por //ps//. Por tanto, en el ejemplo anterior, al correr el comando //du// podría haber sido terminado por el comando | El comando //kill// ''%nro_de_cola'' extermina inmediatamente un trabajo en segundo plano o trabajo suspendido. Además de los trabajos, puede recibir como argumento números de procesos, tal como son presentados por //ps//. Por tanto, en el ejemplo anterior, al correr el comando //du// podría haber sido terminado por el comando |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| El comando //notify// (no es la variable ''notify'' mencionada anteriormente) indica que la terminación de un trabajo específico deberá ser informada inmediatamente al momento de su finalización, en lugar de aguardar el siguiente prompt. | El comando //notify// (no es la variable ''notify'' mencionada anteriormente) indica que debe informar inmediatamente el cumplimiento y finalización de un trabajo específico inmediatamente (en lugar de aguardar el siguiente prompt). |
| |
| Si un trabajo que corre en segundo plano intenta leer entrada del terminal, será automáticamente detenido. Cuando tal trabajo sea luego ejecutado en primer plano, se le podrá dar entrada al trabajo. Si lo desea, puede nuevamente enviar el trabajo al segundo plano hasta que éste solicite entrada nuevamente. Esto se ilustra en la secuencia siguiente, donde el comando ''s'' en el editor de texto puede llevar un tiempo largo. | Si un trabajo en ejecución en segundo plano intenta leer entrada del terminal, resulta detenido automáticamente. Posteriormente, al pasar dicho trabajo a primer plano, podrá recibir entrada. Si se lo desea, es posible enviar nuevamente el trabajo al segundo plano hasta que éste solicite nuevamente entrada. Dicho procedimiento se ilustra en la siguiente secuencia de sesión, donde el comando ''s'' del editor de texto puede requerir un tiempo para cumplir. |
| |
| |
| ^Z | ^Z |
| Stopped | Stopped |
| | |
| % bg | % bg |
| [1] ed ficherogigante & | [1] ed ficherogigante & |
| | |
| % | % |
| ... algunos comandos en segundo plano | ... algunos comandos en segundo plano |
| [1] Stopped (tty input) ed archivazo | [1] Stopped (tty input) ed ficherogigante |
| % fg | % fg |
| ed ficherogigante | ed ficherogigante |
| </code> | </code> |
| |
| De manera que tras indicar el comando ''s'', el trabajo //ed// fue detenido con **^Z** y luego puesto en segundo plano usando //bg//. Algún tiempo después el comando ''s'' terminó, //ed// intentó leer otro comando y fue detenido pues los trabajos en segundo plano no pueden leer desde el terminal. El comando //fg// retorno el trabajo //ed// al primer plano, donde una vez mas pudo aceptar comandos desde el terminal. | Por tanto, tras indicar el comando ''s'', el trabajo //ed// fue detenido con **^Z** y luego pasado al segundo plano usando //bg//. Cierto tiempo después el comando ''s'' finalizó, //ed// intentó leer otro comando y resultó detenido pues los trabajos en segundo plano no pueden leer desde el terminal. El comando //fg// devolvió al primer plano el trabajo //ed//, donde una vez más pudo aceptar comandos desde el terminal. |
| |
| El comando | El comando |
| </code> | </code> |
| |
| provoca que todos los trabajos en segundo plano en su terminal se detengan cuando están por escribir salida al terminal. Se impedirá de esta manera que los mensajes de los trabajos en segundo plano interrumpan la salida de los trabajos en primer plano, y le permite tener un trabajo corriendo en segundo plano sin perder la salida de terminal. También puede utilizarse con programas interactivos que a menudo tienen períodos largos sin interacción. Por tanto, cada vez que una salida solicita más entrada del terminal, se detendrá antes de presentar el prompt de solicitud. Puede entonces correr en primer plano usando //fg// para proveer tal entrada, y si es necesario detenido y vuelto al segundo plano. Puede resultar útil insertar este comando //stty// en su fichero ''.login'' si es que no desea tener salida de los trabajos en segundo plano que le interrumpan su trabajo. También puede reducir la necesidad de redirigir la salida de los trabajos en segundo plano, y si la salida no es muy grande: | detiene todos los trabajos en segundo plano que intenten escribir salida en el terminal. De esta manera se impide que los mensajes de los trabajos en segundo plano interrumpan la salida de los trabajos en primer plano, y permiten correr un trabajo en segundo plano sin perder la salida de terminal. También puede utilizarse con programas interactivos que presentan a menudo períodos largos sin interacción. Por tanto, se detendrá cada vez que una salida solicite mayor entrada del terminal, antes de presentar el prompt de solicitud. Podrá entonces correrlo en primer plano por medio //fg// a fin de proveer tal entrada, y si es necesario detenerlo y pasarlo al segundo plano. Si no desea tener salida de trabajos en segundo plano que interrumpan su trabajo, podrá encontrar útil insertar este comando //stty// en su fichero ''.login''. También puede reducir la necesidad de redirigir la salida de los trabajos en segundo plano, y si la salida no es muy grande: |
| |
| |
| [1] 10387 | [1] 10387 |
| |
| % ed text | % ed texto |
| ... algún tiempo después | ... algún tiempo después |
| q | q |
| wc ficherogigante | wc ficherogigante |
| 13371 30123 302577 | 13371 30123 302577 |
| | |
| % stty - tostop | % stty - tostop |
| </code> | </code> |
| |
| Por lo tanto, tras algún tiempo de ejecutar el comando //wc// (que cuenta líneas, palabras y caracteres de un fichero), tenemos una línea de salida. Cuando intentamos escribir esto al terminal, se detuvo. Al reiniciarlo en el primer plano, nos permitido escribir en el terminal exactamente cuando estábamos listos para observar esta salida. Cuando no estén en primer plano, aquellos programas que intentan cambiar el modo del terminal también se bloquearán, ya sea que //tostop// esté establecido o no (ya que sería muy inconveniente que un programa en segundo plano quiera cambiar el estado del terminal). | En el ejemplo anterior, se ejecutó el comando //wc// (que resulta en una salida de sólo una línea que cuenta líneas, palabras y caracteres de un fichero). Como este requeriría aguardar un cierto tiempo, se detuvo su salida antes que intentara imprimir en el terminal, y nos pusimos a editar el fichero ''texto'' para aprovechar el tiempo. Luego, se ha permitido que //wc// - con su trabajo cumplido - imprima su línea en el terminal, exactamente en el momento en que estábamos listos para observar la salida. Aquellos programas que intentan cambiar el modo del terminal también se bloquearán toda vez que no se encuentren en primer plano (ya sea que //tostop// esté establecido o no, ya que sería muy inconveniente que un programa en segundo plano quiera cambiar el estado del terminal). |
| |
| Como los comandos de trabajos sólo presentan trabajos iniciados en la shell de ejecución actual, no saben nada sobre los trabajos en segundo plano iniciados en otras sesiones de login, o dentro de los ficheros de la shell. En este caso puede usarse //ps// para descubrir los trabajos en segundo plano no iniciados durante la instancia actual de shell. | Como los comandos de trabajos sólo presentan aquellos trabajos __iniciados en la shell de ejecución actual__, desconocen de los trabajos en segundo plano iniciados en otras sesiones de login, o aquellos trabajos ocurridos dentro de los ficheros de la shell. En este caso puede usarse //ps// para descubrir los trabajos en segundo plano no iniciados durante la instancia actual de shell. |
| |
| ==== Directorios de Trabajo ==== | ==== Directorios de Trabajo ==== |
| |
| | Como se mencionó en [[#nombres de ficheros|sección 1.6]], la shell siempre se encuentra activa en un //directorio de trabajo// particular. El comando de "cambio de directorio" //chdir// (también puede usarse su abreviatura //cd//) modifica el directorio de trabajo de la shell - esto es, cambia el directorio en el cual usted se encuentra actualmente. |
| | |
| | Es útil crear un directorio para cada proyecto en el que desea trabajar, y disponer en él todos los ficheros relacionados a dicho proyecto. El comando "crear directorio" //mkdir// genera un directorio nuevo. El comando //pwd// ("imprimir directorio de trabajo") informa la ruta absoluta de directorio del directorio de trabajo de la shell - esto es, el directorio en el cual se encuentra actualmente. Por lo tanto, en el siguiente ejemplo |
| | |
| | <code bash> |
| | %pwd |
| | /usr/bill |
| | |
| | % mkdir periodico |
| | |
| | % chdir periodico |
| | |
| | %pwd |
| | /usr/bill/periodico |
| | |
| | % |
| | </code> |
| | |
| | el usuario ha creado y se ha posicionado en el directorio ''periodico'', donde - por ejemplo - podría colocar un grupo de ficheros relacionados. Siempre podrá volver a su directorio ''home'' de inicio de sesión - sin importar donde se ha movido en la jerarquía de directorios - simplemente ingresando |
| | |
| | <code bash> |
| | cd |
| | </code> |
| | |
| | sin mas argumentos. El nombre ''..'' siempre significa "el directorio por encima de la jerarquía del directorio actual", por lo tanto |
| | |
| | <code bash> |
| | cd .. |
| | </code> |
| | |
| | Cambia el directorio de trabajo de la shell al directorio por encima del actual. El nombre ''.'' puede ser usado en cualquier //nombre de ruta//. Por lo tanto |
| | |
| | <code bash> |
| | cd ../programas |
| | </code> |
| | |
| | significa cambiar al directorio ''programas'' contenido en el directorio por encima del directorio actual. Si tiene varios directorios para diferentes proyectos - por debajo, por tomar de ejemplo, de su directorio ''home'' - esta notación abreviada le permitirá cambiar rápidamente entre ellos. |
| | |
| | La shell siempre recuerda el nombre de ruta de directorio de trabajo actual a través de suvariable ''cwd''. La shell también puede ser requerida de recordar el directorio previo, al cambiar a un nuevo directorio de trabajo. Si en lugar del comando //cd// se utiliza el comando "empujar directorio" //pushd//, la shell guardará el nombre del directorio de trabajo actual en un listado de //pila directorios de uso previo// al cambio de directorio actual. Podrá consultar dicho listado en cualquier momento ingresando el comando "directorios", //dirs//. |
| | |
| | |
| | <code bash> |
| | % pushd periodico/referencias |
| | -/pediodico/referencias - |
| | |
| | % pushd /usr/lib/tmac |
| | /usr/lib/tmac ~/periodico/referencias ~ |
| | |
| | % dirs |
| | /usr/lib/tmac ~/periodico/referencias ~ |
| | |
| | % popd |
| | ~/periodicos/referencias ~ |
| | |
| | %.popd |
| | % |
| | </code> |
| | |
| | El listado de la pila de directorios de uso previo resultará impreso en una línea horizontal, que se lee de izquierda a derecha, con una abreviatura de su directorio ''home'' (en este caso ''/usr/bill'') en forma de tilde (''~''). La pila de directorio se imprime toda vez que hay mas de una entrada en ella, y se ve alterada. También es impresa por un comando //dirs//. Generalmente //dirs// resulta más rápido e informativo que //pwd// ya que junto al directorio de trabajo actual, muestra como cualquier otro directorio registrado en la pila de directorios de uso previo. |
| | |
| | El comando //pushd// sin argumentos alterna el directorio actual, con el primer directorio en la pila de directorios de uso previo. El comando "traer directorio" //popd// sin argumento lo devuelve al directorio donde se encontraba con anterioridad al actual, descartando el directorio de trabajo previo de la pila de directorios. Si ingresa ''popd'' varias veces en serie, retrocederá entre los directorios que ha estado navegando (caminando hacia atrás) por el comando //pushd//. Existen otras opciones a //pushd// y //popd// para manipular los contenidos de la pila de directorios de uso previo, y cambiar a directorios que no se encuentran en la parte superior de la pila; para mas detalles consulte las manpages de Csh. |
| | |
| | Como la shell recuerda el directorio de trabajo en el cual ha comenzado cada trabajo, le advertirá de manera práctica cuando podría confundirse al reiniciar un trabajo en el primer plano que tiene un directorio de trabajo diferentes que el directorio de trabajo actual de la shell. Por lo tanto, al iniciar un trabajo en segundo plano, esta cambiará entonces el directorio de trabajo de la shell y luego conmutará a ejecución en primer plano el trabajo que se encontraba en segundo plano. La shell advertirá entonces que el directorio de trabajo del trabajo en actual ejecución en primer plano es diferente al tabulado en la tabla de trabajos de la C shell. |
| | |
| | <code bash> |
| | % dirs -l |
| | /mnt/bill |
| | |
| | % cd miproyecto |
| | |
| | % dirs |
| | ~/miproyecto |
| | |
| | % ed prog.c |
| | 1143 |
| | ^Z |
| | Stopped |
| | |
| | % cd .. |
| | |
| | % ls |
| | miproyecto |
| | fichero_texto |
| | |
| | % fg |
| | ed prog.c (wd: ~/miproyecto) |
| | </code> |
| | |
| | De esta forma la shell le advierte con ''wd: directorio'' en el momento que exista discrepancia por un cambio de directorio de trabajo, incluso aunque no se haya utilizado un comando //cd//. En el ejemplo anterior, el trabajo suspendido ''ed'' aún se encontraba en ''/mnt/bill/proyectos'', incluso aunque la shell se había cambiado a ''mnt/bill''. Una advertencia similar se ofrece cuando tal trabajo en primer plano finaliza o resulta suspendido (usando la señal STOP). Retornar nuevamente a la shell implica cambiar de directorio de trabajo nuevamente, indicado por ''wd now: directorio''. |
| | |
| | <code bash> |
| | % fg |
| | ed prog.c (wd: -/miproyecto) |
| | ... tras alguna edición |
| | q |
| | (wd now: ~) |
| | |
| | % |
| | </code> |
| | |
| | Estos mensajes resultan algo confusos si usted usa programas que cambian sus propios directorios de trabajo, pues C shell sólo recuerda desde cuál directorio un trabajo se ha iniciado, y asume su permanencia allí. La opción ''-l'' de //jobs// presentará el directorio de trabajo de los trabajos suspendidos o en segundo plano cuando discrepan del directorio de trabajo actual de la shell. |
| | |
| | > Presentar un prompt con el directorio actual de trabajo en la shell - como es usanza en los BSD modernos - solventa en gran medida estas problemáticas. En los 80s se evitaba pues el comando cwd requería un par de segundos en los lentos discos de la VAX, y enlentecía todo el sistema multiusuario [N.d.T.]. |
| |
| ==== Comandos Incorporados útiles ==== | ==== Comandos Incorporados útiles ==== |
| El comando //echo// imprime sus argumentos. A menudo es usado en guiones de shell o como un comando interactivo para veer qué expansiones de nombre de fichero producirá. | El comando //echo// imprime sus argumentos. A menudo es usado en guiones de shell o como un comando interactivo para veer qué expansiones de nombre de fichero producirá. |
| |
| El comando //history// mostrará los contenidos de su //listado de historial//. Los números dados a los eventos del historial pueden usarse para referencia eventos anteriores que son difíciles de referenciar utilizando los mecanismos contextuales introducidos anteriormente. Existe también una variable de shell denominada ''prompt''. | El comando //history// mostrará los contenidos de su //listado de historial//. Los números dados a los eventos del historial pueden usarse para referencia eventos anteriores que son difíciles de referenciar utilizando los mecanismos contextuales introducidos anteriormente. Existe también una variable de shell denominada ''prompt''. |
| |
| Al colocar un caracter ''!'' en su valor, la shell substituirá el número del comando actual con el del //listado de historial//. Puede usar este número para referir a este comando en una subsitución de historia. Por lo tanto, podría | Al colocar un caracter ''!'' en su valor, la shell substituirá el número del comando actual con el del //listado de historial//. Puede usar este número para referir a este comando en una substitución de historia. Por lo tanto, podría |
| |
| <code bash> | <code bash> |
| El comando //rehash// provoca que la shell recompute una tabla de localización de comandos. Esto es necesario si se agregó un comando a un directorio en la ruta de búsqueda ''path'' de la shell actual, y se desea que la shell proceda a encontrarla, de otro modo el algoritmo de detección podría decirle a la shell que el comando no se encontraba en los comandos indicados cuando la tabla de hash fue computada originalmente. | El comando //rehash// provoca que la shell recompute una tabla de localización de comandos. Esto es necesario si se agregó un comando a un directorio en la ruta de búsqueda ''path'' de la shell actual, y se desea que la shell proceda a encontrarla, de otro modo el algoritmo de detección podría decirle a la shell que el comando no se encontraba en los comandos indicados cuando la tabla de hash fue computada originalmente. |
| |
| El comando //repeat// puede utillizarse para repetir un comando varias veces. Por tanto, para realizar cinco copias del fichero ''uno'' hasta el fichero ''cinco'', podría hacer | El comando //repeat// puede utilizarse para repetir un comando varias veces. Por tanto, para realizar cinco copias del fichero ''uno'' hasta el fichero ''cinco'', podría hacer |
| |
| <code bash> | <code bash> |
| |
| De la misma manera, al realizar preparaciones documentales puede crearse un ''makefile'' para definir cómo crear las versiones diferentes del documento y cuáles opciones de rooff o troff son adecuadas para su utilización. | De la misma manera, al realizar preparaciones documentales puede crearse un ''makefile'' para definir cómo crear las versiones diferentes del documento y cuáles opciones de rooff o troff son adecuadas para su utilización. |
| | |
| ==== Invocación y variable argv ==== | ==== Invocación y variable argv ==== |
| |
| Puede intepretar un guion de C Shell diciendo | Puede interpretar un guion de C Shell diciendo |
| |
| <code bash> | <code bash> |
| |
| <code bash> | <code bash> |
| echo Sargv | echo $argv |
| </code> | </code> |
| |
| </code> | </code> |
| |
| Donde ''n'' es un entero que oficia de abreviación de | siendo ''n'' un entero que oficia de abreviación de |
| |
| <code bash> | <code bash> |
| |
| Otro punto importante es que nunca es un error dar un subrango en la forma de ''n-''; si hay menos de ''n'' componentes de una variable dada entonces no se substituye palabra alguna. Un rango en la forma ''m-n'' de la misma forma devolverá un vector vacío sin dar error, toda vez que ''m'' exceda el número de elementos de la variable dada, provisto que el suscripto ''n'' se encuentre dentro del rango. | Otro punto importante es que nunca es un error dar un subrango en la forma de ''n-''; si hay menos de ''n'' componentes de una variable dada entonces no se substituye palabra alguna. Un rango en la forma ''m-n'' de la misma forma devolverá un vector vacío sin dar error, toda vez que ''m'' exceda el número de elementos de la variable dada, provisto que el suscripto ''n'' se encuentre dentro del rango. |
| | |
| ==== Expresiones ==== | ==== Expresiones ==== |
| |
| |
| <code bash> | <code bash> |
| -? filename | -? nombre_fichero |
| </code> | </code> |
| |
| |
| <code bash> | <code bash> |
| % cat copyc | % cat copyc.sh |
| # | # |
| # Copyc copia los programas en la lista especificada | # Copyc.sh copia los programas en la lista especificada |
| # al directorio ~/respaldo si difieren de los ficheros | # al directorio ~/respaldo si difieren de los ficheros |
| # que ya están en ~/respaldo | # que ya están en ~/respaldo |
| # | # |
| set noglob | set noglob |
| foreach i (Sargv) | foreach i ($argv) |
| if ($i !* *.c) continue # no es un fichero .c de modo que no hace nada | if ($i !* *.c) continue # no es un fichero .c de modo que no hace nada |
| if (! -r ~/respaldo/Si:t) then | if (! -r ~/respaldo/Si:t) then |
| </code> | </code> |
| |
| Que si es una línea muy larga, puede ser escrita | La cual - si es una línea muy larga - puede escribirse |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Aquí anulamos la nueva línea por estética. El comando no debe involucrar un ''|'', ''&'' o '';'', y no debe ser otro comando de control. La segunda forma, requiere que la ''<nowiki>\</nowiki>'' final preceda inmedatamente al //fin-de-linea// (o sea, __no de debe dejarse espacio__). | Aquí anulamos la nueva línea por estética. El comando no debe involucrar un ''|'', ''&'' o '';'', y no debe ser otro comando de control. La segunda forma, requiere que la ''<nowiki>\</nowiki>'' final preceda inmediatamente al //fin-de-linea// (o sea, __no de debe dejarse espacio__). |
| |
| La declaración //if// más general anterior también admite la secuencia o pares ''else-if'' seguidos por un único ''else'' y un ''endif'', por ejemplo | La declaración //if// más general anterior también admite la secuencia o pares ''else-if'' seguidos por un único ''else'' y un ''endif'', por ejemplo |
| |
| <code bash> | <code bash> |
| if ( expresión ) tben comando endif # No funciona | if ( expresión ) then comando endif # No funciona |
| </code> | </code> |
| |
| ====Otras estructuras de control ==== | ====Otras estructuras de control ==== |
| |
| La C shell también tiene estructuras de control ''while'' y ''switch'' similares a las del lenguaje C. Estas guardan las formas | La C shell también cuenta con estructuras de control ''while'' y ''switch'' similares a las del lenguaje C. Estas guardan las formas |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| Para mayores detalles, consulte la sección del manual de csh. Los programadores de C deben notar que usamos ''breakslt'' para salir de un switch, ientras que break sale de un bucle //while// o //foreach//. Un error común de cometer en los giones de csh es usar los conmutadores ''break'' en lugar de ''breaksw''. | Para mayores detalles, consulte la sección del manual de csh. Los programadores de C deben notar que usamos ''breakslt'' para salir de un switch, mientras que break sale de un bucle //while// o //foreach//. Un error común de cometer en los guiones de csh es usar los conmutadores ''break'' en lugar de ''breaksw''. |
| |
| Finalmente, csh permite declaraciones ''goto'' con etiquetas que son similares alas de C. Ejemplo: | Finalmente, csh permite declaraciones ''goto'' con etiquetas que son similares alas de C. Ejemplo: |
| goto bucle | goto bucle |
| </code> | </code> |
| | |
| ==== Suplir entrada a comandos ==== | ==== Suplir entrada a comandos ==== |
| | |
| | Los comandos ejecutados desde guiones de shell reciben por defecto la entrada estándar de la shell que corre el guion. Esto es distinto a shells precias que corren en UNIX. Esto permite a los guiones de C shell de participar completamente en tuberías, pero obligan a realizar notación extra para los comandos que deben tomar datos en línea. |
| | |
| | Por lo tanto necesitamos una metanotación para proveer datos en línea a los comandos situados en guiones de C shell. Como ejemplo, considere este guion que corre el editor para borrar los caracteres iniciales en blanco desde las líneas en cada fichero argumento. |
| | |
| | <code bash> |
| | % cat deblanqueador.sh |
| | # deblanqueador.sh - Quita los caracteres en blanco al inicio de una línea |
| | foreach i ($argv) |
| | ed - Si << 'EOF' |
| | 1,$s/^[ ]*// |
| | w |
| | q |
| | 'EOF' |
| | end |
| | % |
| | </code> |
| | |
| | La notación ''<nowiki><< 'EOF'</nowiki>'' significa que la //entrada estándar// para el comando //ed// debe provenir del texto en el fichero de guion de shell en sí, hasta la siguiente linea, lo que literalmente consiste en "''<nowiki>'EOF'</nowiki>''". El hecho de que ''EOF'' se encuentre apostrofado ([[#citado|citado]]) provoca que la shell no sustituya variables en las líneas intervinientes. En general, si alguna parte de la palabra que sigue a ''<<'' - la cual la shell usa para terminar el texto a ser dado al comando - se cita, entonces se anula la substitución de tales substituciones. En este caso, como en nuestro guion de edición hemos utilizado la forma ''1,$'', debemos asegurar que este ''$'' no sufra sustitución como variable. Podríamos haberlo asegurado también por medio de preceder dicha ''$'' con un caracter de ''<nowiki>\</nowiki>''. Por ejemplo: |
| | |
| | <code bash> |
| | 1,\$s/^[ ]*// |
| | </code> |
| | |
| | sin embargo, citar el terminador ''<nowiki>'EOF'</nowiki>'' es una manera más confiable de lograr lo mismo. |
| |
| ==== Atrapando interrupciones ==== | ==== Atrapando interrupciones ==== |
| | |
| | Si nuestro guion de shell crea ficheros temporales, podríamos querer atrapar interrupciones del guion de shell de modo de poder limpiar dichos ficheros. Podremos entonces hacer |
| | |
| | <code bash> |
| | onintr label |
| | </code> |
| | |
| | donde ''etiqueta'' es una etiqueta en nuestro programa. Si la shell recibe una interrupción, hará un //goto ''etiqueta''// y podremos remover los ficheros temporales y luego hacer un comando ''exit'' (que está incorporado en la shell) para salir del guion de shell. Si deseamos salir con //status no cero//, podremos hacer |
| | |
| | <code bash> |
| | exit(1) |
| | </code> |
| | |
| | por ejemplo, para salir con status ''1''. |
| | |
| |
| ==== ¿Qué mas? ==== | ==== ¿Qué mas? ==== |
| | |
| | Existen otras funcionalidades de la shell útiles a quienes escriben procedimientos de shell. las opciones ''verbose'' y ''echo'' y sus respectivas opciones de línea de comandos relacionadas ''-l'' y ''-x'', pueden usarse para asistir en al rastreo de acciones de shell. La opción ''-n'' hace que la shell sólo lea comandos __sin ejecutarlos__, y en ocasiones puede resultar de suma utilidad. |
| | |
| | Es importante notar que csh no ejecuta guiones de shell que no comiencen con el caracter ''#'' - lo que significa que los guiones de C shell comienzan con un comentario. De forma similar, el ''/bin/sh'' de su sistema podría bien diferir del ''csh'' en la interpretacion de guiones de shell que comiencen con ''#''. |
| | |
| | Esto es lo que permite que tanto los guiones de shell y la C shell vivan en armonía. |
| | |
| | También existe otro mecanismo de citado que usa ''"'', que permiten que se ejecuten sólo algunos mecanismos de expansión que hemos discutido hasta el momento en la cadena citada, y sirve para hacer que esta cadena se convierta en una palabra única, como lo hace ''<nowiki>'</nowiki>''. |
| | |
| |
| ===== 4. Otras funcionalidades de la shell menos utilizadas ===== | ===== 4. Otras funcionalidades de la shell menos utilizadas ===== |
| |
| ==== Bucles en la terminal; variables como vectores ==== | ==== Bucles en la terminal; variables como vectores ==== |
| | |
| | En ocasiones es útil usar la estructura de control //foreach// en el terminal para asistir en la realización de iteraciones de comandos similares. Por ejemplo, en el sistema Cory UNIX en Cory Hall hubo en un momento tres shells en uso: ''/bin/sh'', ''/bin/nsh'', y ''/bin/csh''. Para contar la cantidad de personas que usaban cada shell, uno podría haber enviado los comandos |
| | |
| | |
| | |
| | <code bash> |
| | % grep -c csh$ /etc/passwd |
| | 27 |
| | |
| | % grep -c nsh$ /etc/passwd |
| | 128 |
| | |
| | % grep -c -v sh$ /etc/passwd |
| | 430 |
| | |
| | % |
| | </code> |
| | |
| | Ya que estos comandos son muy similares, podremos usar un //foreach// para simplificar. |
| | |
| | <code bash> |
| | % foreach i ('sh$' 'csh$' -v 'sh$') |
| | ? grep -c $i /etc/passwd |
| | ? end |
| | 27 |
| | 128 |
| | 430 |
| | |
| | % |
| | </code> |
| | |
| | Tenga aquí presente que al leer desde el cuerpo de un bucle, la shell le solicita entrada con un ''?''. Las variables son de utilidad en los bucles, pues puede asignarle listas de nombres de ficheros u otras palabras. Por ejemplo, podría hacer |
| | |
| | <code bash> |
| | % set a=('ls') |
| | |
| | % echo $a |
| | csh.n csh.rm |
| | |
| | % ls |
| | csh.n |
| | csh.rm |
| | |
| | % echo $#a |
| | 2 |
| | |
| | % |
| | </code> |
| | |
| | Aquí el comando //set// da a las variables de una lista ''a'' cuyo valor es todos los nombres de fichero del directorio actual. Podemos luego iterar sobre dichos nombres para realizar cualquier función que escojamos. |
| | |
| | La salida de un comando apostrofado entre caracteres ''<nowiki>'</nowiki>'' es convertida por la shell a una lista de palabras. También puede entrecomillar la cadena citada entre caracteres ''"'' para considerar cada línea __no vacía__ como un componente de variable (impidiendo que las líneas resulten divididas como palabras a lo largo de sus caracteres de espacio en blanco o tabuladores. Existe un modificador ''-x'' que puede ser utilizado luego para expandir cada componente de variable en otra variable, dividiéndola en palabras separadas a lo largo de sus caracteres de espacio en blanco o tabuladores. |
| | |
| | |
| | |
| | |
| |
| ==== Llaves {...} en expansión de argumentos ==== | ==== Llaves {...} en expansión de argumentos ==== |
| | |
| | Otra forma de expansión de nombre de fichero aludida anteriormente involucra el uso de caracteres de lave abierta ''{'' y llave cerrada ''}''. Dichos caracteres especifican que la cadena contenida entre llaves, separada por comas '','', debe ser sustituida consecutivamente en los caracteres contenidos entre llaves, y los resultados, expandidos de izquierda a derecha. Por lo tanto |
| | |
| | <code bash> |
| | A{cad1,cad2... stm}B |
| | </code> |
| | |
| | se expande a |
| | |
| | Acad1B Acad2B... AstmB |
| | |
| | Esta expansión ocurre antes que otras expansiones de nombre de fichero, y puede aplicarse recursivamente (si se encuentra anidada). Los resultados de cada cadena expandida se ordenan por separado, preservándose el orden de izquierda a derecha. No se requiere que existan los nombres de fichero resultante si no se emplean mecanismos de expansión ulteriores. Esto significa que este mecanismo puede utilizarse para generar argumentos que no sean nombres de fichero, pero que tengan partes en común. |
| | |
| | Un uso típico de esto sería |
| | |
| | <code bash> |
| | mkdir ~/{hdrs,retrofit,csh} |
| | </code> |
| | |
| | que crea los subdirectorios ''hdrs'', ''retrofit'' y ''csh'' en su directorio ''home''. Este mecanismo es más útil cuando el prefijo común es más largo que el dado en este ejemplo, por ejemplo: |
| | |
| | <code bash> |
| | chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}} |
| | </code> |
| | |
| | ==== Sustitución de Comandos ==== |
| | |
| | Un comando encerrado en caracteres '''' resulta reemplazado justo antes de que se expandan los nombres de cihero, por la salida de dicho comando. Por lo tanto, es posible hacer |
| | |
| | <code bash> |
| | set pwd='pwd' |
| | </code> |
| | |
| | para salvar el directorio actual en la variable ''pwd'', o bien hacer |
| | |
| | <code bash> |
| | ex 'grep -l TRACE *.c' |
| | </code> |
| | |
| | para ejecutar el editor ex proveyéndolo de aquellos ficheros cuyos nombres finalicen en ''.c'' y que contengan la cadena ''TRACE'' como argumento. |
| | |
| | |
| | > La expansión de comandos también ocurre en la entrada redirigida con ''<<''y dentro de citado entrecomillado con ''<nowiki>""</nowiki>''. Refiérase al manual de la shell para los detalles completos |
| | |
| |
| ==== Otros detalles no cubiertos==== | ==== Otros detalles no cubiertos==== |
| | |
| | En circunstancias particulares puede ser necesario conocer la naturaleza y orden exacto de las diferentes sustituciones desarrolladas por la shell. El significado exacto de ciertas combinaciones de citas es importante ocasionalmente. Estas se detallan al completo en su repsectiva sección del manual. La shell tiene una cantidad de opciones //flags// que se emplean mayoritariamente para escribir programas de UNIX, y depurar guiones de shell. Consulte la sección de manual de la shell para obtener un listado de dichas opciones. |
| |
| |
| | ''&'' | continúa ejecutando los siguientes comandos sin esperar completar la ejecución | | | ''&'' | continúa ejecutando los siguientes comandos sin esperar completar la ejecución | |
| |
| ===Metacaracteresa de nombre de fichero=== | ===Metacaracteres de nombre de fichero=== |
| |
| ^ Metacaracter de nombre de fichero ^ Acción ^ | ^ Metacaracter de nombre de fichero ^ Acción ^ |
| |
| ^ Metacaracter ^ Resultado ^ | ^ Metacaracter ^ Resultado ^ |
| | ''$'' | comineza garabateo de nombres de fichero; indica comentarios de shell | '''' | | | | ''$'' | comienza garabateo de nombres de fichero; indica comentarios de shell | '''' | | |
| | ''!'' | opción de refijado (flag) argumentos a comandos. | | | ''!'' | opción de refijado (flag) argumentos a comandos. | |
| | prefija especificaciones de nombre de trabajo | | | prefija especificaciones de nombre de trabajo | |
| |
| ====== Glosario ====== | ====== Glosario ====== |
| |
