PC SOFT

DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

PV

Nouveauté WINDEV Mobile 28 !
  • Ce que vous allez apprendre dans cette leçon
  • Exemple pratique
  • Qu'est-ce qu'une variable ?
  • Déclarer une variable
  • Affectation et utilisation
  • Les types de variables
  • La portée des variables
  • Portée Globale
  • Portée Locale
  • Schéma récapitulatif de la portée
  • Opérations simples sur les variables
  • Conseils
  • Détail d'un type de variable : les variables de type Chaîne
  • Le type Chaîne
  • Construction d'une chaîne
  • Opérations sur une chaîne
  • Recherche d'une chaîne
  • Comparer deux chaînes
Leçon 3.3. Les variables
Ce que vous allez apprendre dans cette leçon
  • Qu'est-ce qu'une variable ?
  • Les différents types de variables.
  • La portée des variables.
  • Le type Chaîne en détail.
Durée de la leçon

Durée estimée : 1 h
Leçon précédenteSommaireLeçon suivante
Exemple pratique
Pour réaliser directement les manipulations de cette leçon, nous allons travailler dans le projet "WLangage" que nous avons créé dans la leçon précédente.
  • Nous allons saisir le code directement dans le code d'initialisation du projet. Ce code étant le tout premier code exécuté lors du test du projet, nous pouvons ainsi réaliser des tests très simplement, sans interface. Pour visualiser le résultat de nos manipulations, nous utiliserons notamment la fonction Trace, qui permet d'écrire l'information voulue aussi bien dans une fenêtre de trace que dans le volet du débogueur (c'est cette dernière option que nous allons utiliser).
  • Pour afficher les événements WLangage liés au projet :
    1. Dans la barre des éléments ouverts, faites un clic droit sur le bouton "P". Le menu contextuel s'affiche.
    2. Sélectionnez l'option "Code de l'élément".
    3. L'éditeur de code affiche les différents événements associés au projet.

Note

Les manipulations de cette leçon peuvent également réalisées avec l'outil WDScript, l'éditeur de scripts WLangage. Pour lancer cet outil, sous le volet "Outils", dans le groupe "Utilitaires", cliquez sur "WDScript".
Qu'est-ce qu'une variable ?
Dans un langage de programmation, une variable permet de conserver des données. Ce sont des parties de la mémoire qui contiennent des chaînes, des nombres, etc.
Les variables permettent d'effectuer des calculs mathématiques, de faire des comparaisons ou tout simplement de stocker des informations pour les retrouver plus tard.
Déclaration et initialisation d'une variable
Une variable est représentée par :
  • un nom : Nom donné à la variable afin de la manipuler par le langage.
  • un type : Nature de la donnée stockée dans la variable (voir Les types de variables).
  • une valeur : Information stockée dans la variable.
  • une portée : Limite d'utilisation de la variable dans le programme (voir La portée des variables). La portée est définie principalement par l'endroit où la variable est déclarée.

Note

Nous avons vu dans les premières leçons qu'il était possible d'utiliser une charte de programmation.
Par défaut, cette charte est appliquée automatiquement aux éléments de votre projet : champs, fenêtres ou pages, états, etc.
Lors de la création du projet, dans l'étape "Charte de programmation", il est possible de sélectionner l'option "Ajouter automatiquement les préfixes à la création des variables". Si cette option est sélectionnée, un préfixe sera automatiquement ajouté pour identifier le type de la variable.
Ainsi, la déclaration :
Prix est un monétaire
deviendra :
moPrix est un monétaire
où "mo" est le préfixe des variables de type "Monétaire".

Cette option peut être modifiée dans l'onglet "Options" de la fenêtre de description de projet, option "Ajouter automatiquement les préfixes".

Déclarer une variable

