LISTE DES MOTS-CLÉS SPÉCIFIQUES.

Métacommande du QBASIC.

$DYNAMIC : indique que les tableaux seront modifiables avec REDIM.

Commandes du QBASIC.

CLEAR : réinitialise toutes les variables et ferme les fichiers ouverts.

COMMON : définit les variables qui pourront être partagées avec d'autres modules externes.

DEF SEG : (obsolète) réserve un espace de mémoire pour l'accès d'une procédure de mémoire.

DIM : déclare un tableau de données, , non redimensionnable, en précisant le type commun à toutes les données.

ERASE : réinitialise les valeurs des tableaux $STATIC et détruit les tableaux $DYNAMIC.

LBOUND() : retourne le plus petit index possible pour la dimension précisée d'un tableau données.

OPTION BASE : définit index du premier item d'un tableau de données à 0, par défaut, ou 1.

REDIM : déclare ou modifie un tableau de données, redimensionnable, en précisant le type commun à toutes les données.

SHARED : définit que la valeur de la variable pourra être lue et/oumodifiée dans SUB ou FUNCTION. 

UBOUND() : retourne le plus grand index possible pour la dimension précisée d'un la tableau données. 

Commandes du QB64.

_PRESERVE : préserve les valeurs des items d'un tableaux lors de l'utilisation de REDIM.

QU'EST-CE QU'UN TABLEAU DE DONNÉES.

Un tableau de données est une variable qui contient un certain nombre de valeurs, ses éléments ou items. 

Avec le QBASIC du QB64, tous les éléments d'un tableau ont le même type de données. Pour affecter, lire ou modifier la valeur d'un item dans un tableau, on le désigne par le nom de la variable représentant le tableau, suivis de sa position, son index, dans le tableau.

La création de tableaux de données sera utile, si vous avez besoin de variables avec des nombres, ou indices, dans leurs noms. Cela rend les tableaux parfaits dans de nombreux cas. Vous pouvez obtenir plusieurs valeurs du même type simplement en faisant référence aux positions des éléments dans un tableau. De plus, vous pouvez avoir des milliers de possibilités en cas de besoin. Les tableaux de données seront aussi utiles pour contenir des données d'image ou de fichier.

CRÉER UN TABLEAU DE DONNÉES.

Dans QB84, tous les tableaux ayant plus de 11 éléments, ou ayant plusieurs dimensions, doivent être déclarés avant leur utilisation.

L'instruction DIM, ou REDIM, doit être utilisée pour déclarer un tableau de données, en indiquant le type commun à toutes ses données et le nombre d'éléments qu'il contiendra avant que le tableau ne soit utilisé. Les tableaux de données QBASIC étaient limités à 32767 éléments, tandis que les tableaux dans QB64 sont limités à 2147483647 éléments sur les systèmes 32 bits, et à 9223372036854775807 éléments sur les systèmes 64 bits. 

DIM LST_Scores(25) AS INTEGER

crée un tableau de 26 items de type INTEGER. Le premier item est à l'index, ou indice, 0 et pourra être appelé avec LST_Scores(0). Le deuxième item est à l'index 1, est sera appelé avec LST_Scores(1). Et ainsi de suite jusqu'au dernier item, le 26è, à l'index 25, nommé LST_Scores(25).

Note : Les déclarations DIM LST_Scores%(25) et DIM LST_Scores(25) AS INTERGER sont identiques, mais dans le premier cas, le suffixe % devra être utilisé pour appeler un item. Par exemple : LST_Scores%(17) pour appeler le 18è item au lieu de LST_Scores(17).

Par défaut l'index du premier item d'un tableau est 0. Mais ce comportement peut être modifié avec l'instruction composée OPTION BASE ?. Avant la déclaration de vos tableaux de données, indiquez dans votre script :

- OPTION BASE 0, et l'index du premier item sera 0, valeur par défaut ;

- OPTION BASE 1, et l'index du premier item sera 1. 

OPTION BASE 1

DIM LST_Scores(25) AS INTEGER

