Variables

Fondamentalement, dans 4D, les données peuvent être stockées de deux manières. Les champs stockent les données sur disque, de manière permanente ; les variables stockent les données en mémoire, de manière temporaire.

Lorsque vous définissez votre base, vous indiquez à 4D les noms et les types de champs que vous voulez utiliser. C’est pratiquement la même chose pour les variables — vous leur donnez un nom et un type.

Les types de variables suivants correspondent à chacun des types de données :

• Alpha(*) ou Texte : chaîne alphanumérique pouvant contenir jusqu’à 2 Go de texte
• Entier : nombre entier compris entre -32768 et 32767
• Entier long : nombre entier compris entre -2^31 et (2^31) -1
• Réel (ou Numérique) : nombre réel compris entre ±1.7e±308 (15 chiffres)
• Date : date comprise entre 1/1/100 et 31/12/32767
• Heure : heure comprise entre 00:00:00 et 596000:00:00 (secondes depuis minuit)
• Booléen : Vrai ou Faux
• Image : toute image Windows ou Mac OS
• BLOB (Binary Large OBject) : suite d'octets pouvant aller jusqu'à 2 Go
• Pointeur : pointeur vers une table, un champ, une variable, un tableau ou un élément de tableau.

(*) En mode Unicode, les types de variables Alpha et Texte sont identiques. En mode non Unicode (mode compatibilité), un Alpha est une chaîne alphanumérique fixe pouvant comprendre jusqu’à 255 caractères.

