Un modeste conteneur de paramètres en PHP5

13 mars 2009 par Olivier Mansour

Voici un code que j’utilise depuis un moment et que je viens d’introduire récemment dans un projet.

L’idée est de proposer à certaine classe de mon projet un conteneur de paramètre flexible et facilement utilisable par les développeurs.

<?php
/**
 * @author omansour
 */
class ParameterHolder
{
 
  private $parameters=array();
 
  /**
   * set un parametre, attention la clef est strtolowerisée
   * @param $key string
   * @param $value mixed
   * @return void
   */
  public function setParameter($key,$value)
  {
    $this->parameters[strtolower($key)] = $value;
  }
 
  /**
   * teste l'existence d'un parametre
   * @param $key string
   * @return boolean
   */
  public function hasParameter($key)
  {
    if (array_key_exists($key, $this->getParameters()))
    {
      return true;
    }
    else
    {
      return false;
    }
  }
 
  /**
   * recuperation d'un parametre
   * @param $key string
   * @param $default string
   * @return mixed
   */
  public function getParameter($key, $default = null)
  {
    if ($this->hasParameter($key))
    {
      return $this->parameters[$key];
    }
    elseif (!is_null($default))
    {
      return $default;
    }
    else
    {
      return null;
    }
  }
 
 
  /**
   * gere automatique les get et les set
   */
  public function __call($name, $arguments)
  {
    $key = strtolower(substr($name,3));
    $arg = isset($arguments[0]) ? $arguments[0] : null;
    if (substr($name,0,3) === 'has')
    {
      return $this->hasParameter($key, $arg);
    }
 
    if (substr($name,0,3) === 'get')
    {
      return $this->getParameter($key, $arg);
    }
 
    if (substr($name,0,3) === 'set')
    {
      if (!$arg)
      {
        throw new myException(get_class($this).' un second argument est nécessaire pour une méthode set');
      }
      return $this->setParameter($key,$arg);
    }
 
    throw new myException('notre __call ne gère que les get ou les set ! méthode indéfinie : '.$name);
  }
}

La méthode __call, ainsi utilisée, permet d’accéder facilement au tableau de paramètres.

Par exemple, dans un script php, on pourra simplement écrire des choses de ce genre :

$param_holder = new ParameterHolder();
$param_holder->setUnParametre('coucou');
$var = $param_holder->getUnParametre();
// ...

Vos classes peuvent également étendre ParametreHolder ou en déclarer un lors de l’appel au constructeur et « attraper » les get* et les set* en utilisant __call. Il est enfin possible de surcharger certains getter ou setter pour faire des traitements spécifiques tout en gardant un comportement générique via __call pour les autres. Voici un petit exemple :

class myClass
{
  private $parameter_holder = null;
  public function __construct()
  {
    $this->parameter_holder = new ParameterHolder();
  }
 
  public function getRaoul()
  {
   throw new myException('tu tu tut, faut pas fâcher Raoul !');
  }
 
  public function __call($name, $arguments)
  {
    $this->parameter_holder->__call($name, $arguments);
  }
 
}

En espérant que cela vous soit utile.

Dans Info et autres geekeries | 3 commentaires | Tags : >

  1. Par YouKnowRiad le 13 mars 2009 | Répondre

    Très intéressant je trouve. j’avais jamais pensé à utiliser la méthode call ainsi. Merci

  2. Par Hugo le 28 mars 2009 | Répondre

    Ta méthode hasParameter() peut se simplifier tout simplement en :

    public function hasParameter($key)
    {
    return array_key_exists(strtolower($key), $this->getParameters());
    }

    PS : au passage j’ai ajouté le strtolower() qui manquait vu que tu le forces dans le setParameter().

    Hugo.

  3. Par Olivier Mansour le 5 juin 2010 | Répondre

    une autre approche intéressante :

    http://wiip.fr/content/proprietes-en-php

Commentaires

RSS des commentaires pour ce post