Avant d'utiliser une variable, il faut tout d'abord la déclarer (c'est-à-dire la créer).
  • Exemple d'une déclaration simple :
    Prix est un monétaire
    • Prix représente le nom de la variable.
    • est un permet de déclarer la variable. Le WLangage utilise le langage naturel en français.
    • monétaire correspond au type de la variable.
  • Exemple d'une déclaration multiple :
    Nom, Prénom sont des chaînes
    • Nom, Prénom représentent les noms des variables.
    • sont des permet de déclarer un ensemble de variables.
    • chaînes représente le type des variables.

Note

En fonction de l'endroit où la variable est déclarée, cette variable peut être globale à l'élément (nous verrons cette notion dans le paragraphe "Portée des variables" dans la suite de cette leçon).

Si vous utilisez le préfixage automatique des variables, la lettre 'g' (pour globale) sera alors ajoutée devant le nom de la variable. Par exemple, la déclaration de la variable Nom devient :
gsNom est une chaîne
Dans la suite de ce cours, nous n'utiliserons pas le préfixage automatique des variables.

Nous verrons en détail les différents types de variables (locale et globale) dans les paragraphes suivants.


  • Nous allons saisir ces déclarations sous l'éditeur de code. Dans l'événement "Initialisation" du projet "WLangage", saisissez le code suivant :
    Prix est un monétaire
    Nom, Prénom sont des chaînes

    Vous pouvez observer la coloration spécifique des différents éléments de la déclaration : une couleur spécifique est utilisée pour le nom de la variable et une autre pour son type. Ces couleurs permettent d'identifier rapidement les différents éléments de votre code.

Affectation et utilisation

Lorsque la variable est déclarée, il est possible de l'affecter (ou lui donner une valeur). L'opérateur = permet d'effectuer cette affectation.

  • Nous allons tout de suite tester cet opérateur. Dans l'événement "Initialisation" du projet "WLangage", ajoutez le code suivant :
    // Affectation d'une variable de type monétaire
    Prix = 1256.67
    // Affichage du contenu de la variable
    Trace(Prix)
    // Affectation d'une variable de type chaîne
    Nom = "Dupont"
    // Affichage du contenu de la variable
    Trace(Nom)

    Dans ce code, les variables Prix et Nom sont affectées avec une valeur. Pour lire et manipuler le contenu de la variable, il suffit d'utiliser le nom donné à la variable pour y accéder. Dans cet exemple, le contenu des variables est affiché dans le volet "Trace du débogueur" grâce à la fonction Trace.
  • Testons notre code :
    1. Lancez le test du projet en mode simulateur :
      • Déroulez parmi les boutons d'accès rapide.
      • Cliquez sur Tester le projet pour lancer le test du projet en mode simulateur.
      • Validez si nécessaire la fenêtre d'avertissement.
    2. Le projet se lance en exécution et l'éditeur de code réapparaît.
    3. Affichez si nécessaire le volet "Trace du débogueur" pour voir le résultat : sous le volet "Accueil", dans le groupe "Environnement", déroulez "Volets", sélectionnez "Volets" puis "Trace du débogueur".
    4. Le volet "Trace du débogueur" contient le contenu de nos variables :
      1256.67
      Dupont
Les types de variables
Le type de la variable permet d'indiquer quelle est la forme de l'information que l'on stocke dans la variable. Les types les plus basiques sont :
  • booléen (Vrai ou Faux),
  • chaîne ("Dupont"),
  • entier (1234),
  • monétaire (12.32),
  • réel (7.766666),
  • etc.

Important

Utilisez le type correspondant à l'information que vous voulez stocker. Vous optimisez ainsi l'utilisation de la mémoire mais surtout vous évitez des erreurs de calcul ou de traitement lors de l'utilisation des variables dans les fonctions du WLangage.

Au cours de ce tutoriel, nous allons utiliser la plupart de ces types de variables. Nous verrons également les types Tableau, Date, Heure, Structure, etc.
Il existe également des variables de type "avancé". Ces types avancés regroupent toutes les caractéristiques de l'élément manipulé en une seule variable. Ces types avancés permettent par exemple de manipuler les documents XML, les emails, les fichiers XLS, etc. Nous manipulerons également ce type de variable dans la suite de ce tutoriel.
Pour plus de détails, consultez l'aide concernant le type voulu (voir Les différents types de variables).
La portée des variables
Il est possible de déclarer les variables à n'importe quel endroit dans le code. Cependant, en fonction de la position de sa déclaration, la variable n'est pas utilisable (ou visible) pour effectuer des traitements ou des calculs. On parle alors de portée des variables.
Il existe 2 types de portée :
  • Globale.
  • Locale.

Portée Globale

Le terme Global(e) signifie que la variable a une visibilité étendue dans le code. La variable est visible en dehors de l'événement (ou du traitement) où elle a été déclarée. Il y a plusieurs niveaux de Globalité :
  • niveau Projet et Collection de procédures,
  • niveau Fenêtre, Fenêtre Mobile, Page, Etat,
  • niveau Champ.
Une variable déclarée au niveau du projet a la visibilité la plus importante dans le programme. Dans ce cas, le variable est déclarée dans l'événement "Initialisation du projet". La variable est visible partout, dans tous les événements et traitements du programme. Attention toutefois à ne pas trop déclarer de variables de cette portée : en effet, la mémoire occupée par la variable est toujours réservée même si la variable n'est pas utilisée. L'utilisation massive de variables globales n'est pas conseillée dans l'architecture d'un programme informatique. Pour passer les variables à un événement ou à un traitement, il est conseillé d'utiliser des paramètres (pour plus de détails, consultez "Paramètres et résultat d'une procédure").
Une variable déclarée au niveau d'une Collection de procédures a la même visibilité qu'une variable déclarée au niveau du projet. L'avantage de déclarer une variable au niveau d'une Collection est de regrouper (ou classer) les variables par thème (collection) afin de rendre plus lisible l'événement "Initialisation" du projet.
Une variable déclarée au niveau d'une Fenêtre, Fenêtre Mobile, Page ou Etat limite la portée de la variable aux événements ou traitements de l'élément (Fenêtre, Fenêtre Mobile, Page ou Etat) et de ses champs. Cela permet d'encapsuler et de limiter les utilisations.
Une variable globale déclarée au niveau d'un champ limite la portée de la variable aux événements du champ. Cela permet de regrouper les variables par champ et ainsi de rendre plus lisible l'événement "Initialisation" de la fenêtre.

Note

Par défaut, les variables globales sont colorées en bleu dans l'éditeur de code. Pour identifier les variables globales et leur portée, il est recommandé d'utiliser une norme d'écriture.

Portée Locale

Le terme Local(e) signifie que la variable a une visibilité très limitée dans le code. La variable est visible uniquement dans le traitement où elle a été déclarée. Cela permet ainsi de restreindre l'utilisation de la variable au traitement ou à l'événement.

Schéma récapitulatif de la portée

Portée des variables
Une variable est globale par défaut lorsqu'elle est déclarée :
  • dans l'événement "Initialisation" du projet (ou dans l'événement "Déclaration" de la collection de procédures). La variable est globale au projet.
  • dans l'événement "Déclarations globales" de la fenêtre, de la page ou de l'état. La variable est globale à l'élément (fenêtre, page ou état) dans lequel elle a été déclarée.
