Manual:Parser functions/da

From MediaWiki.org
Jump to: navigation, search
This page is a translated version of the page Manual:Parser functions and the translation is 77% complete.

Other languages:
dansk • ‎Deutsch • ‎English • ‎español • ‎français • ‎Bahasa Indonesia • ‎日本語 • ‎polski • ‎português do Brasil • ‎русский • ‎ไทย • ‎中文
Gnome-preferences-other.svg Udvidelser:Manual:Extensions UdviklingManual:Developing extensions Tag extensionsManual:Tag extensions Parser functions/daManual:Parser functions Hooks (værktøj)Manual:Hooks Special pagesManual:Special pages SkinsManual:Skins Magic wordsManual:Magic words APIAPI:Extensions
MediaWiki extensions

Parserfunktioner, som tilføjedes i MediaWiki version 1.7, er en type udvidelse, der er tæt knyttet til syntaks-analysen, også kaldet parseren. Udtrykket "parserfunktion" må ikke forveksles med Extension:ParserFunctions, som er en samling af simple parserfunktioner.

Beskrivelse

Whereas a Tag extension is expected to take unprocessed text and return HTML to the browser, a parser function can 'interact' with other wiki elements in the page. For example, the output of a parser function could be used as a template parameter or in the construction of a link.

Den typiske syntaks for en parserfunktion er:

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

For more information, see the documentation for Parser::setFunctionHook ( $id, $callback, $flags = 0 ). This documentation states:

The callback function should have the form:
function myParserFunction( &$parser, $arg1, $arg2, $arg3 ) { ... }
Or with SFH_OBJECT_ARGS:
function myParserFunction( $parser, $frame, $args ) { ... }"

Oprettelse af en parserfunktion er lidt mere kompliceret end at skabe et nyt mærke, fordi funktionens navn skal være et magisk ord/da - et nøgleord, der understøtter aliaser og sprogversioner.

Simpelt eksempel

Nedenfor er et eksempel på en udvidelse, der skaber en parserfunktion.

The registration goes into extension.json, the code into ExampleExtension.class.php:

{
	"name": "Example Extension",
	"author": "Me",
	"version": "1.0.0",
	"url": "https://www.mediawiki.org/wiki/Extension:Example",
	"descriptionmsg": "exampleextension-desc",
	"license-name": "GPL-2.0+",
	"type": "parserhook",
	"AutoloadClasses": {
		"ExampleExtension": "ExampleExtension.class.php"
	},
	"ExtensionMessagesFiles": {
		"ExampleExtension": "ExampleExtension.i18n.php"
	},
	"Hooks": {
		"ParserFirstCallInit": [
			"ExampleExtension::onParserSetup"
		]
	},
	"manifest_version": 1
}
<?php
class ExampleExtension {
   // Register any render callbacks with the parser
   public static function onParserSetup( &$parser ) {

      // Create a function hook associating the "example" magic word with renderExample()
      $parser->setFunctionHook( 'example', 'ExampleExtension::renderExample' );
   }

   // Render the output of {{#example:}}.
   public static function renderExample( $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;
   }
}

En anden fil, ExtensionName.i18n.php, bør indeholde:

<?php
/**
 * @since 1.0.0
 *
 * @file
 *
 * @licence GNU GPL
 * @author Your Name (YourUserName)
 */

$magicWords = array();

/** English
 * @author Your Name (YourUserName)
 */
$magicWords['en'] = array(
   'example' => array( 0, 'example' ),
);

Med denne udvidelse aktiveret

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

producerer

  • param1 is hello and param2 is hi and param3 is hey
