Vous pouvez utiliser la notation objet pour lire ou écrire les valeurs des objets du langage 4D. Pour des raisons de compatibilité, cette fonctionnalité nécessite d'être activée explicitement via une option de compatibilité dans les bases de données converties depuis une version antérieure à 4D v17. La notation objet peut être utilisée dans 4D partout où des expressions sont attendues.

Chaque valeur de propriété à laquelle on accède via la notation objet est une expression. Lorsque la notation objet est activée dans votre base de données (voir ci-dessous), vous pouvez utiliser cette notation à chaque endroit où des expressions 4D sont acceptées :

• dans le code 4D, soit écrit dans des méthodes (éditeur de méthodes) soit externalisé (formules, fichiers de balises 4D traités par PROCESS 4D TAGS ou le serveur Web, fichiers d'export, documents 4D Write Pro, etc.),
• dans les zones Expression du débogueur et de l'Explorateur d'exécution,
• dans la Liste des propriétés de l'éditeur de formulaires pour les objets de formulaires : zone "Variable ou Expression" ainsi que les diverses expressions utilisables dans les list box de type sélection et leurs colonnes (source de données, couleur de fond, style ou couleur de police).

Les objets manipulés via la notation objet doivent être initialisés, par exemple à l'aide de la commande New object, sinon l'accès à leurs propriétés en écriture ou en lecture génère une erreur de syntaxe. Exemple :

Le même principe s'applique pour les champs de type Objet :

La notation objet est utilisée pour accéder aux valeurs de propriétés d'objets et aux éléments de collections via des séquences de symboles et de propriétés référencées (tokens).

Avec la notation objet, il est possible d'accéder aux propriétés d'objets (aussi appelées attributs d'objets) de deux façons :

• à l'aide du symbole "point" :
  
  objet.NomPropriété
  
  Exemple :
  
   employee.name:="Smith"
• à l'aide d'une chaîne entre crochets :
  
  objet["NomPropriété"]
  
  Exemple :
  
   $vName:=employee["name"]

Comme la valeur d'une propriété d'objet peut elle-même être un objet ou une collection, la notation objet requiert une séquence de symboles pour accéder aux sous-propriétés, par exemple :

La notation objet est utilisable avec tout élément de langage qui contient ou retourne un objet, c'est-à-dire :

• avec les objets eux-mêmes (stockés dans des variables, champs, propriétés d'objets, tableaux d'objets ou éléments de collections).
  Exemples :
  
   $age:=$myObjVar.employee.age //variable
 $addr:=[Emp]data_obj.address //champ
 $city:=$addr.city //propriété d'un objet
 $pop:=$aObjCountries{2}.population //tableau d'objets
 $val:=$myCollection[3].subvalue //élément de collection

• avec les commandes 4D qui retournent des objets.
  Exemple :
  
   $measures:=Get database measures.DB.tables

• avec les méthodes projet qui retournent des objets.
  Exemple :
  
    // MyMethod1
 C_OBJECT($0)
 $0:=New object("a";10;"b";20)
 
  //myMethod2
 $result:=MyMethod1.a //10

• avec les collections
  Exemple :
  
   myColl.length //taille de la collection
 maxSal:=myColl.max("salary")

Pour accéder à un élément de collection, vous devez passer le numéro de l'élément à l'intérieur de crochets :

Note : Pour plus d'informations sur les variables de type collection, reportez-vous à la section .

Vous pouvez utiliser toute expression 4D valide qui retourne un entier positif dans expression. Exemples :

Note : N'oubliez pas que les éléments de collection sont numérotés à partir de 0.

Vous pouvez affecter une valeur à un élément de collection à l'aide de la notation objet :

Si le numéro de cet élément est au-delà du dernier élément existant de la collection, la collection est automatiquement redimensionnée et les nouveaux éléments intermédiaires prennent la valeur null :

Propriété length

La propriété length est disponible automatiquement pour toutes les collections et retourne la taille de la collection, i.e. le nombre d'éléments qu'elle contient. Vous pouvez accéder à cette propriété de deux manières :

• en utilisant le symbole "point", par exemple :
  
   $vSize:=myCollection.length
• en utilisant une chaîne entre crochets, par exemple :
  
   $vSize:=myCollection["length"]

A noter que la propriété length est en lecture seulement, elle ne peut pas être fixée.

Il est possible d'accéder aux valeurs de propriétés via des pointeurs. La notation objet pour les pointeurs est semblable à la notation objet standard, à la seule différence que le symbole "point" doit être omis.

• Accès direct :
  
  pointeurObjet->nomPropriété
• Accès par le nom :
  
  pointeurObjet->["nomPropriété"]

Exemple :

Lorsque la notation objet est utilisée, la valeur null est prise en charge via la commande Null. Cette commande peut être utilisée pour affecter ou comparer la valeur null aux propriétés d'objets ou aux éléments de collections, par exemple :

Pour plus d'informations, veuillez vous reporter à la description de la commande Null.

L'évaluation d'une propriété d'objet peut parfois produire une valeur indéfinie (undefined). En règle générale, lorsque le code tente de lire ou d'affecter des expressions indéfinies, 4D génère des erreurs, hormis dans les cas décrits ci-dessous :

• La lecture d'une propriété d'un objet ou d'une valeur indéfini(e) renvoie Indéfini ; l'affectation d'une valeur indéfinie à des variables (hors tableaux) a le même effet qu'appeler CLEAR VARIABLE avec elles :
  
   C_OBJECT($o)
 C_LONGINT($val)
 $val:=10 //$val=10
 $val:=$o.a //$o.a est indéfini (pas d'erreur), et affecter cette valeur efface la variable
  //$val=0
• La lecture de la propriété length d'une collection indéfinie renvoie 0 :
  
   C_COLLECTION($c) //variable créée mais pas de collection définie
 $size:=$c.length //$size = 0
• Une valeur indéfinie passée en paramètre à une méthode projet est automatiquement convertie en 0 ou en "" en fonction de la déclaration du type du paramètre.
  
   C_OBJECT($o)
 mymethod($o.a) //passage d'un paramètre indéfini
 
  //Dans la méthode mymethod
 C_TEXT($1) //Paramètre de type texte
  // $1 contient ""
• Une expression de condition est automatiquement convertie à Faux lorsque son évaluation donne Indéfinie avec les mots-clés Si et Au cas ou :
  
   C_OBJECT($o)
 If($o.a) // faux
 End if
 Case of
    :($o.a) // faux
 End case

• L'affectation d'une valeur indéfinie à une propriété d'objet existante réinitialise ou efface sa valeur, selon son type :
  
  • Objet, collection, pointeur : Null
  • Image : image vide
  • Booléen : Faux
  • Chaîne : ""
  • Numérique : 0
  • Date : !00-00-00! si la base utilise le type date pour les objets, sinon ""
  • Heure : 0 (nombre de ms)
  • Indéfini, Null : pas de changement
   C_OBJECT($o)
 $o:=New object("a";2)
 $o.a:=$o.b //$o.a=0

• L'affectation d'une valeur indéfinie à une propriété d'objet inexistante ne fait rien.

Lorsque des expressions d'un type donné sont attendues dans votre code 4D, vous pouvez vous assurer qu'elles auront le type souhaité même en cas de valeur Indéfinie en les encadrant avec la commande de transtypage 4D appropriée : String, Num, Time, Date, Bool. Ces commandes retournent une valeur vide du type spécifié lorsque l'expression est évaluée à Indéfinie. Par exemple :

Les commandes Formula ou Formula from string vous permettent de créer des objets "formule" natifs que vous pouvez encapsuler dans les propriétés des objets :

Ces propriétés sont des "méthodes objet", i.e. qu'elles sont reliées à leur objet parent. Afin d'exécuter une méthode stockée dans la propriété d'un objet, utilisez l'opérateur ( ) après le nom de la propriété, comme suit :

La syntaxe avec des crochets est également prise en charge :

Vous pouvez appeler votre formule en lui passant des paramètres $1, $2, etc., tout comme pour les méthodes projet de 4D.

Notez que, même sans paramètres, une méthode objet qui doit être exécutée doit être appelée avec des parenthèses ( ). Appeler uniquement la propriété de l'objet retournera une nouvelle référence vers la formule (et ne l'exécutera pas) :

Les règles de nommage des tokens (noms des propriétés d'objets auxquelles on accède via la notation objet) sont plus restrictives que celles qui s'appliquent aux noms d'identifiants 4D standard. Ces noms doivent être conformes à la JavaScript Identifier Grammar (voir ECMA Script standard), notamment : 

• le premier caractère doit être une lettre, un trait de soulignement (_) ou le symbole dollar ($),
• les autres caractères peuvent être des lettres, des chiffres, des traits de soulignement ou des symboles dollar (les espaces sont proscrits),
• ils différencient les caractères majuscules/minuscules.

Notes :

• L'utilisation d'un champ comme indice de collection, par exemple a.b[[Table1]Id], n'est pas autorisé. Vous devez utiliser une variable intermédiaire.
• La création d'attributs d'objets à l'aide d'une chaîne entre crochets permet de s'affranchir des règles d'ECMA Script. Par exemple, l'attribut $o["Mon Att.nom"] est valide dans 4D, malgré l'espace. Dans ce cas cependant, il ne sera pas possible d'utiliser la notation à points avec cet attribut.

Attention
Si les noms de propriété d'objet peuvent contenir des caractères spéciaux tels que "." ou "[ ]" (et sont disponibles en utilisant la syntaxe $o["Mon Att.nom]), cela n'est pas recommandé, puisque vous ne pourrez ni les rechercher ni les trier. Toutes les commandes et méthodes 4D qui exécutent des recherches sur les propriétés d'objets, telles que dataClass.query( ) ou QUERY BY ATTRIBUTE, utilisent une chaine en paramètre cheminPropriété ou cheminAttribut, comme dans l'exemple suivant :

Les recherches et les tris effectués sur les propriétés dont les noms contiennent des caractères spéciaux pourront être mal interprétés et fournir des résultats non valides. Par exemple, si vous avez défini une propriété nommée ["A.1.1"], il ne sera pas possible d'effectuer la recherche suivante :

Depuis toujours, 4D a accepté les points (.) et les crochets ([ et ]) dans les noms tokenisés des objets de la base de données (tables, champs, variables et méthodes).

Toutefois, ces caractères sont utilisés pour identifier les tokens du langage dans la notation objet standard. Les bases de données utilisant des noms contenant des points ou des crochets ne sont donc pas compatibles avec la notation objet standard car le code existant ne fonctionnerait plus en cas de mauvaise interprétation. Par exemple, si le code suivant est écrit :

a.b
a.b:=c[1]

... 4D ne peut pas savoir si a.b et c[1] représentent des noms de variables standard ou si b est une propriété de l'objet a et c le second élément d'une collection c. 

Par conséquent :

• Dans les bases converties depuis des versions antérieures à 4D v17, vous devez sélectionner une option de compatibilité spécifique indiquant que vous souhaitez utiliser la notation objet. En sélectionnant cette option, vous déclarez que votre code est "prêt pour la notation objet", c'est-à-dire qu'il n'utilise aucun nom contenant les caractères "." ou "[]".
• Une fonctionnalité spécifique du CSM vous aide à détecter les noms incompatibles avec la notation objet. L'utilisation de cette fonctionnalité est fortement recommandée avant d'activer l'option (voir la section Page Vérification du chapitre "CSM"). Comme d'habitude, il est recommandé de travailler sur une copie du fichier de structure.
• A compter de 4D v17 (v16 R4), les caractères "." et "[]" ne sont plus autorisés dans les noms des objets tokenisés.

Pour pouvoir utiliser la notation objet dans les bases créées avec une version antérieure à 4D v17, vous devez sélectionner Utiliser la notation objet pour accéder aux propriétés des objets (nécessite Unicode) dans la page Compatibilité de la boîte de dialogue des Propriétés de la base :

Pour plus d'informations, référez-vous à la Page Compatibilité.

Note : Les composants peuvent avoir des propriétés différentes de la base hôte.

L'utilisation de la notation objet simplifie grandement le code 4D de manipulation des objets. A noter toutefois que la notation utilisant les commandes "OB" reste entièrement prise en charge. 

• Ecriture et lecture de propriétés d'objets (cet exemple compare la notation objet et la syntaxe avec commandes) :

• Création de propriétés et affectation de valeurs, y compris d'autres objets :

• Lire une valeur dans un sous-objet est très simple avec la notation objet :

• Vous pouvez accéder aux propriétés d'objets via des chaînes grâce à l'opérateur [ ] :