Pregunta 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?


563
2018-02-02 22:22


origen


Respuestas:


En Bash, test y [ son builtins.

los doble soporte habilita 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 expansión de parámetros para que pueda hacer cosas como:

  • Truncar el contenido de una variable

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

  • Haga 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}
D H L P T

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 paréntesis dobles se usan para operaciones aritmeticas:

((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 soportes individuales también se usan para formación índices:

array[4]="hello"

element=${array[index]}

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

efímero El comentario 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

517
2018-02-02 22:48



  1. Un solo soporte ([) generalmente llama a un programa llamado [; man test o man [ para más información. Ejemplo:

    $ VARIABLE=abcdef
    $ if [ $VARIABLE == abcdef ] ; then echo yes ; else echo no ; fi
    yes
    
  2. El doble soporte ([[) 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. Paréntesis (()) se usan para crear una subshell. 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. Tirantes ({}) se utilizan para identificar inequívocamente 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 corriente contexto de shell, p.

    $ { 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

Hay una sutil diferencia sintáctica con ( ), sin embargo (ver referencia bash); esencialmente, un punto y coma ; después del último comando dentro de llaves es una necesidad, y los apoyos {, }  debe estar rodeado de espacios.


289
2018-02-02 22:27



Soportes 

if [ CONDITION ]    Test construct  
if [[ CONDITION ]]  Extended test construct  
Array[1]=element1   Array initialization  
[a-z]               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

252
2017-12-18 13:47



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

20
2018-06-29 17:40



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

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

[[es una nueva versión mejorada, que es una palabra clave, no un programa.   Esto tiene efectos beneficiosos sobre la facilidad de uso, como se muestra a continuación. [[ es   entendido por KornShell y BASH (por ejemplo, 2.03), pero no por el anterior   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, la vieja sintaxis debería   ser usado. Si, por otro lado, el script requiere BASH o KornShell,   la nueva sintaxis es mucho más flexible.


17
2017-10-28 09:22



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

Paréntesis () se están utilizando 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.

16
2017-09-09 08:56