GNU/Linux >> Tutoriales Linux > >> Linux

¿Qué son los operadores de control y redirección de Shell?

A menudo veo tutoriales en línea que conectan varios comandos con diferentes símbolos. Por ejemplo:

command1 |  command2
command1 &  command2
command1 || command2    
command1 && command2

Otros parecen estar conectando comandos a archivos:

command1  > file1
command1  >> file1

¿Qué son estas cosas? ¿Cómo se llaman? ¿Qué hacen? ¿Hay más de ellos?

Meta hilo sobre esta pregunta..

Respuesta aceptada:

Estos se llaman operadores de shell y sí, hay más de ellos. Daré una breve descripción de los más comunes entre las dos clases principales, operadores de control y operadores de redirección, y cómo funcionan con respecto al shell bash.

A. Operadores de control

Definición de POSIX

En el lenguaje de comandos de shell, un token que realiza una función de control.
Es uno de los siguientes símbolos:

&   &&   (   )   ;   ;;   <newline>   |   ||

Y |& en bash.

Un ! es no un operador de control sino una palabra reservada. Se convierte en un NOT [operador de negación] lógico dentro de las expresiones aritméticas y dentro de las construcciones de prueba (aunque aún requiere un delimitador de espacio).

A.1 Terminadores de lista

; :Ejecutará un comando después de que otro haya finalizado, independientemente del resultado del primero.
```
command1 ; command2
```
Primer command1 se ejecuta, en primer plano, y una vez finalizado, command2 se ejecutará.

Una nueva línea que no está en un literal de cadena o después de ciertas palabras clave es no equivalente al operador punto y coma. Una lista de ; los comandos simples delimitados siguen siendo una lista – como en el analizador del shell, aún debe continuar leyendo los comandos simples que siguen a un ; comando simple delimitado antes de ejecutarse, mientras que una nueva línea puede delimitar una lista de comandos completa, o una lista de listas. La diferencia es sutil, pero complicada:dado que el shell no tiene un imperativo previo para leer datos después de una nueva línea, la nueva línea marca un punto donde el shell puede comenzar a evaluar los comandos simples que ya ha leído, mientras que un ; punto y coma no.
& :Esto ejecutará un comando en segundo plano, permitiéndole continuar trabajando en el mismo shell.
```
 command1 & command2
```
Aquí, command1 se ejecuta en segundo plano y command2 comienza a ejecutarse en primer plano inmediatamente, sin esperar command1 para salir.

Una nueva línea después de command1 es opcional.

A.2 Operadores lógicos

&& :Usado para construir listas AND, le permite ejecutar un comando solo si otro salió con éxito.
```
 command1 && command2
```
Aquí, command2 se ejecutará después de command1 ha terminado y solo si command1 tuvo éxito (si su código de salida era 0). Ambos comandos se ejecutan en primer plano.

Este comando también se puede escribir
```
if command1
then command2
else false
fi
```
o simplemente if command1; then command2; fi si se ignora el estado de retorno.
|| :Usado para construir listas OR, le permite ejecutar un comando solo si otro salió sin éxito.
```
 command1 || command2
```
Aquí, command2 solo se ejecutará si command1 falló (si devolvió un estado de salida distinto de 0). Ambos comandos se ejecutan en primer plano.

Este comando también se puede escribir
```
if command1
then true
else command2
fi
```
o de forma más corta if ! command1; then command2; fi .

Tenga en cuenta que && y || son asociativos por la izquierda; consulte Precedencia de los operadores lógicos de shell &&, || para más información.
! :esta es una palabra reservada que actúa como el operador "no" (pero debe tener un delimitador), que se usa para negar el estado de devolución de un comando:devuelve 0 si el comando devuelve un estado distinto de cero, devuelve 1 si devuelve el estado 0 También un NO lógico para el test utilidad.
```
! command1

[ ! a = a ]
```
Y un verdadero operador NOT dentro de expresiones aritméticas:
```
$ echo $((!0)) $((!23))
1 0
```

A.3 Operador de tubería

| :El operador de tubería, pasa la salida de un comando como entrada a otro. Un comando creado a partir del operador de canalización se denomina canalización.
```
 command1 | command2
```
Cualquier salida impresa por command1 se pasa como entrada a command2 .
|& :Esta es una abreviatura de 2>&1 | en bash y zsh. Pasa tanto la salida estándar como el error estándar de un comando como entrada a otro.
```
command1 |& command2
```

A.4 Otra lista de puntuación

;; se utiliza únicamente para marcar el final de una declaración de caso. Ksh, bash y zsh también son compatibles con ;& pasar al siguiente caso y ;;& (no en ATT ksh) para continuar y probar casos posteriores.

Relacionado:¿Enumerar los archivos a los que accede un programa?

( y ) se utilizan para agrupar comandos y ejecutarlos en una subcapa. { y } también agrupa comandos, pero no los ejecutes en una subcapa. Consulte esta respuesta para ver una discusión sobre los distintos tipos de paréntesis, corchetes y llaves en la sintaxis de shell.

B. Operadores de redirección

Definición POSIX de operador de redirección

En el lenguaje de comandos de shell, un token que realiza una función de redirección. Es uno de los siguientes símbolos:

<     >     >|     <<     >>     <&     >&     <<-     <>

Estos le permiten controlar la entrada y salida de sus comandos. Pueden aparecer en cualquier lugar dentro de un comando simple o pueden seguir un comando. Las redirecciones se procesan en el orden en que aparecen, de izquierda a derecha.

