Bash
Extension des paramètres Bash

Introduction

Syntaxe

• $ {paramètre: offset} # Sous-chaîne commençant au décalage
• $ {paramètre: offset: longueur} # Sous-chaîne de longueur "longueur" commençant à l'offset
• $ {# paramètre} # Longueur du paramètre
• $ {parameter / pattern / string} # Remplace la première occurrence du motif par une chaîne
• $ {parameter // pattern / string} # Remplace toutes les occurrences du motif par une chaîne
• $ {paramètre / # modèle / chaîne} # Remplace le motif par une chaîne si le motif est au début
• $ {paramètre /% modèle / chaîne} # Remplace le motif par la chaîne si le motif est à la fin
• $ {parameter # pattern} # Supprime la correspondance la plus courte du pattern depuis le début du paramètre
• $ {parameter ## pattern} # Supprime la correspondance la plus longue du pattern depuis le début du paramètre
• $ {paramètre% pattern} # Supprime la correspondance la plus courte du motif de la fin du paramètre
• $ {paramètre %% pattern} # Supprime la plus longue correspondance du motif de la fin du paramètre
• $ {parameter: -word} # Développez le mot si le paramètre unset / undefined
• $ {parametre: = mot} # Etendre au mot si le paramètre unset / undefined et définir le paramètre
• $ {paramètre: + mot} # Développez en mot si jeu de paramètres / défini

Substrings et sous-réseaux

var='0123456789abcdef'

# Define a zero-based offset
$ printf '%s\n' "${var:3}"
3456789abcdef

# Offset and length of substring
$ printf '%s\n' "${var:3:4}"
3456

# Negative length counts from the end of the string
$ printf '%s\n' "${var:3:-5}"
3456789a

# Negative offset counts from the end
# Needs a space to avoid confusion with ${var:-6}
$ printf '%s\n' "${var: -6}"
abcdef

# Alternative: parentheses
$ printf '%s\n' "${var:(-6)}"
abcdef

# Negative offset and negative length
$ printf '%s\n' "${var: -6:-5}"
a

Les mêmes extensions s'appliquent si le paramètre est un paramètre positionnel ou l' élément d'un tableau en indice :

# Set positional parameter $1
set -- 0123456789abcdef

# Define offset
$ printf '%s\n' "${1:5}"
56789abcdef

# Assign to array element
myarr[0]='0123456789abcdef'

# Define offset and length
$ printf '%s\n' "${myarr[0]:7:3}"
789

Les expansions analogues s'appliquent aux paramètres de position , les décalages étant basés sur une base:

# Set positional parameters $1, $2, ...
$ set -- 1 2 3 4 5 6 7 8 9 0 a b c d e f

# Define an offset (beware $0 (not a positional parameter)
# is being considered here as well)
$ printf '%s\n' "${@:10}"
0
a
b 
c
d
e
f

# Define an offset and a length
$ printf '%s\n' "${@:10:3}"
0
a
b

# No negative lengths allowed for positional parameters
$ printf '%s\n' "${@:10:-2}"
bash: -2: substring expression < 0

# Negative offset counts from the end
# Needs a space to avoid confusion with ${@:-10:2}
$ printf '%s\n' "${@: -10:2}"
7
8

# ${@:0} is $0 which is not otherwise a positional parameters or part
# of $@
$ printf '%s\n' "${@:0:2}"
/usr/bin/bash
1

L'extension de sous-chaîne peut être utilisée avec les tableaux indexés :

# Create array (zero-based indices)
$ myarr=(0 1 2 3 4 5 6 7 8 9 a b c d e f)

# Elements with index 5 and higher
$ printf '%s\n' "${myarr[@]:12}"
c
d
e
f

# 3 elements, starting with index 5
$ printf '%s\n' "${myarr[@]:5:3}"
5
6
7

# The last element of the array
$ printf '%s\n' "${myarr[@]: -1}"
f

Longueur du paramètre

# Length of a string
$ var='12345'
$ echo "${#var}"
5

Notez que c'est la longueur en nombre de caractères qui n'est pas nécessairement la même que le nombre d' octets (comme dans UTF-8 où la plupart des caractères sont encodés dans plus d'un octet), ni le nombre de glyphes / graphèmes combinaisons de caractères), ni nécessairement la même largeur d'affichage.

# Number of array elements
$ myarr=(1 2 3)
$ echo "${#myarr[@]}"
3

# Works for positional parameters as well
$ set -- 1 2 3 4
$ echo "${#@}"
4

# But more commonly (and portably to other shells), one would use
$ echo "$#"
4

Modifier la casse des caractères alphabétiques

$ v="hello"
# Just the first character
$ printf '%s\n' "${v^}"
Hello
# All characters
$ printf '%s\n' "${v^^}"
HELLO
# Alternative
$ v="hello world"
$ declare -u string="$v"
$ echo "$string"
HELLO WORLD

$ v="BYE"
# Just the first character
$ printf '%s\n' "${v,}"
bYE
# All characters
$ printf '%s\n' "${v,,}"
bye
# Alternative
$ v="HELLO WORLD"
$ declare -l string="$v"
$ echo "$string"
hello world

$ v="Hello World"
# All chars
$ echo "${v~~}"
hELLO wORLD
$ echo "${v~}"
# Just the first char
hello World

Paramètre d'indirection

Bash indirection Bash permet d’obtenir la valeur d’une variable dont le nom est contenu dans une autre variable. Exemple de variables:

$ red="the color red"
$ green="the color green"

$ color=red
$ echo "${!color}"
the color red
$ color=green
$ echo "${!color}"
the color green

Quelques exemples supplémentaires illustrant l'utilisation de l'expansion indirecte:

 $ foo=10
 $ x=foo
 $ echo ${x}      #Classic variable print  
 foo  
 
 $ foo=10
 $ x=foo
 $ echo ${!x}     #Indirect expansion
 10

Un autre exemple:

$ argtester () { for (( i=1; i<="$#"; i++ )); do echo "${i}";done; }; argtester -ab -cd -ef 
1   #i expanded to 1 
2   #i expanded to 2
3   #i expanded to 3

$ argtester () { for (( i=1; i<="$#"; i++ )); do echo "${!i}";done; }; argtester -ab -cd -ef 
-ab     # i=1 --> expanded to $1 ---> expanded to first argument sent to function
-cd     # i=2 --> expanded to $2 ---> expanded to second argument sent to function
-ef     # i=3 --> expanded to $3 ---> expanded to third argument sent to function

Substitution de valeur par défaut

${parameter:-word}

Si le paramètre n'est pas défini ou nul, l'expansion du mot est substituée. Sinon, la valeur du paramètre est substituée.

$ unset var
$ echo "${var:-XX}"     # Parameter is unset -> expansion XX occurs
XX
$ var=""                # Parameter is null -> expansion XX occurs
$ echo "${var:-XX}"
XX
$ var=23                # Parameter is not null -> original expansion occurs
$ echo "${var:-XX}"
23

${parameter:=word}

Si le paramètre est non défini ou nul, l'expansion du mot est affectée au paramètre. La valeur du paramètre est alors substituée. Les paramètres de position et les paramètres spéciaux ne peuvent pas être affectés de cette manière.

$ unset var
$ echo "${var:=XX}"     # Parameter is unset -> word is assigned to XX
XX
$ echo "$var"
XX
$ var=""                # Parameter is null -> word is assigned to XX
$ echo "${var:=XX}"
XX
$ echo "$var"
XX
$ var=23                # Parameter is not null -> no assignment occurs
$ echo "${var:=XX}"
23
$ echo "$var"
23

Erreur si la variable est vide ou non définie

La sémantique de cette méthode est similaire à celle de la substitution de valeur par défaut, mais au lieu de remplacer une valeur par défaut, elle génère une erreur avec le message d'erreur fourni. Les formulaires sont ${VARNAME?ERRMSG} et ${VARNAME:?ERRMSG} . La forme avec : va erreur notre si la variable est non définie ou vide , alors que la forme sans sera seulement une erreur si la variable n'est pas définie . Si une erreur est ERRMSG , le ERRMSG est ERRMSG et le code de sortie est défini sur 1 .

#!/bin/bash
FOO=
# ./script.sh: line 4: FOO: EMPTY
echo "FOO is ${FOO:?EMPTY}"
# FOO is 
echo "FOO is ${FOO?UNSET}"
# ./script.sh: line 8: BAR: EMPTY
echo "BAR is ${BAR:?EMPTY}"
# ./script.sh: line 10: BAR: UNSET
echo "BAR is ${BAR?UNSET}"

L'exécution de l'exemple complet au-dessus de chacune des instructions d'écho erronées doit être commentée pour continuer.

Supprimer un motif du début d'une chaîne

Match le plus court:

$ a='I am a string'
$ echo "${a#*a}"
m a string

Match le plus long:

$ echo "${a##*a}"
 string

Supprimer un motif à la fin d'une chaîne

Match le plus court:

$ a='I am a string'
$ echo "${a%a*}"
I am 

Match le plus long:

$ echo "${a%%a*}"
I 

Remplacer le motif dans la chaîne

Premier match:

$ a='I am a string'
$ echo "${a/a/A}"
I Am a string

Tous les matches:

$ echo "${a//a/A}"
I Am A string

Match au début:

$ echo "${a/#I/y}"
y am a string

Match à la fin:

$ echo "${a/%g/N}"
I am a strinN

Remplacez un motif par rien:

$ echo "${a/g/}"
I am a strin

Ajouter un préfixe aux éléments du tableau:

$ A=(hello world)
$ echo "${A[@]/#/R}"
Rhello Rworld

Munging pendant l'expansion

Les variables ne doivent pas nécessairement être étendues à leurs valeurs - les sous-chaînes peuvent être extraites lors de l’extension, ce qui peut être utile pour extraire des extensions de fichiers ou des parties de chemins. Les personnages qui retentissent gardent leurs significations habituelles, donc .* Se réfère à un point littéral, suivi de toute séquence de caractères; ce n'est pas une expression régulière.

$ v=foo-bar-baz
$ echo ${v%%-*}
foo
$ echo ${v%-*}
foo-bar
$ echo ${v##*-}
baz
$ echo ${v#*-}
bar-baz

Il est également possible de développer une variable en utilisant une valeur par défaut - disons que je veux appeler l'éditeur de l'utilisateur, mais si je n'en ai pas défini un, je voudrais lui donner vim .

$ EDITOR=nano
$ ${EDITOR:-vim} /tmp/some_file
# opens nano
$ unset EDITOR
$ $ ${EDITOR:-vim} /tmp/some_file
# opens vim

Il existe deux manières différentes d'effectuer cette expansion, qui diffèrent selon que la variable concernée est vide ou non définie. Utiliser :- utilisera la valeur par défaut si la variable est non définie ou vide, alors que - utilise uniquement la valeur par défaut si la variable est désactivée, mais utilisera la variable si elle est définie sur la chaîne vide:

$ a="set"
$ b=""
$ unset c
$ echo ${a:-default_a} ${b:-default_b} ${c:-default_c}
set default_b default_c
$ echo ${a-default_a} ${b-default_b} ${c-default_c}
set default_c

Semblable aux défauts, des alternatives peuvent être données; Lorsqu'une valeur par défaut est utilisée si une variable particulière n'est pas disponible, une alternative est utilisée si la variable est disponible.

$ a="set"
$ b=""
$ echo ${a:+alternative_a} ${b:+alternative_b}
alternative_a

Notant que ces extensions peuvent être imbriquées, l'utilisation d'alternatives devient particulièrement utile lorsque vous fournissez des arguments aux indicateurs de ligne de commande;

$ output_file=/tmp/foo
$ wget ${output_file:+"-o ${output_file}"} www.stackexchange.com
# expands to wget -o /tmp/foo www.stackexchange.com
$ unset output_file
$ wget ${output_file:+"-o ${output_file}"} www.stackexchange.com
# expands to wget  www.stackexchange.com 

Extension de paramètres et noms de fichiers

Vous pouvez utiliser Bash Parameter Expansion pour émuler des opérations courantes de traitement de noms de fichiers telles que basename et dirname .

Nous utiliserons ceci comme notre exemple de chemin:

FILENAME="/tmp/example/myfile.txt"

Pour émuler dirname et renvoyer le nom de répertoire d'un chemin de fichier:

echo "${FILENAME%/*}"
#Out: /tmp/example

Pour émuler le basename $FILENAME et renvoyer le nom de fichier d'un chemin de fichier:

echo "${FILENAME##*/}"
#Out: myfile.txt

Pour émuler le basename $FILENAME .txt et renvoyer le nom de fichier sans le .txt. extension:

BASENAME="${FILENAME##*/}"
echo "${BASENAME%%.txt}"
#Out: myfile