14.5. Variables locales à une fonction

Par défaut, une variable définie à l’intérieur d’une fonction est globale ; cela signifie qu’elle est directement modifiable par les autres fonctions du programme shell.

Dans le programme shell glob, la fonction fUn est appelée en premier. Celle-ci crée et initialise la variable var. Puis la fonction fDeux est appelée et modifie la variable (globale) var. Enfin, cette variable est à nouveau modifiée puis sa valeur est affichée.

glob
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	#!/bin/bash

	function fUn
	{
	var=Un             # creation de la variable var
	}

	function fDeux
	{
	var=${var}Deux     # premiere modification de var
	}

	fUn
	fDeux
	var=${var}Princ    # deuxieme modification de var

	echo $var
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

$ glob
UnDeuxPrinc    => trace des modifications successives de la variable globale var
$

Pour définir une variable locale à une fonction, on utilise la commande interne local. Sa syntaxe est :

local [option(s)] [nom[=valeur] ... ]

Les options utilisables avec local sont celles de la commande interne declare. Par conséquent, on définira une ou plusieurs variables de type entier avec la syntaxe local –i (mais aussi local –a pour un tableau classique, local –A pour un tableau associatif).

Le programme shell loc définit une variable entière a locale à la fonction f1. Cette variable n’est pas accessible à l’extérieur de cette fonction.

loc
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	#!/bin/bash

	function f1
	{
	local -i a=12               => a est une variable locale à f1
	(( a++ ))
	echo "-- Dans f1 : a  = $a"
	}

	f1
	echo "Dans main : a  = $a" => tentative d’accès à la valeur de a
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

$ loc
-- Dans f1 : a  = 13
Dans main : a  =      => a n’est pas visible dans le corps du programme
$

La portée d'une variable locale inclut la fonction qui l'a définie ainsi que les fonctions qu'elle appelle (directement ou indirectement).

Dans le programme shell appelsCascade, la variable locale x est vue :

appelsCascade
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	#!/bin/bash

	function f3
	{
	(( x = -x ))			=>  modification de x définie dans la fonction f1
	echo "f3 : x=$x (modification)"
	}


	function f2
	{
	echo "f2 : $((x+10))"		=>  utilisation de x définie dans la fonction f1
	f3					=>  appel de f3
	}


	function f1
	{
        	local -i x				=>  définition de x

	x=2						=>  initialisation de x
	echo "f1 : x=$x (initialisation)"
	f2      					=>  appel de f2
	echo "f1 : Valeur finale : x=$x"
	}


	f1      				=>  appel de f1
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

$ appelsCascade
f1 : x=2 (initialisation)
f2 : 12
f3 : x=-2 (modification)
f1 : Valeur finale : x=-2
$

La fonction f3 affecte la valeur -2 à la variable x précédemment initialisée à la valeur 2 dans la fonction f1. A la fin de l’exécution de f3, la valeur de x reste égale à -2 dans la fonction initiale f1.