Tuto - Les bases du WLangage

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.

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. Dans ce tuto, nous allons présenter quelques types de variable en détail.
• une valeur : Information stockée dans la variable.
• une portée : Limite d'utilisation de la variable dans le programme. La portée est définie principalement par l'endroit où la variable est déclarée. Pour plus de détails sur ce sujet, consultez Portée des variables.

Déclarer une variable

• Dans l'événement "Initialisation" du projet "WLangage", saisissez le code suivant :
  

  Prix est un monétaire

• Dans ce code :
  • 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.

• Dans l'événement "Initialisation" du projet "WLangage", saisissez le code suivant :
  

  Nom, Prénom sont des chaînes

• Dans ce code :
  • 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.

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

// 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)

1. Lancez le test du projet en cliquant sur parmi les boutons d'accès rapide.
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".
   
   Avertissement
   Ne confondez pas le volet "Débogueur" et le volet "Trace du débogueur".
4. Le volet "Trace du débogueur" contient le contenu de nos variables :
   
   1256.67
   Dupont

• booléen (Vrai ou Faux),
• chaîne ("Dupont"),
• entier (1234),
• monétaire (12.32),
• réel (7.766666),
• etc.

Pour aller plus loin :

• Le WLangage propose également des variables de type "avancé" regroupant 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.
  Pour plus de détails, consultez l'aide concernant le type voulu (voir Les différents types de 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.

• + pour faire une addition.
• - pour faire une soustraction.
• * pour faire une multiplication.
• / pour faire une division.

• ++ 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.

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.

1. Lancez le test du projet en cliquant sur parmi les boutons d'accès rapide.
2. 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

• < inférieur strict
• > supérieur strict
• <= inférieur ou égal
• >= supérieur ou égal
• <> différent de
• = égal à

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).

Le type Chaîne

Nom est une chaîne
// Affectation d'une variable de type chaîne
Nom = "Dupont"

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.

MaChaîne est une chaîne
MaChaîne = "
	Exemple de 
	chaîne multiligne
"

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

MaChaîneConstruite est une chaîne
NomProduit est une chaîne = "WINDEV"

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"
   
   // Concaténation
   MaChaîneConstruite = "Mon outil de développement, c'est " + NomProduit + " !"
   Trace("Concaténation : " + 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 2 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 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".

1. Lancez le test du projet en cliquant sur parmi les boutons d'accès rapide.
   Le projet se lance et l'éditeur de code réapparaît.
2. Le volet "Trace du débogueur" contient nos exemples de concaténation :
   
   Concaténation : Mon outil de développement, c'est WINDEV !
   Saisie directe : Mon outil de développement, c'est WINDEV !

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 que la seconde.

Opérations sur une chaîne

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).
     
     

     En WLangage, il n'est pas nécessaire de se soucier des majuscules ou des minuscules lors de la saisie des instructions dans l'éditeur de code : la bonne casse sera automatiquement appliquée lors de la saisie.
   • 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 parmi les boutons d'accès rapide.
5. Le volet "Trace du débogueur" contient les éléments suivants :
   
   WINDEV
   WEBDEV
   WINDEV Mobile
   WEBDEV

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 3 caractères à partir du 10ème caractère dans la trace "isc"
   Trace(Texte[10 SUR 3])

3. Lancez le test du projet en cliquant sur parmi les boutons d'accès rapide.
4. Le volet "Trace du débogueur" contient les informations suivantes :
   
   F
   Franci
   Francisco
   San Franci
   isc

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 !"
   
   // 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 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 !
   MONOUTILDEDÉVELOPPEMENT,C'ESTWINDEV!

Pour aller plus loin : N'hésitez pas à consulter les pages d'aide Manipuler les chaînes de caractères et Fonctions de gestion des chaînes de caractères.

Recherche d'une chaîne

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"
   
   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 parmi les boutons d'accès rapide.
4. Le volet "Trace du débogueur" contient les informations suivantes :
   
   La chaîne WINDEV a été trouvée à la position 30

Comparer deux 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 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 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 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.

Pour aller plus loin : De nombreux opérateurs de comparaison sont disponibles. Pour plus de détails, consultez la page opérateurs de comparaison.