Extension:WSArrays/fr

L'extension WSArrays (ou ComplexArrays) crée un ensemble supplémentaire de fonctions d'analyse qui utilisent les tableaux multidimensionnels et associatifs.

Fonctions
Cette extension définit plus de 20 fonctions d'analyse :



complexarraydefine
Cette fonction crée un nouveau tableau identifié par key.

Explications

 * key (required): nom du tableau
 * array (required): tableau en WSON, ou en utilisant un délimiteur.
 * delimiter (optional, default: ,): délimiteur utilisé pour définir un tableau simple.
 * noparse (optional): arguments pour dire à l'analyseur syntaxique quoi rechercher dans array (voir Utiliser l'anayseur).

complexarraydefinedarrays
Cette fonction de débogage crée un nouveau tableau contenant les clés de tous les tableaux actuellement définis.

Explications

 * key (obligatoire) : nom du tableau qui contiendra les clés des tableaux définis actuellement



complexarrayprint
Cette fonction imprime les valeurs du tableau dans un format personnalisé.

Explication

 * key (obligatoire): Nom du (sous)tableau à imprimer;
 * options (optionnel):
 * markup: Imprimez le résultat en WSON.
 * noparse (optionnel): Initialiser à true pour dire à l'analyseur de ne pas traiter la sortie selon la syntaxe wiki.

Exemples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * foo: quz
 * baz: bar
 * 2
 * baz: bar
 * foo: bar
 * 3
 * baz: . UNIQ347fb3f0c7f3d9c-5

complexarraysize
Cette fonction d'analyse renvoie la taille d'un (sous)tableau.

Explanation

 * key (obligatoire): Nom du (sous) tableau
 * options (optionnel):
 * top: ne comptez que le nombre d'éléments dans le tableau principal (et non pas récursivement).

Exemples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * foo: quz
 * baz: bar
 * 2
 * baz: bar
 * foo: bar

complexarrayslice
Cette fonction d'analyse peut extraire une tranche de tableau.

Explanation

 * new_key (obligatoire): nom du tableau à créer
 * key (obligatoire): nom du tableau à segmenter
 * offset (obligatoire): Avec un décalage positif le nouveau tableau commencera à cet index dans le premier tableau. Si le décalage est négatif, il est compté à partir de la fin du premier tableau.
 * length (optionnel): longueur du nouveau tableau.

Exemples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * baz: bar
 * foo: bar
 * 2
 * boo: bar
 * far: quz
 * 3
 * foo: quux
 * bar: bar

complexarraysearch
Cette fonction d'analyse sémantique recherche un mot clé dans un tableau et renvoie la clé correspondant à cette  valeur. Renvoie 0 si rien n'est trouvé.

Explications

 * key (obligatoire): nom du tableau dans lequel se fera la recherche
 * keyword (obligatoire): mot-clé à rechercher.

Examples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * baz: bar
 * foo: bar
 * 2
 * boo: bar
 * far: quz
 * 3
 * foo: quux
 * bar: bar

complexarraysearcharray
Cette fonction d'analyse syntaxique recherche un mot clé dans un tableau et  crée un nouveau tableau avec les clés en cas de correspondance. S'il n'y a pas de correspondance, il renverra 0.

Explanation

 * new_key (obligatoire): nom du tableau à créer contenant toutes les clés
 * key (obligatoire): nom du tableau dans lequel se fera la recherche
 * keyword (obligatoire): mot clé à rechercher.

Examples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * baz: bar
 * foo: bar
 * 2
 * boo: bar
 * far: quz
 * 3
 * foo: quux
 * bar: bar

complexarrayunset
Cette fonction désactive la clé fournie.

Explanation

 * key (obligatoire): clé à désactiver

Examples
On dispose d'un tableau foobar :


 * foo
 * bar
 * qux
 * baz

complexarrayaddvalue
Cette fonction d'analyse syntaxique ajoute une valeur ou un sous-tableau à un tableau existant, ou remplace un sous-tableau existant par cette valeur.

