Bash
Variables internes

Introduction

Bash variables internes en un coup d'œil

Variable	Détails
$* / $@	Paramètres de position / script (arguments). Développez comme suit: $* et $@ sont les mêmes que $1 $2 ... (notez que cela n'a généralement aucun sens de laisser ceux qui ne sont pas cotés) "$*" est identique à "$1 $2 ..." 1 "$@" est identique à "$1" "$2" ... 1. Les arguments sont séparés par le premier caractère de $ IFS, qui ne doit pas nécessairement être un espace.
$#	Nombre de paramètres de position transmis au script ou à la fonction
$!	ID de processus de la dernière commande (la plus proche des pipelines) dans le dernier travail mis en arrière-plan (notez que ce n'est pas nécessairement la même que l'ID de groupe de processus du travail lorsque le contrôle des travaux est activé)
$$	ID du processus qui a exécuté bash
$?	Etat de sortie de la dernière commande
$n	Paramètres de position, où n = 1, 2, 3, ..., 9
${n}	Paramètres de position (comme ci-dessus), mais n peut être> 9
$0	Dans les scripts, chemin d'accès au script; avec bash -c 'printf "%s\n" "$0"' name args' : name (le premier argument après le script en ligne), sinon, l' argv[0] reçu par bash .
$_	Dernier champ de la dernière commande
$IFS	Séparateur de champ interne
$PATH	Variable d'environnement PATH utilisée pour rechercher des exécutables
$OLDPWD	Répertoire de travail précédent
$PWD	Répertoire de travail actuel
$FUNCNAME	Tableau de noms de fonctions dans la pile des appels d'exécution
$BASH_SOURCE	Tableau contenant les chemins source pour les éléments du tableau FUNCNAME . Peut être utilisé pour obtenir le chemin du script.
$BASH_ALIASES	Tableau associatif contenant tous les alias actuellement définis
$BASH_REMATCH	Tableau de correspondances du dernier match de regex
$BASH_VERSION	Version de la version Bash
$BASH_VERSINFO	Un tableau de 6 éléments avec des informations sur la version de Bash
$BASH	Chemin absolu vers le shell Bash en cours d'exécution lui-même (déterminé bash par bash sur la base de argv[0] et la valeur de $PATH ; peut être erroné dans les cas de coin)
$BASH_SUBSHELL	Niveau Bash subshell
$UID	Réel (pas efficace si différent) ID utilisateur du processus exécutant bash
$PS1	Invite de ligne de commande principale; voir Utilisation des variables PS *
$PS2	Invite de ligne de commande secondaire (utilisée pour une entrée supplémentaire)
$PS3	Invite de ligne de commande tertiaire (utilisé dans la boucle de sélection)
$PS4	Invite de ligne de commande quaternaire (utilisée pour ajouter des informations avec une sortie détaillée)
$RANDOM	Un entier pseudo-aléatoire compris entre 0 et 32767
$REPLY	Variable utilisée par read par défaut lorsqu'aucune variable n'est spécifiée. Également utilisé par select pour renvoyer la valeur fournie par l'utilisateur
$PIPESTATUS	Variable de tableau contenant les valeurs de statut de sortie de chaque commande dans le pipeline de premier plan le plus récemment exécuté.

L'attribution de variables ne doit pas avoir d'espace avant et après. a=123 pas a = 123 . Ce dernier (un signe égal entouré par des espaces) de manière isolée signifie exécuter la commande a avec les arguments = et 123 , mais il est également visible dans l'opérateur de comparaison de chaîne (qui est syntaxiquement un argument [ ou [[ ou tout autre test que vous êtes en utilisant).

$ BASHPID

ID de processus (pid) de l'instance actuelle de Bash. Ce n'est pas la même que la variable $$ , mais cela donne souvent le même résultat. Ceci est nouveau dans Bash 4 et ne fonctionne pas dans Bash 3.

~> $ echo "\$\$ pid = $$  BASHPID = $BASHPID"
$$ pid = 9265  BASHPID = 9265

$ BASH_ENV

Une variable d'environnement pointant vers le fichier de démarrage Bash qui est lu lors de l'appel d'un script.

$ BASH_VERSINFO

Un tableau contenant les informations complètes sur la version est divisé en éléments, bien plus pratique que $BASH_VERSION si vous recherchez uniquement la version principale:

~> $ for ((i=0; i<=5; i++)); do echo "BASH_VERSINFO[$i] = ${BASH_VERSINFO[$i]}"; done
BASH_VERSINFO[0] = 3
BASH_VERSINFO[1] = 2
BASH_VERSINFO[2] = 25
BASH_VERSINFO[3] = 1
BASH_VERSINFO[4] = release
BASH_VERSINFO[5] = x86_64-redhat-linux-gnu

$ BASH_VERSION

Affiche la version de bash en cours d'exécution, ce qui vous permet de décider si vous pouvez utiliser des fonctionnalités avancées:

~> $ echo $BASH_VERSION
4.1.2(1)-release

$ EDITEUR

L'éditeur par défaut qui sera impliqué par tous les scripts ou programmes, généralement vi ou emacs.

~> $ echo $EDITOR
vi

$ FUNCNAME

Pour obtenir le nom de la fonction en cours - tapez:

my_function()
{
    echo "This function is $FUNCNAME"    # This will output "This function is my_function"
}

Cette instruction ne renverra rien si vous le tapez en dehors de la fonction:

my_function

echo "This function is $FUNCNAME"    # This will output "This function is"

$ HOME

Le répertoire de base de l'utilisateur

~> $ echo $HOME
/home/user

$ HOSTNAME

Le nom d'hôte attribué au système lors du démarrage.

~> $ echo $HOSTNAME
mybox.mydomain.com

$ HOSTTYPE

Cette variable identifie le matériel, il peut être utile pour déterminer quels binaires exécuter:

~> $ echo $HOSTTYPE
x86_64

$ GROUPES

Un tableau contenant les nombres de groupes dans lesquels se trouve l'utilisateur:

#!/usr/bin/env bash
echo You are assigned to the following groups:
for group in ${GROUPS[@]}; do
   IFS=: read -r name dummy number members < <(getent group $group )
   printf "name: %-10s number: %-15s members: %s\n" "$name" "$number" "$members" 
done

$ IFS

Contient la chaîne séparateur de champ interne que bash utilise pour diviser les chaînes lors de la boucle , etc. La valeur par défaut est les caractères blancs: \n (saut de ligne), \t (onglet) et dans l' espace. Changer cela en quelque chose d'autre vous permet de diviser les chaînes en utilisant des caractères différents:

IFS=","
INPUTSTR="a,b,c,d"
for field in ${INPUTSTR}; do
    echo $field
done 

Le résultat de ce qui précède est:

a
b
c
d

Remarques:

• Ceci est responsable du phénomène connu sous le nom de fractionnement de mots .

$ LINENO

Affiche le numéro de ligne dans le script en cours. Surtout utile lors du débogage de scripts.

#!/bin/bash
# this is line 2
echo something  # this is line 3
echo $LINENO # Will output 4

$ MACHTYPE

Semblable à $HOSTTYPE ci-dessus, cela inclut également des informations sur le système d'exploitation ainsi que sur le matériel

~> $ echo $MACHTYPE
x86_64-redhat-linux-gnu

$ OLDPWD

OLDPWD (OLDP Rint W ravailler D irectory) contient le répertoire avant le dernier cd commande:

~> $ cd directory
directory> $ echo $OLDPWD
/home/user

$ OSTYPE

Renvoie des informations sur le type de système d'exploitation exécuté sur la machine, par exemple.

~> $ echo $OSTYPE
linux-gnu

$ PATH

Le chemin de recherche pour trouver des binaires pour les commandes. Les exemples courants incluent /usr/bin et /usr/local/bin .

Lorsqu'un utilisateur ou un script tente d'exécuter une commande, les chemins dans $PATH sont recherchés afin de trouver un fichier correspondant avec une autorisation d'exécution.

Les répertoires de $PATH sont séparés par un : caractère.

~> $ echo "$PATH"
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin

Par exemple, si vous tapez $PATH ci-dessus, si vous tapez lss à l'invite, le shell recherchera /usr/kerberos/bin/lss , puis /usr/local/bin/lss , puis /bin/lss , puis /usr/bin/lss , dans cet ordre, avant de conclure qu’il n’ya pas une telle commande.

$ PPID

L'ID de processus (pid) du script ou du parent du shell, c'est-à-dire le processus qui a appelé le script ou le shell en cours.

~> $ echo $$
13016
~> $ echo $PPID
13015

$ PWD

PWD (P Rint T ravail D irectory) Le répertoire de travail actuel , vous êtes en ce moment:

~> $ echo $PWD
/home/user
~> $ cd directory
directory> $ echo $PWD
/home/user/directory

$ SECONDS

Nombre de secondes pendant lesquelles un script a été exécuté. Cela peut devenir assez grand si montré dans le shell:

~> $ echo $SECONDS
98834

$ SHELLOPTS

Une liste en lecture seule des options bash est fournie au démarrage pour contrôler son comportement:

~> $ echo $SHELLOPTS
braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor

$ SHLVL

Lorsque la commande bash est exécutée, un nouveau shell est ouvert. La variable d'environnement $ SHLVL contient le nombre de niveaux de shell exécutés par le shell actuel .

Dans une nouvelle fenêtre de terminal, l'exécution de la commande suivante produira des résultats différents en fonction de la distribution Linux utilisée.

echo $SHLVL

En utilisant Fedora 25 , le résultat est "3". Cela indique que lors de l'ouverture d'un nouveau shell, une commande bash initiale s'exécute et exécute une tâche. La commande initiale bash exécute un processus enfant (une autre commande bash) qui, à son tour, exécute une dernière commande bash pour ouvrir le nouveau shell. Lorsque le nouveau shell s'ouvre, il s'exécute en tant que processus enfant de 2 autres processus shell, d'où la sortie de "3".

Dans l'exemple suivant (étant donné que l'utilisateur exécute Fedora 25), la sortie de $ SHLVL dans un nouveau shell sera définie sur "3". Comme chaque commande bash est exécutée, $ SHLVL s'incrémente d'une unité.

