php.de

Zurück   php.de > Webentwicklung > Software-Design
regex bibliothek regex bibliothek
Wiki Registrieren Grundlagen Suchen Heutige Beiträge Alle Foren als gelesen markieren

Software-Design Diskussionen auf Profi-Niveau: PHP Lösungen auf konzeptioneller Ebene

Antwort
 
LinkBack Themen-Optionen Thema bewerten
Alt 17.10.2009, 17:56  
Erfahrener Benutzer
 
Registriert seit: 16.07.2005
Beiträge: 1.007
PHP-Kenntnisse:
Fortgeschritten
brian johnson befindet sich auf einem aufstrebenden Ast
Standard regex bibliothek
hi,

ich habe beschlossen, das ich unbedingt eine regex bibliothek brauche. ich möchte dazu nicht nur eure meinung hören, sondern auch wie ich es um eine sprachversion erweitern könnte (z.b. für ein datum). ist hier eine abstrakte fabrik am geeignesten? also sowas:

PHP-Code:
preg_main::get('date','de');
preg_main::get('date','en'); 
oder gibt es geeigneteres?

zum code: ich will am ende nurnoch hingehen und sowas schreiben und in einzelnen dateien ablegen:

(die statische methode um auf den regex zugriff zu haben ohne eine neue instanz erstellen zu müssen)
PHP-Code:
<?php

class preg_match_ip extends preg_main
{
    public static function get_static_regex()
    {
        return '(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)';
    }

    public function get_regex()
    {
        return self::get_static_regex();
    }
}

class preg_replace_repeated_whitespace extends preg_main
{
    public function get_regex()
    {
        return '\s+';
    }

    public function get_replace()
    {
        return ' ';
    }
}
und das so anzuwenden:

PHP-Code:
$preg=new preg_match_ip('192.168.1.1');

if($preg->is_match())
    echo 'juhuuuu<br/>';

$preg->set_in('blabla 192.168.1.1 blabla');
$preg->set_match_only_full(); /* alters the regex to have ^ as prefix and + and $ as suffix so it looks if the string ONLY contains the search string */

if(! $preg->is_match())
    echo 'doh!<br/>';

$preg->set_in('i hacked 127.0.0.1');
$preg->set_match_only_full(FALSE);
    echo $preg->replace('myself').'<br/>';

        
$preg->set_in(Array('1.1.1.1','asdfasdf'));
    var_dump($preg->grep());


$preg=new preg_replace_repeated_whitespace('asadf     xcvas    asdf');
echo $preg->replace(); 
ausgabe:
Zitat:
juhuuuu
doh!
i hacked myself
array(1) {
[0]=>
string(7) "1.1.1.1"
}
asadf xcvas asdf
das ist die main klasse dazu:

PHP-Code:
<?php

abstract class preg_main
{
    const SPLIT_DELIM_CAPTURE=    PREG_SPLIT_DELIM_CAPTURE;
    const SPLIT_NO_EMPTY=        PREG_SPLIT_NO_EMPTY;
    const SPLIT_OFFSET_CAPTURE=    PREG_SPLIT_OFFSET_CAPTURE;

    protected $in='';
    protected $match_only=FALSE;
    protected $match_only_full=FALSE;

    public function __construct($in='',$match_only=FALSE,$match_only_full=FALSE)
    {
        //if(!is_string($string) && !($string instanceof common_interface_to_string))
        //    throw new common_e_argument(common_e_argument::EXPECTING_STRING,gettype($string));

        $this->set_match_only($match_only);
        $this->set_match_only_full($match_only_full);

        $this->in=$in;

        $this->preg=new common_preg;
    }

    abstract public function get_regex();

    public function set_in($to)
    {
        $this->in=$to;
    }

    // sets ^ as prefix and $ as suffix on the regex
    // then the regex looks if $in only contains the expression
    public function set_match_only($to=TRUE)
    {
        $this->match_only=(bool)$to;
    }

    // sets ^ as prefix and + and $ as suffix on the regex
    // then the regex looks if $in only contains the repeated expression
    public function set_match_only_full($to=TRUE)
    {
        if($to)
            $this->match_only_full=$this->match_only=TRUE;
        else
            $this->match_only_full=$this->match_only=FALSE;
    }

    public function get_delimiter()
    {
        return '&';
    }

