2. Concepts de base

Mémorisation des données et variables

La Programmatrice met à notre disposition un espace de stockage organisé comme une arborescence de fichiers, mais là, on peut stocker des données élémentaires, des valeurs numériques, des chaînes de caractères etc. en créant des variables.

Essayez, par exemple, les commandes successives indiquées ci-dessous :

add n=57 # crée une variable n initialisée avec la valeur entière 57
n # rend la valeur de n
n+1 # ajoute 1 à n et rend le résultat

add nom="Toto" # crée une variable chaîne de caractères
"Bonjour " ++ nom # concaténation

list # donne la liste des variables créées
ls # id.
ls /v # commande avec option /v pour afficher le contenu avec les valeurs

A noter, dans ces exemples, 2 points de syntaxe particuliers :

1. ce qui est écrit après un # est un commentaire et n'est pas interprété par la Programmatrice.

2. '++' est l'opérateur de concaténation des chaînes de caractères. Il construit une nouvelle chaîne en juxtaposant celles fournies comme opérandes.

Quelques précisions de vocabulaire : on appelle expressions d'une façon générale les commandes ou autres expressions saisies dans la zone de commandes. Ces expressions sont interprétées et évaluées par la Programmatrice qui affiche alors leur valeur. Les données mémorisées par les variables sont aussi appelées valeurs.

Les données sont « variables » car on peut en changer les valeurs. Exemple :

n=43
n

On peut même écrire :

n = n*2 # change la valeur de n
n

Types

On peut préciser le type attendu pour une variable.

add i : int # i ne stockera que des nombres entiers (integer)
add s : string
add t : string = "un texte" # avec une valeur initiale
ls /v

Remarque : () signifie que la variable n'a pas encore de valeur

Essayez l'affectation suivante :

i = "Coucou" # affiche un message d’erreur car "Coucou" n'est pas un nombre entier

Les premiers types à connaître sont :

int : comme integer, pour désigner les nombres entiers relatifs,
num : comme number, pour spécifier les nombres décimaux (incluant les nombres entiers),
string : désignant les chaînes de caractères écrites entre " " et
bool : désignant les valeurs booléennes, c'est-à-dire true ou false.

Redéfinition et suppression des variables

Quand on tente de créer deux fois la même variable, on obtient un message d’erreur. Mais il est possible de redéfinir une variable grâce à l’option /f (ou /force)

add s:int = 123
add /f s:int = 123

On peut aussi supprimer une variable précédemment créée par add grâce à l'instruction remove (ou rm). Ainsi, pour surmonter la difficulté précédente, on aura pu écrire :

rm s
add s:int = 123

Module courant et organisation arborescente

Vous avez sans doute remarqué l'indication "Root.Home". Il s'agit du module courant.

En effet, l’espace de stockage est une arborescence comme dans un système de fichiers. Les données sont sauvegardées dans des « dossiers » qu’on appelle ici « modules ». Root.Home est le module de démarrage par défaut, il désigne le module Home contenu dans le module racine Root. Les modules de l’arborescence sont écrits en les séparant par le "."

La commande ls que nous avons déjà vue affiche la liste des éléments contenus dans le module courant.

Nous utiliserons ci-dessous le module prédéfini Math , dont le nom complet est Root.Lang.Math. Celui-ci regroupe des fonctions mathématiques prédéfinies.

Un peu plus loin, nous verrons comment on peut créer de nouveaux modules et comment on parcourt l'arborescence des données crées.

Instructions

Nous avons déjà vu plusieurs instructions :

- add qui permet de créer une nouvelle variable dans un module,

- remove (ou rm) qui permet de supprimer une variable précédemment créée par add,

- l’affectation, avec le signe "=", qui consiste à définir ou à changer la valeur d’une variable,

- list (ou ls) pour afficher tous les éléments d’un module,

- write qui sert à afficher la valeur d’une expression.

Mais il existe beaucoup d’autres instructions que nous découvrirons progressivement. Puis, nous verrons que nous pouvons nous-mêmes créer de nouvelles instructions.

On peut enchaîner plusieurs instructions en les séparant de ";" (un point-virgule).

add a,b=2,3; write a+b

On peut enchaîner ainsi autant d’instructions qu’on veut. On parle alors d’une séquence d’instructions.

Ajoutons dès maintenant une nouvelle instruction complémentaire aux précédentes :

- var qui est très semblable à add mais qui, contrairement à cette dernière ajoutant une (ou des) nouvelle(s) variable(s) dans le module courant (Home), ne définit qu'une (ou des) variable(s) locale(s) à la commande.

var c,d=2,3; write c+d
list

Cette commande avec var donne le même résultat que ci-dessus cependant, en listant ensuite le contenu du module courant, on ne trouve pas trace des variables c et d alors qu'on a les variables a et b.

Fonctions

Les instructions que nous venons de voir appartiennent à la catégorie plus large des fonctions. Une fonction, en général, permet d'écrire des expressions qui peuvent être évaluées et rendre un résultat.

Par exemple :

Math.sqrt(2)

