Kleine Frage zu nem RegEx Ausdruck

[CrackPod]

Hallo,

ich arbeite mich derzeit durch dieses Tutorial. Dort gibt es folgende Stelle:

        /* 
        * Um uns arbeit zu sparen verwenden wir vorgefertigte Schablonen 
        * für unsere ETF-Tags. 
        */ 
        $this->syntax  = array( 
            1 => '`\[(%s)\](.*?)\[/\\1\]`is', // Ein Parameter 
            2 => '`\[(%s)=["\']?([^"\']*?)["\']?\](.*?)\[/\\1\]`is', // Zwei Parameter 
            3 => '`\[(%s)=["\']?([^"\']*?)["\']?,["\']?([^"\']*?)["\']?\(.*?)\[/\\1\]`is' // Drei Parameter 
        );

Das sind Parameter für die RegEx Ersetzung. Jedoch versteh ich Nummer 2 und 3 nicht.
Könnte mir das einer erklären?

 

[Gelöschtes Mitglied 2703]

also das 1. selektiert z.b.

[BLA]XXX[/BLA]

das 2.

[BLA="X"]XXX[/BLA]
[BLA='X']XXX[/BLA]
[BLA="X']XXX[/BLA]
[BLA=X]XXX[/BLA]

und das 3. dann ..

[BLA="X","XXX,XXX"]XXX[/BLA]
[BLA='X',X]XXX[/BLA]
usw...

vergleich es mal mit den regex und sag dann welche stelle du nicht verstehst

ps:

Achtung:
Sie müssen angemeldet sein um dieses Tutorial anschauen zu können.
Hier gehts zum Anmeldeformular

 

[CrackPod]

achso...
ja, ich denke ich habe es jetzt verstanden. zumindest das mit den RegEx

Also die Code Abschnitte mit den wichtigsten Textstellen.

<?php 
class TextFormatter { 
    // Als erste Variable benötigen wir ein Array, dass die Parser speichert 
    var $parser; 
    // Entweder arbeiten wir hinterher mit "count" oder wir speichern die Anzahl direkt 
    var $parser_count; 
     
    // Konstruktor 
    function TextFormatter() { 
        $this->parser       = array(); 
        $this->parser_count = 0; 
        // Wir muessen nur unsere Attribute initialisieren. Mehr nicht. 
    } 
     
    /* 
    * Wir müssen ja irgendwie einen Parser hinzufügen können. 
    * Mit PHP5 wären hier einige Optionen mehr möglich, aber was soll's... 
    * Der Parser wird als Referenz übergeben, sonst wäre das ein zu starker 
    * Verlust in Punkto Geschwindigkeit. 
    */ 
    function addParser(&$parser) { 
        $this->parser[] = &$parser; // Parser als Referenz speichern 
        $this->parser_count++;      // Counter erhöhen 
    } 
     
    /* 
    * Hinzufügen ist drin, Konstruktor ist fertig, fehlt also nur noch die tatsächliche 
    * Methode zum formatieren. 
    */ 
    function parse($text) { 
        for($i = 0; $i < $this->parser_count; $i++) { 
            $text = $this->parser[$i]->parse($text); 
        } 
        return $text; 
    } 
} 
?>

Diese Klasse ist jetzt auf alle Zeit fertig. ;)
Erstellen wir nun also einen Parser für ETF (Extended Textformat [www.axtis.de]) oder besser bekannt als BBCodes.
Dieser soll aber nur die notwendigsten ETF-Tags (b, u, i) beherrschen.

<?php 
class SimpleETFParser { 
    // Zum speichern der gesuchten Tags 
    var $search; 
    // Und zum speichern dessen mit dem es ersetzt werden soll. 
    var $replace; 
    // Den Konstruktor verwenden wir zum füllen unserer Arrays. 
    function SimpleETFParser() { 
        // Da wir nur einen Regulären Ausdruck haben könnten wir auch einen einfachen String nehmen. 
        $this->search  = array( 
            '`\[(b|u|i)\](.*?)\[/\\1\]`is' // B U I. Mehr brauchen wir nicht. 
        ); 
        $this->replace = array( 
            '<\\1>\\2</\\1>' 
        ); 
    } 
    // Nun die parse-Methode: 
    function parse($text) { 
        return preg_replace($this->search, $this->replace, $text); 
    } 
} 
?>

Na ja. Ist zwar schon nicht schlecht, aber der Parser ist nicht so gut, oder?
Wozu gibts OOP? Wir leiten einfach eine kleine Klasse daraus ab. :)
Wichtig ist, dass diese Klasse die SimpleETFParser-Klasse in Reichweite hat. Das könnt ihr durch ein einfaches require_once gewährleisten. ;)

Ab hier fängt das Unverständniss an

<?php 
class ExtendedETFParser extends SimpleETFParser { 
    var $syntax; 
    function ExtendedETFParser() { 
        $this->search  = array(); 
        $this->replace = array(); 
        /* 
        * Um uns arbeit zu sparen verwenden wir vorgefertigte Schablonen 
        * für unsere ETF-Tags. 
        */ 
        $this->syntax  = array( 
            1 => '`\[(%s)\](.*?)\[/\\1\]`is', // Ein Parameter 
            2 => '`\[(%s)=["\']?([^"\']*?)["\']?\](.*?)\[/\\1\]`is', // Zwei Parameter 
            3 => '`\[(%s)=["\']?([^"\']*?)["\']?,["\']?([^"\']*?)["\']?\(.*?)\[/\\1\]`is' // Drei Parameter 
        ); 
    } 
     
    // Wir werden gleich eine Funktion brauchen, um unsere BBCodes für unsere Schablonen sicher zu machen 
    function preg_quote($text) { 
        // Wir müssen zum üblichen preg_quote noch ` (unsere delimitier) escapen. 
        return preg_quote(str_replace('`', '\`', $text)); 
    } 
     
    // Nun die Methode zum hinzufügen eines ETF-Tags 
    function addTag($tag, $replace, $paramcount=1) { 
        if($paramcount < 1 || $paramcount > 3) { 
            // Kleine Sicherheitsabfrage 
            trigger_error($paramcount.' is not within 1 and 3!', E_USER_WARNING); 
            return; 
        } 
        $tag = $this->preg_quote($tag); 
        $this->search[]  = sprintf($this->syntax[$paramcount], $tag); 
        // Um den Komfort zu erhöhen verwenden wir {paramX} statt \\(X+1) im replace. 
        $this->replace[] = str_replace('{param1}', '\\2', 
                           str_replace('{param2}', '\\3', 
                           str_replace('{param3}', '\\4', 
                           $replace))); 
    } 
} 
?>

 

[Gelöschtes Mitglied 2703]

ieeh PHP4 ^^

also eigentlich werden nur 2 arrays aufgebaut, einmal mit den suchstrings und mit den ersetzungen.

mögliche verwendung könnte dann z.b. so aussehen:

addTag('url','<a href="{param1}" />');

Dann sollte der einzige eintrag im search array so aussehen:

`\[(url)\](.*?)\[/\\1\]`is

und replace:

<a href="\\2" />

also ergibt dann das preg_replace da weiter oben [jetzt rein theoretisch]

preg_replace('`\[(url)\](.*?)\[/\\1\]`is', '<a href="\\2" />', '[url]blubb[/url]');

<a href="blubb" />

edit: kleinen fehler gefixt

 

[CrackPod]

ahh, cool.
Danke, ich denke ich hab jetzt alles verstanden. Werd mir das heut abend nochmal anschaun