Wenn du in deinem Wiki Vorlagen erstellt hast, wirst du früher oder später lernen müssen, wie man Parserfunktionen verwendet, um komplexeren Code zu erstellen. Ob {{#if:}} oder {{#switch:}}, diese helfen dir, bessere Bausteine für deinen Inhalt zu haben.

Irgendwann wirst du jedoch auf ein Problem stoßen: Wenn du zu viele #if verwendest, wird es schwieriger, den Quellcode zu lesen. Stell dir vor, du möchtest die Seiten für Episoden in deinem Wiki über eine Fernsehserie mit den folgenden Regeln automatisch kategorisieren:

1. Wenn es einen {{{Staffel}}}-Parameter gibt, wird [[Kategorie:Episoden aus Staffel {{{Staffel}}}]] hinzugefügt.
2. Wenn der Parameter {{{Staffel}}} fehlt, wird [[Kategorie:Episoden ohne Staffel]] hinzugefügt, damit du sie leicht finden kannst.

In einer Vorlage bräuchte man eine #if: so einfach wie:

{{#if:{{{Staffel|}}}|[[Kategorie:Episoden aus Staffel {{{Staffel}}}]]|[[Kategorie:Episoden ohne Staffel]]}}

So viele {{ }} und [[ ]] können verwirrend wirken, aber es ist nicht schlimm... noch nicht. Was wäre, wenn wir eine neue Regel hinzufügen müssten?

1. Wenn es einen {{{Special}}}-Parameter gibt, der bestimmt, ob es sich um eine besondere oder eine reguläre Episode handelt, muss er stattdessen [[Kategorie:Besondere Episoden der Staffel {{{Staffel}}}]] hinzufügen.

Wie könnten wir dies tun? Vielleicht so etwas wie:

{{#if:{{{Staffel|}}}|{{#if:{{{Special|}}}|[[Kategorie:Besondere Episoden der Staffel {{{Staffel}}}]]|[[Kategorie:Episoden aus Staffel {{{Staffel}}}]]}}|[[Kategorie:Episoden ohne Staffel]]}}

Jetzt wird es ein bisschen schwieriger zu lesen, nicht wahr? Wir haben gerade eine einzige Regel zu unserer Logik hinzugefügt! Parser-Funktionen eignen sich gut für einfache Überprüfungen, aber sie werden komplizierter, wenn man versucht, eine komplexere Logik mit ihnen zu implementieren. Was sollten wir also tun? Als Programmiersprache ist Lua ein leistungsfähigeres Werkzeug, das dir hilft, deinen Vorlagen eine fortgeschrittene Logik hinzuzufügen, und das gleichzeitig einfacher zu lesen ist, wenn du mit der Sprache vertraut bist. Doch bevor wir das vorherige Beispiel umsetzen können, müssen wir verstehen, was Lua ist und wie du es mithilfe von Modulen in deinen Wikis verwenden kannst.

Lua-Schnellstart[]

Lua-Skripte sind in allen Wikis standardmäßig im Namensraum Modul: verfügbar. So wie alle deine Vorlagen mit Vorlage: beginnen, befinden sich alle Lua-Skripte auf Seiten, die mit Modul: beginnen. Die meisten Module werden wie folgt aussehen:

local p = {}

function p.main(frame)
  -- code
end

return p

Fassen wir das vorherige Beispiel noch einmal kurz zusammen:

• local p ist eine Variable, die eine leere Tabelle {} speichert. Du brauchst sie, um alle deine exportierten Funktionen gebündelt zu halten, damit sie am Ende zurückgegeben (return) werden können. Andere Module und Seiten können alles in der exportierten Tabelle verwenden.
• Wir erstellen eine Funktion main innerhalb unserer Tabelle, p. frame ist ein Argument, das alle Funktionen enthält, wenn sie von einer Seite aus aufgerufen wird; du kannst mehr über das frame-Objekt lesen, aber für den Moment müssen wir nur wissen, dass es dir den Zugriff auf die in der Seite verwendeten Parameter ermöglicht. In „{{Vorlage|Erstens|Zweitens|hallo=welt}}“ hättest du zum Beispiel Zugriff auf den ersten Parameter, den zweiten Parameter und den Wert des Parameters „hallo“, der „welt“ ist.

Bedenke: main ist nur ein Beispiel! Du kannst jeden gültigen Namen für deine Funktionen verwenden.

Erstellung unseres Moduls[]

Nun kommen wir zum eigentlichen Code! Konzentriere dich auf den neuen Inhalt, d. h. alles innerhalb der main-Funktion.

local p = {}

function p.categorize(frame)
  local args = require('Dev:Arguments').getArgs(frame)
  local season = args.Staffel
  local special = args.Special
  
  if Staffel then
    if Special then
      return string.format( '[[Kategorie:Besondere Episoden der Staffel %s]]', Staffel )
    else
      return string.format( '[[Kategorie:Episoden aus Staffel %s]]', Staffel )
    end
  else
    return '[[Kategorie:Episoden ohne Staffel]]'
  end
end

return p

Schritt für Schritt[]

Werfen wir einen Blick darauf, was das alles ist.

Zugriff auf die Parameter

Es gibt auch andere Möglichkeiten, auf die Parameter zuzugreifen, die von der Seite an dein Modul übergeben werden, aber die empfehlenswerteste ist die Verwendung von Arguments, einem globalen Lua-Modul, das in allen Wikis verfügbar ist. Es exportiert eine Funktion getArgs, die dir eine Tabelle mit allen Argumenten aus deinem frame-Objekt liefert. Mit dem gleichen Vorlagenaufruf wie zuvor, „{{Vorlage|Erstens|Zweitens|hallo=welt}}“, erhältst du alle Argumente in einer Tabelle wie:

{
  "Erstens",
  "Zweitens",
  hallo = "welt"
}

Denke daran, dass Lua-Tabellen mit der Indizierung bei 1 beginnen! Du könntest also jeden Parameter, den du brauchst, als args[1] (Erstens), args[2] (Zweitens) und args.hallo (welt) aufrufen. Der Zugriff auf einen Schlüssel, der nicht existiert, gibt den Wert nil zurück, was dem undefined von JavaScript oder none von Python entspricht.

Implementierung deiner Logik[]

Mit if-Anweisungen in der Programmierung solltest du bereits vertraut sein. Die Syntax von Lua ist zwar anders, aber leicht zu verstehen.
Wie bei der Verwendung von Parser-Funktionen prüfen wir zunächst, ob der Parameter Staffel gesetzt wurde. Wäre dies nicht der Fall, hätten wir einen nil-Wert aus unserer Tabelle args erhalten, der als false ausgewertet würde.
Der andere Teil, über dessen Bedeutung du dich vielleicht wunderst, ist string.format. Lua hat verschiedene Möglichkeiten, Strings zu „interpolieren“, und dies ist nur eine von ihnen. Der erste Parameter dieser Funktion ist deine Vorlagenzeichenkette, in der jede Instanz von %s durch die folgenden Parameter in der Reihenfolge ersetzt wird (in diesem Fall der in Staffel gespeicherte Wert).

• Wenn Staffel festgelegt ist, prüfe, ob auch Special festgelegt ist.
  • Wenn Special gesetzt ist, füge eine Kategorie [[Kategorie:Besondere Episoden der Staffel %s]] hinzu, wobei %s durch den Wert in Staffel ersetzt wird.
  • Sonst füge eine Kategorie [[Kategorie:Episoden aus Staffel %s]] hinzu.
• Wenn Staffel nicht festgelegt ist, füge eine Kategorie [[Kategorie:Episoden ohne Staffel]] hinzu.

Wie verwende ich es?[]

Hätten wir das vorherige Beispiel in Modul:Episode, könntest du es auf jeder Seite mit {{#invoke:Episode|categorize|Staffel=1}} aufrufen. Dies solltest du jedoch vermeiden. Obwohl die Syntax der von Vorlagen sehr ähnlich ist, könnte sie neue Bearbeiter verwirren: #invoke? Warum categorize? Wo ist diese Vorlage?

Normalerweise werden deine Bearbeiter Module nie direkt verwenden, sondern über Vorlagen. In deiner Vorlage:Episode Infobox könntest du zum Beispiel dein Modul am Ende wie folgt aufrufen: {{#invoke:Episode|categorize}}.

Du fragst dich vielleicht: Woher soll es die Staffel kennen? Nun, dein frame-Objekt hat Zugriff auf alle Parameter, die an {{Episode Infobox}} übergeben werden! Und dank des globalen Arguments-Moduls, das wir zuvor verwendet haben, hast du einfachen Zugriff auf diese Parameter, ohne dein Modul ändern zu müssen. Ist das nicht großartig?

Zusammengefasst[]

Dieser Blog hat dir nur eine Idee gegeben, wie du Lua benutzen kannst, um die Logik in deinen Vorlagen zu vereinfachen. Hoffentlich wirst du in der Lage sein, es in besseren Szenarien anzuwenden, sodass sie einfacher zu warten sind! Hier ist eine kurze Liste von Fällen, in denen du die Verwendung von Lua in Betracht ziehen solltest:

• Deine Vorlage hat viele Parser-Funktionen, besonders wenn sie verschachtelt sind.
• Du musst eine beliebige Anzahl von Parametern verarbeiten. Anstatt manuell {{{Parameter 1}}}, {{{Parameter 2}}}, {{{Parameter 3}}} usw. nach Bedarf hinzuzufügen, könntest du sie mit Lua verwalten.
• Obwohl die Zentralisierung von Daten als eine schlechte Methode für Wikis angesehen wird, kann sie manchmal die beste Lösung für deine Bedürfnisse sein. Und die beste Art, Daten zu zentralisieren, sind Lua-Module.

Denk daran, dass Lua-Module nur von jemandem gepflegt werden können, der die Sprache beherrscht. Versuch, gute Programmierpraktiken in deinem Modul zu befolgen, sodass andere Leute in der Lage sind, zu verstehen, was es tun soll, und leicht durch das Modul zu navigieren, wenn sie etwas reparieren müssen. Zum Beispiel: Verwende beschreibende Variablen (local ip gibt nicht so viele Informationen wie local item_price) und teile deinen Code in verschiedene Funktionen auf, damit er leichter zu lesen ist. Und füge natürlich einige Kommentare hinzu, um den Code für andere verständlich zu machen!

Du hast alle Werkzeuge einer Programmiersprache zur Verfügung, um leistungsfähige Module zu erstellen, die du in deinen Artikeln verwenden kannst, anstatt dich nur auf Parserfunktionen und andere grundlegende Funktionen zu verlassen.

Werde ein Pro: Technische Fragen

Vorstellung von DynamicPageLists auf Fandom

Vorstellung von Lua auf Fandom

Zum Dev-Wiki beitragen

Richtlinien für die Verwendung von Bots auf Fandom

Lerne die Basics Unternimm deine nächsten Schritte
Werde ein Community-Mentor