Guide du typage

4D - Documentation   Français   English   German   Español   Japanese   4D v11 SQL, Commandes par thèmes   4D v11 SQL, Liste alphabétique des commandes   4D v11 SQL, Constantes par thèmes   Retour   Précédent   Suivant

version 2004 (Modifiée)


Cette section décrit les principales causes de conflits de types sur les variables, ainsi que les manières de les éviter.

Conflits sur les variables simples


Les conflits de types simples peuvent se résumer comme suit :

conflit entre deux utilisations,

conflit entre une utilisation et une directive de compilation,

conflit par retypage implicite,

conflit entre deux directives de compilation.

Conflit entre deux utilisations

Le conflit de types le plus simple est celui pour lequel un même nom de variable désigne deux objets différents. Imaginez que dans une application, vous écriviez :

   LaVariable:=5

et que, quelque part ailleurs, dans la même application, vous écriviez :

   LaVariable:=Vrai

Vous générez un conflit de types. Le remède est simple : renommez l'une des deux variables.

Conflit entre une utilisation et une directive de compilation

Imaginez que dans une application, vous écriviez :

   LaVariable:=5

et que, quelque part ailleurs, dans la même application, vous écriviez :

   C_BOOLEEN(LaVariable)

Le compilateur, peignant d'abord les directives de compilation, fera de LaVariable un Booléen mais lorsqu'il découvrira :

   LaVariable:=5

il signalera un conflit de types. Ici encore, le remède est simple : renommez votre variable ou modifiez la directive de compilation.

L'utilisation de variables de types différents dans une expression génère des incohérences. Le compilateur signale très logiquement les incompatibilités. Prenons un exemple simple. Vous écrivez :

   vBooléen:=Vrai    `Le compilateur déduit que vBooléen est de type Booléen
   C_ENTIER(<>vEntier)   `Déclaration d'un Entier par une directive de compilation
   <>vEntier:=3   `Commande compatible avec la directive de compilation
   LaVar:= <>vEntier+vBooléen   `Opération contenant des variables dont les types sont incompatibles

Conflit par retypage implicite

Certaines fonctions renvoient des variables d'un type bien précis. L'affectation du résultat d'une de ces variables à une variable déjà typée différemment provoquera un conflit de types si vous ne faites pas attention.

Dans une application interprétée, vous pouvez écrire :

   No_Ident:=Demander("Numéro d'identification")   `No_Ident est de type Texte
   Si(Ok=1)
      No_Ident:=Num(No_Ident)   `No_Ident est de type Numérique
      CHERCHER([Personnes]Id= No_Ident)
   Fin de si