~> $ echo $SHLVL
3
~> $ bash
~> $ echo $SHLVL
4
~> $ bash
~> $ echo $SHLVL
5

On peut voir que l'exécution de la commande 'bash' (ou l'exécution d'un script bash) ouvre un nouveau shell. En comparaison, la recherche d'un script exécute le code dans le shell actuel.

test1.sh

#!/usr/bin/env bash
echo "Hello from test1.sh. My shell level is $SHLVL"
source "test2.sh"

test2.sh

#!/usr/bin/env bash
echo "Hello from test2.sh. My shell level is $SHLVL"

run.sh

#!/usr/bin/env bash
echo "Hello from run.sh. My shell level is $SHLVL"
./test1.sh

Exécuter:

chmod +x test1.sh && chmod +x run.sh
./run.sh

Sortie:

Hello from run.sh. My shell level is 4
Hello from test1.sh. My shell level is 5
Hello from test2.sh. My shell level is 5

$ UID

Une variable en lecture seule qui stocke le numéro d'identification de l'utilisateur:

~> $ echo $UID
12345

1 $ 2 $ 3 $ etc ...

Paramètres de position passés au script à partir de la ligne de commande ou d'une fonction:

#!/bin/bash
# $n is the n'th positional parameter
echo "$1"
echo "$2"
echo "$3"

