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.
|