Vous pouvez afficher des variables à l’écran (à l'exception des pointeurs et des BLOB), les utiliser pour saisir des données, et les imprimer dans des états. Dans ces cas, elles se comportent exactement comme des champs, et les mêmes contrôles intégrés sont disponibles lorsque vous les créez :

• Formats d’affichage,
• Contrôles de saisie tels que filtres de saisie et valeurs par défaut,
• Filtrages des caractères,
• Enumérations (listes hiérarchiques)
• Valeurs saisissables ou non-saisissables

Les variables peuvent également servir à :

• contrôler des boutons (boutons, cases à cocher, boutons radio, boutons 3D, etc.),
• contrôler des thermomètres, règles et cadrans,
• contrôler des zones de défilement, des pop up menus et des listes déroulantes,
• contrôler des listes hiérarchiques et des menus hiérarchiques,
• contrôler des grilles de boutons, onglets, boutons image, etc.
• afficher les résultats de calculs ne devant pas être sauvegardés.

Vous pouvez créer des variables simplement en les utilisant ; il n’est pas obligatoire de les déclarer formellement comme vous le faites avec les champs. Par exemple, si vous voulez créer une variable qui contient la date du jour plus 30 jours, il vous suffit d’écrire dans 4D :

MaDate est alors créée et contient la valeur que vous voulez. Le programme interprète la ligne comme “MaDate prend la valeur de la date courante plus 30 jours”. Vous pourrez utiliser MaDate à chaque fois que vous le souhaiterez dans votre base. Par exemple, vous pouvez la stocker dans un champ du même type :

Toutefois, il est généralement conseillé de définir explicitement le type d’une variable. Pour plus d’informations sur le typage des variables dans une base, reportez-vous à la section Commandes du thème Compilateur.

Vous pouvez donner des valeurs aux variables et/ou récupérer leur valeur. Donner une valeur à une variable s’appelle assigner une valeur (ou affecter une valeur) et s’effectue à l’aide de l’opérateur d’assignation (:=). L’opérateur d’assignation est également utilisé pour assigner des valeurs aux champs.

L’opérateur d’assignation est le premier moyen pour créer une variable et lui donner une valeur. Vous placez le nom de la variable que vous voulez créer à gauche de l’opérateur. Par exemple :

crée la variable MonNombre et lui donne la valeur numérique 3. Si MonNombre existait déjà, elle prend simplement la valeur 3.

Bien entendu, les variables ne seraient pas très utiles si vous ne pouviez pas récupérer les valeurs qu’elles contiennent. De nouveau, vous utilisez l’opérateur d’assignation. Si vous devez placer la valeur de MonNombre dans un champ nommé [Produits]Taille, il vous suffit de placer MonNombre à droite de l’opérateur d’assignation :

Dans ce cas, [Produits]Taille vaudrait 3. Cet exemple est plutôt simple, mais il illustre le moyen élémentaire dont vous disposez pour transférer des données d’un objet vers un autre en utilisant le langage.

Important : Ne confondez pas l’opérateur d’assignation (:=) avec le signe égal (=) qui est un opérateur de comparaison. L’assignation et la comparaison sont deux opérations très différentes. Pour plus d’informations sur les opérateurs de comparaison, reportez-vous à la section Opérateurs.

Vous pouvez créer trois types de variables : des variables locales, des variables process et des variables interprocess. La différence entre ces trois types de variables est leur portée, ou les objets pour lesquels elles sont disponibles.

Le premier type de variable est la variable locale. Une variable locale, comme son nom l’indique, est locale à une méthode — c’est-à-dire accessible uniquement à l’intérieur de la méthode dans laquelle elle a été créée et inaccessible à l’extérieur de cette méthode. Pour une variable, être locale à une méthode signifie avoir une portée locale.

Vous utilisez une variable locale lorsque vous souhaitez limiter son fonctionnement à la méthode, pour une des raisons suivantes :

• Eviter des conflits de noms avec les autres variables.
• Utiliser temporairement des valeurs,
• Réduire le nombre de variables process.

Le nom d’une variable locale commence toujours par le signe dollar ($) et peut contenir jusqu’à 31 autres caractères. Si vous saisissez un nom plus long, 4D le tronque pour le ramener à 31 caractères.

Lorsque vous développez une base comportant de nombreuses méthodes et variables, il arrive souvent que vous n’ayez besoin d’utiliser une variable que dans une méthode. Vous pouvez alors créer et utiliser une variable locale, sans devoir vous soucier de l’existence d’une autre variable du même nom ailleurs dans la base.

Fréquemment, dans une base de données, des informations ponctuelles sont demandées à l’utilisateur. La commande Demander peut être appelée pour obtenir ces informations. Elle affiche une boîte de dialogue comportant un message demandant à l’utilisateur de répondre et, lorsque la réponse est validée, la retourne. Généralement, il n’est pas nécessaire de conserver cette information très longtemps dans vos méthodes. C’est l’endroit parfait pour utiliser une variable locale. Voici un exemple :

Cette méthode demande simplement à l’utilisateur de saisir un numéro d’identification. La réponse est placée dans une variable locale, $vsID, puis la méthode la recherche parmi les champs [Personnes]ID. Une fois la méthode terminée, la variable locale $vsID est effacée de la mémoire. Ce fonctionnement est bien adapté puisque la variable n’est utile qu’une seule fois et dans cette méthode uniquement.

Le second type de variable est la variable process. Une variable process est “visible” uniquement dans le process où elle a été créée. Elle est utilisable par toutes les méthodes du process et toutes les méthodes appelées depuis le process.

Le nom d’une variable process ne comporte aucun préfixe. Une variable process peut comporter jusqu’à 31 caractères.

En mode interprété, les variables sont gérées dynamiquement : elles sont créées en mémoire et effacées “à la volée”. En mode compilé, tous les process que vous créez (process utilisateurs) partagent la même définition des variables process, mais chaque process dispose de sa propre instance pour chaque variable. Par exemple, la variable maVar est une certaine variable dans le process P_1 et une autre variable dans le process P_2.

Un process peut lire et écrire des variables process dans un autre process à l'aide des commandes LIRE VARIABLE PROCESS et ECRIRE VARIABLE PROCESS. Nous vous recommandons de n'utiliser ces commandes que dans le cadre des besoins décrits ci-dessous (qui sont les raisons pour lesquelles ces commandes ont été créées dans 4D) :

• Communication interprocess à des endroits particuliers de votre code
• Gestion du glisser-déposer interprocess
• En client/serveur, communication entre les process sur les postes clients et les procédures stockées exécutées sur le serveur.

Pour plus d'informations, reportez-vous à la section Introduction aux process et à la description de ces commandes.

Le troisième type de variable est la variable interprocess. Les variables interprocess sont visibles dans toute la base et sont disponibles pour tous les process.

Le nom d’une variable interprocess débute toujours par le symbole (<>) — formé du symbole “inférieur à” suivi du symbole “supérieur à” — et peut comporter jusqu’à 31 caractères supplémentaires.

Note : Cette syntaxe peut être utilisée sur les plates-formes Windows et Macintosh. En outre, sous Mac OS uniquement, vous pouvez utiliser le symbole "diamant" (Option+v sur un clavier français).

Les variables interprocess sont principalement utilisées pour le partage d’informations entre les process.

En mode client/serveur, chaque poste (client et serveur) partage la même définition des variables interprocess, mais chacun utilise une instance différente d'une variable.

Dans l’éditeur de formulaires, le fait de donner un nom à un objet actif — bouton, bouton radio, case à cocher, zone de défilement, thermomètre, etc. — crée automatiquement une variable du même nom. Par exemple, si vous créez un bouton appelé MonBouton, une variable MonBouton est également créée. Notez bien que ce nom de variable n’est pas le libellé du bouton, mais son nom.

Ces variables vous permettent de contrôler et de gérer vos objets. Par exemple, lorsque l’utilisateur clique sur un bouton, la variable du bouton prend la valeur 1 ; sinon, le reste du temps, elle est à 0. La variable associée à un thermomètre ou un cadran vous permet de lire et de modifier les valeurs représentées. Par exemple, si l’utilisateur clique dans un thermomètre pour fixer une nouvelle valeur, la valeur de la variable est modifiée en conséquence. De même, si une méthode change la valeur de la variable, le thermomètre est redessiné pour afficher cette nouvelle valeur.

Pour plus d'informations sur les variables et les formulaires, reportez-vous au manuel Mode Développement de 4D ainsi qu'à la description de la fonction Evenement formulaire.

Vous pouvez laisser à 4D le soin de créer dynamiquement et en fonction des besoins, les variables associées à vos objets de formulaires (boutons, variables saisissables, cases à cocher, etc.). Pour cela, il suffit de laisser vide le champ "Nom de la variable" dans la Liste des propriétés pour l’objet :

Lorsqu’une variable n’est pas nommée, au moment du chargement du formulaire, 4D crée pour l’objet une nouvelle variable avec un nom calculé unique dans l’espace des variables process de l’interpréteur (ce qui permet d’utiliser ce mécanisme même en mode compilé). Cette variable temporaire sera détruite à la fermeture du formulaire.

Pour que ce principe puisse fonctionner en mode compilé, il est impératif que les variables dynamiques soient explicitement typées. Pour cela, vous disposez de deux possibilités :

• définir le type via le menu "Type de variable" de la Liste des propriétés.
  Note : Lorsque la variable est nommée, le menu "Type de variable" ne type pas réellement la variable mais permet uniquement de mettre à jour les options de la Liste des propriétés (hormis pour les variables image). Pour typer une variable nommée, il est nécessaire d’utiliser les commandes du thème Compilateur.
• utiliser un code d'initialisation spécifique lors du chargement du formulaire, en utilisant par exemple la commande VARIABLE VERS VARIABLE :
  
   Si(Evenement formulaire=Sur chargement)
    C_TEXTE($init)
    $Ptr_object:=OBJET Lire pointeur(Objet nommé;"Commentaires")
    $init:=""
    VARIABLE VERS VARIABLE(Numero du process courant;$Ptr_object->;$init)
 Fin de si

Note : Si vous définissez une variable dynamique, sélectionnez la valeur Aucun dans le menu "Type de variable" et n'utilisez pas de code d'initialisation, une erreur de typage sera retournée par le compilateur.

Dans le code 4D, les variables dynamiques sont accessibles via un pointeur obtenu avec la commande OBJET Lire pointeur. Par exemple :

L’intérêt de ce mécanisme est double :

• Il permet le développement de composants de type "sous-formulaire" pouvant être utilisés plusieurs fois dans un même formulaire hôte. Prenons le cas par exemple d’un sous-formulaire datepicker inséré deux fois dans un formulaire hôte pour définir une date de début et une date de fin. Ce sous-formulaire va utiliser des objets pour le choix du jour du mois et de l'année. Il faut donc que ces objets travaillent avec des variables différentes pour la date de début et la date de fin. Laisser 4D créer leur variable avec un nom unique permet de résoudre cette difficulté.
• Il permet de limiter la consommation mémoire. En effet, les objets de formulaire ne travaillent qu'avec des variables process ou interprocess. Or, en mode compilé, une instance de chaque variable process est créée dans tous les process, y compris les process du serveur. Cette instance consomme de la mémoire, même si le formulaire n’est pas utilisé au cours de la session. Laisser 4D créer dynamiquement les variables au chargement des formulaires permet donc d’économiser la mémoire.

Note : Lorsqu’il n’y a pas de nom de variable, c’est le nom de l’objet encadré de guillemets qui est affiché dans l’éditeur de formulaires (lorsque l'objet affiche par défaut un nom de variable).

4D exploite un certain nombre de variables particulières appelées variables système. Ces variables vous permettent de contrôler de nombreuses opérations. Toutes les variables système sont des variables process, disponibles à l’intérieur d’un seul process.

La plus importante de toutes est la variable système OK. Comme son nom le laisse supposer, elle vous indique si tout est OK dans un process particulier. Est-ce que l’enregistrement a bien été sauvegardé ? Est-ce que l’import d’enregistrements s’est bien déroulé ? Est-ce que l’utilisateur a cliqué sur le bouton OK ? La variable système OK prend la valeur 1 lorsqu’une opération s’est correctement déroulée, et 0 dans le cas contraire.

Pour plus d'informations sur les variables système, reportez-vous à la section traitant des Variables système.