calcule la racine carrée de 2, en utilisant la fonction sqrt du module Math, et affiche le résultat.

Une instruction est une fonction particulière qui, hormis les cas d'erreurs, rend et affiche toujours le même résultat : « ok ».

Note : on peut, le plus souvent, utiliser indifféremment l'écriture "fonctionnelle" des fonctions avec leurs arguments entre parenthèses, la "(" étant accolée au nom de fonction, ou l'écriture "sous forme de commande", sans parenthèses.

Exemples :

rm(s)
Math.sqrt 2

Néanmoins, par habitude et pour une meilleure lisibilité, nous emploierons de préférence l'écriture "sous forme de commande" pour les instructions et l'écriture fonctionnelle pour les fonctions « non ok ».

Dans une séquence, les parties situées à gauche des ";" doivent être des instructions et fournir le résultat « ok ». En revanche, à droite, on avoir une expression quelconque. Exemple :

var rac2 = Math.sqrt(2); Math.round(rac2*rac2)

Note : round fournit l'arrondi entier d'un nombre décimal.

Structures de contrôle

Mais les programmes informatiques n’auraient pas grand intérêt s’ils n’exécutaient que des séquences, c’est-à-dire toujours le même enchaînement d’instructions. Ils doivent au contraire permettre d’adapter les traitements aux différents cas qui se présentent.

Pour cela, on a des instructions (ou expressions) conditionnelles telles que : si telle condition alors faire ceci sinon faire cela.

Dans notre langage, voilà, sur un exemple, comme cela s'écrit :

if a < b then write a else write b fi

Cette combinaison d’instructions permettra d’afficher la plus petite des deux valeurs de a et de b.

Comme on peut le voir, cette instruction a la particularité de s’écrire avec plusieurs mots-clés : if, then, else et fi qui termine l’instruction (et qu’il ne faut pas oublier).

Cette structure de contrôle a en réalité plusieurs variantes :

- Il peut ne pas y avoir de clause else. Par exemple,

if a > 10 then write a fi # permet de n’afficher la valeur de a que si elle est > 10

- On peut avoir un enchaînement de plusieurs conditions grâce au mot-clé elif :

if a < b then write "a est le plus petit"

elif a == b then write "les deux sont égaux"

else write "b est le plus petit"

A noter que les expressions situées après then et else ne sont pas obligatoirement des instructions. Par exemple, on peut écrire :

if a < b then a else b fi

On peut, d'autre part, définir des "boucles" qui permettent de répéter certains traitements. Celles-ci sont de plusieurs sortes :

- Les boucles « for »

for a=1 to 10 do write a done

Pour utiliser comme indice de boucle, une variable locale à celle-ci :

for var i=1 to 10 do write i*i done

Pour spécifier un pas différent de 1 :

for var i=1 to 10 step 2 do write i*i done

- Les boucles « while »

var i=1 ;
var j=1 ;
while j < 1000 do
write i ;
i,j = j,j+i
done

Les boucles « repeat … until »

var i = 2 ;
repeat
write i ;
i = i*i
until i>1000

Identificateurs

Quelques précisions sur les noms donnés aux variables que nous appelons "identificateurs".

Ils commencent par une lettre ou le caractère "_" (souligné) et sont composés ensuite d’une suite de lettres, chiffres ou caractère "_". Tout autre caractère (espace, ponctuation, opérateur, séparateur) termine l’identificateur.

Il est possible toutefois de définir un identificateur ne respectant pas cette spécification en l’encadrant de ' ' (quotes simples).

Exemples :

---? add 'son nom':string = "Toto"

---= ok

---? write "Il s’appelle " ++ 'son nom'

Il s’appelle Toto

---= ok

Déclarations simples et multiples

Comme nous l'avons vu dans les exemples précédents, toute variable doit être déclarée avant d'être affectée ou utilisée. Son type peut être précisé ou non, et éventuellement une valeur initiale peut être définie.

Exemples :

---? add i

---= ok

---? i=53

---= ok

---? add j:int=i+1

---= ok

---? add k:int

---= ok

---? k = "Hello"

---= *** Type error : int expected

Rq : Sont évaluées des expressions numériques, alphanumériques, booléennes, ou des instructions dont le résultat est toujours la constante "ok". Toutefois, en cas d’erreur, c'est un message d'erreur qui s'affiche au lieu de "ok".

Les déclarations, initialisations et affectations peuvent également être multiples.

Exemples :

---? add nom:string, age:int

---= ok

---? add i:int, id, actif:bool = 56, "Toto", true

---= ok

---? a,b = b,a

---= ok

Noter, dans ce dernier exemple, le moyen commode (à la mode Python) d’échanger les valeurs de 2 variables.

Dans ces exemples, les opérateurs utilisés se classent, du plus prioritaire au moins prioritaire, dans l’ordre suivant : ':' ',' puis '='. Ainsi, la 2nde déclaration est équivalente à :

---? add ((i:int), id, (actif:bool)) = (56, "Toto", true)

Cela n'étant pas forcément évident au premier coup d'œil, il est conseillé de mettre les parenthèses pour éviter toute confusion.