php : Recherche des clés de tableau sans tenir compte de la casse ?

Question

$myArray = array ('SOmeKeyNAme' => 7);  

Je veux $myArray['somekeyname'] pour revenir 7 .
Existe-t-il un moyen de le faire, sans manipuler le tableau ?

Je ne crée pas le tableau, et donc je ne peux pas contrôler ses clés.

Answer 1

Option 1 - modifier la façon dont vous créez le tableau

Vous ne pouvez pas le faire sans effectuer une recherche linéaire ou modifier le tableau d'origine. L'approche la plus efficace sera d'utiliser strtolower sur les clés lorsque vous insérez ET lorsque vous consultez les valeurs.

 $myArray[strtolower('SOmeKeyNAme')]=7;

 if (isset($myArray[strtolower('SomekeyName')]))
 {

 }

S'il est important pour vous de préserver le cas original de la clé, vous pouvez le stocker comme une valeur supplémentaire pour cette clé, par exemple

$myArray[strtolower('SOmeKeyNAme')]=array('SOmeKeyNAme', 7);

Option 2 - créer une cartographie secondaire

Comme vous avez mis à jour la question pour suggérer que cela ne serait pas possible pour vous, que diriez-vous de créer un tableau fournissant une correspondance entre les versions minuscules et les versions sensibles à la casse ?

$keys=array_keys($myArray);
$map=array();
foreach($keys as $key)
{
     $map[strtolower($key)]=$key;
}

Maintenant vous pouvez utiliser ceci pour obtenir la clé sensible à la casse à partir d'une clé minuscule

$test='somekeyname';
if (isset($map[$test]))
{
     $value=$myArray[$map[$test]];
}

Cela évite de devoir créer une copie complète du tableau avec une clé en minuscules, ce qui est vraiment la seule autre façon de procéder.

Option 3 - Créer une copie du tableau

Si faire une copie complète du tableau n'est pas un problème, alors vous pouvez utiliser tableau_changement_de_key_case pour créer une copie avec des touches en minuscules.

$myCopy=array_change_key_case($myArray, CASE_LOWER);

Answer 2

Je sais qu'il s'agit d'une question ancienne, mais la manière la plus élégante de traiter ce problème est d'utiliser :

array_change_key_case($myArray); //second parameter is CASE_LOWER by default

Dans votre exemple :

$myArray = array ('SOmeKeyNAme' => 7);
$myArray = array_change_key_case($myArray);

Ensuite, $myArray contiendra toutes les clés en minuscules :

echo $myArray['somekeyname'] will contain 7

Vous pouvez également utiliser :

array_change_key_case($myArray, CASE_UPPER);

La documentation peut être vue ici : http://us3.php.net/manual/en/function.array-change-key-case.php

Answer 3

Vous pourriez utiliser ArrayAccess pour créer une classe qui fonctionne avec la syntaxe des tableaux.

Exemple

$lower_array_object = new CaseInsensitiveArray;
$lower_array_object["thisISaKEY"] = "value";
print $lower_array_object["THISisAkey"]; //prints "value"

ou

$lower_array_object = new CaseInsensitiveArray(
    array( "SoMeThInG" => "anything", ... )
);
print $lower_array_object["something"]; //prints "anything"

Classe

class CaseInsensitiveArray implements ArrayAccess
{
    private $_container = array();

    public function __construct( Array $initial_array = array() ) {
        $this->_container = array_map( "strtolower", $initial_array );
    }

    public function offsetSet($offset, $value) {
        if( is_string( $offset ) ) $offset = strtolower($offset);
        if (is_null($offset)) {
            $this->container[] = $value;
        } else {
            $this->container[$offset] = $value;
        }
    }

    public function offsetExists($offset) {
        if( is_string( $offset ) ) $offset = strtolower($offset);
        return isset($this->_container[$offset]);
    }

    public function offsetUnset($offset) {
        if( is_string( $offset ) ) $offset = strtolower($offset);
        unset($this->container[$offset]);
    }

    public function offsetGet($offset) {
        if( is_string( $offset ) ) $offset = strtolower($offset);
        return isset($this->container[$offset])
            ? $this->container[$offset]
            : null;
    }
}

Answer 4

Un moyen simple, mais peut-être coûteux, est de faire une copie, puis d'utiliser array_change_key_case($array_copy, CASE_LOWER) et après cet accès array_copy['somekeyname']

Answer 5

J'ai combiné l'idée de Paul Dixon de créer un mappage pour les touches et l'idée de Kendall Hopkins d'utiliser l'outil de gestion de l'identité de l'utilisateur. Accès aux tableaux pour conserver la manière familière d'accéder à un tableau PHP.

Le résultat est une classe qui évite de copier le tableau initial et permet un accès transparent insensible à la casse, tout en préservant en interne la casse des clés. Limitation : Si des clés insensibles à la casse (par exemple, 'Foo' et 'foo') sont contenues dans le tableau initial ou sont ajoutées dynamiquement, les dernières entrées écraseront les précédentes (ce qui les rendra inaccessibles).

Certes, dans de nombreux cas, il est (imo) beaucoup plus simple de simplement mettre les touches en minuscules par $lowercasedKeys = array_change_key_case($array, CASE_LOWER); comme le suggère Mikpa.

La classe CaseInsensitiveKeysArray

class CaseInsensitiveKeysArray implements ArrayAccess 
{
    private $container = array();
    private $keysMap   = array();

    public function __construct(Array $initial_array = array()) 
    {
        $this->container = $initial_array;

        $keys = array_keys($this->container);
        foreach ($keys as $key) 
        {
            $this->addMappedKey($key);
        }
    }

    public function offsetSet($offset, $value) 
    {
        if (is_null($offset)) 
        {
            $this->container[] = $value;
        }
        else 
        {
            $this->container[$offset] = $value;
            $this->addMappedKey($offset);
        }
    }

    public function offsetExists($offset) 
    {
        if (is_string($offset)) 
        {
            return isset($this->keysMap[strtolower($offset)]);
        }
        else 
        {
            return isset($this->container[$offset]);
        }
    }

    public function offsetUnset($offset) 
    {
        if ($this->offsetExists($offset)) 
        {
            unset($this->container[$this->getMappedKey($offset)]);
            if (is_string($offset)) 
            {
                unset($this->keysMap[strtolower($offset)]);
            }
        }
    }

    public function offsetGet($offset) 
    {
        return $this->offsetExists($offset) ? 
               $this->container[$this->getMappedKey($offset)] : 
               null;
    }

    public function getInternalArray() 
    {
        return $this->container;
    }

    private function addMappedKey($key) 
    {
        if (is_string($key)) 
        {
            $this->keysMap[strtolower($key)] = $key;
        }
    }

    private function getMappedKey($key) 
    {
        if (is_string($key)) 
        {
            return $this->keysMap[strtolower($key)];
        }
        else 
        {
            return $key;
        }
    }
}