Extension:WSArrays

Varování:

This extension is incompatible with plans to parallelize parsing, as is intended by the use of Parsoid . Therefore, the future of this extension is uncertain, and it is expected to become incompatible with the standard MediaWiki parser within a few years. For further information, see úkol T250963 and No support for sequential, in-order processing of extension tags .

Základní informace k tomuto rozšíření MediaWiki

WSArrays Stav rozšíření: bez správce
Zavádění	Funkce analyzátoru
Popis	Přidává funkce analyzátoru, které umožňují vytváření a procházení asociativních a vícerozměrných polí.
Napsal(i)	Wikibase Solutions
Nejnovější verze	5.5.4 (2022-09-12)
MediaWiki	1.31+
PHP	5.3+
Změny v databázi	Ne
Licence	GNU General Public License 2.0 nebo pozdější
Zdrojový kód	GitLab: stránka projektu URL úložiště git [nápověda ] zobrazit historii Poznámka: translatewiki.net neposkytuje žádné aktualizace lokalizace.
Parametry $wfSkipVersionControl $wfEnableResultPrinter
Použité háčky (hooks) ParserFirstCallInit

Rozšíření WSArrays (nebo ComplexArrays) vytváří další sadu funkcí analyzátoru, které fungují na vícerozměrných a asociativních polích.

Funkce

Toto rozšíření definuje více než 20 funkcí analyzátoru:

Název funkce	Aliasy
#complexarraydefine	#cadefine
#complexarrayprint	#caprint
#complexarraypush	#capush
#complexarraysize	#casize
#complexarrayaddvalue	#caaddvalue, #caadd, #caaddv, #caset
#complexarrayreset	#careset, #caclear
#complexarraysort	#casort
#complexarraymap	#camap
#complexarraymaptemplate	#camaptemplate, #camapt, #catemplate
#complexarrayextract	#caextract
#complexarrayunique	#caunique
#complexarraymerge	#camerge
#complexarraypusharray	#capusharray
#complexarrayslice	#caslice
#complexarraysearch	#casearch
#complexarraysearcharray	#casearcharray, #casearcha
#complexarraydefinedarrays	#cadefinedarrays, #cadefined, #cad
#complexarrayarraymap	#caamap, #camapa
#complexarrayparent	#caparent, #capapa, #camama
#complexarrayunset	#caunset, #caremove
#complexarraydiff	#cadiff

Konstrukce polí

complexarraydefine

Tato funkce vytvoří nové pole označené 'key'.

Syntaxe

