Contained WithinFind More DocumentationFeatured Support Resources |  Download this book in PDF (1328 KB)
Chapitre 2 Langage de StarOffice BasicStarOffice Basic fait partie de la famille des langages de type Basic. De nombreuses parties de StarOffice Basic sont identiques à Microsoft Visual Basic pour Applications (VBA) et à Microsoft Visual Basic. Les utilisateurs ayant déjà travaillé avec ces langages se familiariseront rapidement avec StarOffice Basic. De même, les programmeurs utilisant d'autres langages (tels que Java, C++ ou Delphi) se familiariseront aisément avec StarOffice Basic. C'est un langage de programmation procédural abouti qui n'utilise plus de structures de contrôle rudimentaires, comme GoTo et GoSub. Vous pouvez également profiter des avantages de la programmation orientée objet puisque StarOffice Basic possède une interface permettant d'utiliser des bibliothèques d'objets externes. L'intégralité de l'API StarOffice est fondée sur ces interfaces, qui sont décrites en détail plus loin. Ce chapitre propose un aperçu général des éléments clés et des structures du langage StarOffice Basicainsi que du cadre dans lequel les applications et les bibliothèques sont orientées vers StarOffice Basic. Présentation du programme StarOffice BasicStarOffice Basic est un langage interprété. Contrairement à C++ ou à Turbo Pascal, le compilateur de StarOffice ne crée pas de fichiers exécutables ou auto-extractibles, capables de s'exécuter de façon autonome. En revanche, vous pouvez exécuter un programme StarOffice Basic simplement en cliquant sur un bouton. Le code est d'abord vérifié pour rechercher les erreurs patentes, puis exécuté ligne par ligne. Lignes de programmeL'interpréteur Basic fonctionne ligne par ligne, ce qui le différencie des autres langages de programmation. Alors que l'emplacement des retours à la ligne dans le code source des programmes Java, C++ ou Delphi est indifférent, chaque ligne d'un programme Basic constitue une unité indépendante. Les appels de fonction, les expressions mathématiques et les autres éléments du langage, comme les en-têtes de fonction ou de boucle, doivent commencer et finir à l'intérieur d'une même ligne. Si l'espace est insuffisant ou si cela donne des lignes trop longues, il est possible de lier plusieurs lignes ensemble par l'ajout de caractères de soulignage (_). L'exemple suivant montre comment lier les quatre lignes d'une expression mathématique : LongExpression = (Expression1 * Expression2) + _ (Expression3 * Expression4) + _ (Expression5 * Expression6) + _ (Expression7 * Expression8) Remarque – Le caractère de soulignage doit toujours être le dernier de la ligne à lier et ne doit être suivi d'aucun espace ou tabulation, sans quoi le code provoque une erreur. Parallèlement à la liaison de plusieurs lignes, StarOffice Basic permet d'employer le signe de ponctuation ":" pour diviser une ligne en différentes sections afin de pouvoir y placer plusieurs expressions. Les assignations telles que : a = 1 a = a + 1 a = a + 1 peuvent être écrites de la façon suivante : a = 1 : a = a + 1 : a = a + 1 CommentairesOutre le code de programme à exécuter, un programme StarOffice Basic peut contenir des commentaires qui expliquent les différentes parties du programme et fournissent des informations importantes qui peuvent s'avérer utiles par la suite. StarOffice Basic propose deux méthodes pour insérer des commentaires dans le code :
Dim A ' Ceci est un commentaire pour la variable A
Rem Ce commentaire est inséré grâce au mot-clé Rem. Un commentaire comprend généralement tous les caractères jusqu'à la fin de la ligne. StarOffice Basic interprète la ligne suivante de nouveau comme une instruction normale. Si les commentaires s'étendent sur plusieurs lignes, chaque ligne doit être signalée comme étant un commentaire : Dim B ' Ce commentaire pour la variable B étant assez long
' il s'étend sur plusieurs lignes. Le
' signe de commentaire doit donc être répété
' à chaque ligne.
MarqueursUn programme StarOffice Basic peut contenir des dizaines, des centaines ou même des milliers de marqueurs : noms de variables, de constantes, de fonctions, etc. Lorsque vous sélectionnez un nom de marqueur, les règles suivantes s'appliquent :
Remarque – Les règles de construction des marqueurs dans StarOffice Basic ne sont pas les mêmes que dans VBA. Par exemple, avec Option Compatible, StarOffice Basic n'autorise que les caractères spéciaux dans les marqueurs, puisqu'ils peuvent causer des problèmes dans les projets d'envergure internationale. Voici quelques exemples de marqueurs corrects et incorrects : Nom ' Correct
Surname5 ' Correct (le chiffre 5 n'est pas au début du marqueur)
Nom de famille ' Incorrect (les espaces ne sont pas autorisés)
DéjàVu ' Incorrect (les lettres telles que é, à
'ne sont pas autorisées)
5Surnames ' Incorrect (le premier caractère ne peut pas être un chiffre)
Nom.de,famille ' Incorrect (les virgules et les points
' ne sont pas autorisés)
Utilisation des variablesDéclaration implicite de variablesLes langages Basic sont conçus pour être conviviaux. Ainsi, StarOffice Basic permet de créer une variable simplement en l'utilisant et sans avoir à la déclarer explicitement. En d'autres termes, une variable existe dès que vous l'intégrez dans le code. En fonction des variables déjà présentes, l'extrait de code suivant peut déclarer jusqu'à trois nouvelles variables : a = b + c La déclaration implicite de variables n'est pas une bonne habitude de programmation, car cela peut amener à introduire involontairement de nouvelles variables, par exemple en faisant une faute de frappe. Au lieu de générer un message d'erreur, l'interpréteur se contente d'initialiser une nouvelle variable correspondant à la faute de frappe avec une valeur de 0. Les erreurs de ce type peuvent être assez difficiles à repérer dans le code. Déclaration explicite de variablesPour éviter de générer des erreurs en déclarant des variables implicitement, StarOffice Basic propose une option appelée : Option Explicit Elle doit être indiquée dans la première ligne de code de chaque module. Ainsi, un message d'erreur sera émis chaque fois qu'une variable sera utilisée sans avoir été déclarée au préalable. L'option Option Explicit doit se trouver dans tous les modules Basic. La forme la plus simple pour la déclaration explicite d'une variable est la suivante : Dim MyVar Dans cet exemple, une variable portant le nom MyVar et de type variant est déclarée. Une variable de type variant est une variable universelle pouvant contenir tout type de valeur, comme des chaînes de caractères, des nombres entiers, des nombres à virgule flottante et des valeurs booléennes. Voici quelques exemples de variables de typevariant : MyVar = "Hello World" ' Assignation d'une chaîne de caractères MyVar = 1 ' Assignation d'un nombre entier MyVar = 1.0 ' Assignation d'un nombre à virgule flottante MyVar = True ' Assignation d'une valeur booléenne Les variables déclarées dans l'exemple ci-dessus peuvent même être employées pour contenir différents types de variables à l'intérieur d'un même programme. Même si ce dernier point procure une grande souplesse, mieux vaut restreindre une variable à un type unique. Lorsque StarOffice Basic rencontre un type de variable défini de façon incorrecte pour un contexte particulier, il génère un message d'erreur. Utilisez la syntaxe suivante pour déclarer une variable associée à un type particulier : Dim MyVar As Integer ' Déclaration d'une variable de type entier La variable est déclarée en tant qu'entier et peut contenir des valeurs numériques entières. Vous avez également la possibilité d'utiliser la syntaxe suivante pour déclarer une variable de type entier : Dim MyVar% ' Déclaration d'une variable du type entier L'instruction Dim peut être utilisée pour la déclaration de plusieurs variables : Dim MyVar1, MyVar2 Pour assigner aux variables un type permanent, vous devez procéder séparément pour chacune : Dim MyVar1 As Integer, MyVar2 As Integer Si vous ne spécifiez pas de type pour une variable, StarOffice Basic considère qu'elle est de type variant. Par exemple, dans la déclaration de variable suivante, MyVar1 est de type variant et MyVar2 de type entier : Dim MyVar1, MyVar2 As Integer Les sections suivantes dressent la liste des types de variables disponibles dans StarOffice Basic et indiquent la façon de les utiliser et de les déclarer. Chaînes de caractèresLes chaînes de caractères constituent, avec les nombres, les types de base les plus importants de StarOffice Basic. Une chaîne est constituée d'une suite de caractères consécutifs. L'ordinateur stocke les chaînes en interne sous forme d'une suite de nombres, où chacun correspond à un caractère particulier. D'un ensemble de caractères ASCII à UnicodeLes ensembles de caractères font la correspondance entre les caractères d'une chaîne et les codes correspondants (chiffres et lettres) dans un tableau qui décrit comment l'ordinateur affiche la chaîne. Le jeu de caractères ASCIILe jeu de caractères ASCII est un ensemble de codes représentant les chiffres, les caractères et les symboles spéciaux sur un octet. Les codes ASCII de 0 à 127 représentent l'alphabet et des symboles courants (comme les points, les virgules et les parenthèses) ainsi que certains caractères de contrôle spéciaux pour l'affichage à l'écran ou l'impression. Le jeu de caractères ASCII est couramment utilisé comme format standard pour l'échange de données texte entre ordinateurs. Cependant, il manque notamment à ce jeu toute une plage de caractères spéciaux employés en Europe, comme â, ä et î, ainsi que d'autres formats de caractères, comme l'alphabet cyrillique. Le jeu de caractères ANSIMicrosoft a utilisé pour son produit Windows le jeu de caractères ANSI (American National Standards Institute) qui a été peu à peu étendu pour inclure les caractères absents du jeu de caractères ASCII. Pages de codeLes ensembles de caractères ISO 8859 constituent une norme internationale. Les 128 premiers caractères du jeu ISO correspondent au jeu de caractères ASCII. Le standard ISO apporte de nouveaux jeux de caractères (pages de code) afin de pouvoir afficher correctement un plus grand nombre de langues. L'inconvénient est cependant qu'une même valeur peut représenter différents caractères dans différentes langues. UnicodeUnicode augmente la longueur d'un caractère à quatre octets et combine différents jeux de caractères afin de créer un standard permettant de représenter autant de langues que possible. La version 2.0 d'Unicode est à présent prise en charge par de nombreux programmes, dont StarOffice et StarOffice Basic. Variables de chaîne de caractèresStarOffice Basic enregistre les chaînes de caractères comme des variables de chaîne de caractères en Unicode. Une variable de chaîne de caractères peut contenir jusqu'à 65 535 caractères. En interne, StarOffice Basic enregistre la valeur Unicode associée à chaque caractère. La mémoire de travail nécessaire pour une variable de chaîne de caractères dépend de la longueur de celle-ci. Exemple de déclaration d'une variable de chaîne de caractères : Dim Variable As String Vous pouvez également écrire cette déclaration sous la forme : Dim Variable$ Remarque – Lorsque vous portez des applications VBA, assurez-vous que la longueur maximale autorisée pour les chaînes de caractères dans StarOffice Basic est bien respectée (65 535 caractères). Spécification de chaînes explicitesPour assigner une chaîne explicite à une variable de chaîne de caractères, placez la chaîne entre guillemets ("). Dim MyString As String MyString = " This is a test" Pour répartir une chaîne sur deux lignes, ajoutez un signe plus à la fin de la première : Dim MyString As String
MyString = "This string is so long that it" + _
"has been split over two lines."
Pour insérer un guillemet (") dans une chaîne, saisissez-en deux consécutifs à l'endroit voulu : Dim MyString As String MyString = "a ""-quotation mark." ' donne un " (guillemet) NombresStarOffice Basic prend en charge cinq types de base pour traiter les nombres :
Variables entières (Integer)Les variables de type entier (Integer) peuvent stocker tout nombre entier compris entre -32 768 et 32 767. Un entier peut occuper jusqu'à deux octets de mémoire. Pour déclarer une variable de type entier, on utilise le signe %. Les calculs utilisant des variables entières sont très rapides et particulièrement utiles pour les compteurs de boucles. Si vous assignez un nombre à virgule flottante à une variable de type entier, il est arrondi au nombre entier le plus proche. Exemples de déclaration pour des variables entières : Dim Variable As Integer Dim Variable% Variables entières longues (Long)Les variables de type entier long (Long) peuvent stocker tout nombre entier compris entre -2 147 483 648 et 2 147 483 647 et peuvent occuper jusqu'à quatre octets de mémoire. Pour déclarer une variable de type entier long, on utilise le signe &. Les calculs utilisant des variables entières longues sont très rapides et particulièrement utiles pour les compteurs de boucles. Si vous affectez un nombre à virgule flottante à une variable entière, il est arrondi au nombre entier le plus proche. Exemples de déclaration pour des variables de type entier long : Dim Variable as Long Dim Variable& Variables simples (Single)Les variables simples (Single) peuvent stocker tout nombre à virgule flottante positif ou négatif compris entre 3.402823 x 1038 et 1.401298 x 10-45. Une variable de type simple peut occuper jusqu'à quatre octets de mémoire. Pour déclarer une variable de type simple, on utilise le symbole "!". À l'origine, les variables de type simple servaient à réduire le temps de calcul exigé par les variables doubles, plus précises. Cependant, ces considérations de rapidité ne sont plus vraiment pertinentes, ce qui réduit l'intérêt des variables de type simple. Exemples de déclaration pour des variables simples : Dim Variable as Single Dim Variable! Variables doubles (Double)Les variables de type double peuvent stocker tout nombre à virgule flottante positif ou négatif compris entre 1.79769313486232 x 10308 et 4.94065645841247 x 10-324. Une variable de type double peut occuper jusqu'à huit octets de mémoire. Les variables doubles peuvent être utilisées pour des calculs précis. Pour déclarer une variable de type double, on utilise le signe #. Exemples de déclarations de variables doubles : Dim Variable As Double Dim Variable# Variables monétaires (Currency)Les variables monétaires (Currency) diffèrent des autres types de variables par la manière dont elles gèrent les valeurs. Le signe décimal est fixe et suivi de quatre décimales. La variable peut compter jusqu'à 15 chiffres pour sa partie entière. Une variable monétaire peut stocker toute valeur comprise entre -922 337 203 685 477,5808 et +922 337 203 685 477,5807 et peut occuper jusqu'à huit octets de mémoire. Pour déclarer une variable monétaire, on utilise le signe @. Les variables monétaires sont surtout destinées aux calculs financiers qui génèrent des erreurs d'arrondi imprévisibles dues à l'emploi de nombres à virgule flottante. Exemples de déclaration de variables monétaires : Dim Variable As Currency Dim Variable@ Spécification de nombres explicitesLes nombres peuvent être représentés de différentes manières, par exemple au format décimal ou en notation scientifique, voire dans une base différente du système décimal. Les règles suivantes s'appliquent aux caractères numériques dans StarOffice Basic : Nombres entiersLa méthode la plus simple consiste à utiliser des nombres entiers. Ils sont représentés dans le texte source, sans espace pour séparer le chiffre des milliers : Dim A As Integer Dim B As Float A = 1210 B = 2438 Les nombres peuvent être précédés d'un signe plus (+) ou moins (-) (avec ou sans espace après le signe) : Dim A As Integer Dim B As Float A = + 121 B = - 243 Nombres décimauxLorsque vous saisissez un nombre décimal, séparez la partie entière de la partie décimale à l'aide d'un point (.). Ainsi, les textes sources peuvent être transférés d'un pays à un autre sans conversion. Dim A As Integer Dim B As Integer Dim C As Float A = 1223.53 ' est arrondi B = - 23446.46 ' est arrondi C = + 3532.76323 Vous pouvez utiliser les signes "+" et "-" comme préfixes aux nombres décimaux (ici aussi, avec ou sans espace). Si vous assignez un nombre décimal à une variable entière, StarOffice Basic l'arrondit par excès ou par défaut. Notation exponentielleStarOffice Basic permet d'écrire les nombres en notation exponentielle ; vous pouvez par exemple écrire 1.5e-10 pour représenter le nombre 1,5 × 10-10 (0.00000000015). La lettre "e" peut être majuscule ou minuscule et précédée ou non d'un signe plus (+). Voici quelques exemples corrects et incorrects de nombres au format exponentiel : Dim A As Double
A = 1.43E2 ' Correct
A = + 1.43E2 ' Correct (espace entre le signe + et le nombre de base)
A = - 1.43E2 ' Correct (espace entre le signe - et le nombre de base)
A = 1.43E-2 ' Correct (exposant négatif)
A = 1.43E -2 ' Incorrect (les espaces sont interdits à
' l'intérieur des nombres)
A = 1,43E-2 ' Incorrect (les virgules sont interdites
' pour séparer la partie décimale)
A = 1.43E2.2 ' Incorrect (l'exposant doit être un nombre entier)
Notez que les premier et troisième exemples incorrects ne génèrent aucun message d'erreur, bien qu'ils renvoient des valeurs incorrectes. L'expression : A = 1.43E -2 est interprétée comme 1,43 moins 2, soit -0,57. C'est pourtant la valeur 1.43 * 102 (correspondant à 0,0143) qui était attendue. Avec la valeur : A = 1.43E2.2 StarOffice Basic ignore la partie de l'exposant après le point et considère l'expression comme étant : A = 1.43E2 Valeurs hexadécimalesDans le système hexadécimal (base 16), un nombre à deux chiffres correspond exactement à un octet. Ceci permet de gérer les nombres d'une manière reflétant plus fidèlement l'architecture de la machine. Dans le système hexadécimal, les nombres sont représentés au moyen des chiffres de 0 à 9 et des lettres de A à F. La lettre A correspond au nombre 10 en décimal et la lettre F au nombre 15. Pour utiliser des valeurs hexadécimales pour les nombres entiers dans StarOffice Basic, il suffit de les faire précéder par &H. Dim A As Long A = &HFF ' Valeur hexadécimale FF, correspondant à la valeur décimale 255 A = &H10 ' Valeur hexadécimale 10, correspondant à la valeur décimale 16 Valeurs octalesStarOffice Basic comprend également le système octal (base 8), qui utilise les chiffres 0 à 7. Les valeurs dans cette base doivent être précédées de &O. Dim A As Long A = &O77 ' Valeur octale 77, correspondant à la valeur décimale 63 A = &O10 ' Valeur octale 10, correspondant à la valeur décimale 8 True (vrai) et False (faux)Variables booléennesLes variables booléennes ne peuvent prendre que deux valeurs : True (vrai) et False (faux). Elles sont adaptées aux spécifications binaires qui ne peuvent avoir que deux états. Une valeur booléenne est enregistrée en interne sous forme d'entier sur deux octets, 0 correspondant à False et toute autre valeur à True. Il n'existe pas de symbole de déclaration de type pour les variables booléennes. La déclaration ne peut se faire qu'en utilisant la mention supplémentaire As Boolean. Exemple de déclaration d'une variable booléenne : Dim Variable As Boolean Date et heureVariables de dateLes variables de date peuvent contenir des valeurs de date et d'heure. Lors de l'enregistrement de valeurs de date, StarOffice Basic emploie un format interne permettant d'effectuer des comparaisons et des opérations mathématiques sur les heures et les dates. Il n'existe pas de symbole de déclaration de type pour les variables de date. La déclaration ne peut se faire qu'en utilisant la mention supplémentaire As Date. Exemple de déclaration d'une variable de date : Dim Variable As Date Champ de donnéesOutre les variables simples (scalaires), StarOffice Basic prend en charge des champs de données (matrices). Un champ de données contient plusieurs variables adressées au moyen d'un index. Matrices simplesUne déclaration de matrice est similaire à celle d'une variable simple. Cependant, contrairement aux variables, le nom de la matrice est suivi de parenthèses dont le contenu spécifie le nombre d'éléments. L'expression : Dim MyArray(3) déclare une matrice de quatre variables de type variant, à savoir MyArray(0), MyArray(1), MyArray(2) et MyArray(3). Vous pouvez également spécifier le type de variables contenues dans une matrice. Par exemple, la ligne suivante déclare une matrice de quatre variables de type entier : Dim MyInteger(3) As Integer Dans les exemples précédents, l'index de la matrice commence toujours par la valeur initiale standard de zéro. Il est également possible de spécifier une plage de validité (valeurs initiale et finale) lors de la déclaration du champ de données. L'exemple suivant déclare un champ de données comprenant six valeurs entières, pouvant être adressées par des valeurs d'index de 5 à 10 : Dim MyInteger(5 To 10) Les valeurs d'index ne sont pas nécessairement positives. L'exemple suivant montre également une déclaration correcte, mais avec des limites négatives pour le champ de données. Dim MyInteger(-10 To -5) Il déclare un champ de données d'entiers comprenant 6 valeurs, pouvant être adressées par des valeurs d'index allant de -10 à -5. Il y a trois limites à respecter lorsque vous définissez des valeurs d'index pour un champ de données :
Remarque – D'autres limites peuvent s'appliquer aux valeurs d'index pour les champs de données dans VBA. La même considération s'applique également au nombre maximum d'éléments possibles par dimension. Vous trouverez les valeurs qui s'appliquent ici dans la documentation VBA appropriée. Valeur spécifique pour l'index de débutGénéralement, l'index de début d'un champ de données est 0, mais vous pouvez changer cette valeur par défaut en 1 pour toutes les déclarations de champ de données grâce à l'appel : Option Base 1 Cet appel doit être inclus dans l'en-tête d'un module si vous voulez qu'il s'applique à l'ensemble des déclarations de matrice du module. Cependant, cet appel n'affecte pas les séquences UNO définies par l'API StarOffice dont l'index commence toujours à 0. Pour plus de clarté, évitez d'utiliser Option Base 1. Option Base 1 se contente de modifier la valeur d'index de début et n'affecte pas le nombre d'éléments d'une matrice. La déclaration : Option Base 1 ' ... Dim MyInteger(3) crée 4 variables entières qui peuvent être désignées par les expressions MyInteger(1), MyInteger(2), MyInteger(3) et MyInteger(4). Remarque – Dans StarOffice Basic, l'expression Option Base 1 n'affecte pas le nombre d'éléments d'une matrice, contrairement à ce qui se produit dans VBA. Dans StarOffice Basic, seul l'index de début est modifié. La déclaration MyInteger(3) crée trois valeurs entières dans VBA avec des valeurs d'index de 1 à 3, tandis que la même déclaration dans StarOffice Basic crée quatre valeurs entières avec des valeurs d'index de 1 à 4. Avec Option Compatible, StarOffice Basic se comporte comme VBA. Champs de données multidimensionnelsOutre les champs de données à une dimension, vous pouvez créer des champs de données multidimensionnels dans StarOffice Basic. Les différentes dimensions sont séparées les unes des autres par des virgules. L'exemple : Dim MyIntArray(5, 5) définit une matrice d'entiers à deux dimensions, comportant chacune six index (pouvant être adressées par les valeurs d'index de 0 à 5). La matrice peut stocker un total de 6 × 6 = 36 valeurs entières. Théoriquement, vous pouvez définir dans StarOffice Basic des matrices ayant des centaines de dimensions. Cependant, en pratique, ce nombre est limité par la quantité de mémoire dont vous disposez. Modifications dynamiques des dimensions des champs de donnéesDans les exemples précédents, les dimensions des champs de données étaient spécifiées. Il est également possible de définir des matrices dont la dimension des champs de données change de façon dynamique. Vous pouvez par exemple définir une matrice pour contenir tous les mots d'un texte commençant par la lettre A. Comme le nombre de ces mots n'est pas connu au départ, vous devez pouvoir modifier les limites du champ par la suite. Pour effectuer cette opération dans StarOffice Basic, utilisez l'appel de fonction suivant : ReDim MyArray(10) Remarque – Contrairement à VBA, où seules les matrices dynamiques peuvent être dimensionnées avec Dim MyArray(), StarOffice Basic permet de modifier les matrices statiques et dynamiques grâce à ReDim. L'exemple suivant modifie la dimension de la matrice initiale pour qu'elle puisse stocker 11 ou 21 valeurs : Dim MyArray(4) As Integer ' Déclaration avec cinq éléments ' ... ReDim MyArray(10) As Integer ' Passe à 11 éléments ' ... ReDim MyArray(20) As Integer ' Passe à 21 éléments Lorsque vous redéfinissez les dimensions d'une matrice, vous pouvez utiliser chacune des options présentées dans les sections précédentes. Cela comprend notamment les déclarations de champs de données multidimensionnels et les spécifications explicites de valeurs d'index de début et de fin. Lors de la modification des dimensions d'un champ de données, tout son contenu est perdu. Pour conserver les valeurs d'origine, utilisez la commande Preserve : Dim MyArray(10) As Integer ' Définition des dimensions
' initiales
' ...
ReDim Preserve MyArray(20) As Integer ' Augmente le champ de
' données sans affecter
' le contenu
Lorsque vous utilisez Preserve, assurez-vous que le nombre de dimensions et le type de variable restent les mêmes. Remarque – Contrairement à VBA, où seule la limite supérieure de la dernière dimension peut être modifiée lorsque la commande Preserve est utilisée, StarOffice Basic permet de modifier également les autres dimensions. Si vous utilisez ReDim avec Preserve, vous devez employer le même type de données que celui qui a été indiqué lors de la déclaration initiale du champ de données. Portée et durée de vie des variablesUne variable dans StarOffice Basic est créée avec une durée de vie limitée, ainsi qu'une portée limitée qui détermine à partir de quel point du programme elle peut être lue et utilisée. La durée pendant laquelle une variable est conservée ainsi que les endroits depuis lesquels il est possible d'y accéder dépendent de son emplacement et de son type. Variables localesLes variables déclarées dans une fonction ou une procédure sont appelées variables locales : Sub Test Dim MyInteger As Integer ' ... End Sub Les variables locales ne restent valides que durant l'exécution de la fonction ou de la procédure et sont ensuite réinitialisées à zéro. À chaque nouvel appel de la fonction, les valeurs générées précédemment ne sont plus disponibles. Pour conserver les valeurs précédentes, il faut définir la variable comme statique : Sub Test Static MyInteger As Integer ' ... End Sub Remarque – Contrairement à VBA, StarOffice Basic s'assure que le nom d'une variable locale n'est pas utilisé simultanément comme nom de variable globale et privée dans l'en-tête du module. Lorsqu'une application VBA est portée vers StarOffice Basic, il faut modifier tous les noms de variable dupliqués. Variables du domaine publicLes variables du domaine public sont définies dans la section d'en-tête d'un module par le mot-clé Dim. Ces variables sont accessibles à tous les modules de leur bibliothèque : Module A : Dim A As Integer Sub Test Flip Flop End Sub Sub Flip A = A + 1 End Sub Module B : Sub Flop A = A - 1 End Sub La valeur de la variable A n'est pas modifiée par la fonction Test, mais elle est augmentée de un dans la fonction Flip et diminuée de un dans la fonction Flop. Ces deux modifications sont globales. Vous pouvez également employer le mot-clé Public à la place de Dim pour déclarer une variable du domaine public : Public A As Integer Une variable du domaine public n'est accessible que durant l'exécution de la macro associée et est ensuite réinitialisée. Variables globalesDu point de vue de leur fonction, les variables globales sont semblables aux variables du domaine public, si ce n'est que leurs valeurs sont conservées même après l'exécution de la macro associée. Les variables globales sont déclarées dans la section d'en-tête d'un module avec le mot-clé Global : Global A As Integer Variables privéesLes variables privées ne sont accessibles que dans le module à l'intérieur duquel elles ont été définies. Pour définir une variable privée, utilisez le mot-clé Private : Private MyInteger As Integer Si plusieurs modules contiennent une variable privée portant le même nom, StarOffice Basic crée une variable différente pour chaque occurrence. Dans l'exemple suivant, chacun des modules A et B possède une variable privée C. Dans la fonction Test, la variable privée est définie une première fois dans le moduleA, puis définie à nouveau dans le module B. Module A : Private C As Integer Sub Test SetModuleA ' Définit la variable C du module A SetModuleB ' Définit la variable C du module B ShowVarA ' Affiche la variable C du module A (= 10) ShowVarB ' Affiche la variable C du module B (= 20) End Sub Sub SetmoduleA A = 10 End Sub Sub ShowVarA MsgBox C ' Affiche la variable C du module A. End Sub Module B : Private C As Integer Sub SetModuleB A = 20 End Sub Sub ShowVarB MsgBox C ' Affiche la variable C du module B. End Sub End Sub ConstantesDans StarOffice Basic, le mot-clé Const permet de déclarer une constante. Const A = 10 Vous pouvez aussi préciser le type de la constante dans la déclaration : Const B As Double = 10 OpérateursStarOffice Basic comprend les opérateurs mathématiques, logiques et de comparaison courants. Opérateurs mathématiquesLes opérateurs mathématiques s'appliquent à tous les types de nombres. L'opérateur + peut également servir à relier des chaînes de caractères.
Opérateurs logiquesLes opérateurs logiques permettent de lier des éléments selon les règles de l'algèbre de Boole. Si les opérateurs sont appliqués à des valeurs booléennes, la liaison fournit directement le résultat voulu. S'ils sont utilisés en combinaison avec des entiers ou des entiers longs, la liaison est réalisée au niveau des bits.
Opérateurs de comparaisonLes opérateurs de comparaison peuvent s'appliquer à tous les types de variables élémentaires (nombres, dates, chaînes et valeurs booléennes).
Remarque – StarOffice Basic ne prend pas en charge l'opérateur de comparaison VBA Like. Instructions conditionnellesLes instructions conditionnelles permettent de n'exécuter un bloc de code que lorsqu'une condition particulière est remplie. If...Then...ElseL'instruction conditionnelle la plus courante est l'instruction If, comme dans l'exemple suivant : If A > 3 Then B = 2 End If L'assignation B = 2 ne se produit que si la valeur de la variable A est supérieure à trois. La clause If/Else est une variante de l'instruction If : If A > 3 Then B = 2 Else B = 0 End If Dans cet exemple, la variable B reçoit la valeur 2 si la variable A est supérieure à 3. Sinon B reçoit la valeur 0. Pour les situations plus complexes, vous pouvez imbriquer plusieurs instructions If, comme dans l'exemple suivant : If A = 0 Then B = 0 ElseIf A < 3 Then B = 1 Else B = 2 End If Si la valeur de la variable A est zéro, alors B reçoit la valeur 0. Si A est inférieure à 3 (mais non égale à zéro), alors B reçoit la valeur 1. Dans tous les autres cas (c'est-à-dire si A est supérieure ou égale à 3), B reçoit la valeur 2. Select...CaseL'instruction Select...Case constitue une alternative à l'imbrication des instructions If. Elle permet d'employer une même variable pour plusieurs conditions : Select Case DayOfWeek Case 1: NameOfWeekday = "Sunday" Case 2: NameOfWeekday = "Monday" Case 3: NameOfWeekday = "Tuesday" Case 4: NameOfWeekday = "Wednesday" Case 5: NameOfWeekday = "Thursday" Case 6: NameOfWeekday = "Friday" Case 7: NameOfWeekday = "Saturday" End Select Dans cet exemple, chaque jour de la semaine correspond à un nombre, de telle manière que la variable DayOfWeek a la valeur 1 pour Sunday, la valeur 2 pour Monday, etc. La commande Select n'est pas limitée aux correspondances directes : vous pouvez également utiliser des opérateurs de comparaison ou des listes d'expressions dans une instruction Case. Les exemples suivants illustrent les variantes syntaxiques majeures de la commande : Select Case Var Case 1 To 5 ' ... La variable Var est comprise entre 1 et 5 Case 6, 7, 8 ' ... Var est égale à 6, 7 ou 8 Case Var > 8 And Var < 11 ' ... Var est supérieur à 8 et inférieur à 11 Case Else ' ... Tous les autres cas End Select BouclesUne boucle répète l'exécution d'un bloc de code un nombre de fois donné. Certaines boucles peuvent également se répéter indéfiniment. For...NextLa boucle For...Next effectue un nombre de passages déterminé. Le compteur de la boucle définit le nombre de fois qu'elle sera répétée. Dans l'exemple suivant : Dim I For I = 1 To 10 ' ... Corps de la boucle Next I la variable I est le compteur de la boucle, avec une valeur initiale de 1. Le compteur est incrémenté de 1 à la fin de chaque passage. Lorsque la variable I vaut 10, la boucle s'arrête. Pour que le compteur de la boucle soit incrémenté d'une valeur supérieure à 1 à chaque passage, utilisez la fonction Step : Dim I For I = 1 To 10 Step 0.5 ' ... Corps de la boucle Next I Dans l'exemple précédent, le compteur est incrémenté de 0,5 à la fin de chaque passage, et la boucle est exécutée 19 fois. Vous pouvez également utiliser des valeurs de pas négatives : Dim I For I = 10 To 1 Step -1 ' ... Corps de la boucle Next I Dans cet exemple, le compteur commence à 10 et décroît de 1 à chaque passage jusqu'à atteindre la valeur 1. L'instruction Exit For permet de sortir prématurément d'une boucle For. Dans l'exemple suivant, la boucle se termine au cinquième passage : Dim I For I = 1 To 10 If I = 5 Then Exit For End If ' ... Corps de la boucle Next I Remarque – La variante For Each...Next de VBA n'est pas prise en charge dans StarOffice Basic. Do...LoopL'instruction Do...Loop n'est pas liée à un nombre de passages fixe. En revanche, la boucle Do...Loop est répétée jusqu'à ce qu'une certaine condition soit remplie. Il existe quatre variantes de la boucle Do...Loop (les exemples suivants utilisent la condition A > 10) :
Tout comme pour la boucle For...Next, il est possible de sortir de la boucle Do...Loop avant la fin. La commande Exit Do permet d'interrompre une boucle à n'importe quel endroit. Do
If A = 4 Then
Exit Do
End If
' ... Corps de la boucle
While A > 10
Exemple de programme : tri à l'aide de boucles imbriquéesLes boucles ont diverses fonctions, notamment la recherche dans des listes, le renvoi de valeurs ou l'exécution de tâches mathématiques complexes. L'exemple suivant constitue un algorithme utilisant des boucles pour trier une liste par nom. Sub Sort
Dim Entry(1 To 10) As String
Dim Count As Integer
Dim Count2 As Integer
Dim Temp As String
Entry(1) = "Patty"
Entry(2) = "Kurt"
Entry(3) = "Thomas"
Entry(4) = "Michael"
Entry(5) = "David"
Entry(6) = "Cathy"
Entry(7) = "Susie"
Entry(8) = "Edward"
Entry(9) = "Christine"
Entry(10) = "Jerry"
For Count = 1 To 10
For Count2 = Count + 1 To 10
If Entry(Count) > Entry(Count2) Then
Temp = Entry(Count)
Entry(Count) = Entry(Count2)
Entry(Count2) = Temp
End If
Next Count2
Next Count
For Count = 1 To 10
Print Entry(Count)
Next Count
End Sub
Les valeurs sont interverties deux par deux plusieurs fois, jusqu'à ce qu'elles se trouvent classées par ordre croissant. Comme des bulles, les variables remontent peu à peu vers la bonne position. C'est pourquoi cet algorithme est connu sous le nom de tri à bulles. Procédures et fonctionsLes procédures et les fonctions sont les éléments centraux de la structure d'un programme. Elles forment le cadre permettant de diviser un problème complexe en différentes sous-tâches. ProcéduresUne procédure exécute une action sans fournir de valeur explicite. Sa syntaxe est la suivante : Sub Test ' ... Code de la procédure à proprement parler End Sub Dans l'exemple suivant, la procédure Test définie contient du code accessible depuis n'importe quel endroit du programme. L'appel se fait en insérant le nom de la procédure à l'endroit adapté du programme : Test FonctionsUne function, tout comme une procédure, regroupe un bloc d'instructions à exécuter en une unité logique. Cependant, contrairement à une procédure, une fonction renvoie une valeur de retour. Function Test ' ... Code de la fonction à proprement parler Test = 123 End Function La valeur de retour est assignée par une simple affectation. L'assignation ne doit pas forcément être placée à la fin de la fonction, mais peut au contraire se trouver n'importe où à l'intérieur de celle-ci. La fonction précédente peut être appelée à l'intérieur du programme de la façon suivante : Dim A A = Test Ce code définit une variable A et lui assigne le résultat de la fonction Test. La valeur de retour peut être écrasée plusieurs fois à l'intérieur de la fonction. Comme dans le cas d'une assignation de variable classique, la fonction renvoie la valeur qui lui a été assignée en dernier. Function Test Test = 12 ' ... Test = 123 End Function Dans cet exemple, la valeur de retour de la fonction est 123. Si une affectation est interrompue, la fonction renvoie la valeur zero (le nombre 0 pour les valeurs numériques et une chaîne vide pour les chaînes de caractères). La valeur de retour d'une fonction peut être de tout type. Il se déclare de la même manière que pour une variable : Function Test As Integer ' ... Code de la fonction à proprement parler End Function Si l'indication d'une valeur explicite est interrompue, la valeur de retour sera de type variant. Interruption prématurée d'une procédure ou d'une fonctionDans StarOffice Basic, vous pouvez utiliser les commandes Exit Sub et Exit Function pour mettre fin à une procédure ou à une fonction prématurément, par exemple pour traiter les erreurs. Une telle commande interrompt la procédure ou la fonction et reviennent au programme principal, à l'endroit d'où elle avait été appelée. L'exemple suivant montre une procédure s'interrompant lorsque la variable ErrorOccured prend la valeur True. Sub Test
Dim ErrorOccured As Boolean
' ...
If ErrorOccured Then
Exit Sub
End If
' ...
End Sub
Passage de paramètresLes fonctions et les procédures peuvent recevoir un ou plusieurs paramètres. Les paramètres essentiels doivent être indiqués entre parenthèses après le nom de la fonction ou de la procédure. L'exemple : Sub Test (A As Integer, B As String) End Sub définit une procédure qui attend une valeur entière A et une chaîne B comme paramètres. Les paramètres sont normalement passés par référence dans StarOffice Basic. Les modifications apportées aux variables sont conservées lorsque la procédure ou la fonction se termine : Sub Test
Dim A As Integer
A = 10
ChangeValue(A)
' Le paramètre A a maintenant la valeur 20
End Sub
Sub ChangeValue(TheValue As Integer)
TheValue = 20
End Sub
Dans cet exemple, la variable A définie dans la fonction Test est passée comme paramètre à la fonction ChangeValue. Dans la fonction, A prend la valeur 20 qui est passée à la variable TheValue, elle-même conservée lorsque la fonction se termine. Vous pouvez également passer un paramètre par valeur si vous ne souhaitez pas que les modifications effectuées par la suite sur le paramètre affectent sa valeur d'origine. Pour qu'un paramètre soit passé par valeur, le mot-clé ByVal doit précéder la déclaration de la variable dans l'en-tête de la fonction. Dans l'exemple précédent, si la fonction ChangeValue est remplacée par : Sub ChangeValue(ByVal TheValue As Integer) TheValue = 20 End Sub alors la variable de niveau supérieur A n'est pas affectée par cette modification. Après l'appel de la fonction ChangeValue, la variable A conserve la valeur 10. Remarque – La méthode pour passer les paramètres aux procédures et aux fonctions de StarOffice Basic est identique à celle de VBA. Par défaut, les paramètres sont passés par référence. Pour passer des paramètres par valeur, il faut utiliser le mot-clé ByVal. Dans VBA, le mot-clé ByRef peut également être utilisé pour forcer un paramètre à être passé par référence. Dans StarOffice Basic, par défaut les paramètres sont passés par référence, donc ce mot-clé n'est pas pris en charge. Paramètres facultatifsNormalement, tous les paramètres d'une fonction ou d'une procédure doivent être passés lors de l'appel à cette fonction ou procédure. Cependant, dans StarOffice Basic, vous pouvez indiquer que certains paramètres sont facultatifs. Dans ce cas, si les valeurs correspondantes ne sont pas incluses dans l'appel, StarOffice Basic passe un paramètre vide. Dans l'exemple : Sub Test(A As Integer, Optional B As Integer) End Sub le paramètre A est obligatoire, alors que le paramètre B est facultatif. La fonction IsMissing permet de vérifier si un paramètre a bien été passé. Sub Test(A As Integer, Optional B As Integer)
Dim B_Local As Integer
' Vérifie si le paramètre B est présent
If Not IsMissing (B) Then
B_Local = B ' Le paramètre B est présent
Else
B_Local = 0 ' Le paramètre B n'est pas défini ->
' la valeur par défaut est 0
End If
' ... Début de la fonction elle-même
End Sub
L'exemple commence par tester si le paramètre B a bien été passé, et, le cas échéant, passe le même paramètre à la variable interne B_Local. Si le paramètre correspondant n'est pas défini, la variable B_ Local reçoit à la place la valeur par défaut (en l'occurrence la valeur 0). Remarque – Le mot-clé ParamArray proposé par VBA n'est pas pris en charge dans StarOffice Basic. RécursivitéLa récursivité est maintenant possible dans StarOffice Basic. Une procédure ou une fonction récursive a la possibilité de s'appeler elle-même jusqu'à ce qu'une condition de base soit remplie. Lorsque la fonction est appelée avec cette condition de base, elle renvoie un résultat. L'exemple suivant utilise une fonction récursive pour calculer la factorielle des nombres 42, -42 et 3,14: Sub Main
Msgbox CalculateFactorial( 42 ) ' Affiche 1,40500611775288E+51
Msgbox CalculateFactorial( -42 ) ' Affiche "Invalid number
' for factorial"
Msgbox CalculateFactorial( 3.14 ) ' Affiche "Invalid number
' for factorial!"
End Sub
Function CalculateFactorial( Number )
If Number 0 Or Number Int( Number ) Then
CalculateFactorial = "Invalid number for factorial!"
ElseIf Number = 0 Then
CalculateFactorial = 1
Else
' Voici l'appel récursif :
CalculateFactorial = Number * CalculateFactorial( Number - 1 )
Endif
End Function
L'exemple renvoie la factorielle du nombre 42 en appelant de façon récursive la fonction CalculateFactorial jusqu'à atteindre la condition 0! = 1. Remarque – Les niveaux de récursivité sont définis à différents niveaux selon la plate-forme utilisée. Sous Windows, le niveau de récursivité est 5800. Sous Solaris et Linux, le niveau de récursivité est calculé en fonction d'une évaluation de la taille de la pile. Traitement des erreursLa correction des erreurs est l'une des parties les plus lourdes de la programmation. StarOffice Basic propose de nombreux outils pour simplifier le traitement des erreurs. Instruction On ErrorL'instruction On Error est essentielle pour le traitement des erreurs : Sub Test On Error Goto ErrorHandler ' ... Tâche au cours de laquelle une ' erreur est susceptible de se produire Exit Sub ErrorHandler: ' ... Code particulier pour le traitement de l'erreur End Sub La ligne On Error Goto ErrorHandler définit la façon dont StarOffice Basic réagit en cas d'erreur. L'instruction Goto ErrorHandler indique à StarOffice Basic de quitter la ligne de programme active et d'exécuter le code ErrorHandler: . Commande ResumeLa commande Resume Next reprend le déroulement du programme après l'exécution du code de traitement d'erreur, à partir de la ligne suivant celle où l'erreur s'est produite : ErrorHandler: ' ... Code particulier pour le traitement de l'erreur Resume Next La commande Resume Proceed permet d'indiquer un point particulier où reprendre le programme après le traitement de l'erreur : ErrorHandler: ' ... Code particulier pour le traitement de l'erreur Resume Proceed Proceed: ' ... Le programme reprend ici après l'erreur Pour reprendre un programme sans afficher de message d'erreur lorsqu'une erreur se produit, utilisez la syntaxe suivante : Sub Test On Error Resume Next ' ... Tâche au cours de laquelle une ' erreur est susceptible de se produire End Sub La commande On Error Resume Next doit être utilisée avec précaution, car elle a un effet global. Pour plus d'informations, reportez-vous à la section Astuces pour le traitement d'erreur structuré. Requêtes portant sur les erreursPour traiter une erreur, il est précieux de disposer d'une description de celle-ci et de savoir où et pourquoi elle est survenue :
L'appel : MsgBox "Error " & Err & ": " & Error$ & " (line : " & Erl & ")" indique comment afficher les informations concernant une erreur dans une fenêtre de message. Remarque – VBA regroupe les messages d'erreur dans un objet statistique nommé Err, tandis que StarOffice Basic propose les trois variables : Err, Error$ et Erl. Les informations de statut restent valables jusqu'à ce que le programme rencontre une commande Resume ou On Error, qui les réinitialise. Remarque – Dans VBA, la méthode Err.Clear de l'objet Err réinitialise le statut d'erreur après qu'une erreur s'est produite. Dans StarOffice Basic, les commandes utilisées à cet effet sont On Error et Resume. Astuces pour le traitement d'erreur structuréLa commande de définition On Error et la commande de retour Resume sont toutes deux des variantes de la construction Goto. Pour structurer proprement votre code afin de ne pas générer d'erreurs lorsque vous utilisez cette construction, évitez d'utiliser des commandes de saut sans les surveiller. La plus grande prudence est recommandée lors de l'utilisation de la commande On Error Resume Next, car elle supprime tous les messages d'erreur ouverts. La meilleure solution consiste à n'utiliser qu'une seule approche pour le traitement des erreurs à l'intérieur d'un programme : séparez le traitement des erreurs du code du programme lui-même et ne revenez pas dans le code initial après l'apparition d'une erreur. Voici un exemple de procédure de traitement d'erreur : Sub Example
' Définit un programme de traitement des erreurs au début de la fonction
On Error Goto ErrorHandler
' ... Code du programme en lui-même
' Désactive la fonction gestion d'erreur
On Error Goto 0
' Fin de l'implémentation du programme normal
Exit Sub
' Début du traitement des erreurs
ErrorHandler:
' Vérifie s'il s'agit d'une erreur attendue
If Err = ExpectedErrorNo Then
' ... Gestion de l'erreur
Else
' ... Avertissement d'erreur imprévue
End If
On Error Goto 0 ' Désactive le traitement de l'erreur
End Sub
Cette procédure commence par la définition d'un programme de traitement des erreurs, suivi du code du programme en lui-même. À la fin du code du programme, le traitement d'erreur est désactivé par l'appel On Error Goto 0 et l'implémentation de la procédure se termine par la commande Exit Sub (à ne pas confondre avec End Sub). L'exemple commence par vérifier si le numéro de l'erreur correspond à celui attendu (stocké dans la constante imaginaire ExpectedErrorNo), puis traite l'erreur en conséquence. Si une erreur différente se produit, le système émet un avertissement. Il est important de contrôler le numéro de l'erreur, de manière à pouvoir détecter les erreurs inattendues. L'appel On Error Goto 0 à la fin du code réinitialise les informations sur le statut de l'erreur (le code d'erreur dans les variables système Err) pour permettre l'identification d'une erreur ultérieure. |
|