[PHP 5.3] Tableaux : conversion automatique de la clé en int [Résolu]

[rawsrc]

Bonjour,

J'essaye de construire un tableau en conservant le type initial de la clef mais le PHP me fait une conversion implicite de type quand la clef est une chaine numérique : '1' devient 1

Code :

1
2
3
4
<?php 
$a = array('test', '1' => 'num');
var_dump($a);
?>

Le tableau $a est conçu ainsi :

Code :

array(2) { [0]=> string(4) "test" [1]=> string(3) "num" }

Comme vous pouvez le voir la clé '1' est devenue 1.
J'aurais besoin de faire la différence entre '1' et 1 mais je n'ai pas encore trouvé l'astuce.

Des idées ?

[rawsrc]

Salut, euh... moi-même

Bon après moult recherches, il s'avère que cela est impossible - Doc PHP :

Une clé peut être soit un entier, soit une chaîne de caractères. Si une clé est une représentation standard d'un entier, elle sera interprétée comme telle (i.e. "8" sera interprété comme 8, alors que "08" sera interprétée comme "08"). Les nombres à virgule flottante, en tant que clé, seront tronqués en entier.

Bon je me suis dis yaka se servir soi-même. Et j'ai découvert que le yaka n'est pas des plus évidents dans ce cas.
Voici le code d'une classe offrant les possibilités suivantes :

- de différencier les clés d'un tableau ('1' != 1),
- de définir des clés exotiques du type float (123.456),
- de n'effectuer aucun transtypage implicite

J'y ai mis du code en plus à des fins de débogage.
Le principe réside dans la séparation des clés de leur valeur.
2 tableaux indexés linéairement suivent indépendamment les clés d'une part et les valeurs d'autre part.
Le but était de suivre les clés comme des valeurs d'un tableau afin de ne pas les transtyper automatiquement.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
<?php 
 
class SimpleArray implements ArrayAccess, Iterator, Countable {
 
   private $_silo    = array();
   private $_keysmap = array();
   private $_index   = -1;
 
   /**
    * ARRAYACCESS INTERFACE
    */
   function offsetExists($offset) {
      return (FALSE !== array_search($offset, $this->_keysmap, TRUE));
   }
 
   function offsetGet($offset) {
      $index = array_search($offset, $this->_keysmap, TRUE);
      if (FALSE !== $key) {
         return $this->_silo[$index];
      }
   }
 
   function offsetSet($offset, $value) {
      $this->_silo[++$this->_index] = $value;
      if (NULL === $offset) {
         $offset = $this->_index;
      }
      $this->_keysmap[$this->_index] = $offset;
   }
 
   function offsetUnset($offset) {
      $index = array_search($offset, $this->_keysmap, TRUE);
      if (FALSE !== $key) {
         unset($this->_silo[$index]);
         unset($this->_keysmap[$index]);
      }
   }
 
   /**
    * ITERATOR INTERFACE
    */
   function current() {
      $key = key($this->_keysmap);
      $val = $this->_silo[$key];
      return $val;
      # return $this->_silo[key($this->_keysmap)];
   }
 
   function key() {
      $val = current($this->_keysmap);
      return $val;
      #return current($this->_keysmap);
   }
 
   function next() {
      $next = next($this->_keysmap);
      $key = key($this->_keysmap);
      $val = $this->_silo[$key];
      return $val;
      # next($this->_keysmap);
      # return $this->_silo[key($this->_keysmap)];
   }
 
   function rewind() {
      reset($this->_keysmap);
   }
 
   function valid() {
      $val = $this->key();
      return FALSE !== $val;
      #return (FALSE !== $this->key());
   }
 
   /**
    * COUNTABLE INTERFACE
    */
   function count() {
      return count($this->_keysmap);
   }
}
 
?>

Et voici le code de test :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
 
$a = new SimpleArray();
$a['123.456'] = 'string';
$a[123.456] = 'float';
$a[] = 'null';
 
# ici on appelle une clé exotique qui aurait dû 
# être transtypée en integer dans un tableau classique
$d = $a[123.456]; # $d = 'float' => OK
$e = $a['123.456']; # $e = 'string' => OK
 
foreach($a as $k => $v) {
   echo $k, ' : ', $v, '<br />';
}
 
?>

Le problème réside dans le foreach.
La 1ère itération donne le résultat escompté : '123.456' : 'string'
La 2ème itération ne donne pas le résultat escompté : 123 : 'float'
Le foreach semble malgré tout convertir la clé en integer à la lecture quelque soit la valeur renvoyée par la fonction key() de SimpleArray.

A moins d'une boulette de ma part, je ne vois comment il serait possible de contourner cette limitation.

Aux pros de PHP, des idées ?

[rawsrc]

Allez je clôture ce post en disant qu'il me semble que le parcours avec un foreach reste impossible à cause de ce foutu transtypage des clés.

Par contre, il est tout à fait possible de parcourir le SimpleArray avec ceci :

Code :

1
2
3
4
5
6
7
<?php
$a->rewind();
while($a->valid()) {
   echo $a->key(), ' : ', $a->current(), '<br />';
   $a->next();
}
?>

On récupère bien les clés exotiques avec leur valeur.
Et hop, le tour est joué.

Allez je met tout ça au propre et rendez-vous dans le forum Contribuez()

[lucas74]

Petite question... Pourquoi as-tu besoin de cela ?