Vous générez ici un conflit de type sur la troisième ligne. Le remède consiste à contrôler le comportement de la variable. Dans certains cas, vous aurez à créer des variables intermédiaires d'un nom différent. Dans d'autres cas, comme celui-ci en particulier, vous pouvez structurer différemment votre méthode :

   No_Ident:=Num(Demander("Numéro d'identification"))  `No_Ident est de type Numérique
   Si(Ok=1)
      CHERCHER([Personnes]Id=No_Ident)
   Fin de si

Conflit entre deux directives de compilation

Déclarer deux fois la même variable par deux directives de compilation différentes constitue, bien sûr, un retypage. Si, dans la même base, vous écrivez :

   C_BOOLEEN(LaVariable)
   C_TEXTE(LaVariable)

le compilateur est confronté à un dilemme et vous demande quelles étaient vos intentions. Le remède est simple : renommez l'une des deux variables.

Il ne faut pas oublier que le conflit de types pour une directive C_ALPHA peut surgir si vous modifiez la longueur maximale de la chaîne de caractères. Ainsi, si vous écrivez :

   C_ALPHA(5;MaChaine)
   MaChaine:="Fleur"
   C_ALPHA(7;MaChaine)
   MaChaine:="Bonjour"

le compilateur est dans une situation de conflit puisque dans la déclaration des variables de type Alphanumérique, il doit réserver un emplacement de taille adéquate.

Dans ce cas, le remède consiste à donner une directive de compilation qui prenne la longueur maximale, puisque par défaut, le compilateur acceptera une longueur inférieure. Vous pouvez donc écrire :

   C_ALPHA(7;LaChaine)
   LaChaine:="Fleur"
   LaChaine:="Bonjour"

Note : Si vous aviez écrit deux fois C_ALPHA(7;LaChaine), c'est-à-dire :

   C_ALPHA(7;LaChaine)
   LaChaine:="Fleur"
   C_ALPHA(7;LaChaine)
   LaChaine:="Bonjour"

le compilateur l'accepterait tout à fait. C'est simplement redondant.

Note sur les variables locales

Les conflits de types pour les variables locales sont absolument identiques aux conflits de types pour les variables process et interprocess, à ceci près que ces conflits se déroulent dans un espace plus restreint.

Les conflits se jouent au niveau général de la base pour les variables process et interprocess. Les conflits se jouent au niveau particulier de la méthode pour les variables locales. Vous ne pouvez donc pas écrire dans la même méthode :

   $Temp:="Bonjour" 

et puis plus loin

   $Temp:=5

En revanche, vous pouvez écrire dans une méthode M1 :

   $Temp:="Bonjour"

et dans une méthode M2 :

   $Temp:=5

Conflits sur les variables tableau


Les conflits possibles pour un tableau ne portent jamais sur la taille du tableau. En mode compilé comme en mode interprété, les tableaux sont gérés dynamiquement. La taille d'un tableau peut varier au fil des méthodes et vous n'avez pas, bien sûr, à déclarer une taille maximale pour un tableau.

Vous pouvez, en conséquence, dimensionner un tableau à zéro, ajouter ou retirer des éléments, en effacer le contenu. Dans l'optique de la compilation, et ce, dans une même méthode, pour un tableau local ou dans toute la base pour un tableau process ou interprocess, vous devez veiller aux points suivants :

ne pas changer le type des éléments du tableau,

ne pas changer le nombre de dimensions d'un tableau,

dans le cas des tableaux Alpha, ne pas changer la longueur des chaînes de caractères.

Changement de type des éléments d'un tableau

Si vous déclarez un tableau comme étant un tableau d'Entiers, il doit rester un tableau d'Entiers pour toute la base. Il ne pourra jamais contenir, par exemple, des éléments de type Booléen.

Si, dans une application, vous écrivez :

   TABLEAU ENTIER(LeTableau;5)
   TABLEAU BOOLEEN(LeTableau;5)

le compilateur ne peut identifier pour vous le type de LeTableau.

Renommez simplement l'un des deux tableaux.

Changement du nombre de dimensions d'un tableau

En version interprétée, il peut vous arriver de changer le nombre de dimensions d'un tableau.

Lorsque le compilateur établit sa table des symboles, il gère différemment les tableaux à une dimension et les tableaux à deux dimensions.

En conséquence, un tableau déclaré une fois comme étant un tableau à une dimension ne peut être re-déclaré ou utilisé comme un tableau à deux dimensions et vice versa.

Dans une même base, vous ne pouvez donc pas avoir :

   TABLEAU ENTIER(LeTableau1;10)
   TABLEAU ENTIER(LeTableau1;10;10)

En revanche, vous pouvez, évidemment, avoir dans la même application

   TABLEAU ENTIER(LeTableau1;10)
   TABLEAU ENTIER(LeTableau2;10;10)

Par ailleurs, vous pouvez parfaitement écrire :

   TABLEAU BOOLEEN(LeTableau;5)
   TABLEAU BOOLEEN(LeTableau;10)

Comme vous pouvez le noter dans nos exemples, c'est le nombre de dimensions d'un tableau qu'on ne peut changer en cours d'application et non la valeur des dimensions du tableau.

Note : Un tableau à deux dimensions est en fait un ensemble de plusieurs tableaux à une dimension. Pour plus de précisions, reportez-vous à la section Tableaux à deux dimensions.

Cas des tableaux de chaînes fixes

Les tableaux de chaînes fixes, aussi appelés tableaux Alpha, suivent la même règle que les variables Alphanumériques et pour les mêmes raisons.

Si vous écrivez :

   TABLEAU ALPHA(5;LeTableau;10)
   TABLEAU ALPHA(10;LeTableau;10)

le compilateur détecte un conflit de longueur. Le remède est simple : comme dans les chaînes Alpha, vous déclarez la longueur maximale. Le compilateur gère automatiquement les longueurs inférieures.

Retypages implicites

Lors de l'utilisation des commandes COPIER TABLEAU, ENUMERATION VERS TABLEAU, TABLEAU VERS ENUMERATION, SELECTION VERS TABLEAU, SELECTION LIMITEE VERS TABLEAU, TABLEAU VERS SELECTION, VALEURS DISTINCTES, vous pouvez, volontairement ou involontairement, être conduit à des changements de type d'éléments ou de nombre de dimensions, ou pour un tableau Alpha, à des changements de longueur de chaîne. Vous vous retrouverez donc dans un des trois cas cités précédemment.

Le compilateur vous délivrera un message d'erreur et la correction que vous aurez à faire sera en général évidente. Des exemples de retypage implicite de tableaux sont fournis dans la section Précisions de syntaxe.

Tableaux locaux

Si vous souhaitez compiler une base de données qui utilise des tableaux locaux (tableaux visibles uniquement par les méthodes qui les ont créés), il est nécessaire de les déclarer explicitement dans 4D avant de les utiliser.

La déclaration explicite d'un tableau signifie l'utilisation d'une commande de type TABLEAU REEL, TABLEAU ENTIER, etc.

Par exemple, si une méthode génère un tableau local d'entiers contenant 10 valeurs, vous devez écrire au préalable la ligne suivante :

   TABLEAU ENTIER($MonTableau;10)

Typage des variables dessinées dans les formulaires


Les variables dessinées dans un formulaire, qu'il s'agisse d'une case à cocher ou d'une zone externe, sont toutes des variables soit process, soit interprocess.

En mode interprété, la question des types de ces variables ne se pose pas dans la pratique. Elle peut se poser, en revanche, dans l'optique d'une application compilée. Les règles du jeu sont cependant transparentes :

soit vous avez typé votre variable,

soit le compilateur lui attribue un type par défaut qui peut être défini dans les Préférences de compilation (voir le manuel Mode Développement).

Variables considérées par défaut comme des Numériques

Les variables suivantes sont considérées comme des Numériques par défaut :

Case à cocher

Case a cocher 3D

Bouton

Bouton inversé

Bouton invisible

Bouton 3D

Bouton image

Grille de boutons

Bouton radio

Bouton radio 3D

Radio image

Menu image

Menu déroulant hiérarchique

Liste hiérarchique

Règle

Cadran

Thermomètre

Note : Les variables de type Règle, Cadran et Thermomètre seront toujours typées comme des Numériques, même si vous avez choisi l'option Entier long par défaut pour le type des boutons dans les Préférences.

Pour ces variables, vous ne pouvez jamais vous trouver dans un conflit de types puisqu'elles ne peuvent avoir d'autres types que ce type-là, qu'on soit en interprété ou en compilé.

Les seuls conflits de types possibles sur l'une de ces variables viendraient du fait que le nom d'une variable serait le même que celui d'une autre variable placée à un autre endroit dans l'application. Dans ce cas, le remède consiste à renommer cette deuxième variable.

Variable Graphe

Une zone de graphe a automatiquement le type Graphe (Entier long). Il ne peut jamais y avoir de conflit de type.

Les seuls conflits de type possibles sur une variable de type Graphe viendraient du fait que le nom de cette variable serait le même que celui d'une autre variable placée à un autre endroit dans l'application. Dans ce cas, le remède consiste à renommer cette deuxième variable.

Variable Zone externe

Une zone externe est toujours un Entier long. Il ne peut jamais y avoir de conflit de types.

Les seuls conflits de types possibles sur une variable Zone externe viendraient du fait que le nom de cette variable serait le même que celui d'une autre variable placée à un autre endroit dans l'application. Dans ce cas, le remède consiste à renommer cette deuxième variable.

Variables considérées par défaut comme du Texte

Ces variables sont les suivantes :

Variable non-saisissable,

Variable saisissable,

Liste déroulante,

Menu/liste déroulante,

Zone de défilement,

Combo box,

Pop-up Menu,

Onglet.

Ces variables se divisent en deux catégories :

les variables simples (variables saisissables et variables non-saisissables),

les variables d'affichage de tableaux (listes déroulantes, menus/listes déroulantes, zone de défilement, pop-up menu, combo box, onglets).

Variables simples

Par défaut, ces variables reçoivent le type Texte. Si elles sont utilisées dans une méthode objet ou une méthode formulaire, c'est le type que vous avez choisi qui leur sera attribué.

Vous n'avez aucun risque de conflit de types autre que celui qui serait généré par une attribution préalable du même nom à une autre variable.

Variables d'affichage de tableaux

De nombreuses variables vous servent à afficher des tableaux dans les formulaires. Si les valeurs par défaut ont été saisies au niveau des contrôles de saisie des variables en mode Développement, il est conseillé de typer les variables correspondantes explicitement par une déclaration de type tableau (TABLEAU ALPHA, TABLEAU TEXTE...).

Questions de type autour des pointeurs


Si vous utilisez des pointeurs dans vos applications, vous avez pu profiter de la puissance et de la flexibilité de cet outil dans 4D. Le compilateur en conserve intégralement les avantages.

Un pointeur peut pointer indifféremment sur une table, une variable ou un champ. Un même pointeur peut pointer sur des variables de type différent : veillez à ne pas générer des conflits artificiellement, en attribuant à une même variable des types différents.

Faites simplement attention à ne pas changer en cours de route le type de la variable sur laquelle pointe le pointeur en faisant, par exemple, une manipulation du type suivant :

   LaVariable:=5,3
   LePointeur:=-> LaVariable 
   LePointeur->:=6,4
   LePointeur->:=Faux

Dans ce cas de figure, votre pointeur dépointé est une variable Numérique. En affectant à cette variable une valeur booléenne, vous provoquez un conflit de types.

Si vous avez besoin dans une même méthode d'utiliser les pointeurs pour des propos différents, prenez soin de définir votre pointeur :

   LaVariable:=5,3
   LePointeur:=-> LaVariable 
   LePointeur->:=6,4
   LeBool:=Vrai
   LePointeur:=->LeBool
   LePointeur->:=Faux

Un pointeur n'a aucune existence propre. Il est toujours défini en fonction de l'objet qu'il représente. C'est pourquoi le compilateur ne peut pas détecter des conflits de types générés par une utilisation sans contrôle des pointeurs. Vous n'aurez donc pas, en cas de conflit, de message d'erreur durant la phase de typage ou celle de compilation.

Cela ne veut pas dire que lorsque vous utilisez des pointeurs, vous travaillez sans filet. Le compilateur peut vérifier vos utilisations de pointeurs lorsque vous cochez l'option Contrôle d'exécution dans les Préférences de compilation (cf. manuel Mode Développement).

Plug-ins


Généralités

Le compilateur a besoin, au moment de la compilation, des définitions des commandes des plug-ins utilisées dans la base à compiler, c'est-à-dire du nombre et du type des paramètres de ces commandes. Les risques d'erreur de typage sont inexistants à partir du moment où le compilateur trouve effectivement dans l'application ce que vous avez déclaré.

Assurez-vous que vos plug-ins sont installés dans le dossier PlugIns, à l'un des emplacements autorisés par 4D : à côté du fichier de structure de la base ou à côté de l'application exécutable (Windows) / dans le progiciel (Mac OS). Pour des raisons de compatibilité, il reste possible d'utiliser un dossier Win4DX ou Mac4DX à côté du fichier de structure. Pour plus d'informations, reportez-vous au Guide d'installation de 4D.

Le compilateur ne duplique pas le fichier mais tient compte des déclarations des commandes sans rien vous demander en supplément.

Si vos plug-ins sont placés ailleurs, le compilateur vous demande de les localiser lors du typage, via une boîte de dialogue d'ouverture de documents.

Routines recevant des paramètres implicites

Certains plug-ins, par exemple 4D Write, utilisent des commandes qui provoquent l'appel implicite à des commandes 4D.

Prenons un exemple avec 4D Write. Vous disposez d'une commande appelée WR APPELER SUR EVENEMENT. La syntaxe de cette commande est :

WR APPELER SUR EVENEMENT(LaZone;Evénement;MéthodeEvénement)

Le dernier paramètre que vous passez à cette routine est le nom d'une méthode, que vous aurez vous-même écrite dans 4D. Cette méthode sera appelée par 4D Write chaque fois que l'événement attendu sera reçu et cette méthode recevra automatiquement les paramètres suivants :

ParamètresTypeDescription
$0Entier longRetour de fonction
$1Entier longZone 4D Write
$2Entier longTouche Maj.
$3Entier longTouche Alt (Windows), Option (Mac OS)
$4Entier longTouche Ctrl (Windows), Commande (Mac OS)
$5Entier longType d'événement qui a provoqué l'appel
$6 Entier longValeur variant en fonction du paramètre Evénement

Afin que le compilateur connaisse l'existence de ces paramètres et les prenne en compte, vous devez vous assurer qu'ils peuvent effectivement être typés, soit par une directive de compilation, soit parce que leur utilisation, suffisamment explicite, permet de déduire leur type.

Composants 4D


4D permet de créer et de manipuler des composants. Un composant 4D est un ensemble d'objets 4D représentant une ou plusieurs fonctionnalité(s) groupée(s) dans un fichier de structure (appelé base matrice), qu'il est possible d'installer dans différentes bases (appelées bases hôtes).

Une base hôte exécutée en mode interprété peut utiliser indifféremment des composants interprétés ou compilés. Il est possible d'installer des composants interprétés et compilés dans la même base hôte. En revanche, une base hôte exécutée en mode compilé ne peut pas utiliser de composant interprété. Dans ce cas, seuls des composants compilés peuvent être employés.

Une base hôte interprétée contenant des composants interprétés peut être compilée si elle ne fait pas appel à des méthodes du composant interprété. Dans le cas contraire, une boîte de dialogue d'alerte apparaît lorsque vous tentez de compiler l'application et la compilation est impossible.

Un conflit de nom peut se produire lorsqu'une méthode projet partagée du composant a le même nom qu'une méthode projet de la base hôte. Dans ce cas, lorsque du code est exécuté dans le contexte de la base hôte, c'est la méthode de la base hôte qui est appelée. Ce principe permet de "masquer" une méthode du composant avec une méthode personnalisée (par exemple pour

obtenir une fonctionnalité différente). Lorsque le code est exécuté dans le contexte du

composant, c'est la méthode du composant qui est appelée. Un masquage est signalé par un warning lors de la compilation de la base hôte.

Si deux composants partagent des méthodes du même nom, une erreur est générée au moment de la compilation de la base hôte.

Pour plus d'informations sur les composants, reportez-vous au manuel Mode Développement.

Manipulation des locales $0…$N et passation des paramètres


Les manipulations des variables locales suivent toutes les règles déjà énoncées. De même que toutes les autres variables, elles ne peuvent être retypées en cours de méthode.

Dans ce paragraphe, nous abordons deux cas de figure où l'inattention pourrait conduire à des conflits de types :

Lorsque vous avez en fait besoin d'un retypage. L'utilisation de pointeurs vous permet alors d'éviter les conflits de types.

Lorsque vous avez besoin d'adresser des paramètres par indirection.

Utiliser les pointeurs pour éviter les retypages

Il n'est pas possible de retyper une variable. Il est, en revanche, tout à fait possible de faire pointer un pointeur successivement sur des variables de type différent.

Un exemple nous permet d'illustrer ce propos : écrivons une fonction qui nous renvoie l'occupation mémoire d'un tableau à une dimension suivant son type. Le résultat est un numérique dans tous les cas sauf deux : dans le cas des tableaux Texte et des tableaux Image, la taille mémoire occupée par le tableau dépend de valeurs inexprimables sous forme numérique (cf. section Tableaux et mémoire).

Dans le cas des tableaux Texte et des tableaux Image, nous renverrons comme résultat une chaîne de caractères. Cette fonction requiert un paramètre : un pointeur sur le tableau dont on veut connaître l'occupation mémoire.

Pour effectuer cette opération, vous avez le choix entre deux méthodes :

ne travailler qu'avec des variables locales et ne pas vous soucier de leur type — mais dans ce cas, la méthode ne fonctionnera qu'en mode interprété.

utiliser des pointeurs et alors travailler indifféremment en interprété et en compilé.

Fonction OccupMém en interprété seulement (exemple pour Macintosh)

   $Taille:=Taille tableau($1->)
   $Type:=Type($1->)
   Au cas ou
      :($Type=Est un tableau numérique)
         $0:=8+($Taille*10)   ` $0 est un Numérique
      :($Type=Est un tableau entier)
         $0:=8+($Taille*2)   
      :($Type=Est un tableau entierlong)
         $0:=8+($Taille*4)   
      :($Type=Est un tableau date)
         $0:=8+($Taille*6)
      :($Type=Est un tableau texte)
         $0:=Chaine(8+($Taille*4))+("+Somme des longueurs des textes")   ` $0 est un Texte
      :($Type=Est un tableau image)
         $0:=Chaine(8+($Taille*4))+("+Somme des tailles des images")   ` $0 est un Texte
      :($Type=Est un tableau pointeur)
         $0:=8+($Taille*16)   
      :($Type=Est un tableau booléen)
         $0:=8+($Taille/8)   
   Fin de cas

