Une chaîne numérique comme clé de tableau en PHP

Est-il possible d'utiliser une chaîne numérique comme "123"une clé dans un tableau PHP, sans qu'elle soit convertie en entier?

$blah = array('123' => 1);
var_dump($blah);

impressions

array(1) {
  [123]=>
  int(1)
}

Je voudrais

array(1) {
  ["123"]=>
  int(1)
}

Non; non ce n'est pas:

À partir du manuel :

Une clé peut être un entier ou une chaîne. Si une clé est la représentation standard d'un entier, elle sera interprétée comme telle (c'est-à-dire que "8" sera interprété comme 8, tandis que "08" sera interprété comme "08").

Addenda

À cause des commentaires ci-dessous, j'ai pensé qu'il serait amusant de souligner que le comportement est similaire mais pas identique aux clés d'objet JavaScript.

foo = { '10' : 'bar' };

foo['10']; // "bar"
foo[10]; // "bar"
foo[012]; // "bar"
foo['012']; // undefined!

Oui, c'est possible en transtypant un stdClassobjet en tableau :

$data =  new stdClass;
$data->{"12"} = 37;
$data = (array) $data;
var_dump( $data );

Cela vous donne (jusqu'à la version 7.1 de PHP):

array(1) {
  ["12"]=>
  int(37)
}

(Mise à jour: Ma réponse originale montrait une manière plus compliquée en utilisant json_decode()et json_encode()qui n'est pas nécessaire.)

Notez le commentaire : Il n'est malheureusement pas possible de référencer directement la valeur: $data['12']entraînera un avis.

Mise à jour : à
partir de PHP 7.2, il est également possible d'utiliser une chaîne numérique comme clé pour référencer la valeur:

var_dump( $data['12'] ); // int 32

Si vous avez besoin d'utiliser une clé numérique dans une structure de données php, un objet fonctionnera. Et les objets préservent l'ordre, vous pouvez donc itérer.

$obj = new stdClass();
$key = '3';
$obj->$key = 'abc';

Ma solution de contournement est:

$id = 55;
$array = array(
  " $id" => $value
);

L'espace char (prefend) est une bonne solution car gardez la conversion int:

foreach( $array as $key => $value ) {
  echo $key;
}

Vous verrez 55 comme int.

Vous pouvez taper la clé en chaîne, mais elle sera finalement convertie en un entier en raison de la saisie lâche de PHP. Voir par vous-même:

$x=array((string)123=>'abc');
var_dump($x);
$x[123]='def';
var_dump($x);

Depuis le manuel PHP:

Une clé peut être un entier ou une chaîne. Si une clé est la représentation standard d'un entier, elle sera interprétée comme telle (c'est-à-dire que "8" sera interprété comme 8, tandis que "08" sera interprété comme "08"). Les flottants dans la clé sont tronqués en nombre entier. Les types de tableaux indexés et associatifs sont du même type en PHP, qui peuvent à la fois contenir des indices entiers et chaînes.

J'ai eu ce problème en essayant de fusionner des tableaux qui avaient à la fois des clés de chaîne et des clés entières. Il était important que les entiers soient également traités comme des chaînes car il s'agissait de noms pour les champs de saisie (comme dans les pointures de chaussures, etc.)

Quand j'utilisais $data = array_merge($data, $extra);PHP, je réorganisais les clés. Dans une tentative de classement, les clés entières (j'ai essayé avec 6- '6'- "6"même en (string)"6"tant que clés) ont été renommées de 0 à n... Si vous y réfléchissez, dans la plupart des cas, ce serait le comportement souhaité.

Vous pouvez contourner ce problème en utilisant à la $data = $data + $extra;place. Assez simple, mais je n'y ai pas pensé au début ^^.

Les chaînes contenant des entiers valides seront converties en type entier. Par exemple, la clé "8" sera en fait stockée sous 8. Par contre "08" ne sera pas converti, car ce n'est pas un entier décimal valide.

FAUX

J'ai une fonction de casting qui gère le casting séquentiel à associatif,

$array_assoc = cast($arr,'array_assoc');

$array_sequential = cast($arr,'array_sequential');

$obj = cast($arr,'object');

$json = cast($arr,'json');



