| Ambos lados, revisión anteriorRevisión previaPróxima revisión | Revisión previa |
| tutorial_de_csh [2024/07/17 17:31] – peron | tutorial_de_csh [2026/04/21 16:09] (actual) – editor externo 127.0.0.1 |
|---|
| 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. | 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 ===== |
| >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**. | >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**. |
| |
| A consecuencia, el programa de correo hizo eco de los caracteres "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. | 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. |
| |
| 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 ''% ''. | 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 ''% ''. |
| </code> | </code> |
| |
| pues el comando //cat// habría ofrecido el texto a través del entubado a la entrada estándar del comando //mail//. Una vez el comando //cat// hubiese cunmplido en presentar el fichero, 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. | 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 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. | 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. |
| |
| 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 informará entonces cuál es el comando al que continuará ejecución, 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 acaba de copiar un fichero enorme a mi directorio de usuario. | Alguien acaba de copiar un fichero enorme a mi directorio de usuario. |
| El fichero se denomina | El fichero se denomina |
| % 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. |
| | |
| | ===Comandos de control de trabajos=== |
| |
| 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. | ^ 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 | |
| |
| 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. | 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 está en un //directorio de trabajo// particular. El comando de "cambio de directorio" //chdir// (también puede usarse su abreviatura //cd//) cambia el directorio de trabajo de la shell - esto es, cambia el directorio en el cual usted se encuentra actualmente. | 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 hacer un directorio para cada proyecto en el que desea trabajar, y poner todos los ficheros relacionados a ese protecto en dicho directorio. El comando "hacer directorio" //mkdir// crea un nuevo directorio. El comando //pwd// ("imprimir directorio de trabajo") informa la ruta de directorio absoluta del directorio de trabajo de la shell - esto es, el directorio en el cual se encuentra actualmente. Por lo tanto, en el siguiente ejemplo | 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> | <code bash> |
| %pwd | %pwd |
| /usr/bill | /usr/bill |
| | |
| % mkdir periodico | % mkdir periodico |
| | |
| % chdir periodico | % chdir periodico |
| | |
| %pwd | %pwd |
| /usr/bill/periodico | /usr/bill/periodico |
| | |
| % | % |
| </code> | </code> |
| |
| el usuario ha creado y se ha posicionado en el directorio ''periodico'', donde, por ejemplo, podría colocar un grupo de ficheros relacionados. Sin importar donde se ha movido en la jerarquía de directorios, siempre podrá volver a su directorio ''home'' de inicio de sesión, simplemente ingresando | 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> | <code bash> |
| </code> | </code> |
| |
| sin mas argumentos. El nombre ''...'' siempre significa "el directorio por encima de la jerarquía del actual", por lo tanto | sin mas argumentos. El nombre ''..'' siempre significa "el directorio por encima de la jerarquía del directorio actual", por lo tanto |
| |
| <code bash> | <code bash> |
| </code> | </code> |
| |
| significa cambiar al directorio ''programas'' contenido en el directorio por encima del directorio actual. Si tiene varios directorios para diferentes proyectos por debajo, digamos, de su directorio ''home'', esta notación abreviada le permitirá cambiar rápidamente entre ellos. | 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 del directorio de trabajo actual por medio de la variable ''cwd''. La shell también puede ser requerida de recordar el directorio previo, al cambiar a un nuevo directorio de trabajo. Si el comando "empujar directorio" //pushd// se usa en lugar del comando //cd//, la shell guardará el nombre del directorio de trabajo actual en una pila de directorios antes de cambiar al nuevo. Podrá ver esta lista en cualquier momento ingresando el comando "directorios", //dirs//. | 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//. |
| |
| |
| % pushd periodico/referencias | % pushd periodico/referencias |
| -/pediodico/referencias - | -/pediodico/referencias - |
| | |
| % pushd /usr/lib/tmac | % pushd /usr/lib/tmac |
| /usr/lib/tmac -/periodico/referencias - | /usr/lib/tmac ~/periodico/referencias ~ |
| % dirs | % dirs |
| /usr/lib/tmac -/periodico/referencias - | /usr/lib/tmac ~/periodico/referencias ~ |
| % popd | % popd |
| -/periodicos/referencias - | ~/periodicos/referencias ~ |
| %.popd | %.popd |
| % | % |
| </code> | </code> |
| |
| La lista se imprime en una línea horizontal, que se lee de izquierda a derecha, con un tilde (''~'') como abreviatura de su directorio ''home'', en este caso ''/usr/bill''. La pila de directorio se imprime toda vez que hay mas de una entrada en ella, y se vea alterada. También es impresa por un comando //dirs//. Generalmente Dirs es más rápido e informativo que //pwd// ya que muestra el directorio de trabajo actual, así como cualquier otro directorio registrado en la pila de directorios | 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 lista. 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 (descartándolo). Si ingresa ''popd'' varias veces en una serie, lo hará retroceder a través de los directorios que ha estado navegando (cambiando hacia) por el comando //pushd//. Existen otras opciones a //pushd// y //popd// para manipular los contenidos de la pila de directorios y cambiar a directorios que no se encue3ntran del superior de la pila; para mas detalles consulte las manpages de Csh. | 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, prácticamente le advierte 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, si inicia un trabajo en segundo plano, entonces cambia el directorio de trabajo de la shell y luego causar que el trabajo en segundo plano corra en el primer plano, la shell le advierte que el directorio de trabajo del trabajo corriendo actualmente en primer plano es diferente que el que indica la shell. | 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> | <code bash> |
| % dirs -I | % dirs -l |
| /mnt/bill | /mnt/bill |
| | |
| % cd miproyecto | % cd miproyecto |
| | |
| % dirs | % dirs |
| -/miproyecto | ~/miproyecto |
| % ed prog.c | % ed prog.c |
| 1143 | 1143 |
| ^Z | ^Z |
| Stopped | Stopped |
| | |
| % cd .. | % cd .. |
| %ls | |
| | % ls |
| miproyecto | miproyecto |
| fichero_texto | fichero_texto |
| | |
| % fg | % fg |
| ed prog.c (wd: -/miproyecto) | ed prog.c (wd: ~/miproyecto) |
| </code> | </code> |
| |
| De esta forma la shell le advierte cuando hay un cambio implicado de directorio de trabajo, inlcuso aunque no se envió un comando //cd//. En el ejemplo anterior, el trabajo ''ed'' aún se encontraba en | 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''. |
| ''/mnt/bill/proyectos'', incluso aunque la shell se había cambiado a ''mnt/bill''. Una advertencia similar se da cuando tal trabajo de primer plano termina o es suspendido (usando la señal STOP), desde el retorno a la shell nuevamente implica un cambio de directorio de trabajos. | |
| |
| <code bash> | <code bash> |
| q | q |
| (wd now: ~) | (wd now: ~) |
| | |
| % | % |
| </code> | </code> |
| |
| Estos mensajes son algo confusos si usted usa programas que cambian sus propios directorios de trabajo. Como la shell sólo recuerda desde cuál directorio un trabajo es iniciado, y asume que permanecerá allí. La opción ''-l'' de //jobs// presentará el directorio de trabajo de trabajos suspendidos o en segundo plano cuando es diferente desde el directorio de trabajo actual de la shell. | 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 ghell 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 comandoos que deben tomar datos en línea. | 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. | 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. |
| % cat deblanqueador.sh | % cat deblanqueador.sh |
| # deblanqueador.sh - Quita los caracteres en blanco al inicio de una línea | # deblanqueador.sh - Quita los caracteres en blanco al inicio de una línea |
| foreach i (Sargv) | foreach i ($argv) |
| ed - Si << 'EOF' | ed - Si << 'EOF' |
| 1,$s/^[ ]*// | 1,$s/^[ ]*// |
| </code> | </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 subsitució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: | 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> | <code bash> |
| |
| sin embargo, citar el terminador ''<nowiki>'EOF'</nowiki>'' es una manera más confiable de lograr lo mismo. | sin embargo, citar el terminador ''<nowiki>'EOF'</nowiki>'' es una manera más confiable de lograr lo mismo. |
| | |
| ==== Atrapando interrupciones ==== | ==== Atrapando interrupciones ==== |
| |
| |
| ==== ¿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 ====== |
| |