Explanation

 * key (obligatoire): nom du sous tableau à créer
 * value (obligatoire): une valeur en texte simple ou un sous tableau dans n'importe quel langage de balisage pris en charge.

Examples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * foo: quz
 * baz: bar
 * 2
 * baz: bar
 * foo: bar

complexarrayreset
Cette fonction d'analyse syntaxique réinitialise un ou tous les tableaux.

Explanation

 * key (optionnel): nom du tableau à désactiver et si ce nom est à vide alors tous les tableaux seront désactivés.

complexarraysort
Cette fonction d'analyse syntaxique trie un tableau.

Explanation

 * key (obligatoire): tableau à trier
 * options (optionnel):
 * multisort: tri multisort du tableau
 * asort: tri asort du tableau
 * arsort: tri arsort du tableau
 * krsort: tri krsort du tableau
 * natcasesort: tri natcasesort du tableau
 * natsort: tri natsort du tableau
 * rsort: tri rsort du tableau
 * shuffle: mélange le tableau
 * keysort: trier un tableau à deux dimensions en fonction des valeurs d'une clé du deuxième tableau. Vous pouvez modifier l'ordre à descendant en ajoutant ,desc dans les options (donc keysort,desc).
 * sortingkey (optionnel, nécessaire quand keysort est utilisé): clé pour trier le tableau quand keysort est utilisé.

Voir la documentation PHP pour les algorithmes de tri.

Examples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * foo: quz
 * baz: bar
 * 2
 * baz: bar
 * foo: bar

complexarrayunique
Cette fonction d'analyse supprime les clés et les valeurs dupliquées d'un tableau.

Explications

 * key (obligatoire): Nom du tableau.

complexarraypush
Cette fonction d'analyse rajoute une nouvelle valeur ou un sous-tableau à la fin d'un (sous-) tableau existant.

Explications

 * key (obligatoire): nom du (sous) tableau
 * value (obligatoire): valeur en texte simple ou dans un des langages de balisage pris en charge.
 * noparse (optionnel): arguments pour dire à l'analyseur ce qu'il faut rechercher dans subject (voir l'utilisation de l'analyseur).

Exemples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * foo: quz
 * baz: bar
 * 2
 * baz: bar
 * foo: bar

complexarrayextract
Cette fonction d'analyse crée un nouveau tableau à partir d'un sous tableau.

Explication

 * new_key (obligatoire): nom du tableau à créer
 * subarray (obligatoire): sous-tableau à extraire.

Exemples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * baz: bar
 * foo: bar

complexarraymerge
Cette fonction d'analyse crée un nouveau tableau en fusionnant deux ou plusieurs tableaux.

Explication

 * new_key (obligatoire): nom du tableau à créer
 * key1 (obligatoire): nom du premier tableau
 * key2 (obligatoire): nom du deuxième tableau
 * keyn (optionnel): nom du nième tableau
 * options
 * recursive: fusion récursive
 * recursive: fusion récursive

Exemples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * baz: bar
 * foo: bar

et un tableau boofar :


 * 0
 * boo: bar
 * far: quz
 * 1
 * foo: quux
 * bar: bar

complexarraydiff
Cette fonction d'analyse calcule la différence entre deux ou plusieurs tableaux et range le résultat dans un nouveau tableau. Il encode la fonction PHP  pour la protéger.

Explications

 * new_key (obligatoire): nom du tableau à créer
 * key1 (obligatoire): nom du premier tableau
 * key2 (obligatoire): nom du deuxième tableau
 * keyn (optionnel): nom du nème tableau
 * keyn (optionnel): nom du nème tableau

complexarraypusharray
This parser function creates a new array by pushing one or more arrays to the end of another array.

