PC SOFT

DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

  • Présentation
  • Affectation simple : =
  • Affectation multiple
  • Affectation par copie : <=
  • Affectation par copie sur les tableaux
  • Copie homonymique
  • Affectation par prise de référence : <-
  • Remarques
WINDEV
WindowsLinuxUniversal Windows 10 AppJavaEtats et RequêtesCode Utilisateur (MCU)
WEBDEV
WindowsLinuxPHPWEBDEV - Code Navigateur
WINDEV Mobile
AndroidWidget AndroidiPhone/iPadApple WatchUniversal Windows 10 AppWindows Mobile
Autres
Procédures stockées
Opérateurs d'affectation
HFSQL Client/ServeurDisponible uniquement avec ce type de connexion
Présentation
Il existe plusieurs opérateurs d'affectations :
Versions 16 et supérieures
Universal Windows 10 App Cette fonctionnalité est disponible pour les applications Windows Phone.
Nouveauté 16
Universal Windows 10 App Cette fonctionnalité est disponible pour les applications Windows Phone.
Universal Windows 10 App Cette fonctionnalité est disponible pour les applications Windows Phone.
Versions 17 et supérieures
iPhone/iPad Cette fonctionnalité est disponible pour les applications iPhone/iPad.
Nouveauté 17
iPhone/iPad Cette fonctionnalité est disponible pour les applications iPhone/iPad.
iPhone/iPad Cette fonctionnalité est disponible pour les applications iPhone/iPad.
Versions 18 et supérieures
Universal Windows 10 App Cette fonctionnalité est disponible en mode Windows Store apps.
Widget Android Cette fonctionnalité est disponible en mode Widget Android.
Nouveauté 18
Universal Windows 10 App Cette fonctionnalité est disponible en mode Windows Store apps.
Widget Android Cette fonctionnalité est disponible en mode Widget Android.
Universal Windows 10 App Cette fonctionnalité est disponible en mode Windows Store apps.
Widget Android Cette fonctionnalité est disponible en mode Widget Android.
Versions 21 et supérieures
Universal Windows 10 App Cette fonctionnalité est disponible en mode Universal Windows 10 App.
Apple Watch Cette fonctionnalité est disponible en mode Apple Watch.
Nouveauté 21
Universal Windows 10 App Cette fonctionnalité est disponible en mode Universal Windows 10 App.
Apple Watch Cette fonctionnalité est disponible en mode Apple Watch.
Universal Windows 10 App Cette fonctionnalité est disponible en mode Universal Windows 10 App.
Apple Watch Cette fonctionnalité est disponible en mode Apple Watch.
Affectation simple : =
L'affectation simple est utilisée entre tous les types simples (entiers, réels, chaînes, etc.) pour copier la valeur d'une variable dans une autre.
Son fonctionnement varie lorsqu'elle est utilisée sur des types complexes :
Type des variablesEffet
TableauxLe tableau destination est une référence sur le tableau source.
Tableaux associatifsLe contenu du tableau est copié.
FileLe contenu de la file est copié.
PileLe contenu de la pile est copié.
ListeLe contenu de la liste est copié.
Objet = Objet dynamiqueLes membres de l'objet dynamique sont copiés dans ceux de l'objet.
Objet = ObjetLes membres de l'objet source sont copiés dans ceux de l'objet destination.
Objet dynamique = Objet dynamiqueL'objet dynamique destination est une référence à l'objet dynamique source.
Objet dynamique = ObjetL'objet dynamique destination est une référence à l'objet source.
Versions 22 et supérieures
Structure = Structure
Nouveauté 22
Structure = Structure
Structure = Structure
Une copie de la structure est réalisée. Les membres de même nom sont affectés. Les membres inexistants sont ignorés.
Versions 19 et supérieures

Affectation multiple

