Difference between revisions of "FR/Documentation/BASIC Guide/Other Instructions"

From Apache OpenOffice Wiki
Jump to: navigation, search
m (Renvoie vers lien en français)
 
(12 intermediate revisions by 3 users not shown)
Line 1: Line 1:
−
{{DISPLAYTITLE:Other Instructions}}
+
{{DISPLAYTITLE:Autres Instructions}}
−
{{Documentation/BASICGuideTOC/v2
+
{{FR/Documentation/BASICGuideTOC/v2
 
|ShowPrevNext=block
 
|ShowPrevNext=block
 
|ShowPrevPage=block
 
|ShowPrevPage=block
−
|PrevPage=Documentation/BASIC Guide/Error Handling
+
|PrevPage=FR/Documentation/BASIC Guide/Error Handling
−
|NextPage=Documentation/BASIC Guide/Runtime Library
+
|NextPage=FR/Documentation/BASIC Guide/Runtime Library
 
|lang=block
 
|lang=block
 
}}
 
}}
Line 10: Line 10:
 
== <tt>Type...End Type</tt> ==
 
== <tt>Type...End Type</tt> ==
  
−
A ''struct'' is a collection of data fields, that can be manipulated as a single item. In older terms, you may think of a struct as a record, or part of a record.
+
Une ''structure'' est une collection de variables qui peuvent être manipulées comme une seule entité. En d'autres termes, on peut faire l'analogie entre une structure et un enregistrement, ou un morceau d'enregistrement.
−
Une ''structure'' est une collection de variables qui peuvent être manipulées comme une seule entité. En d'autres termes, on peut faire l'analogie entre une structure et une enregistrement, ou un morceau d'enregistrement.
+
  
−
The [[Documentation/BASIC Guide/API Intro|API]] often uses pre-defined structs, but these are ''UNO structs'', a highly-specialized kind of struct.
+
L'[[Documentation/BASIC Guide/API Intro|API]] utilise souvent des structures prédéfinies mais ce sont des ''structures UNO'', un type de structure très spécialisé.
−
L'[[Documentation/BASIC Guide/API Intro|API]] utilise souvent des structures prédefinies mais ce sont des ''structures UNO'', un type de structure très specialisé
+
  
  
 
=== Définition ===
 
=== Définition ===
  
−
With the <tt>Type...End Type</tt> statements, you can define your own (non-UNO) structs:
+
Avec l'instruction <tt>Type...End Type</tt>, vous pouvez définir votre propre structure (non-UNO).
−
Avec l'instruction <tt>Type...End Type</tt>, vous pouvez définir votre propre structure (non-UNO)
+
  
 
<source lang="oobas">
 
<source lang="oobas">
 
Type aMenuItem 'déclare le nom de la structure
 
Type aMenuItem 'déclare le nom de la structure
−
     'Défini les champs dans la structure.
+
     'défini les champs dans la structure
−
     'chaque définition ressemble à une instruction DIM, sabs la commande "Dim"
+
     'chaque définition ressemble à une instruction DIM, sans la commande "Dim"
 
     aCommand as String
 
     aCommand as String
 
     aText as String
 
     aText as String
−
End Type 'ferme la définition
+
End Type 'conclut la définition
 
</source>
 
</source>
  
 
=== Instance ===
 
=== Instance ===
  
−
The <tt>Type</tt> definition is only a pattern or template, not a set of actual variables. To make an ''instance'' of the type, actual variables that can be read and stored, use the <tt>Dim as New</tt> statement:
+
La définition <tt>Type</tt> n'est qu'un modèle, pas un ensemble de variables existantes. Pour avoir une ''instance'' de ce type, avec de véritables variables qui peuvent être manipulées, utiliser l'instruction <tt>Dim ... as New</tt> :
−
La définition <tt>Type</tt> n'est qu'un modèle, pas l'ensemble de variables existantes. Pour avoir une ''instance'' de ce type, véritables variables qui peuvent etre manipulées, utiliser l'instruction <tt>Dim ... as New</tt> :
+
  
 
<source lang="oobas">
 
<source lang="oobas">
Line 42: Line 38:
 
=== Portée ===
 
=== Portée ===
  
−
La définition de <tt>Type</tt> doit être écrite au début du module (avant lea première instruction <tt>Sub</tt> ou <tt>Function</tt>)
+
Comme dans l'exemple ci-dessous, la définition de <tt>Type</tt> peut être écrite au début du module (avant la première instruction <tt>Sub</tt> ou <tt>Function</tt>). La définition sera alors utilisable par toutes les routines dans le module.
  
−
Pour le version 3.0 de {{PRODUCTNAME}}, contrairement aux variables, il est impossible de rendre le type déclaré disponible à un autre module.
+
Depuis la version 3.0 de {{PRODUCTNAME}}, et contrairement aux variables, un type déclaré dans un module ne peut pas être utilisé à partir d'un autre module.
  
