Uma string numérica como chave de array em PHP

É possível usar uma string numérica "123"como uma chave em um array PHP, sem ser convertido para um inteiro?

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

estampas

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

eu quero

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

Não; não, não é:

Do manual :

Uma chave pode ser um número inteiro ou uma string. Se uma chave for a representação padrão de um número inteiro, ela será interpretada como tal (ou seja, "8" será interpretado como 8, enquanto "08" será interpretado como "08").

Termo aditivo

Por causa dos comentários abaixo, achei que seria divertido apontar que o comportamento é semelhante, mas não idêntico, às chaves de objeto JavaScript.

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

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

Sim, é possível lançando um array de um stdClassobjeto:

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

Isso dá a você (até a versão 7.1 do PHP):

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

(Atualização: minha resposta original mostrou uma maneira mais complicada de usar json_decode()e json_encode()que não é necessária.)

Observe o comentário : Infelizmente não é possível referenciar o valor diretamente: $data['12']resultará em um aviso.

Atualização :
A partir do PHP 7.2 também é possível usar uma string numérica como chave para referenciar o valor:

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

Se você precisar usar uma chave numérica em uma estrutura de dados php, um objeto funcionará. E os objetos preservam a ordem, para que você possa iterar.

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

Minha solução alternativa é:

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

O caractere de espaço (prefixar) é uma boa solução porque mantém a conversão int:

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

Você verá 55 como int.

Você pode converter a chave em uma string, mas ela será eventualmente convertida em um inteiro devido à digitação livre do PHP. Veja por si mesmo:

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

Do manual do PHP:

Uma chave pode ser um número inteiro ou uma string. Se uma chave for a representação padrão de um número inteiro, ela será interpretada como tal (ou seja, "8" será interpretado como 8, enquanto "08" será interpretado como "08"). Os flutuadores na chave são truncados para um número inteiro. Os tipos de array indexado e associativo são do mesmo tipo em PHP, que podem conter índices inteiros e strings.

Eu tive esse problema ao tentar mesclar matrizes que tinham chaves de string e inteiras. Era importante que os inteiros também fossem tratados como string, uma vez que eram nomes para campos de entrada (como em tamanhos de sapato etc.)

Quando eu usava o $data = array_merge($data, $extra);PHP, eu 'reordenava' as chaves. Em uma tentativa de ordenar, as chaves inteiras (eu tentei com 6- '6'- "6"mesmo (string)"6"como chaves) foram renomeadas de 0 para n... Se você pensar bem, na maioria dos casos esse seria o comportamento desejado.

Você pode contornar isso usando $data = $data + $extra;. Bem direto, mas não pensei nisso no começo ^^.

Strings contendo inteiros válidos serão convertidos para o tipo inteiro. Por exemplo, a chave "8" será armazenada em 8. Por outro lado, "08" não será convertido, pois não é um inteiro decimal válido.

ERRADO

Eu tenho uma função de casting que lida com o casting de array sequencial para associativo,

$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
}

Como solução alternativa, você pode codificar a matriz PHP em um objeto json, com a opção JSON_FORCE_OBJECT.

ou seja, este exemplo:

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

vai resultar em:

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

Corri para este problema em uma matriz com '0' e '' como chaves. Isso significava que eu não poderia verificar minhas chaves de array com == 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";
    }
}

A solução alternativa é converter as chaves da matriz de volta nas strings antes de usar.

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";
    }
}

Com relação à solução @david, observe que quando você tenta acessar os valores da string na matriz associativa, os números não funcionam. Meu palpite é que eles são lançados em números inteiros nos bastidores (ao acessar a matriz) e nenhum valor é encontrado. Acessar os valores como inteiros também não funcionará. Mas você pode usar array_shift () para obter os valores ou iterar o array.

$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)

Tive esse problema ao tentar classificar uma matriz em que precisava que a chave de classificação fosse um hex sha1. Quando um valor sha1 resultante não tem letras, o PHP transforma a chave em um inteiro. Mas eu precisava classificar a matriz na ordem relativa das strings. Então, eu precisava encontrar uma maneira de forçar a chave a ser uma string sem alterar a ordem de classificação.

Olhando para o gráfico ASCII ( https://en.wikipedia.org/wiki/ASCII ), o ponto de exclamação é classificado quase da mesma forma que o espaço e certamente menor do que todos os números e letras.

Então, acrescentei um ponto de exclamação no final da string chave.

for(...) {

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

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