ONLINE HELP
 WINDEVWEBDEV AND WINDEV MOBILE

Help / Editors / Project editor / Project description
  • 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 ?? (opérateur de coalescence)
  • 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
WINDEV
WindowsLinuxUniversal Windows 10 AppJavaReports and QueriesUser code (UMC)
WEBDEV
WindowsLinuxPHPWEBDEV - Browser code
WINDEV Mobile
AndroidAndroid Widget iPhone/iPadIOS WidgetApple WatchMac CatalystUniversal Windows 10 App
Others
Stored procedures
Support NULL values: Allowing nullable types
Présentation
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 :
  1. Affichez la fenêtre de description du projet : sous le volet "Project", dans le groupe "Project", cliquez sur "Description".
  2. Dans l'onglet "Compilation", cochez l'option "Allow nullable types".
  3. Une fenêtre d'information indiquant les conséquences de cette activation est affichée. Cliquez sur le bouton "Activer".
  4. Validez la fenêtre de description du projet.
Stockage de la valeur Null dans une variable

Présentation

En cochant l'option "Allow nullable types", 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>?
    Par exemple :
    n is int?
    s is string UNICODE?
    n1 is 8-byte int?
  • soit utiliser l'attribut d'extension <nullable>.
    <Nom de la variable> est un(e) <Type> <nullable>
    Par exemple :
    n is int <nullable>
Remarques :
  • Ces syntaxes sont disponibles uniquement si l'option "Allow nullable types" 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 "Allow nullable types", 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 :
    IF Fichier.RubriqueAvecNull = Null THEN
    	// Traitement ...
    END
  • Champ de saisie : Si l'option "Return NULL if empty" 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 "Allow nullable types", 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 is string = Fichier.RubriqueNullable
ou
Left(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.
Syntaxe :
élément_nullable ?!
Exemple :
IF Fichier.RubriqueAvecNull <> Null THEN
	s is string = Fichier.RubriqueAvecNull ?!
END
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 :
    IF Fichier.RubriqueAvecNull <> Null THEN
    	s is string = Fichier.RubriqueAvecNull	// opérateur ?! automatique ici
    END
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 ?? (opérateur de coalescence)

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 :
// La chaîne contiendra "N/A" si la rubrique est Null
s is string = 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.
Syntaxe :
expression_nullable ??*
Exemple :
// La chaîne sera vide si la rubrique est Null
s is string = 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 is string?
valeur_nullable = ProcédureAExécuter()
valeur_nullable ??= "N/A"
Le code de cet exemple permet de simplifier le code suivant :
valeur_nullable is string?
valeur_nullable = ProcédureAExécuter()
IF valeur_nullable = Null THEN
	valeur_nullable = "N/A"
END

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.
Syntaxe :
élément_nullable ??=*
Exemple :
valeur_nullable is string?
	valeur_nullable = ProcédureAExécuter()
	valeur_nullable ??=*
Le code de cet exemple permet de simplifier le code suivant :
valeur_nullable is string?
valeur_nullable = ProcédureAExécuter()
IF valeur_nullable = Null THEN
	valeur_nullable ??*
END
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.
Les fonctions TypeVar et TypeVariable renvoient le type sous-jacent.
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 is string ? = ...
dix_premiers_caractères_ou_Null is string ? = chaine_complète_ou_Null ?. Left s(10)
L'opérateur ?. peut-être combiné avec l'opérateur ?? pour obtenir un résultat simple :
dix_premiers_caractères is string = chaine_complète_ou_Null ?. Left 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
    NullFauxVrai
    NullNullNullVrai
    FauxNullFauxVrai
    VraiVraiVraiVrai
  • ET
    NullFauxVrai
    NullNullFauxNull
    FauxFauxFauxFaux
    VraiNullFauxVrai

Conditions

Dans une condition (SI, TANTQUE, etc.), la valeur Null est équivalente à Faux.
Minimum version required
  • Version 2024
This page is also available for…
Comments
Click [Add] to post a comment

Last update: 05/17/2024

Send a report | Local help