< :Da entrada a un comando.
```
command < file.txt
```
Lo anterior ejecutará command sobre el contenido de file.txt .
<> :igual que arriba, pero el archivo está abierto en lectura+escritura modo en lugar de solo lectura :
```
command <> file.txt
```
Si el archivo no existe, se creará.

Ese operador rara vez se usa porque los comandos generalmente solo leen de su entrada estándar, aunque puede ser útil en varias situaciones específicas.
> :Dirige la salida de un comando a un archivo.
```
command > out.txt
```
Lo anterior guardará la salida del command como out.txt . Si el archivo existe, se sobrescribirá su contenido y si no existe, se creará.

Este operador también se usa a menudo para elegir si algo debe imprimirse con un error estándar o una salida estándar:
```
command >out.txt 2>error.txt
```
En el ejemplo anterior, > redirigirá la salida estándar y 2> redirige el error estándar. La salida también se puede redirigir usando 1> pero, dado que este es el valor predeterminado, el 1 generalmente se omite y se escribe simplemente como > .

Entonces, para ejecutar command en file.txt y guarde su salida en out.txt y cualquier mensaje de error en error.txt ejecutarías:
```
command < file.txt > out.txt 2> error.txt
```
>| :Hace lo mismo que > , pero sobrescribirá el destino, incluso si el shell se ha configurado para rechazar la sobrescritura (con set -C o set -o noclobber ).
```
command >| out.txt
```
Si out.txt existe, la salida del command reemplazará su contenido. Si no existe se creará.
>> :Hace lo mismo que > , excepto que si el archivo de destino existe, se adjuntan los nuevos datos.
```
command >> out.txt
```
Si out.txt existe, la salida del command se añadirá a él, después de lo que ya está en él. Si no existe se creará.
>& :(según la especificación POSIX) cuando está rodeado de dígitos (1>&2 ) o - en el lado derecho (1>&- ) redirige solo a uno descriptor de archivo o lo cierra (>&- ).

Un >& seguido de un número de descriptor de archivo es una forma portátil de redirigir un descriptor de archivo, y >&- es una forma portátil de cerrar un descriptor de archivo.

Si el lado derecho de esta redirección es un archivo, lea la siguiente entrada.
>& , &> , >>& y &>> :(leer arriba también) Redirigir tanto el error estándar como la salida estándar, reemplazando o agregando, respectivamente.
```
command &> out.txt
```
Tanto el error estándar como la salida estándar del command se guardará en out.txt , sobrescribiendo su contenido o creándolo si no existe.
```
command &>> out.txt
```
Como arriba, excepto que si out.txt existe, la salida y el error de command se adjuntará a ella.

El &> la variante se origina en bash , mientras que >& variante proviene de csh (décadas antes). Ambos entran en conflicto con otros operadores de shell POSIX y no deben usarse en portátiles sh guiones.
< :Un documento aquí. A menudo se usa para imprimir cadenas de varias líneas.
```
 command << WORD
     Text
 WORD
```
Aquí, command tomará todo hasta que encuentre la siguiente ocurrencia de WORD , Text en el ejemplo anterior, como input . Mientras WORD es a menudo EoF o variaciones de la misma, puede ser cualquier cadena alfanumérica (y no solo) que desee. Cuando WORD se cita, el texto del presente documento se trata literalmente y no se realizan expansiones (en variables, por ejemplo). Si no está entre comillas, las variables se expandirán. Para obtener más detalles, consulte el manual de bash.

Si desea canalizar la salida del comando command << WORD ... WORD directamente a otro comando o comandos, debe colocar la tubería en la misma línea que << WORD , no puede ponerlo después de la PALABRA final o en la línea siguiente. Por ejemplo:
```
 command << WORD | command2 | command3...
     Text
 WORD
```
<<< :Cadenas Here, similares a los documentos Here, pero pensadas para una sola línea. Estos existen solo en el puerto Unix o rc (donde se originó), zsh, algunas implementaciones de ksh, yash y bash.
```
command <<< WORD
```
Lo que se da como WORD se expande y su valor se pasa como entrada a command . Esto se usa a menudo para pasar el contenido de las variables como entrada a un comando. Por ejemplo:
```
 $ foo="bar"
 $ sed 's/a/A/' <<< "$foo"
 bAr
 # as a short-cut for the standard:
 $ printf '%sn' "$foo" | sed 's/a/A/'
 bAr
 # or
 sed 's/a/A/' << EOF
 $foo
 EOF
```

Algunos otros operadores (>&- , x>&y x<&y ) se puede utilizar para cerrar o duplicar descriptores de archivos. Para obtener detalles sobre ellos, consulte la sección correspondiente del manual de su shell (aquí, por ejemplo, para bash).

Relacionado:¿Cómo aplazar la expansión variable?

Eso solo cubre los operadores más comunes de shells tipo Bourne. Algunos shells tienen algunos operadores de redirección adicionales propios.

Ksh, bash y zsh también tienen construcciones <(…) , >(…) y =(…) (este último en zsh solamente). No se trata de redirecciones, sino de sustitución de procesos.

¿Cuándo son necesarias las comillas dobles?

¿Implicaciones de seguridad de olvidar citar una variable en Bash/posix Shells?

Linux

¿Qué es Intel SGX y cuáles son los beneficios?

¿Cuál es la diferencia entre InnoDB y MyISAM?

¿Cuál es la diferencia entre Linux y Unix?

¿Cuáles son las principales diferencias entre Bsd y Gnu/linux Userland?

¿Redireccionamiento de Io y el comando principal?

¿Cuáles son las diferencias entre cPanel y WHM?