−
Une instance du nouveau type est une variable et répond donc aux règles de portées des variables (voir [[Documentation/BASIC Guide/Scope of Variables|Scope and Life Span of Variables]]).
+
Une instance du nouveau type est une variable et répond donc aux règles de portées des variables (voir [[FR/Documentation/BASIC Guide/Scope of Variables|Portée et durée de vie des variables]]).
  
−
Un exemple de définition et d'utilisation d'un champ dans une instance est donné dans la section <tt>With...End With</tt>.
+
La section <tt>With...End With</tt> montre un exemple d'usage d'une définition et de référencement d'un champ dans une instance.
  
 
== <tt>With...End With</tt> ==
 
== <tt>With...End With</tt> ==
−
=== Qualifiers ===
+
=== Qualificateurs ===
−
In general, Basic does not look inside a container, such as an <tt>Object</tt>, to see what names might be defined there. If you want to use such a name, you must tell Basic where to look. You do that by using the name of the object as a ''qualifier''. Write it before the inner name, and separate it by a period:
+
En général, Basic ne regarde pas à l'intérieur d'un conteneur, comme un <tt>Object</tt> par exemple, pour déterminer quels noms y sont définis. Si vous voulez utiliser un tel nom, il faut indiquer à Basic où le trouver. Vous pouvez faire ceci en utilisant le nom de l'objet en tant que ''qualificateur''. Le qualificateur s'utilise en amont du nom interne, séparé par un point :
  
−
  MyObject.SomeName
+
  MonObjet.UnNom
  
−
Since containers may hold other containers, you may need more than one qualifier. Write the qualifiers in order, from outer to inner:
+
Comme les conteneurs peuvent contenir d'autres conteneurs, vous pourrez avoir besoin de plus d'un ''qualificateur''. Il vous suffit alors de les indiquer dans l'ordre du plus externe au plus interne :
  
−
  OuterObject.InnerObject.FarInsideObject.SomeName
+
  MonObjet.ObjetFils.ObjetPetitFils.UnNom
  
−
These names may also be described as, "concatenated with the dot-operator ('.')".
+
Cette representation peut être décrite comme "concatenée avec l'opérateur point ('.')".
  
−
=== The <tt>With</tt> Alternative ===
+
=== L'alternative <tt>With</tt> ===
  
−
The <tt>With...End With</tt> bracketing statements provide an alternative to writing out all the qualifiers, every time - and some of the qualifiers in the API can be quite long. You specify the qualifiers in the <tt>With</tt> statement. Until Basic encounters the <tt>End With</tt> statement, it looks for ''partly-qualified'' names: names that begin with a period (unary dot-operator). The compiler uses the qualifiers from the <tt>With</tt> as though they were written in front of the partly-qualified name.
+
L'instruction <tt>With...End With</tt> est une alternative pour ne pas écrire tous les qualificateurs à chaque fois (certains qualificateurs de l'API peuvent être assez longs). Vous spécifiez alors les qualificateurs dans l'instruction <tt>With</tt>. Basic recherche alors les noms partiellement qualifiés qui commencent avec un point jusqu'à ce qu'il rencontre l'instruction <tt>End With</tt>. Le compilateur utilise alors le qualificateur déclaré dans l'instruction <tt>With</tt> pour qualifier ces noms comme si le qualificateur était écrit à chaque fois.
  
−
=== Example 1: A User-defined Struct ===
+
=== Exemple 1: Une structure utilisateur ===
  
−
This example shows how you may define and use a struct, and how to reference the items within it, both with and without <tt>With</tt>. Either way, the names of the data fields (from the <tt>Type</tt> definition) must be qualified by the name of the instance (from the <tt>Dim</tt> statement).
+
Cet exemple montre comment déclarer et utiliser une structure ainsi que comment accéder à ses éléments internes, avec et sans l'instruction <tt>With</tt>
  
 
<source lang="oobas">
 
<source lang="oobas">
Line 75: Line 71:
 
     aText as String
 
     aText as String
 
End Type
 
End Type
−
   
+
 
 
Sub Main
 
Sub Main
−
     'Create an instance of the user-defined struct.
+
     'Crée une instance de la structure
−
     ' Note the keyword, "New".
+
     'Noter le mot-clé, "New"
 
     Dim maItem as New aMenuItem
 
     Dim maItem as New aMenuItem
 
     With maItem
 
     With maItem
Line 90: Line 86:
 
</source>
 
</source>
  
−
=== Example 2: Case statement ===
+
=== Exemple 2: Instruction Case ===
  
−
In [[Documentation/BASIC_Guide/Cells and Ranges|Cells and Ranges]], the following example has the qualifiers in the <tt>Case</tt> statements written out completely, for clarity. You can write it more easily, this way:
+
Dans [[FR/Documentation/BASIC_Guide/Cells and Ranges|Cellules et plages]], le qualificateur est intégralement écrit dans l'instruction <tt>Case</tt>. Cet exemple peut être écrit de manière plus concise :
  
 
<source lang="oobas">
 
<source lang="oobas">
Line 118: Line 114:
 
End With
 
End With
 
</source>
 