créé un tableau de 25 items de type INTEGER. Le premier item est à l'index 1 et pourra être appelé avec LST_Scores(1). Le deuxième item est à l'index 2, est sera appelé avec LST_Scores(2). Et ainsi de suite jusqu'au dernier item, le 25è, à l'index 25, nommé LST_Scores(25).

La fonction LBOUND() permet de connaitre l'index du premier item d'une dimension d'un tableau de données, tandis que la fonction UBOUND() retourne l'index de son dernier item.

DIM LST_Durees(60) AS INTEGER

OPTION BASE 1

DIM LST_Scores(25) AS INTEGER

OPTION BASE 0

DIM LST_Restes(12) AS INTEGER

PRINT "Les index des items du tableau LST_Durees vont de"; LBOUND(LST_Durees); "a"; UBOUND((LST_Durees)

PRINT "Les index des items du tableau LST_Scores vont de"; LBOUND(LST_Scores); "a"; UBOUND(LST_Scores)

PRINT "Les index des items du tableau LST_Restes vont de"; LBOUND(LST_Restes); "a"; UBOUND(LST_Restes)

retourne :

Les index des items du tableau LST_Durees vont de 0 a 60 

Les index des items du tableau LST_Scores vont de 1 a 25

Les index des items du tableau LST_Restes vont de 0 a 12

Il est aussi possible de choisir la plage d'index, qui sera utilisé pour désigner les items du tableau de données, en indiquant cette plage au moment de la déclaration du tableau. Notez cependant que des index négatifs, surtout s'ils indiquent l'index du dernier item du tableau, pourront provoquez des erreurs lors de l’exécution du programme.

DIM LST_Distances(10 TO 30) AS INTEGER

PRINT "Les index des items du tableau LST_Distances vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)

retourne : Les index des items du tableau LST_Distances vont de 10 a 30 

L'adresse du segment de mémoire du tableau peut être définie avec DEF SEG = VARSEG(k(0)) : koffset = VARPTR(k(0)). Et si OPTION BASE 1 est utilisée, remplacez 0 par 1. Le premie index du tableau peut être modifié lorsque d'autres données sont indexées dans le tableau. Cependant, QB64 implémente l'accès à la mémoire à l'aide de _MEM. Pour cette raison, l'usage de DEF SEG et fortement déconseillé, et n'est conservé par QB64 que pour maintenir la compatibilité avec les anciens scripts.

LIRE OU MODIFIER LES DONNÉES D'UN TABLEAU.

Pour lire, ou modifier, la valeur d'un des items d'un tableau de données, il suffit de faire suivre le nom du tableau de données par l'index de l'item, entre parenthèses, avec lequel on souhaite travailler.

DIM LST_Valeurs(20) AS INTEGER

FOR kindex = 0 TO 20: PRINT LST_Valeurs(kindex);: NEXT kindex: REM - lecture des valeurs

FOR kindex = 0 TO 20: LST_Valeurs(kindex) = INT (RND * 800): NEXT kindex: REM - modification des valeurs

PRINT

FOR kindex = 0 TO 20: PRINT LST_Valeurs(kindex);: NEXT kindex: REM - lecture des valeurs

retourne :

 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

 564  426  463  231  241  619  11  608  651  567  36  551  990  632  298  760  796  44  759  291  419

Si le mot-clé SHARED est présent dans la déclaration d'un tableau de données, les valeurs de ses items pourront être lues et/ou modifiées dans les procédures et autres fonctions personnalisées. Sinon l’identification du tableau devra être passé comme paramètre lors de l'appel de ces procédures, en prenant garde à la bonne correspondance du type de données.

DIM SHARED LST_Partages(15) AS INTEGER

DIM  LST_Bloques(15) AS INTEGER

k = FNC_Valeurs(LST_Bloques())

PRINT "Apres l'affectation de valeurs."

FOR kindex = 0 TO 15: PRINT LST_Partages(kindex);: NEXT kindex

FOR kindex = 0 TO 15: PRINT LST_Bloques(kindex);: NEXT kindex

END

FUNCTION FNC_Valeurs (Q%())

FOR kindex = 0 TO 15:

LST_Partages(kindex) = INT(RND * 800)

Q%(kindex) = INT(RND * 800)

NEXT kindex

END FUNCTION

retourne :

Apres l'affectation de valeurs.

564  231  11  567  890  374  519  638  97  352  481  73  426  225  520 774

28  675  836  153  733  43  945  253  179  527  943  857  427  539  665 841

Si le mot-clé COMMON est présent dans la déclaration d'un tableau de données, les valeurs de ses items pourront être lues et/ou modifiées dans tous les modules appelés par le programme principal. La combinaison COMMON SHARED sera utilisée si l'on souhaite partager les valeurs des items d'un tableau de données avec les sous-modules et les fonctions de ce module.

DIM LST_Scores(15) AS INTEGER

DIM LST_Niveau(15) AS INTEGER

COMMON LST_Scores

COMMON SHARED LST_Niveau

le tableau nommé LST_Scores est partagé avec tous les modules principaux importés avec $INCLUDE et celui qui serait chargé avec CHAIN, tandis que le tableau nommé LST_Niveau est partagé avec tous les modules principaux importés avec $INCLUDE et celui qui serait chargé avec CHAIN, mais aussi avec les fonctions personnalisées qu'ils comportent;

Note : la technique multimodulaire remonte à l'époque où QBASIC avaient des contraintes de taille de module. Ce qui n'est plus le cas avec QB64, COMMON a été conservé à des fins de compatibilité avec des anciens codes. Les contraintes de taille n'existant plus, il est fortement conseillé de rédiger des projets regroupant toutes les fonctionnalités en un seul script, à l'exception d'éventuelles bibliothèques importées par $INCLUDE. 

L'instruction CLEAR réinitialise toutes les valeurs des items, de tous les tableaux de données, à 0 pour les types numériques et à une chaine vide pour les STRING. Alors que l'instruction ERASE permet de sélectionner les tableaux de données qui doivent être réinitialisés. Notez que les tableaux déclarés avec l'instruction REDIM ou précédés de $DYNAMIC seront détruit et devront être redéclarée après un CLEAR ou un ERASE.

DIM SHARED LST_Un(15) AS INTEGER

DIM SHARED LST_Deux(15) AS INTEGER

DIM SHARED LST_Trois(15) AS INTEGER

PRINT "Apres l'affectations de valeurs."

FNC_Valeurs

FNC_lecture

PRINT

CLEAR

PRINT "Apres une instruction CLEAR."

FNC_lecture

PRINT

FNC_Valeurs

PRINT "Apres l'affectations de nouvelles valeurs."

FNC_lecture

PRINT

ERASE kdeux

PRINT "Apres une instruction ERASE kdeux."

FNC_lecture

PRINT

END

SUB FNC_lecture

    FOR kindex = 0 TO 15: PRINT LST_Un(kindex);: NEXT kindex

    PRINT

    FOR kindex = 0 TO 15: PRINT LST_Deux(kindex);: NEXT kindex

    PRINT

    FOR kindex = 0 TO 15: PRINT LST_Trois(kindex);: NEXT kindex

    PRINT

END SUB

SUB FNC_Valeurs

    FOR kindex = 0 TO 15:

        LST_Un(kindex) = INT(RND * 800)

        LST_Deux(kindex) = INT(RND * 800)

        LST_Trois(kindex) = INT(RND * 800)

    NEXT kindex

END SUB

retourne :

Apres l'affectations de valeurs.

564  231  11  567  890  374  519  638  97  352  481  73  426  225  520 774

28  675  836  153  733  43  945  253  179  527  943  857  427  539  665 841

684  639  833  984  327  749  353  66  835  630  704  63  974 427  532  6 

Apres une instruction CLEAR.

0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

Apres l'affectations de nouvelles valeurs.

634  953  76  536  884  543  893  65  386 532  905  54  734  957  323  665

63  730  633  294  412  83  9  342  947  552  673  772  103  28 519  631 

982  658  720 199  875  284  620  538  517  843  368  472  745  49  876  174

Apres une instruction ERASE kdeux.

634  953  76  536  884  543  893  65  386 532  905  54  734  957  323  665

0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

982  658  720 199  875  284  620  538  517  843  368  472  745  49  876  174

Des tableaux de données peuvent être déclarés dans des procédures personnalisées, FUNCTION ou SUB. De plus, le mot-clé SHARED, sans l'instruction DIM, peut être utilisé à l'intérieur d'une procédure personnalisée, pour exporter les valeurs des variables avec le programme principal, mais pas avec les autres procédures personnalisées. Bientot, QB64 permettra ce partage avec d'autres procédures.

Dans les procédures personnalisées, les tableaux peuvent être définis comme STATIC pour préserver les valeurs de leurs items à la sortie de la procédure pour une utilisation future. Ces valeurs seront conservées jusqu'à ce qu'elles soient modifiées à l'intérieur de cette procédure. 

FNC_Demi: END

SUB FNC_Demi

    STATIC kindex%, LST_Gardes(12) AS DOUBLE

    DIM LST_Perdus(12) AS DOUBLE

    IF kindex% = 0 THEN LST_Gardes(0) = 1000 ELSE LST_Gardes(kindex%) = LST_Gardes(kindex% - 1) / 2

    LST_Perdus(kindex%) = LST_Gardes(kindex%)

    PRINT "A l'index :"; kindex%;  " GARDE :";

    FOR kvaleur = 0 TO 4: PRINT LST_Gardes(kvaleur);: NEXT kvaleur

    PRINT " ET PERDU :";

    FOR kvaleur = 0 TO 4: PRINT LST_Perdus(kvaleur);: NEXT kvaleur

    PRINT

    kindex% = kindex% + 1

IF kindex% < 4 THEN FNC_Demi

END SUB

retourne :

A l'index 0 GARDE : 1000  0  0  0  0 ET PERDU  : 1000  0  0  0  0

A l'index 1 GARDE : 1000  500  0  0  0 ET PERDU  : 0  500  0  0  0

A l'index 2 GARDE : 1000  500  250  0  0 ET PERDU  : 0  0  250  0  0

A l'index 3 GARDE : 1000  500  250  125  0 ET PERDU  : 0  0  0  125  0

Les données du tableau LST_Gardes() et la valeur de kindex% sont conservées entre deux appels de la fonction personnalisée FNC_Demi alors que celles du tableau LST_Perdus() sont détruites.

REDIMENSIONNER UN TABLEAU DE DONNÉES.

Par défaut, les tableaux de données sont $STATIC, c'est-à-dire que leur nombre d'items ne peut pas être modifié, à moins que la métacommande $DYNAMIC ne soit indiqué en début de script. Pour modifier le nombre d'items d'un tableau de données, on utilisera l'instruction REDIM. Si un tableau de données n'est pas modifiable, une erreur pourra interrompre le programme si REDIM est utilisé pour ce tableau de données.

DIM LST_Durees(60) AS INTEGER

REM $DYNAMIC

DIM LST_Scores(25) AS INTEGER

PRINt "Avant de redimensionner les tableaux : "

PRINT "Les index des items du tableau kduree vont de"; LBOUND(LST_Durees); "a"; UBOUND(LST_Durees)

PRINT "Les index des items du tableau kscore vont de"; LBOUND(LST_Scores); "a"; UBOUND(LST_Scores)

PRINT

REDIM LST_Durees(180) AS INTEGER

REDIM LST_Scores(12) AS INTEGER

PRINt "Apres de redimensionner les tableaux : "

PRINT "Les index des items du tableau kduree vont de"; LBOUND(LST_Durees); "a"; UBOUND(LST_Durees)

PRINT "Les index des items du tableau kscore vont de"; LBOUND(LST_Scores); "a"; UBOUND(LST_Scores)

retourne :

Avant de redimensionner les tableaux : 

Les index des items du tableau kduree vont de 0 a 60 

Les index des items du tableau kscore vont de 1 a 25

Apres de redimensionner les tableaux : 

Les index des items du tableau kduree vont de 0 a 60 

Les index des items du tableau kscore vont de 1 a 12

Note : les métacommandes de QBASIC doivent être précédées de l'instruction REM, ou d'une apostrophe (').

Il est possible de déclarer un tableau de données, directement avec l'instruction REDIM. Dans ce cas, il pourra être redimensionné sans utiliser la métacommande $DYNAMIC.

REDIM LST_Durees(60) AS INTEGER

PRINT "Avant de redimensionnement : "; 

PRINT "les index des items du tableau kduree vont de"; LBOUND(LST_Durees); "a"; UBOUND(LST_Durees)

REDIM LST_Durees(180) AS INTEGER

PRINT "Apres de redimensionnement : "; 

PRINT "les index des items du tableau kduree vont de"; LBOUND(LST_Durees); "a"; UBOUND(LST_Durees)

retourne :

Avant de redimensionnement : les index des items du tableau kduree vont de 0 a 60 

Apres de redimensionnement : les index des items du tableau kduree vont de 0 a 180 

L'instruction REDIM permet aussi de modifier la plage d'index des items, en changeant ou non le nombre d'items, d'un tableau de données.

REDIM LST_Distances(10 TO 30) AS INTEGER

PRINT "A. Les index des items du tableau kdistance vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)

REDIM LST_Distances(50 TO 70) AS INTEGER

PRINT "B. Les index des items du tableau kdistance vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)

REDIM LST_Distances(5 TO 10) AS INTEGER

PRINT "C. Les index des items du tableau kdistance vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)

REDIM LST_Distances(37 TO 74) AS INTEGER

PRINT "D. Les index des items du tableau kdistance vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)

retourne :

A. Les index des items du tableau kdistance vont de 10 a 30 

B. Les index des items du tableau kdistance vont de 50 a 70 

C. Les index des items du tableau kdistance vont de 5 a 10 

D. Les index des items du tableau kdistance vont de 37 a 74 

Lors d'un redimensionnement d'un tableau de données, toutes les valeurs des items sont réinitialisées à leur valeur par défaut : 0 pour les valeurs numériques ou une chaine vide pour les STRING. Cela est particulièrement utile pour réinitialiser toutes les valeurs des données du tableau. Cependant, le QB64 a ajouté l'instruction _PRESERVE permettant de conserver les valeurs des items lors du redimensionnement d'un tableau. L'instruction _PRESERVE doit être placée avant le mot-clé SHARED, s'il est utilisé, dans la nouvelle déclaration du tableau de données.

REDIM LST_Durees(60) AS INTEGER

REDIM LST_Scores(15) AS INTEGER

REDIM LST_Cotes(15) AS INTEGER

FOR kvaleur = 0 TO 60 : LST_Durees(kvaleur) = 60 - kvaleur : NEXT kvaleur

FOR kvaleur = 0 TO 15 : LST_Scores(kvaleur) = RND * 100 : NEXT kvaleur

FOR kvaleur = 0 TO 15 : LST_Cotes(kvaleur) = RND * 10 : NEXT kvaleur

PRINT "Avant de redimensionner les tableaux : "

FOR kvaleur = 0 TO  5 : PRINT kvaleur, LST_Durees(kvaleur), LST_Scores(kvaleur), LST_Cotes(kvaleur) : NEXT kvaleur

PRINT

REDIM _PRESERVE LST_Durees(30) AS INTEGER

REDIM LST_Scores(25) AS INTEGER

REDIM LST_Cotes(15) AS INTEGER

PRINT "Apres de redimensionner les tableaux : "

FOR kvaleur = 0 TO  5 : PRINT kvaleur, LST_Durees(kvaleur), LST_Scores(kvaleur), LST_Cotes(kvaleur) : NEXT kvaleur

retourne :

Avant de redimensionner les tableaux : 

0 60 71 7

1 59 53 3

2 58 17 1

3 57 84 7

4 56 47 5

5 55 29 8

Apres de redimensionner les tableaux : 

0 60 0 0

1 59 0 0

2 58 0 0

3 57 0 0

4 56 0 0

5 55 0 0

Si la plage d'index d'un tableau de données et modifiée par une instruction REDIM, la présence de l'instruction _PRESERVE conservera les valeurs de ses items et, de plus, les placera avec les nouveaux index dans le même ordre que précédemment.

REDIM SHARED LST_Valeurs(12) AS INTEGER

FOR kindex = 0 TO 12: LST_Valeurs(kindex) = kindex: NEXT kindex

FNC_Afficher

REDIM _PRESERVE LST_Valeurs(30 TO 42) AS INTEGER

FNC_Afficher

REDIM _PRESERVE LST_Valeurs(20 TO 27) AS INTEGER

FNC_Afficher

REDIM _PRESERVE LST_Valeurs(10 TO 28) AS INTEGER

FNC_Afficher

REDIM LST_Valeurs(7 TO 22) AS INTEGER

FNC_Afficher

END

SUB FNC_Afficher

    kdebut% = LBOUND(LST_Valeurs)

    kfin% = UBOUND(LST_Valeurs)

    FOR kindex = kdebut% TO kfin%: PRINT LST_Valeurs(kindex);: NEXT kindex

    PRINT

END SUB

retourne :

0 1 2 3 4 5 6 7 8 9 10 11 12

0 1 2 3 4 5 6 7 8 9 10 11 12

0 1 2 3 4 5 6 7

0 1 2 3 4 5 6 7 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

LES TABLEAUX DE DONNÉES A PLUSIEURS DIMENSIONS.

Un tableau de données peut être créé avec une, deux, ou plusieurs dimensions. Pour cela, il suffit, dans la déclaration du tableau de données, de séparer le nombre d'items de chaque dimension par une virgule. Le QBASIC accepté jusqu'à 60 dimensions pour les tableaux de données. Le QB64 accepte autant de dimensions que nécessaire, tant que la mémoire de la machine n'est pas saturée.

DIM LST_Coordonnees(17, 8) AS SINGLE

crée un tableau à 2 dimensions. La première dimension contient 18 items et la deuxième dimension 9 items.

DIM LST_3d(23, 14, 37) AS STRING

crée un tableau à 3 dimensions. La première dimension contient 24 items, la deuxième dimension 15 items et la troisième dimension 38 items.

Lors de la création d'un tableau de données multidimension, il est possible de préciser la plage d'index de chacune des dimensions, en séparant chaque plage d'index par une virgule.

DIM LST_Lances(8 TO 27, 14 TO 32, 172 TO 204, 31 TO 50) AS DOUBLE

crée un tableau à 4 dimensions. les index des items vont :

- de 8 à 27 pour la première dimension, soit 20 items ;

- de 14 à 32 pour la deuxième dimension, soit 19 items ;

- de 172 à 204 pour la troisième dimension, soit 33 items ;

- de 31 à 50 pour la quatrième dimension, soit 20 items.

Les instructions et mots-clés présentés précédemment, pour les tableaux de données simples, peuvent être utilisés pour les tableaux de données à plusieurs dimensions, à condition de préciser à quelle dimension il faut l'appliquer.

DIM LST_Lances(8 TO 27, 14 TO 32, 172 TO 204, 31 TO 50 ) AS DOUBLE

PRINT "Les index de la premiere dimension de"; LBOUND(LST_Lances, 1); "a"; UBOUND(LST_Lances, 1)

PRINT "Les index de la deuxieme dimension de"; LBOUND(LST_Lances, 2); "a"; UBOUND(LST_Lances, 2)

PRINT "Les index de la troisieme dimension de"; LBOUND(LST_Lances, 3); "a"; UBOUND(LST_Lances, 3)

PRINT "Les index de la quatrieme dimension de"; LBOUND(LST_Lances, 4); "a"; UBOUND(LST_Lances, 4)

retourne :

Les index de la première dimension de 8 a 27

Les index de la deuxième dimension de 14 a 32

Les index de la troisième dimension de 172 a 204 

Les index de la quatrième dimension de 31 a 50 

Note : Il est bien entendu possible de modifier le nombre d'items de chaque dimension d'un tableau de données $DYNAMIC ou déclaré avec l'instruction REDIM, de changer leur plage d'index, et de conserver les valeurs des items lors de ces opérations avec _PRESERVE, mais il n'est pas possible de modifier le nombre de dimensions d'un tableau de données.

.

SAUVEGARDER ET RESTITUER LES DONNÉES D'UN TABLEAU.

A la fin du programme, les valeurs des items des tableaux de données sont détruites. Si ces valeurs sont des valeurs connues et immuables au départ du programme, elles peuvent être intégrées au script avec des instructions DATA, READ et RESTORE. Mais si ces valeurs sont modifiées durant l'exécution de l'applications et qu'elles doivent être restituées au prochain lancement du programme, il faudra prévoir de les sauvegarder dans un fichier. 

Note : Les fichiers étant principalement des fichiers textes, il faudra penser à convertir les valeurs numériques en STRING pour l'enregistrement, mais surtout de les reconvertir dans le bon type numérique lors de l'acquisition des valeurs. Par exemple :

REM --- Creation d'un tableau avec des valeurs aleatoies ---

DIM LST_Valeurs(20) AS INTEGER

FOR kindex% = 0 TO 20: LST_Valeurs(kindex%) = INT(RND * 800): NEXT kindex%: REM - affecte des valeurs aux items

FOR kindex% = 0 TO 20: PRINT LST_Valeurs(kindex%);: NEXT kindex%: REM - affiche les valeurs pour le controle

REM --- Enregistrement des valeurs du tableau dans un fichier (texte) ---

OPEN "MonFichier.txt" FOR OUTPUT AS #1: REM - ouvre le fichier texte en ecriture

FOR kindex% = LBOUND(LST_Valeurs) TO UBOUND(LST_Valeurs): REM - créer un boucle pour tous les index

    kvaleur$ = STR$(LST_Valeurs(kindex%)): REM - créer un boucle pour tous les index

    PRINT #1,  kvaleur$: REM - ecrit la valeur dans le fichier en derniere position

NEXT kindex%

CLOSE #1: REM - IMPORTANT - ferme le fichier

REM --- RaZ des valeurs (pour controle) ---

CLEAR: REM - réinitialise les valeurs des items à 0

PRINT

FOR kindex% = 0 TO 20: PRINT LST_Valeurs(kindex%);: NEXT kindex%: REM - controle de la réinitialisation

PRINT

REM --- Lecture et conversion des valeurs du tableau depuis un fichier ---

OPEN "MonFichier.txt" FOR INPUT AS #1: REM - ouvre le fichier texte en lecture

kindex% = LBOUND(LST_Valeurs): REM - initialise la valeur du premier index du tableau de donnees

DO UNTIL EOF(1): REM - creer une boucle tant que la fin du fichier n'est pas atteinte

    INPUT #1, kvaleur$: REM - lecture (recuperation) de l’enregistrement suivant

    kvaleur% = VAL(kvaleur$): REM - reconvertie la valeur dans le bon type numérique

    LST_Valeurs(kindex%) = kvaleur%: REM - affecte l'item de l'index correspondant avec la valeur

    kindex%= kindex% + 1: REM - augmente la valeur de l'index de 1

LOOP

CLOSE #1: REM - IMPORTANT - ferme le fichier

REM --- Affichage pour controle ---

FOR kindex% = 0 TO 20: PRINT LST_Valeurs(kindex%);: NEXT kindex%: REM - controle de la bonne restitution

retourne :

 564  426  463  231  241  619  11  608  651  567  36  551  990  632  298  760  796  44  759  291  419

 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

 564  426  463  231  241  619  11  608  651  567  36  551  990  632  298  760  796  44  759  291  419

TABLEAU DE DONNÉES AVEC DES TYPES DIFFÉRENTS.

Les items d'un tableau de données doivent tous être du même type. En théorie, il n'est donc pas possible de trouver des valeurs de types différents numériques, voire des STRING, dans les données d'un même tableau. Cependant, pour palier à cette contrainte, il suffit de définir un type personnalisé de données avant de déclarer le tableau et d'utiliser ce nouveau type personnalisé comme type pour les données du tableau. Par exemple :