function cast($var, $type){

    $orig_type = gettype($var);

    if($orig_type == 'string'){

        if($type == 'object'){
            $temp = json_decode($var);
        } else if($type == 'array'){
            $temp = json_decode($var, true);
        }
        if(isset($temp) && json_last_error() == JSON_ERROR_NONE){
            return $temp;
        }
    }
    if(@settype($var, $type)){
        return $var;
    }
    switch( $orig_type ) {

        case 'array' :

            if($type == 'array_assoc'){

                $obj = new stdClass;
                foreach($var as $key => $value){
                    $obj->{$key} = $value;
                }
                return (array) $obj;

            } else if($type == 'array_sequential'){

                return array_values($var);

            } else if($type == 'json'){

                return json_encode($var);
            }
        break;
    }
    return null; // or trigger_error
}

Pour contourner ce problème, vous pouvez encoder un tableau PHP en objet json, avec l'option JSON_FORCE_OBJECT.

ie, cet exemple:

     $a = array('foo','bar','baz');
     echo "RESULT: ", json_encode($a, JSON_FORCE_OBJECT);

aura pour résultat:

     RESULT: {"0" : "foo", "1": "bar", "2" : "baz"}

J'ai rencontré ce problème sur un tableau avec à la fois «0» et «» comme clés. Cela signifiait que je ne pouvais pas vérifier mes clés de tableau avec == ou ===.

$array=array(''=>'empty', '0'=>'zero', '1'=>'one');
echo "Test 1\n";
foreach ($array as $key=>$value) {
    if ($key == '') { // Error - wrongly finds '0' as well
        echo "$value\n";
    }
}
echo "Test 2\n";
foreach ($array as $key=>$value) {
    if ($key === '0') { // Error - doesn't find '0'
        echo "$value\n";
    }
}

La solution de contournement consiste à convertir les clés du tableau en chaînes avant utilisation.

echo "Test 3\n";
foreach ($array as $key=>$value) {
    if ((string)$key == '') { // Cast back to string - fixes problem
        echo "$value\n";
    }
}
echo "Test 4\n";
foreach ($array as $key=>$value) {
    if ((string)$key === '0') { // Cast back to string - fixes problem
        echo "$value\n";
    }
}

En ce qui concerne la solution @david, veuillez noter que lorsque vous essayez d'accéder aux valeurs de chaîne dans le tableau associatif, les nombres ne fonctionneront pas. Je suppose qu'ils sont convertis en nombres entiers dans les coulisses (lors de l'accès au tableau) et qu'aucune valeur n'est trouvée. L'accès aux valeurs sous forme d'entiers ne fonctionnera pas non plus. Mais vous pouvez utiliser array_shift () pour obtenir les valeurs ou parcourir le tableau.

$data = new stdClass;
$data->{"0"} = "Zero";
$data->{"1"} = "One";
$data->{"A"} = "A";
$data->{"B"} = "B";

$data = (array)$data;

var_dump($data);
/*
Note the key "0" is correctly saved as a string:
array(3) {
  ["0"]=>
  string(4) "Zero"
  ["A"]=>
  string(1) "A"
  ["B"]=>
  string(1) "B"
}
*/

//Now let's access the associative array via the values 
//given from var_dump() above:
var_dump($data["0"]); // NULL -> Expected string(1) "0"
var_dump($data[0]); // NULL (as expected)
var_dump($data["1"]); // NULL -> Expected string(1) "1"
var_dump($data[1]); // NULL (as expected)
var_dump($data["A"]); // string(1) "A" (as expected)
var_dump($data["B"]); // string(1) "B" (as expected)

J'ai eu ce problème en essayant de trier un tableau où j'avais besoin que la clé de tri soit un hex sha1. Lorsqu'une valeur sha1 résultante n'a pas de lettres, PHP transforme la clé en un entier. Mais j'avais besoin de trier le tableau dans l'ordre relatif des chaînes. J'avais donc besoin de trouver un moyen de forcer la clé à être une chaîne sans changer l'ordre de tri.

En regardant le graphique ASCII ( https://en.wikipedia.org/wiki/ASCII ), le point d'exclamation est à peu près identique à l'espace et certainement inférieur à tous les chiffres et lettres.

J'ai donc ajouté un point d'exclamation à la fin de la chaîne de clé.

for(...) {

    $database[$sha.'!'] = array($sha,$name,$age);
}

ksort($database);
$row = reset($database);
$topsha = $row[0];