Udvidelser:

• Udvikling
• Tag extensions
• Parser functions/da
• Hooks (værktøj)
• Specialsider
• Skins
• Magic words
• API
• Content models

Parserfunktioner, som tilføjedes i MediaWiki version 1.7, er en type udvidelse, der er tæt knyttet til syntaks-analysen, ogsa kaldet parseren. Udtrykket "parserfunktion" ma ikke forveksles med Extension:ParserFunctions , som er en samling af simple parserfunktioner. (See Help:Extension:ParserFunctions for those.)

Beskrivelse

Den typiske syntaks for en parserfunktion er:

{{ #functionname: param1 | param2 | param3 }}

The callback function should have the form:

function myParserFunction( $parser, $arg1, $arg2, $arg3 ) { ... }

Or with SFH_OBJECT_ARGS :

function myParserFunction( $parser, $frame, $args ) { ... }

The first variant of the call passes all arguments as plain text. The second passes all arguments as an array of PPNode s, except for the first ( $args[0] ), which is currently text, though this may change in the future. These represent the unexpanded wikitext. The $frame parameter can be used to expand these arguments as needed. This is commonly used for conditional processing so that only the true case is evaluated with an if- or switch-like parser function. The frame object can also climb up the document tree to get information about the caller and has functions to determine and manage call depth, time-to-live, and whether the result of the parser function is volatile.

Simpelt eksempel

Nedenfor er et eksempel pa en udvidelse, der skaber en parserfunktion.

{

	"name"
:
 "ExampleExtension"
,

	"author"
:
 "Me"
,

	"version"
:
 "1.0.0"
,

	"url"
:
 "https://www.mediawiki.org/wiki/Extension:ExampleExtension"
,

	"descriptionmsg"
:
 "exampleextension-desc"
,

	"license-name"
:
 "GPL-2.0-or-later"
,

	"type"
:
 "parserhook"
,

	"MessagesDirs"
:
 {

		"ExampleExtension"
:
 [

			"i18n"

		]

	},

	"AutoloadClasses"
:
 {

		"ExampleExtensionHooks"
:
 "src/ExampleExtensionHooks.php"

	},

	"ExtensionMessagesFiles"
:
 {

		"ExampleExtensionMagic"
:
 "ExampleExtension.i18n.php"

	},

	"Hooks"
:
 {

		"ParserFirstCallInit"
:
 "ExampleExtensionHooks::onParserFirstCallInit"

	},

	"manifest_version"
:
 1

}

<?php

class
 ExampleExtensionHooks
 {

   // Register any render callbacks with the parser

   public
 static
 function
 onParserFirstCallInit
(
 Parser
 $parser
 )
 {


      // Create a function hook associating the <code>example</code> magic word with renderExample()

      $parser
->
setFunctionHook
(
 'example'
,
 [
 self
::
class
,
 'renderExample'
 ]
 );

   }


   // Render the output of {{#example:}}.

   public
 static
 function
 renderExample
(
 Parser
 $parser
,
 $param1
 =
 ''
,
 $param2
 =
 ''
,
 $param3
 =
 ''
 )
 {


      // The input parameters are wikitext with templates expanded.

      // The output should be wikitext too.

      $output
 =
 "param1 is 
$param1
 and param2 is 
$param2
 and param3 is 
$param3
"
;


      return
 $output
;

   }

}

<?php

/**

 * @license GPL-2.0-or-later

 * @author Your Name (YourUserName)

 */


$magicWords
 =
 [];


/** English

 * @author Your Name (YourUserName)

 */

$magicWords
[
'en'
]
 =
 [

   'example'
 =>
 [
 0
,
 'example'
 ],

];

Med denne udvidelse aktiveret

• {{#example: hello | hi | hey}}

producerer

• param1 is hello and param2 is hi and param3 is hey

MediaWiki\MediaWikiServices
::
getInstance
()
->
getContentLanguage
()
->
mMagicExtensions
[
'wikicodeToHtml'
]
 =
 [
'MAG_CUSTOM'
,
 'custom'
];

$wgHooks
[
'ParserFirstCallInit'
][]
 =
 function
 (
 Parser
 $parser
 )
 
{

	MediaWiki\MediaWikiServices
::
getInstance
()
->
getContentLanguage
()
->
mMagicExtensions
[
'wikicodeToHtml'
]
 =
 [
'wikicodeToHtml'
,
 'wikicodeToHtml'
];


	$parser
->
setFunctionHook
(
 'wikicodeToHtml'
,
 'wikicodeToHtml'
 );

};

 
function
 wikicodeToHtml
(
 Parser
 $parser
,
 $code
 =
 ''
 )
 
{

	$title
 =
 $parser
->
getTitle
();

	$options
 =
 $parser
->
Options
();

	$options
->
enableLimitReport
(
false
);

	$parser
 =
 $parser
->
getFreshParser
();

	return
 [
$parser
->
parse
(
$code
,
 $title
,
 $options
)
->
getText
(),
 'isHTML'
 =>
 true
];

}

Længere funktioner

Sæt dette ind i din extension.json fil:

"Hooks"
:
 {

	"ParserFirstCallInit"
:
 "ExampleExtensionHooks::onParserFirstCallInit"

},

"AutoloadClasses"
:
 {

	"ExampleExtensionHooks"
:
 "src/ExampleExtensionHooks.php"

}

• See: writing an event handler for other styles.

Sa sæt dette i din MyExtension.hooks.php fil:

class
 ExampleExtensionHooks
 {

      public
 static
 function
 onParserFirstCallInit
(
 Parser
 $parser
 )
 {

           $parser
->
setFunctionHook
(
 'example'
,
 [
 self
::
class
,
 'renderExample'
 ]
 );

      }

}

Parser brugergrænseflade

Styring af systemanalyse-resultat

return
 [
 $output
,
 'noparse'
 =>
 false
 ];

Omvendt, for at fa din parserfunktion til at returnere ikke-gennemgaet HTML i stedet for wikitekst, brug dette:

return
 [
 $output
,
 'noparse'
 =>
 true
,
 'isHTML'
 =>
 true
 ];

Navngivning

Som standard tilføjer MW en hash karakter (nummertegn, "#") til navnet af hver parserfunktion. For at undertrykke denne tilføjelse (og opna en parser funktion uden "#" præfiks), indsæt SFH_NO_HASH konstant i den valgfri flag-argument til setFunctionHook, som beskrevet nedenfor . To suppress that addition (and obtain a parser function with no # prefix), include the SFH_NO_HASH constant in the optional flags argument to setFunctionHook, as described below .

Nar du vælger et navn uden et hash præfiks, vær opmærksom pa at indlejring af en side med et navn, der starter med dette funktionsnavn efterfulgt af et kolon, er ikke længere muligt. Undga især funktionsnavne svarende til et navnerums-navn. I tilfælde af at interwiki indlejring [1] er aktiveret, undga da ogsa funktionsnavne svarende til et interwiki præfiks.

setFunctionHook krogen

For flere oplysninger om grænsefladen ind i parseren, se dokumentationen for setFunctionHook i includes/Parser.php. Her er en (muligvis dateret) kopi af disse bemærkninger:

Parametre:

• string $id - det magiske ord ID
• mixed $callback - tilbagekalds-funktionen (og objektet) at bruge

• SFH_NO_HASH (1) constant if you call the function without # .
• SFH_OBJECT_ARGS (2) if you pass a PPFrame object and array of arguments instead of a series of function arguments, for which see above .
• Defaults to 0 (no flags).

Returværdi: navnets gamle tilbagekalds-funktion, hvis der er nogen

Opret en funktion, for eks. {{#sum:1|2|3}} . Tilbagekalds-funktionen bør have formen:

function
 myParserFunction
(
 $parser
,
 $arg1
,
 $arg2
,
 $arg3
 )
 {
 ...
 }

Tilbagekaldet kan enten returnere tekstresultatet af funktionen, eller en tabel med teksten i element 0, og et antal flag i de andre elementer. Navnene pa flagene er specificeret i nøglerne. Gyldige flag er:

Some parser functions represent a significant use of a wiki's resources and should be marked as "expensive". The number of expensive parser functions on any given page is limited by the $wgExpensiveParserFunctionLimit setting. What counts as expensive is left up to the function itself, but typically, anything that is likely to cause a delay that extends beyond simple processing of data should be considered. This includes things like database reads and writes, launching a shell script synchronously, or file manipulation. On the other hand, not all such functions should necessarily be tagged. Semantic MediaWiki, for example, only marks a percentage of its database reads as expensive. This is due to the fact that on certain data-intensive pages, it could easily overflow the normal expensive parser function limits. In cases like this, the potential for noticeably slower performance that doesn't get flagged as expensive is a trade-off to having the functionality that SMW offers.

To mark your parser function as expensive, from within the body of the function's code, use $result = $parser -> incrementExpensiveFunctionCount (); . The return value will be false if the expensive function limit has been reached or exceeded.

Navngivne parametre

function
 ExampleExtensionRenderParserFunction
(
 &
$parser
 )
 {

	// Suppose the user invoked the parser function like so:

	// {{#myparserfunction: foo=bar | apple=orange | banana }}


	$options
 =
 extractOptions
(
 array_slice
(
 func_get_args
(),
 1
 )
 );


	// Now you've got an array that looks like this:

	// [foo] => 'bar'

	// [apple] => 'orange'

	// [banana] => true

	// Continue writing your code...

}


/**

 * Converts an array of values in form [0] => "name=value"

 * into a real associative array in form [name] => value

 * If no = is provided, true is assumed like this: [name] => true

 *

 * @param array string $options

 * @return array $results

 */

function
 extractOptions
(
 array
 $options
 )
 {

	$results
 =
 [];

	foreach
 (
 $options
 as
 $option
 )
 {

		$pair
 =
 array_map
(
 'trim'
,
 explode
(
 '='
,
 $option
,
 2
 )
 );

		if
 (
 count
(
 $pair
 )
 ===
 2
 )
 {

			$results
[
 $pair
[
0
]
 ]
 =
 $pair
[
1
];

		}

		if
 (
 count
(
 $pair
 )
 ===
 1
 )
 {

			$results
[
 $pair
[
0
]
 ]
 =
 true
;

		}

	}

	return
 $results
;

}

Se ogsa

• Brugervejledning:Udvikling af udvidelser , or for more general information about extensions, see Manual:Extensions/da and Extensions FAQ .
• Manual:Tag extensions
• Manual:Magic words

Code:

• Manual:Parser.php
• Manual:Hooks/ParserFirstCallInit
• Parser function hooks - an (incomplete) list of parser functions provided by core and extensions

• Manual:Extension data

Examples:

• ParserFunctions-udvidelsen er en velkendt samling af parserfunktioner.
• Help:Extension:ParserFunctions

Category:Parser function extensions [[::Category:Parser function extensions| ]]