Comment utiliser les crochets doubles ou simples, les parenthèses et les accolades ?

Question

Je ne sais pas comment utiliser les crochets, les parenthèses et les accolades dans Bash, ni quelle est la différence entre leur forme double ou simple. Existe-t-il une explication claire ?

Answer 1

Dans Bash, test et [ sont des modules intégrés au shell.

Le site double support qui est un mot-clé de l'interpréteur de commandes, permet de bénéficier de fonctionnalités supplémentaires. Par exemple, vous pouvez utiliser && et || au lieu de -a et -o et il y a un opérateur de correspondance d'expression régulière =~ .

De plus, dans un test simple, les crochets doubles semblent être évalués beaucoup plus rapidement que les crochets simples.

$ time for ((i=0; i<10000000; i++)); do [[ "$i" = 1000 ]]; done

real    0m24.548s
user    0m24.337s
sys 0m0.036s
$ time for ((i=0; i<10000000; i++)); do [ "$i" = 1000 ]; done

real    0m33.478s
user    0m33.478s
sys 0m0.000s

Les accolades, en plus de délimiter un nom de variable sont utilisées pour expansion des paramètres pour que vous puissiez faire des choses comme :

• Tronquer le contenu d'une variable

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

• Faites des substitutions similaires à sed

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

• Utiliser une valeur par défaut

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

• et plusieurs autres

De plus, les expansions d'accolades créent des listes de chaînes de caractères qui sont généralement itérées dans des boucles :

$ 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

Notez que les fonctions de zéro en tête et d'incrémentation n'étaient pas disponibles avant Bash 4.

Merci à gboffi de m'avoir rappelé les expansions d'accolades.

Les doubles parenthèses sont utilisées pour opérations arithmétiques :

((a++))

((meaning = 42))

for ((i=0; i<10; i++))

echo $((a + b + (14 * c)))

et ils vous permettent d'omettre le signe dollar sur les variables de type entier et tableau et d'inclure des espaces autour des opérateurs pour plus de lisibilité.

Les parenthèses simples sont également utilisées pour tableau des indices :

array[4]="hello"

element=${array[index]}

Les accolades sont nécessaires pour (la plupart/toutes ?) les références de tableaux du côté droit.

de l'éphémère m'a rappelé que les parenthèses sont également utilisées pour les sous-ensembles. Et qu'elles sont utilisées pour créer des tableaux.

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

Answer 2

1. Une seule parenthèse ( [ ) appelle en fait un programme nommé [ ; man test ou man [ pour plus d'informations. Exemple :

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

2. La double parenthèse ( [[ ) fait la même chose (en gros) qu'un simple crochet, mais c'est un buildin de bash.

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

3. Parenthèses ( () ) sont utilisés pour créer un sous-shell. Par exemple :

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

   Comme vous pouvez le constater, le sous-shell vous permet d'effectuer des opérations sans affecter l'environnement du shell actuel.

4. (a) Les accolades ( {} ) sont utilisés pour identifier sans ambiguïté les variables. Exemple :

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

   (b) Les accolades sont également utilisées pour exécuter une séquence de commandes dans le programme actuel contexte de l'obus, par exemple

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

Il y a une différence syntaxique subtile avec ( ) Cependant, (voir référence bash ) ; essentiellement, un point-virgule ; après la dernière commande entre accolades est indispensable, et les accolades { , } doit être entouré d'espaces.

Answer 3

Supports

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

Bretelles bouclées

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

Parenthèses

( 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 

Parenthèses doubles

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

Je voulais juste ajouter ceci 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

Answer 5

Parenthèses dans la définition de la fonction

Parenthèses () sont utilisés dans la définition des fonctions :

function_name () { command1 ; command2 ; }

C'est la raison pour laquelle vous devez échapper aux parenthèses même dans les paramètres de commande :

$ echo (
bash: syntax error near unexpected token `newline'

$ echo \(
(

$ echo () { command echo The command echo was redefined. ; }
$ echo anything
The command echo was redefined.