SommaireTelecharger la documentationChapitre suivantChapitre precedent  

  .: News :.: Edito :.: Scripts :.: Forum :.: Erreurs :.: Jobs :. 
 
Sommaire

Gestion des arguments

Compter le nombre d'arguments
Lecture des arguments
L'ancienne technique de lecture des arguments (obsolète)
Cas des nombres variables de paramètres et des arguments optionnels
Accéder aux arguments
Cas des arguments passés par référence
Assurer la protection en écriture des autres paramètres

7.10.5 Accéder aux arguments

Pour accéder aux arguments, il est nécessaire à chaque argument d'avoir un type clairement défini. Encore une fois, étant donné la nature très dynamique de PHP, il existe des petits couacs. Comme PHP ne fait jamais de vérifications de type, il est possible à l'utilisateur d'appeler une fonction avec n'importe quel type de données, que vous le souhaitiez ou pas. Même si vous attendez un entier, l'utilisateur peut vous fournir un tableau, et vice versa. PHP ne fera pas la différence.

Pour contourner ce problème, vous devez utiliser une API pour forcer les conversions de chaque argument qui est passé (voir aussi <>).

Note:  Toutes les fonctions de conversions prennent un **zval comme paramètre.

Fonctions de conversion d'arguments

> >
Fonction Description
convert_to_boolean_ex Convertit en type booléen type. Les valeurs booléennes sont inchangées. Les valeurs de type long, double, et les chaînes de caractères contenant 0 ou la valeur NULL sont transformées en booléen 0 (FALSE). Les tableaux et objets sont convertis en booléens en fonction du nombre d'entrées ou de propriétés dont il disposent : Les tableaux et les objets vides sont convertis en booléen 0 (FALSE). Tous les autres sont converties en booléen 1 (TRUE).
convert_to_long_ex Convertit en long, le type entier par défaut. Les valeurs NULL, les booléens, les ressources, et bien sur les longs sont inchangés. Les doubles sont tronqués. Les chaînes contenant des entiers sont transformés en leur équvalent numérique. Sinon, le résultat est 0. Les tableaux et les objets sont convertis en 0 si ils sont vides, et sinon en 1.
convert_to_double_ex Convertit en double, le type de nombre à virgule flottante par défaut. Les valeurs NULL, les bool.ens, les ressources, les longs, et bien sur les doubles sont inchangés. Les chaînes contenant un nombre sont converties en leur équivalent numérique, sinon, elle sont converties en 0.0. Les tableaux et les objets sont convertis en 0.0 si ils sont vides, et sinon en 1.0.
convert_to_string_ex Convertit en chaîne. Les chaînes sont inchangées. La valeur NULL est convertie en une chaîne vide. Les booléens contenant TRUE sont convertis en "1", et sinon, en chaîne vide. Les longs et les doubles sont convertis dans leur représentation correspondantes. Les tableaux sont transformés en chaîne "Array" et les objets, en "Object".
convert_to_array_ex(value) Converti en tableau. Les tableaux sont inchangés. Les objets sont convertis en tableaux, en assignant leur propriétés comme index de tableau. La valeur NULL est converties en tableau vide. Toutes les autres valeurs sont transformées en un tableau à un élément, avec l'index 0.
convert_to_object_ex(value) Convertit en objet. Les objets sont inchangés. Les valeurs NULL sont converties en un objet vide. Les tableaux sont convertis en utilisant leurs clé d'index comme membre de l'objet, et la valeur correspondante comme valeur du membre de l'objet. Toues les autres types sont transformés en un objet, ayant le membre scalar, et leur valeur respective comme valeur de ce membre.
convert_to_null_ex(value) COnverti en valeur NULL, c'est à dire vide.
Note

Vous pouvez trouver une illustration de ces comportements dans le fichier cross_conversion.php dans le CD associé. <> shows the output.

Conversions de type en PHP.

Utiliser ces fonctoins sur vos arguments vous assurera que le type demandé est le bon pour chacun d'entre eux. Si le type fourni n'est pas le bon, PHP force les mauvais types à des valeurs par défaut (chaînes vides, tableaux ou objets vdes, 0 pour les valeurs numériques, FALSE pour les booléens). Cela garantit un état bien connu.

