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 globale varglob. Puis la fonction fDeux est appelée et modifie la variable varglob. Enfin, cette variable est à nouveau modifiée puis sa valeur est affichée.

	#!/bin/bash
	#	@(#)	glob

	function fUn
	{
	varglob=Un             # creation de la variable globale varglob
	}


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


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

	echo $varglob

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

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

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, local -n pour une variable nameref).

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.

	#!/bin/bash
	#	@(#)	loc

	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’acces à 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 (c.à.d. la "zone" dans laquelle elle est manipulable) 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 x locale à la fonction f1 est vue :

Tour à tour, les fonctions f2 et f3 modifient la valeur de la variable x locale à la fonction f1.

	#!/bin/bash
	#	@(#)	appelscascade


	function f3
	{	
	(( x = -x ))				# modification de x definie dans la fonction f1
	echo "f3 : x=$x (modification)"
	}	


	function f2
	{
	(( x = x+10 ))				# modification de x definie dans la fonction f1
	echo "f2 : x=$x (modification)"	
	f3					# appel de f3
	}


	function f1
	{	
       		local -i x			#  definition 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 : x=12 (modification)
f3 : x=-12 (modification)
f1 : Valeur finale : x=-12
$

La fonction f1 définie et initialise la variable locale x à la valeur 2 puis appelle la fonction f2. La fonction f2 ajoute la valeur 10 à la variable x puis appelle la fonction f3. Cette dernière lui affecte la valeur opposée. Après exécution de f3, la valeur de x est égale à -12 dans la fonction initiale f1.