======Variables chaîne de caractères======

======Retour a la ligne dans une variable======
[[https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html]] \\
l'expression **$'** devant une chaîne permet d'y insérer des caractères d'échappements en les précédents de **\**.
\\
[[https://www.gnu.org/software/bash/manual/html_node/Locale-Translation.html]] \\
l'expression **$"** devant une chaîne convertira les caractères dans leurs forme locale.
<code bash>
TOTO=$"ligne1\nligne2\nligne3\n"
echo -e $TOTO
</code>
<code bash>
ligne1
ligne2
ligne3
</code>

<code bash>
TOTO='ligne1
ligne2
ligne3'
echo ${TOTO%%$'\n'*} 
</code>
<code bash>ligne1</code>
<code bash>
TOTO=$"ligne1\nligne2\nligne3\n"
</code>
<code bash>
echo ${TOTO%%$"\n"*} 
</code>
<code bash>ligne1</code>

=====Récupérer uniquement le nom du répertoire courant sans le chemin absolu=====
<code bash>
resultat=${PWD##*/}
</code>  

=====Longueur d'une variable=====
avec ${#Variable} \\
<code bash>
VAR=azerty 
echo ${#VAR} 
</code>
<code bash>6</code>

=====Nombre éléments d'un tableau=====
avec ${#Tableau[@]}\\
<code bash>
VAR=( un deux trois quatre )
echo ${#VAR[@]}
</code>
<code bash>4</code>

=====Longueur d'un élément d'un tableau====
Les éléments d'un tableau sont numérotés en commençant a 0 pour le 1<sup>er</sup> élément.\\
avec ${#Tableau[n]} \\
<code bash>
VAR=( un deux trois quatre )
echo ${#VAR[2]}
</code>
<code bash>5</code>

=====Renvoi la sous-chaîne a partir du nième caractère =====
Les caractères d'une chaîne sont numérotés en commençant a 0 pour le 1<sup>er</sup> caractère.\\
renvoi la sous chaîne à partir du nième caractère et jusqu’à la fin.\\
Avec ${Chaine:n}\\
<code bash>
VAR=azerty
echo ${VAR:3}
</code>
<code bash>rty</code>

{| border="2" style="text-align: center; font-weight: bold;"
! style="width: 25%"| chaîne caractères ||  a  ||  z  ||  e  ||  r ||  t  ||  y
|-
! numéro de caractère ||  0  ||  1  ||  2  ||  3  ||  4  ||  5  
|-
! résultat            ||     ||     ||     ||  r   ||  t  ||  y
|}
\\

=====Extraire une sous-chaîne de caractères en partant du début=====
Les caractères d'une chaîne sont numérotés en commençant a 0 pour le 1er caractère.\\
avec ${Chaîne:début:longueur} \\
début=3\\
longueur=4\\
{| border="2" style="text-align: center; font-weight: bold;"
! style="width: 25%"| chaine caracteres || a || z || e || r || t || y || u || i || o || p
|-
! numero de caractère || 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9
|-
!decompte de la longueur || - || - || - || 1 || 2 || 3 || 4 || - || - || -
|-
!  résultat              ||   ||   ||   || r || t || y || u ||   ||   ||
|}
<code bash>
VAR=azertyuiop
echo ${VAR:3:4}
</code>
<code bash>rtyu</code>

=====Extraire une sous-chaîne de caractères en partant de la fin=====
Les éléments d'une chaîne peuvent être numéroté en commençant par le dernier caractère. Dans ce cas, on compte en nombre négatif en commençant par le dernier caractère à (-1)\\
Dernier caractère à (-1).\\
Avant dernier caractère à (-2).\\
...\\
avec ${Chaîne:(-début):longueur} \\
(-début)=(-8)\\
longueur=5\\
{| border="2" style="text-align: center; font-weight: bold;"
! style="width: 25%"| chaine caracteres || a || z || e || r || t || y || u || i || o || p
|-
! numero de caractère || -10 || -9 || -8 || -7 || -6 || -5 || -4 || -3 || -2 || -1
|-
!decompte de la longueur || - || - || 1 || 2 || 3 || 4 || 5 || - || - || -
|-
!résultat                ||   ||   ||  e || r || t || y || u ||   ||   ||
|}
<code bash>
VAR=azertyuiop
echo ${VAR:(-8):5}
</code>
<code bash>ertyu</code>

=====Suppression de la plus courte chaîne recherché, en partant du début=====


{| border="2" style="text-align: center; font-weight: bold;"
! style="width: 25%"| chaine caractères || a || z || e || r || E || c || h || e || r || c || h || e || t || y || U 
|-
! recherche et suppression || - || - || - || r || E || c || h || e || r || c || h || e || - || - || -
|-
! résultat ||  a || z  || e ||  ||  ||  ||  ||   ||   ||  ||  ||  || t || y || U
|}

\\
<code bash>
VAR=azerEcherchetyu
${VAR#rEcherche}
</code>

<code bash>
azetyU
</code>

\\
le caractère "*" est un caractère générique qui remplace 1 ou plusieurs caractères differents.
\\

<code bash>
VAR=AZERTYUIOPQSD
echo ${VAR#A*R}		# A*R correspond ici a AZER
</code>

<code bash>
TYUIOPQSD
</code>

\\
[AB] signifie le caractère A ou le caractère B\\
[AB[AB][AB][AB] signifie 4 caractères ( A ou B) qui se suivent
\\
<code bash>
VAR=ABABAB_TOTO
echo ${VAR#[AB][AB][AB][AB]}
</code>
<code bash>
AB_TOTO
</code>
\\

=====Suppression de la plus longue chaine, a partir du début=====

<code bash>
VAR=ABCABC123ABCabc
echo ${VAR##A*C}
</code>
<code bash>
abc
</code>

=====suppression de la plus courte chaîne en partant de la fin=====

<code bash>
VAR=abcABC123ABCabc
echo ${VAR%b*c}	
</code>
<code bash>
abcABC123ABCa
</code>

=====Suppression de la plus longue chaîne en partant de la fin=====
<nowiki>
${VAR%%recherche}:
</nowiki>
\\
<code bash>
VAR=abcABC123ABCabc
echo ${VAR%%b*c}
</code>
<code bash>
a
</code>

=====Chercher et remplacer une sous-chaîne dans une variable=====

Il y a 2 possibilités: la première occurrence ou toutes les occurrences:
<code bash>
${VAR/recherche/remplacé par}	# première occurrence
${VAR//recherche/remplacé par}	# toutes les occurrences
</code>
\\
Dans tous les cas, c'est la sous-chaîne la plus grande correspondant à "recherche" qui sera remplacée. \\
<code bash>
VAR=abcABC123ABCabc
echo ${VAR/b*c/Z}
</code>
<code bash>
aZ
</code>

=====Chercher et remplacer la première sous-chaîne d'une variable=====
<code bash>
VAR=abcABC123ABCabc
echo ${VAR/#abc/---}	
</code>
<code bash>
---ABC123ABCabc
</code>

=====chercher et remplacer dernière sous-chaîne d'une variable=====
<code bash>
VAR=abcABC123ABCabc
echo ${VAR/%abc/---}	
</code>
<code bash>
abcABC123ABC---
</code>

=====Renvoyer une chaîne lorsque la variable est non définie=====
Cette syntaxe ne défini pas ou ne modifie pas la valeur de VAR.\\
si VAR est défini (avec une valeur ou avec nulle), on retourne sa valeur, y compris nulle, sinon, si VAR est indéfini, on retourne la chaîne choisi, ici "défaut", sans définir la variable\\
<code bash>
unset VAR                # on supprime VAR si elle existe
echo ${VAR-défaut}	
defaut
echo ${VAR}
   # vide
</code>
Mais si la variable a été déclaré (même sans contenu)\\
<code bash>
declare VAR  # ou declare VAR=""   => VAR existe, mais est nulle
echo ${VAR-défaut}
   # vide
</code>
=====Renvoyer une chaîne lorsque la variable est non définie ou nulle=====
Cette syntaxe ne défini pas ou ne modifie pas la valeur de VAR.\\
Pour retourner une valeur (ici une chaîne: defaut) a une variable indéfinie ou nulle, on peut utiliser la syntaxe :\\
 **${VAR:-defaut}**.\\
<code bash>
declare VAR="" # ou unset VAR, ou declare VAR  
echo ${VAR:-defaut}
</code>
<code bash>
valeur_par_defaut
</code>

=====Définir une variable uniquement si elle est indéfinie=====
définir VAR si elle est indéfinie avec ${VAR=Chaîne}
<code bash>
unset VAR			# VAR n'est pas défini
echo ${VAR=valeur_par_defaut}	
valeur_par_defaut
echo ${VAR}
valeur_par_defaut
</code>
\\
=====Définir une variable uniquement si elle est indéfinie ou nulle=====
définir VAR lorsqu'elle est nulle ou indefinie avec ${VAR:=Chaîne} \\
<code bash>
VAR= 		                       # défini VAR a nulle
echo ${VAR:=valeur_par_defaut}	
valeur_par_defaut
</code>
<code bash>
unset VAR		               # indéfinir VAR
echo ${VAR:=valeur_par_defaut}	
valeur_par_defaut
</code>
\\

=====retourner une chaîne si une variable est définie=====
<code bash>
unset VAR
echo echo ${VAR+autre_valeur}
</code>
résultat:
<code bash>
# vide
</code>
<code bash>
VAR=valeur_1
echo ${VAR+autre_valeur}
</code>
résultat:
<code bash>
autre_valeur
</code>
<code bash>
VAR=				# vide
echo ${VAR+autre_valeur}	
</code>
resultat:
<code bash>
autre_valeur
</code>
=====retourner une chaîne si une variable est non vide=====
<code bash>
VAR=
echo ${VAR:+autre_valeur}	
</code>
resultat:
<code bash>
   # vide
</code>
<code bash>
VAR=TOTO
echo ${VAR:+autre_valeur}	
</code>
resultat:
<code bash>
TOTO
</code>
=====message d'erreur si une variable est indéfini=====
le message est renvoyé sur la sortie d'erreurs standard **stderr** avec un **code retour 1**.
<code bash>
unset TOTO			# TOTO n'est pas définie
echo ${TOTO?pas définie}		
-bash: TOTO: pas définie	# message sur stderr
echo $?
1
TOTO=                           # TOTO est définie mais vide = nulle
echo ${TOTO?pas definie}	
   # vide, valeur nulle autorisée
echo $?
0
</code>
=====message d'erreur si une variable est nulle ou indéfini=====
<code bash>
TOTO=""
echo ${TOTO:?valeur nulle}	
-bash: TOTO: valeur nulle #sortie sur stderr
unset TOTO
echo ${TOTO:?indefine}	
-bash: TOTO: indefine     #sortie sur stderr
</code>

=====Conversion en minuscule=====
<code bash>
x="TOTO"
echo ${x,,}
toto
</code>
Si la chaîne est déjà en minuscule, pas de modification.

=====Conversion en minuscule d'une lettre de la chaîne=====
<code bash>
x="TOTO EST DANS LA CUISINE"
echo ${x,,O}
ToTo EST DANS LA CUISINE
</code>

=====Conversion en minuscule de plusieurs lettres de la chaîne=====
<code bash>
x="TOTO EST DANS LA CUISINE"
echo ${x,,[OTAU]}
toto ESt DaNS La CuISINE

#ou pour un intervalle
echo ${x,,[A-N]}
TOTO eST danS la cUiSine

#ou pour plusieurs intervalles
echo ${x,,[A-EN-RS-Z]}
toto est dans La cuIsIne
</code>
=====Conversion en majuscule=====
<code bash>
x="TOTO"
echo ${x^^}
toto
</code>
Si la chaîne est déjà en majuscule, pas de modification.

=====Premier caractère en majuscule=====
<code bash>
x="toto"
echo ${x^}
Toto
</code>
si le 1e caractère est déjà en majuscule, pas de modification.

=====Premier caractère en minuscule=====
<code bash>
x="ToTo est Dans lA cUisInE"
echo ${x,}
toTo est Dans lA cUisInE
</code>
si le 1e caractère est déjà en minuscule, pas de modification.

=====Inverse la case de la chaîne=====
<code bash>
x="ToTo est Dans lA cUisInE"
echo ${x~~}
tOtO EST dANS La CuISiNe
</code>

=====Inverse la case du 1e caractère, et ne modifie pas les autres=====
<code bash>
x="ToTo est Dans lA cUisInE"
echo ${x~}
toTo est Dans lA cUisInE
</code>