[Corvin]

Ein besserer Titel fiel mir nicht ein..

Ich habe folgenden Code:

PHP-Code:

<?php
$text = "[x] [x] TEXT [/x] [/x]";
$text = preg_replace("/\[x\](.*)\[\/x\]/isU", "[y]\\1[/y]", $text);
echo $text;
?>

Die Ausgabe ist nun:

[y] [x] TEXT [/y] [/x]

Ich hätte die Ausgabe aber gerne so:

[y] [y] TEXT [/y] [/y]

Es soll also das erste und das letzte Tag ersetzt werden und dann soll, falls mehrere Tags ineinander verschachtelt sind, immer weiter nach innen gegangen werden beim Ersetzen.

Hat jemand eine Idee, wie man das geschickt anstellen könnte?

Ich hoffe das war verständlich..

[$traight-$hoota]

da wird dir nix anderes übrigbleiben, als die verschachtelungen "mitzuzählen" und z.B. in einem verscachtelten Array abzubildern.

PHP-Code:

<?php
$text = "[x] [x] TEXT [/x] [/x]";
$structure = $curr = array();
$parts = preg_split("#\[/?x\]#", $text, PREG_SPLIT_DELIM_CAPTURE);
$depth = 0;
foreach($part in $parts){
    switch($part){
        case '[x]':
            $depth++;
            $t = array();
            $curr[] = $t
            $curr = $t;
            $curr['parent'] = $curr;
        break;
        case '[/x]':
            $depth--;
            $curr = $curr['parent'];
        break;
        default:
            $curr[] = $part;
    }
}
?>

is nicht getestet, sollte aber nen vernünftigen tree liefern...

[pago]

"`\[x\](.|?R)*\[/x\]`"

Könnte funktionieren. Hab selbst noch nie mit Rekursion in Regex gearbeitet, aber irgendwie so wirds sein.

[Artemis]

http://www.phpfriend.de/forum/ftopic45053.html

[Corvin]

Vielen Dank für die ganzen Anregungen!

Ich hab's jetzt so gelöst:

PHP-Code:

<?php
class Test
{
    /**
     * The text..
     *
     * @access  protected
     * @var     string
     */
    protected $text = "";

    /**
     * Number of open tag.
     *
     * @access  protected
     * @var     integer
     */
    protected $openTags = 0;

    /**
     * Number of close tags.
     *
     * @access  protected
     * @var     integer
     */
    protected $closeTags = 0;

    /**
     * blub.
     *
     * @access  public
     */
    public function __construct() {
        $this->main();
    }

    /**
     * Replace Tags.
     *
     * @access  protected
     * @uses    this::$text
     * @uses    this::$openTags
     * @return  string
     */
    protected  function main() {
        $this->text = "[x] [x] TEXT [/x] [/x]";

        // count open tags and add number .. ( [x] => [x:nr] )
        $this->text = preg_replace("/\[x\]/isUe", '$this->countTags("x", "open")', $this->text);

        // count close tags
        $this->text = preg_replace("/\[\/x\]/isUe", '$this->countTags("x", "close_count")', $this->text);

        // and add number .. ( [/x] => [/x:nr] )
        $this->text = preg_replace("/\[\/x\]/isUe", '$this->countTags("x", "close")', $this->text);


        // replace all tags
        for( $i=1; $i < ( count($this->openTags)+2 ); $i++ ) {
            $this->text = preg_replace("/\[x\:$i\](.*)\[\/x\:$i\]/isU", "[y]\\1[/y]", $this->text);
        }

        echo $this->text;
    }

    /**
     * Count tags.
     *
     * @access  protected
     * @uses    this::$openTags
     * @uses    this::$closeTags
     * @return  string
     */
    protected function countTags($tag, $type) {
        switch( $type ) {
            case "open":
                $this->openTags++;
                $tag = $tag .":" .$this->openTags;
                $tag = "[" .$tag ."]";
                break;

            case "close":
                $tag = $tag .":" .$this->closeTags;
                $tag = "[/" .$tag ."]";
                $this->closeTags--;
                break;

            case "close_count":
                $this->closeTags++;
                $tag = "[/" .$tag ."]";
                break;
        }

        return $tag;
    }

}
new Test;
?>

[$traight-$hoota]

Ich habe auch mal ein recursives pattern geschrieben, dass verschachtelte divs mit class="section" finden soll.

#<div.*\sclass=".*section.*".*>(.|(?R))*</div>#sU

Dabei wird aber das jeweils erste tiefer liegende element zusammen mit dem parent-element gefunden. also hab ich folgendes probiert:

#<div.*\sclass=".*section.*".*>(.|(?R))*(?:</div>|<div.*\sclass=".*section.*".*>)#sU

Dabei wird zwar ein parent-element alleine gefunden, aber das erste child-element fehlt, weil der beginn des elements ja schon im vorhergehenden element als endbedingung verwendet wurde.

hab grad keinen plan, wie ich das lösen könnte...

[dago]

Irgendwie nervt es, jedes mal wenn man ein neuen Parser braucht sich immer wieder damit zu beschäftigen, bis er sich so verhält, wie man das gerne hätte. Deswegen schreibe gerade eine Klasse, bei der ich in dann das Verhalten konfigurieren kann. Dabei habe ich nochmal String- und Parser-Funktionen angeschaut.

preg_replace_callback könnte das sein, was ihr sucht:
http://www.php.net/manual/en/functio....php#id5812409