    public function get_replace()
    {
        return '';
    }

    public function get_flags($flags=NULL)
    {
        return $flags;
    }

    // u === unicode
    public function get_modifier($modifier=NULL)
    {
        return $modifier.'u';
    }

    public function build_regex()
    {
        $result=$this->get_delimiter();

        if($this->match_only)
            $result.='^';
        
        if($this->match_only_full)
            $result.='(';

        $result.=$this->get_regex();

        if($this->match_only_full)
            $result.=')+';

        if($this->match_only)
            $result.='$';

        $result.=$this->get_delimiter().$this->get_modifier();

        return $result;
    }


    
    public function is_match($in=NULL,$flags=NULL,$offset=NULL)
    {
        if($in===NULL)
            $in=$this->in;

        try
        {
            $this->preg->set_pattern($this->build_regex());

            return $this->preg->is_match($in,$flags,$offset);

        }
        catch(common_e_preg $common_e_preg)
        {
            throw new preg_e_match($common_e_preg);
        }
    }

    public function is_match_all($in=NULL,$flags=NULL,$offset=NULL)
    {
        if($in===NULL)
            $in=$this->in;

        try
        {
            $this->preg->set_pattern($this->build_regex());
            return $this->preg->is_match_all($in,$flags,$offset);
        }
        catch(common_e_preg $common_e_preg)
        {
            throw new preg_e_match($common_e_preg);
        }
    }

    public function is_grep($in=NULL,$flags=NULL)
    {
        if($in===NULL)
            $in=$this->in;

        try
        {
            $this->preg->set_pattern($this->build_regex());
            return $this->preg->is_grep($in,$flags);
        }
        catch(common_e_preg $e_preg)
        {
            throw new preg_e_match($e_preg);
        }
    }

    public function get_match()
    {
        return $this->preg->get_match();
    }

    public function get_replace_count()
    {
        return $this->preg->get_replace_count();
    }

    public function match($in=NULL,$flags=NULL,$offset=NULL)
    {
        if($in===NULL)
            $in=$this->in;

        try
        {
            $this->preg->set_pattern($this->build_regex());
            return $this->preg->match($in,$flags,$offset);

        }
        catch(common_e_preg $common_e_preg)
        {
            throw new preg_e_match($common_e_preg);
        }
    }

    public function match_all($in=NULL,$flags=NULL,$offset=NULL)
    {
        if($in===NULL)
            $in=$this->in;

        try
        {
            $this->preg->set_pattern($this->build_regex());
            return $this->preg->match_all($in,$flags,$offset);

        }
        catch(common_e_preg $common_e_preg)
        {
            throw new preg_e_match($common_e_preg);
        }
    }

    public function grep($in=NULL,$flags=NULL,$offset=NULL)
    {
        if($in===NULL)
            $in=$this->in;

        try
        {
            $this->preg->set_pattern($this->build_regex());
            return $this->preg->grep($in,$flags,$offset);

        }
        catch(common_e_preg $common_e_preg)
        {
            throw new preg_e_match($common_e_preg);
        }
    }

    public function replace($with=NULL,$in=NULL,$limit=-1)
    {
        if($in===NULL)
            $in=$this->in;

        if($with===NULL)
            $with=$this->get_replace();

        try
        {
            $this->preg->set_pattern($this->build_regex());
            return $this->preg->replace($with,$in,$limit);
        }
        catch(common_e_preg $common_e_preg)
        {
            throw new preg_e_match($common_e_preg);
        }
    }

    public function replace_callback($callback=NULL,$in=NULL,$limit=-1)
    {
        if($in===NULL)
            $in=$this->in;

        if($callback===NULL && $this->callback!==NULL)
            $with=$this->callback;

        if(!is_callable($with))
            throw new common_e_argument(common_e_argument::IS_NOT_CALLABLE,$with);

        try
        {
            $this->preg->set_pattern($this->build_regex());
            return $this->preg->replace_callback($in,$with,$limit);
        }
        catch(common_e_preg $e_preg)
        {
            throw new preg_e_match($e_preg);
        }
    }

    public function __toString()
    {
        return $this->get_regex();
    }
}
die hintergrundklasse common_preg

PHP-Code:
<?php 
 