Denne magicWords tabel er ikke valgfri. Hvis den udelades, vil parserfunktionen simpelthen ikke virke og {{#example: hello | hi}} vil blive gengivet som om udvidelsen ikke er blevet installeret.
Be aware that entries for $wgExtensionMessagesFiles will be ignored if there exists an entry in $wgMessagesDirs with the same key. To be on the safe side you could use the following:
// Allow translation of the parser function name and avoid conflicts with localisation
$wgExtensionMessagesFiles['ExampleExtensionMagic'] = __DIR__ . '/ExampleExtension.i18n.magic.php';
$wgMessagesDirs['ExampleExtension'] = __DIR__ . '/i18n';

Længere funktioner

For længere funktioner vil du måske adskille krog-funktionerne til en _body.php eller .hooks.php fil og lave dem til en klasses statiske funktioner. Så kan du hente klassen med $wgAutoloadClasses og kalde de statiske funktioner på krogene:

Sæt dette ind i din MyExtension.php fil:

$wgAutoloadClasses['MyExtensionHooks'] = "$dir/MyExtension.hooks.php";
$wgHooks[' ... '][] = 'MyExtensionHooks::MyExtensionFunction';

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

class MyExtensionHooks {
      public static function MyExtensionFunction( ... ) {
           ...
           $parser->setFunctionHook( 'example',
                'MyExtensionHooks::ExampleExtensionRenderParserFunction' );
           ...
      }
}

Mellemlagring

Ligesom med mærke-udvidelser kan $parser->disableCache() bruges til at afbryde mellemlagringen (cache'en) for dynamiske udvidelser.

Parser brugergrænseflade

Styring af systemanalyse-resultat

For at få wikiteksten, der returneres af din parserfunktion, til være fuldt systemanalyseret (med udvidelse af skabeloner), skal du indstille noparse til false ved returneringen:

return array( $output, 'noparse' => false );

Det ser ud til at standardværdien for noparse er ændret fra false til true, i hvert fald i nogle situationer, omkring version 1.12.

Omvendt, for at få din parserfunktion til at returnere ikke-gennemgået HTML i stedet for wikitekst, brug dette:

return array( $output, 'noparse' => true, 'isHTML' => true );

Imidlertid vil

Dette er {{#example:hallo | hej }} en test.

producere noget lignende dette:

This is

param1 is hallo and param2 is hej en test.

Dette sker på grund af den hårde kode "\n\n", der er foranstillet til parserfunktioners HTML resultat. For at undgå dette og sørge for, at HTML-koden er vises mellem til den omgivende tekst, kan du bruge denne:

return $parser->insertStripItem( $output, $parser->mStripState );

Navngivning

Som standard tilføjer MW en hash karakter (nummertegn, "#") til navnet af hver parserfunktion. For at undertrykke denne tilføjelse (og opnå en parser funktion uden "#" præfiks), indsæt SFH_NO_HASH konstant i den valgfri flag-argument til setFunctionHook, som beskrevet nedenfor.

Når du vælger et navn uden et hash præfiks, vær opmærksom på at indlejring af en side med et navn, der starter med dette funktionsnavn efterfulgt af et kolon, er ikke længere muligt. Undgå især funktionsnavne svarende til et navnerums-navn. I tilfælde af at interwiki indlejring [1] er aktiveret, undgå da også 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:

function setFunctionHook( $id, $callback, $flags = 0 ) Parametre:

  • string $id - det magiske ord ID
  • mixed $callback - tilbagekalds-funktionen (og objektet) at bruge
  • integer $flags - valgfri, sættes til SFH_NO_HASH konstanten, for at kalde funktionen uden "#".

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 på flagene er specificeret i nøglerne. Gyldige flag er:

found 
Den returnerede tekst er gyldig, stop behandlingen af skabelonen. Dette er som standard aktiveret.
nowiki 
Wiki-opmærkning i resultatet skal udelades
noparse 
Usikre HTML-mærker bør ikke gennemgås osv.
noargs 
Erstat ikke triple-tuborgklamme argumenter i den returnerede værdi
isHTML 
Den returnerede tekst er HTML og skal værnes mod wikitekst forandring

Navngivne parametre

Parserfunktioner understøtter ikke navngivne parametre på samme måde som skabeloner og mærke-udvidelser, men det er til tider nyttigt at lade som om. Brugerne er ofte vant til at bruge lodrette streger ( | ) til at adskille argumenter, så det er rart også at kunne gøre det i parserfunktionens kontekst. Her er et simpelt eksempel på hvordan det gøres.

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) );

	#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 = array();

	foreach ( $options as $option ) {
		$pair = explode( '=', $option, 2 );
		if ( count( $pair ) === 2 ) {
			$name = trim( $pair[0] );
			$value = trim( $pair[1] );
			$results[$name] = $value;
		}

		if ( count( $pair ) === 1 ) {
			$name = trim( $pair[0] );
			$results[$name] = true;
		}
	}
	//Now you've got an array that looks like this:
	//  [foo] => "bar"
	//	[apple] => "orange"
	//	[banana] => true

	return $results;
}

Se også