L'opérateur '=' peut également être utiliser pour affecter plusieurs variables en une seule ligne de code.
La syntaxe utilisée est la suivante :
( <Variable 1>, <Variable 2>, ... <Variable N> ) = ( <Valeur 1>, <Valeur 2>, ... <Valeur M> )
où :
  • N représente le nombre de variables déclarées.
  • M représente le nombre de valeurs à affecter.
Remarques :
  • Les expressions à droite du signe '=' sont d'abord évaluées de gauche à droite.
  • Les opérations d'affectation des variables à gauche du signe sont ensuite effectuées de gauche à droite.
  • Il n'y a pas de dépendances entre les expressions de droite et celles de gauche. Par contre, il peut y avoir une dépendance entre les variables de gauche.
  • Si il y a moins de variables que de valeurs (N inférieur à M), une erreur de compilation sera générée.
  • Si il y a plus de variables que de valeurs (N supérieur ou égal à M), seules les premières variables seront affectées.
  • Versions 20 et supérieures
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
    Nouveauté 20
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
Exemples :
(x, y, z) = (5, 8, 12)
// x vaut 5, y vaut 8, z vaut 12

(x, y, z) = (25, 38)
// x vaut 25, y vaut 38, z n'est pas affecté


(x, , z) = (14, 87)
// x vaut 14, y n'est pas affecté, z vaut 87

(t[Indice1()], t[Indice2()]) = (Calcul1(), calcul2())
// L'ordre d'exécution des procédures est le suivant :
// Calcul1()
// Calcul2()
// Indice1()
// Indice2()
// puis t[Indice1()] est affecté de la valeur de Calcul1()
// puis t[Indice2()] est affecté de la valeur de Calcul2()

(i, t[i]) = (1, "ABC")
// Affecte tout d'abord 1 à i
// Affecte ensuite "ABC" dans t à l'indice i
Nouveauté 19

Affectation multiple

L'opérateur '=' peut également être utiliser pour affecter plusieurs variables en une seule ligne de code.
La syntaxe utilisée est la suivante :
( <Variable 1>, <Variable 2>, ... <Variable N> ) = ( <Valeur 1>, <Valeur 2>, ... <Valeur M> )
où :
  • N représente le nombre de variables déclarées.
  • M représente le nombre de valeurs à affecter.
Remarques :
  • Les expressions à droite du signe '=' sont d'abord évaluées de gauche à droite.
  • Les opérations d'affectation des variables à gauche du signe sont ensuite effectuées de gauche à droite.
  • Il n'y a pas de dépendances entre les expressions de droite et celles de gauche. Par contre, il peut y avoir une dépendance entre les variables de gauche.
  • Si il y a moins de variables que de valeurs (N inférieur à M), une erreur de compilation sera générée.
  • Si il y a plus de variables que de valeurs (N supérieur ou égal à M), seules les premières variables seront affectées.
  • Versions 20 et supérieures
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
    Nouveauté 20
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
Exemples :
(x, y, z) = (5, 8, 12)
// x vaut 5, y vaut 8, z vaut 12

(x, y, z) = (25, 38)
// x vaut 25, y vaut 38, z n'est pas affecté


(x, , z) = (14, 87)
// x vaut 14, y n'est pas affecté, z vaut 87

(t[Indice1()], t[Indice2()]) = (Calcul1(), calcul2())
// L'ordre d'exécution des procédures est le suivant :
// Calcul1()
// Calcul2()
// Indice1()
// Indice2()
// puis t[Indice1()] est affecté de la valeur de Calcul1()
// puis t[Indice2()] est affecté de la valeur de Calcul2()

(i, t[i]) = (1, "ABC")
// Affecte tout d'abord 1 à i
// Affecte ensuite "ABC" dans t à l'indice i

Affectation multiple

L'opérateur '=' peut également être utiliser pour affecter plusieurs variables en une seule ligne de code.
La syntaxe utilisée est la suivante :
( <Variable 1>, <Variable 2>, ... <Variable N> ) = ( <Valeur 1>, <Valeur 2>, ... <Valeur M> )
où :
  • N représente le nombre de variables déclarées.
  • M représente le nombre de valeurs à affecter.