</source>
−
Notice that the <tt>With</tt> construct must be entirely outside of the <tt>Select</tt> construct.
+
Notez que l'instruction <tt>With</tt> doit encadrer entièrement l'instruction <tt>Select</tt>.
  
 
{{InterWiki Languages BasicGuide|articletitle=Documentation/BASIC Guide/Other Instructions}}
 
{{InterWiki Languages BasicGuide|articletitle=Documentation/BASIC Guide/Other Instructions}}
 
{{PDL1}}
 
{{PDL1}}

Latest revision as of 13:52, 20 September 2009

doc OOo
Book.png

Type...End Type

Une structure est une collection de variables qui peuvent être manipulées comme une seule entité. En d'autres termes, on peut faire l'analogie entre une structure et un enregistrement, ou un morceau d'enregistrement.

L'API utilise souvent des structures prédéfinies mais ce sont des structures UNO, un type de structure très spécialisé.


Définition

Avec l'instruction Type...End Type, vous pouvez définir votre propre structure (non-UNO). 

Type aMenuItem			'déclare le nom de la structure
    'défini les champs dans la structure
    'chaque définition ressemble à une instruction DIM, sans la commande "Dim"
    aCommand as String		
    aText as String
End Type			'conclut la définition

Instance

La définition Type n'est qu'un modèle, pas un ensemble de variables existantes. Pour avoir une instance de ce type, avec de véritables variables qui peuvent être manipulées, utiliser l'instruction Dim ... as New : 

Dim maItem as New aMenuItem

Portée

Comme dans l'exemple ci-dessous, la définition de Type peut être écrite au début du module (avant la première instruction Sub ou Function). La définition sera alors utilisable par toutes les routines dans le module.

Depuis la version 3.0 de OpenOffice.org, et contrairement aux variables, un type déclaré dans un module ne peut pas être utilisé à partir d'un autre module.

Une instance du nouveau type est une variable et répond donc aux règles de portées des variables (voir Portée et durée de vie des variables).

La section With...End With montre un exemple d'usage d'une définition et de référencement d'un champ dans une instance.

With...End With

Qualificateurs

En général, Basic ne regarde pas à l'intérieur d'un conteneur, comme un Object par exemple, pour déterminer quels noms y sont définis. Si vous voulez utiliser un tel nom, il faut indiquer à Basic où le trouver. Vous pouvez faire ceci en utilisant le nom de l'objet en tant que qualificateur. Le qualificateur s'utilise en amont du nom interne, séparé par un point : 

MonObjet.UnNom

Comme les conteneurs peuvent contenir d'autres conteneurs, vous pourrez avoir besoin de plus d'un qualificateur. Il vous suffit alors de les indiquer dans l'ordre du plus externe au plus interne : 

MonObjet.ObjetFils.ObjetPetitFils.UnNom

Cette representation peut être décrite comme "concatenée avec l'opérateur point ('.')".

L'alternative With

L'instruction With...End With est une alternative pour ne pas écrire tous les qualificateurs à chaque fois (certains qualificateurs de l'API peuvent être assez longs). Vous spécifiez alors les qualificateurs dans l'instruction With. Basic recherche alors les noms partiellement qualifiés qui commencent avec un point jusqu'à ce qu'il rencontre l'instruction End With. Le compilateur utilise alors le qualificateur déclaré dans l'instruction With pour qualifier ces noms comme si le qualificateur était écrit à chaque fois.

Exemple 1: Une structure utilisateur

Cet exemple montre comment déclarer et utiliser une structure ainsi que comment accéder à ses éléments internes, avec et sans l'instruction With 

Type aMenuItem
    aCommand as String
    aText as String
End Type
 
Sub Main
    'Crée une instance de la structure
    'Noter le mot-clé, "New"
    Dim maItem as New aMenuItem
    With maItem
        .aCommand = ".uno:Copy"
        .aText = "~Copy"
    End With
 
    MsgBox     "Command: " & maItem.aCommand & Chr(13) _
            & "Text: " & maItem.aText
End Sub

Exemple 2: Instruction Case

Dans Cellules et plages, le qualificateur est intégralement écrit dans l'instruction Case. Cet exemple peut être écrit de manière plus concise : 

Dim Doc As Object
Dim Sheet As Object
Dim Cell As Object
 
Doc = StarDesktop.CurrentComponent
Sheet = Doc.Sheets(0)
Cell = Sheet.getCellByPosition(1,1)	'Cell "B2" (0-based!)
 
Cell.Value = 1000
 
With com.sun.star.table.CellContentType
  Select Case Cell.Type
    Case .EMPTY 
      MsgBox "Content: Empty"
    Case .VALUE
      MsgBox "Content: Value"
    Case .TEXT
      MsgBox "Content: Text"
    Case .FORMULA
     MsgBox "Content: Formula"
  End Select
End With

Notez que l'instruction With doit encadrer entièrement l'instruction Select.


Content on this page is licensed under the Public Documentation License (PDL).
Retrieved from "https://wiki.openoffice.org/w/index.php?title=FR/Documentation/BASIC_Guide/Other_Instructions&oldid=140846"
Personal tools