Explications

 * new_key (obligatoire): Nom du tableau à créer
 * key1 (obligatoire): Nom du premier tableau
 * key2 (obligatoire): Le nom du deuxième tableau
 * keyn (optionnel): Nom du nième tableau;
 * keyn (optionnel): Nom du nième tableau;

Exemples
On dispose d'un tableau foobar :


 * 0
 * foo: bar
 * baz: quz
 * 1
 * baz: bar
 * foo: bar

et un tableau boofar :


 * 0
 * boo: bar
 * far: quz
 * 1
 * foo: quux
 * bar: bar

complexarraymap
This parser function iterates over an array and maps the values of the array onto a mapping key.

Explication

 * key (obligatoire): The name of the array that is going to be mapped;
 * mapping_key (obligatoire): mot clé à remplacer dans le sujet
 * subject (obligatoire): chaîne sur laquelle se fera l'analyse des correspondances
 * delimiter (optionnel): délimiteur ajouté à chaque ligne sauf la dernière
 * show (optionnel): Initialiser à  pour afficher la clé de correspondance lorsqu'aucune valeur de chaîne n'existe pour cette clé.

Exemples
On dispose d'un tableau foobar :


 * 0
 * bar
 * quz
 * 1
 * bar
 * bar
 * 2
 * bar
 * quz
 * 3
 * quux

complexarraymaptemplate
This parser function maps the contents of an array in a template.

Explication

 * key (obligatoire): The name of the array that needs to be mapped;
 * template (obligatoire): The name of the template the array must be mapped to.

Exemples
Nous avons respectivement un tableau appelé foobar, un tableau appelé boofar et un tableau appelé bazbar :

foobar:
 * 0
 * foo: bar
 * baz: quz
 * 1
 * baz: bar
 * foo: bar
 * 2
 * foo: quz
 * baz: bar
 * bar
 * bex
 * box

boofar:
 * foobar
 * bazbar
 * boofar

bazbar:
 * foo: bar
 * boo: far

Anonymous
Ces fonctions utilisent des tableaux anonymes. La fonction gère à la fois la définition et la sortie du tableau. You do not have to define an array beforehand.

complexarrayarraymap
This parser function is very similar to #complexarraymap, but the input and output is handled in the same function (which makes it anonymous).

Explication

 * value (obligatoire): Valeur à segmenter
 * delimiter (obligatoire): Délimiteur à utiliser pour la segmentation
 * variable (obligatoire): chaîne à remplacer dans formula
 * formula (obligatoire): Chaîne où variable est à remplacer
 * new_delimiter (obligatoire): Délimiteur entre les résultats.

complexarrayparent
Cette fonction renvoie la clé du parent de la clé donnée.

Explication

 * key (obligatoire): Clé à partir de laquelle la clé parent doit être renvoyée

Exemples


Opérateur Wairudokado
The Wairudokado operator (Japanese: ワイルドカード, pronounced Wairudokādo, meaning wildcard; a tribute to the Scope Resolution Operator in PHP) is a powerful operator that gives users the ability to use wildcards when manipulating or printing subarrays.

Example
This operator can be used on every parser function that supports subarrays (such as ). Suppose we have the array foobar:


 * 0
 * name: Foo
 * 1
 * name: Bar
 * 2
 * name: Baz
 * 3
 * name: Bex

And we want to print every value of "name". We could use a to iterate over the array and print each value seperately, but we can also use a Wairudokado operator in the #complexarrayprint function.

Semantic MediaWiki
This extension introduces a new format for displaying Semantic MediaWiki results. In order to use the new format, use. Because the result printer defines a new complexarray, you need to provide a name for that array using ; if   is left empty, the result printer will print the array as WSON.

Semantic variables
A list of semantic variables is included in the complexarray when you query a list of pages. The following variables are included:


 * catitle: The title of the page
 * cafullurl: The full URL of the page
 * canamespace: The namespace the page lives in
 * caexists: Whether or not the page exists (0/1)
 * cadisplaytitle: The displaytitle of the page

