bash - traduccion - Cómo utilizar corchetes dobles o simples, paréntesis, llaves.

bash variables

Question

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

Answer 1

Paréntesis en la definición de funciones

Los paréntesis () se están utilizando en la definición de la función:

function_name () { command1 ; command2 ; }

Esa es la razón por la que tienes que escapar de paréntesis incluso en los 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.

Answer 2

1. Un solo corchete ( [ ) 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 paréntesis doble ( [[ ) hace lo mismo (básicamente) como un corchete simple, pero es un basin incorporado.

   $ VARIABLE=abcdef
   $ if [[ $VARIABLE == 123456 ]] ; then echo yes ; else echo no ; fi
   no

3. Los paréntesis ( () ) se utilizan 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. Las llaves ( {} ) se utilizan para identificar variables de forma inequívoca. Ejemplo:

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

4b. Las llaves también se usan 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 diferencia sintáctica sutil con ( ) (vea la referencia de bash ); Básicamente, un punto y coma ; después del último comando entre llaves es obligatorio, y las llaves { , } deben estar rodeadas por espacios.

Answer 3

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

Para abreviar una larga historia: la prueba implementa la sintaxis antigua y portátil del comando. En casi todos los shells (los shells Bourne más antiguos son la excepción), [es un sinónimo de test (pero requiere un argumento final de]). Aunque todos los shells modernos tienen implementaciones integradas de [, por lo general, todavía hay un ejecutable externo con ese nombre, por ejemplo, / bin / [.

[[es una nueva versión mejorada de la misma, que es una palabra clave, no un programa. Esto tiene efectos beneficiosos en la facilidad de uso, como se muestra a continuación. [[se entiende por KornShell y BASH (por ejemplo, 2.03), pero no por el POSIX o BourneShell anterior.

Y la conclusión:

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

Answer 4

Solo quería agregar estos desde 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

Answer 5

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

Tirantes rizados

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

Paréntesis dobles

(( 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

Answer 6

En Bash, test y [ están incorporados.

El doble soporte permite una funcionalidad adicional. Por ejemplo, puedes usar && y || en lugar de -a y -o y hay un operador de concordancia de expresiones regulares =~ .

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

• Truncar los contenidos de una variable.

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

• Hacer sustituciones similares a sed

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

• Usa un valor predeterminado

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

• y varios mas

Además, las expansiones de refuerzo crean listas de cadenas que normalmente se repiten en los 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 de cero e incremento no estaban disponibles antes de Bash 4.

Gracias a gboffi por recordarme acerca de las expansiones de corsé.

Los paréntesis dobles se utilizan 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 las variables de enteros y matrices e incluyen espacios alrededor de los operadores para facilitar la lectura.

Los corchetes individuales también se utilizan para los índices de array :

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

Se requieren corsé para las referencias de matriz (¿la mayoría / todas?) En el lado derecho.

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

array=(1 2 3)
echo ${array[1]}
2