Extension:WSArrays
Toto rozšíření není v současné době aktivně udržováno! Ačkoli to může stále fungovat, jakákoli hlášení o chybách nebo požadavky na funkce budou pravděpodobně ignorovány. |
WSArrays Stav rozšíření: neudržované |
|
---|---|
Implementace | 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í. |
Autoř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 novější |
Stáhnout | GitLab: Poznámka: |
|
|
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
Funkce | Výsledek |
---|---|
{{#caprint: foobar}} |
|
{{#caprint: foobar[0]}} |
|
{{#caprint: foobar[3]}} |
|
{{#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:
|
{{#caslice: boofar | foobar | -1 }} |
To dává poslední prvek pole: boofar:
|
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:
|
{{#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:
|
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"]}} |
|
{{#caadd: foobar[3][foo][bar][baz]|bex}} |
|
{{#caadd: foobar[0]|["abc","123"]}} |
|
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}} |
|
{{#casort: foobar|keysort,desc|foo}} |
|
{{#casort: foobar|shuffle}} |
|
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}} |
|
{{#capush: foobar[1]|bex}} |
|
{{#capush: foobar | (("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:
|
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:
|
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:
|
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 |
{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1]<br/> | true }} |
What the bar is this quz |
{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1] | <br/> | true }} |
What the bar is this quz |
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]}} |
|
Sémantická MediaWiki
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:
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"]);
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žceextensions/
. - 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.