Forum Programmation.php Typage des paramètres d'une fonction

Posté par santos le 17 novembre 2008 à 18:50.

Étiquettes : aucune

nov.

2008

Bonjour,

bien que ce soit facultatif, il est normalement possible de typer les paramètres attendus d'une fonction ou méthode, comme par exemple en Java.

Exemple :



class Foo{}


class Bar


{


	public function __construct(Foo $foo){}


}


class Plop


{


	public function __construct(string $text){}


}


$myBar = new Bar(new Foo());


$myPlop = new Plop("Hello world !");

$myBar, pas de souci. Mais $myPlop, erreur :

Catchable fatal error: Argument 1 passed to Plop::__construct() must be an instance of string, string given

En gros chaque fois que le type défini est une classe utilisateur, pas de souci, mais si c'est un type simple, erreur.

Une idée ?

Merci d'avance !

# Typage

Posté par Raphaël G. (site web personnel) le 17 novembre 2008 à 19:42. Évalué à 2.

Attention, le string dans ce cas là n'est pas un t_string, mais une classe string !!!

Je te conseille la lecture de ceci :
http://fr.php.net/string
Et le modèle objet de php5 (sur le 4 c'est une vaste blague) :
http://fr.php.net/manual/en/language.oop5.php

ps : dans la pratique en modèle objet tu ne précise le prototype que pour les classes personnelles, car pour les string et int par exemple ça ne marche pas !
- [^] # Re: Typage
  
  Posté par santos le 18 novembre 2008 à 15:42. Évalué à 2.
  
  salut Raphaël,
  
  j'ai lu les pages en question (que je connaissais déjà^^)
  
  Justement, ce que je cherche, c'est une solution pour spécifier des types simples (int, string)...
  
  ça serait quand-même dingue que ça ne soit pas possible !
  - [^] # Re: Typage
    
    Posté par Raphaël G. (site web personnel) le 18 novembre 2008 à 17:29. Évalué à 2.
    
    Justement j'avais cherché il y a un an et demi a le faire, mais j'en était justement arrivé a la conclusion que c'était impossible.
    
    La seule solution est d'ajouter du if(!is_string($arg)) new Exception(''); dans les fonctions.
    
    Regarde sinon du côté des interfaces.
    
    Il me semble que les int marchaient il me semble, mais pas les string.
    
    Une autre solution est de regarder dans le bugtracker php et de poster un bug si tu ne trouves pas.
    - [^] # Re: Typage
      
      Posté par santos le 18 novembre 2008 à 17:42. Évalué à 2.
      
      erf :s
      
      Merci pour l'info en tous cas.

# Ma solution

Posté par santos le 19 novembre 2008 à 13:56. Évalué à 2.

Bon, finalement, voilà la solution à laquelle je me suis résigné.

Si un paramètre de méthode est de type simple, je ne spécifie pas son type dans le prototype de la méthode :

public function plop($str)

Par contre en début de méthode je vérifie le type du paramètre :

Utils::checkType('string', $str);

Compatible avec n'importe quel type simple ou classe utilisateur ; déclenche une exception si le type de la variable fournie n'est pas celui attendu.

Inversement, si un paramètre de méthode est une instance de classe (système ou utilisateur), je spécifie la classe attendue dans le prototype :

public function plop(MonType $object)

Par ailleurs, je peux récupérer le type d'un paramètre :

Utils::getParameterType(ReflectionParameter $param);

Si $param est de type simple, la méthode retourne null ; sinon, elle retourne le nom de la classe correspondante.

[^] # code de Utils::checkType() et Utils::getParameterType()

Posté par santos le 19 novembre 2008 à 14:12. Évalué à 2.

Pour ceux que ça intéresse, voilà le code des mes méthodes Utils::checkType() et Utils.getParameterType().


<?php

/**
 * Provides a lot of commun functions.
 * 
 * @package Utils
 * @author François NAUTRE<f.nautre@cotep.fr>
 * @date 07/11/2008
 * @version 1.0.0
 * @since 1.0.0
 *
 */
class Utils
{
	/**
	 * Verifies if some variable is really typed as expected.
	 *
	 * @param string $type The expected type.
	 * @param Object $value The variable to be checked.
	 * @return boolean true if the specified variable is quite typed.
	 * @since 1.0.0
	 */
	public static function checkType($type, $value, $required=true)
	{
		if (!is_string($type))
		{
			die ("Utils::checkType : Required type unspecified.");
		}
		if ($required AND empty($value))
		{
			die ("Utils::checkType : Missing required parameter.");
		}
		try
		{
			switch($type)
			{
				case "string":
					if (is_string($value))
					{
						return true;
					}
					break;
				case "float":
					if (is_float($value))
					{
						return true;
					}
					break;
				case "integer":
					if (is_int($value))
					{
						return true;
					}
					break;
				case "boolean":
					if (is_bool($value))
					{
						return true;
					}
					break;
				case "array":
					if (is_array($value))
					{
						return true;
					}
					break;
				case "resource":
					if (is_resource($value))
					{
						return true;
					}
					break;
				case "object":
					if (is_object($value))
					{
						return true;
					}
					break;
				case "any":
					if (!empty($value))
					{
						return true;
					}
					break;
				default:
					if ($value instanceof $type)
					{
						return true;
					}
					break;
			}
			trigger_error("Unexpected variable type : expected ".$type." , found ".getType($value));
		}
		catch (Exception $e)
		{
			die($e);
		}
		return false;
	}

	/**
	 * Retrieves type of the specified parameter.
	 *
	 * @param ReflectionParameter $parameter The parameter to retrieve his type.
	 * @return string Name of the required class parameter if the parameter must be an object, NULL otherwise.
	 * @since 1.0.0
	 */
	public static function getParameterType(ReflectionParameter $parameter)
	{
		try
		{
			$class = $parameter->getClass();
			$type = empty($class)? null : $class->getName();
		}
		catch (Exception $e)
		{
			$type = null;
		}
		return $type;
	}

	...
	
}

?>

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.