17 avril 2011

PSO, Enchainer les traitements sur une chaîne de caractères en PHP

A force d'utiliser jQuery, l'envie est grande de travailler de la même manière en PHP. Voici donc une toute petite classe qui permet d’enchaîner les traitements sur une même chaîne de caractères.

Démonstration

$s = PSO::factory("\ttoto");

echo $s, PHP_EOL;
//     toto

echo $s->trim()->md5(), PHP_EOL;
// f71dbe52628a3f83a77ab494817525c6

echo $s->slice(3,2), PHP_EOL;
// db

echo $s->isMatch('/^D.*/i') ? 'true' : 'false', PHP_EOL;
// true

echo $s->isMatch('/^D.*/') ? 'true' : 'false', PHP_EOL;
// false

echo count($s), PHP_EOL;
// 2

Non exhaustif

Le nombre de méthode applicable à cette classe est potentiellement énorme. Actuellement, leur nombre est limité et cette classe s'enrichira au grès de mes besoins ou des contributions.

Une façade à mbstring

L'intérêt de cette classe est aussi de supporter presque nativement des chaines multioctets (du moins autant que cela soit possible avec PHP).


$s = PSO::factory("éè");
echo count($s), PHP_EOL;
// 2 
echo strlen($s->toString()),PHP_EOL;
// 4

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/plor

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/plor

2 commentaires:

  1. class str {
    private static $_instance = null;
    private $v = '';
    private $ex = 'µ';

    /**
    * Fonction magique __call
    */
    public function __call($method, $args) {
    if (function_exists($method)) {

    foreach($args as $k => $v){
    if($v == self::$_instance->ex)
    $args[$k] = self::$_instance->v;
    }
    self::$_instance->v = call_user_func_array($method, $args);
    return self::$_instance;
    } else {
    return self::$_instance;
    }
    }


    public function __toString()
    {
    return (string) self::$_instance->v;
    }


    /**
    * Initialisation de l'instance du singleton
    */
    public static function factory($v,$ex='µ') {
    self::$_instance = new self();
    self::$_instance->v = $v;
    self::$_instance->ex = $ex;
    return self::$_instance;
    }

    private function __clone() {}
    }

    echo str::factory("\ttoto",'µ')->trim('µ')->md5('µ')->preg_replace('#c6#s','H','µ');

    Un peu plus contraignant mais universel de suite ! Non ?

    RépondreSupprimer
  2. C'est une approche différente qui permet surtout d’enchaîner très rapidement des fonctions php.

    Mais pour la classe PSO, j'avais 3 objectifs :
    - faciliter les traitements sur des chaînes multioctets (facade à mb_string)
    - Ajouter une surcouche, sans perdre trop de temps d'exécution (aussi minime soit-il) cad limiter l'usage de __call cf. https://github.com/touv/plor/blob/master/misc/pso.php
    - Obtenir un code lisible et peu contraignant.

    RépondreSupprimer