Question Comment utiliser des parenthèses simples ou doubles, des parenthèses, des accolades


Je suis confus par l'utilisation des parenthèses, des parenthèses, des accolades dans Bash, aussi bien que la différence entre leurs formes doubles ou simples. Y a-t-il une explication claire?


563
2018-02-02 22:22


origine


Réponses:


Dans Bash, test et [ sont des builtins.

le double support permet des 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 =~.

Les accolades, en plus de délimiter un nom de variable sont utilisés pour expansion de paramètre donc vous pouvez faire des choses comme:

  • Tronquer le contenu d'une variable

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

  • Faire 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

En outre, les expansions d'accolades créent des listes de chaînes qui sont généralement itérées dans les 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 Zéro et Incrémentation principales n'étaient pas disponibles avant Bash 4.

Merci à gboffi de me rappeler les expansions de l'orthèse.

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 les signes de dollar sur les variables entières et de tableau et incluent des espaces autour des opérateurs pour la lisibilité.

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

array[4]="hello"

element=${array[index]}

Les accolades sont requises pour les références de tableau (la plupart / toutes?) Sur le côté droit.

éphémère commentaire m'a rappelé que les parenthèses sont également utilisées pour les sous-couches. Et qu'ils sont utilisés pour créer des tableaux.

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

517
2018-02-02 22:48



  1. Un seul support ([) appelle généralement 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. Le double support ([[) fait la même chose (fondamentalement) qu'une seule parenthèse, mais est un bash intégré.

    $ 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 voir, le sous-shell vous a permis d'effectuer des opérations sans affecter l'environnement du shell en cours.

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

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

4b. Les accolades sont également utilisées pour exécuter une séquence de commandes dans le actuel contexte de coque, par ex.

    $ { 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 un must, et les accolades {, }  doit être entouré d'espaces.


289
2018-02-02 22:27



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

Accolades 

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

Double parenthèses 

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



Je voulais juste les ajouter 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 différence entre tester, [ et [[ est expliqué dans les grands détails dans le BashFAQ.

Pour résumer une longue histoire: test implémente l'ancienne syntaxe portable de   la commande. Dans presque tous les coquillages (les plus anciens obus de Bourne sont les   exception), [est un synonyme de test (mais nécessite un argument final de   ]). Bien que toutes les coques modernes aient des implémentations intégrées de [,   il existe généralement toujours un exécutable externe de ce nom, par ex.   /poubelle/[.

[[est une nouvelle version améliorée de celui-ci, qui est un mot-clé, pas un programme.   Cela a des effets bénéfiques sur la facilité d'utilisation, comme indiqué ci-dessous. [[ est   compris par KornShell et BASH (par exemple 2.03), mais pas par le plus ancien   POSIX ou BourneShell.

Et la conclusion:

Quand la nouvelle commande de test [devrait-elle être utilisée, et quand l'ancienne [?   Si la portabilité de BourneShell est une préoccupation, l'ancienne syntaxe   être utilisé. Si d'un autre côté le script nécessite BASH ou KornShell,   la nouvelle syntaxe est beaucoup plus flexible.


17
2017-10-28 09:22



Parenthèses dans la définition de fonction

Parenthèses () sont utilisés dans la définition de la fonction:

function_name () { command1 ; command2 ; }

C'est la raison pour laquelle vous devez échapper des 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.

16
2017-09-09 08:56