Un modeste conteneur de paramètres en PHP5

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.

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.

Publicités

3 réflexions au sujet de « Un modeste conteneur de paramètres en PHP5 »

  1. Hugo

    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.

    Répondre

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s