Funciones de los distintos paréntesis/corchetes/llaves en shell ()、(())、[]、[[]]、{}

Uno、Paréntesis pequeños, paréntesis redondos ()

1. Paréntesis simple ()

Grupo de comandosLos comandos dentro del paréntesis se ejecutarán secuencialmente en una sub-shell nueva, por lo que las variables dentro del paréntesis no pueden ser utilizadas por el resto del script. Entre los múltiples comandos dentro del paréntesis se usan punto y coma para separarlos; el último comando puede omitir el punto y coma, y no es necesario que haya espacios entre los comandos y el paréntesis.
Sustitución de comandosEquivale a `cmd`. El shell escanea la línea de comandos y, al encontrar la estructura $(cmd), ejecuta el cmd dentro de $(cmd) una vez, obtiene su salida estándar y luego coloca esta salida en el comando original. Algunos shells no lo admiten, como tcsh.
Se utiliza para inicializar arrays.Por ejemplo: array=(a b c d)

2. Paréntesis doble (( ))

Expansión de enteros. Esta expansión es un cálculo de tipo entero y no admite números de coma flotante. La estructura ((exp)) expande y calcula el valor de una expresión aritmética. Si el resultado de la expresión es 0, el código de estado de salida devuelto es 1, o "falso"; mientras que una expresión con valor distinto de cero devolverá un código de estado de salida de 0, o "verdadero". Si se trata de una evaluación lógica, si la expresión exp es verdadera, es 1; si es falsa, es 0.
Siempre que los operadores y expresiones dentro del paréntesis cumplan las reglas de operación del lenguaje C, se pueden usar en $((exp)), incluso el operador ternario. Al realizar operaciones en diferentes bases (como binario, octal, hexadecimal), todos los resultados de salida se convierten automáticamente a decimal. Por ejemplo: echo $((16#5f)) da como resultado 95 (conversión de base 16 a decimal).
El uso simple de (( )) también puede redefinir el valor de una variable; por ejemplo, a=5; ((a++)) redefine $a como 6.
Se usa comúnmente para comparaciones aritméticas; las variables dentro del doble paréntesis no necesitan el prefijo $. Dentro del paréntesis se admiten múltiples expresiones separadas por comas. Siempre que las expresiones dentro del paréntesis cumplan las reglas del lenguaje C, se puede usar directamente for((i=0;i<5;i++)). Si no se usan dobles paréntesis, sería for i in `seq 0 4` o for i in {0..4}. Otro ejemplo: se puede usar directamente if (($i<5)); sin dobles paréntesis, sería if [ $i -lt 5 ].

Dos、Corchetes, corchetes cuadrados []

1. Corchete simple []

Es un comando interno de bash; [ y test son equivalentes. Si no se indica mediante una ruta absoluta, normalmente usamos el comando incluido en bash. En la estructura if/test, el corchete izquierdo es un identificador del comando que invoca a test, y el corchete derecho cierra la evaluación de la condición. Este comando toma sus argumentos como una expresión de comparación o como una prueba de archivos, y devuelve un código de estado de salida según el resultado de la comparación. En la estructura if/test no es obligatorio el corchete derecho, pero en las nuevas versiones de Bash se requiere.
Los operadores de comparación disponibles en test y [] son solo == y !=; ambos se utilizan para comparar cadenas, no para comparar enteros. Para comparar enteros solo se pueden usar formas como -eq, -gt. Ni la comparación de cadenas ni la de enteros admite los signos mayor que o menor que. Si realmente se quiere usarlos, en la comparación de cadenas se puede usar la forma escapada; por ejemplo, al comparar "ab" y "bc": [ ab \< bc ], el resultado es verdadero, es decir, el estado de retorno es 0. En [ ], el Y lógico y el O lógico se representan con -a y -o.
Rango de caracteres. Se usa como parte de una expresión regular para describir un rango de caracteres que coincida. Dentro de los corchetes usados como test no se pueden usar expresiones regulares.
En el contexto de una estructura array, los corchetes se utilizan para referirse al número de cada elemento del array.

2. Corchete doble [[ ]]

[[ es una palabra clave del lenguaje de programación bash. No es un comando; la estructura [[ ]] es más general que la estructura [ ]. Entre [[ y ]], todos los caracteres no sufren expansión de nombres de archivo ni división de palabras, pero sí se produce expansión de parámetros y sustitución de comandos.
Admite coincidencia de patrones de cadenas; con el operador =~ incluso admite expresiones regulares de shell. En la comparación de cadenas, se puede tomar el lado derecho como un patrón, y no solo como una cadena; por ejemplo, [[ hello == hell? ]] da como resultado verdadero. En [[ ]], para coincidir cadenas o comodines no se necesitan comillas.
Usar la estructura de evaluación de condiciones [[ ... ]] en lugar de [ ... ] puede evitar muchos errores lógicos en el script. Por ejemplo, los operadores &&, ||, < y > pueden existir normalmente en la estructura [[ ]], pero si aparecen en la estructura [ ], se reportará un error. Por ejemplo, se puede usar directamente if [[ $a != 1 && $a != 2 ]]; sin doble corchete, sería if [ $a -ne 1] && [ $a != 2 ] o if [ $a -ne 1 -a $a != 2 ].
bash trata la expresión dentro de los dobles corchetes como un elemento único y devuelve un código de estado de salida.

if ($i<5)    
if [ $i -lt 5 ]    
if [ $a -ne 1 -a $a != 2 ]    
if [ $a -ne 1] && [ $a != 2 ]    
if [[ $a != 1 && $a != 2 ]]    
     
for i in $(seq 0 4);do echo $i;done    
for i in `seq 0 4`;do echo $i;done    
for ((i=0;i<5;i++));do echo $i;done    
for i in {0..4};do echo $i;done

Tres、Llaves, corchetes rizados {}

1. Uso general

(1) Expansión de llaves. El (globbing) expandirá los nombres de archivo dentro de las llaves. En las llaves no se permite espacio en blanco, a menos que este esté entre comillas o escapado. Primer tipo: expande la lista de archivos separados por comas dentro de las llaves. Por ejemplo: touch {a,b}.txt da como resultado a.txt b.txt. Segundo tipo: expande la lista de archivos secuenciales separados por puntos (..) dentro de las llaves. Por ejemplo: touch {a..d}.txt da como resultado a.txt b.txt c.txt d.txt

# ls {ex1,ex2}.sh    
ex1.sh  ex2.sh    
# ls {ex{1..3},ex4}.sh    
ex1.sh  ex2.sh  ex3.sh  ex4.sh    
# ls {ex[1-3],ex4}.sh    
ex1.sh  ex2.sh  ex3.sh  ex4.sh

(2) Bloque de código, también llamado grupo interno; esta estructura en realidad crea una función anónima. A diferencia de los comandos entre paréntesis, los comandos entre llaves no abren una sub-shell nueva para ejecutarse, es decir, el resto del script aún puede usar las variables dentro de las llaves. Los comandos entre llaves se separan con punto y coma; el último también debe llevar punto y coma. Entre el primer comando de {} y la llave izquierda debe haber un espacio.

2. Varias estructuras especiales de sustitución

${var:-string} 
${var:+string} 
${var:=string}
${var:?string}

1. ${var:-string} y ${var:=string}: si la variable var está vacía, se usa string en la línea de comandos para reemplazar a ${var:-string}; si la variable var no está vacía, se usa el valor de var para reemplazar a ${var:-string}. La regla de sustitución de ${var:=string} es la misma que la de ${var:-string}; la diferencia es que en ${var:=string}, si var está vacía, al reemplazar ${var:=string} con string, también se asigna string a la variable var. Un uso muy común de ${var:=string} es determinar si una variable ha sido asignada; si no lo ha sido, se le asigna un valor por defecto.

2. La regla de sustitución de ${var:+string} es la contraria a la anterior, es decir, solo se reemplaza por string cuando var no está vacía; si var está vacía, no se reemplaza o, más bien, se reemplaza por el valor de la variable var, que es un valor vacío. (Como la variable var está vacía en ese caso, ambas afirmaciones son equivalentes.)

3. La regla de sustitución de {var:?string}: si la variable var no está vacía, se usa el valor de var para reemplazar a {var:?string}; si var está vacía, se envía string a la salida estándar de error y se sale del script. Podemos usar esta característica para comprobar si se ha establecido el valor de una variable.

Extensión complementariaEn las cinco estructuras de sustitución anteriores, string no tiene por qué ser un valor constante; puede ser el valor de otra variable o la salida de un comando.

3. Cuatro estructuras de sustitución por coincidencia de patrones

Método para recordar la coincidencia de patrones:

# es quitar el lado izquierdo (en el teclado, # está a la izquierda de $)
% es quitar el lado derecho (en el teclado, % está a la derecha de $)

En # y %, un símbolo único es la coincidencia mínima; dos símbolos iguales son la coincidencia máxima.

${var%pattern}
${var%%pattern
${var#pattern}
${var##pattern}

Primer tipo: ${variable%pattern}. En este tipo, el shell busca en variable para ver si termina con el patrón dado pattern. Si es así, elimina de la línea de comandos la coincidencia más corta por la derecha del contenido de variable.
Segundo tipo: ${variable%%pattern}. En este tipo, el shell busca en variable para ver si termina con el patrón dado pattern. Si es así, elimina de la línea de comandos la coincidencia más larga por la derecha del contenido de variable.
Tercer tipo: ${variable#pattern}. En este tipo, el shell busca en variable para ver si comienza con el patrón dado pattern. Si es así, elimina de la línea de comandos la coincidencia más corta por la izquierda del contenido de variable.
Cuarto tipo: ${variable##pattern}. En este tipo, el shell busca en variable para ver si termina con el patrón dado pattern. Si es así, elimina de la línea de comandos la coincidencia más larga por la derecha del contenido de variable.
En ninguno de estos cuatro modos se modifica el valor de variable. Solo cuando se utiliza el símbolo de coincidencia * en el pattern, % y %%, # y ## tienen diferencias. El pattern en la estructura admite comodines: * representa cero o más caracteres arbitrarios, ? representa la coincidencia con un solo carácter arbitrario, [...] representa la coincidencia con los caracteres dentro de los corchetes, y [!...] representa la no coincidencia con los caracteres dentro de los corchetes.

# var=testcase    
# echo $var    
testcase    
# echo ${var%s*e}   
testca    
# echo $var    
testcase   
# echo ${var%%s*e}   
te  
# echo ${var#?e}    
stcase  
# echo ${var##?e}    
stcase  
# echo ${var##*e}    
  
# echo ${var##*s}    
e    
# echo ${var##test}    
case

4. Extracción y sustitución de cadenas

${var:num}
${var:num1:num2}
${var/pattern/pattern}
${var//pattern/pattern}

Primer modo: ${var:num}. En este modo, el shell extrae todos los caracteres desde la posición num hasta el final de var. Si num es positivo, comienza desde la posición 0 a la izquierda; si num es negativo, extrae la subcadena desde la derecha, pero debe añadirse un espacio o un número después de los dos puntos, o todo el num debe ir entre paréntesis, como ${var: -2}, ${var:1-3} o ${var:(-2)}.
Segundo modo: ${var:num1:num2}, num1 es la posición y num2 es la longitud. Indica extraer una subcadena de longitud $num2 comenzando desde la posición $num1 de la cadena $var. No puede ser negativo.
Tercer modo: ${var/pattern/pattern} indica reemplazar la primera coincidencia de pattern en la cadena var con otro pattern.
Cuarto modo: ${var//pattern/pattern} indica reemplazar todas las coincidencias de pattern en la cadena var con otro pattern.

[root@centos ~]# var=/home/centos  
[root@centos ~]# echo $var  
/home/centos  
[root@centos ~]# echo ${var:5}  
/centos  
[root@centos ~]# echo ${var: -6}  
centos  
[root@centos ~]# echo ${var:(-6)}  
centos  
[root@centos ~]# echo ${var:1:4}  
home  
[root@centos ~]# echo ${var/o/h}  
/hhme/centos  
[root@centos ~]# echo ${var//o/h}  
/hhme/cenths

Cuatro、Corchetes después del símbolo $

(1) ${a} El valor de la variable a. Las llaves pueden omitirse cuando no haya ambigüedad.
(2) $(cmd) Sustitución de comando, con el mismo efecto que `cmd`. El resultado es la salida del comando shell cmd. Sin embargo, algunas versiones de Shell no admiten la sustitución de comandos con la forma $(), como tcsh.
(3) $((expression)) Tiene el mismo efecto que `expr expression`. Calcula el valor numérico de la expresión matemática exp, donde exp solo necesita cumplir con las reglas de operación del lenguaje C; incluso se pueden calcular operadores ternarios y expresiones lógicas.

Cinco、Uso

1. Ejecución de múltiples comandos
- (1) Paréntesis simple, (cmd1;cmd2;cmd3) Abre un nuevo sub-shell para ejecutar los comandos cmd1, cmd2, cmd3 en orden. Los comandos se separan con punto y coma; después del último comando puede omitirse el punto y coma.
- (2) Llaves simples, { cmd1;cmd2;cmd3;} Ejecuta los comandos cmd1, cmd2, cmd3 en orden en el shell actual. Los comandos se separan con punto y coma; después del último comando debe haber punto y coma, y el primer comando debe estar separado de la llave izquierda por un espacio.
Sobre{}y()En cuanto a los operadores de redirección, los que están dentro de los paréntesis solo afectan a ese comando, mientras que los que están fuera de los paréntesis afectan a todos los comandos dentro de los paréntesis.

Fuente original: http://blog.csdn.net/taiyang1987912/article/details/39551385