Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] regulärer ausdruck: negation einer zeichenkette

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • [Erledigt] regulärer ausdruck: negation einer zeichenkette

    Morgen,

    ich habe eine Templatedatei die z.B. folgendermaßen aussehen könnte:

    Code:
    <table style="border:#000 1px solid;">
      {loop repeat=$array id=1}
      <tr>
        <td style="background-color:%cycle values=#ddd,#eee id=1%;">
          %$array.val%
        </td>
        {loop repeat=$array2 id=2}
        <td style="background-color:%cycle values=#ddd,#eee id=1%;">
          %$array2.val%
        </td>
        {/loop id=2}
        <td style="background-color:%cycle values=#ddd,#eee id=1%;">
          %$array.val2%
        </td>
        <td style="background-color:%cycle values=#ddd,#eee id=1%;">
          100 %
        </td>
      </tr>
      {/loop id=1}
    </table>
    schleifen habe ich mit { und } eingefasst. Andere Variablen werden dagegen von Prozentzeichen umschlossen. Dies habe ich gemacht, da ich bei verschachtelten Schleifen die innerste Schleife zuerst übersetze und mich dann nach außen vorarbeite!

    Dazu habe ich folgenden Ausdruck verwendet:

    PHP-Code:
    const reg_exp_loops '/\{loop {1,}repeat\=(\$[a-z0-9_]*) {1,}id\=([a-z0-9_]*)\}([^\}]*)\{\/loop {1,}id\=\2\}/is'
    ([^\}]*) <= damit wird der Inhalt zwischen den Schleifen-Tags ermittelt. Ich würde aber viel lieber anstelle der Prozentzeichen durchgehend { und } verwenden, damit es einheitlich ist! Deswegen dachte ich, könnte ich nach allem Suchen was nicht die Zeichenkette "loop" enthält:

    Mein bisheriger Ansatz (die suche nach der id habe ich bei diesem Test weggelassen):

    PHP-Code:
    $reg_exp '/\{loop {1,}repeat\=\$[a-z0-9_]*\}(?!loop)(.*)\{\/loop\}/i'
    interessant ist für mich dieser Abschnitt:
    Code:
    (?!loop)(.*)
    Dies funktioniert aber nur wenn ich eine Zeichenkette wie diese habe:
    PHP-Code:
    '{loop repeat=$array}loopdfgf{/loop}' 
    das Wort befindet sich also direkt nach der schließenden Klammer für die Schleife. Tauchen Zeichen vor loop auf, wie { oder / funktioniert es nicht mehr!

    Habt ihr eine Idee wie ich nach einer kompletten Zeichenkette suchen kann, in denen nicht das zusammenhänge Wort "loop" vorkommt?


  • #2
    PHP-Code:
    $reg_exp '/\{loop {1,}repeat\=\$[a-z0-9_]*\}(.*?)\{\/loop\}/i'
    verswtehe überhaupt nicht was du willst aber vielleicht geht es ja so
    sucht einfach alles zwischen den loop-klammern...
    Under Construktion

    Kommentar


    • #3
      ja, also das problem ist das er dann auch schleifen innerhalb einer Schleife findet (bei Verschachtelungen)! Daher suche ich erst die Schleifen, die keine weiteren Schleifen beinhalten und ersetze eben den Inhalt! Ist diese innere Schleife ersetzt, enthält die Schleife um diese Schleife ja keine Schleife mehr, sie kommt also als nächstes dran usw.

      schwierig zu erklären. In PHP sähe das so aus:

      PHP-Code:
      //äußere Schleife
      for ($i 0$i 5$i++) {
        
      //innere Schleife
        
      for ($j 0$j 6$j++) {
          echo 
      'bla' $j $i;
        }

      das was innerhalb der inneren Schleife steht wird nun 6 mal wiederholt. dann wäre noch folgendes übrig:

      PHP-Code:
      //äußere Schleife
      for ($i 0$i 5$i++) {
        
      //innere Schleife
        
      bla 0 $i
        bla 1 $i
        bla 2 $i
        bla 3 $i
        bla 4 $i
        bla 5 $i

      herauskäme

      PHP-Code:
        bla 0 0
        bla 1 0
        bla 2 0
        bla 3 0
        bla 4 0
        bla 5 0
       
        bla 0 1
        bla 1 1
        bla 2 1
        bla 3 1
        bla 4 1
        bla 5 1

        bla 0 2
        bla 1 2
        bla 2 2
        bla 3 2
        bla 4 2
        bla 5 2

        bla 0 3
        bla 1 3
        bla 2 3
        bla 3 3
        bla 4 3
        bla 5 3

        bla 0 4
        bla 1 4
        bla 2 4
        bla 3 4
        bla 4 4
        bla 5 4 
      das ist die Idee und es funktioniert auch. Ich möchte eben nur die %, die die Variable umschließen durch { und } ersetzen wie bei der Schleife. Doch der Reg. Ausdr. enthält die Negation ([^\}])*, daher kann ich innerhalb der schleifen keine } verwenden und habe zu Prozentzeichen gegriffen. Die Negation habe ich eingeführt, damit ich eben die innersten Schleifen herausfinden kann. Nach einem durchlauf wird geprüft ob das Resultat noch Schleifen enthält. Wenn ja wird die Funktion zum Ersetzen erneut aufgerufen!

      Kommentar


      • #4
        Stichwort: negative Assertions
        --

        „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
        Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


        --

        Kommentar


        • #5
          tja, wenn man nicht weiß wonach man suchen soll...

          danke. hab es gelöst. Wenn es besser und/oder einfacher geht, bitte ich um rückmeldung!

          PHP-Code:
          //lookahead assertion: (?!.*?\{loop {1,}repeat\=\$[a-z0-9_]* {1,}id\=[a-z0-9_]*\})
          //lookbehind assertion: (?<!\{\/loop\})

          $reg_exp '/\{loop {1,}repeat\=(\$[a-z0-9_]*) {1,}id\=([a-z0-9_]*)\}
          (?!.*?\{loop {1,}repeat\=\$[a-z0-9_]* {1,}id\=[a-z0-9_]*\})(.*?)(?<!\{\/loop\})
          \{\/loop\}/is'

          aufgefallen ist mir, dass ich in lookahead assertions nach zeichenketten einer unbekannten Länge suchen kann, z.B.
          Code:
          (?![a-z0-9_]*)
          bei lookbehind assertions darf ich das scheinbar nicht:

          Code:
          (?<!\{\/loop\}.*?)
          Fehlermeldung:
          Code:
          lookbehind assertion is not fixed length
          woran liegt das?

          Kommentar


          • #6
            Das liegt am Prinzip wie reg. Ausdrücke arbeiten. Von links nach rechts. Sie matchen so viel wie sie dürfen, passt das nächste Zeichen nicht, gibts eine Art Fallback (es wird ein Zeichen des Matchings entfernt). Beim Matchen ist das noch relativ überschaubar, bei Assertions, die den String ja nicht matchen, gibts einfach zu viele Kombinationen.

            So erklär ich mir das.

            Ich hatte irgendwo mal ne gute Webquelle, wenn ich die wiederfinde trag ichs nach.
            --

            „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
            Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


            --

            Kommentar

            Lädt...
            X