class common_preg 
{ 
    protected $in=NULL; 
    protected $pattern=''; 
    protected $match_match=Array(); 
    protected $replace_count=0; 
    protected $limit=-1;
    protected $callback; 
     
    public function __construct($pattern=NULL) 
    {
        if($pattern!==NULL) 
            $this->set_pattern($pattern); 
    }

    public function set_pattern($to)
    { 
        if(!is_string($to) && !is_array($to)) 
            throw new common_e_argument(common_e_argument::EXPECTING_STRING,gettype($to)); 
             
        if(!is_array($to) && trim($to)==='') 
            throw new common_e_argument(common_e_argument::IS_EMPTY,1);

        $this->pattern=$to;
    }

    public function set_pattern_by_reference(&$to)
    {
        $this->set_pattern($to);

        $this->pattern=&$to;
    } 
     
    public function set_in($in) 
    { 
        $this->in=$in; 
    } 
     
    public function set_in_by_reference(&$in) 
    { 
        $this->in=&$in; 
    } 
     
    public function set_replace_with($with) 
    { 
        $this->with=$with; 
    } 
 
    public function set_replace_with_by_reference(&$with) 
    { 
        $this->with=&$with; 
    } 
     
    public function set_limit($limit) 
    { 
        if(!is_int($limit)) 
            throw new common_e_argument(common_e_argument::EXPECTING_INTEGER,gettype($limit));

        if($limit<1 && $limit!==-1)
            throw new common_e_argument(common_e_argument::OUT_OF_RANGE,'-1 or 1-n'); 
             
        $this->limit=$limit; 
    }

    public function set_callback($to)
    {
        if(!is_callable($to))
            throw new common_e_argument(common_e_argument::IS_NOT_CALLABLE,$to);

        $this->callback=$to;
    } 
     
    public function get_match() 
    { 
        return $this->match_match; 
    } 
     
    public function get_replace_count() 
    { 
        return $this->replace_count; 
    } 
     
    public function is_match($in=NULL,$flags=NULL,$offset=NULL) 
    { 
        return $this->match($in,$flags,$offset)!==FALSE; 
    } 
     
    public function is_match_all($in=NULL,$flags=NULL,$offset=NULL) 
    {
        return $this->match_all($in,$flags,$offset)!==FALSE; 
    } 
     
    public function is_grep($in=NULL,$flags=NULL) 
    {
        $return=$this->grep($in,$flags,$offset); 
        return !empty($return); 
    }

    public function match($in=NULL,$flags=NULL,$offset=NULL)
    {
        if($in===NULL) 
            $in=$this->in; 
     
        $this->match_match=Array(); 
        $match=preg_match($this->pattern,$in,$this->match_match,$flags,$offset); 
 
        if(preg_last_error()!==PREG_NO_ERROR) 
            throw common_e_preg::create(common_e::UNKNOWN,preg_last_error());
        elseif($match===FALSE) 
            throw new common_e_preg(common_e_preg::INTERNAL_ERROR); 
        elseif(empty($this->match_match))
            return FALSE;
        else 
            return $this->match_match;
    }

    public function match_all($in=NULL,$flags=NULL,$offset=NULL)
    { 
        if($in===NULL) 
            $in=$this->in; 
 
        $this->match_match=Array(); 
        $return=preg_match_all($this->pattern,$in,$this->match_match,$flags,$offset); 
 
        if(preg_last_error()!==PREG_NO_ERROR) 
            throw common_e_preg::create(preg_last_error());
        elseif($match===FALSE) 
            throw new common_e_preg(common_e_preg::INTERNAL_ERROR); 
        elseif(empty($this->match_match))
            return FALSE; 
        else 
            return $this->match_match;
    } 
     
    public function grep($in=NULL,$flags=NULL) 
    { 
        if($in===NULL) 
            $in=$this->in; 
             
        $this->match_match=preg_grep($this->pattern,$in,$flags); 
         
        if(preg_last_error()!==PREG_NO_ERROR) 
            throw new common_e_preg(common_e::UNKNOWN,preg_last_error()); 
        else 
            return $this->match_match; 
    } 
     