Dans la méthode ci-dessus, il y a changement de type de $0 suivant les valeurs de $1.

Fonction OccupMém en mode interprété et compilé (exemple pour Macintosh)

Ecrivons maintenant cette méthode en utilisant un pointeur :

   $Taille:=Taille tableau($1->)
   $Type:=Type($1->)
   VarNum:=0
   Au cas ou
      :($Type=Est un tableau numérique)
         VarNum:=8+($Taille*10)   ` VarNum est un Numérique
      :($Type=Est un tableau entier)
         VarNum:=8+($Taille*2)   
      :($Type=Est un tableau entierlong)
         VarNum:=8+($Taille*4)   
      :($Type=Est un tableau date)
         VarNum:=8+($Taille*6)   
      :($Type=Est un tableau texte)
         VarText:=Chaine(8+($Taille*4))+("+Somme des longueurs des textes")  
      :($Type=Est un tableau image)
         VarText:=Chaine(8+($Taille*4))+("+Somme des tailles des images")
      :($Type=Est un tableau pointeur)
         VarNum:=8+($Taille*16)   
      :($Type=Est un tableau booléen)
         VarNum:=8+($Taille/8)   
   Fin de cas
   Si (VarNum#0)
      $0:=->VarNum
   Sinon
      $0:=->VarText
   Fin de si

Il faut noter la différence entre ces deux séquences :

dans le premier cas, le résultat de la fonction est la variable que l'on attendait,

dans le second cas, le résultat de la fonction est un pointeur sur cette variable. Il vous appartient alors de simplement dépointer le résultat reçu.

Indirections sur les paramètres

Le compilateur gère la puissance et la souplesse de l'indirection sur les paramètres. En mode interprété, 4D vous donne toute latitude concernant le nombre et le type des paramètres. Vous gardez en mode compilé cette même liberté à condition de ne pas introduire de conflit de types et de ne pas utiliser, dans la méthode appelée, plus de paramètres que vous en avez passés, ce qui est facile.

Afin de contourner un éventuel conflit, les paramètres adressés par indirection doivent tous être du même type.

Pour une bonne gestion de cette indirection, il est important de respecter la convention suivante : si tous les paramètres ne sont pas adressés par indirection, ce qui est le cas le plus fréquent, il faut que les paramètres adressés par indirection soient passés en fin de liste.

A l'intérieur de la méthode, l'adressage par indirection se fait sous la forme : ${$i}, $i étant une variable numérique. ${$i} est appelé paramètre générique.

Illustrons notre propos par un exemple : écrivons une fonction qui prend des valeurs, fait leur somme et renvoie cette somme formatée suivant un format qui peut varier avec les valeurs.

A chaque appel à cette méthode, le nombre de valeurs à additionner peut varier. Il faudra donc passer comme paramètre à notre méthode les valeurs, en nombre variable, et le format, exprimé sous forme d'une chaîne de caractères.

Un appel à cette fonction se fera de la façon suivante :

   Résultat:=LaSomme("##0,00";125,2;33,5;24)

La méthode appelante récupérera dans ce cas la chaîne : 182,70, somme des nombres passés, formatée suivant le format spécifié. D'après ce que l'on a vu plus haut, les paramètres de la fonction doivent être passés dans un ordre précis : le format d'abord et ensuite les valeurs, dont le nombre peut varier d'un appel à l'autre.

Examinons maintenant la fonction que nous appelons LaSomme :

   $Somme:=0
   Boucle($i;2;Nombre de parametres)
      $Somme:=$Somme+${$i}
   Fin de boucle
   $0:=Chaine($Somme;$1)

Cette fonction pourra être appelée de diverses manières :

   Résultat:=LaSomme("##0,00";125,2;33,5;24)
   Résultat:=LaSomme("000";1;18;4;23;17)

De même que pour les autres variables locales, la déclaration du paramètre générique par directive de compilation n'est pas obligatoire. Si elle est nécessaire (cas d'ambiguïté ou d'optimisation), elle se fait avec la syntaxe suivante :

   C_ENTIER(${4})

La commande ci-dessus signifie que tous les paramètres à partir du quatrième (inclus) seront adressés par indirection. Ils seront tous de type Entier. Les types de $1, $2 et $3 pourront être quelconques. En revanche, si vous utilisez $2 par indirection, le type utilisé sera le type générique. Il sera donc de type Entier, même si pour vous, par exemple, il était de type Réel.

Note : Le compilateur utilisant cette commande durant le typage, le nombre, dans la déclaration, doit toujours être une constante et jamais une variable.

Variables réservées et constantes


Des variables et des constantes de 4D ont un type et une identité fixés par le compilateur. On ne peut donc créer une nouvelle variable, une méthode, une fonction ou une commande de plug-in portant le nom d'une de ces variables ou d'une de ces constantes. Bien entendu, vous pouvez tester leur valeur et les utiliser comme auparavant.

Variables système

Voici la liste complète des Variables système de 4D accompagnées de leur type.

VariableType
OKEntier long
DocumentAlpha (Chaîne fixe) : 255
FldDelimitEntier long
RecDelimitEntier long
ErrorEntier long
MouseDownEntier long
KeyCodeEntier long
ModifiersEntier long
MouseXEntier long
MouseYEntier long
MouseProcEntier long

Variables des états rapides

Lorsqu'on crée une colonne calculée dans un état, 4D crée automatiquement une variable C1 pour la première, C2, C3... pour les autres. Généralement, cette création est faite de façon transparente pour vous.

Dans le cas où vous utiliseriez ces variables dans des méthodes, souvenez-vous que, comme les autres variables, les variables C1, C2... ne peuvent être retypées.

Constantes prédéfinies 4D

La liste des constantes prédéfinies de 4D peut être consultée dans ce manuel, vous pouvez également les visualiser dans l'Explorateur, en mode Développement.

Référence

Conseils d'optimisation, Messages d'erreurs, Précisions de syntaxe, Utilisation des directives de compilation.


4D - Documentation   Français   English   German   Español   Japanese   4D v11 SQL, Commandes par thèmes   4D v11 SQL, Liste alphabétique des commandes   4D v11 SQL, Constantes par thèmes   Retour   Précédent   Suivant