TABLE DES MATIÈRES RÉSUMÉE
0.1Introduction 8
0.1.1L’intérêt de la programmation 8
0.1.1Vue d’ensemble et méthode de travail 9
0.2Algorithmie et programmation élémentaires 11
0.2.1Généralités 11
0.2.2Premier contact : programme BONJOUR 24
0.2.3Alternatives 46
0.2.4Répétitions 65
0.2.5Sous-programmes et fonctions 77
0.2.6Compléments 85
0.2.7Exercices 95
0.3Algorithmie et programmation améliorées 100
0.3.1Un menu pour s’ouvrir l’appétit 100
0.3.2Algorithmie améliorée 111
0.3.3Les langages et les programmations 111
0.3.4Améliorations des entrées et des sorties 118
0.3.5Fichiers : opérations de base 118
0.3.6Opérations diverses 127
0.4Du boulot de pro 128
0.4.1Algorithmie 128
0.4.2Le langage dBASE 128
0.5COMPLEMENTS 139
0.5.1Sources d'information 139
0.5.2Historique 139
TABLE DES MATIÈRES DETAILLEE
0.1Introduction 8
0.1.1L’intérêt de la programmation 8
0.1.1Vue d’ensemble et méthode de travail 9
0.1.1.0.1Vue d’ensemble 9
0.1.1.0.2Méthode de travail 9
0.1.1.0.3Plan d’étude 10
0.1.1.0.4Rappels et conseils 10
0.2Algorithmie et programmation élémentaires 11
0.2.1Généralités 11
0.2.1.1L’algorithmie 11
0.2.1.2La programmation 15
0.2.1.2.1Quelques langages 15
0.2.1.2.2Structure de principe d’un programme 19
0.2.1.2.3Délimitation du programme 19
0.2.1.2.4Éléments d’un langage 19
0.2.2Premier contact : programme BONJOUR 24
0.2.2.1Travail préparatoire sur papier 25
0.2.2.1.1Compréhension du problème 25
0.2.2.1.2Algorithme 25
0.2.2.1.3Déclaration des variables et délimitation du programme 25
0.2.2.1.4Lecture de données tapées au clavier, avec affichage d’un message 28
0.2.2.1.5Traitements simples 31
0.2.2.1.6Sortie de résultats, avec un message 32
0.2.2.1.7Récapitulatif du programme au brouillon 34
0.2.2.2Travail sur l'ordinateur 37
0.2.2.2.1Lancement du logiciel 37
0.2.2.2.2Frappe et stockage du programme 37
0.2.2.2.3Exécution et mise au point 43
0.2.2.3Application : programme RECTANGLE 45
0.2.2.4Exercices 46
0.2.3Alternatives 46
0.2.3.1L’alternative simple 46
0.2.3.1.1Principe 46
0.2.3.1.2Forme générale 46
0.2.3.1.3Fonctionnement 47
0.2.3.1.4Organigramme équivalent 47
0.2.3.1.5Exemple : programme COMPARNOMS1 47
0.2.3.1.6Programmation 48
0.2.3.1.7Cas d'une formule de tableur 49
0.2.3.2L’alternative simplifiée 49
0.2.3.2.1Présentation 50
0.2.3.2.2Exemple : programme COMPARNOMS2 50
0.2.3.2.3Programmation 50
0.2.3.3Les alternatives imbriquées 51
0.2.3.3.1Présentation 51
0.2.3.3.2Exemple : programme COMPARNOMS3 52
0.2.3.3.3Programmation 53
0.2.3.3.4Remarque 54
0.2.3.3.5Cas d'une formule de tableur 54
0.2.3.4L’alternative multiple 54
0.2.3.4.1Principe 54
0.2.3.4.2Forme générale 55
0.2.3.4.3Fonctionnement 55
0.2.3.4.4Organigramme équivalent 55
0.2.3.4.5Exemple : programme COMPARNOMS4 56
0.2.3.4.6Programmation 57
0.2.3.4.7Remarque 58
0.2.3.5Application : programme BONJOURSI 58
0.2.3.5.1Algorithme 58
0.2.3.5.2dBASE interface texte 59
0.2.3.5.3dBASE interface fenêtre 59
0.2.3.5.4Paradox 59
0.2.3.5.5Lotus 59
0.2.3.5.6Access 59
0.2.3.5.7Macro WordBasic 7 59
0.2.3.5.8Macro Excel 7 60
0.2.3.6Exercices 60
0.2.3.6.1Énoncés 60
0.2.3.6.2Corrigés 61
0.2.4Répétitions 65
0.2.4.1La répétition Tant que 65
0.2.4.1.1Principe 65
0.2.4.1.2Forme générale 65
0.2.4.1.3Fonctionnement 66
0.2.4.1.4Organigramme équivalent 66
0.2.4.1.5Exemple : programme COMPTERTANTQUE 66
0.2.4.1.6 Programmation 67
0.2.4.1.7Remarques et conseils 67
0.2.4.2La répétition Jusqu’à 68
0.2.4.2.1Principe 68
0.2.4.2.2Forme générale 68
0.2.4.2.3Fonctionnement 68
0.2.4.2.4Organigramme équivalent 69
0.2.4.2.5Exemple : programme COMPTERJUSQUA 69
0.2.4.2.6Programmation 69
0.2.4.2.7Remarques et conseils 70
0.2.4.3La répétition Pour 70
0.2.4.3.1Principe 70
0.2.4.3.2Forme générale 71
0.2.4.3.3Fonctionnement 71
0.2.4.3.4Organigramme équivalent 71
0.2.4.3.5Exemple : programme COMPTERPOUR 72
0.2.4.3.6Programmation 72
0.2.4.3.7Remarques et conseils 73
0.2.4.4La répétition infinie 73
0.2.4.4.1Principe 74
0.2.4.4.2Une forme possible 74
0.2.4.4.3Exemple : menu en interface texte 74
0.2.4.4.4Remarque : arrêt forcé 75
0.2.4.5Application : programme BONJOURREPETITION 75
0.2.4.5.1dBASE interface texte 75
0.2.4.5.2dBASE interface fenêtre 75
0.2.4.5.3Paradox 75
0.2.4.5.4Lotus 75
0.2.4.5.5Access 76
0.2.4.5.6WordBasic 7 76
0.2.4.5.7Excel 7 76
0.2.4.6Exercices 76
0.2.5Sous-programmes et fonctions 77
0.2.5.1Les sous-programmes 77
0.2.5.2Les fonctions 78
0.2.5.3Sous-programmes et fonctions de bibliothèque 79
0.2.5.4Programmation 79
0.2.5.4.1Sous-programmes 79
0.2.5.4.2Fonctions 80
0.2.5.5Application 82
0.2.5.6Exercices 82
0.2.5.6.1Enoncés 83
0.2.5.6.2Corrigés 83
0.2.6Compléments 85
0.2.6.1Test de fin d’un fichier ou d’une suite de données 85
0.2.6.2Outils 85
0.2.6.2.1Les totalisateurs 85
0.2.6.2.2Les compteurs 87
0.2.6.2.3Les témoins 88
0.2.6.3Conseils 89
0.2.6.3.1Comprendre ce que représente un algorithme 90
0.2.6.3.2"Faire tourner" un algorithme 90
0.2.6.3.3Les principes de la PS 91
0.2.6.3.4Recettes 91
0.2.6.3.5Pour bâtir un algorithme 92
0.2.6.3.6Définitions provenant de dBASE 92
0.2.6.4Exercices 94
0.2.7Exercices 95
0.2.7.1Énoncés 95
0.2.7.2Corrigés 96
0.3Algorithmie et programmation améliorées 100
0.3.1Un menu pour s’ouvrir l’appétit 100
0.3.1.1Un menu pour nos exos 100
0.3.1.1.1Programmation classique et interface texte 101
0.3.1.1.2Programmation orientée objets et interface fenêtre 102
0.3.1.2Menu dBASE interface texte 102
0.3.1.3Menu dBASE interface fenêtre "Débutants" 103
0.3.1.3.1Nul salut hors le formulaire 103
0.3.1.3.2Création du menu 104
0.3.1.3.3 Création du formulaire de base et affectation du menu 105
0.3.1.3.4 Exécution du formulaire de base 106
0.3.1.3.5 Différence entre dBASE 5 et dBASE 5.5 106
0.3.1.4 Menu dBASE "Comme les pros" 106
0.3.1.4.1 Ajout du menu "Comme les pros" 107
0.3.1.4.2 Mieux que les pros 109
0.3.1.5Menus dans les autres langages 110
0.3.1.5.1Paradox 110
0.3.1.5.2Lotus 110
0.3.1.5.3Access 110
0.3.1.6Exercices 110
0.3.2Algorithmie améliorée 111
0.3.3Les langages et les programmations 111
0.3.3.1Les programmations 111
0.3.3.2Les avatars du programme 111
0.3.3.3Les concepts de la POO 113
0.3.3.3.1Les objets et les classes 113
0.3.3.3.2Les contrôles 115
0.3.3.3.3Les propriétés 115
0.3.3.3.4Les méthodes 116
0.3.3.3.5Les évènements 116
0.3.3.4L’exécution 116
0.3.3.5Divers 117
0.3.4Améliorations des entrées et des sorties 118
0.3.5Fichiers : opérations de base 118
0.3.5.1Commandes 118
0.3.5.2Exercices 125
0.3.5.2.1Enoncés 125
0.3.5.2.2Corrigés 125
0.3.6Opérations diverses 127
0.4Du boulot de pro 128
0.4.1Algorithmie 128
0.4.2Le langage dBASE 128
0.4.2.1Classes 128
0.4.2.1.1Classes personnalisées 128
0.4.2.1.2Classes standard 128
0.4.2.2Formulaires 129
0.4.2.3Exemple : "Bonjour" en programmation directe 130
0.4.2.4Exercices 132
0.4.2.4.1Enoncés 132
0.4.2.4.2Corrigés 132
0.5COMPLEMENTS 139
0.5.1Sources d'information 139
0.5.2Historique 139
16/02/2003
0.1Introduction
Revoir notamment le chapitre sur les données, dans le tome A.
0.1.1L’intérêt de la programmation
- On va beaucoup plus vite et plus clairement qu’avec des manipulations laborieuses à la souris, surtout lorsqu’elles sont répétitives ;
- Dès qu’on dépasse une exploitation simple de ses données, on est amené à avoir besoin de solutions spécifiques.
0.1.1Vue d’ensemble et méthode de travail
0.1.1.0.1Vue d’ensemble
Rappel sur le processus pratique : on se trouve face à un petit problème de gestion ; on veut le faire traiter par un ordinateur ; que faire entre les 2 ?
1- préparation par un informaticien
A orientée vers le problème :
a- comprendre le problème posé et concevoir les grandes lignes d’une solution, rédigée en français ordinaire
b- algorithme détaillé
B orientée vers l’ordinateur :
a- choix d’un langage, avec éventuellement adaptation de l’algorithme selon le langage choisi, et codage de l’algorithme : rédaction du programme au brouillon
b- frappe et stockage du programme dans l’ordinateur
c- exécution du programme en ordinateur : essais et mise au point
2- utilisation réelle par l’utilisateur, à qui le(s) programme(s) laborieusement établi(s) est (sont) supposé(s) rendre service dans l’accomplissement de son travail.
0.1.1.0.2Méthode de travail
La vue que j’ai donnée ci-dessus pourrait être celle d’un informaticien travaillant dans une entreprise, à qui on demanderait de réaliser une application pour un des services de cette entreprise.
Pour nos TD, nous adapterons cela de la manière suivante (je vous incite quand même à réfléchir à la cohérence entre ce que j'ai raconté dans le § précédent et la démarche proposée ci-dessous) :
a- travail préparatoire sur papier :
- AVANT de commencer quoi que ce soit, bien lire l'énoncé et bien comprendre ce qu'on vous demande, et non ce que vous avez envie de comprendre ; vous faire une idée claire de TOUTES les opérations à enchaîner pour aboutir à l'obtention du résultat qu'on vous demande ;
- établir l’algorithme sur papier ;
- rédiger le programme au brouillon, dans le langage qu'on vous a indiqué ;
b- travail sur l’ordinateur (j'insiste : seulement APRÈS les étapes de préparation sur papier) :
- lancer le logiciel nécessaire à la frappe, au stockage et à l'exécution du programme (c'est généralement, mais pas obligatoirement, le même) ;
- taper le programme au clavier et le sauvegarder ;
- lancer l'exécution de ce programme pour l’essayer, et effectuer les éventuelles corrections pour la mise au point.
c- le prof expérimente votre œuvre d'art : si elle ne lui donne pas ce qu'il attend, c'est la note zéro… Justification : imaginez que vous soyez responsable d'un service dans une entreprise ; vous avez fait appel à une société d'informatique pour réaliser un logiciel quelconque dont vous avez besoin ; cette société a fait un boulot minable, et vous a installé un logiciel qui ne fonctionne pas comme vous lui avez demandé ; lorsqu'elle vous envoie la facture, il y a peu de chances pour que vous ayez envie de la payer…
La démarche que je préconise est fastidieuse, certes, mais dites-vous que très rares sont ceux qui peuvent "pisser du code" ex abrupto. Je tiens à bien insister sur ce que j’ai déjà dit à maintes reprises et qui est réellement fondamental : il est impératif de se résigner à suivre un minimum de méthode si l’on veut programmer correctement, et de s’astreindre à suivre mes conseils : effectuer le travail préparatoire sur papier AVANT de se précipiter sur son clavier.
0.1.1.0.3Plan d’étude
Le plan d’étude devrait donc être d’abord l’algorithmie, ensuite les langages. Cependant, pour ne pas frustrer les plus impatients, nous mènerons les deux en parallèle : chaque fois que nous étudierons une question d’algorithmie, nous verrons immédiatement comment la programmer et ce que donne l’exécution par l’ordinateur.
0.1.1.0.4Rappels et conseils
a- pour ne pas tout mélanger, créez un ou des répertoires sur votre disquette pour les exercices de programmation. Si vous étudiez, comme je le préconise, plusieurs langages en parallèle, créez autant de répertoires, par exemple "exos WordBasic 7", "exos Access", etc., mais pour dBASE, appelez-le "prgdbase", ou "exosdb" ; si vous désirez à tout prix des ennuis, appelez-le "exos db", ou "exercices dbase" ; si vous ne comprenez pas pourquoi, revoyez votre cours dBASE.
b- vérifiez bien votre répertoire par défaut ! Comme d’habitude, revoyez vos cours WORD, EXCEL, ou dBASE si vous ne comprenez pas ce que cela signifie !
c- conservez soigneusement tous vos exercices dans ce répertoire, ils vous resserviront plus tard lorsque nous verrons comment établir un menu. Attention : pour que ces exercices de la fin du cours fonctionnent correctement, il est indispensable que vous sauvegardiez TOUS vos exercices dans un langage donné dans le même répertoire.
d- faites très attention à ne pas ouvrir plusieurs instances (exemplaires) de votre application. Par exemple en TD, je vois très souvent des étudiants désespérés qui ne comprennent pas pourquoi leur dBASE donne par moments ce qu'ils attendent, et à d'autres moments leur refuse... Cela se surveille dans la barre des tâches. J'ai vu jusqu'à 8, oui, HUIT, dBASE ouverts ! Si on ouvre volontairement plusieurs exemplaires et si on maîtrise ce que l'on fait dans chacun, ça va, pas de problème, mais cela, je ne l'ai jamais vu !
0.2Algorithmie et programmation élémentaires
0.2.1Généralités
0.2.1.1L’algorithmie
J’ai déjà défini la programmation comme "l’art d’établir des programmes", ou, en termes plus grand public, "l’art de donner à un ordinateur les ordres nécessaires pour qu’il exécute exactement ce qu’on veut lui faire exécuter".
Il faut donc d’abord savoir soi-même quelles sont les opérations à réaliser, et surtout dans quel ordre on doit les exécuter : c’est l’étape de conception de la logique, ou de la structure du futur programme.
La seconde étape est le codage de la logique dans le langage choisi.
Un algorithme est une représentation par énoncés des différentes étapes d’un travail, mettant en évidence leur enchaînement.
C’est donc un outil d’aide à la programmation.
Très important : l’algorithme n’est ni le raisonnement, ni le programme !
- c’est une aide au raisonnement, permettant un support visuel commode, mais ce n’est pas le raisonnement ;
- c’est aussi une représentation en français du futur programme, mais ce n’est pas le programme.
Cette représentation doit respecter un formalisme rigoureux.
Nous nous contenterons de 3 règles simples :
- la déclaration préalable des variables et des constantes symboliques à utiliser dans le futur programme ;
- la délimitation claire de l’algorithme proprement dit par les mots "début" et "fin ;
- l’indentation des lignes constituant le corps de l’algorithme, destinée à bien repérer visuellement certains regroupements d’opérations.
N.B. La déclaration des variables ainsi que le codage des mots "début" et "fin" n’étant pas obligatoires dans tous les langages, je les omettrai parfois. Mais pour l’examen, vous ne devez pas les oublier !
Un organigramme est un moyen de représentation graphique des différentes étapes d’un travail, mettant en évidence leur enchaînement.
En d’autres termes, c’est une description graphique du travail en question.
C’est donc lui aussi un outil d’aide à la programmation.
Pour dessiner un organigramme, on utilise un certain nombre de symboles normalisés. Pour les organigrammes simples que nous allons bâtir, 4 suffiront. Les 3 premiers permettent de représenter les opérations élémentaires que nous connaissons, le 4ème est de pure commodité.
Pour a, b, d, on écrit évidemment l’opération concernée à l’intérieur du symbole. Pour b, on peut bien sûr permuter les sorties (oui à droite, non à gauche) si cela améliore le dessin d’ensemble.
Nous allons calculer la superficie et le périmètre d’un rectangle.
Nous supposerons que le lecteur, même non-mathématicien, se souvient des formules !
En application de la méthode préconisée, je donne quand même les explications : la superficie est égale au produit de la largeur par la longueur, et le périmètre est égal à 2 fois la largeur plus la longueur.
Soient LARG la largeur, LONG la longueur, SUPERF la superficie, et PERIM le périmètre.
L’algorithme est :
Variables : LARG, LONG, SUPERF, PERIM numériques
Début
Afficher message : "Tapez la largeur :"
Lire LARG
Afficher message : "Tapez la longueur :"
Lire LONG
Calculer SUPERF = LARG * LONG
Calculer PERIM = ( LARG + LONG ) * 2
Afficher message : "La superficie est :"
Afficher SUPERF
Afficher message : "Le périmètre est :"
Afficher PERIM
Fin
L’organigramme équivalent est :
Ce que nous venons d’établir dans le paragraphe précédent porte le doux nom de "structure de séquence". Eh oui, cher Monsieur JOURDAIN, lorsque vous effectuez des opérations les unes après les autres, vous "exécutez une structure séquentielle" ! Ça en jette, n’est-ce pas ? C’est tout de même mieux que de dire "j’effectue ces opérations à la queue-leu-leu", non ?
Nous étudierons dans la suite diverses autres structures, qui portent des noms évocateurs tels que "rupture de séquence" ou "structures de contrôle".
Exemples de définitions :
- de Microsoft : "Les instructions conditionnelles et les instructions de boucle (aussi appelées structures de contrôle) vous permettent d'écrire du code Visual Basic capable de prendre des décisions et de répéter des actions.".
- de dBASE : "Commandes de contrôle d'exécution : les commandes qui contrôlent le flux de l'exécution du programme. Les commandes de contrôle de flux (également appelées structures de contrôle) se connectent sur d'autres commandes ou bouclent de manière répétitive sur une série de commandes.".
Ah ! Ces informaticiens, quel sens de la Poésie, avec un grand P !
0.2.1.2La programmation
Revoir les chapitres "Programmation" et "Logiciels" du tome A.
0.2.1.2.1Quelques langages
La plus grande partie de ce que je raconterai au sujet de dBASE 5.5 sera aussi valable pour les versions ultérieures : dBASE 7, dB2K, dBASE Plus.
Extraits de l’aide de dBASE 5.5
Dans ces extraits de l’aide du logiciel, l’expression "Visual dBASE" désigne dBASE 5.5.
Visual dBASE est un système de gestion de base de données complet qui est à la fois un environnement de développement et un ensemble d'outils interactifs pour la gestion des données.
Visual dBASE place le langage dBASE et l'interface utilisateur dans l'environnement visuel, orienté objet, de Microsoft Windows, tout en conservant la compatibilité avec les versions précédentes de dBASE. Vous pouvez utiliser interactivement les outils de visualisation, tels que les menus et boîtes de dialogue ou directement le langage dBASE.
dBASE comprend plus de 600 éléments de langage (commandes, instructions, fonctions, etc.) que vous pouvez utiliser pour écrire des applications.
Le langage dBase est un langage de programmation structurée orienté objets conçu essentiellement pour développer des applications de bases de données. Il consiste en un ensemble de commandes, de fonctions et de classes que vous utilisez pour créer des applications destinées à stocker, gérer et traiter des données.
Visual dBASE inclut de nouvelles fonctions de langage telles que les extensions de programmation orientées objet conçues spécialement pour simplifier le développement d'applications dans l'environnement Windows.
dBASE en mode commande et en mode programmation
Nous avons travaillé avec dBASE jusqu’à présent en utilisant la souris, les menus, les boîtes de dialogue, etc., comme nous le faisions sous Word et sous Excel ; c’est ce que j’appelle le mode fenêtre interactif, ou le mode interface graphique.
Mais dBASE permet 2 autres façons de travailler (c’est-à-dire au total 3 modes d’utilisation) :
- en mode ligne de commande, avec une interface texte ;
- en mode programmation, qu’on peut encore subdiviser en programmation avec interface texte, dans la fenêtre de commande, et en programmation avec interface graphique à la sauce Windows.
À noter que c’est le seul S.G.B.D. à permettre le mode ligne de commande, les autres n’offrent que le mode programmation, ou scripts (outre le mode fenêtre interactif, évidemment).
ObjectPAL est le langage d'application orienté objet de Paradox. C'est un langage de programmation piloté par les événements, différent d'un langage de programmation procédural traditionnel par de nombreux aspects.
Avec ObjectPAL, vous mettez en place des objets (par exemple des boutons et des champs) dans une fiche ou un état et associez des modules de code, appelés méthodes, qui s'exécutent quand quelque chose se passe sur l'objet.
ObjectPAL a deux aspects :
le langage lui-même (types d'objets, méthodes, procédures, et constructions)
l'Environnement de Développement Intégré (EDI) qui inclut
l'Editeur ObjectPAL
le Débogueur
un mécanisme de création et d'exécution des scripts
les fonctions de distribution des applications
Le S.G.B.D. Approach offre 2 moyens de programmer :
- Le langage macro, qui ne vous permet pas d'automatiser tout ce que l'application vous permet de faire. Vous pouvez contrôler une plus grande partie d'Approach en programmant à l'aide de LotusScript. Dès lors, vous pouvez incorporer un programme LotusScript dans une macro, ou inversement, incorporer une macro dans un script.
- Le langage LotusScript, qui est commun aux produits de la suite bureautique de Lotus (essentiellement Wordpro, 1-2-3, Approach).
LotusScript est un langage de programmation orienté objet permettant d'automatiser les tâches des applications que vous développez dans Approach. LotusScript est plus puissant et souple que le langage de macro d'Approach, mais son utilisation requiert des connaissances élémentaires en programmation.
Les tâches que vous pouvez accomplir avec LotusScript dans Approach sont les suivantes :
• Lancement de l'exécution des scripts en réponse aux différentes actions de l'utilisateur (clic ou double-clic de souris, frappe de touche)
• Modification des attributs (couleur, taille, position, visibilité), d'un bloc de texte ou d'un autre élément d'affichage dans une vue
• Affichage ou gestion des boîtes de dialogue d'Approach
• Recherche ou modification globale rapides sur les données de bases de données volumineuses
• Automatisation de l'affichage et de la modification des données dans les vues
• Incorporation de contrôles personnalisés OLE (OCX) dans une application
Automatisation des tâches dans Approach
Si vous avez l'intention d'automatiser les tâches dans Approach, n'oubliez pas les autres outils qu'Approach met à votre disposition pour l'automatisation de tâches. Dans certains cas, il peut y avoir une méthode plus simple que d'écrire un script en vue d'accomplir une tâche particulière.
Par exemple, la création d'une recherche nommée permet de rechercher des enregistrements en fonction des conditions de recherche définies. Ainsi, une fois les conditions enregistrées, il est possible de répéter la recherche à tout moment. Dans ce cas, il est plus facile et plus efficace d'exécuter une recherche nommée que d'effectuer la même tâche à l'aide de LotusScript.
.Microsoft Visual Basic édition Applications.
Il a fallu attendre MS Office 8 (97) pour que le VBA remplace le langage WordBasic dans Word.
La différence principale entre Visual Basic Édition Applications et WordBasic réside dans le fait que si le langage WordBasic est constitué d'une liste simple d'environ 900 commandes, Visual Basic est lui constitué d'une hiérarchie d'objets, dont chacun dispose d'un jeu de méthodes et de propriétés donné (similaire aux instructions et aux fonctions dans WordBasic). Alors que la plupart des commandes WordBasic peuvent être exécutées à tout moment, Visual Basic ne rend accessible que les méthodes et les propriétés des objets qui sont disponibles à un moment donné.
Les objets constituent la composante fondamentale de Visual Basic : presque tout ce que vous faites sous Visual Basic implique la modification d'objets. Tous les éléments de Word (documents, paragraphes, champs, signets, etc.) peuvent être représentés par un objet dans Visual Basic. À la différence de WordBasic, certains objets ne sont accessibles qu'à partir d'autres objets.
Logique Visual Basic
Pour effectuer une tâche sous Visual Basic, vous devez déterminer l'objet approprié. Par exemple, si vous voulez appliquer une mise en forme de caractères disponible à partir de la boîte de dialogue Police, utilisez l'objet Font. Vous devez ensuite effectuer une recherche d'antécédents dans la hiérarchie d'objets de Word, à savoir remonter de l'objet Font jusqu'à l'objet Application, en passant par les objets successifs qui contiennent l'objet Font à modifier. Une fois que vous avez déterminé le chemin d'accès à votre objet (Selection.Font par exemple), utilisez l'Explorateur d'objets, l'aide ou des fonctionnalités telles que membres de liste automatique dans Visual Basic Editor pour déterminer quelles sont les propriétés et les méthodes pouvant être appliquées à l'objet.
WordBasic 7
Visual Basic Excel 7
BASIC
Pascal
C, C++
SQL
Un langage unifié pour la définition, l'interrogation, la modification et le contrôle de données dans une base de données relationnelle. Visual dBASE fournit l'accès aux tables SQL.
Rappel : le piratage est interdit.
Trouvez un bon vieux MS/DOS, avec ou sans Win 3 mais avec licence : il comprend QBASIC, que vous pourrez exécuter dans une fenêtre DOS. Certes, l’interface est exclusivement en mode texte, mais pour apprendre à manipuler les alternatives et les répétitions, cela est largement suffisant.
Sinon, vous pouvez facilement vous procurer un excellent outil d'apprentissage de la programmation, appelé AMS BASIC, soit dans une revue telle que PC Outils, soit sur http://www.filnet.fr/ams. La version simple est gratuite ; vous pouvez commander une version plus complète auprès de l’auteur :
Pierre GRANDOLINI
108, rue Damrémont - 75018 PARIS
06.13.11.54.46
Publicité gracieuse : il faut encourager les petits gars qui bossent ! Hélas, depuis fin avril 2002, la référence à AMS a disparu sur le site de filnet...
Regarder www.yabasic.de, tout en anglais (comme l'extension le laisse prévoir...)...
Pour JavaScript ou HTML, il suffit de disposer d'un navigateur sérieux, tel que Opéra ou Netscape (éventuellement Internet Explorer).
0.2.1.2.2Structure de principe d’un programme
Programmation procédurale (classique) :
Entrée de données
Traitements et calculs plus ou moins compliqués
Sortie des résultats, soit à l’écran soit à l’imprimante
Programmation événementielle :
Nous l’examinerons à l’intérieur d’une application, telle que dBASE, Paradox, Access ou même Word, ou Excel.
Tout est basé sur les clics, les fenêtres, etc. d’où :
On affiche divers éléments, et selon ce que fait l’utilisateur, qui clique gauche ou droit sur ceci ou cela, on déclenche tel ou tel traitement : il faut donc que le programme capte ces actions de l’utilisateur, c’est ça les évènements.
Par ailleurs, ces éléments sont affichés dans une fenêtre adéquate de l’application, qu’on appelle un formulaire.
Le principe est donc d’établir un formulaire, de disposer dessus les contrôles nécessaires, d’établir autant de programmes que nécessaire, et d’établir les liaisons entres les contrôles et les programmes.
0.2.1.2.3Délimitation du programme
Nous avons vu qu'un algorithme était délimité par les mots "début" et "fin". Une délimitation similaire existe dans les langages, mais pas dans tous. Nous reverrons ce point plus loin, à propos de notre exemple de programme "bonjour".
0.2.1.2.4Éléments d’un langage
Nous avons déjà vu pas mal de choses dans le polycop A, sur les données et sur les langages. Mais comme je suis un brave type, vraiment sympa dans le fond, je récapitule l’essentiel. Revoyez quand même les passages sur les données et sur les langages dans le A, car je ne répète pas tout ici.
Les éléments notés entre crochets ( [ et ] ) sont facultatifs.
Une commande par ligne ; astuces pour plusieurs commandes par ligne.
Si une commande est trop longue, continuation sur ligne suivante. Sous dBASE, le point virgule.
Commentaires à l’intérieur d’un programme, conseillés car si on modifie un programme quelques mois après, on ne se rappellera peut-être pas bien ce qu’on a voulu faire : mot clef REM (DOS), astérisque (dBASE), apostrophe (MS Visual Basic)
Rappel : l’étendue d’une commande est la partie de cette commande qui précise sur quels enregistrements d'un fichier elle va s’appliquer.
Pour dBASE :
- les choix de portée sont :
RECORD n l’enregistrement n° n ;
NEXT n les n enregistrements à partir de l’enregistrement courant compris ;
ALL tous les enregistrements du fichier ;
REST de l’enregistrement courant à la fin du fichier.
- nous verrons les clauses "pour" et "tant que" plus loin.
Voir le § correspondant dans le tome A.
Les valeurs "vrai" et "faux" (encore appelées "constantes logiques") sont en général dans les langages notées
.T. ou T ou true pour "vrai"
.F. ou F ou false pour "faux"
Note : attention à la présence des points (1 avant, 1 après, comme d’habitude sans espace les séparant de la lettre) ou à leur absence selon le langage utilisé.
Rappel : prenez l’habitude, pour éviter des ennuis en programmation, de séparer les mots par un espace, et de ne pas en mettre là où il n’en faut pas, notamment entre les points et la constante logique (ou l’opérateur, voir plus loin) qu’ils encadrent ! ! !
Sous dBASE: nous utiliserons pour nos exercices 4 types de constantes :
|
Type |
Code sous dBASE |
Écriture sous dBASE |
Exemple sous dBASE |
|
Numérique |
N |
Ordinaire, suite de chiffres |
3,1416 |
|
Caractère |
C |
Entre guillemets. Attention : " et non « et » |
‘’bonjour’’ |
|
Logique |
L |
.T. pour vrai, et .F. pour faux |
.T. |
|
Date |
D |
Entre accolades |
{14/07/1515} |
ATTENTION : en programmation, les guillemets doivent être des doubles apostrophes, et non des doubles chevrons.
Constante symbolique ********
Voir le § correspondant dans le tome A.
Type : cf. ci-dessus.
Déclaration… bla bla bla
Liste de données : suite de variables et de constantes séparées par une virgule.
Exemples :
A, B, C
SURF, PERIM
"La surface est : ", SURF, "Le périmètre est : ", PERIM
Attention :
a- problème de la marque décimale, par exemple dans 3,1416. Sous dBASE, l'instruction afficher 3,1416 provoquerait l'affichage de 3, et plus loin de 1416.
b- le rôle du point-virgule varie selon les langages. Vérifier sa signification avant de l'employer.
Une condition, en informatique, porte sur la comparaison de 2 variables, ou plus généralement de 2 expressions, arithmétiques ou alpha-numériques. On l’appelle également "test de relation", ou "test". La réponse à un test de condition est soit "vrai", si la condition est satisfaite, soit "faux", si elle ne l’est pas. On dit aussi que la condition est "vraie" ou "fausse".
La forme générale est :
Expression opérateur de comparaison expression
La comparaison proprement dite s’effectue au moyen des symboles bien connus, appelés "opérateurs de comparaison" ou "opérateurs de relation", ou encore "opérateurs relationnels" :
|
> supérieur à |
>= supérieur ou égal |
|
< inférieur à |
<= inférieur ou égal |
|
= égal à |
<> différent de |
La comparaison de valeurs alphanumériques en informatique est évidemment réalisée de façon à coïncider avec l’ordre alphabétique habituel.
Sous dBASE, représentation classique, sans problème.
Définition dBASE : "Condition : une expression dont l'évaluation renvoie Vrai (.T.) ou Faux (.F.)".
Exemples :
A < B
3 * ( A + 7 ) > 5 * B – C
5 >= C
dans les exemples ci-dessus, le résultat "vrai" ou "faux" dépend évidemment des valeurs des inconnues A, B et C.
Attention à quelques pièges, par exemple :
1- ne pas confondre "=" et "=" ! ! ! ( ? ? ?) Je traduis : ne pas confondre l’opérateur de relation "égal" et l’instruction d’affectation souvent notée par le même signe "égal" !
2- la proposition "5 > 7" existe, et est toujours fausse.
3- la proposition "Pierre > Jean" existe, et est toujours vraie (et ne venez pas me raconter, comme je l’ai entendu dire un jour : "On ne peut pas savoir, on n’a pas leurs notes !").
Opérateurs logiques classiques :
NON
ET
OU
(XOU, OU exclusif)
Les opérateurs logiques sont en général dans les langages notés :
.NOT. ou NOT pour "non" ;
.AND. ou AND pour "et" ;
.OR. ou OR pour "ou".
Note : attention à la présence des points (1 avant, 1 après, comme d’habitude sans espace les séparant de la lettre) ou à leur absence, selon le langage utilisé.
Attention aux règles de la logique ! Exemple du piège classique dans les énoncés d’examen : la négation (en français : le contraire) de "A > B" n’est pas "A < B", mais "A <= B" ! ! !
Rappel pour les expressions composées :
-Règles de priorité.
- Rôle des parenthèses.
- Révisez vos cours de terminale sur la logique, notamment sur l’utilisation des parenthèses dans les expressions logiques !
Exemples sous dBASE :
On a un fichier comprenant un code catégorie professionnelle dans un champ CATEG, le code pour les cadres étant C, l’âge dans un champ AGE, et la date de naissance dans un champ DATENAIS.
1- on veut dans une commande quelconque sélectionner les cadres de moins de 25 ans et de plus de 50. La condition est :
CATEG = "C" .AND. (AGE < 25 .OR. AGE > 50)
Attention ! Si j’avais voulu les cadres de 25 ans et moins et de 50 ans et plus, la condition aurait été :
CATEG = "C" .AND. (AGE <= 25 .OR. AGE >= 50)
2- on veut les cadres âgés de 35 à 50 ans :
CATEG = ‘’C’’ .AND. AGE >= 35 .AND. AGE <= 50
3- on veut les cadres en dehors de la fourchette ci-dessus :
CATEG = ‘’C’’ .AND. ( AGE < 35 .OR. AGE > 50 )
Notez l'emploi des parenthèses.
4- on veut les employés nés après 1975 :
CATEG = "E" .AND. DATENAIS > {31/12/1975}
5- on veut les employés nés en 1983 :
CATEG = "E" .AND. DATENAIS >= {01/01/1983} .AND. DATENAIS <= {31/12/1983}
Variante :
CATEG = "E" . .AND. DATENAIS > {31/12/1982} .AND. DATENAIS < {01/01/1984}
Test de signe
Test de type, ou de classe : permet de déterminer le type, ou la classe, de l’opérande testé : numérique, caractère, etc.
Test de touche du clavier
Test de fin de fichier
0.2.2Premier contact : programme BONJOUR
La plupart du temps, je me bornerai à donner des recettes immédiatement applicables, pour ne pas décourager ceux qui sont impatients de bidouiller : les explications pour les méthodiques et les curieux viendront dans les chapitres suivants.
Le premier contact concerne l’entrée de données au clavier, et la sortie de résultats sur écran ou sur imprimante : cela est bien la base de tout travail sur un ordinateur : on lui fournit des informations, et on veut connaître le résultat !
Nous verrons qu’il y a un aspect important de dialogue entre l’utilisateur et le programme : le programme guide l’utilisateur dans la frappe des données grâce à l’affichage de messages prévus par le programmeur lors de sa conception (du futur programme, pas du programmeur !).
Nous étudierons cela sur un exemple très simple et très original, celui d'un programme appelé "bonjour".
Le Pape souhaite "Bonne Année" au Monde dans une centaine de langues. Nous nous contenterons plus modestement de dire "Bonjour" dans quelques langages de programmation.
Nous allons ainsi démarrer tout doucettement par un programme qui demande le nom de l’utilisateur puis qui affiche "bonjour" suivi de ce nom. Ce programme bénéficiera dans les chapitres suivants de quelques perfectionnements selon la progression de nos connaissances.
Cet exemple nous permettra d'apprendre comment afficher des explications destinées à l’utilisateur, lire une ou des données tapées par cet utilisateur, récupérer cette ou ces données dans le programme pour pouvoir les traiter, et enfin afficher une ou des données du programme (qui dans les exercices suivants seront le(s) résultat(s) de calculs et de traitements plus ou moins longs et complexes), avec éventuellement des commentaires.
Nous suivrons la méthode de travail préconisée ci-dessus.
0.2.2.1Travail préparatoire sur papier
0.2.2.1.1Compréhension du problème
La compréhension du problème et la conception de la solution présentent peu de difficultés majeures…
Nous constatons qu’il nous suffit d’une seule variable, que nous appellerons A (nous aurions pu l’appeler "NOM", puisqu’elle va stocker le nom, mais cette appellation crée une confusion dans l’esprit du néophyte ; nous aurions pu tout aussi bien l’appeler "TRUC", ou n’importe comment, le résultat aurait été le même). Cependant, nous utiliserons volontairement une deuxième variable, que nous appellerons B, et nous copierons A dans B, pour bien montrer que la donnée tapée (ici le nom) a bien été captée par le programme, et peut donc faire l’objet d’un traitement quelconque, qui pourrait être plus ou moins long, avec d’autres entrées et des sorties, faisant appel à des sous-programmes, etc..
0.2.2.1.2Algorithme
Établissons ensuite l’algorithme. Sa complexité reste raisonnable :
variables A, B : caractères
début
afficher "Tapez votre nom "
lire A
B = A
afficher "Bonjour "
afficher B
fin
Nous verrons par la suite que cet innocent petit algorithme va subir moult transformations selon le langage utilisé...
0.2.2.1.3Déclaration des variables et délimitation du programme
Dans les cas simples comme celui-ci, dBASE crée lui-même les variables lors de leur initialisation, et il n’est pas nécessaire de les déclarer.
Les mots algorithmiques "début" et "fin" ne se codent pas en dBASE.
Le programme est délimité par
Sub Bonjour
Et
End Sub
Les variables sont déclarées par :
Dim A As String
Dim B As String
Ressemble à Lotus, mais attention aux subtiles différences :
Les variables sont déclarées par la commande "dim", et on indique le type, mais à l’intérieur du programme :
Dim A, B As String
Le programme doit commencer par :
Sub nomduprogramme()
Et se terminer par :
End Sub
Nous verrons plus loin, lorsque j’expliquerai comment on enregistre ce programme, que nous pouvons faire autrement. Pour l’instant, cela nous donnera finalement :
Sub bonjour()
Dim A, B As String
Corps du programme
End Sub
Les variables ne sont pas déclarées. Mais on peut ajouter le symbole "$" au nom d’une variable caractère.
Le programme doit commencer par :
Sub MAIN
Et se terminer par :
End Sub
Comme sous Access, les variables sont déclarées par la commande "dim", et on indique le type, mais à l’intérieur du programme :
Dim A, B As String
Le programme doit commencer par :
Sub Bonjour()
Et se terminer par :
End Sub
Ce qui nous donnera finalement :
Sub Bonjour()
Dim A, B As String
Corps du programme
End Sub
On peut intégrer un script JavaScript dans une page HTML. Le code du script doit être placé à l'intérieur des balises <script> et </script>, et le langage doit être spécifié avec l'attribut language, ce qui nous donne au début du programme :
<html>
<script language="javascript">
et à la fin du programme :
</script>
</html>
Il n’est pas nécessaire de déclarer les variables, elles seront créées lors de leur initialisation.
Le HTML n'est absolument pas fait pour ce que nous voulons faire ici. Nous n'en ferons donc qu'une toute petite partie, par simple curiosité !
Le "programme", qui n'est pas du tout un programme, mais un "document", doit commencer par la balise :
<html>
et se terminer par la balise :
</html>
0.2.2.1.4Lecture de données tapées au clavier, avec affichage d’un message
Rappel : l’opération baptisée "lecture" permet au programme de "récupérer" en mémoire centrale ce que l’utilisateur frappe au clavier.
Comme nous l'avons vu plus haut, par exemple dans l'algorithme du rectangle, le programmeur prévoit presque toujours d'afficher des messages afin de guider l'utilisateur qui va plus tard se servir du programme pour effectuer son travail. En effet, cet utilisateur ne sait pas comment a été conçu et réalisé le programme, et sans cela ne saurait pas ce qu'il doit frapper comme données à tel ou tel moment.
C'est pourquoi on trouve dans tous les programmes des séquences du genre :
Afficher un message réclamant telle donnée
Lire la donnée frappée au clavier
Revoyez au besoin mon exemple du rectangle.
On peut très bien coder cela en 2 lignes, mais les langages de programmation permettent presque tous de synthétiser ces 2 lignes en une seule, sous la forme :
Lire "message " , donnée
Noter l’espace entre le dernier caractère du message et le guillemet fermant, sinon, plus tard à l’exécution du programme, on tapera la donnée attachée à ce dernier caractère affiché, ce qui n’est pas catastrophique, mais n’est pas esthétique.
Attention au fonctionnement ! J'insiste bien sur le fait que cette ligne unique déclenche DEUX opérations : il ne s'agit en aucun cas de lire un message et une donnée tapés au clavier, mais d'AFFICHER à l'écran le message prévu, PUIS de LIRE la donnée tapée au clavier par l'utilisateur en réponse au message.
Reprenons mon exemple du rectangle. La séquence de 4 lignes :
Afficher message : "Tapez la largeur :"
Lire LARG
Afficher message : "Tapez la longueur :"
Lire LONG
peut s'écrire en 2 lignes :
Lire "Tapez la largeur :" , LARG
Lire "Tapez la longueur :" , LONG
Le résultat sera exactement le même.
Les langages différencient la lecture des données numériques et des données caractères, mais hélas pas tous de la même façon.
DBASE possède 2 instructions de lecture, selon qu'il s'agit de lire des données numériques ou caractères.
- lecture d’une donnée numérique :
INPUT [‘’message’’] TO variablemémoirenumérique
Exemple :
INPUT ‘’Tapez votre âge : ‘’ TO A
N.B. attention la diffrence avec le INPUT du BASIC, voir plus loin.
- lecture d’une donnée caractères :
ACCEPT [‘’message’’] TO variablemémoirecaractère
Exemple :
ACCEPT ‘’Tapez votre nom : ‘’ TO N
Dans notre exercice "bonjour", cela donne :
ACCEPT ‘’Tapez votre nom : ‘’ TO A
N.B. pour avoir constaté à maintes reprises en TD que l’évidence suivante n’était pas évidente pour tout le monde, j’insiste : ne confondez pas le A du programme bonjour, qui contient le nom, et le A de l’exemple de lecture de l’âge, qui contient l’âge ! Il s’agit de 2 exercices et de 2 programmes différents, il n’y a donc aucun risque de confusion de la part de dBASE ! Les noms de variables sont relatifs au programme dans lequel ils figurent, ils n’ont aucune valeur universelle !
L’affaire est malheureusement moins simple que ci-dessus… Il est incompréhensible qu’il n’existe pas de boîte du genre "inputbox", alors que "msgbox" existe, mais c’est comme ça !
Il n’y a pas à proprement parler de "programme", au sens ancien du terme. Comme je l’ai déjà dit, on est contraint pour l’acquisition de données de passer par la création d’un formulaire comportant un champ de saisie, appelé "SAISIE1", dans lequel on tapera le nom, et un bouton pour continuer lorsqu’on a tapé le nom. Nous devrons étudier la suite de notre "programme" pour que le fait de cliquer sur ce bouton provoque la fermeture du formulaire de saisie, et l’affichage du mot Bonjour suivi du nom. Pour l’instant, il faut capter la frappe du nom, c’est à dire la valeur du champ "SAISIE1" :
Public A
A = this.SAISIE1.value
Nous verrons plus tard le pourquoi de la ligne "Public A".
A = Inputbox$("Tapez votre nom :")
A = InputBox("Tapez votre nom : ")
A$ = InputBox$("Tapez votre nom : ")
A = InputBox("Tapez votre nom : ")
Input "Tapez votre nom :", A
Attention la diffrence avec le INPUT de dBASE : c'est le mme mot INPUT, le fonctionnement est exactement le mme, mais aprs le message il y a une virgule au lieu du mot TO.
var A = prompt("Tapez votre nom : ","Votre nom")
Le texte "Votre nom" apparaîtra dans le rectangle de saisie.
0.2.2.1.5Traitements simples
En algorithmie, l'affectation est notée par un flèche arrière :
←
Exemple :
A ← B
Qu'on peut prononcer : A reçoit la valeur de B.
Attention au fonctionnement : cette instruction signifie très exactement ceci : prendre la valeur contenue dans la zone mémoire appelée A et la copier dans la zone mémoire appelée B.
Dans les langages dont je parle ici, l'affectation est toujours note par le signe gal.
Exemple :
A = B
N.B. ne pas confondre "=" et "=" ! ! ! ( ? ? ?) Je traduis : ne pas confondre l'opérateur de relation "égal" et l'instruction d'affectation, bien qu'elle soit notée par le même signe "égal" !
Oprateurs classiques, dj vus.
Exemple (très original) :
Le début du programme a calculé le total hors taxe d'une facture, et stocké le résultat dans une variable appelée TOTHT (pour "total hors taxe", mais vous auriez pu choisir le nom MONTHT, pour "montant hors taxe", ou toute autre désignation qui vous ferait plaisir). On veut multiplier ce total hors taxe par le taux de TVA, soit actuellement 19,6 %, pour obtenir le montant TTC de la facture, et le stocker dans une variable que l'on veut appeler TOTTC (pour "total toutes taxes comprises", mais vous auriez pu choisir le nom MONTTTC, pour "montant toutes taxes comprises", ou toute autre appellation).
La ligne de programme est (dans quasiment tous les langages) :
TOTTTC = TOTHT * 1,196
N.B.
1- dans l'algorithme, il faudrait évidemment écrire : TOTTTC ← TOTHT * 1,196
2- on peut aussi écrire TOTTTC = TOTHT + TOTHT * 0,196, ou TOTTTC = TOTHT + TOTHT * 19,6 / 100. Pourquoi faire simple, alors qu'il est si facile de faire compliqu ?
3- selon la francisation plus ou moins complète du langage, vous serez peut-être obligé d'écrire 1.196, avec un point décimal au lieu d'une virgule. C'est un piège classique.
0.2.2.1.6Sortie de résultats, avec un message
On rencontre ici une situation similaire à celle que nous avons vue pour la lecture, mais évidemment en sens inverse : on fournit à l'utilisateur du programme des explications sur les résultats qu'on va afficher sous ses yeux émerveillés.
La forme générale est :
Afficher liste de messages et de données
Le fonctionnement est simple : cette commande affiche les messages et les données indiqués.
Reprenons toujours l'exemple du rectangle. La séquence de 4 lignes :
Afficher message : "La superficie est :"
Afficher SUPERF
Afficher message : "Le périmètre est :"
Afficher PERIM
peut s'écrire en une seule ligne :
Afficher "La superficie est : " , SUPERF , "Le périmètre est : " , PERIM
Notez toujours l'espace avant le guillemet fermant, pour la raison déjà expliquée dans le § sur la lecture.
L'affichage s'effectue, comme son nom le laisse supposer, sur écran. Cependant, on a souvent besoin de sortir les résultats sur papier, c'est à dire d'utiliser l'imprimante. J'indiquerai donc pour chaque langage, après les commandes d'affichage, les commandes d'impression.
? liste de textes et de variables
La sortie s’affiche à l’écran, sauf si elle est redirigée vers l’imprimante, par une commande que nous verrons plus loin.
Exemple :
? ‘’Votre nom est ‘’, N, ‘’ et vous êtes âgé de ‘’, A, ‘’ ans.’’
Dans notre exercice "bonjour", cela donne :
? ‘’Bonjour ‘’, B
Il ne faudra évidemment pas oublier l’affectation AVANT l’écriture :
B =A
Sinon ce pauvre dBASE ne pourra pas savoir ce qu’est B, c’est évident !
Impression : voir dans l’aide l’emploi de la commande :
SET PRINTER
L'affichage s'effectue par la commande msgbox. Voir détails dans l'aide.
On commencera par fermer le formulaire de saisie :
close form
Puis, comme ci-dessus, il ne faudra pas oublier l’affectation suivie de l’affichage, d’où :
B = A
? msgbox("Bonjour" + B)
Remarquez que l’opérateur de concaténation de chaînes se note par le signe "+".
B = A
Msgbox "Bonjour " + B
B = A
MsgBox "Bonjour " & B
En Visual Basic, l’opérateur de concaténation se note par le signe "&".
B$ = A$
MsgBox "Bonjour " + B$
Attention : en WordBasic, l’opérateur de concaténation se note par le signe "+". On note une fois de plus la parfaite harmonie au sein de la "suite" MS Office 7…
B = A
MsgBox ("Bonjour " & B)
Attention à l’opérateur de concaténation qui est celui de VBA et non de Word 7.
B = A
Print "Bonjour", B
B = A
alert ("Bonjour " + B )
Il existe une balise qui permet d'afficher un texte :
<cite>Permet d'afficher un texte (une citation)</cite>
Ici, on peut donc écire la ligne :
<cite>Bonjour</cite>
0.2.2.1.7Récapitulatif du programme au brouillon
Récapitulons ce que nous avons vu pour la rédaction du programme :
a- pour le codage ligne à ligne de l’algorithme :
|
Algorithme |
Programme dBASE |
|
Variables A, B : caractères |
Ne se déclarent pas en dBASE |
|
Début |
Ne se code pas en dBASE |
|
afficher "Tapez votre nom : " lire A |
2 lignes codées en 1 seule : Accept "Tapez votre nom :" to A |
|
B = A |
B = A |
|
afficher "Bonjour " afficher B |
2 lignes codées en 1 seule : ? "Bonjour " , B |
|
Fin |
Ne se code pas en dBASE |
b- d’où le programme complet au brouillon :
Accept "Tapez votre nom : " to A
B = A
? ‘’Bonjour ‘’, B
En codant ligne à ligne comme expliqué ci-dessus pour dBASE, on obtient le programme complet qui se présente ainsi :
Sub Bonjour
Dim A As String
Dim B As String
A = Inputbox$("Tapez votre nom :")
B = A
Msgbox "Bonjour " + B
End Sub
En codant ligne à ligne comme expliqué ci-dessus pour dBASE, on obtient la macro complète qui se présente ainsi :
Sub MAIN
A$ = InputBox$("Tapez votre nom : ")
B$ = A$
MsgBox "Bonjour " + B$
End Sub
En codant ligne à ligne comme expliqué ci-dessus pour dBASE, on obtient la macro complète qui se présente ainsi :
Sub Bonjour()
Dim A, B As String
A = InputBox("Tapez votre nom : ")
B = A
MsgBox ("Bonjour " & B)
End Sub
En codant ligne à ligne comme expliqué ci-dessus pour dBASE, on obtient le programme complet qui se présente ainsi :
Sub bonjour()
Dim A, B As String
A = InputBox("Tapez votre nom : ")
B = A
MsgBox "Bonjour " & B
End Sub
<HTML>
<script language="javascript">
var A = prompt("Tapez votre nom : ","Votre nom")
B = A
alert ("Bonjour " + B )
</script>
</HTML>
<html>
<cite>Bonjour</cite>
</html>
0.2.2.2Travail sur l'ordinateur
0.2.2.2.1Lancement du logiciel
**************
0.2.2.2.2Frappe et stockage du programme
J’entends par "frappe du programme", la frappe au clavier des instructions précédemment écrites au brouillon, et par "stockage du programme" sa conservation dans le micro, sur le disque dur ou sur une disquette, l’ensemble pouvant être désigné sous le terme d’enregistrement de ce programme.
Certaines applications exigent que les programmes, ou les scripts, soient "hébergés" dans un document qu’elles créent. D’autres, comme dBASE, acceptent que les programmes soient stockés dans un fichier texte, doté d’une extension spécifique (et non .txt).
On a donc plusieurs possibilités pour créer le source : soit frapper sous un texteur quelconque et enregistrer avec l’extension voulue par le logiciel qu’on va employer, soit copier-coller à partir du texteur dans l’application, soit frapper sous l’éditeur du logiciel, soit utiliser l’outil de génération de code de l’application.
Attention, si vous employez un texteur ou si vous rusez avec des copier-coller à partir d'un texte de cours quelconque (pas le mien, car mon cours n'est pas quelconque !), à quelques pièges. Par exemple, dans certains cas que nous étudierons plus loin, on utilise des lettres encadrées de guillemets, du genre "A". Les texteurs habituellement remplacent les guillemets double apostrophe par des guillemets doubles chevrons avec un espace insécable, ce qui vous donne la séquence suivante : guillemets doubles chevrons ouvrants, espace, A, espace, guillemets doubles chevrons fermants. Et le programme ne fonctionne pas ! Il faut se ramener, avec des Remplacer, à la séquence guillemets double apostrophe, A, guillemets double apostrophe. Evidemment, dans le présent document, j'ai désactivé l'écriture des chevrons.
dBASE interface texte
L’utilisation de dBASE en mode commande directe fournit une excellente transition avec la programmation en interface texte.
Pour employer dBASE en mode commande, l’outil essentiel est bien entendu la fenêtre de commande. C’est, comme son nom l’indique, la fenêtre dans laquelle l’utilisateur frappe ses lignes de commande.
En principe, elle est déjà ouverte ; si vous l’avez réduite (puisqu’on ne peut pas la fermer complètement et la faire disparaître), vous la restaurez soit directement sur sa réduction, soit en cliquant sur l’icône figurant une lampe d’Aladin (un seul "d" en français…) en principe la 2ème en partant de la droite dans la barre d’outils, soit par le menu fenêtre. Vous la maximisez, pour y voir clair.
Elle présente 2 parties, l’une (en haut) pour la frappe des commandes, l’autre (en bas) pour l’affichage des résultats (si personne n’a bricolé les paramètres de présentation de cette fenêtre !).
Il faut bien insister sur ce point : quand on emploie dBASE en mode commande, c’est dans cette fenêtre de commande que TOUT se passe, aussi bien la frappe des commandes que l’affichage des résultats. On frappe une commande tout bêtement, telle qu’elle est expliquée dans le cours, sans se poser la moindre question métaphysique, dans la partie de la fenêtre destinée à la frappe, et on admire instantanément le résultat dans la partie destinée à cet effet.
Conseils : 1- maximiser ou restaurer la fenêtre de commande, selon vos besoins, mais ne JAMAIS la réduire en bas du bureau de dBASE, la laisser entr’ouverte (dans son état "normal", c'est à dire par défaut) lorsque vous fermez dBASE ; vous éviterez ainsi des ennuis quand plus tard vous lancerez l’exécution de certains programmes.
2- ne pas mélanger le mode commande et le mode fenêtre que vous connaissez déjà ; cela marche dans certains cas, mais pas dans tous, et vous aurez des surprises ; donc éviter ; par exemple si vous avez ouvert une table en mode fenêtre (interface graphique), ne tentez pas de la lister dans la fenêtre de commande.
Rappels : 1- cette fenêtre de commande peut subir toutes les manipulations habituelles des fenêtres Windows, par exemple le dimensionnement et le déplacement.
2- pour dBASE 5 et 5.5, utiliser uniquement des noms DOS pour les répertoires, les fichiers, les tables, les champs, les programmes, etc..
3- vérifier qu'on est dans le bon répertoire par défaut (en TD, le répertoire EXODB sur la disquette).
Sous dBASE, on invoque l’éditeur de programme par la commande :
MODIFY COMMAND nomduprogrammequ’onveutcréer
On voit alors s’ouvrir la fenêtre de l’éditeur, et on tape les instructions composant le programme, en lignes successives.
La fenêtre de cet éditeur a pour titre le nom qu'on vient de donner au futur programme. Si on a tapé MODIFY COMMAND sans fournir de nom de programme, la barre de titre de l'éditeur indique "sans titre", et il faudra donner le nom qu'on veut lorsqu'on fera "enregistrer sous", exactement comme sous Word ou sous Excel.
Exemple :
On veut créer le programme TRUC.PRG. On tape dans la fenêtre de commande :
modify command truc
N.B. 1 si on travaille sous l’éditeur de dBASE, il est inutile de taper l’extension, dBASE s’en charge tout seul ; par contre, si on travaille sous un texteur, ou sous le bloc-notes de Win, il est impératif de bien donner l’extension .prg.
Rappel 1 : il est indifférent de frapper les commandes en majuscules ou en minuscules.
Lorsque vous avez fini la frappe, il faut évidemment sauvegarder ce magnifique effort sur votre disquette si vous êtes en T.D., ou sur le disque dur si vous êtes sur votre ordinateur personnel, puis au besoin fermer la fenêtre de l’éditeur. Comment faire pour sauvegarder ? Relisez ce que j'ai écrit quelques lignes plus haut, révisez vos cours Word et Excel, et tentez de faire fonctionner le petit pois qui vous sert de cerveau !
N.B. 2 vous pouvez à ce moment vérifier que l’enregistrement de votre programme s’est correctement déroulé en lançant l’explorateur et en regardant dans le répertoire voulu si vous avez bien à l’endroit prévu un fichier "truc.prg".
Rappels 2 :
- ne confondez pas l’explorateur de Windows et le navigateur de dBASE !
- inutile de fermer dBASE pour lancer l’explorateur, et inutile également de fermer l’explorateur après usage pour ré-afficher dBASE ! Ce pauvre Windows ne sait pas faire grand’chose, c‘est vrai, mais faire tourner 2 applications simples en même temps, il y arrive quand même à peu près !
Dans notre exercice "Bonjour", en suivant la méthode de travail préconisée ci-dessus, cela donne pour l’enregistrement :
a- taper la commande :
modify command bonjour
b- taper le texte du programme dans la fenêtre de l’éditeur de programme, en lisant son brouillon, et sans oublier une ligne... Eh oui ! J'en ai vu en TD oublier une ligne... Il y en a quand même trois à copier, c'est dur, c'est à la limite des possibilités humaines... Authentique, hélas...
c- sauvegarder ce monument de la pensée humaine, et fermer la fenêtre de l’éditeur de programme.
Conseil : bien veiller à fermer l'éditeur de programme, sinon vous rencontrerez un inconvénient similaire à celui signalé plus bas lors de la mise au point : vous aurez plusieurs fenêtres ouvertes les unes sur les autres, mais vous n'en voyez qu'une, et vous taperez des lignes de programme tantôt dans l'une, tantôt dans l'autre, et vous piaillerez que votre programme ne va pas comme vous voulez…
dBASE interface fenêtre
Je rappelle qu’il n’y a pas à proprement parler de "programme", au sens ancien du terme. On doit créer un formulaire, qui abritera divers petits morceaux.
Fichier | Nouveau | Formulaire
Dans la fenêtre Nouveau formulaire, choisir Concepteur ;
On voit apparaître plusieurs petites fenêtres : Concepteur de formulaire, Contrôles, Inspecteur, et Palette des champs, qui ne nous intéressera pas. Si certaines ne sont pas visibles, cliquer sur le menu Fenêtre, ou cliquer droit.
Attention : ne pas cliquer n'importe où n'importe comment, car ces fenêtres auxiliaires sont contextuelles, c'est-à-dire relatives à l'objet sélectionné. Par exemple si vous êtes en train de travailler sur un bouton, l'inspecteur sera celui de ce bouton, mais si vous avez cliqué par inadvertance ailleurs, l'inspecteur changera de contenu, vous ne verrez plus les mêmes éléments, et vous ne trouverez pas ce que vous cherchez.
Dans la fenêtre Contrôles, prendre la zone de texte (le A majuscule), la glisser sur la grille du Concepteur, la positionner et la dimensionner en hauteur et largeur, car nous allons y écrire le texte "Tapez votre nom" ; cliquer, si besoin est, sur l’onglet Propriétés de l’Inspecteur, puis sur la propriété Text ; Texte1 apparaît sur fond de couleur ; le remplacer par notre texte, c’est à dire "Tapez votre nom", sans les guillemets ; ce libellé figure maintenant sur le Concepteur, c’est celui qui sera visible sur le formulaire final.
Rappel : si vous laissez votre pointeur, tout au moins celui de votre souris, quelques secondes sur un symbole, une bulle d’aide vous dit ce que c’est.
Prendre le contrôle de saisie, le glisser sur le Concepteur, le positionner et le dimensionner ; c’est là que lors de l’exécution on tapera le nom, à la place de "Saisie1".
Prendre le bouton sur les Contrôles, le glisser sur le Concepteur, le positionner et le dimensionner ; modifier la propriété Text dans l’Inspecteur, pour écrire "Continuer" (sans les guillemets !) ; pendant qu’on s’occupe de ce bouton, profitons-en pour introduire la portion correspondante de notre minuscule programme ; cliquer sur l’onglet Évènement, puis sur l’évènement "OnClick" ; il apparaît un outil à droite d’un rectangle blanc ; cliquer sur cet outil ; dans la fenêtre Éditeur de procédure, on voit une ligne :
Procedure BOUTON1_OnClick
En dessous de cette ligne, taper les commandes vues plus haut :
close form
B = A
? msgbox("Bonjour " + B)
fermer la fenêtre de l’Éditeur de procédure.
Enfin, la capture de la saisie doit s’effectuer au niveau du formulaire ; pour cela, cliquer sur la grille du Concepteur, évidemment en dehors des 3 zones que nous venons de créer ! L’inspecteur devient alors celui du formulaire ; cliquer sur l’onglet Évènement, puis sur l’événement "OnChange" ; cliquer sur l’outil ; dans la fenêtre Éditeur de procédure, on voit une ligne :
Procedure Form_OnChange
En dessous de cette ligne, taper l’autre portion de notre "programme", c’est à dire la commande de capture de la saisie :
Public A
A = this.SAISIE1.value
Fermer l’Éditeur.
Sauvegarder le tout, de façon classique, par Fichier | Enregistrer sous, en tant que formulaire, avec l’extension .wfm. Bien qu’on ne puisse pas confondre le programme dBASE précédent en mode texte, appelé "bonjour.prg", et celui-ci, du fait que son extension est ".wfm" et non ".prg", il est prudent d’appeler ce nouveau "programme" (qui n’est pas vraiment un programme, mais plutôt un formulaire contenant un programme) "bonjourf", ce qui donnera une fois enregistré "bonjourf.wfm". Fermer toutes les fenêtres dont on n'a plus besoin et qui auraient pu rester ouvertes.
N.B. vous avez pu trouver bizarre ci-dessus qu’on s’occupe d’abord de la fin avant de s’occuper du début : c’est ça la programmation évènementielle ! Remarquez que, conceptuellement, le travail à effectuer est exactement le même que dans le cas de la programmation procédurale (heureusement !) : saisie du nom tapé au clavier, transfert dans une autre variable, sortie du résultat ; mais, physiquement, la disposition des morceaux est complètement différente. Cela surprend, mais on finit par s'y habituer.
Paradox
Lotus
Lancer Approach, ouvrir une base quelconque, éventuellement vide.
Edition | afficher éditeur de scripts
Dans la fenêtre Object, laisser Globals ; dans la fenêtre script, dérouler et cliquer sur initialize.
Dans la fenêtre en dessous, remplacer initialize pas Bonjour, et taper le programme ; ne pas fermer l’éditeur de scripts.
Access
Vous êtes en possession du programme complet, tel que vu plus haut.
Et maintenant, accrochez-vous au pinceau, parce que c’est pas de la tarte (d’ailleurs sous Access rien n’est de la tarte !), et c’est là que vous allez admirer la simplicité de dBASE ! Prenez une tablette de chocolat, et allons-y (note : je donne le processus pour Access 9, si j’ai le courage, j’indiquerai plus tard les différences pour les autres versions Access 10, 8 et 7). Rappel quand même : revoyez dans le chapitre précédent la philosophie de l’opération, pour ne pas perdre le fil des manipulations : on crée un formulaire avec des contrôles, on enregistre dans ce formulaire les programmes voulus, et on crée les liens entre les contrôles et les programmes.
a- lancer Access (par la fenêtre si possible !) ; choisir "nouvelle base" puis OK ;
b- indiquez comme chemin d’enregistrement votre répertoire "exos Access" ; nom du fichier : "essais Access" ; créer ;
c- vous voyez apparaître une boîte avec une colonne à gauche "Objets" ; sélectionnez "formulaires" (cliquez 1 seule fois) ; 2-cliquez sur "créer un formulaire en mode création" dans la sous-fenêtre de droite (ou cliquez sur "nouveau" dans la barre d’outils de la boîte, puis mode création | OK, sans choisir de table) ;
d- vous obtenez une nouvelle sous-fenêtre dont le titre est "formulaire1 : formulaire", présentant un quadrillage gris-bleuté très chicos ; dans la boîte à outils (qui devrait être dans le coin inférieur gauche, si personne n’a bricolé votre Access ; si vous ne la voyez pas, cliquez sur Affichage | Boîte à outils), cliquez sur le symbole "bouton de commande" ; promenez votre pointeur sur le quadrillage, il prend la forme d’un signe "+" avec un petit rectangle blanc en bas à droite ; lorsque vous avez trouvé l’endroit idéal, appuyez sur le bouton gauche, gardez appuyé et dessinez un rectangle ; lorsque vous le trouvez suffisamment beau, lâchez le bouton ; annulez l’assistant "bouton de commande" qui apparaît ; vous voyez votre rectangle avec la mention "commande0" (sans espace entre le e et le 0) ; noircissez commande0 pour le remplacer par un autre texte, par exemple "programme bonjour" ;
e- cliquez sur affichage ; avant de cliquer sur code, observez bien le symbole à gauche (points rouge, vert, jaune avec une étoile jaune) et repérez le dans la barre d’outils : la prochaine fois, vous passerez par là ;
f- une fenêtre Visual Basic s’ouvre ; ne vous occupez pas du texte "Option Compare Database" dans la sous-fenêtre principale ; déroulez le rectangle "général", au dessus à gauche ; observez les rubriques : général, commande0, détail, form ; idem pour le rectangle "déclarations" à droite, qui ne contient que déclarations ;
g- cliquez dans la sous-fenêtre principale en dessous de "Option Compare Database", et tapez votre programme, tel qu'écrit plus haut ; vous constatez que "bonjour" remplace "déclarations" dans le rectangle de droite ;
h- il faut maintenant créer le lien entre le bouton et le programme, pour que quand l’utilisateur cliquera sur ce bouton il déclenche notre programme bonjour ; dérouler général, cliquer sur commande0 ; on voit apparaître :
Private Sub Commande0_Click()
End Sub
i- il suffit de taper entre ces 2 lignes "bonjour", sans les () et sans ""; on obtient donc :
Private Sub Commande0_Click()
bonjour
End Sub
j- fermer la fenêtre de Visual Basic (attention, il ne suffit pas de fermer la fenêtre dans laquelle on vient de taper, il faut bien fermer la fenêtre de Visual Basic) ; fermer le formulaire1 ; Access demande si on veut enregistrer les modifications ; je vous laisse deviner ce qu’il faut répondre ! Il réclame alors le nom ; donnez par exemple "bonjour" (à taper sans les guillemets) ;
k- tout se ferme, et on revient à la fenêtre de la base de données, mais on a maintenant un formulaire "bonjour".
Macro WordBasic 7
Enregistrement :
- Outils | Macro (sans "s") | Macros (avec "s")
- taper le nom de la macro, puis Créer
- taper le texte de la macro (fermer les fenêtres à gauche, pour avoir un plan d’écriture)
- tout fermer
La macro est maintenant stockée par Word 7 sous le nom indiqué, quelque part dans ses dossiers personnels.
Macro Excel 7
Enregistrement :
- Outils | Macro (sans "s") | Macros (avec "s")
- taper le nom de la macro, puis Créer
- on a une fenêtre Visual Basic
- taper le texte de la macro
- fermer la fenêtre Visual Basic
La macro est maintenant stockée par Excel 7 sous le nom indiqué, quelque part dans ses dossiers personnels.
Macro améliorée bonjour2 :
Sub Bonjour2()
Dim A, B As String
A = InputBox("Tapez votre nom : ", "Boîte de saisie du nom", "Votre nom")
B = A
texte = "Bonjour " & B
bouton = vbOKOnly
titre = "Boîte d'affichage du nom"
réponse = MsgBox(texte, bouton, titre)
End Sub
JavaScript
Le plus simple est d'utiliser ce bon vieux bloc-notes, ou tout éditeur ou texteur, mais à condition d'enregistrer en format texte, et de renommer ensuite l'extension en .html.
Il suffit de taper le programme complet tel que vu plus haut, en l'appelant bonjourjs.html.
HTML
Idem JavaScript : on utilise le bloc-notes, ou tout éditeur ou texteur, on tape les 3 lignes vues plus haut, on enregistre en format texte en appelant le document bonjourhtml, et on renomme ensuite l'extension en .html, ce qui donne bonjourhtml.html, à ne pas confondre avec bonjourjs.html.
0.2.2.2.3Exécution et mise au point
dBASE interface texte
On peut lancer l’exécution d’un programme de plusieurs façons :
- dans la fenêtre de commande, en tapant la commande :
DO nomduprogramme
Note : l’extension .prg n’est pas obligatoire dans le nom du programme.
- par le navigateur, type de fichiers "programmes", et 2-cliquer sur celui qu’on veut lancer ;
- dans l’explorateur, de façon classique : 2-cliquer sur le nom du programme, comme pour n’importe quelle application ; mais attention, cela ouvre dBASE ! Rappel : s’il est déjà ouvert par ailleurs, on se retrouve avec 2 dBASE tournant en parallèle, et cela ne donne rien de bien bon ; bien surveiller cela dans la barre des tâches ; donc si vous voulez expérimenter cette méthode, le mieux est de prendre bien soin de fermer dBASE avant.
Dans notre exercice "bonjour", cela donne, si on opère dans la fenêtre de commande :
Do bonjour
On voit avec un petit cri de ravissement apparaître dans la partie inférieure de la fenêtre de commande le texte "Tapez votre nom :", vous tapez votre nom, et bla bla bla………
Évidemment, vous ne verrez cela que si vous avez suivi mes conseils et n’avez pas réduit la fenêtre de commande !
Pour les éventuelles modifications et corrections du programme, on rappelle l’éditeur par la même commande modify :
Modify command bonjour
Et on tape les modifs comme si on était sous un texteur quelconque.
Rappel : attention à ne pas ouvrir plusieurs fenêtres de l'éditeur ; voir plus haut ce que j'ai déjà dit à propos de ce phénomène.
dBASE interface fenêtre
Là encore, plusieurs façons de lancer l’exécution :
- dans la fenêtre de commande de dBASE, en tapant :
do bonjourf.wfm
l’extension .wfm est obligatoire.
- par le navigateur de dBASE, en sélectionnant le type de fichier "formulaire" ;
- directement sous Win, par l’explorateur, en 2-cliquant sur bonjourf.wfm ;
Bien évidemment, comme déjà dit dans le § précédent, prenez bien soin de ne pas ouvrir plusieurs dBASE !
Pour les éventuelles modifications et corrections, dans le Navigateur (type formulaire) cliquer droit sur le formulaire à modifier, en l’occurrence bonjourf.wfm, et cliquer sur "Concevoir le formulaire".
Paradox
Lotus
Dans les menus de l’éditeur de scripts, cliquer sur Script | Run current sub
Pour les corrections, dans l’éditeur de scripts.
Access
Pour exécuter notre formulaire "bonjour", il suffit de 2-cliquer dessus. Nous voyons la fenêtre de notre formulaire, mais il est maintenant en mode exécution, et non plus en mode création ; on clique sur le bouton bonjour, et notre programme s’exécute (enfin !) ; fermer ensuite bonjour.
Pour les corrections : le sélectionner (clic simple, sinon on le lance !) ; puis Affichage | Code, ou icône Code : on retrouve la fenêtre Visual Basic.
Macro WordBasic 7
Outils | Macro | Macros, choisir la macro dans la liste, puis Exécuter.
Pour les modifications et corrections : idem, mais Modifier au lieu d’Exécuter.
Macro Excel 7
Outils | Macro | Macros, choisir la macro dans la liste, puis Exécuter.
Pour les modifications et corrections : idem, mais Modifier au lieu d’Exécuter.
JavaScript
Il suffit de lancer un navigateur sérieux, tel que (dans une version récente, pour éviter toute difficulté de compatibilité, et ne pas confondre avec le navigateur de dBASE !), puis, très classiquement, de faire menu fichier | commande ouvrir, d'aller chercher dans la boîte d'ouverture votre programme bonjourjs.html, et de l'ouvrir, c'est-à-dire de lancer son exécution (le programme sera interprété et exécuté par le navigateur).
Ceux qui n'ont pas choisi la qualité de fonctionnement avec Opéra ou Netscape, ou qui aiment la difficulté et ne craignent pas de planter leur bécane, peuvent tenter l'aventure avec Internet Explorer.
HTML
Idem JavaScript.
0.2.2.3Application : programme RECTANGLE
Rectangle. Programmez l’algorithme génial vu au début, et exécutez le programme, en suivant exactement le même plan de travail que pour le programme bonjour.
dBASE interface texte
Appeler ce programme RECTGL, pour les raisons expliquées plus haut.
dBASE interface fenêtre
Paradox
Lotus
Access
WordBasic 7
Excel 7
Exercices
Sphère, intersection de 2 droites, équ du 1er degré ? ? ?
Solde fiche de compte d'un locataire : lignes débit, lignes crédit, sortir le solde
Faites la même chose que pour le rectangle : connaissant le rayon, calculez l'aire et la longueur de la circonférence et l’aire. Profitez-en pour chercher dans chaque langage la constante "pi" ! Appelez ce programme CERCLE.
0.2.3Alternatives
0.2.3.1L’alternative simple
0.2.3.1.1Principe
Lorsqu’on pose une condition, on se trouve, comme nous venons de le dire ci-dessus, devant 2 possibilités. L’alternative est la commande double qui indique ce qu’on doit faire dans chacun de ces 2 cas.
0.2.3.1.2Forme générale
début du programme
SI condition
ALORS
Traitement 1
SINON
Traitement 2
FINSI
suite du programme
0.2.3.1.3Fonctionnement
Si la condition est remplie, on exécute le traitement 1 puis on continue à la ligne suivant immédiatement le FINSI (sans se préoccuper du traitement 2), sinon on exécute le traitement 2 (sans se préoccuper du traitement 1) puis on continue à la ligne suivant immédiatement le FINSI.
0.2.3.1.4Organigramme équivalent
0.2.3.1.5Exemple : programme COMPARNOMS1
On donne 2 noms, supposés différents par simplification (pour éviter d’avoir à traiter le cas d’égalité, ce qui nous ferait 3 cas au lieu de 2, nous verrons cela plus loin), et on veut les écrire dans l’ordre alphabétique :
Algorithme :
Variables NOMA, NOMB : caractères
Début
Afficher "Tapez le 1er nom :"
Lire NOMA
Afficher "Tapez le 2ème nom :"
Lire NOMB
Si NOMA < NOMB
Alors
Écrire NOMA, NOMB
Sinon
Écrire NOMB, NOMA
Finsi
Fin
0.2.3.1.6Programmation
Forme générale :
IF condition
Commandes 1
ELSE
Commandes 2
ENDIF
Notes :
1- le alors n’est pas explicité dans ce langage (il l’est dans d’autres) ;
2- pas d’espace entre END et IF.
Exemple : programme COMPARNOMS1
Sous dBASE 5 et 5.5, il faut raccourcir le nom du programme COMPARNOMS1 en COMPNOM1.
Le programme est :
accept "Tapez le 1er nom :" to NOMA
accept "Tapez le 2ème nom :" to NOMB
if NOMA < NOMB
? NOMA, NOMB
else
? NOMB, NOMA
endif
Cas d'une formule de tableur
Nous venons de voir comment programmer l'alternative dans différents langages. Nous savons que les tableurs possèdent une fonction SI, utilisable dans les formules. Pour prendre l'exemple particulier d'EXCEL, nous savons comment programmer une alternative en Visual Basic sous Excel, et nous savons également employer la fonction SI d'Excel dans une formule, indépendamment de toute programmation VBA ou de toute macro.
Cette fonction SI a la forme générale suivante :
SI ( condition ; traitement si la condition est vraie ; traitement si la condition est fausse )
Il est important de remarquer que cette écriture est exactement la même que celle de l'algorithme, à cela près qu'elle est en ligne au lieu d'être en colonne :
Le SI algorithmique est codé par le SI et la parenthèse ouvrante, les alors et sinon par les 2 point-virgule, le FINSI par la parenthèse fermante. A ces détails près, l'écriture est exactement la même !
0.2.3.2L’alternative simplifiée
0.2.3.2.1Présentation
Principe : lorsqu’on désire simplement tester une condition, sans examiner le cas SINON.
Forme générale :
Début du programme
SI condition ALORS traitement
Suite du programme
Fonctionnement évident : si la condition est vraie, le traitement est exécuté, et on continue à la ligne en dessous, sauf très évidemment si le traitement concerné consiste en un branchement vers une autre partie du programme, par exemple un sous-programme ; il faut mentalement compléter la ligne SI par "sous-entendu : sinon ne rien faire, ignorer le traitement, et passer directement à la ligne en dessous du SI".
0.2.3.2.2Exemple : programme COMPARNOMS2
Avec les mêmes hypothèses que pour COMPARNOMS1, on aurait, en employant des alternatives simplifiées :
Algorithme :
Variables NOMA, NOMB : caractères
Début
Afficher "Tapez le 1er nom :"
Lire NOMA
Afficher "Tapez le 2ème nom :"
Lire NOMB
Si NOMA < NOMB alors écrire NOMA, NOMB
Si NOMA = NOMB alors écrire NOMB, NOMA
Fin
0.2.3.2.3Programmation
Sous dBASE, il n'y a pas d'instruction spécifique d'alternative simplifiée à proprement parler. On peut cependant la simuler ainsi :
IF condition
Commandes
ENDIF
Exemple : programme COMPNOM2 (attention à l'orthographe du nom du programme !).
accept "Tapez le 1er nom :" to NOMA
accept "Tapez le 2ème nom :" to NOMB
if NOMA < NOMB
? NOMA, NOMB
endif
if NOMA > NOMB
? NOMB, NOMA
endif
Les alternatives imbriquées
0.2.3.3.1Présentation
On peut imbriquer des alternatives, à condition bien entendu de ne pas les faire se chevaucher.
Le schéma donné ci-dessous à titre d’exemple est suffisamment clair pour se passer d’explication. Il faut bien faire attention à "fermer" chaque SI par un FINSI correspondant. Le problème est exactement le même que celui des parenthèses dans une formule mathématique.
0.2.3.3.2Exemple : programme COMPARNOMS3
Comparaison de 2 noms, version 3 : on améliore le programme COMPARNOMS1 en admettant que les 2 noms tapés peuvent être identiques, c'est à dire que nous avons maintenant 3 cas et non plus 2.
Algorithme :
Variables NOMA, NOMB : caractères
Début
Afficher "Tapez le 1er nom :"
Lire NOMA
Afficher "Tapez le 2ème nom :"
Lire NOMB
Si NOMA < NOMB
Alors
Écrire NOMA, NOMB
Sinon
Si NOMA = NOMB
Ecrire "les 2 noms sont les mêmes"
sinon
Écrire NOMB, NOMA
Finsi
Finsi
Fin
N.B. C'est là où apparaît l'intérêt de l'indentation, qui facilite le repérage visuel d'éventuels chevauchements.
0.2.3.3.3Programmation
Pas de problème particulier : la commande d'alternative est celle vue plus haut, et il suffit de les imbriquer exactement comme dans l'algorithme, en faisant attention à éviter les chevauchements.
Programmation de l'exemple COMPARNOMS3, sous dBASE en interface texte :
accept "Tapez le 1er nom :" to NOMA
accept "Tapez le 2ème nom :" to NOMB
if NOMA < NOMB
? NOMA, NOMB
else
if NOMA = NOMB
? "Les 2 noms sont les mêmes"
else
? NOMB, NOMA
endif
endif
N.B. 1- comme pour l'algorithme, noter l'intérêt de l'indentation, qui facilite le repérage visuel d'éventuels chevauchements.
2- appeler ce programme COMPNOM3.
0.2.3.3.4Remarque
Attention à une erreur fréquemment commise. Je vois souvent des algorithmes ainsi formulés, sur l’exemple COMPARNOMS1 (rappel : les 2 noms sont supposés différents) :
Si NOMA < NOMB
Alors
Écrire NOMA, NOMB
Sinon si NOMA > NOMB
Écrire NOMB, NOMA
Finsi
Le fait de répéter la condition, tout au moins son "contraire", après le SINON prouve que vous n’avez pas compris le fonctionnement… et c’est zéro à l’exo !
0.2.3.3.5Cas d'une formule de tableur
Les imbrications de SI se font dans une formule de tableur exactement comme je l'ai expliqué plus haut :
N.B. attention ! De même qu'il y a 2 FINSI, il y a 2 parenthèses fermantes !
0.2.3.4L’alternative multiple
0.2.3.4.1Principe
Également appelée alternative généralisée.
L’alternative ne connaît que 2 cas possibles. Mais très souvent, on rencontre plusieurs cas. On pose donc plusieurs conditions successives, conduisant à des tests en cascade, et à des alternatives imbriquées, devenant vite pénibles à écrire et à vérifier. Heureusement, les théoriciens de l’algorithmie, dans Leur Immense Bonté, ont inventé l’alternative multiple, pour nous soulager, nous autres pauvres laborieux de base !
0.2.3.4.2Forme générale
Début du programme
SELON CAS
CAS condition 1
Traitement 1
CAS condition 2
Traitement 2
CAS condition 3
Traitement 3
………………..
…………...
AUTRES CAS
Traitement autre
FINCAS
Suite du programme
0.2.3.4.3Fonctionnement
Évident : la condition 1 est évaluée, si elle est remplie, le traitement 1 est exécuté, puis le programme continue à la ligne en dessous du FINCAS ; si elle n’est pas remplie, le processus est identique pour la condition 2, et ainsi de suite ; la clause AUTRES CAS est facultative ; si elle existe, et si aucune des conditions précédentes ne s’est trouvée vraie, c’est le traitement autre qui sera exécuté ; si elle n’existe pas, le programme continue normalement à la ligne après le FINCAS.
0.2.3.4.4Organigramme équivalent
0.2.3.4.5Exemple : programme COMPARNOMS4
Reprenons compnoms3, mais avec un selon cas au lieu des alternatives imbriquées.
Algorithme :
Variables NOMA, NOMB : caractères
Début
Afficher "Tapez le 1er nom :"
Lire NOMA
Afficher "Tapez le 2ème nom :"
Lire NOMB
Selon cas
Cas NOMA < NOMB
Écrire NOMA, NOMB
Cas NOMA = NOMB
Écrire "Les 2 noms sont identiques"
Cas NOMA > NOMB
Écrire NOMB, NOMA
Fincas
Fin
Note :
Il n’y a évidemment pas d’autres cas. On peut donc adopter la variante suivante :
Selon cas
Cas NOMA < NOMB
Écrire NOMA, NOMB
Cas NOMA = NOMB
Écrire "Les 2 noms sont identiques"
Autres cas
Écrire NOMB, NOMA
Fincas
0.2.3.4.6Programmation
DO CASE
CASE condition 1
Commandes 1
CASE condition 2
Commandes 2
CASE condition 3
Commandes 3
……………………………
……………………………..
OTHERWISE
Commandes
ENCASE
Note : pas d’espace entre END et CASE.
Exemple : COMPNOM4
*********************
Remarque
Attention à 2 conséquences du fonctionnement de l'alternative multiple :
a- si aucune des conditions n’est vraie, et si la clause AUTRES CAS n’est pas présente, rien ne sera exécuté ;
b- les conditions ne sont pas cumulatives ; elles sont examinées dans leur ordre d’apparition ; dès que l’une est vraie, le programme exécute le traitement prévu, puis est débranché sur la suite après le FINCAS, et les autres conditions ne sont même pas examinées ; par exemple si les conditions 2 et 5 sont toutes deux vraies, seul le traitement 2 sera exécuté, et le traitement 5 sera ignoré.
0.2.3.5Application : programme BONJOURSI
On veut dire "Bonjour madame Untel", ou "Bonjour monsieur Untel", selon le cas. Il faudra donc compléter le programme "bonjour" en demandant le genre de la personne qui tape son nom, et différencier la sortie.
0.2.3.5.1Algorithme
Complétons l’algorithme de bonjour. La complexité ne devient pas insurmontable :
variables A, B : caractères ; CODESEXE : numérique
début
afficher "Tapez votre nom :"
lire A
afficher "Tapez votre code sexe de la Sécu :"
lire codesexe
B = A
Si codesexe = 1
Alors
Écrire "Bonjour monsieur", B
Sinon
Écrire "Bonjour madame", B
finsi
fin
0.2.3.5.2dBASE interface texte
Attention : pour les raisons déjà expliquées à maintes reprises, appeler ce programme "bonjsi", et non "bonjoursi".
Accept "Tapez votre nom :" to A
Input "Tapez votre code sexe de la Sécu :" to codesexe
B = A
If codesexe = 1
? "Bonjour monsieur", B
else
? "Bonjour madame", B
endif
0.2.3.5.3dBASE interface fenêtre
Appeler ce programme "bonjsif".
Rappel : même si on le dénomme "bonjsi", on ne risque pas de le confondre avec le "bonjsi" du § précédent, à cause de l'extension .wfm et non .prg, mais c'est encore mieux comme ça.
0.2.3.5.4Paradox
0.2.3.5.5Lotus
0.2.3.5.6Access
0.2.3.5.7Macro WordBasic 7
Sub MAIN
A$ = InputBox$("Tapez votre nom : ", "Boîte de saisie du nom", "votre nom")
B$ = A$
codesexe = Val(InputBox$("Tapez votre code sexe de la Sécu : ", "Boîte de saisie du code sexe", "0"))
If codesexe = 1 Then
MsgBox "Bonjour monsieur " + B$, "Boîte d'affichage pour hommes"
Else
MsgBox "Bonjour madame " + B$, "Boîte d'affichage pour femmes"
End If
End Sub
0.2.3.5.8Macro Excel 7
Sub Bonjoursi()
Dim A, B As String
Dim codesexe As Integer
A$ = InputBox$("Tapez votre nom :", "Boîte de saisie du nom", "votre nom")
B$ = A$
codesexe = Val(InputBox$("Tapez votre code sexe de la Sécu : ", "Boîte de saisie du code sexe", "0"))
If codesexe = 1 Then
texte = "Bonjour monsieur " & B
titre = "Boîte d'affichage pour hommes"
Else
texte = "Bonjour madame " & B
titre = "Boîte d'affichage pour femmes"
End If
bouton = vbOKOnly
réponse = MsgBox(texte, bouton, titre)
End Sub
0.2.3.6Exercices
0.2.3.6.1Énoncés
Imaginons qu’un magasin solde tous ses articles. Les réductions sont de 15 %, 20 %, 30 %, 50 % selon les articles. On veut délivrer au client une fiche indiquant le prix initial (le prix normal de vente avant solde), le montant de la remise, et le prix final à payer. Il existe bien sûr plusieurs solutions, mais pour les besoins de mon exemple, j’adopterai la suivante :on entre dans l’ordinateur le prix initial et un code correspondant au taux de remise, soit un nombre de 1 à 4. Enfin, on se bornera à traiter les clients un par un, car je ne parle de la répétition et du traitement des fichiers que plus loin.
Reprenez l’algorithme de la version 1. Ce que nous avons fait fonctionne très bien, mais cela est quand même un peu lourd à écrire, et on risque de se mélanger les pinceaux dans l’emplacement et le nombre de FINSI. Nous allons constater ici les bienfaits inestimables du SELON CAS.
Il y a une hypothèse indispensable pour assurer le bon fonctionnement de la solution que j’ai donnée dans la version 2. Trouvez-la, et améliorez l'algorithme en tenant compte de cette réflexion. Ensuite, réfléchissez bien sur votre nouvelle solution, et pondez une remarque encore plus intelligente que la première.
Êtes-vous réellement satisfait de la solution que j’ai donnée pour la version 3 ? Si oui, vous avez tort, car elle n’est pas bonne ! Trouvez pourquoi, et corrigez !
Reprenez l’algorithme de la version 1, celui utilisé plus haut pour illustrer les alternatives imbriquées, et réécrivez-le avec des alternatives simplifiées.
Cela serait-il possible avec la version 3 ?
Comparez 2 dates, fournies chacune, pour les besoins de l’exercice, en 3 variables séparées, soit J1, M1, A1 pour la date 1, et J2, M2, A2 pour la date 2. Vous devez afficher l’un des messages suivants : "Date 1 antérieure", "Date 1 postérieure", ou "Les dates sont les mêmes".
N.B. nous verrons plus loin qu'il existe heureusement des façons plus simples de travailler sur les dates. Considérez qu'il s'agit, à ce stade, d'un exercice de raisonnement !
0.2.3.6.2Corrigés
L’algorithme avec des alternatives imbriquées est :
Variables : PI, PF, R réels ; CS entier
Début
Écrire "Tapez le prix initial :"
Lire PI
Écrire "Tapez le code solde :"
Lire CS
Si CS = 1
Alors
R = PI * 0,15
Sinon
Si CS = 2
Alors
R = PI * 0,2
Sinon
Si CS = 3
Alors
R = PI * 0,3
Sinon
R = PI * 0,5
Finsi
Finsi
Finsi
PF = PI – R
Ecrire PI, R, PF
Fin
Remarques :
a- j’ai mis en "facteur commun" à la fin le calcul du prix final et l’écriture des résultats ; c’est évident, certes, mais dites-vous bien, mes petits lapins, que cela s’appelle un "regroupement de séquences" ! ! !
b- pour l’autre remarque, qui pourrait éventuellement vous être venue à l'esprit, voir plus loin l’énoncé de l’exercice "calcul de soldes version 3".
Variables : PI, PF, R réels ; CS entier
Début
Écrire "Tapez le prix initial :"
Lire PI
Écrire "Tapez le code solde :"
Lire CS
Selon cas
Cas CS = 1
R = PI * 0,15
Cas CS = 2
R = PI * 0,2
Cas CS = 3
R = PI * 0,3
Autres cas
R = PI * 0,5
Fin cas
PF = PI – R
Ecrire PI, R, PF
Fin
C’est exactement la même chose qu'avec les alternatives imbriquées, mais c’est tout de même plus simple à écrire et à vérifier !
Attention : après avoir étudié le corrigé ci-dessous, vous devez IMPÉRATIVEMENT faire l’exercice suivant "Calcul de soldes, version 4".
La solution que j’ai donnée dans la version 2 ne peut fonctionner correctement que s’il n’y a pas d’autres cas possibles. Vous me direz "mais le code ne peut être que 1, ou 2, ou 3, ou 4. S’il n’est ni 1, ni 2, ni 3, il est forcément 4 !" Certes, dans la théorie… Mais dans la pratique… Et les erreurs de frappe ? Imaginez que vous tapiez 7 ? Tous les codes frappés différents de 1, ou 2, ou 3, vont conduire à une remise de 50 %, ce qui n’est pas forcément du goût du patron du magasin ! Il faut donc améliorer l’algorithme pour détecter cette erreur, et sortir un message d’alerte. La solution est simplissime :
Cas CS = 3
R = PI * 0,3
Cas CS = 4
R = PI * 0,5
Autres cas
Ecrire "Erreur de frappe, recommencez !"
Fin cas
PF = PI – R
Ecrire PI, R, PF
Fin
Remarque intelligente : on peut ainsi détecter certaines erreurs de frappe, mais pas toutes : si l’utilisateur de votre programme tape un 4 au lieu d’un 2, cela est indétectable…
0.2.3.6.2.1dBASE interface texte
0.2.3.6.2.2dBASE interface fenêtre
0.2.3.6.2.3Paradox
0.2.3.6.2.4Lotus
0.2.3.6.2.5Access
0.2.3.6.2.6WordBasic 7
0.2.3.6.2.7Excel 7
L’algorithme de la version 3 n’est pas bon, car après AUTRES CAS, on exécute quand même la fin, la séquence située après le FIN CAS, c’est-à-dire le calcul du prix final et l’affichage des résultats ! Que se passerait-il exactement si on programmait cet algorithme ? On ne peut pas le dire avec précision, car cela dépend du langage utilisé. Un logiciel du genre de dBASE protesterait en rencontrant R, à qui il n’a pas été présenté, en proclamant quelque chose du genre "variable non définie", et s’arrêterait en refusant de calculer PF. Mais dans un cas réel, où au lieu de traiter les clients 1 par 1, en relançant le programme à chaque fois, on aurait une répétition, et à partir du 2ème client (en supposant qu’il n’y ait pas d’erreur sur le 1er code frappé), la variable R serait connue, dBASE n’aurait plus de raison de s’émouvoir, il appliquerait sans mollir au client en cours la remise du client précédent, après avoir affiché son message d’erreur…
Le bon algorithme est donc :
Autres cas
Ecrire "Erreur de frappe, recommencez !"
Arrêt du programme
Fin cas
Retenez quand même que la clause "autres cas" peut servir à la récupération de certaines erreurs.
0.2.3.6.2.8dBASE interface texte
0.2.3.6.2.9dBASE interface fenêtre
0.2.3.6.2.10Paradox
0.2.3.6.2.11Lotus
0.2.3.6.2.12Access
0.2.3.6.2.13WordBasic 7
0.2.3.6.2.14Excel 7
Répétitions
"Répéter" en algorithmie correspond à "recommencer" dans le langage courant.
On emploie souvent les mots "boucle" ou "itération".
L’exemple classique est celui du calcul de la paye des employés d’une entreprise. Lorsqu’on a calculé la paye du premier employé, il faut bien calculer la paye de tous les autres, sinon ils ne seraient vraisemblablement pas très contents, et alerteraient leurs syndicats. Il faut donc "continuer", c’est-à-dire en fait "recommencer" exactement les mêmes calculs pour le deuxième, puis le troisième, etc..
Mais il ne faut bien sûr pas répéter indéfiniment ces calculs : on s’arrête lorsqu’on a fini ( ! ! ! ? ? ?), c’est-à-dire lorsqu’on a traité tous les employés.
Nous voyons ainsi qu’une répétition doit comporter une condition d’arrêt, qui provoque l’interruption de la répétition. Selon la façon de formuler cette condition, on distingue 3 répétitions, que nous allons étudier. Notons cependant que certains langages sont généreux en variantes.
0.2.4.1La répétition Tant que
0.2.4.1.1Principe
On répète un certain traitement "tant que" une certaine condition est remplie (ou "vraie").
Dans mon exemple de calcul de paye, on dirait : on répète le calcul de paye tant qu’il reste un employé à payer, ou tant qu’on n’est pas arrivé à la fin des employés. C’est d’ailleurs cette dernière formulation que nous retrouverons plus tard, lorsque nous étudierons les traitements des fichiers.
0.2.4.1.2Forme générale
Début du programme
REPETER TANT QUE condition
Traitement (parfois appelé "corps de la répétition")
FINTANT
Suite du programme
0.2.4.1.3Fonctionnement
La condition est évaluée ; si elle est fausse, la répétition est ignorée, et l’exécution se poursuit directement après le "fintant" ; si elle est vraie, les commandes du traitement sont exécutées jusqu’au "fintant", qui renvoie au "répéter" ; la condition est alors réévaluée ; si elle est toujours vraie, le processus recommence ; si elle est devenue fausse, l’exécution saute à la ligne qui suit immédiatement le "fintant", et le programme se poursuit.
0.2.4.1.4Organigramme équivalent
0.2.4.1.5Exemple : programme COMPTERTANTQUE
Compter (à partir de 0) tant que l’utilisateur ne dit pas d’arrêter :
Variables rep caractère, N entier
début
N = 0
Rep = "N"
Tant que rep <> "O" faire
écrire N
N = N + 1
Ecrire "Voulez-vous continuer O / N ?"
Lire rep
Fin tant
Ecrire "C’est fini."
Fin
Note : ne confondez pas la variable "N", qui stocke le nombre en cours, et la lettre "N" tapée en réponse à la question !
0.2.4.1.6 Programmation
DO WHILE condition
commandes
ENDDO
Note : pas d’espace entre END et DO.
Exemple : programme COMPTTQ
**************
Remarques et conseils
Attention à 2 conséquences de ce fonctionnement :
a- si la condition est initialement fausse, le traitement entre le "répéter" et le "fintant" n’est pas exécuté du tout ;
b- si la condition reste toujours vraie (soit au hasard d’un cas particulier, soit par une erreur de programmation) la répétition ne s’arrête jamais ; l’opérateur "perd la main" ; nous verrons plus loin que, parfois, on utilise cette caractéristique pour fabriquer volontairement une répétition infinie.
Le corps de la répétition peut être complexe, voire très complexe, et contenir des entrées, des sorties, des alternatives, d’autres répétitions (Ah ! Les délices des calculs matriciels d’antan !), des appels à des sous-programmes, etc..
Attention à 2 pièges à l’examen :
- ne pas oublier d’initialiser, d’une façon ou d’une autre, la condition ;
- bien réfléchir au sens du test : telle condition, ou NON condition.
0.2.4.2La répétition Jusqu’à
0.2.4.2.1Principe
On répète un certain traitement "jusqu’à ce que" une certaine condition soit remplie (ou "vraie").
Dans mon exemple de calcul de paye, on dirait : on répète le calcul de paye jusqu’à ce qu’il n’y ait plus d’employé à payer, ou jusqu’à ce qu’on soit arrivé à la fin des employés.
0.2.4.2.2Forme générale
Début du programme
REPETER
Traitement
JUSQU'À condition
Suite du programme
0.2.4.2.3Fonctionnement
Le traitement est exécuté, puis la condition est évaluée ; si elle n’est pas remplie ("fausse"), le déroulement est renvoyé au "répéter", et le processus recommence ; si elle est devenue vraie, l’exécution passe à la ligne qui suit immédiatement le "jusqu’à", et le programme se poursuit.
0.2.4.2.4Organigramme équivalent
0.2.4.2.5Exemple : programme COMPTERJUSQUA
Compter (à partir de 0) jusqu’à une valeur N indiquée par l’utilisateur
0.2.4.2.6Programmation
DO
Commandes
UNTIL condition
Exemple : programme COMPTJQ
Remarques et conseils
Attention à 2 conséquences de ce fonctionnement :
a- l’une est l’inverse de celle vue plus haut pour la répétition "tantque" : le traitement concerné est toujours exécuté au moins une fois, même si la condition est initialement vraie ; en particulier, si on lit un fichier, il faut que ce fichier comporte au moins un enregistrement ; s’il est vide, on aura des ennuis ;
b- l’autre est qu’on ne peut pas interchanger sans précaution les répétitions "tantque" et "jusqu’à" en "inversant" la condition : "jusqu’à condition" est logiquement équivalent à "tant que non condition" (et inversement !), certes, mais il faut se méfier de la caractéristique a- ci-dessus ; réfléchissez à cela !
0.2.4.3La répétition Pour
0.2.4.3.1Principe
On répète un certain traitement un certain nombre de fois.
Dans mon exemple de calcul de paye, on dirait : on répète le calcul de paye N fois (il faut connaître N, l’effectif de l’entreprise).
0.2.4.3.2Forme générale
Début du programme
POUR indice VARIANT DE valeur initiale A valeur finale AVEC PAS pas
Traitement
FINPOUR
Suite du programme
Les 3 valeurs, valeur initiale, valeur finale, pas, sont appelées les paramètres de la répétition ; si le pas vaut 1, son indication est facultative.
0.2.4.3.3Fonctionnement
Cette variante intègre l’utilisation d’un compteur (nous verrons plus loin ce que c’est), appelé "indice de répétition".
L’indice reçoit la valeur initiale indiquée ; si elle est supérieure à la valeur finale, le déroulement saute à la ligne suivant le "finpour", et le programme se poursuit ; sinon le traitement est exécuté ; le "finpour" renvoie au "pour", la valeur de l’indice est incrémentée de la valeur du pas, et le processus recommence.
Le pas peut être négatif, mais dans ce cas, il vaut mieux que la valeur finale soit inférieure à la valeur initiale !
0.2.4.3.4Organigramme équivalent
0.2.4.3.5Exemple : programme COMPTERPOUR
Je veux écrire 10 fois bonjour :
Variable : I entier
Début
Pour I variant de 1 à 10
Écrire "Bonjour"
Finpour
Fin
0.2.4.3.6Programmation
FOR indice = valeur initiale TO valeur finale STEP pas
Commandes
NEXT
Rappels :
a- ne pas bricoler l’indice, ni le pas, dans la boucle ;
b- le pas est facultatif ; s’il n’est pas explicité, il vaut 1 par défaut.
Exemple : programme COMPTPR
Remarques et conseils
Attention :
a-le fonctionnement de cette forme "pour" n’est pas vraiment normalisé dans tous les langages, et le fonctionnement peut être différent de celui que j’explique ici ;
b- les paramètres peuvent être des variables ;
c- on peut utiliser l’indice dans des calculs à l’intérieur de la boucle, ou après la sortie, mais il faut être prudent dans sa manipulation (et dans celle des paramètres) ;
d- retenez dans la pratique que la boucle est exécutée pour la dernière fois pour la plus grande valeur de l’indice non supérieure à la valeur finale ;
e- une conséquence de ce fonctionnement est que, selon les valeurs respectives des paramètres, la boucle peut ne pas être exécutée du tout, ou… ne jamais s’arrêter !
0.2.4.4La répétition infinie
0.2.4.4.1Principe
Encore dite "répétition systématique", ou "boucle infinie". Il s’agit, comme son nom l’indique, d’une répétition qui ne s’arrête jamais.
0.2.4.4.2Une forme possible
Une façon simple d’en fabriquer une est d'employer une répétition TANT QUE :
REPETER TANT QUE vrai
Traitement
FINTANT
Où "vrai" est la constante logique toujours vraie. La condition du TANT QUE étant toujours vraie, il est clair que la répétition ne s'arrêtera jamais.
Etant donné qu'il y a toujours une fin à tout, même aux répétitions infinies, il faut prévoir dans le traitement situé à l'intérieur de la boucle une condition d'arrêt. Nous en verrons divers exemples dans la suite.
0.2.4.4.3Exemple : menu en interface texte
Exemple d’utilisation d'une boucle infinie pour fabriquer un menu (sous dBASE ou autre) en interface texte.
Cette application est prématurée, car elle est à employer essentiellement avec des sous-programmes. Par ailleurs, je la réserve comme introduction à la partie suivante, sur la programmation "améliorée". Je positionne cependant ici l'algorithme de principe, car il constitue une excellente illustration.
Algorithme de principe :
Début du programme
Répéter tant que vrai
Afficher un menu proposant des choix et demandant de taper un code (lettre ou chiffre) pour indiquer ce choix
Lire la réponse
Avec un "selon cas", pour chaque réponse prévue indiquer les instructions à exécuter, ou appeler un sous-programme particulier adapté à cette réponse
Fintant
Fin du programme
N.B. c'est dans chaque module (j'appelle module les instructions à exécuter et les sous-programmes appelés dans le SELON CAS), ou dans un des modules, qu'on placera une instruction d'arrêt du programme.
0.2.4.4.4Remarque : arrêt forcé
La répétition infinie est parfois utile, comme dans l'exemple donné ci-dessus. Mais elle résulte malheureusement souvent d'une erreur de programmation : le programme boucle, c'est à dire qu'il tourne sans s'arrêter.
Si vous avez de la chance, il y a une instruction d'écriture dans la boucle. Vous voyez alors des lignes défiler à toute vitesse (et si vous imprimez, vous gaspillez beaucoup de papier pour rien…), et vous vous doutez que quelque chose ne tourne pas rond. Sinon, il ne se passe rien, vous ne voyez rien, et généralement vous perdez la main au clavier. Vous avez beau taper n'importe quoi, il ne se passe vraiment rien, et vous avez l'impression que l'ordinateur est planté. Il n'en est pourtant rien, cela ne vient pas de Win (pour une fois !), mais de vos qualités de programmeur...
Que faire alors ? Tenter une manœuvre d'arrêt de votre programme fautif, sans pour autant planter la machine pour de bon :
Sous DOS Contrôle + c
Sous Win invoquer le gestionnaire de tâches (Alt + Ctrl + Suppr) et tuer celle voulue
Sous dBASE échappe
0.2.4.5Application : programme BONJOURREPETITION
On reprend le programme "Bonjour", et on veut dire "Bonjour" 5 fois de suite.
0.2.4.5.1dBASE interface texte
Rappel : appeler ce programme "bonjrep".
0.2.4.5.2dBASE interface fenêtre
Rappel : appeler ce programme "bonjref".
0.2.4.5.3Paradox
0.2.4.5.4Lotus
0.2.4.5.5Access
0.2.4.5.6WordBasic 7
Sub MAIN
A$ = InputBox$("Tapez votre nom :", "Boîte de saisie du nom", "votre nom")
B$ = A$
For num = 1 To 5
MsgBox "numéro" + Str$(num) + " Bonjour " + B$, "Boîte d'affichage du nom"
Next num
End Sub
0.2.4.5.7Excel 7
0.2.4.6Exercices
Exos faire bonjTQ et JQ avec l'opérateur qui dit stop ou encore
BonjPR 2 variantes : nb de fois prédéterminé, et nb de fois indiqué par l'opérateur
Compter tant qu’on n’a pas atteint une valeur N indiquée par l’utilisateur.
Écrire bonjour un nombre de fois indiqué par l’utilisateur, en numérotant les lignes.
Idem, en numérotant les lignes de 5 en 5.
Trouvez dans quel(s) cas une boucle POUR ne s’arrêtera pas. Cherchez comment s’en prémunir.
0.2.5Sous-programmes et fonctions
0.2.5.1Les sous-programmes
Il peut arriver qu’on ait à utiliser à plusieurs endroits d’un programme la même séquence de calculs, ou le même bloc de traitement.
On peut bien entendu rédiger ainsi le programme, en écrivant à chaque fois les instructions du traitement concerné. Mais on irait évidemment beaucoup plus vite si on pouvait ne les écrire qu’une seule fois, en quelque sorte en "facteur commun", sans rien changer pour l’exécution.
On dit que le traitement concerné est mis en "sous-programme", le programme proprement dit devenant ipso facto le "programme principal".
Cette façon de procéder nécessite des instructions spéciales dans les langages de programmation, et le détail de la réalisation n’est malheureusement pas le même dans les divers langages. On peut cependant dégager les points communs suivants :
a- on évite de mélanger les instructions du (des) sous-programme(s) et celles du programme principal. Pour cela, certains langages les délimitent par des instructions spéciales, d’autres les stockent carrément dans des fichiers physiquement séparés, et portant un nom propre.
b- aux endroits adéquats du programme principal on ordonne d’effectuer le branchement sur le sous-programme voulu au moyen d’une "instruction d’appel", qui transfère le contrôle au sous-programme désigné.
c- à la fin du sous-programme, il faut revenir au programme principal. Cela est réalisé par une "instruction de retour", qui rend la commande de l’ordinateur au programme principal, c’est-à-dire qui ordonne de revenir à la ligne du programme principal qui suit immédiatement l’instruction d’appel qui a provoqué le transfert au sous-programme (il peut en effet y avoir plusieurs appels au même sous-programme, voir l’exemple suivant). La difficulté est évidemment de gérer le retour au bon endroit, surtout lorsqu’il y a plusieurs appels, mais cela, c’est le langage qui s’en charge, ce qui est bien sympathique de sa part !
0.2.5.2Les fonctions
Un sous-programme est en fait un véritable programme, qui peut être plus ou moins long, comporter des opérations plus ou moins complexes, y compris des entrées et des sorties, voire faire appel lui-même à d’autres sous-programmes.
À l’opposé, on peut avoir besoin d’un résultat unique, obtenu par une simple expression (arithmétique ou autre). On emploie alors une forme allégée du sous-programme : la fonction.
Une fonction doit être déclarée par le programmeur avant son utilisation. Il s’agit simplement d’une instruction particulière, appelée "déclaration de fonction", permettant de définir la formule constituant cette fonction et le nom que le programmeur désire lui donner. Il pourra ensuite l’employer en la désignant simplement par ce nom, ce qui lui évitera d’écrire à chaque fois la formule.
Arrondi : exo : conversion euro
0.2.5.3Sous-programmes et fonctions de bibliothèque
Pour soulager le travail du programmeur, certaines tâches spéciales ou particulièrement courantes et utiles ont été inclues, d’une façon ou d’une autre, dans les possibilités des divers langages de programmation.
C’est ce qu’on appelle les sous-programmes et les fonctions de bibliothèque. On rencontre également les qualificatifs "intrinsèques" ou "prédéfinis".
Le programmeur peut les employer en les appelant par leur nom réservé, sans aucune déclaration particulière préalable.
On peut distinguer quelques grandes catégories :
a- les fonctions mathématiques
- usuelles : racine carrée, exponentielle, log, trigo, trigo hyperbolique…
- utiles en informatique : génération de nombre aléatoire…
b- les fonctions statistiques
c- les fonctions financières
d- les fonctions de traitement de caractères
e- des fonctions diverses, par exemple date et heure système
f- des utilitaires, par exemple copie de fichiers, tri…
0.2.5.4Programmation
0.2.5.4.1Sous-programmes
Le sous-programme est un fichier distinct du fichier programme principal. On le tape et on l’enregistre comme un véritable programme. Il a donc un nom différent de celui du programme principal.
Il n’a pas d’instruction de début particulière ; elle serait d’ailleurs inutile, puisque ce sous-programme est physiquement distinct du programme principal et qu’il possède un nom différent, ce qui suffit à l’identifier.
Par contre, il faut le terminer par une instruction de retour, qui est :
RETURN
L’appel du sous-programme à partir du programme principal s’effectue tout simplement par la commande :
DO nomdusousprogrammeappelé
Fonctions
dBASE connaît deux sortes de fonctions :
Intégrées
Utilisateur
Les fonctions renvoient des valeurs et sont constituées d'un mot réservé suivi par des parenthèses ouvrante et fermante. Les parenthèses peuvent contenir des arguments qui sont passées à la fonction pour être traités. Dans l'exemple qui suit, la fonction SQRT( ) renvoie la racine carrée de 36 :
? SQRT(36)
Fonctions intégrées
Les fonctions intégrées de dBASE effectuent généralement des opérations arithmétiques, des opérations sur du texte ou des dates, des opérations logiques ou de conversion. Quelques fonctions renvoient une valeur que vous pouvez utiliser. Ainsi, RECNO( ) renvoie le numéro de l'enregistrement en cours. Certaines fonctions, comme RLOCK( ) et TRIM( ), effectuent une action et renvoient une valeur.
Fonctions utilisateur
Les fonctions utilisateur sont des fonctions que vous créez et que vous appelez dans un programme exactement de la même manière qu'une fonction intégrée. Pour définir une fonction utilisateur, utilisez la commande FUNCTION, suivie du nom de la fonction utilisateur, d'une liste facultative de paramètres, et de la suite des commandes à éxécuter lorsque la fonction utilisateur est appelée.
Quelques fonctions :
DATE()
Renvoie la date système, sous la forme jj/mm/aa ; sinon vérifier si vous avez bien choisi le format de date français. Pour cela, dans un programme, commencez par la commande :
SET DATE FRENCH
Exemple :
Je veux afficher la date du jour :
? date()
EOF()
Renvoie la valeur logique .T. lorsque le pointeur d’enregistrement rencontre la fin logique du fichier courant.
C’est la fonction la plus utilisée dans les exercices et pour l’examen !
INT(expression numérique)
Renvoie la partie entière de l’expression spécifiée.
RANDOM() : génération d’un nombre aléatoire.
Renvoie une valeur décimale comprise entre 0 et 1.
Syntaxe :
RANDOM([<expN>])
<expN> est le nombre servant de semence à RANDOM( ).
Description :
RANDOM( ) permet de générer une série de nombres aléatoires. Si une valeur positive <expN> est spécifiée, RANDOM( ) utilise <expN> comme valeur de semence. Une valeur de semence est la valeur sur laquelle une fonction opère et renvoie un résultat. Ainsi, RANDOM( ) renvoie toujours la même valeur si la même valeur positive de <expN> est spécifiée. Par exemple, RANDOM(199) renvoie toujours 0,11, RANDOM(399) renvoie toujours 0,23 et RANDOM(599) renvoie toujours 0,35.
Pour les versions de dBASE antérieures à la version 5, la fonction est RAND().
Vous pouvez tester le fonctionnement de RANDOM() avec le programme du jeu idiot, amélioration 4 (attention : il faudra évidemment multiplier par 100 et prendre la partie entière !).
STR(expression numérique, longueur, nombre de décimales)
Convertit une expression numérique en chaîne de caractères.
UPPER(expression caractères)
Converti la chaîne en majuscules. Très utile par exemple pour éviter les problèmes de majuscules et de minuscules dans les noms d’un fichier des salariés, des étudiants, de votre carnet d’adresses, etc..
Exemples :
a- La variable A contient "Dupond".
Après exécution de la commande :
A = upper(A)
Elle contiendra "DUPOND".
b- hypothénuse
c- test de la fonction aléatoire
on va générer un nombre aléatoire N, le ramener entre 0 et 10, et compter les nombres de fois N1, N2, N3 etc. pour vérifier s'il est vrai qu'ils deviennent voisins lorsque N devient très grand.
Application
****************
0.2.5.6Exercices
0.2.5.6.1Enoncés
Calcul hypoténuse triangle rectangle ****
Tirer un nombre aléatoire entier compris entre 2 entiers donnés n1 et n2.
Tirer un nombre aléatoire entre 0 et 9 (ou entre 1 et 10), et vérifier la loi des grands nombres.
0.2.5.6.2Corrigés
Il faut tout d'abord chercher comment tirer un nombre entre 0 et 9, sachant que la fonction aléatoire (tout au moins celle de dBASE) renvoie un nombre compris entre 0 et 1. L'astuce est la suivante : on tire un nombre x, on le multiplie par 10, et on prend la partie entière.
Si vous voulez tirer un nombre entre 1 et 10, il suffit d'ajouter 1 au résultat du tirage.
Ensuite, on définit 10 variables nb0, nb1, nb2, … nb9, destinées chacune à compter le nombre de résultats correspondant, et avec un selon cas, on effectuera le comptage dans la variable voulue selon le résultat du tirage.
Vous pourrez vérifier qu'on a bien nb0 + nb1 + nb2 + … + nb9 = N, le nombre de tirages décidé.
Enfin, vous écrirez les 10 totaux, et tenterez de constater que pour N petit ils sont différents, voire très différents, et vous regarderez si, lorsque N augmente, leur écart se réduit, et si pour N très grand, ils deviennent très voisins. Attention quand même : plus N est grand, plus le temps de calcul est long, évidemment !
Les phanas des stats pourront secouer les résultats dans tous les sens : moyenne, écart-type, et tout le bazar !
L'algorithme est :
***************
Programme dBASE interface texte (l'appeler LOIGDNB) :
Set talk off
Input "Tapez le nombre de tirages : " to n
Nb0 = 0
Nb1 = 0
Nb2 = 0
Nb3 = 0
Nb4 = 0
Nb5 = 0
Nb6 = 0
Nb7 = 0
Nb8 = 0
Nb9 = 0
For i = 1 to n
X = random()
Y = int(10 * x)
Do case
Case y = 0
Nb0 = nb0 + 1
Case y = 1
Nb1 = nb1 + 1
Case y = 2
Nb2 = nb2 + 1
Case y = 3
Nb3 = nb3 + 1
Case y = 4
Nb4 = nb4 + 1
Case y = 5
Nb5 = nb5 + 1
Case y = 6
Nb6 = nb6 + 1
Case y = 7
Nb7 = nb7 + 1
Case y = 8
Nb8 = nb8 + 1
Case y = 9
Nb9 = nb9 + 1
Endcase
Next i
N2 = nb0 + nb1 + nb2 + nb3 + nb4 + nb5 + nb6 + nb7 + nb8 + nb9
If n2 <> n
? "Anomalie : le total des tirages ", n2, " ne correspond pas au nombre demandé", n
Endif
? nb0, nb1, nb2, nb3, nb4, nb5, nb6, nb7, nb8, nb9
N.B. ne faites pas attention aux majuscules mises automatiquement par ce crétin de Word.
0.2.6Compléments
0.2.6.1Test de fin d’un fichier ou d’une suite de données
L'outil essentiel est la répétition tant que, combinée à un test particulier.
Fichier :
non FF
2 lectures, imposées, suite à l’assassinat de ce bon vieux GOTO par la PS…
Pb du fichier vide, au moins un enregistrement…
Exemple :
Suite de données tapées au clavier :
une possibilité est de frapper, lorsqu’on en a terminé avec les données voulues, une donnée supplémentaire consistant en une valeur "bizarre", qu’on est certain de ne pas rencontrer dans les valeurs ordinaires, par exemple pour du numérique 9999 (et c’est dans cette ancestrale recette de programmation qu’il faut voir l’origine de la magnifique opération commerciale connue sous le nom de "Grande Peur Du 9 Septembre 99"…), ou une valeur négative si on est sûr de n’avoir que des valeurs positives (par exemple des prix de produits), ou pour du caractère ZZZZ, ou %%%, ou n’importe quoi. On prévoit dans l’algorithme le test de cette valeur convenue, et hop ! le tour est joué !
2 lectures, la 1ère nécessaire pour initialiser la condition, sinon astuce pour initialiser la var…
Exemple : ***********
On peut employer la répétition jusqu'à.
Attention : la donnée fictive de fin n’est pas à traiter !
0.2.6.2Outils
0.2.6.2.1Les totalisateurs
Un totalisateur, ou accumulateur, est une variable utilisée par le programmeur pour additionner des valeurs dont il désire obtenir le total (inattendu, n’est-ce pas ?), le plus souvent lors d’une répétition.
Comment procéder pour additionner des valeurs ?
Il faut bien entendu utiliser une variable mémoire à laquelle on donne un nom jugé évocateur de son (futur) contenu.
À chaque itération, on additionne ce qu’il faut dans cette variable grâce à une instruction d’affectation.
Mais il faut faire attention à un point important : qu’y a-t-il dans cette variable au départ ? On n’en sait rien ! Il peut y avoir n’importe quoi dans cette zone de la MC, suivant ce que l’ordinateur a exécuté avant que nous ne lancions notre programme. C’est d’ailleurs la raison pour laquelle les langages refusent de fonctionner dans ce cas et protestent en vous avertissant : "variable non définie".
De toutes façons, pour être sûr de ce qu’il y a dans une variable, la meilleure solution est encore d’y mettre nous-même ce qui nous arrange ! Cette opération s’appelle l’"initialisation" de la variable. Nous placerons donc systématiquement les initialisations nécessaires en début de programme.
L’opération d’addition est appelée "accumulation" ou "totalisation" (le mot "incrémentation" est à réserver pour le compteur, § suivant). C’est elle qui va nous procurer à la fin le total voulu.
Imaginons que nous ayons un fichier SALARIES dont la structure comprend un champ SALAIRE, contenant bien sûr le salaire. Nous voulons connaître le total des salaires (attention : le jour de l’examen, pour changer, on vous demandera peut-être la masse salariale…).
Variable : TS réel
Début
TS = 0
Ouvrir fichier SALARIES
Lire enregistrement
Répéter tant que non fin de fichier SALARIES
TS = TS + salaire
Lire enregistrement suivant
Fintant
Fermer fichier SALARIES
Écrire "Le total des salaires est :", TS
Fin
Notes :
a- j’ai appelé la variable destinée à recevoir le total des salaires TS pour évoquer "total salaires", mais on pourrait l’appeler TOTSAL, ou simplement T, pour "total", ou CS, ou CUMSAL, pour "cumul salaires" ; certains langages autorisent à l’appeler clairement TOTAL SALAIRES.
b- l’initialisation est ici à 0.
c- remarquez l’emplacement de l’initialisation et de l’accumulation.
Les initialisations ne s’effectuent pas systématiquement à 0, tout dépend du problème traité.
L’initialisation doit être placée AVANT la répétition, pas au début à l’intérieur, sinon le totalisateur sera réinitialisé à chaque tour, et à la fin on n’aura pas le total. Pardon ? Que dites-vous ? "C’est évident !". Ah oui ? On en reparlera en TD, ça sera à mon tour de rigoler…
Pour finir, un conseil général :
Faites toujours très attention en début de programme à ce qu’il n’y ait pas de donnée indésirable dans les diverses zones de mémoire que vous employez.
0.2.6.2.2Les compteurs
Le compteur est un cas particulier de l’accumulateur (à moins que ce ne soit l’inverse : l’accumulateur serait-il une généralisation du compteur ? Allez savoir…) : c’est une variable que le programmeur utilise pour… compter (qui l’eût cru ?) !
J’insiste sur le fait qu’il s’agit bien d’une zone mémoire manipulée par le programmeur, et non pas, en dépit de son nom, d’un dispositif mécanique ou électronique quelconque qui compterait tout seul les éléments auxquels on s’intéresse.
Évident : il suffit d’incrémenter le compteur de 1 à chaque tour !
Reprenons le fichier SALARIES du § précédent. Nous voulons connaître le nombre de salariés (attention : le jour de l’examen, pour changer, on vous demandera peut-être l’effectif du personnel…).
Variable : NBS entier
Début
NBS = 0
Ouvrir fichier SALARIES
Lire enregistrement
Répéter tant que non fin de fichier SALARIES
NBS = NBS + 1
Lire enregistrement suivant
Fintant
Fermer fichier SALARIES
Écrire "Le nombre de salariés est :", NBS
Fin
Note : j’ai initialisé NBS à 0, car cette variable va contenir le nombre de salariés qui vient d’être lu : je lis un enregistrement, puis je le compte (si vous êtes victime des apparences, revoyez le § sur la répétition "tant que" plus haut).
L’incrémentation peut être différente de 1, selon le problème traité. Par exemple, on peut écrire des lignes numérotées de 10 en 10, ou de 20 en 20.
0.2.6.2.3Les témoins
Dans les exemples et exercices que nous avons traités jusqu’à présent figuraient de nombreux tests (conditions). Le fait que, à la sortie de ces tests, le programme se branche sur la séquence "oui" ou sur la séquence "non" dépendait de la valeur de la zone testée, c’est-à-dire in fine du hasard de la présentation des données en entrée, et échappait donc à la volonté du programmeur.
A contrario, il peut parfois être utile de brancher volontairement le déroulement du programme sur telle ou telle séquence.
On se servira pour cela d’une variable employée d’une façon très particulière, et appelée "témoin", ou "indicateur", ou "aiguillage" : le programmeur lui affecte une valeur donnée, ce qui permet d’imposer le résultat d’un test ultérieur, c’est-à-dire d’imposer l’exécution d’une séquence d’opérations dont on a besoin, ou de supprimer l’exécution d’une séquence momentanément indésirable.
Reprenons le fichier SALARIES précédent, et imaginons que le nom soit dans un champ NOM. On veut lister les noms en 2 colonnes de 30 caractères de largeur. Plus précisément, on veut présenter le 1er nom sur la 1ère ligne, colonne de gauche, le 2ème nom sur la 1ère ligne, colonne de droite, le 3ème sur la 2ème ligne, colonne de gauche, le 4ème sur la 2ème ligne, colonne de droite, et ainsi de suite. On supposera que ce champ NOM a une taille de 20 caractères ; il n’y a donc pas de difficulté pour mettre 2 noms sur la même ligne. Mais nous ne le programmerons pas, car nous n'étudierons pas les instructions permettant de se positionner sur la ligne.
Variable T logique (booléen)
Début
Ouvrir fichier SALARIES
Lire enregistrement
T = vrai
Répéter tant que non fin de fichier SALARIES
Si T = vrai
Alors
Écrire NOM en position 1
T = faux
Sinon
Écrire NOM en position 31
T = vrai
Finsi
Lire enregistrement
Fintant
Fermer fichier SALARIES
Fin
Notes :
a- ne pas confondre ma variable T et la constante logique .T. !
b- remarquer l’initialisation de T, qui impose la 1ère sortie du test telle qu’on la veut.
c- remarquer que, dans chaque branche de l’alternative, on "bascule" le témoin pour préparer le tour suivant.
d- remarquer surtout que le témoin ne peut pas changer de valeur sans commande du programmeur.
e- la figure ci-dessus est parfois appelé "bascule", pour une raison évidente (voir c).
Si le témoin ne prend que 2 valeurs, on emploie une variable logique, encore dite "booléenne". Mais on peut fort bien employer une variable numérique, avec les valeurs 0 et 1, ou 1 et 2, ou une variable caractère, avec les valeurs A et B, ou n’importe quoi, du moment qu’on maîtrise ce qu’on fait.
0.2.6.3Conseils
0.2.6.3.1Comprendre ce que représente un algorithme
0.2.6.3.2"Faire tourner" un algorithme
Matériel nécessaire : la feuille sur laquelle figure l’algorithme à "faire tourner", à gauche, une feuille de brouillon à droite, un index gauche, une main droite avec un crayon dedans, mutandis mutatis pour les gauchers, bien entendu.
Processus : tracer sur la feuille de brouillon un tableau avec autant de colonnes qu’il y a de variables dans l’algorithme ; s’imaginer qu’on n’est plus le programmeur en train de concevoir une solution, mais qu’on est l’ordinateur en train d’obéir aux consignes qu’on a précédemment rédigées ; poser l’index gauche au début de l’algorithme ; faire ce qui est écrit, sans chercher à comprendre (pour quelques uns, ce devrait être facile…), et en particulier, si la ligne en cours concerne une variable, écrire dans le tableau la valeur de cette variable ; glisser l’index gauche là où il faut (sur la feuille de l’algorithme !), c’est à dire à la ligne en dessous si on est dans une séquence, à la ligne voulue s’il y a un branchement, par exemple dans une alternative ou une répétition ; à chaque changement de ligne dans l’algorithme, tracer une nouvelle ligne dans le tableau ; continuer ainsi jusqu’à la fin de l’algorithme.
La recette du succès : tenter d’être aussi stupide qu’un processeur INTEL, c’est à dire exécuter les ordres écrits en évitant soigneusement de réfléchir, même et surtout s’ils semblent bizarres.
Application sur en exemple représentatif de ce qu’on vous demandera à l’examen :
Soit l’algorithme :
1 Variables : A, J, P, Z, entiers
2 Début
3 A = 0
4 Z = 1
5 Tant que Z < 5 faire
6 P = A
7 A = A + 1
8 J = P – Z
9 Z = Z + 2
10 Fintant
11 Écrire A, J, P, Z
12 Fin
N.B. J’ai numéroté les lignes pour la commodité des explications qui vont suivre.
Question : que va écrire cet algorithme ?
Allons-y courageusement :
Pour la ligne 1, il n’y a qu’à tracer 4 colonnes et mettre les noms des variables.
Pour la ligne 2, rien à faire.
Ligne 3, on écrit 0 dans la colonne A.
Ligne 4, on écrit 1 dans la colonne Z.
Bien, vous avez compris le principe, je donne l’ensemble ci-dessous :
|
Étape |
Ligne |
Explications |
A |
J |
P |
Z |
|
1 |
1 |
Tracer les colonnes nécessaires pour les 4 variables |
|
|
|
|
|
2 |
2 |
Rien à faire |
|
|
|
|
|
3 |
3 |
Ça commence : on affecte la valeur 0 à A |
0 |
|
|
|
|
4 |
4 |
Idem : valeur 1 à Z |
|
|
|
1 |
|
5 |
5 |
Est-ce que Z est inférieur à 5 ? regardons sa valeur : c’est 1, la réponse est OUI, on passe donc à la ligne 6 |
|
|
|
|
|
6 |
6 |
On donne à P la valeur de A, soit 0 |
|
|
0 |
|
|
7 |
7 |
On additionne 1 à la valeur de A, d’où 1 |
1 |
|
|
|
|
8 |
8 |
On calcule J, soit 0 moins 1, soit –1 |
|
-1 |
|
|
|
9 |
9 |
On calcule la nouvelle valeur de Z soit 1 + 2 |
|
|
|
3 |
|
10 |
10 |
Le fintant nous renvoie à la ligne 5 |
|
|
|
|
|
11 |
5 |
Est-ce que Z est inférieur à 5 ? regardons sa valeur : c’est 3, la réponse est OUI, on passe donc à la ligne 6 |
|
|
|
|
|
12 |
6 |
P prend la valeur de A, soit 1 |
|
|
1 |
|
|
13 |
7 |
On additionne 1 à la valeur de A, d’où 2 |
2 |
|
|
|
|
14 |
8 |
On calcule J, soit 1 moins 3, soit –2 |
|
-2 |
|
|
|
15 |
9 |
On calcule la nouvelle valeur de Z soit 3 + 2 |
|
|
|
5 |
|
16 |
10 |
Le fintant nous renvoie à la ligne 5 |
|
|
|
|
|
17 |
5 |
Est-ce que Z est inférieur à 5 ? regardons sa valeur : c’est 5, attention au piège ! 5 n’est pas inférieur à 5 ! La réponse est NON, on passe donc à la ligne 11 |
|
|
|
|
|
18 |
11 |
On nous demande d’écrire les valeurs des variables : il suffit de regarder dans notre tableau la dernière valeur de chaque colonne. L’ordinateur écrira donc : 2,-2,1,5 |
|
|
|
|
|
19 |
12 |
C’est fini, on pousse un soupir de soulagement ! |
|
|
|
|
Pardon, que dites-vous ? "C’est débile, cet exo !" ? Vouais, on sait, on sait ! Si vous avez mieux, ne vous gênez surtout pas, on vous en sera reconnaissants ! Et vos petits camarades qui souffrent dessus le jour de l’examen aussi !
0.2.6.3.3Les principes de la PS
Respecter les principes de la PS.
0.2.6.3.4Recettes
Optimisation : ordonner les tests dans l’ordre des fréquences décroissantes.
Exemple :
Dans l’exercice de la comparaison de 2 noms, il est vraisemblable que le cas de 2 noms identiques est le moins fréquent. Si l’opération doit être répétée un très grand nombre de fois, il est clair qu’il faut mettre le cas d’égalité en dernier pour que le programme s’exécute plus vite :
Selon cas
Cas NOMA < NOMB
Écrire NOMA, NOMB
Cas NOMA > NOMB
Écrire NOMB, NOMA
Autres cas
Écrire "Les 2 noms sont identiques"
Fincas
0.2.6.3.5Pour bâtir un algorithme
0.2.6.3.6Définitions provenant de dBASE
Rappels et compléments provenant de l’aide de dBASE :
fichier bibliothèque
Un fichier où sont stockées les procédures et les fonctions pour être utilisées par d'autres programmes. Les programmeurs créent souvent des fichiers bibliothèques contenant des sous-programmes fréquemment utilisés.
fonction
Un sous-programme qui renvoie une valeur. Les fonctions consistent en un mot réservé, suivi de parenthèses, qui peut contenir des arguments.
fonction utilisateur
Une fonction créée avec une commande FUNCTION contenant d'autres commandes ou fonctions. Vous pouvez réduire la taille du programme et améliorer la fiabilité en consolidant des séquences de commandes fréquemment utilisées en fonctions utilisateur.
procédure
Un groupe nommé de commandes commençant par PROCEDURE. Vous pouvez réduire la taille d'un programme et améliorer la modularité en consolidant des séquences de commandes fréquemment utilisées dans des procédures.
sous-programme
Un groupe de commandes effectuant une tâche spécifique. Les programmeurs créent des sous-programmes pour organiser et augmenter la modularité de leur code. Les sous-programmes incluent des procédures, des fonctions utilisateur et des blocs de code.
constante
Une valeur littérale que vous affectez à un champ ou à une variable mémoire.
variable mémoire
Un emplacement nommé en mémoire dans lequel vous stockez des valeurs telles que des chaînes, des nombres et des dates. Les programmeurs créent des variables mémoire (aussi appelées variables) pour stocker temporairement des valeurs pour les calculs et autres opérations. La commande STORE affecte des valeurs aux variables mémoire.
fenêtre active
La fenêtre ayant la focalisation. Plusieurs fenêtres peuvent être ouvertes en même temps, mais une seule peut avoir la focalisation à un instant donné.
fenêtre de l'application
La principale fenêtre apparaissant lorsqu'une application est lancée. La barre de menus de l'application et la barre d'état font partie de la fenêtre application. Les fenêtres d'application peuvent contenir d'autres fenêtres. Par exemple, la fenêtre d'application Visual dBASE contient les fenêtres Navigateur et Commande.
fenêtre modale
Une fenêtre qui, lorsqu'elle est activée, prend le contrôle de l'interface utilisateur. L'utilisateur ne peut pas basculer sur une autre fenêtre sans quitter la fenêtre modale. Les boîtes de dialogue sont des exemples de fenêtres modales ; lorsqu'une boîte de dialogue est ouverte, vous ne pouvez pas effectuer d'autres actions en dehors d'elle jusqu'à ce qu'elle soit fermée.
fenêtre non modale
Une fenêtre qui ne requiert pas d'interaction exclusive de la part de l'utilisateur. Un utilisateur peut ouvrir plusieurs fenêtres non modales et passer de l'une à l'autre dans une application.
focalisation
Un contrôle ou une fenêtre a la focalisation lorsque l'utilisateur le sélectionne. Dans une interface événementielle, où de nombreuses fenêtres et contrôles apparaissent à l'écran, un seul peut avoir la focalisation à un moment donné. Lorsqu'un objet a la focalisation, vous pouvez choisir une action à effectuer sur cet objet.
formulaire
Une fenêtre contenant les contrôles pour l'affichage ou l'édition de données. Les formulaires sont créés visuellement avec le concepteur de formulaire.
formulaire MDI
Une fenêtre MDI (Multiple Document Interface) contenant les fonctionnalités standard de Windows MDI, dont un titre de fenêtre, la case de menu système, les boutons Agrandir et Réduire et des menus. Les fenêtres MDI sont dimensionnables et peuvent être déplacées.
interface à documents multiples (MDI)
Un standard Windows qui permet à une application de gérer plusieurs fenêtres ou vues d'un même document dans la fenêtre principale de l'application. Dans Visual dBASE, vous pouvez avoir plusieurs fenêtres (fenêtre Commande, Navigateur, Concepteur de table, etc.) ouvertes en même temps.
requête
Une question que vous posez sur les informations d'une table. Créez une requête en utilisant le concepteur de requête pour construire un modèle des informations souhaitées : quelles tables vous voulez, quels enregistrements de ces tables et quels champs de ces enregistrements. Exécutez ensuite la requête pour créer une vue des données. Lorsque vous lancez la requête, dBASE génère et exécute le code nécessaire pour sélectionner et organiser les informations requises. Lorsque vous sauvegardez une requête, les commandes dBASE sont stockées dans un fichier .QBE.
vue (requête)
Une sélection de données organisées provenant d'une ou de plusieurs tables. Les détails d'une vue sont définis dans une requête. Les détails d'une requête incluent l'ordre des champs, celui des enregistrements, la sélection d'enregistrements et certains calculs. Lorsqu'une requête est exécutée, les données apparaissent dans la fenêtre Enregistrements où elles peuvent être visualisées et bien souvent éditées. Une vue est une table virtuelle. C'est-à-dire qu'elle n'existe qu'en mémoire et est supprimée de la mémoire lorsque la requête est fermée.
code source
Les commandes ou les instructions sous une forme lisible. Les fichiers programmes (.PRG) sont un exemple de code source. Les programmeurs écrivent du code source et le compilent en code objet lisible par la machine.
fichier programme
Un fichier texte contenant des commandes dBASE. Les fichiers programmes ont des extensions .PRG par défaut. Vous pouvez créer des programmes avec n'importe quel éditeur de texte. La commande MODIFY COMMAND permet aussi de créer un programme.
0.2.6.4Exercices
Après les 2 exos compter nb et comptr tot, calculer moyenne, et montrer fusion des 2 pg
Adapter l’algorithme du décompte du nombre de salariés en initialisant NBS à 1. Attention au petit piège…
Compter jq N donné par l’utilisateur non
Compter de tant en tant non
Décompter : je vais m’arrêter dans…………..
On a placé l’initialisation d’un totalisateur au début à l’intérieur d’une répétition. Quelle est la valeur de ce totalisateur à la fin ?
Totalisateurs : total des débits et des crédits dans le fichier des locataires
Compteurs : compter le nombre de locataires
Salaire moyen : récupérer et fusionner les 2 programmes précédents calculant l'effectif et le total des salaires
Salaire des H, des F…………
L'exercice suivant est un simple exercice de raisonnement. Nous ne le programmerons pas, car nous n'étudierons pas les instructions permettant de se positionner sur la ligne. Nous nous bornerons à l'algorithme.
Listage des noms sur 3 colonnes : on reprend le fichier SALARIES précédent. On veut lister les noms en 3 colonnes. Plus précisément, on veut présenter le 1er nom sur la 1ère ligne, colonne de gauche, le 2ème nom sur la 1ère ligne, colonne du milieu, le 3ème sur la 1ère ligne, colonne de droite, le 4ème sur la 2ème ligne, colonne de gauche, et ainsi de suite.
0.2.7Exercices
0.2.7.1Énoncés
Le "jeu idiot" se joue à 2 (à la différence du jeu du cochonnet, qui se joue à Troyes) : le premier joueur choisit un nombre arbitrairement (en T.D., ne prenez pas un nombre trop grand !) et l’introduit dans l’ordinateur ; le second joueur doit trouver ce nombre en tapant des essais successifs, l’ordinateur lui indiquant à chaque fois "c’est plus", ou "c’est moins", ou "vous avez gagné" (attention à la formulation de l’énoncé !).
On "améliore" par étapes l’exercice précédent de la façon suivante : on va indiquer en combien de coups le 2ème joueur a gagné (version 2) ; puis on va émettre un commentaire plus ou poins agréable ou désagréable sur ses capacités intellectuelles, selon le nombre d’essais qu’il lui aura fallu (version 3) ; on vérifiera ensuite que la valeur à trouver est positive et ne dépasse pas une valeur raisonnable, par exemple 100, sinon la recherche serait trop longue (version 4) ; enfin on veut jouer seul, on fera générer le nombre à deviner aléatoirement par le programme (version 5).
Complétez l’algorithme du "Calcul de soldes version 4" avec une répétition et une fin de traitement.
Équation du second degré (racines réelles), PPCM, PGCD, factorielle, liste des N nombres premiers, partie entière, modulo, valeur absolue, recherche, dans une liste de N valeurs tapées au clavier ou lues dans un fichier, du minimum, du maximum, des 2.
Sortir la table de multiplication demandée, les sortir toutes, jeu "vous enseignez la multiplication à votre petit frère".
0.2.7.2Corrigés
0.2.7.2.0.1Algorithme
Variables : NB1, NB2 : entiers
Début
Écrire "1er joueur, tapez un nombre :"
Lire NB1
Effacer l’écran
Écrire "2ème joueur, tapez un essai :"
Lire NB2
Tant que NB2 <> NB1 faire
Si NB2 > NB1
Alors
Écrire "C’est moins !"
Sinon
Écrire "C’est plus !"
Finsi
Écrire "2ème joueur, tapez un essai :"
Lire NB2
Fintant
Écrire "Vous avez gagné !"
Fin
Note : ne pas oublier d’effacer l’écran avant que le 2ème joueur ne commence ses essais !
0.2.7.2.0.2dBASE interface texte
0.2.7.2.0.3dBASE interface fenêtre
0.2.7.2.0.4Paradox
0.2.7.2.0.5Lotus
0.2.7.2.0.6Access
0.2.7.2.0.7WordBasic 7
0.2.7.2.0.8Excel 7
Version 2 :
Variables : NB1, NB2, NBC : entiers
Début
Écrire "1er joueur, tapez un nombre :"
Lire NB1
Effacer l’écran
Écrire "2ème joueur, tapez un essai :"
Lire NB2
NBC = 1
Tant que NB2 <> NB1 faire
Si NB2 > NB1
Alors
Écrire "C’est moins !"
Sinon
Écrire "C’est plus !"
Finsi
Écrire "2ème joueur, tapez un essai :"
Lire NB2
NBC = NBC + 1
Fintant
Écrire "Vous avez gagné en", NBC, "essais !"
Fin
Version 3 :
………
Fintant
Selon cas
Cas NBC = 1
Écrire "Vous avez gagné du 1er coup ! Avez-vous triché ?"
Cas NBC < 5
Écrire "Vous avez gagné en", NBC, "essais, bravo !"
Cas NBC < 10
Écrire "Vous avez gagné en", NBC, "essais, vous êtes moyen !"
Cas NBC < 15
Écrire "Vous avez gagné en", NBC, "essais, vous êtes faible !"
Autres cas
Écrire "Il vous a fallu", NBC, "essais pour gagner, vous êtes vraiment nul !"
fincas
Fin
Version 3 bis :
……………….
Cas NBC < 10
Écrire "Vous avez gagné en", NBC, "essais, vous êtes moyen !"
Cas NBC < 15
Écrire "Vous avez gagné en", NBC, "essais, vous êtes faible !"
Cas NBC < 20
Écrire "Il vous a fallu", NBC, "essais pour gagner, vous êtes vraiment nul !"
Autres cas
Écrire "C’était votre 20ème essai, et vous n’avez toujours pas trouvé !"
Écrire "Vous êtes vraiment trop nul, j’abandonne ! ! !"
Arrêt du programme
fincas
Fin
Note : remarquez qu’on peut arrêter le programme à l’intérieur de l’alternative, et retourner soit sous l’application, soit sous le système (quitter l’application qui hébergeait le programme et revenir sous Windows).
Version 4:
Variables : NB1, NB2, NBC : entiers
Début
Écrire "1er joueur, tapez un nombre :"
Lire NB1
Si NB1 <=0
Alors
Écrire "Vous avez tapé un nombre négatif ou nul, je le porte à 1"
NB1 = 1
Sinon
Si NB1 > 100
Alors
Écrire "Vous avez tapé un nombre supérieur à 100, je le ramène à 100"
NB1 = 100
Finsi
Finsi
………..
Version 4 bis :
…………..
Lire NB1
Si NB1 <=0
Alors
Écrire "Vous avez tapé un nombre négatif ou nul, je le porte à 1"
NB1 = 1
Finsi
Si NB1 > 100
Alors
Écrire "Vous avez tapé un nombre supérieur à 100, je le ramène à 100"
NB1 = 100
Finsi
………..
Version 4 ter :
…………..
Lire NB1
Selon cas
cas NB1 <=0
Écrire "Vous avez tapé un nombre négatif ou nul, je le porte à 1"
NB1 = 1
Cas NB1 > 100
Écrire "Vous avez tapé un nombre supérieur à 100, je le ramène à 100"
NB1 = 100
Fincas
………..
Version 5 :
Variables : NB1, NB2, NBC : entiers
Début
NB1 = aléatoire(1, 100)
Écrire "Tapez un essai :"
………….
Note : si le langage que vous employez possède une fonction qui crée des nombres au hasard compris entre 2 bornes données, ici il vous faut évidemment 1 et 100, sinon (entre 0 et 1) voir astuce plus haut.
0.3Algorithmie et programmation améliorées
0.3.1Un menu pour s’ouvrir l’appétit
Pour aborder la vraie programmation, il faut préalablement absorber tout un fatras de trucs peu ragoûtants. Je commence donc en guise d’apéritif par un amuse-gueule amusant, la réalisation d’un menu, pour ne pas vous décourager avant même les hors d’œuvres !
Si vous avez travaillé consciencieusement, vous devez maintenant posséder un bon nombre de programmes dans votre répertoire d’exercices : rectangle, cercle, bonjour, comparaison des noms et des dates, calcul de soldes, compter, le jeu idiot, etc., la plupart avec leurs variantes.
Nous allons établir un menu appelant quelques uns de ces programmes (il n'est pas utile de les appeler tous, l'essentiel est de comprendre la principe de fonctionnement).
Rappels :
1- pour tous les langages, il peut y avoir des différences, parfois importantes, selon la version utilisée. En particulier, il y a des différences entre dBASE 5, dBASE 5.5 (les versions disponibles dans les salles de TD), et dBASE Plus (la version commercialisée depuis 2002).
2- le résultat est le même, mais les différences sont importantes entre la programmation classique et la programmation orientée objets.
0.3.1.1Un menu pour nos exos
Nous allons donc réaliser un programme affichant un menu offrant les principaux programmes que nous avons déjà écrits : bonjour, rectangle, comparaison de 2 noms, calcul de soldes, dans leur version 1.
Attention : pour que tout fonctionne bien, il est indispensable que vous ayez sauvegardé tous vos exercices dans le même répertoire !
0.3.1.1.1Programmation classique et interface texte
L’algorithme de principe a déjà été donné ci-dessus, dans la chapitre sur les répétitions infinies :
Début du programme
Répéter tant que vrai
Afficher un menu proposant des choix et demandant de taper un code (lettre ou chiffre) pour indiquer ce choix
Lire la réponse
Avec un "selon cas", appeler pour chaque réponse prévue un sous-programme particulier adapté à cette réponse
Fintant
Fin du programme
Menu pour nos exos :
Début
Variable rep caractères
Tant que VRAI faire
Afficher texte
MENU POUR MES EXERCICES
Vous pouvez choisir :
A bonjour
B rectangle
C comparaison de 2 noms
D soldes
Y retour sous dBASE
Z retour sous système
Fin texte
Écrire "Tapez la lettre correspondant à votre choix :"
Lire rep
Selon cas
Cas rep = "A"
Appel BONJOUR
Cas rep = "B"
Appel RECTGL
Cas rep = "C"
Appel COMPNOM1
Cas rep = "D"
Appel SOLDES1
Cas rep = "Y"
Retour
Cas rep = "Z"
Quitter
Autres cas
Écrire "Erreur de frappe, recommencez."
Fin cas
Fin tant
Fin
0.3.1.1.2Programmation orientée objets et interface fenêtre
Rappel : le principe est d’établir un formulaire, de disposer dessus les contrôles nécessaires, dans le cas présent des appels à nos exercices, et d’établir les liaisons entres les contrôles et les programmes d’exercices déjà écrits.
0.3.1.2Menu dBASE interface texte
Rappels, une fois de plus, et certainement une fois de plus pour rien :
a- commencer par bien choisir le répertoire de travail, dans le Navigateur : soit le répertoire "EXOSDB" sur la disquette, soit le répertoire temporaire du disque dur ;
b- même sous dBASE 5.5, utiliser uniquement des noms MS/DOS.
Programme :
Do while .T.
text
MENU POUR MES EXERCICES
Vous pouvez choisir :
A bonjour
B rectangle
C comparaison de 2 noms
D soldes
Y retour sous dBASE
Z retour sous système
endtext
accept "Tapez la lettre correspondant à votre choix :" to rep
do case
case rep = "A"
do BONJOUR
case rep = "B"
do RECTGL
case rep = "C"
do COMPNOM1
case rep = "D"
do SOLDES1
case rep = "Y"
return
case rep = "Z"
quit
otherwise
? "Erreur de frappe, recommencez."
endcase
enddo
0.3.1.3Menu dBASE interface fenêtre "Débutants"
Mêmes rappels que ci-dessus.
Le principe consiste à créer un menu, comportant plusieurs choix, puis à indiquer pour chaque choix la procédure à exécuter, enfin à affecter ce menu à un formulaire que l’utilisateur pourra employer selon les habitudes standard sous Windows.
Attention, il y a malheureusement quelques différences entre dBASE 5.5 et dBASE 5.
0.3.1.3.1Nul salut hors le formulaire
Extraits de l’aide :
Les formulaires sont des fenêtres qui affichent des messages et des données en réponse aux entrées des utilisateurs. Ces fenêtres sont dotées d'éléments d'interaction tels que les menus, les boutons et les barres de défilement. Vous pouvez générer des écrans de saisie simples utilisant une ou plusieurs tables. Les formulaires permettent aussi de générer l'interface utilisateur complète d'une application complexe.
Lorsque vous créez un formulaire, vous commencez avec une fenêtre formulaire vide. Vous devez ensuite sélectionner et placer des objets tels que des champs de saisie, des boîtes listes et des cases à cocher. Visual dBASE dispose de la plupart des objets Windows standard. Le formulaire et les contrôles qu'il contient sont des objets.
0.3.1.3.2Création du menu
0.3.1.3.2.1Ouverture du "Concepteur de menu"
- Sous dBASE 5.5 : Fichier | Nouveau | Menu ; on a directement le "Concepteur de menu".
- Sous dBASE 5 : Fichier | Nouveau | Formulaire, on obtient la boite "Expert formulaire" ; Formulaire vierge | Créer, on obtient le "Concepteur de formulaire" ; Disposition | Outils ; Cliquer sur "Concevoir un menu" ; on obtient le "Concepteur de menu".
0.3.1.3.2.2 Intitulés des menus et des choix
- La fenêtre "Concepteur de menu" est la fenêtre du futur menu ; taper l’intitulé du menu :
Débutants
dans la case de saisie (le rectangle dans lequel clignote la barre verticale du pointeur, à gauche en dessous de la barre de titre), puis Entrée.
- Une autre case de saisie apparaît en dessous de "Débutants" ; taper :
bonjour
puis Entrée ; une nouvelle case de saisie apparaît en dessous de "bonjour" ; taper :
rectangle
puis Entrée, et continuer ainsi pour tous les programmes qu’on veut pouvoir lancer par ce menu.
0.3.1.3.2.3 Procédures
- Il faut maintenant affecter une procédure à chaque choix du menu.
- Revenir sélectionner le 1er choix, (dans notre exemple : "Rectangle") ; sous dBASE 5 : clic droit sur "Rectangle" dans le "Concepteur de menu", ou Vue (dans la barre de menus de dBASE), pour voir si la ligne "Propriétés de l’objet" est cochée ; si non, la cocher, puis faire passer la fenêtre "Propriétés" en avant par le menu "Fenêtre" de dBASE ; sous dBASE 5.5 : mêmes manœuvres, mais cette fenêtre s’appelle "Inspecteur" au lieu de "Propriétés".
- Dans cette fenêtre "Propriétés", ou "Inspecteur", activer l’onglet "Événements" (l’onglet sélectionné est sur fond gris, les autres sur fond blanc) ; activer l’événement "On_Click" ou "OnClick" ; la moitié droite du rectangle devient blanche ; cliquer sur l’outil apparu à droite de ce rectangle blanc : cela ouvre une fenêtre "Procédures" sous dBASE 5, "Éditeur de procédure" sous dBASE 5.5, avec "OnClick" ou "On_Click" dans le rectangle à haut à gauche juste en dessous de la barre de titre.
- Variante à employer préférentiellement : 2-cliquer sur le choix pour faire apparaître la fenêtre de procédure (en effet, vous verrez plus loin dans les manœuvres que Vue | Procédures ou clic droit | Procédures ne donnent pas forcément l’accès directement à la procédure voulue, il faut selon les cas la chercher dans le rectangle blanc en haut à gauche).
- Variante sous dBASE 5.5 :le clic droit ou Vue (cf. 3 alinéas plus haut) donne l’accès à l’"Éditeur de procédure".
- Dans la fenêtre de procédure, taper la procédure sur le modèle suivant :
close forms
do NOMDUPROGRAMMEVOULU.PRG
wait
do JOLIFORM.WFM
puis fermer la fenêtre de procédure.
- Répéter ces opérations pour chaque choix.
- Par exemple pour le programme BONJOUR.PRG, la procédure est :
close forms
do BONJOUR
wait
do JOLIFORM.WFM
0.3.1.3.2.4 Enregistrement du menu
- Fichier | Enregistrer sous (rappel bis : vérifier qu’on est dans le bon répertoire ! ! !), donner le nom JOLIMENU au menu ; remarquer que la fenêtre du "Concepteur de menu" affiche maintenant le titre "JOLIMENU" dans la barre de titre, au lieu de "Sans titre" ; fermer le "Concepteur de menu", ce qui ferme aussi les fenêtres associées, et sous dBASE 5 on retrouve le "Concepteur de formulaire Sans titre".
0.3.1.3.3 Création du formulaire de base et affectation du menu
- Sous dBASE 5.5, ouvrir à nouveau le "Concepteur de formulaire" : Fichier | Nouveau | Formulaire, puis dans la fenêtre "Nouveau formulaire", cliquer sur "Concepteur" ; sous dBASE 5, la question ne se pose pas car lorsqu’on a fermé le "Concepteur de menu", on s’est retrouvé dans le "Concepteur de formulaire Sans titre".
- sous dBASE 5 : clic droit | Propriétés de l’objet dans le "Concepteur de formulaire", ou Vue | Propriétés des objets, pour voir si la ligne "Propriétés de l’objet" est cochée ; si non, la cocher, puis faire passer cette fenêtre "Propriétés" en avant par le menu "Fenêtre" de dBASE. Sous dBASE 5.5 activer l’"Inspecteur" de façon analogue.
- Dans cette fenêtre, activer l’onglet "Propriétés" ; si la propriété "Fenêtre" est précédée d’un signe "+", 2-cliquer dessus pour ouvrir le détail de la propriété "Fenêtre" (noter que le signe "+" se transforme en signe "-") ; activer la propriété "MDI" et la mettre à ".F." ; activer la propriété "MenuFile", cliquer sur l’outil qui apparaît à droite ; il apparaît une fenêtre appelée "Constructeur de propriété" sous dBASE 5.5, et "Choix d’un menu" sous dBASE 5 ; choisir le menu voulu, ici JOLIMENU, puis "OK" ; activer la propriété "Text" et taper le titre qu’on veut donner au formulaire :
Mon joli formulaire
- Fichier | Enregistrer sous, donner le nom JOLIFORM au formulaire, puis le fermer.
0.3.1.3.4 Exécution du formulaire de base
- On peut préalablement agrandir la fenêtre de commande, ce qui permettra de mieux voir l’exécution, puisque tous les programmes de ce menu ont été écrits pour être exécutés en mode commande.
- Lancement : on lance l’exécution du formulaire "JOLIFORM.WFM" comme celle d’un programme dBASE, soit à partir du Navigateur si dBASE est déjà ouvert (sélectionner "Formulaires" à gauche, puis 2-cliquer sur "JOLIFORM.WFM" à droite), soit, si dBASE est fermé, directement à partir de l’Explorateur (2-cliquer sur "JOLIFORM.WFM").
- On voit avec émerveillement apparaître une fenêtre intitulée "Mon joli formulaire", avec "Débutants" dans la barre des menus ; on l’utilise comme n’importe quelle application Windows.
- Attention : ne pas oublier d’appuyer sur une touche quelconque pour revenir au menu, après l’exécution du module qu’on a choisi, à cause du "wait" introduit dans chaque procédure.
0.3.1.3.5 Différence entre dBASE 5 et dBASE 5.5
- La différence essentielle entre dBASE 5 et dBASE 5.5 (pour ce que nous venons de faire) est que sous dBASE 5 il faut transiter par le "Concepteur de formulaire" puis Disposition | Outils | Concevoir un menu pour accéder au "Concepteur de menu", alors que sous dBASE 5.5 on l’a directement par Fichier | Nouveau | Menu.
- Cependant, la démarche d’ensemble est la même.
0.3.1.4 Menu dBASE "Comme les pros"
Nous allons améliorer notre menu.
Nous en profiterons pour programmer un autre exercice.
Préalablement, créez une table ETUD, avec les champs NOM (20 C), NOTEINFO (4 N 1 décimale), NOTEPCENT (idem) et NOTEFIXE (idem). Tapez quelques lignes de données pour les champs NOM et NOTEINFO (évidemment rien dans NOTEPCENT et NOTEFIXE).
Ce programme pourra servir à des profs qui veulent pouvoir tester différentes hypothèses d’augmentation (ou de diminution !) des notes, par le biais soit d’un pourcentage soit d’un nombre de points fixe, en vue d'harmoniser leur notation sur différents groupes d'étudiants.
0.3.1.4.1 Ajout du menu "Comme les pros"
- Pour modifier un menu dans un formulaire : sous dBASE 5, dans le Navigateur, sélectionner "Tous" ou "Personnalisé" (tout en bas) à gauche, puis sélectionner le menu voulu à droite. Ensuite, soit Navigateur | Conception de menu, soit clic droit | Conception de menu ; sous dBASE 5.5, le menu apparaît dans la catégorie "Formulaires" du "Navigateur", et on peut 2-cliquer dessus.
- Donc, ouvrir JOLIMENU.MNU en mode conception, et vérifier que le pointeur (barre verticale clignotante) est bien sur "Débutants" (sinon, l’y mettre).
- TAB, ce qui ouvre un autre rectangle à droite du 1er, et rebelote : frapper :
Comme les pros
comme menu, puis :
Etudiants
comme 1er choix (on pourra en ajouter d’autres ultérieurement), puis TAB pour créer un sous choix en cascade d’Etudiants ; taper un 1er sous choix :
Note pourcentage
avec comme procédure :
close forms
do POURCENT.WFM
puis créer un 2ème sous choix :
Note fixe
en dessous de "Note pourcentage"
avec comme procédure :
close forms
do FIXE.WFM
- Sauvegarder les modifs, et fermer JOLIMENU, par exemple par Fichier | Enregistrer et fermer.
- créer un formulaire POURCENT.WFM.
- Dans ce formulaire, faire apparaître la fenêtre "Contrôles" comme vu plus haut pour la fenêtre "Propriétés" ou "Inspecteur" ; sous dBASE 5.5, dans Vue ou par le clic droit, il faut activer "Palette des contrôles" ; cliquer sur "Champ de saisie", dans la fenêtre des contrôles, onglet "Standard" ; revenir sur le formulaire, le pointeur se transforme en signe + ; appuyer sur le bouton gauche et maintenir appuyé pour dessiner un rectangle ; lâcher le bouton : le rectangle devient blanc, avec "Saisie1" en haut à gauche.
- Les carrés noirs aux angles et aux milieux des cotés de ce rectangle montrent qu’il est sélectionné ; les "Contrôles" ou "Palette des contrôles", "Propriétés de l’objet" ou "Inspecteur" et "Procédures" ou "Éditeur de procédure" figurant dans "Vue" ou par le clic droit sont ceux de l’objet sélectionné ; faire passer la fenêtre "Propriétés" / "Inspecteur" devant par le menu "Fenêtre", puis onglet "Propriétés" de cette fenêtre ; vérifier que dans le rectangle blanc juste en dessous de la barre de titre bleue on a "form.saisie1" ; activer la propriété "Value", taper :
Tapez le pourcentage d’augmentation :
à la place de "Saisie1", puis Entrée : le fond jaune devient bleu.
- Cliquer dans le gris du formulaire pour désélectionner le rectangle de saisie et sélectionner le formulaire lui-même ; les "Contrôles", "Propriétés de l’objet" et "Procédures" cochés sont alors ceux du formulaire lui-même ; activer la fenêtre "Propriétés" / "Inspecteur", puis onglet "Propriétés", activer "Text" et taper :
Saisie du pourcentage
- Onglet "Evénements", activer "On_Change", cliquer sur la clef (à droite), puis dans la fenêtre "Procédure" qui s’ouvre, taper la procédure suivante :
WPOURCENT = this.Saisie1.Value
WPOURCENT = val(WPOURCENT)
use ETUD
do while .not. eof()
replace NOTEPCENT with NOTEINFO * (1+ WPOURCENT / 100)
do case
case NOTEPCENT > 20
replace NOTEPCENT with 20
case NOTEPCENT < 0
replace NOTEPCENT with 0
endcase
skip
enddo
close forms
browse
use
do JOLIFORM.WFM
- En prévision de la frappe de la procédure "FIXE", qui sera très similaire, sélectionner la totalité de cette procédure, puis Edition | Copier, ou clic droit | Copier.
- Évidemment, enregistrer ce formulaire sous le nom "POURCENT.WFM" et le fermer.
- De la même façon, mutandis mutatis, créer le formulaire FIXE.WFM ; son titre :
Saisie du nombre de points
son message :
Tapez le nombre de points :
sa procédure :
WFIXE = this.Saisie1.Value
WFIXE = val(WFIXE)
use ETUD
do while .not. eof()
replace NOTEFIXE with NOTEINFO + WFIXE
do case
case NOTEFIXE > 20
replace NOTEFIXE with 20
case NOTEFIXE < 0
replace NOTEFIXE with 0
endcase
skip
enddo
close forms
browse
use
do JOLIFORM.WFM
- Expérimenter JOLIFORM.WFM, et pousser des hurlements d’admiration.
- Notez que nous n’avons pas mis de "wait" dans les procédures de ce menu "Comme les pros".
- Dans "JOLIMENU", ajouter un menu "Fin", avec les choix "Retour sous dBASE" et "Retour sous Windows".
- Procédure de "Retour sous dBASE" :
close forms
- Procédure de "Retour sous Windows" :
quit
- Expérimenter, et compléter son C.V. par :
Certifié Programmeur Expert sous dBASE.
0.3.1.4.2 Mieux que les pros
- Ouvrir "JOLIFORM.WFM" en mode conception et activer ses Propriétés / Inspecteur | Evénements ; activer OnOpen, cliquer sur l’outil, taper la procédure :
shell(.f.)
activer OnClose (toujours dans Propriétés | Evénements) et taper la procédure :
shell(.t.)
activer Propriétés | Propriétés, développer si besoin la propriété "Fenêtre", régler "MDI" à ".f.".
- Sauvegarder les modifs.
- Pour que le résultat soit plus frappant, réduire toutes les applications en cours dans la barre des tâches, ou les fermer.
- Lancer l’exécution, et appeler les voisins pour les épater.
- Attention : dans le contexte de ces petits exemples, prendre bien soin de manœuvrer avec précaution.
- Variante : dans Propriétés | Propriétés | Fenêtre | WindowState, sélectionner "2- Agrandi" au lieu de "0- Normal".
- Sauvegarder, exécuter, et s’évanouir d’admiration.
0.3.1.5Menus dans les autres langages
0.3.1.5.1Paradox
0.3.1.5.2Lotus
0.3.1.5.3Access
0.3.1.6Exercices
Faire des menus à 2 niveaux : au niveau 1, menu offrant le choix entre différentes catégories : calculs géométriques, bonjour, dates, soldes. Puis chaque choix dans ce menu (niveau 1) affichera un sous-menu (niveau 2) proposant les possibilités : rectangle, cercle, sphère, etc. pour les calculs géométriques, les différentes versions de bonjour, les différentes versions des dates, les différentes versions des soldes.
0.3.2Algorithmie améliorée
Var globales, locales
Var indicée, vecteurs, tables
Procédure et avatars, blocs
0.3.3Les langages et les programmations
0.3.3.1Les programmations
Langage (ou programmation) :
- libre (règne du GOTO)
- structuré (mort du GOTO…)
- procédural
- évènementiel
- objet, ou orienté objet
- joyeux mélange de toutes ces notions.
0.3.3.2Les avatars du programme
Définition d'une macro (Lotus)
Une macro est une commande simple exécutant une séquence d'instructions. Vous pouvez la nommer, générer des tâches en utilisant une séquence de commandes et l'affecter à un événement qui l'exécute. Cliquer sur un bouton ou appuyer sur un ensemble de touches particulier constituent des événements courants.
Intérêt d'une création de macro
Les macros simplifient votre travail en automatisant les tâches répétitives. Des macros reliées entre elles permettent également d'automatiser des séquences de tâches complexes. Elles permettent d'accomplir les tâches suivantes :
• automatisation des procédures exécutées habituellement à partir du clavier ou de la souris, telles que la modification de la couleur du texte ;
• exécution des tâches complexes et des procédures de programmation telles que les boucles et les instructions Si-alors-sinon ;
• aide aux utilisateurs non familiarisés avec Approach par l'intermédiaire de tâches et d'applications que vous générez et contrôlez.
Exemple
Vous pouvez utiliser une macro pour exécuter une tâche simple, comme le passage d'un formulaire à un état, ou pour exécuter plusieurs tâches impliquant par exemple, la recherche de toutes les factures impayées, leur tri par date et par ordre croissant, le chargement et l'impression d'une lettre type.
Première étape de la création d'une macro
Définissez de manière très précise la tâche que vous destinez à la macro. Si cette tâche est complexe, exécutez-la et notez bien toutes les étapes nécessaires à sa réalisation. Lorsque vous avez compris ce qu'elle met en oeuvre, vous êtes prêt à créer la macro.
Macro-commande (dBASE)
Une macro-commande est une action ou un événement utilisable dans une instruction. Les commandes Supprimer, Exécuter, Enregistrer, Modifier et Fermer font partie des commandes courantes.
Script (Microsoft)
Un script est un fichier-texte qui contient une série de commandes, de paramètres et d'expressions. Un fichier script peut être créé à l'aide de n'importe quel éditeur de texte tel que Bloc-notes de Microsoft.
Un script doit comporter une procédure principale MAIN, spécifiée par le mot clé proc et le mot clé endproc correspondant pour marquer la fin de la procédure.
Vous devez déclarer des variables avant d'ajouter des commandes. La première commande dans la procédure principale est exécutée, et toutes les commandes suivantes sont exécutées dans l'ordre où elles apparaissent dans le script. Le script se termine à la fin de la procédure principale.
proc nom
Marque le début d'une procédure. Chaque script doit avoir une procédure principale (proc main). L'exécution du script commence au début de la procédure MAIN et se termine à la fin de celle-ci.
endproc
Marque la fin d'une procédure. Lorsque le script est exécuté jusqu'à l'instruction endproc de la procédure MAIN, l'accès réseau à distance démarre PPP ou SLIP.
Un type de données permettant de stocker des petits groupes sans nom de commandes ou d'expressions. Les blocs de code vous permettent de fonctionner avec du code programme comme s'il s'agissait de données, vous pouvez affecter des blocs de code aux variables mémoire ou aux propriétés des objets. Un bloc de code est délimité par des accolades ({ }).
0.3.3.3Les concepts de la POO
0.3.3.3.1Les objets et les classes
0.3.3.3.1.1Aide de dBASE
Classe
Les classes sont des spécifications, ou modèles, utilisées pour créer des objets. Visual dBASE propose de nombreuses classes standard que vous pouvez employer pour créer les objets usuels de Windows, comme les boutons radio, les boutons-poussoirs et les champs de saisie.
Autre définition :
Une spécification, ou modèle, permettant de créer des instances d'un objet particulier. Form et Entryfield sont des exemples de classes standard fournies par dBASE. Vous pouvez déclarer vos propres classes avec la commande CLASS...ENDCLASS.
Objet et instance
Lorsque vous créez un objet, vous créez une instance de cette classe d'objet. L'objet possédera les attributs prédéfinis spécifiés dans la classe. Ces attributs sont appelés propriétés. Lorsque vous avez créé un objet, vous pouvez en personnaliser les caractéristiques en affectant des valeurs aux propriétés. Chaque classe fournit également des méthodes intégrées qui, lorsqu'elles sont appelées effectuent des opérations sur un objet. Certaines propriétés ont des codes qui leur sont associés et effectuent des opérations sur l'objet.
Un objet créé à partir d'une classe. Par exemple, un formulaire est une instance d'une classe formulaire (ou d'une classe personnalisée dérivée d'une classe formulaire).
Dérivation
La déclaration d'une nouvelle classe (une sous-classe) basée sur une autre classe (une superclasse). Les programmeurs construisent des hiérarchies de classes en les faisant dériver les unes des autres.
Sous-classe
Une classe dérivée d'une autre classe (appelée super classe). Une sous-classe hérite des propriétés de la super classe.
Super classe
Une classe utilisée pour faire dériver une autre classe (appelée une sous-classe). La sous-classe hérite de toutes les propriétés de la super classe.
Constructeur
Le code programme dans une instruction CLASS...ENDCLASS s'exécutant lorsqu'un objet de cette classe est créé. Le code constructeur peut contenir n'importe quelle commande dBASE, bien qu'il ne contienne normalement que les instructions d'affectation de propriétés et de méthode.
0.3.3.3.1.2Aide de WordBasic 7
Les objets constituent la composante fondamentale de Visual Basic : presque tout ce que vous faites sous Visual Basic implique la modification d'objets. Tous les éléments de Word (documents, tableaux, paragraphes, champs, signets, etc.) peuvent être représentés par un objet sous Visual Basic.
Que sont les objets et les collections ?
Un objet reprsente un lment de Word, tel qu'un document, un paragraphe, un signet ou un seul caractre. Une collection est un objet qui contient plusieurs autres objets, en gnral du mme type : par exemple, tous les signets d'un document sont contenus dans une seule collection d'objets. En utilisant les proprits et les mthodes, vous pouvez modifier un seul objet ou la totalit d'une collection d'objets.
L'interface utilisateur contient des objets qui sont des éléments graphiques de l'interface et des contrôles Windows. Les menus, les boutons-poussoirs et les cases à cocher sont des exemples d'objets, également connus comme contrôles. Vous pouvez déplacer les objets, les dimensionner et leur affecter des propriétés qui modifient leur apparence et leur comportement. Les programmeurs utilisent des objets comme des collections de variables mémoire, où chaque variable représente une propriété de l'objet.
0.3.3.3.2Les contrôles
Objets affichés sur un formulaire (menus, boutons-poussoirs et boîtes listes, par exemple).
0.3.3.3.3Les propriétés
0.3.3.3.3.1Aide de dBASE
propriétés
Les attributs d'un objet. Vous pouvez visualiser et changer les propriétés d'un objet avec l'inspecteur. Pour ouvrir l'inspecteur, exécutez la fonction INSPECT( ) ou choisissez la commande Inspecteur dans le menu Vue ou dans le TurboMenu.
Les classes standard proposées par dBASE pour Windows disposent de plus de 170 propriétés, beaucoup de ces propriétés étant communes à plusieurs classes. Utilisez ces propriétés pour modifier les caractéristiques d'un objet, pour faire réagir un objet à un événement ou pour entreprendre une action.
Les propriétés effectuant une action sont suivies de parenthèses. Ces actions sont appelées méthodes.
opérateur point
Un opérateur ( . ) qui accède à la propriété d'un objet via une référence objet. Placez la référence objet sur le côté gauche de l'opérateur point et placez le nom de la propriété sur la droite de l'opérateur. La syntaxe de la commande contenant l'opérateur point est habituellement appelée notation point.
0.3.3.3.3.2Aide de WordBasic 7
Qu'est-ce qu'une propriété ?
Une proprit est un attribut d'un objet ou un aspect de son comportement. Par exemple, les proprits d'un document sont notamment son nom, son contenu, son tat d'enregistrement ainsi que l'activation ou non du suivi des modifications. Pour modifier les caractristiques d'un objet, vous changez les valeurs de ses proprits.
Pour affecter une valeur une proprit, faites suivre la rfrence un objet d'un point, du nom de la proprit, d'un signe gal et de la nouvelle valeur de la proprit. L'exemple ci-dessous montre comment activer le suivi des modifications dans le document nomm "MyDoc.doc".
Documents("MyDoc.doc").TrackRevisions = True
Dans cet exemple, Documents fait référence à la collection de documents ouverts, et le nom "MyDoc.doc" identifie un document donné de cette collection. Une valeur est affectée à la propriété TrackRevisions pour ce document.
Certaines proprits ne peuvent se voir affecter de valeur. La rubrique d'aide relative chaque proprit indique si vous pouvez affecter une valeur cette proprit (proprit en lecture-criture), ou si elle peut uniquement tre lue (proprit en lecture seule).
Vous pouvez renvoyer des informations sur un objet en renvoyant la valeur de l'une de ses proprits. Cet exemple montre comment renvoyer le nom du document actif :
docName = ActiveDocument.Name
Dans cet exemple, ActiveDocument fait référence au document figurant dans la fenêtre active de Word. Le nom de ce document est affecté à la variable docName.
0.3.3.3.4Les méthodes
0.3.3.3.4.1Aide de dBASE
méthode
Une fonction, une procédure ou un bloc de code associé à un objet. Les méthodes effectuent des actions sur les objets. Par exemple, appelez la méthode Close() pour fermer un formulaire.
0.3.3.3.4.2Aide de WordBasic 7
Qu'est-ce qu'une méthode ?
Une méthode est une action qu'un objet peut effectuer. Par exemple, un document pouvant être imprimé, l'objet Document dispose d'une méthode PrintOut. Les méthodes ont souvent des arguments qui qualifient le mode d'exécution de l'action. L'exemple ci-dessous montre comment imprimer les trois premières pages du document actif.
ActiveDocument.PrintOut From:=1, To:=3
Dans la plupart des cas, les méthodes sont des actions et les propriétés sont des qualités. L'utilisation d'une méthode fait que quelque chose arrive à un objet, alors que l'utilisation d'une propriété renvoie des informations sur l'objet ou entraîne la modification de l'une de ses qualités.
0.3.3.3.5Les évènements
Une occurrence telle qu'une frappe de touche ou un clic souris. La plupart des événements sont des actions utilisateur ; cependant, certains événements sont des actions effectuées par un programme ou le système d'exploitation. Dans les formulaires, vous pouvez écrire des codes de gestion d'événement (code programme) s'exécutant en réponse aux événements.
0.3.3.4L’exécution
Exécuter :
L'utilisation d'un objet. Lorsque vous exécutez une table, vous l'ouvrez en mode tabulaire dans lequel vous pouvez éditer les données. Lorsque vous exécutez une requête, vous visualisez les données des tables sélectionnées pour la requête. Lorsque vous exécutez un formulaire, les contrôles deviennent actifs.
0.3.3.5Divers
Héritage
Lorsque vous faites dériver une classe (une sous-classe) d'une autre classe (une super classe), la sous-classe hérite de toutes les propriétés et méthodes de la super classe. L'héritage est un concept important dans la programmation orientée objet car elle facilite la réutilisation du code programme. Lorsque vous devez modifier une partie d'une classe, vous pouvez faire dériver une sous-classe, puis ne modifier que les propriétés ou méthodes ayant besoin de l'être.
Polymorphisme
Le fait de donner à une classe, dans une hiérarchie de classes, la possibilité d'implémenter une action qui est commune à toutes les classes de la hiérarchie, par tout moyen nécessaire. Le polymorphisme (littéralement, "avoir plusieurs formes") est un concept important dans la programmation orientée objet.
Visual dBASE supporte le polymorphisme en permettant aux programmeurs de faire dériver une classe d'une autre et en surchargeant une propriété ou une méthode de la nouvelle classe par une valeur différente ou un sous-programme. La propriété ou la méthode surchargée partage le même nom dans les deux classes, mais prend une "forme" différente dans chaque classe.
Encapsulation
Combine les variables mémoire et les procédures pour former une nouvelle structure appelée un objet. L'encapsulation est un concept important dans la programmation orientée objet. L'encapsulation des variables et des procédures dans un objet les sépare des données de mêmes noms n'importe où dans l'application. L'encapsulation améliore également la réutilisation en regroupant les données associées.
0.3.4Améliorations des entrées et des sorties
0.3.5Fichiers : opérations de base
0.3.5.1Commandes
Voir cours d’amphi.
OPERATIONS SUR LES FICHIERS
Ces commandes s’appliquent pour la plupart au fichier courant. Si aucun fichier n’est actif, dBASE affiche une boîte de demande d’ouverture de table.
Création d’un fichier :
CREATE fichier
Exemple, pour créer le fichier FITOTO :
create fitoto
Ouverture d’un fichier :
USE fichier
Exemple, pour ouvrir le fichier BIDULE :
use bidule
Attention à un point très important : cette commande ouvre le fichier indiqué et lit le premier enregistrement, mais ne l’affiche pas.
Il y a une grosse différence avec des langages tels que le BASIC : il n’existe pas à proprement parler d’instruction de lecture d’enregistrement (ni d’écriture, d’ailleurs) dans dBASE ; après l’ouverture du fichier, le premier enregistrement est disponible en MC, et on peut tout de suite l’employer pour travailler, sans qu’il y ait besoin d’une quelconque autre instruction ; mais on ne voit absolument rien à l’écran qui confirme que le fichier est ouvert et que cet enregistrement est disponible en MC, et cela chagrine énormément les débutants...
Affichage de la structure du fichier actif :
DISPLAY STRUCTURE
Ou
LIST STRUCTURE
Modification de la structure du fichier actif :
MODIFY STRUCTURE
Copier un fichier, ou une partie d’un fichier :
COPY TO nouveaunom [portée] [FIELDS listedechamps] [FOR condition]
Il existe d’autres options.
Cette commande copie le fichier actif.
Exemple :
FICHETUD est actif, on veut copier uniquement les noms et prénoms de ceux qui ont un bac D dans un nouveau fichier ETUD2 :
Copy to etud2 all fields nom, prenom for bac = "D"
Copier la structure du fichier actif :
COPY STRUCTURE TO nouveaufichier [FIELDS listedechamps]
Cette commande crée un nouveau fichier de même structure (complète ou partielle), mais vide.
Fermeture d’un fichier :
USE
Ferme le fichier actif.
Fermer tous les fichiers ouverts :
CLOSE ALL
Copier n’importe quel fichier :
COPY FILE fichiersource TO fichierdestination
Effacer n’importe quel fichier :
DELETE FILE fichieravecsonextension
Variante : ERASE
OPERATIONS SUR LES DONNEES
Lecture et écriture d’enregistrements :
Il n’existe pas à proprement parler d’instruction de lecture d’enregistrement d’un fichier ni d’écriture dans dBASE ; il y a donc une grosse différence avec des langages tels que le BASIC, et les débutants doivent s’y habituer.
Comme vu plus haut, la "lecture" du premier enregistrement du fichier s’effectue "automatiquement" à l’ouverture de ce fichier, sans aucune instruction spécifique ; la "lecture" des autres s’effectue au moyen des commandes de déplacement et de recherche que nous allons examiner ci-dessous.
Lecture d’un fichier : inconvénient de 2 lectures, 1 avant le tantque, l’autre avant le fintant
Pour l’écriture, on effectue cette opération sous le biais d’une modification du ou des champs concernés, grâce à l’instruction de remplacement de valeur d’un champ :
REPLACE [portée] champ WITH expression [,champ WITH expression…] [FOR condition]
Exemple :
dans un fichier de stock de vins, on veut augmenter les prix des bordeaux de 15 % :
replace all prix with prix * 1,15 for region = "Bx"
Déplacements et recherches dans le fichier :
Aller à un enregistrement n :
GOTO n
Ou : GO n
Aller directement au dernier enregistrement :
GO BOTTOM
Revenir directement au premier enregistrement :
GO TOP
Avancer ou reculer d’un certain nombre d’enregistrements :
SKIP n
Exemples : skip 3 avance de 3 enregistrements, skip -5 recule de 5.
SKIP seul avance de 1.
Recherche d’un enregistrement :
2 instructions pour cela, selon les cas :
LOCATE portée FOR condition
Utilisable avec tout fichier, indexé ou non ; recherche séquentielle, qui s’arrête au 1er enregistrement qui vérifie la condition de recherche.
Si on veut avoir les autres enregistrements situés après, il faut poursuivre avec l’instruction CONTINUE, donc faire une boucle jusqu’à la fin du fichier. L’observation ( en TD et aux partiels) des dégâts provoqués dans le cerveau des débutants par ce fonctionnement fait que je déconseille vigoureusement cette commande aux esprits faibles.
FIND chaînedecaractères
Utilisable uniquement avec un fichier indexé ; recherche le 1er enregistrement dont la clef d’index correspond à la chaîne spécifiée.
Même remarque que ci-dessus.
Ces 4 commandes GO, SKIP, LOCATE et FIND positionnent le pointeur d’enregistrement sur l’enregistrement spécifié, lequel devient disponible en MC, et on peut tout de suite l’employer pour travailler, sans qu’il y ait besoin d’une quelconque autre instruction ; mais je répète qu’on ne voit absolument rien à l’écran qui confirme que cet enregistrement est disponible en MC, et cela perturbe énormément les débutants...
Affichage d’enregistrements
2 cas : avec possibilité de modification ou sans, selon ce qu’on veut faire (et la confiance qu’on accorde aux capacités de l’utilisateur du programme !) :
avec possibilité de modification :
EDIT [portée] [FOR condition] [FIELDS liste de champs]
Affiche un formulaire ;
BROWSE [FOR condition] [FIELDS liste de champs]
Affiche une table ;
sans possibilité de modification :
DISPLAY [portée] [FOR condition] [FIELDS liste de champs]
DISPLAY effectue une pause lorsque le volet de résultats est plein et affiche une boîte de dialogue proposant de continuer..
LIST [portée] [FOR condition] [FIELDS liste de champs]
Ces 2 commandes font progresser le pointeur.
Suppression et rappel d’enregistrements :
Lors d’un affichage avec EDIT ou BROWSE, suppression et rappel avec la commande à bascule Ctrl + U.
DELETE [portée] [FOR condition]
Suppression logique : à l’affichage avec LIST ou DISPLAY ALL, ces enregistrements sont repérés par une astérisque au début de la ligne ; avec BROWSE par une croix rouge ; avec EDIT, rien ne permet de les distinguer.
Rappel des enregistrements marqués comme supprimés logiquement :
RECALL [portée] [FOR condition]
Les "rappelle" et efface la marque.
Suppression physique , ou "compactage" :
PACK
Rappel : après la suppression physique des enregistrements marqués comme supprimés logiquement, ils disparaissent définitivement, et il devient impossible de les rappeler.
N.B. ne pas confondre avec la compression de fichier, type ARJ, ou RAR, ou WINZIP…
Suppression physique de TOUS les enregistrements du fichier :
ZAP
Cette commande met le fichier à vide ; elle est équivalente à DELETE ALL puis PACK, mais plus rapide.
Ajouter des enregistrements au fichier actif :
Ajouter un enregistrement avec ouverture d’un formulaire de saisie :
APPEND
Écrire les modifications : Ctrl + S
Fermer en gardant les modifications : Ctrl + W
Fermer en abandonnant les modifications : Ctrl + Q
Ajouter un enregistrement vide pour le garnir par programme :
APPEND BLANK
Évidemment, on le garnit ensuite avec des instructions REPLACE.
Ajouter des enregistrements provenant d’un autre fichier (de préférence de même structure !) :
APPEND FROM fichier [FOR condition
Exemple : le fichier courant est ETUD2, et on veut ajouter les étudiants de FICHETUD qui ont un bac C :
Append from fichetud for bac = "C"
Insérer des enregistrements :
INSERT [BLANK] [BEFORE]
Insère un enregistrement après (ou avant) l’enregistrement courant.
Là encore, on le garnit ensuite avec des instructions REPLACE.
Calculs sur un fichier :
Essentiellement :
COUNT [portée] [FOR condition] TO variablemémoire
Compte le nombre d’enregistrements satisfaisant à la condition.
SUM [portée] expression [FOR condition] TO variablemémoire
Calcule le total.
Exemple :
On veut calculer le prix moyen des bourgognes, en affichant les éléments de ce calcul :
Sum all prix to totprixbg for region = "Bg"
Count all for region = "Bg" to nbbg
Prixmoybg = totprixbg / nbbg
? "Total des prix des bourgognes :", totprixbg
? "Nombre de bourgognes :", nbbg
? "Prix moyen d’un bourgogne :", prixmoybg
N.B. si l’on n’a besoin d’afficher que le résultat, il existe une instruction de calcul de moyenne :
AVERAGE prix FOR region = "Bg" TO prixmoybg
? "Prix moyen d’un bourgogne :", prixmoybg
Impression :
Les commandes d’affichage peuvent être complétées d’une clause :
TO PRINTER
Qui envoie les résultats à l’imprimante.
Exemple :
List all nom, prenom to printer
Voir également "SET PRINTER" dans l’aide de dBASE.
TRI ET INDEXATION
Tri :
SORT ON champ1 [, champ2…] TO nouveaufichier [DESCENDING]
Il y a d’autres clauses.
Indexation :
Il faut d’abord créer le fichier index :
INDEX ON clef TO fichierindex
Ensuite, si on veut employer le fichier dans l’ordre de l’index :
USE fichier INDEX fichierindex
Si on veut employer le fichier à nouveau dans son ordre naturel :
USE fichier
Il y a une autre façon de procéder, et d’autres clauses.
Exercices
0.3.5.2.1Enoncés
Listage d’un fichier : réaliser l'équivalent de la commande LIST, au moyen d'un petit programme.
Listage d’un fichier en numérotant les lignes de 5 en 5.
Lister un fichier selon critères LIST FOR
Dans fichier pinards : augmenter les Bx de 10 %, avec IF
Augmenter les Bx de 10 %, les Bg de 15 %, baisser les Bj de 5 %, augme les Ch de 18 %, avec DO CASE
Recherche de doublons dans un fichier FIFI
Etudier le programme ci-dessus, trouver dans quel cas il fonctionne et dans quel cas il ne donne pas le résultat espéré, puis écrire un programme qui fonctionne correctement dans tous les cas.
Trouver une astuce qui permette d'utiliser le programme doublon1 en ajoutant simplement 2 lignes dans ce programme.
0.3.5.2.2Corrigés
use FIFI
nomanc = space(1)
prenomanc = space(1)
doublon = .f.
do while .not. eof()
if upper(nom) = nomanc .and. upper(prenom) = prenomanc
? msgbox("Doublon sur : " + nom + " " + prenom)
doublon = .t.
endif
nomanc = upper(nom)
prenomanc = upper(prenom)
skip
enddo
if .not. doublon
? msgbox("Pas trouvé de doublon.")
endif
use
Pour que le programme doublon1 fonctionne correctement, il faut que le fichier FIFI soit trié (classé) par nom et prénom.
S'il n'est pas trié, ou s'il est trié sur un autre critère, il faut…
use FIFI
nomanc = upper(nom)
prenomanc = upper(prenom)
count to nummax
doublon = .f.
for num = 2 to nummax
go num
locate rest for upper(nom) = nomanc .and. upper(prenom) = prenomanc
if .not. eof()
? msgbox("Doublon sur : " + nom + " " + prenom)
doublon = .t.
endif
go num
nomanc = upper(nom)
prenomanc = upper(prenom)
next
if .not. doublon
? msgbox("Pas trouvé de doublon.")
endif
use
Indexer FIFI sur nom + prenom, puis ouvrir le fichier indexé.
0.3.6Opérations diverses
Production d’un état :
REPORT FORM nomdufichier
Si on veut améliorer la présentation :
@SAY…
Voir l’aide de dBASE.
0.4Du boulot de pro
0.4.1Algorithmie
structures de données : file, piles, listes
0.4.2Le langage dBASE
0.4.2.1Classes
0.4.2.1.1Classes personnalisées
Vous pouvez créer de nouvelles classes à partir de zéro, ou les dériver des classes standard. Pour cela, utilisez la commande CLASS...ENDCLASS. Une classe dérivée d'une autre classe est appelée une sous-classe. Elle hérite des propriétés et des méthodes de la classe sur laquelle elle se base. Vous pouvez ensuite personnaliser les attributs de la sous-classe en ajoutant, en supprimant ou en modifiant des propriétés.
0.4.2.1.2Classes standard
La plupart des classes standard que Visual dBASE fournit sont des spécifications pour les objets standard de Windows (également appelés contrôles) que vous créez et placez sur des fenêtres utilisateur appelées formulaires. Pour créer vos propres objets, vous devez d'abord créer les classes correspondantes (pour plus d'informations, voir la rubrique Classes personnalisées).
Les classes standard proposées par Visual dBASE disposent de plus de 200 propriétés, beaucoup de ces propriétés étant communes à plusieurs classes. Utilisez ces propriétés pour modifier les caractéristiques d'un objet, pour faire réagir un objet à un événement ou pour entreprendre une action.
0.4.2.2Formulaires
Les formulaires sont des fenêtres qui affichent des messages et des données en réponse aux entrées des utilisateurs. Ces fenêtres sont dotées d'éléments d'interaction tels que les menus, les boutons et les barres de défilement. Vous pouvez générer des écrans de saisie simples utilisant une ou plusieurs tables. Les formulaires permettent aussi de générer l'interface utilisateur complète d'une application complexe.
Lorsque vous créez un formulaire, vous commencez avec une fenêtre formulaire vide. Vous devez ensuite sélectionner et placer des objets tels que des champs de saisie, des boîtes listes et des cases à cocher. Visual dBASE dispose de la plupart des objets Windows standard. Le formulaire et les contrôles qu'il contient sont des objets.
Une fois l'interface utilisateur créée, vous pouvez spécifier les propriétés des objets de façon à personnaliser leurs caractéristiques et leur comportement. Pour le faire de façon interactive, utilisez l'inspecteur. L'inspecteur répertorie toutes les propriétés d'un objet et ses valeurs en cours.
Les propriétés sont principalement des variables mémoire qui contiennent des données relatives à un objet. Il y a trois types de propriétés :
Propriétés : elles définissent les caractéristiques d'un objet (par exemple, sa taille, son emplacement et sa couleur).
Événements (propriétés événementielles) : ils déterminent le comportement d'un objet (comment il répond aux événements tels que les clics de souris et les frappes de clavier). Vous pouvez spécifier ce qui se produit lorsqu'un événement survient en liant un bloc de code, ou une procédure à la propriété événementielle. Ce code est appelé gestionnaire d'événement.
Méthodes : ces procédures sont associées à un objet. Elles déterminent quelles actions peuvent être effectuées sur des objets (libération en mémoire, focalisation ou déplacement des objets).
A propos des fichiers formulaires (.WFM)
Lorsque vous sauvegardez un formulaire, le concepteur de formulaire génère le code dBASE qui définit le formulaire et ses objets. Le code spécifie les propriétés des objets et le code de gestion d'événement associé au formulaire et à ses objets.
Opérations sur les fichiers formulaires
Les formulaires sont sauvegardés sous forme de fichiers texte avec une extension .WFM (Windows ForM) par défaut. Les opérations suivantes peuvent être réalisées sur un fichier .WFM :
Exécution du fichier à l'aide de la commande DO ou depuis le navigateur
Débogage du fichier
Édition du fichier avec l'éditeur de texte
Le concepteur de formulaire est un outil à deux voies : vous pouvez modifier un formulaire en utilisant le concepteur de formulaire ou en éditant le code généré dans le fichier .WFM à l'aide d'un éditeur de texte. Les deux techniques sont interchangeables, car les modifications sont répercutées dans le concepteur de formulaire et dans le code généré.
0.4.2.3Exemple : "Bonjour" en programmation directe
Tout d’abord, pour ne pas avoir d’ennuis dans les différents modules de nos futurs programmes, nous devons déclarer la variable A (qui contiendra le nom) publique, c’est-à-dire commune à tous les modules et sous-programmes de notre programme.
Il faut créer un formulaire qui affiche un message disant de taper votre nom, avec un rectangle de saisie pour la frappe de ce nom. Le formulaire est créé grâce à la commande "define form", le champ de saisie à l’intérieur de ce formulaire est créé grâce à la commande "define entryfield". Lorsque l’utilisateur frappe un nom dans le champs de saisie prévu à cet effet, ce nom frappé est stocké dans une variable appelée A, grâce à un petit bloc de code d’affectation.
Enfin, il ne faut pas oublier d’exécuter le formulaire, c’est à dire de l’ouvrir.
public A
DEFINE FORM saisnom
DEFINE ENTRYFIELD votre_nom of saisnom;
property onchange {; A = this.value}
OPEN FORM saisnom
Nous allons copier le nom, qui est stocké dans la variable A, dans une autre variable B (que nous devrons également déclarer publique, donc ne pas oublier de compléter la déclaration de A), cela pour bien montrer que la donnée lue peut effectivement être traitée par le programme :
B = A
Nous placerons cette affectation dans le bloc de code qui contient "A = this.value".
L’affichage du nom, précédé du message "Bonjour", s’effectue au moyen de la fonction "msgbox()" :
? msgbox("Bonjour " + B)
Cet affichage devra s’effectuer juste après la fermeture du formulaire de saisie du nom. Le plus simple est de le placer comme bloc de code dans la propriété "onclose" de ce formulaire, ce qui nous donne finalement :
onclose {; ? msgbox("Bonjour " + B)}
Notons que dans notre cas simple, l’affectation "B = A" peut être placée soit après la capture du nom, c’est à dire dans le bloc de code qui contient "A = this.value", soit avant l’émission du message de sortie c’est à dire dans le bloc de code qui contient "? msgbox("Bonjour " + B)".
Le programme complet s’établit donc ainsi :
public A, B
DEFINE FORM saisnom;
onclose {; ? msgbox("Bonjour " + B)}
DEFINE ENTRYFIELD votre_nom of saisnom;
onchange {; A = this.value; B = A}
OPEN FORM saisnom
public A, B
DEFINE FORM saisnom;
property Text "Boite de saisie du nom",;
onclose {; ? msgbox("Bonjour " + B)}
DEFINE TEXT wtexte of saisnom;
property Text "Tapez votre nom :",;
Width 20, Top 1
DEFINE ENTRYFIELD votre_nom of saisnom;
property Width 20, Top 5, Left 25,;
onchange {; A = this.value; B = A}
DEFINE TEXT wtexte2 of saisnom;
property Text "Pour voir la suite, fermez la boîte",;
Width 40, Top 10
OPEN FORM saisnom
0.4.2.4Exercices
0.4.2.4.1Enoncés
Monsieur RICHPRO est Président d'une association, et s'occupe du fichier des adhérents. Il modifie de temps en temps la structure, et effectue des mises à jour sur les données. Malheureusement, il s'est mélangé les pinceaux dans les versions successives de ce fichier, et a mis à jour par erreur des versions plus anciennes.
Le fichier est trop gros pour songer à pointer ces versions manuellement, et de toutes façons, Monsieur RICHPRO est trop paresseux pour se lancer dans un travail aussi épuisant.
Il décide donc d'écrire un programme pour cela, et, tant qu'à faire, de généraliser le problème, de la façon suivante : on veut comparer 2 versions d'un fichier quelconque, sur le plan de la structure (des champs ont pu être ajoutés ou supprimés), des enregistrements (idem), et des valeurs des champs (qui ont pu être modifiées).
0.4.2.4.2Corrigés
Créer un formulaire de saisie selon l'exemple ci-dessous :
pour l'événement OnChange de ce formulaire, taper :
Procedure Form_OnChange
Public fica, ficb
fica = this.SAISIE1.value
ficb = this.SAISIE2.value
Pour l'événement OnClick du bouton Continuer, taper :
Procedure BOUTON1_OnClick
close forms
do compfic4
Enfin, pour le programme compfic4 appelé parce bouton Continuer, taper :
set talk off
set safety off
set directory to c:\perriol\temp
set exclusive on
*
* effacement des anciennes tables des structures et de comparaison
* des enregistrements, des champs et des valeurs
if file("strua.dbf")
delete file strua.dbf
endif
if file("strub.dbf")
delete file strub.dbf
endif
if file("compch.dbf")
delete file compch.dbf
endif
if file("compenr.dbf")
delete file compenr.dbf
endif
if file("compval.dbf")
delete file compval.dbf
endif
*
* création de la nouvelle table de comparaison des champs
select 3
create table compch (sens char(32), nom char(10))
use compch
* préparation du témoin de différence de champ
wch = .t.
* création des tables dont les enregistrements sont les champs de A et B
* c'est-à-dire qui contiennent les structures de A et B
select A
use &fica
COPY TO strua.dbf STRUCTURE EXTENDED
use strua
select B
use &ficb
COPY TO strub.dbf STRUCTURE EXTENDED
use strub
*
* 1ère partie : recherche des champs de A qui n'existent pas dans B
* balayage de A
select A
do while .not. eof()
* balayage de B
select B
go top
do while .not. eof()
if B->field_name = A->field_name
wch = .f.
exit
endif
skip
* fin du balayage de B
enddo
* écriture éventuelle dans la table des différences
if wch
select 3
append blank
replace sens with "champ de A n'existant pas dans B"
replace nom with A->field_name
endif
wch = .t.
* fin du balayage de A
select 1
skip
enddo
*
* 2ème partie : recherche des champs de B qui n'existent pas dans A
* idem ci-dessus, en permutant A et B
wch = .t.
select B
go top
do while .not. eof()
select A
go top
do while .not. eof()
if A->field_name = B->field_name
wch = .f.
exit
endif
skip
enddo
if wch
select 3
append blank
replace sens with "champ de B n'existant pas dans A"
replace nom with B->field_name
endif
wch = .t.
select 2
skip
enddo
* fin des parties 1 et 2 :
* affichage de la table contenant les différences de champs
select 3
browse
close all
*
* 3ème partie : recherche des enregistrements d'une table
* qui n'existent pas dans l'autre
* création de la nouvelle table de comparaison des enregistrements
select 3
create table compenr (sens char(37), nom char(17), prenom char(15))
use compenr
select 1
use &fica
select 2
use &ficb
* recherche des enregistrements de A qui n'existent pas dans B
* attention : on suppose qu'il y a au moins les champs nom et prenom
* dans les 2 tables A et B
select 1
do while .not. eof()
select 2
go top
locate for nom = A->nom .and. B->prenom = A->prenom
if eof()
select 3
append blank
replace sens with "enregistrement de A inexistant dans B"
replace nom with A->nom
replace prenom with A->prenom
endif
select 1
skip
enddo
* recherche des enregistrements de B qui n'existent pas dans A
* on utilise la même table compenr
select 2
go top
do while .not. eof()
select 1
go top
locate for A->nom = B->nom .and. A->prenom = B->prenom
if eof()
select 3
append blank
replace sens with "enregistrement de B inexistant dans A"
replace nom with B->nom
replace prenom with B->prenom
endif
select 2
skip
enddo
select 3
browse
close all
*
* 4ème partie : comparaison des valeurs des enregistrements communs
* création de la nouvelle table de comparaison des valeurs
select 3
create table compval ( nom char(17), prenom char(15), champ char(10), valeura char(32), valeurb char(32))
use compval
* comparaison des valeurs des champs de A et B
select A
use &fica
select B
use &ficb
* on prend STRUA et STRUB comme guide des noms de champs
* qui existent
select 4
use strua
select 5
use strub
* on balaye la table A en cherchant dans B
select 1
go top
do while .not. eof()
select 2
go top
locate for upper(B->nom) = upper(A->nom) .and. upper(B->prenom) = upper(A->prenom)
if .not. eof()
select 4
go top
do while .not. eof()
champ4 = field_name
select 5
go top
locate for field_name = champ4
if .not. eof()
if B->&champ4 <> A->&champ4
select 3
append blank
replace nom with A->nom
replace prenom with A->prenom
replace champ with champ4
replace valeura with A->&champ4
replace valeurb with B->&champ4
exit
endif
endif
select 4
skip
enddo
endif
select 1
skip
enddo
select 3
browse
use
close all
return
0.5COMPLEMENTS
0.5.1Sources d'information
- Programmez n° 50 février 2003 : numéro spécial "Histoire et prospective des langages".
0.5.2Historique