    public function replace($with=NULL,$in=NULL,$limit=NULL) 
    { 
        if($in===NULL) 
            $in=$this->in; 
 
        if($with===NULL) 
            $with=$this->with; 
 
        if($limit===NULL) 
            $limit=$this->limit; 
 
        $return=preg_replace($this->pattern,$with,$in,$limit,$this->replace_count); 
 
        if(preg_last_error()!==PREG_NO_ERROR) 
            throw new common_e_preg(common_e::UNKNOWN,preg_last_error());
        elseif($return===NULL)
            throw new common_e_preg(common_e_preg::INTERNAL_ERROR); 
        else 
            return $return; 
    } 
     
    public function replace_callback($in=NULL,$callback=NULL,$limit=NULL) 
    { 
        if($in===NULL) 
            $in=$this->in; 
 
        if($callback===NULL) 
            $callback=$this->callback; 
             
        if(!is_callable($callback)) 
            throw new common_e_argument(common_e_argument::INVALID_CALLBACK,(string)$callback); 
 
        if($limit===NULL) 
            $limit=$this->limit; 
 
        $return=preg_replace($this->pattern,$with,$in,$limit,$this->replace_count); 
 
        if(preg_last_error()!==PREG_NO_ERROR) 
            throw new common_e_preg(common_e::UNKNOWN,preg_last_error());
        elseif($return===NULL)
            throw new common_e_preg(common_e_preg::INTERNAL_ERROR); 
        else 
            return $return; 
    }

    public function split($in=NULL,$limit=NULL,$flags=NULL)
    { 
        if($in===NULL) 
            $in=$this->in;

        if($limit===NULL)
            $limit=$this->limit; 

        $return=preg_split($this->pattern,$in,$limit,$flags); 
 
        if(preg_last_error()!==PREG_NO_ERROR) 
            throw new common_e_preg(common_e::UNKNOWN,preg_last_error()); 
        else 
            return $return;
    } 
     
    public function escape($what,$delimiter=NULL) 
    { 
        return preg_quote($what,$delimiter); 
    } 
} 
 
/*  
        $preg=new common_preg('!some!i'); 
        if($preg->is_match('This is some piece of some Text!')) 
        { 
            var_dump($preg->get_match()); 
        } 
 
        if($preg->is_match_all('This is some piece of some Text!')) 
        { 
            var_dump($preg->get_match()); 
        }

        var_dump($preg->match('This is some piece of some Text!'); 
         
        $array=array('some','something','super','nothing'); 
        $value=''; 
        $preg->set_in($value); 
 
        foreach($array as $value) 
        { 
            if($preg->match()) 
                echo $value.' '; 
        } 
 
        echo '<hr />'; 
         
        echo $preg->replace('something','any')."\n"; 
        echo $preg->replace('some other things','any')."\n"; 
         
        $preg->set_replace_with('any'); 
         
        echo $preg->replace('something')."\n"; 
        echo $preg->replace('some other things')."\n"; 
         
        echo '<hr />'; 
         
        $array=array('some','something','super','nothing'); 
        $value=''; 
        $preg->set_in_by_reference($value); 
        $replace='any'; 
        $preg->set_replace_with($replace); 
 
        foreach($array as $value) //$value is reused, and prior given as reference to $preg 
        { 
            echo $preg->replace().' '; 
        } 
*/
die exceptions>

PHP-Code:
<?php 
 
class common_e_argument extends common_e //common_e_avoidable 
{ 
    const MISSING=                'Missing argument "%s:.'; 
    const MISSING_ARRAY_INDEX=        'Missing array index "%s".'; 
    const DIVISION_BY_ZERO=            'Divison by Zero (Got Error: "You are not Chuck Norris!")'; 
    const IS_EMPTY=                'Given argument # %d is empty.'; 
    const KEY_IS_EMPTY=            'Did not expect empty key, array: "%s".'; 
    const WRONG_COUNT=            'Expecting exactly %d arguments.'; 
    const EXPECTING_MORE_DIMENSIONAL_ARRAY=    'Expecting Array with %d dimensions.'; 
    const EXPECTING_SCALAR=            'Expecting Scalar, %s given.'; 
    const EXPECTING_ARRAY=            'Expecting Array, %s given.'; 
    const EXPECTING_STRING=            'Expecting String, %s given.'; 
    const EXPECTING_BOOLEAN=        'Expecting Boolean, %s given.'; 
    const EXPECTING_INTEGER=        'Expecting Integer, %s given.'; 
    const EXPECTING_FLOAT=            'Expecting Float, %s given.'; 
    const EXPECTING_INSTANCEOF=        'Expecting instanceof %s.'; 
    const NOT_SET=                'Variable "%s" is not set, therefore it cannot be given or changed.'; 
    const OUT_OF_RANGE=            'Variable is out of range.'; 
    const CLASS_NOT_FOUND=            'Class %s not found.'; 
    const IS_NOT_CALLABLE=            '%s is not callable.'; 
}