Voici un exemple, issue du module présenté auparavant, qui utilise ces fonctions de conversion.


zval **parameter;
if((ZEND_NUM_ARGS() != 1) || (zend_get_parameters_ex(1, ¶meter) != SUCCESS))
{
    WRONG_PARAM_COUNT;
}
convert_to_long_ex(parameter);
RETURN_LONG(Z_LVAL_P(parameter));
Après avoir lu le pointeur de paramètre, la valeur du paramètre est convertie en long (un entier), qui représente la valeur de retour de la fonction. Comprendre l'accès aux valeurs demande une petite discussion sur le type zval, dont la définition est illustrée <>.

Définition du type zval de PHP/Zend.

typedef pval zval;
     
typedef struct _zval_struct zval;
typedef union _zvalue_value {
    long lval;                    /* long value */
    double dval;                /* double value */
    struct {
        char *val;
        int len;
    } str;
    HashTable *ht;                /* hash table value */
    struct {
        zend_class_entry *ce;
        HashTable *properties;
    } obj;
} zvalue_value;
struct _zval_struct {
    /* Variable information */
    zvalue_value value;        /* value */
    unsigned char type;    /* active type */
    unsigned char is_ref;
    short refcount;
};

En réalité, pval (défini dans php.h ) est simplement un alias de zval (défini dans zend.h ), qui, à son tour, pointe sur _zval_struct. C'est la structure la plus interessante. _zval_struct est la structure "maître", contenant la valeur, le type, et les informations de référence. La sous structure zvalue_value est une union, qui contient la valeur de la variable. Suivant le type de la variable, vous aurez à accéder aux différents membres de cette union. Pour une description des deux structures, voyez <>, <> et <>.

Structure zval

> >
Entrée Description
value Union contenant la valeur de cette variable. Voyez <> pour une description.
type Contient le type de la variable. Pour une liste des types disponibles, voyez <>.
is_ref 0 signifie que cette variable n'est pas une référence; 1 signifie que cette variable est une référence à une autre variable;
refcount Ceci est le nombre de références qui existe pour cette variable. Pour chaque nouvelle référence vers la valeur de cette variable, ce compteur est incrémenté de 1. Pour chaque référence perdue, le compteur est décrémenté de 1. Lorsque le compteur de référence atteint 0, il n'y a plus de référence, et la valeur est alors automatiquement détruite.
Structure de zvalue_value

> >
Entrée Description
lval Utilisez cette propriété si la variable est de type IS_LONG, IS_BOOLEAN, ou IS_RESOURCE.
dval Utilisez cette propriété si la variable est de type IS_DOUBLE.
str Cette structure peut être utilisée pour accéder aux variables de type IS_STRING. Le membre len contient la taille de la chaîne; le membre val pointe sur la chaîne elle-même. Zend utilise des chaînes C; C'est à dire que la chaîne est toujours terminées par 0x00.
ht Cette entrée pointe sur l'entrée de la variable dans la table de hashage, si cette variable est un tableau.
obj Utilisez cette propriété si la variable est de type IS_OBJECT.
Constantes de Type de variable de Zend

> >
Constante Description
IS_NULL Représente la valeur NULL (vide).
IS_LONG Représente un long (entier).
IS_DOUBLE Représente un double (nombre à virgule flottante).
IS_STRING Représente une chaîne de caractère.
IS_ARRAY Représente un tableau.
IS_OBJECT Représente un objet.
IS_BOOL Représente un booléen.
IS_RESOURCE Représente une ressource (pour plus de détails sur les ressources, voyez la section appropriées ci-dessous).
IS_CONSTANT Représente une constante (définie).

Pour accéder à la valeur d'un long, il sufft d'accéder à zval.value.lval, Pour accéder à la valeur d'un double, il sufft d'accéder à zval.value.dval, et ansi de suite... Comme toutes les valeurs sont stockées dans un type union, accéder à une valeur qui ne correspond pas au type courant retournera une valeur sans aucun sens.

Accéder aux tableaux et objets est un peu plus compliqué, et nous étudierons cela plus tard.


Chapitre précédentChapitre suivantAccueil nexen.net