Le résultat de ce qui précède est:

~> $ ./testscript.sh firstarg secondarg thirdarg
firstarg
secondarg
thirdarg

Si le nombre d'arguments positionnels est supérieur à neuf, des accolades doivent être utilisées.

#  "set -- " sets positional parameters
set -- 1 2 3 4 5 6 7 8 nine ten eleven twelve
# the following line will output 10 not 1 as the value of $1 the digit 1
# will be concatenated with the following 0
echo $10   # outputs 1
echo ${10} # outputs ten
# to show this clearly:
set -- arg{1..12}
echo $10 
echo ${10}

$ #

Pour obtenir le nombre d’arguments en ligne de commande ou de paramètres de position, tapez:

#!/bin/bash
echo "$#"

Lorsqu'il est exécuté avec trois arguments, l'exemple ci-dessus aboutira à la sortie:

~> $ ./testscript.sh firstarg secondarg thirdarg
3

$ *

Renverra tous les paramètres de position dans une seule chaîne.

testscript.sh:

#!/bin/bash
echo "$*"

Exécutez le script avec plusieurs arguments:

./testscript.sh firstarg secondarg thirdarg 

Sortie:

firstarg secondarg thirdarg

$!

L'ID de processus (pid) du dernier travail exécuté en arrière-plan:

