Travailler avec des variables sous Linux

Un grand nombre de valeurs importantes sont stockées sur les systèmes Linux dans ce que nous appelons des «variables», mais il existe en fait plusieurs types de variables et quelques commandes intéressantes qui peuvent vous aider à les utiliser. Dans un article précédent, nous avons examiné les variables d'environnement et où elles sont définies. Dans cet article, nous allons examiner les variables utilisées sur la ligne de commande et dans les scripts.

Variables utilisateur

Bien qu'il soit assez facile de configurer une variable sur la ligne de commande, il existe quelques astuces intéressantes. Pour configurer une variable, tout ce que vous devez faire est quelque chose comme ceci:

$ myvar = 11 $ myvar2 = "onze" 

Pour afficher les valeurs, il vous suffit de faire ceci:

$ echo $ myvar 11 $ echo $ myvar2 onze 

Vous pouvez également travailler avec vos variables. Par exemple, pour incrémenter une variable numérique, vous pouvez utiliser l'une de ces commandes:

$ myvar = $ ((myvar + 1)) $ echo $ myvar 12 $ ((myvar = myvar + 1)) $ echo $ myvar 13 $ ((myvar + = 1)) $ echo $ myvar 14 $ ((myvar ++)) $ echo $ myvar 15 $ let "myvar = myvar + 1" $ echo $ myvar 16 $ let "myvar + = 1" $ echo $ myvar 17 $ let "myvar ++" $ echo $ myvar 18 

Avec certains d'entre eux, vous pouvez ajouter plus de 1 à la valeur d'une variable. Par exemple:

$ myvar0 = 0 $ ((myvar0 ++)) $ echo $ myvar0 1 $ ((myvar0 + = 10)) $ echo $ myvar0 11 

Avec tous ces choix, vous en trouverez probablement au moins un qui est facile à retenir et pratique à utiliser.

Vous pouvez également désarmé une variable - essentiellement la définir.

$ unset myvar $ echo $ myvar 

Une autre option intéressante est que vous pouvez configurer une variable et la faire lecture seulement. En d'autres termes, une fois définie en lecture seule, sa valeur ne peut pas être modifiée (du moins pas sans une certaine magie de ligne de commande très délicate). Cela signifie que vous ne pouvez pas non plus le désactiver.

$ readonly myvar3 = 1 $ echo $ myvar3 1 $ ((myvar3 ++)) -bash: myvar3: variable en lecture seule $ unset myvar3 -bash: unset: myvar3: ne peut pas désinstaller: variable readonly 

Vous pouvez utiliser n'importe laquelle de ces options de réglage et d'incrémentation pour attribuer et manipuler des variables dans les scripts, mais il y en a aussi très utiles variables internes pour travailler dans des scripts. Notez que vous ne pouvez pas réaffecter leurs valeurs ou les incrémenter.

Variables internes

De nombreuses variables peuvent être utilisées dans les scripts pour évaluer les arguments et afficher des informations sur le script lui-même.

  • $ 1, $ 2, $ 3 etc. représentent les premier, deuxième, troisième, etc. arguments du script.
  • $ # représente le nombre d'arguments.
  • $ * représente la chaîne d'arguments.
  • $ 0 représente le nom du script lui-même.
  • $? représente le code retour de la commande précédemment exécutée (0 = succès).
  • $$ affiche l'ID de processus pour le script.
  • $ PPID affiche l'ID de processus pour votre shell (le processus parent pour le script).

Certaines de ces variables fonctionnent également sur la ligne de commande mais affichent des informations connexes:

  • $ 0 affiche le nom du shell que vous utilisez (par exemple, -bash).
  • $$ affiche l'ID de processus pour votre shell.
  • $ PPID affiche l'ID de processus pour le processus parent de votre shell (pour moi, c'est sshd).

Si nous jetons toutes ces variables dans un script juste pour voir les résultats, nous pouvons le faire:

#! / bin / bash echo $ 0 echo $ 1 echo $ 2 echo $ # echo $ * echo $? echo $$ echo $ PPID 

Lorsque nous appelons ce script, nous verrons quelque chose comme ceci:

$ tryme un deux trois / home / shs / ​​bin / tryme <== script name one <== first argument two <== second argument 3 <== number of arguments one two three <== all arguments 0 <== return code from previous echo command 10410 <== script's process ID 10109 <== parent process's ID 

Si nous vérifions l'ID de processus du shell une fois le script exécuté, nous pouvons voir qu'il correspond au PPID affiché dans le script:

$ echo $$ 10109 <== shell's process ID 

Bien sûr, nous sommes plus susceptibles d'utiliser ces variables de manière beaucoup plus utile que de simplement afficher leurs valeurs. Voyons quelques façons de le faire.

Vérification pour voir si des arguments ont été fournis:

if [$ # == 0]; puis faites écho à "$ 0 filename" exit 1 fi 

Vérification pour voir si un processus particulier est en cours d'exécution:

ps -ef | grep apache2> / dev / null si [$? ! = 0]; alors l'écho d'Apache n'exécute pas la sortie fi 

Vérifier qu'un fichier existe avant d'essayer d'y accéder:

if [$ # -lt 2]; puis echo "Usage: $ 0 lines filename" exit 1 fi if [! -f 2 $]; puis echo "Erreur: Fichier $ 2 introuvable" exit 2 else head - $ 1 $ 2 fi 

Et dans ce petit script, nous vérifions si le nombre correct d'arguments a été fourni, si le premier argument est numérique et si le deuxième argument est un fichier existant.

#! / bin / bash if [$ # -lt 2]; echo "Usage: $ 0 lines filename" exit 1 fi if [[$ 1! = [0-9] *]]; echo "Erreur: $ 1 n'est pas numérique" quittez 2 fi si [! -f 2 $]; puis écho "Erreur: fichier $ 2 introuvable" exit 3 sinon écho en haut de la tête du fichier - $ 1 $ 2 fi 

Renommer des variables

Lors de l'écriture d'un script compliqué, il est souvent utile d'attribuer des noms aux arguments du script plutôt que de continuer à y faire référence en tant que $ 1, $ 2, etc. À la 35e ligne, quelqu'un qui lit votre script a peut-être oublié ce que représente 2 $. Ce sera beaucoup plus facile pour cette personne si vous affectez la valeur d'un paramètre important à $ filename ou $ numlines.

#! / bin / bash if [$ # -lt 2]; puis echo "Usage: $ 0 lines filename" exit 1 else numlines = $ 1 filename = $ 2 fi if [[$ numlines! = [0-9] *]]; puis echo "Erreur: $ numlines n'est pas numérique" exit 2 fi si [! -f $ filename]; puis echo "Erreur: Fichier $ nom_fichier introuvable" exit 3 sinon echo en haut de la tête du fichier - $ numlines $ filename fi 

Bien sûr, cet exemple de script ne fait rien de plus que d'exécuter la commande head pour afficher les premières lignes X dans un fichier, mais il est destiné à montrer comment les paramètres internes peuvent être utilisés dans les scripts pour s'assurer que le script fonctionne bien ou échoue avec au moins une certaine clarté.

[Regardez les astuces Linux de deux minutes de Sandra Henry-Stocker pour apprendre à maîtriser une multitude de commandes Linux] Rejoignez les communautés Network World sur Facebook et LinkedIn pour commenter des sujets qui vous tiennent à cœur.