Remarques :
  • Les expressions à droite du signe '=' sont d'abord évaluées de gauche à droite.
  • Les opérations d'affectation des variables à gauche du signe sont ensuite effectuées de gauche à droite.
  • Il n'y a pas de dépendances entre les expressions de droite et celles de gauche. Par contre, il peut y avoir une dépendance entre les variables de gauche.
  • Si il y a moins de variables que de valeurs (N inférieur à M), une erreur de compilation sera générée.
  • Si il y a plus de variables que de valeurs (N supérieur ou égal à M), seules les premières variables seront affectées.
  • Versions 20 et supérieures
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
    Nouveauté 20
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
    Pour affecter la même valeur à toutes les variables, il suffit d'utiliser la syntaxe suivante :
    ( <Variable 1>, <Variable 2>, ... <Variable N> ) = <Valeur>

    Par exemple :
    (x,y,z) = 0

    WEBDEV - Code Navigateur Non disponible.
Exemples :
(x, y, z) = (5, 8, 12)
// x vaut 5, y vaut 8, z vaut 12

(x, y, z) = (25, 38)
// x vaut 25, y vaut 38, z n'est pas affecté


(x, , z) = (14, 87)
// x vaut 14, y n'est pas affecté, z vaut 87

(t[Indice1()], t[Indice2()]) = (Calcul1(), calcul2())
// L'ordre d'exécution des procédures est le suivant :
// Calcul1()
// Calcul2()
// Indice1()
// Indice2()
// puis t[Indice1()] est affecté de la valeur de Calcul1()
// puis t[Indice2()] est affecté de la valeur de Calcul2()

(i, t[i]) = (1, "ABC")
// Affecte tout d'abord 1 à i
// Affecte ensuite "ABC" dans t à l'indice i
Affectation par copie : <=
L'affectation par copie force toujours la copie de l'élément source dans l'élément destination.
Une nouvelle zone de mémoire est allouée pour stocker la valeur copiée.
Versions 17 et supérieures

Affectation par copie sur les tableaux

Il est possible d'utiliser l'opérateur <= sur les tableaux.
Ces tableaux peuvent être de types différents.
L'affectation utilise les conversions implicites du WLangage (comme le ferait l'opérateur =).
Exemple :
// Déclaration de deux tableaux de même taille de types différents (entier et booléen)
tabEntiers  est un tableau de 3 par 2 entiers
tabBooléens est un tableau de 3 par 2 booléens

// Remplissage du tableau d'entiers
tabEntiers[1,1] = -6
tabEntiers[1,2] = 9
tabEntiers[2,1] = 0

// Copie du tableau d'entiers dans le tableau de booléens
tabBooléens <= tabEntiers

// Traces du tableau de booléens
// (Rappel : tous les nombres autres que zéro sont "Vrai" en logique booléenne)
Trace(tabBooléens[1,1]) // Affiche 1
Trace(tabBooléens[1,2]) // Affiche 1
Trace(tabBooléens[2,1]) // Affiche 0
Trace(tabBooléens[2,2]) // Affiche 0
Nouveauté 17

Affectation par copie sur les tableaux

Il est possible d'utiliser l'opérateur <= sur les tableaux.
Ces tableaux peuvent être de types différents.
L'affectation utilise les conversions implicites du WLangage (comme le ferait l'opérateur =).
Exemple :
// Déclaration de deux tableaux de même taille de types différents (entier et booléen)
tabEntiers  est un tableau de 3 par 2 entiers
tabBooléens est un tableau de 3 par 2 booléens

// Remplissage du tableau d'entiers
tabEntiers[1,1] = -6
tabEntiers[1,2] = 9
tabEntiers[2,1] = 0

// Copie du tableau d'entiers dans le tableau de booléens
tabBooléens <= tabEntiers

