|
|
|
|
|
|
|
|
- Présentation
- Activer les types nullables
- Fonctionnalités liées à l'activation des types nullables
- Stockage de la valeur Null dans une variable
- Présentation
- Type simple nullable
- Savoir si un élément est null
- Récupérer la valeur d'un élément qui autorise la valeur Null
- L'opérateur ?!
- L'opérateur ??
- L'opérateur ??*
- L'opérateur ??=
- L'opérateur ??=*
- Utilisation du Null dans les fonctions WLangage
- Cas particulier : Sérialise / Désérialise
- Cas particulier : Syntaxe préfixée
- Utilisation du Null dans les procédures
- Passage de paramètres par valeur
- Valeur de retour
- Opérations réalisables sur des variables autorisant le Null
- Opérations arithmétiques
- Opérations de comparaison
- Opérations booléennes
- Conditions
Gestion de la valeur NULL : Activation des types nullables
A partir de la version 2024, il devient possible d'activer les types nullables dans un projet WINDEV, WEBDEV ou WINDEV Mobile. L'activation des types nullables entraîne de nombreuses modifications dans la gestion du Null effectuée par votre projet. Cette page d'aide présente les différentes fonctionnalités mises en place lors de l'activation de cette option. Activer les types nullables Pour activer les types nullables : - Affichez la fenêtre de description du projet : sous le volet "Projet", dans le groupe "Projet", cliquez sur "Description".
- Dans l'onglet "Compilation", cochez l'option "Autoriser les types nullables".
- Une fenêtre d'information indiquant les conséquences de cette activation est affichée. Cliquez sur le bouton "Activer".
- Validez la fenêtre de description du projet.
Fonctionnalités liées à l'activation des types nullables En cochant l'option "Autoriser les types nullables", différentes fonctionnalités sont activées. Ces fonctionnalités changent la programmation de la gestion du Null : Stockage de la valeur Null dans une variable Présentation En cochant l'option "Autoriser les types nullables", l'affectation de la constante Null à une variable change notamment pour les types simples. En effet, dans ce mode, un type simple (entier, chaîne, date, etc.), appelé type non nullable, n'autorise plus la valeur Null. Remarque : Pour les types complexes (objet, tableau, etc.), le comportement est inchangé : un type complexe peut être Null. Pour utiliser la constante Null avec des variables de type simple, il faut désormais utiliser les types simples nullables. Type simple nullable Pour définir un type simple nullable, il est possible d'utiliser une des syntaxes suivantes : - soit ajouter un caractère "?" à la fin du nom du type.
<Nom de la variable> est un(e) <Type>?
n est un entier?
s est une chaîne UNICODE?
n1 est un entier sur 8 octets?
- soit utiliser l'attribut d'extension <nullable>.
<Nom de la variable> est un(e) <Type> <nullable>
n est un entier <nullable>
Remarques : - Ces syntaxes sont disponibles uniquement si l'option "Autoriser les types nullables" est cochée.
- La valeur par défaut d'un type nullable est Null (et non plus la valeur initiale du type).
- L'inférence de type est disponible pour les types nullables. Par exemple :
SOIT x = ProcédureRenvoieEntierNullable()
Les types simples pouvant être nullables sont les suivants :
Savoir si un élément est null En cochant l'option "Autoriser les types nullables", la comparaison d'un élément à la constante Null change de la manière suivante : - un type simple non nullable peut être comparé avec la constante Null : le résultat correspond systématiquement à Faux.
- un type simple nullable peut être comparé avec la constante Null : le résultat correspond à Vrai si sa valeur est Null, Faux dans le cas contraire.
- un type complexe qui autorisait la valeur Null dans les versions précédentes (objet, tableau, etc.) ne change pas de comportement : il peut toujours être comparé à la valeur Null.
Remarques : - Rubrique HFSQL : Si le fichier de données et la rubrique autorisent la valeur Null, il est désormais possible de savoir si une rubrique HFSQL est Null en la comparant directement à la constante Null. Exemple :
SI Fichier.RubriqueAvecNull = Null ALORS
FIN
- Champ de saisie : Si l'option "Retourner NULL si vide" est cochée pour le champ, il est possible de savoir si un champ de saisie a renvoyé Null.
Récupérer la valeur d'un élément qui autorise la valeur Null En cochant l'option "Autoriser les types nullables", la récupération de la valeur d'un élément qui autorise le Null doit être vérifiée. L'affectation de la valeur d'un élément nullable dans un élément nullable ne pose pas de problème. La valeur Null est conservée si nécessaire entre les deux éléments. Par contre, l'affectation d'un élément nullable dans un élément non nullable entraîne une erreur de compilation. Par exemple, il est interdit d'écrire les lignes de code suivantes : s est une chaîne = Fichier.RubriqueNullable
ou Gauche(Fichier.RubriqueNullable)
En effet, il est nécessaire lors de cette affectation de gérer le cas de la valeur Null. Pour cela, le WLangage met plusieurs opérateurs à votre disposition pour accéder aux valeurs des éléments qui autorisent la valeur Null : ?!, ??, ??*, ??= et ??=*. L'opérateur ?! Lors de l'affectation, s'il est certain que la valeur sera non Null, il est possible d'utiliser l'opérateur ?!. L'erreur de compilation sur l'utilisation d'un élément nullable ne sera pas affichée dans ce cas. Exemple : SI Fichier.RubriqueAvecNull <> Null ALORS
s est une chaîne = Fichier.RubriqueAvecNull ?!
FIN
Rappel : Si le code est erroné et si la valeur correspond à Null à l'exécution, une exception du mécanisme de sécurité du WLangage se produira. Remarque : Dans de nombreux cas, l'opérateur ?! s'applique automatiquement pour simplifier l'écriture du code : - sur les éléments non déterminables à la compilation : résultats de requête, indirection, etc.
- dans certaines syntaxes conditionnelles. Par exemple :
SI Fichier.RubriqueAvecNull <> Null ALORS
s est une chaîne = Fichier.RubriqueAvecNull
FIN
Attention : l'application automatique de l'opérateur ?! ne dispense pas de gérer le cas de la valeur Null. Dans le cas contraire, une exception se produira à l'exécution du code. L'opérateur ?? L'opérateur ?? permet de récupérer : - la valeur d'un élément nullable si cette valeur est non Null,
- une valeur de substitution si la valeur de l'élément nullable correspond à Null.
Syntaxe : expression_nullable ?? valeur_de_substitution Exemple :
s est une chaîne = Fichier.RubriqueAvecNull ?? "N/A"
L'opérateur ??* L'opérateur ??* permet de récupérer : - la valeur d'un élément nullable si cette valeur est non Null.
- la valeur par défaut du type si la valeur de l'élément nullable correspond à Null.
Exemple :
s est une chaîne = Fichier.RubriqueAvecNull ??*
L'opérateur ??= L'opérateur ??= permet de simplifier l'affectation d'une valeur à un élément nullable correspondant à Null en indiquant directement la valeur de substitution. Cet opérateur est disponible uniquement pour les variables ou pour les rubriques des fichiers de données. Syntaxe : élément_nullable ??= valeur_de_substitution Exemple : valeur_nullable est une chaîne?
valeur_nullable = ProcédureAExécuter()
valeur_nullable ??= "N/A"
Le code de cet exemple permet de simplifier le code suivant : valeur_nullable est une chaîne?
valeur_nullable = ProcédureAExécuter()
SI valeur_nullable = Null ALORS
valeur_nullable = "N/A"
FIN
L'opérateur ??=* L'opérateur ??=* permet de simplifier l'affectation d'une valeur à un élément nullable correspondant à Null en utilisant directement la valeur par défaut en cas de valeur Null. Cet opérateur est disponible uniquement pour les variables ou pour les rubriques des fichiers de données. Exemple : valeur_nullable est une chaîne?
valeur_nullable = ProcédureAExécuter()
valeur_nullable ??=*
Le code de cet exemple permet de simplifier le code suivant : valeur_nullable est une chaîne?
valeur_nullable = ProcédureAExécuter()
SI valeur_nullable = Null ALORS
valeur_nullable ??*
FIN
Utilisation du Null dans les fonctions WLangage Pour simplifier le débogage, la fonction Trace autorise l'affichage de la valeur Null ou d'un type nullable : - si la valeur est Null, la chaîne "<Null>" est affichée.
- si le type est nullable avec une valeur non Null, la chaîne "<Nullable>" est ajoutée à la suite de la valeur convertie en chaîne.
A partir de la version 2024 Update 2, la fonction TypeEstNullable permet de savoir si le type est nullable. Note : De nombreuses fonctions du WLangage autorisent la valeur Null et fonctionnent comme avant ( ArbreAjoute, ArbreModifie, etc.). Cas particulier : Sérialise / Désérialise - Lors de la désérialisation binaire, un membre nullable est remis à Null s'il n'existe pas dans le buffer sérialisé.
- Lors de la sérialisation XML, un membre nullable de valeur Null n'est pas sérialisé. Lors de la désérialisation, le membre est remis à Null s'il n'existe pas dans le XML.
- Lors de la sérialisation JSON, un membre nullable de valeur Null n'est pas sérialisé. Lors de la désérialisation, le membre est remis à Null s'il n'existe pas dans le JSON.
Cas particulier : Syntaxe préfixée L'opérateur ?. permet d'appeler une fonction du WLangage directement sur un type nullable sans passer par une variable intermédiaire. Syntaxe : résultat = élément_nullable ?. FonctionDuWLangage(...) - Si élément_nullable ne vaut pas Null, la fonction est appelée.
- Si élément_nullable vaut Null, la fonction n'est pas appelée et résultat vaut Null.
Exemple : chaine_complète_ou_Null est une chaîne ? = ...
dix_premiers_caractères_ou_Null est une chaîne ? = chaine_complète_ou_Null ?. Gauche s(10)
L'opérateur ?. peut-être combiné avec l'opérateur ?? pour obtenir un résultat simple : dix_premiers_caractères est une chaîne = chaine_complète_ou_Null ?. Gauche s(10) ?? ""
Utilisation du Null dans les procédures Passage de paramètres par valeur La valeur Null ou une valeur nullable ne peuvent pas être passées à un paramètre non typé non nullable ou de type simple non nullable. Pour autoriser le passage de Null ou d'une valeur nullable à un paramètre, il est nécessaire de le préciser grâce aux syntaxes suivantes :
PROCÉDURE ProcédureAvecUnParamètreNullable(paramètre ?) PROCÉDURE ProcédureAvecUnParamètreNullable(paramètre est un entier ?) Remarque : Les conversions implicites entre les types simples s'appliquent entre les types nullables correspondants. Valeur de retour De manière similaire aux paramètres, il faut préciser que le type de retour est nullable si une procédure doit renvoyer Null ou une valeur nullable. Les syntaxes correspondantes sont les suivantes : PROCÉDURE ProcédureRenvoieUneValeurNullable () : ? PROCÉDURE ProcédureRenvoieUneValeurNullable () : entier ? Opérations réalisables sur des variables autorisant le Null Opérations arithmétiques Les opérations arithmétiques et les opérations de chaîne sont interdites si l'une des opérandes est Null. L'exécution de ces opérations provoque une exception. Une erreur de compilation permet de trouver les cas posant problème. Liste des opérations arithmétiques : | | - + (addition et concaténation)
- ++
- +=
- -
- --
- -=
| - *
- *=
- / (division et concaténation de chaînes pour les chemins)
- /=
- %
- ^
|
Opérations de comparaison L'opérateur = (égal) renvoie : - Vrai si les deux valeurs sont Null ;
- Faux si une valeur est Null et pas l'autre.
L'opérateur <> (différent) renvoie : - Vrai si une valeur est Null et pas l'autre ;
- Faux si les deux valeurs sont Null.
Les autres comparaisons provoquent une exception si une des valeurs est Null : Opérations booléennes Les opérations booléennes ont un comportement particulier avec les valeurs booléennes nullables. - PAS
- PAS Null = Null
- PAS Faux = Vrai
- PAS Vrai = Faux
- OU
| | | | | Null | Faux | Vrai | | Null | Null | Null | Vrai | | Faux | Null | Faux | Vrai | | Vrai | Vrai | Vrai | Vrai |
- ET
| | | | | Null | Faux | Vrai | | Null | Null | Faux | Null | | Faux | Faux | Faux | Faux | | Vrai | Null | Faux | Vrai |
Conditions Dans une condition (SI, TANTQUE, etc.), la valeur Null est équivalente à Faux.
Documentation également disponible pour…
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|