Dans tous les autres cas, une variable est locale au traitement ou à l'événement dans lequel elle est déclarée.
Attention : Pour déclarer une variable globale à un champ, il est nécessaire d'indiquer le mot-clé "GLOBAL" lors de sa déclaration dans l'événement "Initialisation" du champ.
Opérations simples sur les variables
Pour effectuer des calculs sur des variables, le WLangage met à disposition les opérateurs mathématiques classiques :
  • + pour faire une addition.
  • - pour faire une soustraction.
  • * pour faire une multiplication.
  • / pour faire une division.
D'autres opérateurs peuvent être utilisés pour réaliser des calculs :
  • ++ pour incrémenter de 1 (additionner 1 à la variable).
  • - - pour décrémenter de 1 (soustraire 1 à la variable).
  • += pour affecter en additionnant une valeur.
  • - = pour affecter en soustrayant une valeur.
  • Pour avoir un aperçu des opérations réalisables, nous allons faire un petit test :
    1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
    2. Saisissez le code suivant :
      // Déclaration de variables
      Compteur est un entier
      V1 est un entier
      Res est un numérique
       
      // Affectation
      Compteur = 10
      V1 = 3
       
      // Utilisation des opérateurs
      Compteur = Compteur + 3   // Compteur vaut 13
      Trace(Compteur)
      Compteur ++ // Compteur vaut 14
      Trace(Compteur)
      Compteur -= 8 // Compteur vaut 6
      Trace(Compteur)
      Compteur = Compteur * V1 // Compteur vaut 18
      Trace(Compteur)
      Res = Compteur / 5 // Res vaut 3.6
      Trace(Res)
      Ce code permet de faire diverses opérations et affiche à chaque fois le résultat dans la fenêtre de trace.
  • Testons notre code :
    1. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
    2. Affichez si nécessaire le volet "Trace du débogueur" pour voir le résultat : sous le volet "Accueil", dans le groupe "Environnement", déroulez "Volets" et sélectionnez "Volets" puis "Trace du débogueur".
    3. Le volet "Trace du débogueur" contient la valeur de la variable Compteur pour chaque opération réalisée :
      13
      14
      6
      18
      3.6