// Traces du tableau de booléens
// (Rappel : tous les nombres autres que zéro sont "Vrai" en logique booléenne)
Trace(tabBooléens[1,1]) // Affiche 1
Trace(tabBooléens[1,2]) // Affiche 1
Trace(tabBooléens[2,1]) // Affiche 0
Trace(tabBooléens[2,2]) // Affiche 0

Affectation par copie sur les tableaux

Il est possible d'utiliser l'opérateur <= sur les tableaux.
Ces tableaux peuvent être de types différents.
L'affectation utilise les conversions implicites du WLangage (comme le ferait l'opérateur =).
Exemple :
// Déclaration de deux tableaux de même taille de types différents (entier et booléen)
tabEntiers  est un tableau de 3 par 2 entiers
tabBooléens est un tableau de 3 par 2 booléens

// Remplissage du tableau d'entiers
tabEntiers[1,1] = -6
tabEntiers[1,2] = 9
tabEntiers[2,1] = 0

// Copie du tableau d'entiers dans le tableau de booléens
tabBooléens <= tabEntiers

// Traces du tableau de booléens
// (Rappel : tous les nombres autres que zéro sont "Vrai" en logique booléenne)
Trace(tabBooléens[1,1]) // Affiche 1
Trace(tabBooléens[1,2]) // Affiche 1
Trace(tabBooléens[2,1]) // Affiche 0
Trace(tabBooléens[2,2]) // Affiche 0
Versions 17 et supérieures

Copie homonymique

Le mécanisme de la copie homonymique utilise l'opérateur <= pour transférer des données depuis un élément structuré vers un autre élément structuré.
Lors de la copie, les membres de même nom sont automatiquement recopiés de l'élément structuré source vers l'élément structuré destination. Les conversions de type seront automatiquement effectuées.
Il est ainsi possible de réaliser par exemple :
  • le transfert du contenu des membres d'une structure vers les rubriques d'un fichier HyperFileSQL, le transfert du contenu des membres d'une structure vers les rubriques d'un fichier HFSQL,
  • le transfert des membres d'un type avancé (type Email par exemple) vers les membres d'une classe.
Les types structurés manipulables sont les suivants :
  • structures,
  • classes,
  • types avancés,
  • fichiers HyperFileSQL,
  • requêtes,
  • sources de données.
Android Limitation : la copie homonymique n'est pas disponible pour les applications Android.
Exemple : Copie de classes
// Déclaration des classes
Classe_1 est une Classe
        commun est un entier
        membre_1 est un entier
FIN

Classe_2 est une Classe
        commun est un entier
        membre_2 est un entier
FIN

// Affectation
o1 est Classe_1
o1.commun = 1
o1.membre_1 = 1

o2 est Classe_2
o2.commun = 2
o2.membre_2 = 2

// Copie
o1 <= o2