class common_e_preg extends common_e
{

}
schonmal danke!
__________________
PHP4?!?>>>Aktuelle PHP Version: 5.2.11 || 5.3.0
Suse 11.2 *vorfreude*
brian johnson ist offline   Mit Zitat antworten
Sponsor Mitteilung
PHP Code Flüsterer

Registriert seit: 21.08.2005
Beiträge: 4682
PHP-Kenntnisse:
Fortgeschritten

Alt 17.10.2009, 22:29  
Moderator und Wett-König
 
Benutzerbild von dr.e.
 
Registriert seit: 21.05.2008
Beiträge: 3.657
PHP-Kenntnisse:
Fortgeschritten
dr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblick
dr.e. eine Nachricht über Skype™ schicken
Standard
Hallo Brian,

die Idee gefällt mir gut, ich bin nur mit der Namensgebung noch nicht so glücklich. Was du das aus OO-Sicht modellierst, ist eine RegExp und kein preg_match. Du solltest sowohl namentlich als auch programmatisch verstecken, welche RegExp-Bibliothek du im Hintergrund nutz.
Weiterhin sollten die Methoden etwas eingängiger lauten. Statt set_in() würde ich setInput() oder setContent() erwarten. Schau dir mal die JAVA Naming Convention an, dann sieht der Code einfach schöner aus.

Konzeptuell würde ich das Klassen-Design nochmal etwas überdenken. preg_main sollte IMHO die Methoden, die für die konkrete RegExp nötig sind nicht in public, sonder in protected generieren, diese müssen nach Aussen nicht sichtbar sein. Insgesamt gibt es gefühlt auch zuviele public Methoden.
__________________
Viele Grüße,
Dr.E.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1. Think about software design before you start to write code!
2. Discuss and review it together with experts!
3. Choose good tools (-> Adventure PHP Framework (APF))!
4. Write clean and reusable software only!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
dr.e. ist offline   Mit Zitat antworten
Alt 18.10.2009, 13:43  
Erfahrener Benutzer
 
Registriert seit: 16.07.2005
Beiträge: 1.007
PHP-Kenntnisse:
Fortgeschritten
brian johnson befindet sich auf einem aufstrebenden Ast
Standard
Zitat:
Zitat von dr.e. Beitrag anzeigen
Hallo Brian,

die Idee gefällt mir gut, ich bin nur mit der Namensgebung noch nicht so glücklich. Was du das aus OO-Sicht modellierst, ist eine RegExp und kein preg_match. Du solltest sowohl namentlich als auch programmatisch verstecken, welche RegExp-Bibliothek du im Hintergrund nutz.
stimmt.

Zitat:
Zitat von dr.e. Beitrag anzeigen
Weiterhin sollten die Methoden etwas eingängiger lauten. Statt set_in() würde ich setInput() oder setContent() erwarten.
stimmt auch!

Zitat:
Schau dir mal die JAVA Naming Convention an, dann sieht der Code einfach schöner aus.
nur wenn du damit nicht auf DromedarCase anspielst

Zitat:
Konzeptuell würde ich das Klassen-Design nochmal etwas überdenken. preg_main sollte IMHO die Methoden, die für die konkrete RegExp nötig sind nicht in public, sonder in protected generieren, diese müssen nach Aussen nicht sichtbar sein. Insgesamt gibt es gefühlt auch zuviele public Methoden.
hmm

get_regex()
build_regex()
get_delimiter()

könnte ich noch auf protected setzen, alle anderen get funktionen sollen auch ein entsprechendes set haben (was ich noch nicht implementiert habe) von daher fände ich es wichtig diese auch als public bereitzustellen.

wie würdest du noch eine sprachvariante dafür erstellen? mit einer factory methode wie vorgeschlagen?

