En los sistemas operativos tipo Unix, sh es el nombre del comando del shell Bourne, el intérprete de lenguaje de comandos estándar de Unix y muchos sistemas operativos tipo Unix, incluido Linux.
Sintaxis
sh [-acefhikmnprstuvx] [arg] ...
Descripción e historia
sh es un intérprete de lenguaje de comandos que ejecuta comandos leídos desde una cadena de línea de comandos, la entrada estándar o un archivo especificado.
Stephen Bourne desarrolló el shell Bourne en 1977 en los Laboratorios Bell de AT&T en 1977. Era el shell predeterminado de Unix Versión 7. La mayoría de los sistemas similares a Unix contienen el archivo / bin / sh que es el shell Bourne o un enlace simbólico. (o enlace duro) a un shell compatible.
El Bourne Shell se desarrolló originalmente como un reemplazo para el shell Thompson, cuyo archivo ejecutable también se llamaba sh. Aunque se utiliza como un intérprete de comandos interactivo, su propósito original era funcionar como un lenguaje de script.
Las características de Bourne Shell incluyen:
- Las secuencias de comandos se pueden invocar como comandos utilizando su nombre de archivo.
- El caparazón puede usarse de forma interactiva o no interactiva.
- Los comandos pueden ejecutarse sincrónicamente o asincrónicamente.
- El shell admite la redirección de entrada y salida, y las tuberías.
- Un conjunto robusto de comandos integrados.
- Construcciones de control de flujo, facilidades de cotización y funciones.
- Variables sin tipo.
- Ambas variables locales y globales.
- Los scripts se pueden interpretar, es decir, no tienen que compilarse para ejecutarse.
- Sustitución de comandos usando comillas inversas, por ejemplo: `comando`
- "Aquí documentos": el uso de << para incrustar un bloque de texto de entrada dentro de un script.
- bucles "for / do / done", en particular el uso de $ * para recorrer los argumentos.
- Mecanismo de selección "case / in / esac", destinado principalmente a ayudar al análisis de argumentos.
- Soporte para variables de entorno utilizando parámetros de palabras clave y variables exportables.
- Disposiciones fuertes para controlar la entrada y salida y en sus facilidades de coincidencia de expresiones.
El uso de Bourne Shell ha sido reemplazado en gran medida por Bourne-Again Shell (bash), que admite funciones interactivas más fáciles de usar, como el control de trabajos y un historial de comandos.
Comandos
Un comando simple es una secuencia de palabras no en blanco separadas por espacios en blanco (un espacio en blanco es una pestaña o un espacio). La primera palabra especifica el nombre del comando que se ejecutará. Excepto como se especifica a continuación, las palabras restantes se pasan como argumentos al comando invocado. El nombre del comando se pasa como argumento 0 (ver exec). El valor de un comando simple es su estado de salida si termina normalmente o más de 200 si termina anormalmente (consulte nuestra descripción general de las señales del sistema operativo para obtener una lista de valores de estado).
Una tubería es una secuencia de uno o más comandos separados por una barra vertical ("|"). La salida estándar de cada comando pero la última está conectada por una tubería a la entrada estándar del siguiente comando. Cada comando se ejecuta como un proceso separado; el shell espera a que termine el último comando. El valor de una tubería es el estado de salida de su último comando.
Una lista es una secuencia de una o más tuberías separadas por ";", "&", "&&" o "||" y opcionalmente terminado por ";" o "&". ";" y "&" tienen la misma precedencia que es menor que la de "&&" y "||", "&&" y "||" También tienen igual precedencia. Un punto y coma provoca la ejecución secuencial; un ampersand hace que la tubería anterior se ejecute sin esperar a que termine. El símbolo "&&" ("||") hace que la siguiente lista se ejecute solo si la canalización anterior devuelve un valor cero (no cero). Las nuevas líneas pueden aparecer en una lista, en lugar de punto y coma, para delimitar comandos.
Un "#" al comienzo de una palabra comienza un comentario y hace que se ignore el resto de la línea.
Un comando es un comando simple o uno de los siguientes. El valor devuelto por un comando es el del último comando simple ejecutado en el comando:
| para nombre [en palabra …] hacer lista | En bucle. Cada vez que se ejecuta un comando for, el nombre se establece en la siguiente palabra en la lista de palabras for. Si se omite 'en palabra …', se asume 'en "[correo electrónico protegido]"'. La ejecución termina cuando no hay más palabras en la lista. |
| palabra del caso en [patrón [| patrón] …) lista ;;] … esac | Un comando de caso ejecuta la lista asociada con el primer patrón que coincide con la palabra. La forma de los patrones es la misma que la utilizada para la generación del nombre de archivo. |
| si lista entonces lista [lista elif luego lista] … [más lista] fi | Se ejecuta la lista siguiente if, y si devuelve cero, se ejecuta la lista siguiente. De lo contrario, se ejecuta la lista que sigue a elif ("else if") y si su valor es cero, se ejecuta la siguiente lista. Si no se ejecuta la lista else. |
| mientras lista [hacer lista] hecho | Un comando while ejecuta repetidamente la lista while, y si su valor es cero, ejecuta la lista do; de lo contrario el ciclo termina. El valor devuelto por un comando while es el del último comando ejecutado en la lista do. hasta que pueda usarse en lugar de while para negar la prueba de terminación de bucle. |
| (lista) | Ejecutar lista en una subshell. |
| {lista; } | La lista se ejecuta. |
| lista de nombres; } | Define el nombre de la función de shell. Cada vez que el nombre se reconoce como un comando, se ejecuta la lista, con los parámetros posicionales $ 1, $ 2 … establecidos en los argumentos del comando. Después de que la función regresa, los parámetros posicionales anteriores se restauran. |
Las siguientes palabras solo se reconocen como la primera palabra de un comando, y cuando no se incluyen entre comillas:
- if
- entonces
- más
- elif
- fi
- caso
- in
- esac
- idea
- mientras
- hasta
- do
- hecho
- {
- }
Sustitución de comando
La salida estándar de un comando encerrado en un par de acentos graves («) puede usarse como parte o la totalidad de una palabra; se eliminan las nuevas líneas finales. Por ejemplo, si el script ejecutable echotest.sh contenía el comando:
echo "El nombre de este script es` basename $ 0` ".
Luego, ejecutar el script mostrará la salida combinada de echo y basename:
El nombre de este script es echotest.sh.
Sustitución de parámetros
El carácter $ se usa para introducir parámetros sustituibles. A los parámetros posicionales se les pueden asignar valores por conjunto. Las variables se pueden establecer en la forma "nombre = valor [nombre = valor] …".
| $ {parámetro} | Un parámetro es una secuencia de letras, dígitos o guiones bajos (un nombre), un dígito o cualquiera de los caracteres * @ #? PS El valor, si lo hay, del parámetro se sustituye. Las llaves solo son necesarias cuando el parámetro va seguido de una letra, dígito o guión bajo que no debe interpretarse como parte de su nombre. Si el parámetro es un dígito, entonces es un parámetro posicional. Si el parámetro es * o @, todos los parámetros posicionales, comenzando con $ 1, se sustituyen separados por espacios. $ 0 se establece desde el argumento cero cuando se invoca el shell. |
| $ {parámetro: -word} | Si el parámetro está configurado y no está vacío, sustituya su valor; de lo contrario sustituir palabra. |
| $ {parámetro: = palabra} | Si el parámetro no está configurado y no está vacío, configúrelo en word; el valor del parámetro luego se sustituye. Los parámetros posicionales pueden no asignarse de esta manera. |
| $ {parámetro:? palabra} | Si el parámetro está configurado y no está vacío, sustituya su valor; de lo contrario, imprima word y salga del shell. Si se omite la palabra, se imprime un mensaje estándar. |
| $ {parámetro: + palabra} | Si el parámetro está configurado y no está vacío, sustituya la palabra; de lo contrario, no sustituya nada. |
Si se omite:, las sustituciones solo se ejecutan si el parámetro está configurado, incluso si está vacío.
En lo anterior, la palabra no se evalúa a menos que se use como la cadena sustituida. Entonces, por ejemplo, "echo $ {d-`pwd`}" solo ejecutará pwd si d no está configurado.
El shell establece automáticamente los siguientes parámetros:
| # | El número de parámetros posicionales, en decimal. |
| – | Opciones suministradas al shell en la invocación o por conjunto. |
| ? | El valor devuelto por el último comando ejecutado, en decimal. |
| $ | El número de proceso de este shell. |
| ! | El número de proceso del último comando de fondo invocado. |
El shell utiliza los siguientes parámetros:
| CDPATH | La ruta de búsqueda para el comando cd. |
| INICIO | El argumento predeterminado (directorio de inicio) para el comando cd. |
| OPTARG | El valor del argumento de la última opción procesada por el comando especial getopts. |
| OPTIND | El índice de la última opción procesada por el comando especial getopts. |
| TRAYECTORIA | La ruta de búsqueda de comandos (ver Ejecución). |
| Si esta variable se establece con el nombre de un archivo de correo, el shell informa al usuario de la llegada del correo en el archivo especificado. | |
| CHEQUEO | Si se establece esta variable, se interpreta como un valor en segundos para esperar entre comprobaciones de correo nuevo. El valor predeterminado es 600 (10 minutos). Si el valor es cero, el correo se verifica antes de cada solicitud. |
| Ruta de correo | Una lista de archivos separados por dos puntos que se comprueban para correo nuevo. MAIL se ignora si se establece esta variable. |
| PS1 | Cadena de solicitud primaria, por defecto '$'. |
| PS2 | Cadena de solicitud secundaria, por defecto '>'. |
| IFS | Separadores de campo internos, normalmente espacio, tabulación y nueva línea. |
| LANG, LC_ALL | Variables locales. |
| LC_CTYPE | Afecta la asignación de bytes a caracteres para la generación del nombre de archivo, para la interpretación de '' y para manejar $ IFS. |
| SHACCT | Si esta variable se establece en el entorno inicial pasado al shell y apunta a un archivo que el usuario puede escribir, se le escriben estadísticas contables. |
| TIMEOUT | El shell existe cuando se solicita entrada si no se ingresa ningún comando por más del valor dado en segundos. Un valor de cero significa que no hay tiempo de espera y es el valor predeterminado. |
Interpretación en blanco
Después de la sustitución de parámetros y comandos, todos los resultados de la sustitución se analizan en busca de caracteres separadores de campos internos (los que se encuentran en $ IFS) y se dividen en argumentos distintos donde se encuentran dichos caracteres. Los argumentos nulos explícitos ("" o '') se retienen. Los argumentos nulos implícitos (los que resultan de parámetros que no tienen valores) se eliminan.
Generación de nombre de archivo
Después de la sustitución, cada palabra de comando se escanea en busca de los caracteres "*", "?" y "[". Si aparece uno de estos caracteres, la palabra se considera un patrón. La palabra se reemplaza con nombres de archivos ordenados alfabéticamente que coinciden con el patrón. Si no se encuentra un nombre de archivo que coincida con el patrón, la palabra no se modifica. El personaje . al comienzo de un nombre de archivo o inmediatamente después de "/", y el carácter "/", debe coincidir explícitamente.
| * | Coincide con cualquier cadena, incluida la cadena nula. |
| ? | Coincide con cualquier personaje individual. |
| […] | Coincide con cualquiera de los caracteres incluidos. Un par de caracteres separados por: coincide con cualquier carácter léxico entre el par. |
| [! …] | Coincide con cualquier personaje excepto los adjuntos. |
Citando
Los siguientes caracteres tienen un significado especial para el shell y provocan la terminación de una palabra a menos que se cite:
- ;
- y
- (
- )
- |
- ^
- <
- >
- nueva línea
- espacio
- lengüeta
Se puede citar un carácter precediéndolo con una "". "\ nueva línea" se ignora. Todos los caracteres encerrados entre un par de comillas (''), excepto una comilla simple, se citan. Dentro de las comillas dobles ("") se produce la sustitución de parámetros y comandos y "" cita los caracteres , `" y $.
'$ *' es equivalente a '$ 1 $ 2 …', mientras que '[correo electrónico protegido]' es equivalente a '"$ 1" "$ 2" …'.
Incitación
Cuando se usa de forma interactiva, el shell solicita el valor de $ PS1 antes de leer un comando. Si en cualquier momento se escribe una nueva línea y se necesita más información para completar un comando, se emite el indicador secundario ($ PS2).
Entrada y salida
Antes de ejecutar un comando, su entrada y salida pueden redirigirse utilizando una notación especial interpretada por el shell. Lo siguiente puede aparecer en cualquier lugar de un comando simple o puede preceder o seguir un comando y no se pasa al comando invocado. La sustitución se produce antes de usar la palabra o el dígito:
| <palabra | Use la palabra archivo como entrada estándar (descriptor de archivo 0). |
| > palabra | Use la palabra archivo como salida estándar (descriptor de archivo 1). Si el archivo no existe, se crea; de lo contrario se trunca a longitud cero. |
| >> palabra | Use la palabra archivo como salida estándar. Si el archivo existe, la salida se agrega (buscando hasta el final); de lo contrario se crea el archivo. |
| << [-] palabra | La entrada del shell se lee en una línea igual a la palabra o al final del archivo. El documento resultante se convierte en la entrada estándar. Si se cita cualquier carácter de la palabra, entonces no se coloca ninguna interpretación sobre los caracteres del documento; de lo contrario, se produce la sustitución de parámetros y comandos, newline se ignora y se utiliza para citar los caracteres $ `y el primer carácter de la palabra. El "-" opcional hace que el carácter de tabulador inicial se elimine del documento resultante; la palabra también puede ser precedida por un tabulador. |
| <& digito | La entrada estándar se duplica desde el dígito descriptor del archivo. De manera similar para la salida estándar usando>. |
| <& – | La entrada estándar está cerrada. De manera similar para la salida estándar usando>. |
Si uno de los anteriores está precedido por un dígito, el descriptor de archivo creado es el especificado por el dígito (en lugar del 0 o 1 predeterminado). Por ejemplo, "… 2> & 1" crea el descriptor de archivo 2 para ser un duplicado del descriptor de archivo 1. Si un comando es seguido por & entonces la entrada estándar predeterminada para el comando es el archivo vacío (/ dev / null), a menos que el control de trabajo esté habilitado. De lo contrario, el entorno para la ejecución de un comando contiene los descriptores de archivo del shell de invocación modificado por las especificaciones de entrada y salida.
Medio Ambiente
El entorno es una lista de pares de nombre-valor que se pasa a un programa ejecutado de la misma manera que una lista de argumentos normal; ver ejecutivo y medio ambiente. El shell interactúa con el entorno de varias maneras. En la invocación, el shell explora el entorno y crea un parámetro para cada nombre encontrado, dándole el valor correspondiente. Los comandos ejecutados heredan el mismo entorno. Si el usuario modifica los valores de estos parámetros o crea nuevos, ninguno de ellos afecta el entorno a menos que el comando de exportación se utilice para vincular el parámetro del shell al entorno. El entorno visto por cualquier comando ejecutado se compone de cualquier par de nombre-valor no modificado originalmente heredado por el shell, más cualquier modificación o adición, todo lo cual debe tenerse en cuenta en los comandos de exportación.
El entorno para cualquier comando simple se puede aumentar con el prefijo con una o más asignaciones a los parámetros. Así, estas dos líneas son equivalentes:
PLAZO = args de 450 cmd
(exportación TERM; TERM = 450; cmd args)
Señales
Las señales INTERRUPT y QUIT para un comando invocado se ignoran si el comando es seguido por & (a menos que el control de trabajo esté habilitado); de lo contrario, las señales tienen los valores heredados por el shell de su padre. Ver también trampa.
Ejecución
Cada vez que se ejecuta un comando, se realizan las sustituciones anteriores. El shell primero busca si se definió una función con el nombre del comando; Si es así, se elige para la ejecución. De lo contrario, a excepción de los "comandos especiales" enumerados a continuación, se crea un nuevo proceso y se intenta ejecutar el comando a través de un ejecutivo.
El parámetro de shell $ PATH define la ruta de búsqueda para el directorio que contiene el comando. Cada nombre de directorio alternativo está separado por dos puntos (":"). La ruta predeterminada es '/ usr / sbin: / bin: / usr / bin:'. Si el nombre del comando contiene un / entonces la ruta de búsqueda no se usa. De lo contrario, se busca un archivo ejecutable en cada directorio de la ruta. Si el archivo tiene permiso de ejecución pero no es un archivo a.out, se supone que es un archivo que contiene comandos de shell. Se genera un subshell (es decir, un proceso separado) para leerlo. Un comando entre paréntesis también se ejecuta en una subshell.
Comandos especiales
| : | Sin efecto; El comando no hace nada. | ||||||||||||||||||||||||||||||||||||||||||||||||
| . archivo | Lea y ejecute comandos del archivo y regrese. La ruta de búsqueda $ PATH se usa para encontrar el directorio que contiene el archivo. | ||||||||||||||||||||||||||||||||||||||||||||||||
| descanso [n] | Salga del ciclo de cierre para o while, si lo hay. Si se especifica n, rompa n niveles. | ||||||||||||||||||||||||||||||||||||||||||||||||
| continuar [n] | Reanude la próxima iteración del cerramiento para o mientras el ciclo. Si se especifica n, continúe en el enésimo bucle de cierre. | ||||||||||||||||||||||||||||||||||||||||||||||||
| cd [arg] | Cambiar el directorio actual a arg. El parámetro de shell $ HOME es el argumento predeterminado. Si no se encuentra el directorio arg y el parámetro $ CDPATH contiene una lista de directorios separados por dos puntos, cada uno de estos directorios se usa como un prefijo para arg en el orden dado, y el directorio actual se establece en el primero que se encuentra. Si no se encuentra un directorio adecuado, un shell interactivo puede intentar corregir los errores ortográficos y proponer un nombre de directorio alternativo:
cd / usf / lb cd / usr / lib? yok Si la respuesta es 'y' o cualquier otra cosa que no sea 'n', el shell establecerá el directorio actual al propuesto. |
||||||||||||||||||||||||||||||||||||||||||||||||
| echo [arg …] | Cada arg se imprime a la salida estándar; luego, se imprime una nueva línea. Las siguientes secuencias de escape se reconocen en arg:
Si / usr / ucb precede a / usr / sbin o / usr / bin en la configuración actual de la variable $ PATH y el primer argumento es -n, la nueva línea de terminación no se imprime y no se reconocen secuencias de escape. Si la variable $ SYSV3 se establece en el entorno inicial pasado al shell, el argumento -n también se interpreta, pero las secuencias de escape se procesan como de costumbre. |
||||||||||||||||||||||||||||||||||||||||||||||||
| eval [arg …] | Los argumentos se leen como entrada al shell y se ejecutan los comandos resultantes. | ||||||||||||||||||||||||||||||||||||||||||||||||
| exec [arg …] | El comando especificado por los argumentos se ejecuta en lugar de este shell sin crear un nuevo proceso. Los argumentos de entrada / salida pueden aparecer y (si no se dan otros argumentos) pueden hacer que se modifique la entrada / salida del shell. | ||||||||||||||||||||||||||||||||||||||||||||||||
| salir [n] | Hace que el shell salga con el estado de salida especificado por n. Si se omite n, el estado de salida es el del último comando ejecutado. Un final de archivo también saldrá del shell. | ||||||||||||||||||||||||||||||||||||||||||||||||
| exportar [nombre …] | Los nombres de pila están marcados para la exportación automática al entorno de comandos ejecutados posteriormente. Si no se proporcionan argumentos, se imprime una lista de nombres exportables. | ||||||||||||||||||||||||||||||||||||||||||||||||
| getopts optstring variable [arg …] | Recupera opciones y argumentos de opción de arg (o los parámetros posicionales) similares a getopt. optstring es una lista de caracteres (bytes); Cada carácter representa una letra de opción. Un carácter seguido de ":" indica que la opción tiene un argumento. Llamar getopts repetidamente hace que se recupere una opción por llamada. El índice de la opción actual se almacena en la variable OPTIND; se inicializa a 1 cuando se inicia el shell. El argumento de opción, si lo hay, se almacena en la variable OPTARG. El carácter de opción se almacena en la variable. Cuando se alcanza el final de las opciones, getopts regresa con un valor distinto de cero. Un argumento que falta o una opción ilegal también provoca un valor de retorno distinto de cero, y se imprime un mensaje de error con error estándar. | ||||||||||||||||||||||||||||||||||||||||||||||||
| hash [nombre …] | El shell mantiene una tabla hash de las ubicaciones de los comandos externos. Si se dan argumentos de nombre, cada uno se busca y se inserta en la tabla si se encuentra. De lo contrario, se imprime una lista de los comandos actualmente en la tabla. | ||||||||||||||||||||||||||||||||||||||||||||||||
| newgrp [arg …] | Equivalente a "exec newgrp arg …". | ||||||||||||||||||||||||||||||||||||||||||||||||
| pwd | Imprime el nombre del directorio de trabajo actual. | ||||||||||||||||||||||||||||||||||||||||||||||||
| leer [-r] nombre … | Se lee una línea de la entrada estándar; Las palabras sucesivas de la entrada se asignan al nombre de las variables en orden, con las palabras restantes a la última variable. El código de retorno es 0 a menos que se encuentre el final del archivo. Normalmente, las barras invertidas escapan al siguiente personaje; esto se inhibe si se da la opción -r. | ||||||||||||||||||||||||||||||||||||||||||||||||
| readonly [nombre …] | Los nombres de pila se marcan como de solo lectura y los valores de estos nombres no pueden modificarse mediante una asignación posterior. Si no se dan argumentos, se imprime una lista de todos los nombres de solo lectura. | ||||||||||||||||||||||||||||||||||||||||||||||||
| volver [n] | Regrese de una función de shell al nivel de ejecución anterior. Con el argumento n, la variable especial $? se establece en el valor dado. | ||||||||||||||||||||||||||||||||||||||||||||||||
| establecer [–aefhknptuvx [arg …]] |
Estas banderas también se pueden usar al invocar el shell. El conjunto actual de banderas se puede encontrar en $ -. Si se usa + en lugar de -, las banderas dadas están deshabilitadas. Los argumentos restantes son parámetros posicionales y se asignan, en orden, a $ 1, $ 2, etc. Si no se proporcionan argumentos, se imprimen los valores de todos los nombres. |
||||||||||||||||||||||||||||||||||||||||||||||||
| turno [n] | Los parámetros posicionales de $ 2 … se renombran $ 1 … El argumento n provoca un cambio por el número dado, es decir, $ n + 1 se renombra a $ 1 y así sucesivamente. | ||||||||||||||||||||||||||||||||||||||||||||||||
| veces | Imprima los tiempos de usuario y sistema acumulados para los procesos ejecutados desde el shell. | ||||||||||||||||||||||||||||||||||||||||||||||||
| prueba [expr] | prueba evalúa la expresión expr, y si su valor es verdadero, entonces devuelve el estado de salida cero; de lo contrario, se devuelve un estado de salida distinto de cero. La prueba devuelve una salida distinta de cero si no hay argumentos. Las siguientes primitivas se utilizan para construir expr:
Estas primarias se pueden combinar con los siguientes operadores:
-a tiene mayor precedencia que -o. Observe que todos los operadores y banderas son argumentos separados para probar. Observe también que los paréntesis son significativos como separadores de comandos y deben escaparse. |
||||||||||||||||||||||||||||||||||||||||||||||||
| trampa [arg] [n | nombre] … | El argumento es un comando que debe leerse y ejecutarse cuando el shell recibe la (s) señal (es) n. Tenga en cuenta que arg se escanea una vez cuando se establece la trampa y una vez cuando se toma la trampa. Los comandos trap se ejecutan en orden de número de señal. Si arg está ausente, todas las trampas n se restablecen a sus valores originales. Si arg es la cadena nula, esta señal es ignorada por el shell y por los comandos invocados. Si n es 0, entonces el comando arg se ejecuta al salir del shell; de lo contrario, al recibir la señal n como está numerada en la señal. La captura sin argumentos imprime una lista de comandos asociados con cada número de señal. Se puede usar un nombre simbólico en lugar del argumento n; está formado por el nombre de la señal en el lenguaje C menos el prefijo SIG, por ejemplo, TERM para SIGTERM. EXIT es lo mismo que un argumento cero ('0'). | ||||||||||||||||||||||||||||||||||||||||||||||||
| escribe un nombre … | Para cada nombre, imprime si se ejecutaría como una función de shell, como un comando especial o como un comando externo. En el último caso, también se imprime el nombre de ruta completo al comando. | ||||||||||||||||||||||||||||||||||||||||||||||||
| ulimit [- [HS] [a | cdfmnstuv]] ulimit [- [HS] [c | d | f | m | n | s | t | u | v]] [límite] |
Maneja los límites de recursos para el shell y los procesos creados por él, como se describe en getrlimit. Sin un argumento de límite, se imprime la configuración actual; de lo contrario, se establece un nuevo límite. Se aceptan las siguientes opciones:
|
||||||||||||||||||||||||||||||||||||||||||||||||
| umask [-S] [nnn] | La máscara de creación de archivos de usuario se establece en el valor octal nnn (consulte umask). Los modos simbólicos como se describe en chmod también se aceptan. Si se omite nnn, se imprime el valor actual de la máscara. Con la opción -S, la máscara actual se imprime como una cadena simbólica. | ||||||||||||||||||||||||||||||||||||||||||||||||
| variable no establecida … | Desensambla cada variable nombrada. | ||||||||||||||||||||||||||||||||||||||||||||||||
| espera [n] | Espere el proceso especificado e informe su estado de terminación. Si no se da n, se produce una espera para todos los procesos secundarios actualmente activos. El código de retorno de este comando es del proceso esperado. Si n no se refiere a un proceso secundario del shell, la espera regresa inmediatamente con el código 0. |
Invocación
Si el primer carácter del argumento cero es -, los comandos se leen desde / etc / profile y $ HOME / .profile, si existe el archivo respectivo. Los comandos se leen como se describe a continuación. El shell interpreta los siguientes indicadores cuando se invoca:
| -cuerda C | Si el indicador -c está presente, los comandos se leen de la cadena. |
| -s | Si el indicador -s está presente o si no quedan argumentos, los comandos se leen desde la entrada estándar. La salida del shell se escribe en el descriptor de archivo 2. |
| -i | Si el indicador -i está presente o si la entrada y la salida del shell están conectadas a un terminal (como lo indica la función isatty ()), este shell es interactivo. En este caso, la señal de terminación SIGTERM se ignora (de modo que 'kill 0' no mata a un shell interactivo) y la señal de interrupción SIGINT se captura e ignora (de modo que la espera es interrumpible). En todos los casos, SIGQUIT es ignorado por el shell. |
Los indicadores y argumentos restantes se describen en el comando set.
Control de trabajo
Cuando se invoca un shell interactivo como jsh, se habilita el control del trabajo. El control de trabajos permite detener y reanudar procesos, y cambiar entre trabajos en primer plano y en segundo plano. Un trabajo consiste en los comandos de una sola tubería. Cada trabajo se coloca en un grupo de proceso separado; un shell de inicio de sesión y todos los trabajos creados por él forman una sesión. La interrupción, el abandono y otros caracteres de control de terminal solo afectan al grupo de procesos en primer plano actual. El trabajo en primer plano se puede detener presionando la tecla de suspensión, típicamente ^ Z; cualquier trabajo se puede detener enviándole la señal de STOP. Los trabajos se identifican mediante ID de trabajo de la siguiente forma:
| %, %% o% + | El trabajo actual. |
| %- | El trabajo que anteriormente era el trabajo actual. |
| ?cuerda | El único trabajo cuyo nombre contiene cadena. |
| %número | El trabajo con el número dado. |
| número | El trabajo con el número de identificación del grupo de procesos. |
| cadena | El único trabajo para el que la cadena es un prefijo de su nombre. |
Los siguientes comandos integrados también están disponibles con control de trabajo:
| bg [jobid …] | Coloca cada jobid en el fondo. La identificación de trabajo predeterminada es el trabajo actual. | ||||||
| fg [jobid …] | Selecciona secuencialmente cada jobid como el trabajo en primer plano. La identificación de trabajo predeterminada es el trabajo actual. | ||||||
| trabajos [-p | -l] [jobid …] | [-x comando [argumentos …]] |
Imprime información sobre cada jobid o ejecuta el comando:
|
||||||
| matar [[-s señal | -signal] jobid … | -l [estado] | Una versión especial del comando kill que reconoce los identificadores de trabajo en sus argumentos. | ||||||
| dejar de trabajo … | Detiene los trabajos dados (es decir, les envía una señal de PARADA). | ||||||
| suspender | Detiene el propio caparazón. Esto no está permitido si el shell es un líder de sesión. | ||||||
| espera [jobid] | El comando de espera (ver arriba) reconoce los identificadores de trabajo en sus argumentos. |
Notas
Por razones históricas, ^ es sinónimo de | como separador de tubería. Por lo tanto, se desaconseja su uso en nuevas aplicaciones.
Si se redirige un comando que no sea un comando simple (es decir, 'para …', 'caso …', etc.), se ejecuta en una subshell. Si las asignaciones de variables deben estar visibles en el shell principal después de que la entrada se haya redirigido, se puede usar el comando especial exec:
exec 5 <& 0 <entrada mientras se lee la línea do ... variable = valor ... hecho exec <& 5 5 <& -
Si se modifican los parámetros que se han heredado del entorno inicial, se deben exportar explícitamente para que el cambio sea visible para los comandos externos, como se describe en el apartado "Entorno" anterior.
El parámetro $ IFS se aplica a cualquier palabra sin comillas. Así:
IFS = X echoXfoo
ejecuta el comando 'echo' con el argumento 'foo'. El comando 'set -' sin más argumentos es un no-op (sin operación). El comando especial shift se puede usar para eliminar todos los parámetros posicionales.
Solo hay un espacio de nombres para funciones y parámetros. Una definición de función eliminará un parámetro con el mismo nombre y viceversa.
Las asignaciones de parámetros que preceden a un comando especial afectan al propio shell; las asignaciones de parámetros que preceden a la llamada de una función se ignoran.
archivos
/ etc / profile $ HOME / .profile / tmp / sh * / dev / null
Ejemplos
sh
Invoca el shell Bourne y lo coloca en un símbolo del sistema.
Comandos relacionados
bc – A calculator.init – El padre de todos los procesos en el sistema.kill – Envía una señal a un proceso, afectando su comportamiento o matándolo.ksh – El comando de shell Korn interpreter.login – Comienza una sesión en un sistema.newgrp – Inicie sesión en un nuevo grupo.ps – Informe el estado de un proceso o procesos.pwd – Imprima el nombre del directorio de trabajo.stty – Configure las opciones para la pantalla de su terminal.
#goog-gt-tt {display:none !important;}.goog-te-banner-frame {display:none !important;}.goog-te-menu-value:hover {text-decoration:none !important;}body {top:0 !important;}#gtranslate_element {display:none!important;}
var gt_not_translated_list = [«sh [-acefhikmnprstuvx] [arg] …»,»OPTARG»,»OPTIND»,»LANG, LC_ALL»,»LC_CTYPE»,»SHACCT»,»cd [arg]»,»echo [arg …]»,»eval [arg …]»,»exec [arg …]»,»getopts optstring variable [arg …]»,»newgrp [arg …]»,»-t [fildes]»,»-z s1″,»-n s1″,»s1 = s2″,»n1 -eq n2″,»umask [-S] [nnn]»,»bg [jobid …]»,»fg [jobid …]»];
document.cookie = «googtrans=/en/es; domain=.balogs.xyz»;
document.cookie = «googtrans=/en/es»;
function GTranslateElementInit() {new google.translate.TranslateElement({pageLanguage: ‘en’,layout: google.translate.TranslateElement.InlineLayout.SIMPLE,autoDisplay: false,multilanguagePage: true}, ‘gtranslate_element’);}