// Résultat
// o1.commun = 2
// o1.membre_1 = 1
Remarques :
  • L'opérateur <= peut être remplacé par l'opérateur = lorsque le fonctionnement ne présente pas d’ambiguïté.
  • Pour les structures et les classes, chaque membre peut être suivi d'un attribut "Mapping". Cet attribut permet de spécifier le nom du membre à "mapper" au membre de la structure ou de la classe.
    Exemple :
    // Déclaration des classes
    Classe_Simple_1 est une Classe
            commun est un entier
            membre_1 est un entier
    FIN

    Classe_Mapping_1 est une Classe
            nCommun est un entier, mapping = "commun"
            membre_1 est un entier, mapping = ""
    FIN

    // Affectation
    o1 est Classe_Mapping_1
    o1.nCommun = 1
    o1.membre_1 = 1

    o2 est Classe_Simple_1
    o2.commun = 2
    o2.membre_1 = 2

    o1 <= o2

    // Résultat
    // o1.ncommum = 2
    // o1.membre_1 = 1
  • Pour les types avancés disposant de sous-éléments dynamiques (par exemple le type xmlNoeud ou les éléments structurés des Webservices), les sous-éléments sont prioritaires sur les propriétés standard du type.
    Exemple :
    // Déclaration des classes
    Classe_xmlNoeud est une Classe
    Nom est une chaîne
    Balise1 est une chaîne
    Balise2 est une chaîne
    FIN

    // Affectation
    o1 est un Classe_xmlNoeud
    o1.Nom = ""
    o1.Balise1 = ""
    o1.Balise2 = ""

    c1 est un xmlNoeud
    c1..Nom = "Noeud_XML_avec_balise_Nom"
    c1.Nom = "Nom"
    c1.Balise1 = "Balise1"
    c1.Balise2 = "Balise2"

    o1 <= c1


    // Résultat
    // o1.Nom = "Nom"
    // o1.Balise1 = "Balise1"
    // o1.Balise2 = "Balise2"
  • Cas particulier : copie homonymique entre des structures ou classes :
    • L'attribut "mapping" est autorisé pour les membres de la structure ou classe source ou destination (mais pas pour les deux).
    • Si un membre dérivé a le même nom que un membre de la classe de base ou un mapping avec le même nom, seul le nom de la classe dérivée est pris en compte.
  • Limite : La copie homonymique n'est pas disponible :
    • sur les objets .Net,
    • sur les objets automation,
    • si la source et la destination sont des types avancés avec des sous-éléments dynamiques.
Nouveauté 17

Copie homonymique

Le mécanisme de la copie homonymique utilise l'opérateur <= pour transférer des données depuis un élément structuré vers un autre élément structuré.
Lors de la copie, les membres de même nom sont automatiquement recopiés de l'élément structuré source vers l'élément structuré destination. Les conversions de type seront automatiquement effectuées.
Il est ainsi possible de réaliser par exemple :
  • le transfert du contenu des membres d'une structure vers les rubriques d'un fichier HyperFileSQL, le transfert du contenu des membres d'une structure vers les rubriques d'un fichier HFSQL,
  • le transfert des membres d'un type avancé (type Email par exemple) vers les membres d'une classe.
Les types structurés manipulables sont les suivants :
  • structures,
  • classes,
  • types avancés,
  • fichiers HyperFileSQL,
  • requêtes,
  • sources de données.
Android Limitation : la copie homonymique n'est pas disponible pour les applications Android.
Exemple : Copie de classes
// Déclaration des classes
Classe_1 est une Classe
        commun est un entier
        membre_1 est un entier
FIN

Classe_2 est une Classe
        commun est un entier
        membre_2 est un entier
FIN

// Affectation
o1 est Classe_1
o1.commun = 1
o1.membre_1 = 1

o2 est Classe_2
o2.commun = 2
o2.membre_2 = 2

// Copie
o1 <= o2