auf jeden fall schonmal danke!
__________________
PHP4?!?>>>Aktuelle PHP Version: 5.2.11 || 5.3.0
Suse 11.2 *vorfreude*
brian johnson ist offline   Mit Zitat antworten
Alt 18.10.2009, 16:25  
Moderator und Wett-König
 
Benutzerbild von dr.e.
 
Registriert seit: 21.05.2008
Beiträge: 3.657
PHP-Kenntnisse:
Fortgeschritten
dr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblick
dr.e. eine Nachricht über Skype™ schicken
Standard
Hi,

Zitat:
könnte ich noch auf protected setzen, alle anderen get funktionen sollen auch ein entsprechendes set haben (was ich noch nicht implementiert habe) von daher fände ich es wichtig diese auch als public bereitzustellen.
Wenn es wirklich so viele sind, dann ist da noch ein Fehler im Busch. Ich vermute mal, dass die Entitäten nicht klar abgegrenzt sind. Soll heißen: du modellierst mehrere Bereiche in einer Klasse. Um das aufzulösen kannst du dir nun überlegen, welche Bereiche du in einer Klasse hast und diese ggf. Nach-Typisieren, sprich als eigenen Datentyp auslagern.

Zitat:
wie würdest du noch eine sprachvariante dafür erstellen? mit einer factory methode wie vorgeschlagen?
Meinst du die Fehlermeldungen? Das würde ich lassen, denn Entwickler-Sprache ist Englisch. Wer das nicht versteht sollte zur VHS gehen. Allerdings würde ich das Konzept ändern und eine RegExpException (Benennung!) einführen. Diese enthält die Fehler-Strings dann statisch. Auslagern musst du das eigentlich garnicht, denn es gehört quasi zu dem Block, wo sie auch geworfen wird.
__________________
Viele Grüße,
Dr.E.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1. Think about software design before you start to write code!
2. Discuss and review it together with experts!
3. Choose good tools (-> Adventure PHP Framework (APF))!
4. Write clean and reusable software only!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
dr.e. ist offline   Mit Zitat antworten
Alt 18.10.2009, 16:38  
Erfahrener Benutzer
 
Registriert seit: 16.07.2005
Beiträge: 1.007
PHP-Kenntnisse:
Fortgeschritten
brian johnson befindet sich auf einem aufstrebenden Ast
Standard
Zitat:
Zitat von dr.e. Beitrag anzeigen
Wenn es wirklich so viele sind, dann ist da noch ein Fehler im Busch. Ich vermute mal, dass die Entitäten nicht klar abgegrenzt sind. Soll heißen: du modellierst mehrere Bereiche in einer Klasse. Um das aufzulösen kannst du dir nun überlegen, welche Bereiche du in einer Klasse hast und diese ggf. Nach-Typisieren, sprich als eigenen Datentyp auslagern.
nun, die is_* methoden sind ja nur wrapper, aber aus komfort gründen würde ich die nur ungern in decorator klassen schreiben.

was man natürlich noch machen könnte, wäre sowas:

PHP-Code:
$regex=new regex_replace('blabla',new regex_ip);
$regex->replace(); 
fände ich aber unpraktisch. und die setter und getter beinflussen das verhalten, von daher sollten die schon dort bleiben wo sie sind.

Zitat:
Zitat von dr.e. Beitrag anzeigen
Meinst du die Fehlermeldungen? Das würde ich lassen, denn Entwickler-Sprache ist Englisch. Wer das nicht versteht sollte zur VHS gehen. Allerdings würde ich das Konzept ändern und eine RegExpException (Benennung!) einführen. Diese enthält die Fehler-Strings dann statisch. Auslagern musst du das eigentlich garnicht, denn es gehört quasi zu dem Block, wo sie auch geworfen wird.
nein, ich meinte regexe auf die Ausgabesprache bezogen. so z.b. das datum, im deutschen schreibe ich:

Zitat:
18.10.2009
im englsichen

Zitat:
10/18/2009
das sind leider schonwieder 2 verschiedene regexe. deswegen die frage, ob ich dafür ein factory modell nehmen soll:

PHP-Code:
regex_main::get('date',SPRACHE); 
oder ob es anders besser wäre.
__________________
PHP4?!?>>>Aktuelle PHP Version: 5.2.11 || 5.3.0
Suse 11.2 *vorfreude*
brian johnson ist offline   Mit Zitat antworten
Alt 18.10.2009, 19:15  
Moderator und Wett-König
 