~> $ ls &
testfile1 testfile2
[1]+  Done                    ls
~> $ echo $!
21715

$ _

Affiche le dernier champ de la dernière commande exécutée, utile pour faire passer quelque chose à une autre commande:

 ~> $ ls *.sh;echo $_
testscript1.sh  testscript2.sh
testscript2.sh

---

Il donne le chemin du script s'il est utilisé avant toute autre commande:

test.sh:

#!/bin/bash
echo "$_"

Sortie:

~> $ ./test.sh # running test.sh
./test.sh

Note: Ce n'est pas une manière infaillible d'obtenir le chemin du script

$?

Le statut de sortie de la dernière fonction ou commande exécutée. Habituellement, 0 signifie que tout autre élément indique un échec:

~> $ ls *.blah;echo $?
ls: cannot access *.blah: No such file or directory
2
~> $ ls;echo $?
testfile1 testfile2
0

$$

L'ID de processus (pid) du processus en cours:

~> $ echo $$
13246

$ @

"$@" développe en tant que mots séparés pour tous les arguments de la ligne de commande. Il est différent de "$*" , qui étend tous les arguments en un seul mot.

"$@" est particulièrement utile pour une boucle par des arguments et la manipulation des arguments avec des espaces.

Considérons que nous sommes dans un script que nous avons invoqué avec deux arguments, comme ceci:

$ ./script.sh "␣1␣2␣" "␣3␣␣4␣"

---

Les variables $* ou $@ deviendront $1␣$2 , qui à leur tour se développeront en 1 1␣2␣3␣4 pour que la boucle ci-dessous:

for var in $*; do # same for var in $@; do
    echo \<"$var"\>
done

imprimera pour les deux

<1>
<2>
<3>
<4>

---

Alors que "$*" sera étendu à "$1␣$2" qui s'étendra à son tour en "␣1␣2␣␣␣3␣␣4␣" et donc la boucle:

for var in "$*"; do
    echo \<"$var"\>   
done

invoquera seulement l' echo une fois et imprimera

<␣1␣2␣␣␣3␣␣4␣>

---

Et enfin "$@" se développera dans "$1" "$2" , qui se développera dans "␣1␣2␣" "␣3␣␣4␣" et donc la boucle

for var in "$@"; do
    echo \<"$var"\>
done

imprimera

<␣1␣2␣>
<␣3␣␣4␣>

préservant ainsi à la fois l'espacement interne dans les arguments et la séparation des arguments. Notez que la construction for var in "$@"; do ... est tellement commun et idiomatique que c'est la valeur par défaut pour une boucle for et peut être raccourci for var; do ...

$ HISTSIZE

Le nombre maximum de commandes mémorisées:

~> $ echo $HISTSIZE
1000

$ RANDOM

Chaque fois que ce paramètre est référencé, un entier aléatoire compris entre 0 et 32767 est généré. Assigner une valeur à cette variable génère le générateur de nombres aléatoires ( source ).

~> $ echo $RANDOM 
27119
~> $ echo $RANDOM 
1349