Ankündigung

Einklappen
Keine Ankündigung bisher.

Suche Anregung : PHP-Seitig XML / HTML / DomDoc

Einklappen

Neue Werbung 2019

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

  • Suche Anregung : PHP-Seitig XML / HTML / DomDoc

    Ich entwickle gerade ein Framework, in dem unter anderen Objekte erzeugt werden können, welche die gleiche Hierachie haben, wie HTML bzw eine DOMNode aus HTML ( alles PHP Serverseitig ). Mein Hauptproblem ist, wie ich aus dem Object dynamisch DOMDocument-Object erzeuge. Dabei steht die Frage im Raum, wie am besten mit der Gernereierung verfahren wird.

    Es gibt die Möglichkeit, das Objekt einem Generator zu übergeben.
    Problem hierbei. Ich müssten einen sinnvollen Weg finden durch die verschachtelte Objektstruktur zu parsen, nur die relavanten Eingenschaften auszulesen, um diese dann als DOMDoc aufzubauen. Aus dem DOMDoc kann ich später XML und auch HTML erzeugen.

    Natürlich will ich nicht vorher direkt dem Parser sagen, dass ein Body-Tag kommt usw. Das soll der Parser selber wissen. Ich hatte dazu Refelction verwendet um in dem Objekt Eigenschaften bekannt zu machen, die z.B. vom Typ HtmlBase sind.


    Ein anderer Weg wäre, das DOMDoc direkt im Objekt zu erzeugen also über die Klasse. Wobei ich da noch keine richtige Lösung habe Dom-Teile in den Dombaum zu hängen.




    PHP-Code:
      <?php
    /**
     * Created by PhpStorm.
     * User: alpha
     * Date: 14.07.19
     * Time: 01:29
     */

    namespace cls\htmlelements;


    use 
    cls\simple_types\StringType;
    use 
    DOMDocument;
    use 
    Traversable;

    class 
    Html {

        const 
    HTML5_DOC_TYPE '<!DOCTYPE html>';

        
    /**
         * @var StringType
         */
        
    private $doctype;


        
    /**
         * @var Head
         */
        
    private $head;


        
    /**
         * @var Body
         */
        
    private $body;


        
    /**
         * Html constructor.
         *
         * @param StringType|NULL $doctype
         * @param Head|NULL       $head
         * @param Body|NULL       $body
         */
        
    public function __constructStringType $doctype NULLHead $head NULL Body $body NULL )
        {
            
    $this -> doctype $doctype;
            
    $this -> head $head;
            
    $this -> body $body;
        }


        
    /**
         * @param StringType|NULL $val
         *
         * @return string
         */
        
    public function DoctypeStringType $val NULL ) : StringType {

            if( 
    $val === NULL ){
                return 
    $this -> get_doctype ();
            }

            return 
    $this -> set_doctype $val );

        }
        
    /**
         * @return StringType
         */
        
    private function get_doctype() : StringType {
            return 
    $this -> doctype;
        }
        
    /**
         * @param StringType $val
         *
         * @return StringType
         */
        
    private function set_doctypeStringType $val ) : StringType {
            
    $this -> doctype $val;
            return 
    $this -> get_doctype ();
        }


        
    /**
         * @param Head|NULL $val
         *
         * @return Head
         */
        
    public function HeadHead $val NULL ) : Head {
            if( 
    $val === NULL ){
                return 
    $this -> get_head ();
            }

            return 
    $this -> set_head $val );
        }
        
    /**
         * @return Head
         */
        
    private function get_head() : Head {
            return ( 
    $this -> head ) ?: new Head();
        }
        
    /**
         * @param Head $val
         *
         * @return Head
         */
        
    private function set_headHead $val ) : Head {
            return 
    $this -> head $val;
        }


        public function 
    Body(){

        }


        public function 
    get_html_elements(){

            
    $reflect = new \ReflectionClass(__CLASS__ );

            
    /**
             * @var $value \ReflectionProperty
             */
            
    foreach(  $reflect->getProperties ()  as $value ){

                
    $name $value->name;
                
    $obj $this -> $name();
                if( 
    $obj instanceof HtmlBase ){
                    
    print_r $obj );
                    
    print_r (PHP_EOL);
                }
            }

        }



    }



    bitcoin.de <- Meine Freelancerwährung


  • #2
    Ist ziemlich einfach: https://de.wikipedia.org/wiki/Kompos...Entwurfsmuster)
    Jedes Element weiß wie es als XML dargestellt wird. Wenn der Objektbaum zum XML gewandelt werden soll, wird der Aufruf von der Wurzel bis zu den Blätter durchgereicht und die einzelnen Elemente geben jeweils ihre XML-Darstellung zurück, diese z.B. DOMDocuments können dann in das DOMDocument vom Wurzelelement importiert werden.
    Relax, you're doing fine.
    RTFM | php.de Wissenssammlung | Datenbankindizes | Dateien in der DB?

    Kommentar


    • #3
      @VPn Dein Link verläuft ins Leere ..
      Ich versteh leider nicht, wie ich damit weiter komme. Wie erzeuge ich denn den XML-Baum?
      bitcoin.de <- Meine Freelancerwährung

      Kommentar


      • #4
        Grundsätzlich solltest du das Rendering von der eigentlich Datenstruktur trennen. D.h. du hast auf der einen Seite eine Datenstruktur welche deinen Baum darstellt und auf der anderen Seite eine Rendering-Funktion welche mit dieser Datenstruktur arbeitet und ein Ergebnis erzeugt. Hier ein simples Beispiel:

        PHP-Code:
        <?php

        function node($value, array $nodes = []){
          return (object)[
            
        'value' => $value,
            
        'nodes' => $nodes,
          ];
        }

        function 
        render(\stdClass $nodeint $indent 0){
          return 
        array_reduce($node->nodes, function($output$node) use($indent){
            return 
        $output render($node$indent 2);
          }, 
        sprintf("%s [%s]\n"str_repeat(' '$indent), $node->value));
        }

        $tree node('root', [
          
        node(1, [
            
        node(1.1),
            
        node(1.2, [
              
        node(1.21),
              
        node(1.22),
              
        node(1.23),
            ]),
            
        node(1.3),
            
        node(1.4, [
              
        node(1.41),
              
        node(1.42),
            ]),
          ])
        ]);

        echo 
        render($tree);
        Ausgabe:
        Code:
        [root]
          [1]
            [1.1]
            [1.2]
              [1.21]
              [1.22]
              [1.23]
            [1.3]
            [1.4]
              [1.41]
              [1.42]
        In deinem Fall musst du die render()-Funktion so anpassen dass Sie gültige HTML/XML-Knoten erzeugt und mit deiner Datenstruktur zurechtkommt.

        Kommentar

        Lädt...
        X