Cómo usar brackets dobles o simples, paréntesis, llaves

Estoy confundido por el uso de corchetes, paréntesis, llaves en Bash, así como la diferencia entre sus formularios dobles o individuales. ¿Hay una explicación clara?

En Bash, test y [ son construcciones internas.

El doble soporte permite una funcionalidad adicional. Por ejemplo, puedes usar && y || en lugar de -a y -o y hay un operador de coincidencia de expresión regular =~ .

Las llaves, además de delimitar un nombre de variable, se utilizan para la expansión de parámetros, por lo que puede hacer cosas como:

  • Truncar el contenido de una variable

    $ var="abcde"; echo ${var%d*}
    abc

  • Hacer sustituciones similares a sed

    $ var="abcde"; echo ${var/de/12}
    abc12

  • Use un valor predeterminado

    $ default="hello"; unset var; echo ${var:-$default}
    hello

  • y varios más

Además, las expansiones de llaves crean listas de cadenas que generalmente se repiten en bucles:

 $ echo f{oo,ee,a}d food feed fad $ mv error.log{,.OLD} (error.log is renamed to error.log.OLD because the brace expression expands to "mv error.log error.log.OLD") $ for num in {000..2}; do echo "$num"; done 000 001 002 $ echo {00..8..2} 00 02 04 06 08 $ echo {D..T..4} DHLPT 

Tenga en cuenta que las características iniciales cero e incremento no estaban disponibles antes de Bash 4.

Gracias a gboffi por recordarme sobre las expansiones de corsés.

Los dobles paréntesis se usan para operaciones aritméticas :

 ((a++)) ((meaning = 42)) for ((i=0; i<10; i++)) echo $((a + b + (14 * c))) 

y le permiten omitir los signos de dólar en variables enteras y de matriz e incluir espacios alrededor de los operadores para su legibilidad.

Los corchetes individuales también se usan para índices de matriz :

 array[4]="hello" element=${array[index]} 

Se requieren corchetes para (¿la mayoría / todas?) Referencias de matriz en el lado derecho.

El comentario de ephemient me recordó que los paréntesis también se usan para las subcapas. Y que se utilizan para crear matrices.

 array=(1 2 3) echo ${array[1]} 2 
  1. Un paréntesis único ( [ ) generalmente llama a un progtwig llamado [ ; man test u man [ para más información. Ejemplo:

     $ VARIABLE=abcdef $ if [ $VARIABLE == abcdef ] ; then echo yes ; else echo no ; fi yes 
  2. El corchete doble ( [[ ) hace lo mismo (básicamente) que un corchete simple, pero es un bash incorporado.

     $ VARIABLE=abcdef $ if [[ $VARIABLE == 123456 ]] ; then echo yes ; else echo no ; fi no 
  3. Los paréntesis ( () ) se utilizan para crear una subcadena. Por ejemplo:

     $ pwd /home/user $ (cd /tmp; pwd) /tmp $ pwd /home/user 

    Como puede ver, la subshell le permitió realizar operaciones sin afectar el entorno del shell actual.

4a. Las llaves ( {} ) se utilizan para identificar inequívocamente las variables. Ejemplo:

  $ VARIABLE=abcdef $ echo Variable: $VARIABLE Variable: abcdef $ echo Variable: $VARIABLE123456 Variable: $ echo Variable: ${VARIABLE}123456 Variable: abcdef123456 

4b. Los apoyos también se utilizan para ejecutar una secuencia de comandos en el contexto de shell actual , por ejemplo

  $ { date; top -b -n1 | head ; } >logfile # 'date' and 'top' output are concatenated, # could be useful sometimes to hunt for a top loader ) $ { date; make 2>&1; date; } | tee logfile # now we can calculate the duration of a build from the logfile 

Sin embargo, hay una sutil diferencia sintáctica con ( ) (ver referencia bash ); esencialmente, un punto y coma ; después de que el último comando dentro de las llaves sea obligatorio, y las llaves { , } deben estar rodeadas de espacios.

Soportes

 if [ CONDITION ] Test construct if [[ CONDITION ]] Extended test construct Array[1]=element1 Array initialization [az] Range of characters within a Regular Expression $[ expression ] A non-standard & obsolete version of $(( expression )) [1] 

[1] http://wiki.bash-hackers.org/scripting/obsolete

Paréntesis rizadas

 ${variable} Parameter substitution ${!variable} Indirect variable reference { command1; command2; . . . commandN; } Block of code {string1,string2,string3,...} Brace expansion {a..z} Extended brace expansion {} Text replacement, after find and xargs 

Paréntesis

 ( command1; command2 ) Command group executed within a subshell Array=(element1 element2 element3) Array initialization result=$(COMMAND) Command substitution, new style >(COMMAND) Process substitution < (COMMAND) Process substitution 

Doble paréntesis

 (( var = 78 )) Integer arithmetic var=$(( 20 + 5 )) Integer arithmetic, with variable assignment (( var++ )) C-style variable increment (( var-- )) C-style variable decrement (( var0 = var1<98?9:21 )) C-style ternary operation 

Solo quería agregar estos de TLDP :

 ~:$ echo $SHELL /bin/bash ~:$ echo ${#SHELL} 9 ~:$ ARRAY=(one two three) ~:$ echo ${#ARRAY} 3 ~:$ echo ${TEST:-test} test ~:$ echo $TEST ~:$ export TEST=a_string ~:$ echo ${TEST:-test} a_string ~:$ echo ${TEST2:-$TEST} a_string ~:$ echo $TEST2 ~:$ echo ${TEST2:=$TEST} a_string ~:$ echo $TEST2 a_string ~:$ export STRING="thisisaverylongname" ~:$ echo ${STRING:4} isaverylongname ~:$ echo ${STRING:6:5} avery ~:$ echo ${ARRAY[*]} one two one three one four ~:$ echo ${ARRAY[*]#one} two three four ~:$ echo ${ARRAY[*]#t} one wo one hree one four ~:$ echo ${ARRAY[*]#t*} one wo one hree one four ~:$ echo ${ARRAY[*]##t*} one one one four ~:$ echo $STRING thisisaverylongname ~:$ echo ${STRING%name} thisisaverylong ~:$ echo ${STRING/name/string} thisisaverylongstring 

La diferencia entre la prueba , [ y [[ se explica en gran detalle en BashFAQ .

Para abreviar, la prueba implementa la syntax antigua y portátil del comando. En casi todas las conchas (las conchas de Bourne más antiguas son la excepción), [es un sinónimo de prueba (pero requiere un argumento final de]). Aunque todas las shells modernas tienen implementaciones incorporadas de [, usualmente todavía hay un ejecutable externo de ese nombre, por ejemplo, / bin / [.

[[es una nueva versión mejorada, que es una palabra clave, no un progtwig. Esto tiene efectos beneficiosos sobre la facilidad de uso, como se muestra a continuación. [[KornShell y BASH lo entienden [por ejemplo, 2.03], pero no por los antiguos POSIX o BourneShell).

Y la conclusión:

¿Cuándo debería utilizarse el nuevo comando de prueba [[y el anterior [? Si la portabilidad de BourneShell es una preocupación, se debe usar la syntax anterior. Si, por otro lado, el script requiere BASH o KornShell, la nueva syntax es mucho más flexible.

Paréntesis en la definición de la función

Los paréntesis () se utilizan en la definición de funciones:

 function_name () { command1 ; command2 ; } 

Esa es la razón por la que tiene que escapar paréntesis incluso en parámetros de comando:

 $ echo ( bash: syntax error near unexpected token `newline' $ echo \( ( $ echo () { command echo The command echo was redefined. ; } $ echo anything The command echo was redefined.