Commentaires

1. Le mercredi 17 décembre 2008 à 16:05, par fch // Fred Hardy

1. function is_array_of($type, $mixed, $recursive = false) {
2.   if (is_array ( $mixed ) === false)
3.     return false;
4.   else {
5.     foreach ( $mixed as $value ) {
6.       if (is_array ( $value ) === false) {
7.         if (gettype ( $value ) !== $type)
8.           return false;
9.       } else if ($recursive === false)
10.         return false;
11.       else if (is_array_of ( $type, $value, $recursive ) === false)
12.         return false;
13.     }
14.    
15.     return true;
16.   }
17. }

2. Le mercredi 17 décembre 2008 à 17:05, par Moosh

On avance, doit-on ajouter un passage par référence?

A propos de passage :... filter_input_array

3. Le mercredi 17 décembre 2008 à 17:51, par fch // Fred Hardy

Le passage par référence n'a pas d'intérêt puisque la fonction ne modifie pas le contenu du tableau.

4. Le mercredi 17 décembre 2008 à 23:28, par Moosh

ca oui, c'est plus pour la vitesse que je pensais ca mais ca ne change rien.

5. Le jeudi 18 décembre 2008 à 00:15, par Hugues

Le passage par référence n’augmentera pas la vitesse, car le moteur PHP fait bien les choses. Lors l’assignation de la valeur d’une variable à une autre variable, le moteur PHP pointe toujours sur la valeur de la première variable TANT QUE LA SECONDE VARIABLE NE FAIT PAS L’OBJET D’UNE MODIFICATION. C’est seulement, au moment d’une tentative de modification de la seconde variable qu’un vrai passage par copie se fera.

Concernant l’amélioration de la fonction, dans un contexte objet, il pourrait être intéressant d’ajouter la possibilité de vérifier le type de classe quand il s’agit d’objet. Par exemple en l’appelant cette manière :

is_array_of(array('object', 'MyClass') , $array);

Le code pourrait être complété de la façon suivante :

1.  
2. function is_array_of($type, $mixed, $recursive = false) {
3.   if (is_array ( $mixed ) === false) {
4.     return false;
5.   } else {
6.     foreach ( $mixed as $value ) {
7.      
8.       if (is_array ( $value ) === false) {
9.         if (is_array ( $type ) && $type [0] = 'object' && isset ( $type [1] )) {
10.           if ($value instanceof $type [1] === false) {
11.             return false;
12.           }
13.         } elseif (gettype ( $value ) !== $type) {
14.           return false;
15.         }
16.       } else if ($recursive === false)
17.         return false;
18.       else if (is_array_of ( $type, $value, $recursive ) === false)
19.         return false;
20.     }
21.    
22.     return true;
23.   }
24. }

Mais personnellement, je trouve que la fonction devient un peu fouillis là, et j’opterais pour un découpage en deux fonctions :
function check_type($value, $type, $class = null) qui serait appelée dans
function check_array_type($array, $type, $recursive);

6. Le jeudi 18 décembre 2008 à 07:17, par Moosh

Vieux réflexes de codeur pascal; ...

Il faut dire que j'ai fait ce post sur un coup de tête sans trop réfléchir à la question.

Je ne vais pas éditer mon post, mais bien laisser en évidence ces commentaires, riches comme un refactoring. Je vais juste ajouter la coloration

7. Le vendredi 19 décembre 2008 à 10:33, par ZeFredz

Chouette fonction très pratique, mais en y repensant ce matin, je me suis rendu compte qu'il a un problème si on choisit comme type 'array'.

La fonction va renvoyer false au lieu de true pour un array d'array en mode non récursif. En effet, comme is_array est prioritaire sur gettype dans le code de la fonction, c'est $recursive === false qui est évalué et is_array_of va toujours renvoyer false :

$ar = array(array(), array(), array());
var_dump( is_array_of('array', $ar) ); // --> bool(false)

Il faudrait donc sans doute faire un cas particulier pour le type 'array'.

Par contre, le mode récursif renvoie true :

$ar = array(array(array()), array(), array());
var_dump( is_array_of('array', $ar, true) ); // --> bool(true)

Mais il renvoie false si les array fils ne sont pas vide :

$ar = array(array(1,2,3), array(), array());
var_dump( is_array_of('array', $ar, true) ); // --> false

Cela signifie que le mode récursif ne peut tester qu'un tableau de tableaux de tableaux... tous vides et on pourrait donc se demander s'il a vraiment du sens avec le type 'array'.

On pourrait aussi envisager tout bonnement de se débarrasser du type 'array'... Voilà, j'espère que ça permettra d'améliorer cette fonction et surtout d'éviter des bugs dans les applis qui vont l'utiliser.

8. Le samedi 20 décembre 2008 à 00:12, par Moosh

oui je vois, en fait j'étais dans l'optique, les arrays sont des noeuds, je veux évaluer les feuilles

9. Le samedi 20 décembre 2008 à 02:32, par Hugues

Si, en théorie, le test du type ‘array’ et l’invocation simultanée du mode récursif peut sembler un peu ‘borderline’, en pratique, l’usage d’array imbriqués est très fréquent en PHP.

On peut sans doute résoudre le problème en transformant le paramètre de récursivité d’un simple flag booléen à un nombre qui définirait les niveaux de récursivité attendus.

La fonction devrait alors être adapté de la façon suivante :

1. function is_array_of($type, $mixed, $recursive = 0) {
2.  
3.   if (is_array ( $mixed ) === false) {
4.     return false;
5.   } else {
6.    
7.     foreach ( $mixed as $value ) {
8.      
9.       if ($recursive > 0) {
10.         if (is_array_of ( $type, $value, $recursive - 1 ) === false) {
11.           return false;
12.         }
13.       } else {
14.         if (is_array ( $type ) && $type [0] = 'object' && isset ( $type [1] )) {
15.           if ($value instanceof $type [1] === false) {
16.             return false;
17.           }
18.         } elseif (gettype ( $value ) !== $type) {
19.           return false;
20.         }
21.       }
22.     }
23.   }
24.  
25.   return true;
26. }
27.  

Ajouter un commentaire

Nom ou pseudo :

Email (facultatif) :

Site Web (facultatif) :

Commentaire :

Le code HTML sera affiché comme du texte.

Se souvenir de mes informations