Additional parameters
WSArrays defines two new parameters:


 * name: The name of the array that is going to be created
 * simple: Option to hide Semantic variables from page results as well as hiding mailto: prefixes on email results (yes/no, default: yes)

Seeing tables instead of complex arrays
In case Semantic MediaWiki renders a table when format is, you must first check if you have set   to. If this is the case and it still does not work, WSArrays might not have been able to create a symbolic link from the SemanticMediaWiki folder to the WSArrays folder. This link can be manually created by copying the file  from the extension's root folder to.

Writing extensions
While WSArrays provides many functions for manipulating and showing arrays, sometimes these are not enough. For this reason, we provide an interface to easily extend the functionality of WSArrays with new parser functions.

Extensions are placed in the extensions/ directory. Each extension is implemented as a derived class from. The name of the file in which this class will be located, must be the same as the class name (case-sensitive). An example for the class  would be. The class must implement at least the following methods:

Returning the result
is executed by the parser hook. You can read how to write parser functions here. The documentation below is specific to WSArrays.

Manipulating arrays
All arrays in WSArrays must be stored as a ComplexArray object. If you want to manipulate an existing array, you must convert the ComplexArray object to an array, manipulate the array and then convert it back to a ComplexArray object.

or when using :

Registering the extension
In order to enable the extension, you must add the extension name and aliases to.

Add the following to :

Manipulation of the parser
WSArrays manipulates the Parser in several ways. In order to use WSArrays to its fullest extend, it is important to know about this. This only applies to the following parser functions:


 * 
 * 
 * 

How WSArrays manipulates the parser
WSArrays manipulates the parser by using SFH_OBJECT_ARGS. This way, the parser arguments are passed as PPNode objects instead of plain text. This allows for conditional expansion of the parse tree (see doc.wikimedia.org for more information). Using SFH_OBJECT_ARGS we can tell the parser to not parse the elements and return the raw text inputted by the user, which we can then parse in WSArrays.

How to control the manipulation
Different people have different needs, which is why we allow you to control the manipulation of the parser. Again, this documentation only applies to the parser functions listed above.

By default, all input is automatically parsed by the parser before it is passed over to WSArrays (except for the 'map' in and .) This allows you to use template parameters as well as magic words and templates when manipulating or defining arrays. This is however not always what you want. For instance, when you want to use a very complex template inside of an array, and you don't want to completely break when you use on it, you can tell WSArrays to not parse the input. If you then print the array, the template is printed as if it were enclosed with nowiki tags.

What if I want to parse the template later on?
Not parsing the template entirely is probably not what you want. WSArrays tells the parser to parse the element when necessary, such as when using it in a map or when printing it as a value.

Arguments
You can include the following arguments as a comma-separated list in the 'noparse'-parameter of any applicable function.

Using WSArrays in other extensions
WSArrays provides an interface to easily use, manipulate and create arrays from any extension in the wiki.

Initialisation
In order to use the interface, include the  class into your extension, like so:

Getting the contents of an array
The contents of the array "foobar" can be retrieved like so:

Getting the contents of a subarray
The contents of "foobar[Foo][Bar]" can be retrieved like so:

Changing the contents of an array
The contents of the array "foobar" can be changed like so:

The contents of a specific value or subarray can also be changed like so:

Unsetting an array
An array can be unset like so:

Configuration
WSArrays possède quelques paramètres de configuration.


 * Option to skip version control and force the initialization of WSArrays, accepts a boolean (default: false). This may crash your wiki.
 * Option to skip version control and force the initialization of WSArrays, accepts a boolean (default: false). This may crash your wiki.


 * Option to enable the Semantic MediaWiki result printer, accepts a boolean (default: false). Setting this to true if you have not correctly installed the result printer (see ) will result in your wiki not working.
 * Option to enable the Semantic MediaWiki result printer, accepts a boolean (default: false). Setting this to true if you have not correctly installed the result printer (see ) will result in your wiki not working.