// Résultat
// o1.commun = 2
// o1.membre_1 = 1
Remarques :
  • L'opérateur <= peut être remplacé par l'opérateur = lorsque le fonctionnement ne présente pas d’ambiguïté.
  • Pour les structures et les classes, chaque membre peut être suivi d'un attribut "Mapping". Cet attribut permet de spécifier le nom du membre à "mapper" au membre de la structure ou de la classe.
    Exemple :
    // Déclaration des classes
    Classe_Simple_1 est une Classe
            commun est un entier
            membre_1 est un entier
    FIN

    Classe_Mapping_1 est une Classe
            nCommun est un entier, mapping = "commun"
            membre_1 est un entier, mapping = ""
    FIN

    // Affectation
    o1 est Classe_Mapping_1
    o1.nCommun = 1
    o1.membre_1 = 1

    o2 est Classe_Simple_1
    o2.commun = 2
    o2.membre_1 = 2

    o1 <= o2

    // Résultat
    // o1.ncommum = 2
    // o1.membre_1 = 1
  • Pour les types avancés disposant de sous-éléments dynamiques (par exemple le type xmlNoeud ou les éléments structurés des Webservices), les sous-éléments sont prioritaires sur les propriétés standard du type.
    Exemple :
    // Déclaration des classes
    Classe_xmlNoeud est une Classe
    Nom est une chaîne
    Balise1 est une chaîne
    Balise2 est une chaîne
    FIN

    // Affectation
    o1 est un Classe_xmlNoeud
    o1.Nom = ""
    o1.Balise1 = ""
    o1.Balise2 = ""

    c1 est un xmlNoeud
    c1..Nom = "Noeud_XML_avec_balise_Nom"
    c1.Nom = "Nom"
    c1.Balise1 = "Balise1"
    c1.Balise2 = "Balise2"

    o1 <= c1


    // Résultat
    // o1.Nom = "Nom"
    // o1.Balise1 = "Balise1"
    // o1.Balise2 = "Balise2"
  • Cas particulier : copie homonymique entre des structures ou classes :
    • L'attribut "mapping" est autorisé pour les membres de la structure ou classe source ou destination (mais pas pour les deux).
    • Si un membre dérivé a le même nom que un membre de la classe de base ou un mapping avec le même nom, seul le nom de la classe dérivée est pris en compte.
  • Limite : La copie homonymique n'est pas disponible :
    • sur les objets .Net,
    • sur les objets automation,
    • si la source et la destination sont des types avancés avec des sous-éléments dynamiques.

Copie homonymique

Le mécanisme de la copie homonymique utilise l'opérateur <= pour transférer des données depuis un élément structuré vers un autre élément structuré.
Lors de la copie, les membres de même nom sont automatiquement recopiés de l'élément structuré source vers l'élément structuré destination. Les conversions de type seront automatiquement effectuées.
Il est ainsi possible de réaliser par exemple :
  • le transfert du contenu des membres d'une structure vers les rubriques d'un fichier HyperFileSQL, le transfert du contenu des membres d'une structure vers les rubriques d'un fichier HFSQL,
  • le transfert des membres d'un type avancé (type Email par exemple) vers les membres d'une classe.
Les types structurés manipulables sont les suivants :
  • structures,
  • classes,
  • types avancés,
  • fichiers HyperFileSQL,
  • requêtes,
  • sources de données.
Android Limitation : la copie homonymique n'est pas disponible pour les applications Android.
Exemple : Copie de classes
// Déclaration des classes
Classe_1 est une Classe
        commun est un entier
        membre_1 est un entier
FIN

Classe_2 est une Classe
        commun est un entier
        membre_2 est un entier
FIN

// Affectation
o1 est Classe_1
o1.commun = 1
o1.membre_1 = 1

o2 est Classe_2
o2.commun = 2
o2.membre_2 = 2

// Copie
o1 <= o2

// Résultat
// o1.commun = 2
// o1.membre_1 = 1
Remarques :
  • L'opérateur <= peut être remplacé par l'opérateur = lorsque le fonctionnement ne présente pas d’ambiguïté.
  • Pour les structures et les classes, chaque membre peut être suivi d'un attribut "Mapping". Cet attribut permet de spécifier le nom du membre à "mapper" au membre de la structure ou de la classe.
    Exemple :
    // Déclaration des classes
    Classe_Simple_1 est une Classe
            commun est un entier
            membre_1 est un entier
    FIN

    Classe_Mapping_1 est une Classe
            nCommun est un entier, mapping = "commun"
            membre_1 est un entier, mapping = ""
    FIN

    // Affectation
    o1 est Classe_Mapping_1
    o1.nCommun = 1
    o1.membre_1 = 1

    o2 est Classe_Simple_1
    o2.commun = 2
    o2.membre_1 = 2

    o1 <= o2

    // Résultat
    // o1.ncommum = 2
    // o1.membre_1 = 1
  • Pour les types avancés disposant de sous-éléments dynamiques (par exemple le type xmlNoeud ou les éléments structurés des Webservices), les sous-éléments sont prioritaires sur les propriétés standard du type.
    Exemple :
    // Déclaration des classes
    Classe_xmlNoeud est une Classe
    Nom est une chaîne
    Balise1 est une chaîne
    Balise2 est une chaîne
    FIN

    // Affectation
    o1 est un Classe_xmlNoeud
    o1.Nom = ""
    o1.Balise1 = ""
    o1.Balise2 = ""

    c1 est un xmlNoeud
    c1..Nom = "Noeud_XML_avec_balise_Nom"
    c1.Nom = "Nom"
    c1.Balise1 = "Balise1"
    c1.Balise2 = "Balise2"

    o1 <= c1


    // Résultat
    // o1.Nom = "Nom"
    // o1.Balise1 = "Balise1"
    // o1.Balise2 = "Balise2"
  • Cas particulier : copie homonymique entre des structures ou classes :
    • L'attribut "mapping" est autorisé pour les membres de la structure ou classe source ou destination (mais pas pour les deux).
    • Si un membre dérivé a le même nom que un membre de la classe de base ou un mapping avec le même nom, seul le nom de la classe dérivée est pris en compte.
  • Limite : La copie homonymique n'est pas disponible :
    • sur les objets .Net,
    • sur les objets automation,
    • si la source et la destination sont des types avancés avec des sous-éléments dynamiques.
Affectation par prise de référence : <-
L'affectation par prise de référence force l'élément destination à référencer la même zone de données que l'élément source.
Cette affectation ne peut pas être utilisée avec les types simples (entiers, réels, chaînes, etc.).
Ce type d'affectation peut être utilisé pour manipuler directement :
Remarques
Versions 16 et supérieures
Les opérateurs de prise de référence (=, <= et <-) renvoient "Null" si l'affectation ou la prise de référence est invalide. Il devient possible d'écrire le code suivant :
Objet1 est un objet ClasseBase1
Objet2 est un objet ClasseDérivée

Objet1 <- Objet2

SI Objet1 = Null ALORS
        Trace("Objet1 n'est pas un ClasseDérivée ni une classe ancêtre de ClasseDérivée.")
SINON
        Trace("Objet1 est un ClasseDérivée ou un classe ancêtre de ClasseDérivée.")
FIN
Nouveauté 16
Les opérateurs de prise de référence (=, <= et <-) renvoient "Null" si l'affectation ou la prise de référence est invalide. Il devient possible d'écrire le code suivant :
Objet1 est un objet ClasseBase1
Objet2 est un objet ClasseDérivée

Objet1 <- Objet2

SI Objet1 = Null ALORS
        Trace("Objet1 n'est pas un ClasseDérivée ni une classe ancêtre de ClasseDérivée.")
SINON
        Trace("Objet1 est un ClasseDérivée ou un classe ancêtre de ClasseDérivée.")
FIN
Les opérateurs de prise de référence (=, <= et <-) renvoient "Null" si l'affectation ou la prise de référence est invalide. Il devient possible d'écrire le code suivant :
Objet1 est un objet ClasseBase1
Objet2 est un objet ClasseDérivée

Objet1 <- Objet2

SI Objet1 = Null ALORS
        Trace("Objet1 n'est pas un ClasseDérivée ni une classe ancêtre de ClasseDérivée.")
SINON
        Trace("Objet1 est un ClasseDérivée ou un classe ancêtre de ClasseDérivée.")
FIN
Version minimum requise
  • Version 15
Documentation également disponible pour…
Commentaires
Attention lors de l'utilisation de "=" et "<=" avec des structures avec des membres de type dynamiqu
Consulter ce post sur le forum :

https://forum.pcsoft.fr/fr-FR/pcsoft.fr.windev/209694-comportement-bizarre-tableaux-structure-avec-membres-type-dynamique-209774/read.awp
Sylvain RICAU
19 sep. 2017