Benutzerbild von dr.e.
 
Registriert seit: 21.05.2008
Beiträge: 3.657
PHP-Kenntnisse:
Fortgeschritten
dr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblick
dr.e. eine Nachricht über Skype™ schicken
Standard
Den ersten Punkten stimme ich zu - überzeugt -, allerdings solltest du das auch so im Methoden-Block dokumentieren.

Was die Sprache angeht, würde ich die Sprache wie vorgeschlagen übergeben und eine Factory nutzen, dir die richtige Regexp für die geünschte Sprache zu erstellen.
__________________
Viele Grüße,
Dr.E.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1. Think about software design before you start to write code!
2. Discuss and review it together with experts!
3. Choose good tools (-> Adventure PHP Framework (APF))!
4. Write clean and reusable software only!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
dr.e. ist offline   Mit Zitat antworten
Alt 19.10.2009, 11:57  
Erfahrener Benutzer
 
Registriert seit: 30.07.2008
Beiträge: 1.169
PHP-Kenntnisse:
Fortgeschritten
xm22 sorgt für eine eindrucksvolle Atmosphärexm22 sorgt für eine eindrucksvolle Atmosphärexm22 sorgt für eine eindrucksvolle Atmosphäre
Standard
Zitat:
eine RegExp und kein preg_match
Warum dann nicht gleich den Verweis auf Reguläre Ausdrücke beschränken?

Eigene RegExp-Klassen? Warum nicht direkt eine Bibliothek aus Validatoren. Kann ja auch sein, dass ein Wert mal zusätzlich mit einer Callback-Funktion getestet werden soll. Und dann müsste man nach dem jetzigen Konzept weitere, externe Validatoren benutzen.

Und dafür gibt es wiederum genügend vorhandene Sachen (z. B. Zend_Validate)
xm22 ist offline   Mit Zitat antworten
Alt 19.10.2009, 13:07  
moderatives Dielektrikum
 
Benutzerbild von nikosch
 
Registriert seit: 21.05.2008
Beiträge: 35.994
PHP-Kenntnisse:
Fortgeschritten
nikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunftnikosch hat eine strahlende Zukunft
Standard
Nunja, Filter und Validatoren sind ja nicht die einzigen Anwendungen für reguläre Ausdrücke.
__________________
--
One pixel is still too big. Please make it smaller. ASAP.

Initiative Mittelstand.
Die wichtigste Gestaltungsregel im Screendesign ist Pi mal Daumen des Arbeitgebers.
--
nikosch ist gerade online   Mit Zitat antworten
Alt 19.10.2009, 15:07  
Erfahrener Benutzer
 
Registriert seit: 16.07.2005
Beiträge: 1.007
PHP-Kenntnisse:
Fortgeschritten
brian johnson befindet sich auf einem aufstrebenden Ast
Standard
Zitat:
Zitat von xm22 Beitrag anzeigen
Warum dann nicht gleich den Verweis auf Reguläre Ausdrücke beschränken?

Eigene RegExp-Klassen? Warum nicht direkt eine Bibliothek aus Validatoren. Kann ja auch sein, dass ein Wert mal zusätzlich mit einer Callback-Funktion getestet werden soll. Und dann müsste man nach dem jetzigen Konzept weitere, externe Validatoren benutzen.

Und dafür gibt es wiederum genügend vorhandene Sachen (z. B. Zend_Validate)
da hab ich das sogar her. ich wollte alle ip adressen in einem dokument maskieren. doch Zend_Validate prüft IPs so:

PHP-Code:
public function isValid($value)
    {
        if (!is_string($value)) {
            $this->_error(self::INVALID);
            return false;
        }

        $this->_setValue($value);

        if ((ip2long($value) === false) || (long2ip(ip2long($value)) !== $value)) {
            if (!function_exists('inet_pton')) {
                $this->_error(self::NOT_IP_ADDRESS);
                return false;
            } else if ((@inet_pton($value) === false) ||(inet_ntop(@inet_pton($value)) !== $value)) {
                $this->_error(self::NOT_IP_ADDRESS);
                return false;
            }
        }

        return true;
    } 
da hab ich dann nun gestanden und musste malwieder einen regex suchen.