Des opérateurs de comparaison sont également disponibles :
  • < inférieur strict
  • > supérieur strict
  • <= inférieur ou égal
  • >= supérieur ou égal
  • <> différent de
  • = égal à
D'autres opérateurs sont disponibles. Pour plus de détails sur les opérateurs, consultez Liste des opérateurs.

Conseils

  • Il est très pratique de nommer les variables avec des noms longs (et éviter les noms très courts i, j, k par exemple). Lors de la relecture du programme, il est ainsi possible de se rappeler à quoi sert la variable.
  • Pour définir le nom des variables, le WLangage accepte tous les caractères Unicode, y compris les accents. Autant en profiter pour plus de lisibilité ! Attention toutefois : certains caractères sont interdits : espace, =, point, virgule, etc.
  • Il est très important de donner le bon type à la variable en fonction de son utilisation. Par exemple, pour stocker une suite de chiffres, il peut être nécessaire :
    • d'utiliser une variable de type numérique si cette variable doit être utilisée pour des calculs.
    • d'utiliser une variable de type chaîne si cette variable permet de stocker des chiffres sans effectuer de calculs (par exemple pour mémoriser le numéro de sécurité sociale).
Détail d'un type de variable : les variables de type Chaîne
Les variables de type Chaîne sont un des types de variables les plus utilisés.
Nous allons détailler une partie des fonctionnalités disponibles sur ce type de variable.

Le type Chaîne

Nous savons déjà que le type Chaîne permet de stocker et manipuler les caractères et les chaînes de caractères.
Nous avons déjà vu comment initialiser une variable de type chaîne :
Nom est une chaîne
// Affectation d'une variable de type chaîne
Nom = "Dupont"

Note

En WLangage, le caractère " (double quote) est le caractère utilisé pour délimiter une chaîne de caractères. Dans l'exemple ci-dessus, les doubles quotes sont utilisées pour affecter la valeur Dupont à la variable Nom.
Il n'est pas nécessaire de déclarer la longueur de la chaîne : le WLangage adapte automatiquement cette longueur lors de l'utilisation de la variable.

Astuce

