Hilfe bei Umwandlung einer prozeduralen Fkt. in OOP (PHP5)

[eldiavolo666]

Hallo,

ich bin OOP Anfänger und versuche folgende Funktion in OOP (PHP5) umzuwandeln:

function map_dirs($path, $node) 
{    
      $path = $path  . $node. '/';
       if(is_dir($path))
       {
               if($contents = opendir($path)) 
               {
                       while(($node = readdir($contents)) !== false)
                       {
                               if($node!="." && $node!="..") 
                               {
                                       echo get_content($path . $node);
                                       map_dirs($path ,$node ,$arNoScanDir, $arNoScanFile,$ext);
                               }
                       }
               closedir($contents);
               }
       }
} 

Die rekursive Funktion (von php.net) durchläuft ein Verzeichniss (festgelegt in der Variablen $path. $node ist zunächst leer) und dessen Unterverzeichnisse. Wenn es eine Datei ist wird diese an die Funktion get_contents übergeben und ausgegeben.

Mit oop bekomme ich das ganze aber leider überhaupt nicht hin. Ich denke mein Hauptproblem ist eben die Rekursion bzw. die Variablen.

Kann mir jemand einen Ansatz liefern.

Gruss,
Alex

[TobiaZ]

wäre einfacher, wenn du ein konkretes problem liefern könntest.

Eigentlich gibts keinen all zu großen unterschied, auch wenn du oo programmieren willst.

[eldiavolo666]

Also in all meiner Unwissenheit habe ich das folgende bisher geschrieben.

class Search
{
    public $path;
    public $node;

    public function __construct($path, $node)
    {
        $this->path           = $path;
        $this->node           = $node;
    }    
    
    public function map_dirs()
    {
          echo "PATH:".$this->path;
          $this->path = $this->path . $this->node . "/";
           if(is_dir($this->path)) 
           {
               if($this->contents = opendir($this->path)) 
               {
                   while(($this->node = readdir($this->contents)) !== false)
                   {
                      if($this->node != "." && $this->node != "..") 
                       {
                         echo $this->node."<br />\n";
                         $this->map_dirs();
                       }
                   }
               closedir($this->contents);
               }
           }
    }    
}

$path           = '/home/public/htdocs/dir';
$node           = '';

$website_search = new Search($path, $node); 
$website_search->map_dirs(); 

Problem scheint die Variable $path zu sein. In diesem Script hier wird die Variable einfach immer um $node erweitert. Das sieht dann aber bald so aus Dies/ist/ein.php/pfad.php/der.php...
Irgend wie stimmt die ganze Variablen übergabe wohl nicht. Aber mir ist nicht ganz klar ob meine Variablen die die Methode müssen, ob sie überhaupt in den Konstruktor müssen, oder irgendwie ganz anders *seufz*

[TobiaZ]

dann musst du bei dateien dafür sorgen, dass der $path eben nicht erweitert wird. nur bei verzeichnissen.

[closure]

Hi,

an dem eigentlichen algo ist nicht viel OO zu machen.
Generell nutzt man OOP nicht, weil man eben OOP nutzen möchte,
sondern weil es vorteile bringt. Wenn es keine vorteile bringt,
dann lässt man es eben. Man kann ziemlich schnell in die OOP-hölle
gelangen wenn man einfache aufgaben zu sehr auseinander nimmt.

In deinem fall könnte man OOP übertreiben etwa wie folgt.

<?php
    
    error_reporting(E_ALL);
    
    interface Visitable{
        public function accept(Visitor $visitor);
    }

    interface Visitor{
        public function visit($obj);
    }

    interface Strategy{
        public function execute();
    }
    
    class Path implements Visitable{
        private $dir_name_;
        private $file_name_;
        
        public function __construct($path_str){
            $this->dir_name_ = dirname($path_str);
            $this->file_name_ = basename($path_str);
        }
        
        public function accept(Visitor $visitor){
            $visitor->visit($this);
        }

        public function file_name(){
            return $this->file_name_;
        }

        public function dir_name(){
            return $this->dir_name_;
        }
    }
    
    class DepthFirstTraversal implements Strategy{
        private $start_;
        private $vistor_;

        public function __construct($start_at,$visitor){
            if(!file_exists($start_at))
                throw new Exception('File or directory does not exist');
            if(!is_dir($start_at))
                throw new Exception('Path is not a directory');
            $this->start_ = $start_at;
            $this->visitor_ = $visitor;
        }

        public function execute(){
            $this->traverse($this->start_,$this->visitor_);
        }
        
        protected function traverse($the_dir){
            $d = dir($the_dir);
            while(false !== ($cur = $d->read())){
                if($cur != '.' && $cur != '..' && is_dir($the_dir.$cur)){
                    $this->traverse($the_dir.$cur.'/');
                }else{
                    $p = new Path($the_dir.$cur);
                    $p->accept($this->visitor_);    
                }                
            }
            $d->close();
        }
    }

    class PathPrinter implements Visitor{
        public function visit($path_obj){
            echo "File is:{$path_obj->file_name()} while dir is: {$path_obj->dir_name()}\n";
        }
    }

    //context
    class Task{
        private $strat_;

        public function __construct(Strategy $strat){
            $this->strat_ = $strat;
        }

        public function run(){
            $this->strat_->execute();
        }
    }

    $t = new Task(new DepthFirstTraversal('/some/path/',new PathPrinter()));
    $t->run();

    
?>

greets

[eldiavolo666]

@closure



Da hast Du natürlich Recht. Mein snippet war ja auch nur der winzige Teil, eines Teils, dessen Teil, davon der Teil-Teil-Unterteil...usw. . Letztlich sollen da natürlich noch einige Methoden/Klassen/Variablen hinzukommen. Dann nämlich macht der OOP Ansatz m.E. durchaus wieder Sinn.

Mit Interfaces will ich aber dann doch nicht arbeiten. Sooo umfangreich und Allgemeingültig wird das Ganze dann doch wieder nicht.

Wie gesagt ist mein Problem glaube ich die Rekursion. Die im prozeduaralen Ansatz wunderbar funktioniert und die gewünschte Ausgabe erzeugt in meinem OOP Ansatz aber nicht. Da hab ich also wohl noch Verständnisprobleme.

[closure]

Ok,
dann schau dir doch mal die klasse da oben an (DepthFirstTraversal).
Da wird das problem ja gelösst. Vll kannst du davon etwas gebrauchen.

greets

[eldiavolo666]

@closure

Hmm, also wenn ich das Script anwende werden mir nur files und dirs der ersten Ebene angezeigt.

[closure]

Hi,

Achte darauf dass bei der pfadangabe der letzte slash mit
angegeben wird.

Das ist ein feature, das man in einer productionrelease fixen sollte

greets

[eldiavolo666]

Bingo!

Sieht mir zwar - für meine Fall - wie der OOP overkill aus aber es funktioniert. Aber das Skript muß ich erst mal verdauen um es zu verstehen

Thx