jetzt schreib ich halt nurnoch:

PHP-Code:
$regex=new regex_ip('meine IP ist 127.0.0.1');
$regex->replace('X.X.X.X'); 
jetzt kann ich mir auch noch einen schönen iterator drumrum schreiben. und einen filter_iterator. *ich mag iteratoren *

@Dr.e.: danke!
__________________
PHP4?!?>>>Aktuelle PHP Version: 5.2.11 || 5.3.0
Suse 11.2 *vorfreude*
brian johnson ist offline   Mit Zitat antworten
Alt 19.10.2009, 16:23  
Moderator und Wett-König
 
Benutzerbild von dr.e.
 
Registriert seit: 21.05.2008
Beiträge: 3.657
PHP-Kenntnisse:
Fortgeschritten
dr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblickdr.e. ist ein Lichtblick
dr.e. eine Nachricht über Skype™ schicken
Standard
Zitat:
@Dr.e.: danke!
Wie immer:gerne!
__________________
Viele Grüße,
Dr.E.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1. Think about software design before you start to write code!
2. Discuss and review it together with experts!
3. Choose good tools (-> Adventure PHP Framework (APF))!
4. Write clean and reusable software only!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
dr.e. ist offline   Mit Zitat antworten
Antwort

« Sinn von MVC-Frameworks auf PHP-Basis, die Zweite | Plugin-Schnittstelle für Board-System »

Themen-Optionen
Thema bewerten
Thema bewerten:

Forumregeln
Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.
BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are an
Gehe zu

Ähnliche Themen
Thema Autor Forum Antworten Letzter Beitrag
Array sortieren mit regex Lupi PHP Tipps 2008 3 21.07.2008 15:17
Regex: Auslesen der Meta-Tags einer Webseite Sucheingrenzung pepe24 PHP Tipps 2008 12 31.05.2008 15:41
2 Regex in PHP kompatible Syntax übersetzen NoiZy PHP-Fortgeschrittene 6 07.04.2008 09:04
Regex Link Problem Broadcast PHP Tipps 2008 2 29.02.2008 16:30
Gierig/nicht gieriger Regex Papst PHP Tipps 2008 22 02.12.2007 20:15
[gelöst :D ] regex tuts nur einmal pro zeile notyyy PHP Tipps 2008 17 24.09.2007 15:40
RegEx für Mail-Adresse (Bitte prüfen!) vollkommenegal PHP Tipps 2006 13 20.11.2006 20:02
Regex löscht alle Zeilenumbrüche. Anduril PHP Tipps 2006 3 16.10.2006 22:36
habe ein paar fragen zu REGEX imported_kremser PHP Tipps 2006 11 31.01.2006 15:30
RegEx findet Stringvorkommen nicht PHP Tipps 2007 6 08.12.2005 21:52
RegEx? DerDesian PHP Tipps 2005 2 08.03.2005 12:57
Anker Links parsen (RegEx) Spyker PHP Tipps 2005 1 31.01.2005 12:01
Regex für attribute in quelltexten robo47 PHP Tipps 2005 6 27.01.2005 18:29
[Erledigt] Regex für selektives Replacement PHP-Fortgeschrittene 2 25.12.2004 15:57
Problem mit regex PHP Tipps 2004 1 09.09.2004 10:00

Besucher kamen über folgende Suchanfragen bei Google auf diese Seite
regex bibliothek, php regex erstellen, regex bib, php regex-klassen, regexp bibliothek, regexp skype block, bibliothek regex, regex bibiothek, nulllimit.de, regex bibl, mit php regex generieren, regex php erstellen, php sprache aus webseite auslesen meta preg, anker html php suchen preg, php regex bibliotheken, regex welche bibliothek, regex bibliothek php, php regex match in array, php ip aus string filtern regex, klassen bibkiothek php

Alle Zeitangaben in WEZ +2. Es ist jetzt 00:35 Uhr.

php.de - Das deutsche PHP-Forum - Kontakt - Impressum - Forenregeln - Archiv - Nach oben



Powered by vBulletin® Version 3.7.2 (Deutsch)
Copyright ©2000 - 2012, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO 3.2.0
Aprilia-Forum, Aquaristik-Forum, Liebeskummer-Forum, Zierfisch-Forum, Geizkragen-Forum