Pour initialiser une variable de type chaîne avec un texte sur plusieurs lignes, utilisez la syntaxe suivante :
<Nom variable> = "
<Texte de la ligne 1>
<Texte de la ligne 2>
"
Par exemple :
MaChaîne est une chaîne
MaChaîne = "
Exemple de
chaîne multi-ligne
"
Il est également possible d'affecter une variable de type chaîne avec le contenu d'un champ manipulant des chaînes. Ainsi, le code permettant d'affecter une variable de type chaîne avec le contenu d'un champ de saisie est le suivant :
Nom est une chaîne
// Affectation d'une variable de type chaîne
// avec le contenu du champ de saisie SAI_Nom
Nom = SAI_Nom

Construction d'une chaîne

Comme nous l'avons vu précédemment, la déclaration et l'affectation d'une chaîne sont très simples. Par exemple :
MaChaîneConstruite est une chaîne
NomProduit est une chaîne = "WINDEV Mobile"
Cependant, bien souvent, une chaîne peut être composée d'éléments variables, comme le nom d'un produit par exemple. Dans ce cas, plusieurs méthodes de construction des chaînes sont disponibles. Nous allons tester ces différentes méthodes, et voir leurs avantages et leurs inconvénients.

  • Reprenons notre exemple "WLangage" :
    1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
    2. Dans l'événement "Initialisation" du projet "WLangage", saisissez le code suivant :
      MaChaîneConstruite est une chaîne
      NomProduit est une chaîne = "WINDEV Mobile"
       
      // Concaténation
      MaChaîneConstruite = "Mon outil de développement, c'est " + NomProduit + " !"
      Trace("Concaténation : " + MaChaîneConstruite)
       
      // ChaîneConstruit
      MaChaîneConstruite = ChaîneConstruit("Mon outil de développement, c'est %1 !", NomProduit)
      Trace("ChaîneConstruit : " + MaChaîneConstruite)
       
      // Saisie directe de la variable (syntaxe [% %])
      MaChaîneConstruite = "Mon outil de développement, c'est [%NomProduit%] !"
      Trace("Saisie directe : " + MaChaîneConstruite)

      Dans ce code, la variable MaChaîneConstruite est construite en utilisant 3 méthodes différentes :
      • 1ère méthode : concaténation simple grâce à l'opérateur '+' . Les chaînes sont simplement mises les unes à la suite des autres. Cette méthode est la plus courante. Cependant, cette méthode atteint ses limites si le message doit être affiché à l'utilisateur dans une application multilingue. En effet, selon la syntaxe de la langue utilisée, il peut être nécessaire de déplacer la position de la variable, ce qui ne sera pas possible dans ce cas.
      • 2ème méthode : Utilisation de la fonction ChaîneConstruit. Cette fonction permet d'écrire le message dans son ensemble, la partie variable étant identifiée par '%1', '%2', etc. La valeur de ces identifiants correspond aux paramètres suivants de la fonction. Cette méthode est bien plus simple pour une traduction, mais reste difficilement lisible (le contenu des %x étant des paramètres de la fonction).
      • 3ème méthode : Utilisation directe de la variable. Cette méthode regroupe tous les avantages : simplicité pour la traduction et compréhension directe du message. Il suffit de mettre directement le nom de la variable voulue dans la chaîne en l'encadrant par les balises [% et %].
      Pour chaque type de construction, la fonction Trace permet d'afficher le résultat dans le volet "Trace du débogueur".

  • Testons notre code :
    1. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
      Le projet se lance et l'éditeur de code réapparaît.
    2. Affichez si nécessaire le volet "Trace du débogueur" pour voir le résultat : sous le volet "Accueil", dans le groupe "Environnement", déroulez "Volets" et sélectionnez "Volets" puis "Trace du débogueur".
    3. Le volet "Trace du débogueur" contient nos exemples de concaténation :
      Concaténation : Mon outil de développement, c'est WINDEV Mobile !
      ChaîneConstruit : Mon outil de développement, c'est WINDEV Mobile !
      Saisie directe : Mon outil de développement, c'est WINDEV Mobile !

