Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : AmigaBasic - Les variables alpha-numériques
(Article écrit par Michel Descoins et extrait d'Amiga News Tech - juillet 1989)
|
|
Déjà le troisième volet de notre excursion au pays d'AmigaBasic, dans lequel nous continuons, sur notre
lancée et sans plus attendre, notre exploration des variables. Au menu d'aujourd'hui, les variables alpha-numériques.
Variable alpha-numérique
Avant tout, qu'est-ce qu'une variable alpha-numérique ? Excellente question ma foi, à laquelle je vais m'empresser
de répondre, avec toute la rigueur qui me caractérise. A la différence d'une variable de type numérique,
une variable alpha-numérique peut contenir n'importe quelle valeur codée, sous forme de suite de caractères
ASCII. Ceci était la définition globale, voici maintenant un exemple légèrement plus démonstratif.
"a$" et "b$" sont deux variables de type alpha-numérique. Votre esprit perspicace n'aura sans doute pas manqué
de remarquer le suffixe "$", qui suit immédiatement leur nom. C'est un moyen simple - aussi bien pour AmigaBasic
que pour nous-même - de savoir qu'effectivement, "a" et "b" sont alpha-numériques, et non simplement numériques.
Vous aurez également remarqué que le texte assigné à ces variables est inscrit entre guillemets. Les guillemets
sont, en BASIC, un signe séparateur de texte et ne font pas partie du texte lui-même. En d'autres termes,
notre variable "a$" contient la chaîne Bonjour, guillemets exclus, et non la chaîne "Bonjour", guillemets inclus.
Notez au passage qu'il est tout à fait possible que coexistent dans un programme, deux variables de même nom, mais
de type différent. Ainsi, dans les lignes suivantes :
a=12
a$="Only AMIGA makes it possible"
|
...les deux variables "a" et "a$" sont entièrement distinctes.
Édition de variables alpha-numériques
Devinez qui vient dîner ce soir ? Allez, je vous le donne en mille : c'est encore l'instruction "PRINT"
qui va nous servir à éditer à l'écran, le contenu d'une variable alphanumérique.
a$="Oups ! Je suis en retard"
PRINT a$
|
Et le texte "Oups ! Je suis en retard" s'affichera à l'écran (encore une fois, sans les
guillemets. Je ne les mets moi-même dans ce texte, que par souci de respecter certaines
règles élémentaires de grammaire). C'est tellement simple qu'il n'y a rien de plus à
dire sur le sujet. Passons donc à une notion à priori plus bizarre...
Calcul sur les variables alpha-numériques
Pardon ? Quid ? Larousse ? Il est possible de calculer des textes ? Mais comment,
j'aimerais que l'on m'explique ce phénomène... En fait, il n'existe qu'une seule opération
possible sur les variables alphanumériques : l'addition. Prenons un exemple tout bête (merci
pour moi) :
a$="Commodore"
b$="Revue"
c$=a$+b$
PRINT c$
|
Et alors là, ô miracle, le nom désormais célèbre "Commodore Revue" s'affiche à l'écran.
Que s'est-il donc passé au sein de l'interpréteur BASIC ? Eh bien tenez-vous bien
(tenez-vous mieux, on voit tout, là...), AmigaBasic a pris le contenu de la variable
"a$", auquel il a ajouté celui de la variable "b$", pour enfin affecter ce résultat
à la variable "c$". En fait d'ajouter, il a tout simplement placé "b$" à la suite de "a$".
Petit piège à éviter
Les débutants en programmation en BASIC, et après tout c'est à eux que s'adresse cette rubrique,
font souvent l'erreur, bien compréhensible après tout, qui consiste à considérer un nombre
contenu dans une variable alpha-numérique, avec son équivalent numérique. Ainsi, il n'est pas rare
de rencontrer les quelques lignes suivantes :
Lors de l'exécution de ce programme, un message d'erreur s'affiche. Il ne faut en effet
pas confondre la suite de caractères "12", qui est donc composée des caractères ASCII "1"
et "2" et le nombre "12". En règle générale, une variable alpha-numérique ne peut pas être
utilisée directement dans des calculs mêlant une ou plusieurs variables numériques.
Voilà à peu près tout ce que nous avons besoin de savoir pour le moment, sur les variables
alpha-numériques. Au fur et à mesure de nos pérégrinations basicardes, nous rencontrerons
diverses instructions et/ou fonctions, destinées à les gérer de manière aussi complète que
possible. Pour l'heure, nous allons effectuer un grand pas en avant et découvrir les tests.
Les tests
C'est en effet bien beau de pouvoir jongler ainsi avec toutes sortes de variables, encore
faudrait-il pouvoir prendre connaissance de leur valeur. En effet, nous n'avons jusqu'ici
rencontré des variables dont nous avions nous-même réalisé l'affectation. De fait, connaître
leur valeur était d'une part évident (et pour cause !) et d'autre part, sans grand intérêt.
Mais il arrive parfois, bien plus souvent que l'on ne le pense, qu'une variable puisse avoir
une valeur totalement inconnue à priori. Par exemple, si elle est le résultat d'un calcul,
ou bien s'il s'agit d'une valeur entrée par l'utilisateur. Nous disposons, en BASIC,
du groupe d'instructions IF... THEN... ELSE (ou ELSE IF)... END IF, qui permet de
tester les variables (et bien d'autres choses encore) et de réagir en fonction du résultat de
ce test. Considérez donc le programme suivant :
INPUT "Entrez un nombre entre 1 et 100";a
IF a<1 THEN
PRINT "Plus grand, voyons !"
END
END IF
IF a>100 THEN
PRINT "Plus petit !"
ELSE
PRINT "Merci beaucoup"
END IF
END
|
Que fait ce programme ? Il demande un nombre compris entre 1 et 100. Mais rien, à part
cette invite bien sûr, n'oblige l'utilisateur à effectivement donner un nombre compris dans
cette fourchette. Il peut très bien, par erreur ou par malice, entrer -15, 1002 ou
n'importe quel autre nombre.
L'intérêt du test est que l'on peut vérifier la conformité du nombre. La ligne "IF a<
THEN" sert à vérifier si "a" est inférieur à "1" (les matheux auront reconnu le signe
inférieur <). Si (IF) c'est le cas, alors (THEN) on affiche (PRINT) le message
"Plus grand, voyons !" et on termine le programme (END). Dans le cas contraire, ces
deux instructions sont tout bonnement ignorées et l'on saute jusqu'au prochain END IF
(littéralement, "fin de si", soit fin de test).
On procède alors à un second test, visant à vérifier si a est supérieur à 100. Là encore, si c'est
le cas, on affiche le message "Plus petit !" et on termine le programme. Sinon (ELSE), c'est
que l'utilisateur s'est plié à notre volonté, et que le nombre est effectivement compris entre
1 et 100. Dans ce cas-là, on affiche le message "Merci beaucoup", on termine le test (END IF),
puis le programme lui-même.
La règle à retenir pour les tests est donc la suivante : la condition suivant le IF est évaluée ;
si elle est vraie, alors les instructions placées entre le IF et le END IF (ou le ELSE) sont
exécutées. Si en revanche elle est fausse, on saute les instructions suivant le IF jusqu'à ce que
l'on rencontre un ELSE (sinon), ou une fin de test (END IF). Bien entendu, il existe plusieurs
tests possibles :
Opérateur |
Signification |
= |
Égalité |
< |
Infériorité stricte |
> |
Supériorité stricte |
<= ou =< |
Infériorité ou égalité |
>= ou => |
Supériorité ou égalité |
<> |
Non égalité (différence) |
De même, il est possible de combiner plusieurs tests dans une seule instruction IF, grâce à ce que
l'on appelle les opérateurs logiques, qui sont au nombre de quatre :
Opérateur |
Signification |
AND |
Les deux conditions doivent être vraies |
OR |
L'une ou l'autre condition doit être vraie |
XOR |
Seulement une condition doit être vraie |
NOT |
La condition doit être fausse |
Simplifions donc notre programme-exemple de tantôt :
INPUT "Donnez un nombre entre 1 et 100";a
IF a>0 AND a<101 THEN
PRINT "Merci beaucoup"
ELSE
PRINT "J'ai dit : entre 1 et 100 !"
END IF
END
|
Ce qui équivaut à :
INPUT "Donnez un nombre entre 1 et 100";a
IF a<1 OR a>100 THEN
PRINT "J'ai dit : entre 1 et 100 !"
ELSE
PRINT "Merci beaucoup"
END IF
END
|
Et pour quelques dollars de plus...
Vous l'aurez compris, il est également possible de tester des variables alpha-numériques avec
l'instruction "IF". Je vais d'abord vous donner un exemple, les explications suivront.
INPUT "Entrez le mot de passe";a$
IF a$="AMIGA" THEN
PRINT "Mot de passe correct"
ELSE IF a$="ATARI" THEN
PRINT "Arghh ! Un traître !"
ELSE
PRINT "Mot de passe incorrect"
END IF
|
Ici, on commence par demander un mot de passe. Si ce mot est "AMIGA", alors on affiche
"Mot de passe correct", sinon, si ce mot est "ATARI", on hurle au traître (hé, hé, hé),
sinon enfin, on se contente d'afficher "Mot de passe incorrect". Ce qui se passe en fait,
c'est que l'on compare la chaîne de caractères contenue dans la variable "a$", avec la
chaîne "AMIGA". Si les deux chaînes sont égales (c'est-à-dire identiques), alors la
condition est remplie. Si elles sont différentes, on compare "a$" avec "ATARI".
Si alors le résultat de cette comparaison est vraie, la condition est remplie, sinon (c'est-à-dire
si "a$" ne valait ni "AMIGA" ni "ATARI"), c'est le mauvais mot de passe.
En plus de pouvoir comparer l'égalité (plutôt, l'identicité de deux chaînes), on peut
également comparer leur supériorité et leur infériorité. Comment cela est-il possible ?
Je vous rappelle qu'une variable alpha-numérique est composée de plusieurs caractères
qui se suivent. Ces caractères correspondent tous à un code ASCII, c'est-à-dire une
valeur comprise entre 0 et 255. Ainsi, le "A" majuscule vaut "65", le "B" 66, tandis
que le "a" minuscule vaut 97, "b" 98, etc.
Le BASIC ne traite en fait rien d'autre que ces codes ASCII ; pour lui, "A"
ne signifie rien du tout, seul "65" a un sens. L'instruction "IF" va comparer un à un tous
les codes ASCII des deux chaînes (dans notre exemple, "a$" et "AMIGA"), jusqu'à ce qu'il
rencontre une différence entre les deux. Cette différence peut être due à une lettre dans
la chaîne, mais aussi à des longueurs de chaînes différentes. Voici quelques exemples qui,
je l'espère, vous aideront à comprendre un peu mieux tout cela :
"AMIGA"<"ATARI"
"amiga">"ATARI"
"AMIGA"="AMIGA"
"AMIGA"<"amiga"
C'est fini pour aujourd'hui
Voilà pour ce qui concerne les variables alpha-numériques et les tests. Le mois prochain,
nous entamerons un gros chapitre du BASIC : les branchements et les boucles. Ce qui,
d'ailleurs, clôturera notre approche de la programmation en BASIC en général et nous
ouvrira toutes grandes, les portes de l'AmigaBasic en particulier, avec ses spécificités
dues à l'Amiga.
|