Ce sont les variables que les utilisateurs peuvent définir. Le shell étant un langage interprété non typé, aucune déclaration n'est nécessaire et la même variable peut contenir tour à tour une chaîne de caractères, un entier, ou un vecteur (tableau d'éléments de type chaîne de caractères ou entier, indexé par des entiers, commençant à 1).

Affectation. Cette opération permet d'associer un contenu à une variable (le contenant). En csh comme en tcsh, l'affectation se fait en utilisant la commande interne set de la manière suivante :

EXEMPLE :

$ set myvar1 = 10                                                               
$ set myvar2 = "chaine de caractère"
$ 

Accès au contenu. L'accès au contenu de la variable se fait en préfixant le nom de la variable par le symbole $.

EXEMPLE (SUITE) :

$ echo $myvar1                                                                  
10
$ echo $myvar2
chaine de caractère

$ echo myvar1     # omission du méta-caractère $
myvar1            # echo affiche le mot myvar1

On peut aussi encadrer la variable par les symboles { et } avant de la préfixer par le symbole $ :

EXEMPLE (SUITE) :

$ set si  = "pas "                                                              
$ echo "c'est vraiment $sidrôle"
sidrôle: Undefined variable.   # le $ porte ici sur le mot sidrôle et non sur si
$ echo "c'est vraiment ${si}drôle"
c'est vraiment pas drôle
$

Effacer une variable. Cette opération permet de libérer la case mémoire occupée par la variable. Cela se fait en csh comme en tcsh, en utilisant la commande interne unset de la manière suivante :

EXEMPLE (SUITE) :

$ echo $myvar1                                                                  
10
$ unset myvar1
$ echo $myvar1
myvar1: Undefined variable.
$ 

Variable de type vecteur. Voici un exemple :

CODE :

#!/bin/csh
# ~/bin/testvect.sh

set vect = ( 2 -2 4 -4 6 -6 8 -8 10 -10 ) 

# afficher les éléments du vecteur vect, élément par élément                    
set i = 1
set sum = 0
echo " -  Affichage élément par élément"
while ( $i <= ${#vect} ) 
    echo '$vect[' $i '] = ' $vect[$i]
    @ sum = $sum + $vect[$i]
    @ i++
end

echo " - Somme des elements = " $sum

set j = 5
echo "Voici le vecteur vect (${#vect} éléments)         : " $vect[1-]
echo "Voici les $j premiers éléments du vecteur    : " $vect[-$j]
echo "Voici les derniers éléments à partir du $j e : " $vect[$j-]

# fin du script


EXEMPLE :

$ ./testvect.sh                                                                 
 -  Affichage élément par élément
$vect[ 1 ] =  2
$vect[ 2 ] =  -2
$vect[ 3 ] =  4
$vect[ 4 ] =  -4
$vect[ 5 ] =  6
$vect[ 6 ] =  -6
$vect[ 7 ] =  8
$vect[ 8 ] =  -8
$vect[ 9 ] =  10
$vect[ 10 ] =  -10
 - Somme des elements =  0
Voici le vecteur vect (10 éléments)         :  2 -2 4 -4 6 -6 8 -8 10 -10
Voici les 5 premiers éléments du vecteur    :  2 -2 4 -4 6
Voici les derniers éléments à partir du 5 e :  6 -6 8 -8 10 -10

$

Modificateurs de variables. Les modificateurs [modifiers] suivants peuvent être appliqués aux variables. On travaillera avec l'exemple (un vecteur) suivant :

$ set mypath = ( /usr/local/src/foo.c /usr/src/bar.cc )   # un vecteur de path  

$ echo $mypath:h                    
/usr/local/src /usr/src/bar.cc
$ echo $mypath:gh
/usr/local/src /usr/src

$ echo $mypath:t                    
foo.c /usr/src/bar.cc
$ echo $mypath:gt
foo.c bar.cc

$ echo $mypath:r
/usr/local/src/foo /usr/src/bar.cc  
$ echo $mypath:gr
/usr/local/src/foo /usr/src/bar

$ echo $mypath:e                    
c /usr/src/bar.cc
$ echo $mypath:ge
c cc

Mécanismes de substitution. 

$ set v = toto
$ echo ${?v}   # renvoit 1 puisque la variable v est définie        
1
$ echo $u
u: Undefined variable.
$ echo ${?u}   # moyen commode pour savoir si une variable est définie          
0 

Le shell définit pour chaque commande un certain nombre de paramètres « automatiques ».

CODE :

#!/bin/csh
# ~/bin/testparm.sh

echo 'je suis le script, $0 = ' $0

if ( ${#argv} > 0 ) then
    echo ' évoqué avec $# (= $#argv = ${#argv}) = ' ${#argv}  ' arguments sur la
 ligne de commande'
    echo 'Voici les paramètres : $* (= $argv[*] = ${argv[*]}) = ' ${argv[*]}
    set i = 1
    foreach param ( $argv[*] ) 
        echo "paramètre ($i) :  $param"
        @ i++
    end
else
    echo ' pas d arguments, nb arg $# (= $#argv = ${#argv}) = ' ${#argv}
endif

# fin du script


EXEMPLE :

$ ./testparam.sh toto titi tutu 147
je suis le script, $0 =  ./testparam.sh
 évoqué avec $# (= $#argv = ${#argv}) =  4  arguments sur la ligne de commande  
Voici les paramètres : $* (= $argv[*]) =  toto titi tutu 147
paramètre (1) :  toto
paramètre (2) :  titi
paramètre (3) :  tutu
paramètre (4) :  147
$
$ ./testparam.sh
je suis le script, $0 =  ./testparam.sh
 pas d arguments, nb arg $# (= $#argv = ${#argv}) =  0
$

Elle se fait en utilisant la variable spéciale $<

CODE :

#!/bin/csh
# ~/bin/testread.sh                                                             

echo -n " Votre réponse (o, n) ? "
set rep = $<

if ( $rep == o ) then 
   echo "réponse oui"
else
   echo autre réponse : $rep
endif


EXEMPLE :

$ ./testread.sh
Votre réponse (o, n) ? yes
autre réponse : yes

$ ./testread.sh
 Votre réponse (o, n) ? o
réponse oui

Règles :

La commande interne @ permet de réaliser des opérations arithmétiques sur des valeurs ou variables entières, attention à respecter l'espace entre le symbole @ et la variable.

$ set v = 3
$ set u = 8
$ set p = 5
$ @ x = $v + $u * $p   # attention à la priorité des opérateurs                 
$ echo $x
43
$ @ x = ( $v + $u ) * $p
55

$ @ q = $u / $p        # division entière
$ @ r = $u % $p
$ echo quotient = $q et reste = $r
quotient = 1 et reste = 3

$ @ v++                # incrémentation d'une unité
$ echo $v
4

$ @ v += 2             # incrémentation de deux unités
$ echo $v
6

$ @ u /= 2             # @ u = u / 2
$ echo $u
4

$ @ u = ( $u <<  3 )   # décalage à gauche de 3 bits, ce qui revient à une x 8  
$ echo $u
32

$ @ v = (( $v + 4 ) >> 2 ) # 10 décaler de 2 bits à droite, soit 10 / 4 = 2
$ echo $v
2