{{#complexarraydefine:key|array|delimiter|noparse}}

Zdůvodnění

• key (povinné) – název pole;
• array (povinné) – pole jako WSON nebo pomocí oddělovače.
• delimiter (volitelné, výchozí je: ,) – oddělovač používaný při definování jednoduchého pole.
• noparse (volitelné) – argumenty, které analyzátoru sdělí, co má analyzovat v 'array' (viz #Manipulace s analyzátorem).

Příklady

Definujte vícerozměrné pole s názvem 'baz'	{{#cadefine:baz|(("foo":(("bar":"baz"))))}}
Definujte jednoduché pole nazvané 'bex' (poznámka, někdy WSArrays správně nerozpoznává pole oddělená oddělovači. Zkuste přidat oddělovač namísto použití výchozího (,))	{{#cadefine:bex|foo; bar; baz|;}}

complexarraydefinedarrays

Tato ladicí funkce vytvoří nové pole obsahující klíče všech aktuálně definovaných polí.

Syntaxe

{{#complexarraydefinedarrays: key}}

Zdůvodnění

• key (povinné) – název pole, které bude obsahovat klíče aktuálně definovaných polí

Práce s poli

Extrakce

complexarrayprint

Tato funkce vytiskne hodnoty pole ve vlastním formátu.

Syntaxe

{{#complexarrayprint:key|options|noparse}}

Zdůvodnění

• key (povinné) – název (pod)pole, které má být vytištěno;
• options (volitelné):
  • markup – vytiskněte výsledek jako WSON.
• noparse (volitelné) – nastavením na "true" sdělíte analyzátoru, že výstup nepovažuje za syntaxi wiki.

Příklady

Máme pole nazvané 'foobar':

• 0
  • foo: bar
  • baz: quz
• 1
  • foo: quz
  • baz: bar
• 2
  • baz: bar
  • foo: bar
• 3
  • baz: {{SomeTemplate|Test}}. ?UNIQ347fb3f0c7f3d9c-5

Pokud jste definovali pole pomocí noparse, chování je jiné.

Funkce	Výsledek
{{#caprint: foobar}}	0 foo: bar baz: quz 1 foo: quz baz: bar 2 baz: bar foo: bar 3 baz: Test. {{SomeTemplate|Test}}
{{#caprint: foobar[0]}}	foo: bar baz: quz
{{#caprint: foobar[3]}}	Test. {{SomeTemplate|Test}}
{{#caprint: foobar[0][foo]}}	bar

complexarraysize

Tato funkce analyzátoru vrací velikost (pod)pole.

Syntax

{{#complexarraysize:key|options}}

Explanation

• key (povinné) – název (pod)pole;
• options (volitelné)
  • top – počítejte pouze počet položek v horním poli (ne rekurzivně).

Příklady

Máme pole nazvané 'foobar':

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

Funkce	Výsledek
{{#casize: foobar}}	9
{{#casize: foobar[1]}}	2
{{#casize: foobar|top}}	3

complexarrayslice

Tato funkce analyzátoru může extrahovat řez z pole.

Syntax

{{#complexarrayslice:new_key|key|offset|length}}

Explanation

• new_key (povinné) – název pole, které se má vytvořit;
• key (povinné) – název pole, které je třeba rozdělit na části;
• offset (povinné) – pro kladný offset začne nové pole na tomto offsetu v prvním poli. V případě záporného posunu bude nové pole začínat tak daleko od konce prvního pole;
• length (volitelné) – délka nového pole.

Příklady

Máme pole nazvané foobar:

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

Funkce	Výsledek
{{#caslice: boofar | foobar | 2 | 1 }}	To dává třetí prvek pole. boofar: 0 boo: bar far: quz
{{#caslice: boofar | foobar | -1 }}	To dává poslední prvek pole: boofar: 0 foo: quux bar: bar

complexarraysearch

Tato funkce analyzátoru vyhledává v poli klíčové slovo a vrací odpovídající klíč první shody. Pokud nejsou žádné shody, vrátí 0.

Syntaxe

{{#complexarraysearch:key|keyword}}

Zdůvodnění

• key (povinné) – název pole, které se bude prohledávat;
• keyword (povinné) – klíčové slovo, které se bude hledat.

Příklady

Máme pole nazvané foobar:

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

Funkce	Výsledek
{{#casearch: foobar | quux }}	WSArray[3][foo]
{{#casearch: foobar | bar }}	WSArray[0][foo]

complexarraysearcharray

Tato funkce analyzátoru vyhledá klíčové slovo v poli a vytvoří nové pole s odpovídajícími klíči shod. Pokud nejsou žádné shody, vrátí 0.

Syntax

{{#complexarraysearcharray:new_key|key|keyword}}

Explanation

• new_key (povinné) – název pole, které se má vytvořit, obsahující všechny klíče;
• key (povinné) – název pole, které se bude prohledávat;
• keyword (povinné) – klíčové slovo, které se bude hledat.

Příklady

Máme pole nazvané foobar:

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

Funkce	Výsledek
{{#casearcha: boofar | foobar | bar }}	boofar: foobar[0][foo] foobar[1][baz] foobar[1][foo] foobar[2][boo] foobar[3][bar]
{{#casearcha: boofar | foobar | quux }}	boofar: foobar[3][foo]

Změna

complexarrayunset

Tato funkce zruší nastavení daného klíče.

Syntaxe

{{#complexarrayunset: key }}

Zdůvodnění

• key (povinné) – klíč, který by měl být deaktivován

Příklady

Předpokládejme, že máme pole nazvané "foobar":

• foo
  • bar
  • qux
• baz

Funkce	Výsledek
{{#caunset: foobar[foo][1] }}	foobar: foo bar baz

complexarrayaddvalue

Tato funkce analyzátoru přidá hodnotu nebo podpole k existujícímu poli nebo nahradí existující podpole touto hodnotou.

Syntaxe

{{#complexarrayaddvalue:key|value}}

Zdůvodnění

• key (povinné) – název podpole, která bude vytvořena;
• value (povinné) – hodnota v prostém textu nebo podpole v libovolném podporovaném značkovacím jazyce.

Příklady

Máme pole nazvané 'foobar':

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

Funkce	Výsledek
{{#caadd: foobar[0][bex]|["abc","123"]}}	0 foo: bar baz: quz bex abc 123 1 foo: quz baz: bar 2 baz: bar foo: bar
{{#caadd: foobar[3][foo][bar][baz]|bex}}	0 foo: bar baz: quz 1 foo: quz baz: bar 2 baz: bar foo: bar 3 foo bar baz: bex
{{#caadd: foobar[0]|["abc","123"]}}	0 abc 123 1 foo: quz baz: bar 2 baz: bar foo: bar

complexarrayreset

Tato funkce analyzátoru resetuje všechna pole nebo jedno pole.

Syntaxe

{{#complexarrayreset:key}}

Zdůvodnění

• key (volitelné) – název pole, které musí být deaktivováno, pokud je prázdné, všechna pole budou deaktivována.

complexarraysort

Tato funkce analyzátoru třídí pole.

Syntaxe

{{#complexarraysort:key|options|sortingkey}}

Zdůvodnění

• key (povinné) – pole, které je třeba seřadit;
• options (volitelné)
  • multisort – seřazení pole pomocí multisort;
  • asort – seřazení pole pomocí asort;
  • arsort – seřazení pole pomocí arsort;
  • krsort – seřazení pole pomocí krsort;
  • natcasesort – seřazení pole pomocí natcasesort;
  • natsort – seřazení pole pomocí natasort;
  • rsort – seřazení pole pomocí rsort;
  • shuffle – zamíchání polem;
  • keysort – seřazení dvourozměrného pole podle hodnot klíče ve druhém poli. Pořadí můžete změnit na sestupné přidáním ",desc" v možnostech (takže "keysort,desc").
• sortingkey (volitelné, nutné při použití řazení klíčů) – klíč, pomocí kterého musí být pole seřazeno při použití keyort.

Algoritmy řazení najdete v PHP dokumentaci.

Příklady

Máme pole nazvané 'foobar':

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

Funkce	Výsledek
{{#casort: foobar|keysort|foo}}	0 foo: bar baz: quz 1 baz: bar foo: bar 2 foo: quz baz: bar
{{#casort: foobar|keysort,desc|foo}}	0 foo: quz baz: bar 1 foo: bar baz: quz 2 baz: bar foo: bar
{{#casort: foobar|shuffle}}	0 foo: bar baz: quz 1 foo: quz baz: bar 2 baz: bar foo: bar

complexarrayunique

Tato funkce analyzátoru odstraní duplicitní klíče a hodnoty z pole.

Syntaxe

{{#complexarrayunique:key}}

Zdůvodnění

• key (povinné) – název pole.

Interakce

complexarraypush

Tato funkce analyzátoru vloží novou hodnotu nebo podpole na konec existujícího (pod)pole.

Syntaxe

{{#complexarraypush:key|value|noparse}}

Zdůvodnění

• key (povinné) – název (pod)pole;
• value (povinné) – hodnota v prostém textu nebo v jakémkoli podporovaném značkovacím jazyce.
• noparse (volitelné) – argumenty, které analyzátoru sdělují, co má analyzovat v 'předmětu' (viz #Manipulace s analyzátorem).

Příklady

Máme pole s názvem 'foobar':

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

Funkce	Výsledek
{{#capush: foobar|bex}}	0 foo: bar baz: quz 1 foo: quz baz: bar 2 baz: bar foo: bar test
{{#capush: foobar[1]|bex}}	0 foo: bar baz: quz 1 foo: quz baz: bar bex 2 baz: bar foo: bar
{{#capush: foobar | (("bex":"baz")) }}	0 foo: bar baz: quz 1 foo: quz baz: bar bex 2 baz: bar foo: bar 3 bex: baz

complexarrayextract

Tato funkce analyzátoru vytvoří nové pole z podpole.

Syntaxe

{{#complexarrayextract: new_key | subarray }}

Zdůvodnění

• new_key (povinné) – název pole, které se má vytvořit;
• subarray (povinné) – podpole, kterou je třeba extrahovat.

Příklady

Máme pole s názvem 'foobar':

• 0
  • foo: bar
  • baz: quz
• 1
  • baz: bar
  • foo: bar

Function	Result
{{#caextract: boofar | foobar[0] }}	boofar: 0 foo: bar baz: quz

complexarraymerge

Tato funkce analyzátoru vytvoří nové pole sloučením dvou nebo více polí.

Syntaxe

{{#complexarraymerge: new_key | key1 | key2 | ... | keyn | options }}

Zdůvodnění

• new_key (povinné) – název pole, které se má vytvořit;
• key1 (povinné) – název (pod)pole;
• key2 (povinné) – název druhého pole;
• ...
• keyn (volitelné) – název n-tého pole;
• options
  • recursive – Sloučit rekurzivně

Příklady

Máme pole s názvem 'foobar':

• 0
  • foo: bar
  • baz: quz
• 1
  • baz: bar
  • foo: bar

a řádek s názvem 'boofar':

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

Funkce	Výsledek
{{#camerge: farboo | foobar | boofar}}	farboo: 0 foo: bar baz: quz 1 baz: bar foo: bar 2 boo: bar far: quz 3 foo: quux bar: bar

complexarraydiff

Tato funkce analyzátoru vypočítá rozdíl mezi dvěma nebo více poli a uloží jej do nového pole. Stínuje funkci PHP array_diff_assoc().

Syntaxe

{{#complexarraydiff: new_key | key1 | key2 | ... | keyn }}

Zdůvodnění

• new_key (povinné) – název pole, které se má vytvořit;
• key1 (povinné) – název (pod)pole;
• key2 (povinné) – název druhého pole;
• ...
• keyn (volitelné) – název n-tého pole;

complexarraypusharray

Tato funkce analyzátoru vytvoří nové pole posunutím jednoho nebo více polí na konec jiného pole.

Syntaxe

{{#complexarraypusharray:new_key|key1|key2|...|keyn}}

Zdůvodnění

• new_key (povinné) – název pole, které se má vytvořit;
• key1 (povinné) – název (pod)pole;
• key2 (povinné) – název druhého pole;
• ...
• keyn (volitelné) – název n-tého pole;

Příklady

Máme pole nazvané 'foobar':

• 0
  • foo: bar
  • baz: quz
• 1
  • baz: bar
  • foo: bar

a pole nazvané 'boofar':

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

Funkce	Výsledek
{{#capusharray: farboo | foobar | boofar}}	farboo: 0 0 foo: bar baz: quz 1 baz: bar foo: bar 1 0 boo: bar far: quz 1 foo: quux bar: bar

Iterace

complexarraymap

Tato funkce analyzátoru iteruje pole a mapuje hodnoty pole na mapovací klíč.

Syntaxe

{{#complexarraymap:key|mapping_key|subject|delimiter|show}}

Zdůvodnění

• key (povinné) – název pole, které bude mapováno;
• mapping_key (povinné) – klíčové slovo, které bude v předmětu nahrazeno;
• subject (povinné) – řetězec, na který bude mapování aplikováno;
• delimiter (volitelné) – oddělovač připojený ke každému řádku kromě posledního;
• show (volitelné) – nastavte toto na true, aby se mapovací klíč zobrazil, když pro něj neexistuje žádná řetězcová hodnota.

Příklady

Máme pole s názvem foobar:

• 0
  • bar
  • quz
• 1
  • bar
  • bar
• 2
  • bar
  • quz
• 3
  • quux

Funkce	Výsledek
{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1]<br/> }}	What the bar is this quz What the bar is this bar What the bar is this quz What the quux is this
{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1]<br/> | true }}	What the bar is this quz What the bar is this bar What the bar is this quz What the quux is this @@@[1]
{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1] | <br/> | true }}	What the bar is this quz What the bar is this bar What the bar is this quz What the quux is this @@@[1]

complexarraymaptemplate

Tato funkce analyzátoru mapuje obsah pole v šabloně.

Syntaxe

{{#complexarraymaptemplate:key|template}}

Zdůvodnění

• key (povinné) – název pole, které je třeba namapovat;
• template (povinné) – název šablony, na kterou musí být pole namapováno.

Příklady

Máme pole nazvané 'foobar', pole 'boofar' a pole 'bazbar', resp.:

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

Funkce	Výsledek
{{#catemplate: foobar|Template}}	{{Template|foo=bar|baz=quz}} {{Template|baz=bar|foo=bar}} {{Template|foo=quz|baz=bar|bar=["bex","box"]}}
{{#catemplate: boofar|Template}}	{{Template|foobar|bazbar|boofar}}
{{#catemplate: bazbar|Template}}	{{Template|foo=bar|boo=far}}

Anonymous

Tyto funkce používají anonymní pole. Funkce zpracovává definici i výstup pole. Pole nemusíte předem definovat.

complexarrayarraymap

Tato funkce syntaktického analyzátoru je velmi podobná #complexarraymap, ale vstup a výstup jsou zpracovány ve stejné funkci (což ji činí anonymní).

Syntaxe

{{#complexarrayarraymap: value | delimiter | variable | formula | new_delimiter }}

Zdůvodnění

• value (povinné) – hodnota, která má být rozdělena;
• delimiter (povinné) – oddělovač pro rozdělení hodnoty;
• variable (povinné) – řetězec, který má být nahrazen ve 'vzorci';
• formula (povinné) – řetězec, kde je nahrazena 'proměnná';
• new_delimiter (povinné) – oddělovač mezi výsledky.

Příklady

Funkce	Výsledek
{{#caamap: a, b, c | , | @@ | Current variable: @@ | !<br/>}}	Current variable: a!<br/> Current variable: b!<br/> Current variable: c
{{#caamap: a; b; c | ; | ! | Just ! test | <br/>}}	Just a test<br/> Just b test<br/> Just c test

complexarrayparent

Tato funkce vrací klíč rodiče daného klíče.

Syntaxe

{{#complexarrayparent: key }}

Zdůvodnění

• key (povinné) – klíč, ze kterého má být vrácen nadřazený klíč

Příklady

Funkce	Výsledek
{{#caparent: foobar[0][1][test] }}	foobar[0][1]

Operátor Wairudokado

Operátor Wairudokado (japonština: ワイルドカード, vyslovováno wairudokādo, což znamená zástupný znak. Operátor rozlišení rozsahu v PHP) je výkonný operátor, který uživatelům umožňuje používat zástupné znaky při manipulaci nebo tisku podpolí.

Příklad

Tento operátor lze použít u každé funkce analyzátoru, která podporuje podpole (jako je #complexarrayprint). Předpokládejme, že máme pole foobar:

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

A my chceme vytisknout každou hodnotu "name". Mohli bychom použít #complexarraymap k iteraci přes pole a vytisknout každou hodnotu samostatně, ale můžeme také použít operátor Wairudokado ve funkci #complexarrayprint.

Function	Result
{{#caprint: foobar[*][name]}}	Foo Bar Baz Bex

Když je operátor Wairudokado na konci ukazatele, je ignorován. Sekvenční operátory Wairudokado jsou interpretovány jako jeden.

Sémantická MediaWiki

Tato tiskárna výsledků vyžaduje Semantic MediaWiki 3.0 nebo vyšší.

Toto rozšíření zavádí nový formát pro zobrazování výsledků Semantic MediaWiki. Chcete-li použít nový formát, použijte format=complexarray. Protože výsledná tiskárna definuje nové komplexní pole, musíte pro toto pole zadat název pomocí name=<name>. Pokud name zůstane prázdné, výsledná tiskárna vytiskne pole jako WSON.

Sémantické proměnné

Seznam sémantických proměnných je součástí komplexního pole, když se dotazujete na seznam stránek. Jsou zahrnuty následující proměnné:

catitle

název stránky

cafullurl

úplná adresa URL stránky

canamespace

jmenný prostor, ve kterém stránka žije

caexists

zda stránka existuje nebo ne (0/1)

cadisplaytitle

zobrazovaný název stránky

Další parametry

WSArrays definuje dva nové parametry:

name

název pole, které se má vytvořit;

simple

možnost skrýt sémantické proměnné z výsledků stránky a také skrýt předpony mailto: u výsledků e-mailu (ano/ne, výchozí: ano)

Zobrazení tabulek místo složitých polí

V případě, že Semantic MediaWiki vykreslí tabulku ve formátu complexarray, musíte nejprve zkontrolovat, zda jste nastavili $wfEnableResultPrinter na true. Pokud je tomu tak a stále to nefunguje, WSArrays možná nedokázalo vytvořit symbolický odkaz ze složky SemanticMediaWiki do složky WSArrays. Tento odkaz lze vytvořit ručně zkopírováním souboru ComplexArrayPrinter.php z kořenové složky rozšíření do SemanticMediaWiki/src/Query/ResultPrinters.

Psaní rozšíření

I když WSArrays poskytuje mnoho funkcí pro manipulaci a zobrazování polí, někdy to nestačí. Z tohoto důvodu poskytujeme rozhraní pro snadné rozšíření funkčnosti WSArrays o nové funkce analyzátoru.

Rozšíření jsou umístěna v adresáři extensions/. Každé rozšíření je implementováno jako odvozená třída od Extension.php. Název souboru, ve kterém bude tato třída umístěn, musí být stejný jako název třídy (rozlišují se malá a velká písmena). Příklad pro třídu ExampleClass by byl ExampleClass.php. Třída musí implementovat alespoň následující metody:

<?php

class ExampleClass extends Extension {
    /**
     * Vrátí název této funkce analyzátoru.
     *
     * @return string
     */
    public function getName() {
        return 'exampleclass';
    }

    /**
     * Měl by vrátit pole obsahující aliasy této funkce analyzátoru.
     *
     * @return array
     */
    public function getAliases() {
        return [
            'caexample',
            'caexampleclass'
        ];
    }

    /** 
     * Mělo by vrátit buď 'sfh' nebo 'normal'. 
     * Když se vrátí 'sfh', funkce setFunctionHook se zavolá pomocí Parser::SFH_OBJECT_ARGS
     * jako parametr umožňující hlubší integraci s parserem.
     *
     * @return string
     */
    public function getType() {
        return 'sfh';
    }

    /**
     * Tato funkce je volána analyzátorem.
     *
     * @return mixed
     */
    public static function getResult( Parser $parser, $arg1, $arg2, ...) {
        return 'Foobar';
    }
}

?>

Vrácení výsledku

getResult() je spuštěn háčkem analyzátoru. Jak psát funkce analyzátoru si můžete přečíst zde. Níže uvedená dokumentace je specifická pro WSArrays.

Manipulace s poli

Všechna pole v WSArrays musí být uložena jako objekt ComplexArray. Pokud chcete manipulovat s existujícím polem, musíte převést objekt ComplexArray na pole, manipulovat s polem a poté jej převést zpět na objekt ComplexArray.

public static function getResult( Parser $parser, $arg1, $arg2, $arg3 ) {
    // $arg1 obsahuje název existujícího pole;
    // getArray() vrátí pole.
    $array = WSArrays::$arrays[$arg1]->getArray();

    // Manipulovat s polem...

    // Pole jsou uložena v proměnné $arrays, která se nachází ve třídě WSArrays.
    // Pokud pole neuložíte jako ComplexArray, stávající funkce analyzátoru nebudou s tímto polem fungovat.
    WSArrays::$arrays[$arg1] = new ComplexArray( $array );

    return null;
}

nebo při použití SFH_OBJECT_ARGS:

public static function getResult( Parser $parser, $frame, $args ) {
    // Převeďte první prvek v poli $args na řetězec.
    // Pokud potřebujete, aby analyzátor nejprve analyzoval argumenty, vynechejte PPFrame::NO_ARGS | PPFrame::NO_TEMPLATES.
    // Můžete také použít GlobalFunctions::getSFHValue() a GlobalFunctions::rawValue().
    if ( isset( $args[0] ) ) {
        $arg1 = trim( $frame->expand( $args[0], PPFrame::NO_ARGS | PPFrame::NO_TEMPLATES ) );
    }

    // $arg1 obsahuje název existujícího pole.
    $array = WSArrays::$arrays[$arg1]->getArray();

    // Manipulovat s polem...

    // Pole jsou uložena v proměnné $arrays, která se nachází ve třídě WSArrays.
    // Pokud pole neuložíte jako ComplexArray, stávající funkce analyzátoru nebudou s tímto polem fungovat.
    WSArrays::$arrays[$arg1] = new ComplexArray($array);

    return null;
}

Registrace rozšíření

Chcete-li rozšíření povolit, musíte přidat název rozšíření a aliasy do WSArrays.i18n.php.

K $magicWords['en'] přidejte následující:

'<extensionname>' => [ 0, '<extensionname>' ],
'<alias1>' => [ 0, '<alias1>' ],
'<alias2>' => [ 0, '<alias2>' ],
...

Manipulace s analyzátorem

WSArrays manipuluje s analyzátorem několika způsoby. Aby bylo možné využívat pole v plném rozsahu, je důležité o tom vědět. To platí pouze pro následující funkce analyzátoru:

• #complexarraydefine
• #complexarrayprint
• #complexarraypushvalue

Jak WSArrays manipuluje s analyzátorem

WSArrays manipuluje s analyzátorem pomocí SFH_OBJECT_ARGS. Tímto způsobem jsou argumenty analyzátoru předány jako objekty PPNode namísto prostého textu. To umožňuje podmíněné rozšíření stromu analýzy (další informace viz doc.wikimedia.org). Pomocí SFH_OBJECT_ARGS můžeme říci analyzátoru, aby neanalyzoval prvky a vrátil nezpracovaný text zadaný uživatelem, který pak můžeme analyzovat v WSArrays.

Jak ovládat manipulaci

Různí lidé mají různé potřeby, a proto vám umožňujeme ovládat manipulaci s analyzátorem. Tato dokumentace se opět vztahuje pouze na funkce analyzátoru uvedené výše.

Ve výchozím nastavení je veškerý vstup automaticky analyzován analyzátorem, než je předán do WSArrays (kromě 'mapy' v #complexarraymap a #complexarrayprint.) To vám umožňuje používat parametry šablony i magická slova a šablony při manipulaci nebo definování polí. To však není vždy to, co chcete. Například, když chcete použít velmi složitou šablonu uvnitř pole a nechcete se úplně rozbít, když na ní použijete #complexarrayprint, můžete říct WSArrays, aby neanalyzoval vstup. Pokud pak pole vytisknete, šablona se vytiskne, jako by byla uzavřena značkami nowiki.

Co když chci šablonu analyzovat později?

Úplná analýza šablony pravděpodobně není to, co chcete. WSArrays říká analyzátoru, aby v případě potřeby prvek analyzoval, například když jej použijete v mapě nebo když jej vytisknete jako hodnotu.

Argumenty

Následující argumenty můžete zahrnout jako seznam oddělený čárkami v parametru 'noparse' jakékoli použitelné funkce.

Argument	Výsledek
NO_IGNORE	Do rozšíření rámce zahrňte konstantu PPFrame::NO_IGNORE.
NO_ARGS	Do rozšíření rámce zahrňte konstantu PPFrame::NO_ARGS.
NO_TEMPLATES	Do rozšíření rámce zahrňte konstantu PPFrame::NO_TEMPLATES, která analyzátoru říká, že nemá analyzovat šablony.
NO_TAGS	Do rozšíření rámce zahrňte konstantu PPFrame::NO_TAGS, která říká analyzátoru, aby neanalyzoval značky.

Použití WSArrays v jiných rozšířeních

WSArrays poskytuje rozhraní pro snadné použití, manipulaci a vytváření polí z libovolného rozšíření na wiki.

Inicializace

Chcete-li používat rozhraní, zahrňte do svého rozšíření třídu ComplexArrayWrapper, například:

include_once "/dir/to/ComplexArrayWrapper.php";

$interface = new ComplexArrayWrapper();

Získání obsahu pole

Obsah pole "foobar" lze získat takto:

$array = $interface->on("foobar")->get();

Získání obsahu podpole

Obsah "foobar[Foo][Bar]" lze získat takto:

$array = $interface->on("foobar")->in(["Foo", "Bar"])->get();

Změna obsahu pole

Obsah pole "foobar" lze změnit takto:

$interface->on("foobar")->set(["foo", "bar" => ["baz", "bar"]]);

Obsah konkrétní hodnoty nebo podpole lze také změnit takto:

$interface->on("foobar")->in(["Foo", "Bar"])->set("Specific value");

// nebo

$interface->on("foobar")->in(["Foo", "Bar"])->set(["sub", "array"]);

Pokud pole nebo podpole neexistuje, vytvoří se automaticky. Toto je také preferovaný způsob vytváření nového pole.

Zrušení nastavení pole

Pole lze zrušit takto:

$interface->on("foobar")->unsetArray();

Instalace

• Ke stažení soubor/y a vložte je do adresáře pojmenovaného WSArrays ve vaší složce extensions/.
• Na konec vašeho souboru LocalSettings.php přidejte následující kód:

  wfLoadExtension( 'WSArrays' );
  

• Vyžaduje nastavení v konfiguračním souboru.
•  Dokončeno – Přejděte na stránku Special:Version vaší wiki a zkontrolujte, zda bylo rozšíření úspěšně nainstalováno.

Konfigurace

WSArrays má několik konfiguračních parametrů.

$wfSkipVersionControl

Možnost přeskočit správu verzí a vynutit inicializaci WSArrays, přijímá logickou hodnotu (výchozí: false). To může způsobit selhání vaší wiki.

$wfEnableResultPrinter

Možnost povolit vytištění výsledků Semantic MediaWiki, přijímá logickou hodnotu (výchozí: false). Nastavení na true, pokud jste správně nenainstalovali výsledkovou tiskárnu (viz #Installation), způsobí, že vaše wiki nebude fungovat.

Související odkazy

• rozšíření "Arrays" – umožňuje provoz na jednoduchých polích.