Note

La méthode utilisée pour la concaténation de chaîne influe sur la simplification de la compréhension et de la traduction, mais aussi sur les performances. Ainsi, la première méthode prend environ deux fois plus de temps qu'une des deux autres méthodes.

Opérations sur une chaîne

Le WLangage propose de nombreux opérateurs et fonctions permettant de gérer les extractions et les manipulations de chaînes.

  • Pour avoir un aperçu de la puissance et de la simplicité du WLangage pour la manipulation des chaînes, faisons un petit test rapide afin de parcourir une chaîne et d'en extraire les sous-chaînes.
    1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
    2. Saisissez le code suivant :
      ListeProduits est une chaîne = "
      WINDEV
      WEBDEV
      WINDEV Mobile
      "
       
      POUR TOUTE CHAÎNE UnProduit DE ListeProduits SÉPARÉE PAR RC
      Trace(UnProduit)
      FIN
      Produit est une chaîne = ListeProduits.ExtraitChaîne(2, RC)
      Trace(Produit)
    3. Ce code permet à la fois de parcourir la chaîne multiligne et d'en extraire un élément. Examinons ce code :
      • La chaîne ListeProduits est une chaîne multiligne.
      • L'instruction "POUR TOUTE CHAINE" nous permet de parcourir les différents éléments de la chaîne. Ces éléments sont séparés par un RC (Retour Chariot).
      • La fonction <Chaîne>.ExtraitChaîne appliquée à la chaîne permet dans notre cas d'extraire le second élément de la chaîne (c'est-à-dire "WEBDEV").
    4. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
    5. Le volet "Trace du débogueur" contient les éléments suivants :
      WINDEV
      WEBDEV
      WINDEV Mobile
      WEBDEV
  • Il est également possible d'extraire des parties d'une chaîne en utilisant simplement les opérateurs [[ et ]]. Ces opérateurs permettent simplement d'extraire la partie du texte voulue, en spécifiant le numéro du caractère de départ et ou d'arrivée.
    1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
    2. Saisissez le code suivant :
      Texte est une chaîne = "San Francisco"
      // Affiche le cinquième caractère dans la trace "F"
      Trace(Texte[[5]])
      // Affiche les caractères de 5 à 10 dans la trace "Franci"
      Trace(Texte[[5 À 10]])
      // Affiche les caractères à partir du cinquième dans la trace "Francisco"
      Trace(Texte[[5 À]])
      // Affiche les 10 premiers caractères dans la trace "San Franci"
      Trace(Texte[[À 10]])
      // Affiche à partir du 10ème caractère dans la trace "isco"
      Trace(Texte[[10 SUR 4]])
    3. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
    4. Le volet "Trace du débogueur" contient les informations suivantes :
      F
      Franci
      Francisco
      San Franci
      isco
  • Le WLangage permet également de formater la chaîne de caractères grâce à la fonction <Chaîne>.Formate. Il est ainsi possible de demander à afficher une chaîne sans accent, en majuscules ou un minuscules, etc. Voici un petit exemple rapide :
    1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
    2. Saisissez le code suivant :
      TexteInitial est une chaîne = "Mon outil de développement, c'est WINDEV Mobile !"
       
      // Formate la chaîne initiale sans accent et en minuscule
      TexteInitial = TexteInitial.Formate(ccSansAccent + ccMinuscule)
      Trace(TexteInitial)
      // Formate la chaîne obtenue sans espace et en majuscule
      TexteInitial = TexteInitial.Formate(ccMajuscule + ccSansEspaceIntérieur)
      Trace(TexteInitial)
    3. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
    4. Le volet "Trace du débogueur" contient les informations suivantes :
      mon outil de developpement, c'est windev mobile !
      MONOUTILDEDÉVELOPPEMENT,C'ESTWINDEVMOBILE!
Pour plus de détails sur la gestion des chaînes de caractères, consultez Manipuler les chaînes de caractères et Fonctions de gestion des chaînes de caractères.

Recherche d'une chaîne

Une manipulation courante sur les chaînes de caractères est la recherche. Qui n'a pas voulu savoir si un mot était présent dans une chaîne de caractères, quelle était sa position, etc. En WLangage, rien de plus simple.

  • Nous allons effectuer une recherche dans une chaîne de caractères :
    1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
    2. Saisissez le code WLangage suivant :
      ChaîneARechercher est une chaîne = "WINDEV Mobile"
       
      TexteOriginal est une chaîne = "
      Outils de développement :
      - WINDEV
      - WEBDEV
      - WINDEV Mobile
      "
       
      Pos est un entier
      Pos = Position(TexteOriginal, ChaîneARechercher)
      SI Pos = 0 ALORS
      Trace("La chaîne [%ChaîneARechercher%] n'a pas été trouvée dans le texte")
      SINON
      Trace("La chaîne [%ChaîneARechercher%] a été trouvée à la position [%Pos%]")
      FIN

      Examinons ce code WLangage :
      • Plusieurs variables sont déclarées :
        • une variable de type Chaîne correspondant à la chaîne à rechercher.
        • une variable de type Chaîne correspondant au texte dans lequel la recherche doit être effectuée.
        • une variable de type Entier correspondant à la position de la chaîne recherchée.
      • La fonction WLangage Position permet de rechercher une chaîne dans une autre. Dans notre exemple, nous recherchons le contenu de la variable ChaîneARechercher dans le contenu de la variable TexteOriginal.
      • Si la fonction Position renvoie 0, cela signifie que la chaîne à rechercher n'a pas été trouvée.
      • Un message est affiché grâce à la fonction Trace indiquant si la chaîne a été trouvée et sa position.
    3. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
    4. Le volet "Trace du débogueur" contient les informations suivantes :
      La chaîne WINDEV Mobile a été trouvée à la position 50

Comparer deux chaînes

Une autre opération courante sur les chaînes de caractères est la comparaison de chaînes : trouver si deux chaînes sont identiques.
  • Nous allons effectuer une comparaison de deux chaînes de caractères :
    1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
    2. Saisissez le code WLangage suivant :
      // Chaînes à comparer
      Chaîne1 est une chaîne = "DEVELOPPEMENT"
      Chaîne2 est une chaîne = "DEV"
       
      // Les 2 chaînes sont comparées avec l'opérateur ~= (égalité souple)
      SI Chaîne1 ~= Chaîne2 ALORS
      Trace("Les 2 chaînes sont équivalentes")
      SINON
      Trace("Les 2 chaînes sont différentes")
      FIN

      Examinons ce code WLangage :
      • Deux variables de type Chaîne sont déclarées. Elles contiennent les chaînes à comparer.
      • La comparaison est effectuée avec l'opérateur ~= (égalité souple). Cet opérateur permet de faire une comparaison sans tenir compte de la casse, des espaces avant et après la chaîne et sans tenir compte des accents.
      • Le résultat de la comparaison est affiché.
    3. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
    4. Le volet "Trace du débogueur" contient les informations suivantes :
      Les 2 chaînes sont différentes
    5. Revenez dans le code et modifiez la ligne de code correspondant à la déclaration de Chaîne2 :
      Chaîne2 est une chaîne = "Développement"
    6. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
    7. Le volet "Trace du débogueur" contient les informations suivantes :
      Les 2 chaînes sont équivalentes
      En effet, même si les deux chaînes n'ont pas la même casse, elles sont identiques.
Remarque : Il existe différents opérateurs de comparaison.
Leçon précédenteSommaireLeçon suivante
Version minimum requise
  • Version 28
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire