Comment vérifier si le tableau PHP est associatif ou séquentiel?

PHP traite tous les tableaux comme associatifs, il n'y a donc aucune fonction intégrée. Quelqu'un peut-il recommander un moyen assez efficace de vérifier si un tableau ne contient que des clés numériques?

Fondamentalement, je veux pouvoir faire la différence entre ceci:

$sequentialArray = array('apple', 'orange', 'tomato', 'carrot');

et ça:

$assocArray = array('fruit1' => 'apple', 
                    'fruit2' => 'orange', 
                    'veg1' => 'tomato', 
                    'veg2' => 'carrot');

Vous avez posé deux questions qui ne sont pas tout à fait équivalentes:

• Premièrement, comment déterminer si un tableau n'a que des touches numériques
• Deuxièmement, comment déterminer si un tableau a des touches numériques séquentielles , à partir de 0

Considérez lequel de ces comportements vous avez réellement besoin. (Il se peut que l'un ou l'autre fasse l'affaire pour vous.)

La première question (vérifier simplement que toutes les touches sont numériques) est bien répondu par le capitaine kurO .

Pour la deuxième question (vérifier si le tableau est indexé zéro et séquentiel), vous pouvez utiliser la fonction suivante:

function isAssoc(array $arr)
{
    if (array() === $arr) return false;
    return array_keys($arr) !== range(0, count($arr) - 1);
}

var_dump(isAssoc(['a', 'b', 'c'])); // false
var_dump(isAssoc(["0" => 'a', "1" => 'b', "2" => 'c'])); // false
var_dump(isAssoc(["1" => 'a', "0" => 'b', "2" => 'c'])); // true
var_dump(isAssoc(["a" => 'a', "b" => 'b', "c" => 'c'])); // true

Pour vérifier simplement si le tableau a des clés non entières (pas si le tableau est indexé séquentiellement ou zéro):

function has_string_keys(array $array) {
  return count(array_filter(array_keys($array), 'is_string')) > 0;
}

S'il y a au moins une clé de chaîne, $arraysera considérée comme un tableau associatif.

C'est sûrement une meilleure alternative.

<?php
$arr = array(1,2,3,4);
$isIndexed = array_values($arr) === $arr;

De nombreux commentateurs dans cette question ne comprennent pas comment fonctionnent les tableaux en PHP. Dans la documentation de la baie :

Une clé peut être soit un entier soit 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 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 des chaînes.

En d'autres termes, il n'existe pas de clé de tableau de "8" car elle sera toujours (silencieusement) convertie en entier 8. Il n'est donc pas nécessaire d'essayer de différencier les entiers des chaînes numériques.

Si vous voulez le moyen le plus efficace de vérifier un tableau pour les clés non entières sans faire une copie d'une partie du tableau (comme le fait array_keys ()) ou de tout (comme foreach le fait):

function keyedNext( &$arr, &$k){
    $k = key($arr);
    return next($arr);
}

for ($k = key(reset($my_array)); is_int($k); keyedNext($my_array,$k))
    $onlyIntKeys = is_null($k);

Cela fonctionne car key () renvoie NULL lorsque la position actuelle du tableau n'est pas valide et NULL ne peut jamais être une clé valide (si vous essayez d'utiliser NULL comme clé de tableau, elle est silencieusement convertie en "").

Comme indiqué par le PO :

PHP traite tous les tableaux comme associatifs

il n'est pas tout à fait sensé (à mon humble avis) d'écrire une fonction qui vérifie si un tableau est associatif . Donc, première chose: qu'est-ce qu'une clé dans un tableau PHP ?:

La clé peut être soit un entier soit une chaîne .

Cela signifie qu'il y a 3 cas possibles:

• Cas 1. toutes les clés sont numériques / entières .
• Cas 2. toutes les clés sont des chaînes .
• Cas 3. certaines clés sont des chaînes , certaines clés sont numériques / entières .

Nous pouvons vérifier chaque cas avec les fonctions suivantes.

Cas 1: toutes les clés sont numériques / entières .

Remarque : Cette fonction renvoie également true pour les tableaux vides.

//! Check whether the input is an array whose keys are all integers.
/*!
    \param[in] $InputArray          (array) Input array.
    \return                         (bool) \b true iff the input is an array whose keys are all integers.
*/
function IsArrayAllKeyInt($InputArray)
{
    if(!is_array($InputArray))
    {
        return false;
    }

    if(count($InputArray) <= 0)
    {
        return true;
    }

    return array_unique(array_map("is_int", array_keys($InputArray))) === array(true);
}

Cas 2: toutes les clés sont des chaînes .

Remarque : Cette fonction renvoie également true pour les tableaux vides.

//! Check whether the input is an array whose keys are all strings.
/*!
    \param[in] $InputArray          (array) Input array.
    \return                         (bool) \b true iff the input is an array whose keys are all strings.
*/
function IsArrayAllKeyString($InputArray)
{
    if(!is_array($InputArray))
    {
        return false;
    }

    if(count($InputArray) <= 0)
    {
        return true;
    }

    return array_unique(array_map("is_string", array_keys($InputArray))) === array(true);
}

Cas 3. certaines clés sont des chaînes , certaines clés sont numériques / entières .

Remarque : Cette fonction renvoie également true pour les tableaux vides.

//! Check whether the input is an array with at least one key being an integer and at least one key being a string.
/*!
    \param[in] $InputArray          (array) Input array.
    \return                         (bool) \b true iff the input is an array with at least one key being an integer and at least one key being a string.
*/
function IsArraySomeKeyIntAndSomeKeyString($InputArray)
{
    if(!is_array($InputArray))
    {
        return false;
    }

    if(count($InputArray) <= 0)
    {
        return true;
    }

    return count(array_unique(array_map("is_string", array_keys($InputArray)))) >= 2;
}

Il s'ensuit que:

• Si la valeur n'est pas un tableau , les 3 fonctions renvoient false .
• Si la valeur est un tableau vide , les 3 fonctions renvoient true
  (ce qui est par définition, comme dans " l'ensemble vide est un sous-ensemble de tout ensemble A car tous ses éléments appartiennent à A ").
• Si la valeur est un tableau non vide , exactement 1 fonction renvoie true .

Maintenant, pour qu'un tableau soit un tableau "authentique" auquel nous sommes tous habitués, ce qui signifie:

• Ses clés sont toutes numériques / entières .
• Ses clés sont séquentielles (c'est-à-dire augmentant à l'étape 1).
• Ses clés partent de zéro .

Nous pouvons vérifier avec la fonction suivante.

Cas 3a. les clés sont numériques / entières , séquentielles et basées sur zéro .

Remarque : Cette fonction renvoie également true pour les tableaux vides.

//! Check whether the input is an array whose keys are numeric, sequential, and zero-based.
/*!
    \param[in] $InputArray          (array) Input array.
    \return                         (bool) \b true iff the input is an array whose keys are numeric, sequential, and zero-based.
*/
function IsArrayKeyNumericSequentialZeroBased($InputArray)
{
    if(!is_array($InputArray))
    {
        return false;
    }

    if(count($InputArray) <= 0)
    {
        return true;
    }

    return array_keys($InputArray) === range(0, count($InputArray) - 1);
}

Avertissements / pièges (ou, encore plus de faits particuliers sur les clés de tableau en PHP)

Touches entières

Les clés de ces tableaux sont des entiers :

array(0 => "b");
array(13 => "b");
array(-13 => "b");          // Negative integers are also integers.
array(0x1A => "b");         // Hexadecimal notation.

Touches de chaîne

Les clés de ces tableaux sont des chaînes :

array("fish and chips" => "b");
array("" => "b");                                   // An empty string is also a string.
array("stackoverflow_email@example.com" => "b");    // Strings may contain non-alphanumeric characters.
array("stack\t\"over\"\r\nflow's cool" => "b");     // Strings may contain special characters.
array('$tα€k↔øv∈rflöw⛄' => "b");                    // Strings may contain all kinds of symbols.
array("functіon" => "b");                           // You think this looks fine? Think again! (see https://stackoverflow.com/q/9246051/1402846)
array("ま말轉转ДŁ" => "b");                         // How about Japanese/Korean/Chinese/Russian/Polish?
array("fi\x0sh" => "b");                            // Strings may contain null characters.
array(file_get_contents("https://www.google.com/images/nav_logo114.png") => "b");   // Strings may even be binary!

Touches entières qui ressemblent à des chaînes

Si vous pensez que la clé array("13" => "b")est une chaîne , vous vous trompez . Du doc ici :

Les chaînes contenant des entiers valides seront converties en type entier. Par exemple, la clé "8" sera stockée sous 8. En revanche, "08" ne sera pas converti, car il ne s'agit pas d'un entier décimal valide.

Par exemple, la clé de ces tableaux sont des entiers :

array("13" => "b");
array("-13" => "b");                        // Negative, ok.

Mais la clé de ces tableaux sont des chaînes :

array("13." => "b");
array("+13" => "b");                        // Positive, not ok.
array("-013" => "b");
array("0x1A" => "b");                       // Not converted to integers even though it's a valid hexadecimal number.
array("013" => "b");                        // Not converted to integers even though it's a valid octal number.
array("18446744073709551616" => "b");       // Not converted to integers as it can't fit into a 64-bit integer.

De plus, selon le doc ,

La taille d'un entier dépend de la plate-forme, bien qu'une valeur maximale d'environ deux milliards soit la valeur habituelle (c'est-à-dire 32 bits signés). Les plates-formes 64 bits ont généralement une valeur maximale d'environ 9E18, à l'exception de Windows, qui est toujours de 32 bits. PHP ne prend pas en charge les entiers non signés.

La clé de ce tableau peut donc être ou non un entier - cela dépend de votre plate-forme.

array("60000000000" => "b");                // Array key could be integer or string, it can fit into a 64-bit (but not 32-bit) integer.

Pire encore, PHP a tendance à être bogué si l'entier est proche de la frontière 2 ³¹ = 2 147 483 648 (voir bogue 51430 , bogue 52899 ). Par exemple, sur mon environnement local (PHP 5.3.8 sur XAMPP 1.7.7 sur Windows 7), var_dump(array("2147483647" => "b"))donne

array(1) {
    [2147483647]=>
    string(1) "b"
}   

mais sur cette démo en direct sur codepad (PHP 5.2.5), la même expression donne

array(1) {
    ["2147483647"]=>
    string(1) "b"
}

La clé est donc un entier dans un environnement mais une chaîne dans un autre, même s'il 2147483647s'agit d'un entier 32 bits signé valide .

En termes de vitesse:

function isAssoc($array)
{
    return ($array !== array_values($array));
}

Côté mémoire:

function isAssoc($array)
{
    $array = array_keys($array); return ($array !== array_keys($array));
}

function checkAssoc($array){
    return  ctype_digit( implode('', array_keys($array) ) );
}

En fait, le moyen le plus efficace est donc:

function is_assoc($array){
   $keys = array_keys($array);
   return $keys !== array_keys($keys);
}

Cela fonctionne car il compare les clés (qui pour un tableau séquentiel sont toujours 0,1,2 etc.) aux clés des clés (qui seront toujours 0,1,2 etc.).

J'ai utilisé les deux array_keys($obj) !== range(0, count($obj) - 1)et array_values($arr) !== $arr(qui sont duaux l'un de l'autre, bien que le second soit moins cher que le premier) mais les deux échouent pour les très grands tableaux.

En effet, array_keyset array_valuessont toutes deux des opérations très coûteuses (car elles construisent un tout nouveau tableau de taille à peu près celui de l'original).

La fonction suivante est plus robuste que les méthodes fournies ci-dessus:

function array_type( $obj ){
    $last_key = -1;
    $type = 'index';
    foreach( $obj as $key => $val ){
        if( !is_int( $key ) || $key < 0 ){
            return 'assoc';
        }
        if( $key !== $last_key + 1 ){
            $type = 'sparse';
        }
        $last_key = $key;
    }
    return $type;
}

Notez également que si vous ne vous souciez pas de différencier les tableaux clairsemés des tableaux associatifs, vous pouvez simplement revenir 'assoc'des deux ifblocs.

Enfin, bien que cela puisse sembler beaucoup moins «élégant» que beaucoup de «solutions» sur cette page, en pratique, il est beaucoup plus efficace. Presque tous les tableaux associatifs seront détectés instantanément. Seuls les tableaux indexés seront vérifiés de manière exhaustive, et les méthodes décrites ci-dessus non seulement vérifient de manière exhaustive les tableaux indexés, mais les dupliquent.

Je pense que les deux fonctions suivantes sont la meilleure façon de vérifier «si un tableau est associatif ou numérique». Étant donné que «numérique» peut signifier uniquement des touches numériques ou uniquement des touches numériques séquentielles, deux fonctions sont répertoriées ci-dessous qui vérifient l'une ou l'autre condition:

function is_indexed_array(&$arr) {
  for (reset($arr); is_int(key($arr)); next($arr));
  return is_null(key($arr));
}

function is_sequential_array(&$arr, $base = 0) {
  for (reset($arr), $base = (int) $base; key($arr) === $base++; next($arr));
  return is_null(key($arr));
}

La première fonction vérifie si chaque clé est une valeur entière. La deuxième fonction vérifie si chaque clé est une valeur entière et vérifie en outre si toutes les clés sont séquentielles à partir de $ base, ce qui par défaut est 0 et peut donc être omis si vous n'avez pas besoin de spécifier une autre valeur de base. key ($ my_array) retourne null si le pointeur de lecture est déplacé au-delà de la fin du tableau, ce qui termine la boucle for et rend la déclaration après la boucle for vraie si toutes les clés sont entières. Sinon, la boucle se termine prématurément car une clé est de type chaîne et l'instruction après la boucle for renverra false. Cette dernière fonction ajoute en plus un à $ base après chaque comparaison, pour pouvoir vérifier si la clé suivante a la valeur correcte. La comparaison stricte permet également de vérifier si la clé est de type entier. La partie $ base = (int) $ base dans la première section de la boucle for peut être omise lorsque $ base est omis ou si vous vous assurez qu'elle n'est appelée qu'en utilisant un entier. Mais comme je ne peux pas être sûr pour tout le monde, je l'ai laissé. La déclaration n'est exécutée qu'une seule fois, de toute façon. Je pense que ce sont les solutions les plus efficaces:

• Côté mémoire: pas de copie des données ou des plages de clés. Faire un array_values ​​ou array_keys peut sembler plus court (moins de code) mais gardez à l'esprit ce qui se passe en arrière-plan une fois que vous avez fait cet appel. Oui, il y a plus de déclarations (visibles) que dans certaines autres solutions, mais ce n'est pas ce qui compte, n'est-ce pas?
• Temps sage: Outre le fait que la copie / extraction de données et / ou de clés prend également du temps, cette solution est plus efficace que de faire une foreach. Encore une fois, un foreach peut sembler plus efficace pour certains car il est plus court en notation, mais en arrière-plan, foreach appelle également reset, key et ensuite pour faire une boucle. Mais en plus, il appelle également valid pour vérifier la condition de fin, ce qui est évité ici en raison de la combinaison avec la vérification entière.

N'oubliez pas qu'une clé de tableau ne peut être qu'un entier ou une chaîne et qu'une chaîne strictement numérique telle que "1" (mais pas "01") sera traduite en entier. C'est ce qui fait que la recherche d'une clé entière est la seule opération nécessaire en plus de compter si vous voulez que le tableau soit séquentiel. Naturellement, si is_indexed_array renvoie false, le tableau peut être considéré comme associatif. Je dis «vu», car en fait ils le sont tous.

Cette fonction peut gérer:

• tableau avec trous dans l'index (par exemple 1,2,4,5,8,10)
• tableau avec clés "0x": par exemple, la clé '08' est associative tandis que la clé '8' est séquentielle.

l'idée est simple: si l'une des clés n'est PAS un entier, c'est un tableau associatif, sinon c'est séquentiel.

function is_asso($a){
    foreach(array_keys($a) as $key) {if (!is_int($key)) return TRUE;}
    return FALSE;
}

J'ai remarqué deux approches populaires pour cette question: l'une utilisant array_values()et l'autre utilisant key(). Pour savoir ce qui est plus rapide, j'ai écrit un petit programme:

$arrays = Array(
  'Array #1' => Array(1, 2, 3, 54, 23, 212, 123, 1, 1),
  'Array #2' => Array("Stack", 1.5, 20, Array(3.4)),
  'Array #3' => Array(1 => 4, 2 => 2),
  'Array #4' => Array(3.0, "2", 3000, "Stack", 5 => "4"),
  'Array #5' => Array("3" => 4, "2" => 2),
  'Array #6' => Array("0" => "One", 1.0 => "Two", 2 => "Three"),
  'Array #7' => Array(3 => "asdf", 4 => "asdf"),
  'Array #8' => Array("apple" => 1, "orange" => 2),
);

function is_indexed_array_1(Array &$arr) {
  return $arr === array_values($arr);
}

function is_indexed_array_2(Array &$arr) {
  for (reset($arr), $i = 0; key($arr) === $i++; next($arr))
    ;
  return is_null(key($arr));
}

// Method #1
$start = microtime(true);
for ($i = 0; $i < 1000; $i++) {
  foreach ($arrays as $array) {
    $dummy = is_indexed_array_1($array);
  }
}
$end = microtime(true);
echo "Time taken with method #1 = ".round(($end-$start)*1000.0,3)."ms\n";

// Method #2
$start = microtime(true);
for ($i = 0; $i < 1000; $i++) {
  foreach ($arrays as $array) {
    $dummy = is_indexed_array_2($array);
  }
}
$end = microtime(true);
echo "Time taken with method #1 = ".round(($end-$start)*1000.0,3)."ms\n";

La sortie du programme sur PHP 5.2 sur CentOS est la suivante:

Temps pris avec la méthode # 1 = 10,745 ms
Temps pris avec la méthode # 2 = 18,239 ms

La sortie sur PHP 5.3 a donné des résultats similaires. De toute évidence, l'utilisation array_values()est beaucoup plus rapide.

Une façon d'aborder cela est de se superposer json_encode, qui a déjà sa propre méthode interne de différenciation entre un tableau associatif et un tableau indexé afin de sortir le JSON correct.

Vous pouvez le faire en vérifiant si le premier caractère renvoyé après l'encodage est un {(tableau associatif) ou un [(tableau indexé).

// Too short :)
function is_assoc($arr) {
    ksort($arr);
    return json_encode($arr)[0] === '{';
}

Il existe déjà de nombreuses réponses, mais voici la méthode sur laquelle Laravel s'appuie dans sa classe Arr:

/**
 * Determines if an array is associative.
 *
 * An array is "associative" if it doesn't have sequential numerical keys beginning with zero.
 *
 * @param  array  $array
 * @return bool
 */
public static function isAssoc(array $array)
{
    $keys = array_keys($array);

    return array_keys($keys) !== $keys;
}

Source: https://github.com/laravel/framework/blob/5.4/src/Illuminate/Support/Arr.php

function array_is_assoc(array $a) {
    $i = 0;
    foreach ($a as $k => $v) {
        if ($k !== $i++) {
            return true;
        }
    }
    return false;
}

Rapide, concis et efficace en mémoire. Aucune comparaison coûteuse, appel de fonction ou copie de tableau.

En utilisant l' extension PHP xarray

Vous pouvez le faire très rapidement (environ 30 fois plus vite en PHP 5.6):

if (array_is_indexed($array)) {  }

Ou:

if (array_is_assoc($array)) {  }

Je sais qu'il est un peu inutile d'ajouter une réponse à cette énorme file d'attente, mais voici une solution O (n) lisible qui ne nécessite pas de duplication de valeurs:

function isNumericArray($array) {
    $count = count($array);
    for ($i = 0; $i < $count; $i++) {
        if (!isset($array[$i])) {
            return FALSE;
        }
    }
    return TRUE;
}

Plutôt que de vérifier les clés pour voir si elles sont toutes numériques, vous parcourez les clés qui seraient là pour un tableau numérique et vous vous assurez qu'elles existent.

Ma solution:

function isAssociative(array $array)
{
    return array_keys(array_merge($array)) !== range(0, count($array) - 1);
}

array_mergesur un seul tableau réindexera toutes les integerclés, mais pas les autres. Par exemple:

array_merge([1 => 'One', 3 => 'Three', 'two' => 'Two', 6 => 'Six']);

// This will returns [0 => 'One', 1 => 'Three', 'two' => 'Two', 2 => 'Six']

Donc, si une liste (un tableau non associatif) est créée, ['a', 'b', 'c']une valeur est supprimée unset($a[1])puis array_mergeappelée, la liste est réindexée à partir de 0.

Après quelques analyses locales, débogage, vérification du compilateur, profilage et abus de 3v4l.org pour comparer plusieurs versions (oui, j'ai reçu un avertissement pour arrêter) et comparer avec chaque variation que j'ai pu trouver ...

Je vous donne une fonction de test associatif de tableau associatif du meilleur-moyen-pire-cas dérivée organiquement qui est au pire à peu près aussi bonne ou meilleure que tous les autres scénarios de cas moyen.

/**
 * Tests if an array is an associative array.
 *
 * @param array $array An array to test.
 * @return boolean True if the array is associative, otherwise false.
 */
function is_assoc(array &$arr) {
    // don't try to check non-arrays or empty arrays
    if (FALSE === is_array($arr) || 0 === ($l = count($arr))) {
        return false;
    }

    // shortcut by guessing at the beginning
    reset($arr);
    if (key($arr) !== 0) {
        return true;
    }

    // shortcut by guessing at the end
    end($arr);
    if (key($arr) !== $l-1) {
        return true;
    }

    // rely on php to optimize test by reference or fast compare
    return array_values($arr) !== $arr;
}

Depuis https://3v4l.org/rkieX :

<?php

// array_values
function method_1(Array &$arr) {
    return $arr === array_values($arr);
}

// method_2 was DQ; did not actually work

// array_keys
function method_3(Array &$arr) {
    return array_keys($arr) === range(0, count($arr) - 1);
}

// foreach
function method_4(Array &$arr) {
    $idx = 0;
    foreach( $arr as $key => $val ){
        if( $key !== $idx )
            return FALSE;
        ++$idx;
    }
    return TRUE;
}

// guessing
function method_5(Array &$arr) {
    global $METHOD_5_KEY;
    $i = 0;
    $l = count($arr)-1;

    end($arr);
    if ( key($arr) !== $l )
        return FALSE;

    reset($arr);
    do {
        if ( $i !== key($arr) )
            return FALSE;
        ++$i;
        next($arr);
    } while ($i < $l);
    return TRUE;
}

// naieve
function method_6(Array &$arr) {
    $i = 0;
    $l = count($arr);
    do {
        if ( NULL === @$arr[$i] )
            return FALSE;
        ++$i;
    } while ($i < $l);
    return TRUE;
}

// deep reference reliance
function method_7(Array &$arr) {
    return array_keys(array_values($arr)) === array_keys($arr);
}


// organic (guessing + array_values)
function method_8(Array &$arr) {
    reset($arr);
    if ( key($arr) !== 0 )
        return FALSE;

    end($arr);
    if ( key($arr) !== count($arr)-1 )
        return FALSE;

    return array_values($arr) === $arr;
}

function benchmark(Array &$methods, Array &$target, $expected){    
    foreach($methods as $method){
        $start = microtime(true);
        for ($i = 0; $i < 2000; ++$i) {
            //$dummy = call_user_func($method, $target);
            if ( $method($target) !== $expected ) {
                echo "Method $method is disqualified for returning an incorrect result.\n";
                unset($methods[array_search($method,$methods,true)]);
                $i = 0;
                break;
            }
        }
        if ( $i != 0 ) {
            $end = microtime(true);
            echo "Time taken with $method = ".round(($end-$start)*1000.0,3)."ms\n";
        }
    }
}



$true_targets = [
    'Giant array' => range(0, 500),
    'Tiny array' => range(0, 20),
];


$g = range(0,10);
unset($g[0]);

$false_targets = [
    'Large array 1' => range(0, 100) + ['a'=>'a'] + range(101, 200),
    'Large array 2' => ['a'=>'a'] + range(0, 200),
    'Tiny array' => range(0, 10) + ['a'=>'a'] + range(11, 20),
    'Gotcha array' => $g,
];

$methods = [
    'method_1',
    'method_3',
    'method_4',
    'method_5',
    'method_6',
    'method_7',
    'method_8'
];


foreach($false_targets as $targetName => $target){
    echo "==== Benchmark using $targetName expecing FALSE ====\n";
    benchmark($methods, $target, false);
    echo "\n";
}
foreach($true_targets as $targetName => $target){
    echo "==== Benchmark using $targetName expecting TRUE ====\n";
    benchmark($methods, $target, true);
    echo "\n";
}

Voici la méthode que j'utilise:

function is_associative ( $a )
{
    return in_array(false, array_map('is_numeric', array_keys($a)));
}

assert( true === is_associative(array(1, 2, 3, 4)) );

assert( false === is_associative(array('foo' => 'bar', 'bar' => 'baz')) );

assert( false === is_associative(array(1, 2, 3, 'foo' => 'bar')) );

Notez que cela ne tient pas compte des cas spéciaux comme:

$a = array( 1, 2, 3, 4 );

unset($a[1]);

assert( true === is_associative($a) );

Désolé, je ne peux pas vous aider. Il est également quelque peu performant pour les tableaux de taille décente, car il ne fait pas de copies inutiles. Ce sont ces petites choses qui rendent Python et Ruby tellement plus agréables à écrire ...: P

<?php

function is_list($array) {
    return array_keys($array) === range(0, count($array) - 1);
}

function is_assoc($array) {
    return count(array_filter(array_keys($array), 'is_string')) == count($array);
}

?>

Ces deux exemples, qui ont marqué le plus de points, ne fonctionnent pas correctement avec des tableaux comme $array = array('foo' => 'bar', 1)

Cela fonctionnerait aussi ( démo ):

function array_has_numeric_keys_only(array $array)
{
    try {
        SplFixedArray::fromArray($array, true);
    } catch (InvalidArgumentException $e) {
        return false;
    }
    return true;
}

Veuillez noter que le point principal de cette réponse est de vous informer de l'existence de SplFixedArrayet non de vous encourager à utiliser des exceptions pour ce type de tests.

Je pense que la définition d'un tableau scalaire variera selon l'application. Autrement dit, certaines applications nécessiteront un sens plus strict de ce qui peut être qualifié de tableau scalaire, et certaines applications nécessiteront un sens plus lâche.

Ci-dessous, je présente 3 méthodes de rigueur variable.

<?php
/**
 * Since PHP stores all arrays as associative internally, there is no proper
 * definition of a scalar array.
 * 
 * As such, developers are likely to have varying definitions of scalar array,
 * based on their application needs.
 * 
 * In this file, I present 3 increasingly strict methods of determining if an
 * array is scalar.
 * 
 * @author David Farrell <DavidPFarrell@gmail.com>
 */

/**
 * isArrayWithOnlyIntKeys defines a scalar array as containing
 * only integer keys.
 * 
 * If you are explicitly setting integer keys on an array, you
 * may need this function to determine scalar-ness.
 * 
 * @param array $a
 * @return boolean
 */ 
function isArrayWithOnlyIntKeys(array $a)
{
    if (!is_array($a))
        return false;
    foreach ($a as $k => $v)
        if (!is_int($k))
            return false;
    return true;
}

/**
 * isArrayWithOnlyAscendingIntKeys defines a scalar array as
 * containing only integer keys in ascending (but not necessarily
 * sequential) order.
 * 
 * If you are performing pushes, pops, and unsets on your array,
 * you may need this function to determine scalar-ness.
 * 
 * @param array $a
 * @return boolean
 */ 
function isArrayWithOnlyAscendingIntKeys(array $a)
{
    if (!is_array($a))
        return false;
    $prev = null;
    foreach ($a as $k => $v)
    {
        if (!is_int($k) || (null !== $prev && $k <= $prev))
            return false;
        $prev = $k;
    }
    return true;
}

/**
 * isArrayWithOnlyZeroBasedSequentialIntKeys defines a scalar array
 * as containing only integer keys in sequential, ascending order,
 * starting from 0.
 * 
 * If you are only performing operations on your array that are
 * guaranteed to either maintain consistent key values, or that
 * re-base the keys for consistency, then you can use this function.
 * 
 * @param array $a
 * @return boolean
 */
function isArrayWithOnlyZeroBasedSequentialIntKeys(array $a)
{
    if (!is_array($a))
        return false;
    $i = 0;
    foreach ($a as $k => $v)
        if ($i++ !== $k)
            return false;
    return true;
}

Un de plus rapide depuis la source . Ajuster l'encodage de json_encode(et bson_encode). Il en va de même pour la conformité aux tableaux javascript.

function isSequential($value){
    if(is_array($value) || ($value instanceof \Countable && $value instanceof \ArrayAccess)){
        for ($i = count($value) - 1; $i >= 0; $i--) {
            if (!isset($value[$i]) && !array_key_exists($i, $value)) {
                return false;
            }
        }
        return true;
    } else {
        throw new \InvalidArgumentException(
            sprintf('Data type "%s" is not supported by method %s', gettype($value), __METHOD__)
        );
    }
}

Serait-ce la solution?

  public static function isArrayAssociative(array $array) {
      reset($array);
      return !is_int(key($array));
  }

La mise en garde est évidemment que le curseur du tableau est réinitialisé, mais je dirais que la fonction est probablement utilisée avant même que le tableau soit traversé ou utilisé.

Beaucoup de solutions ici sont élégantes et jolies, mais ne s'adaptent pas bien et sont gourmandes en mémoire ou en processeur. La plupart créent 2 nouveaux points de données en mémoire avec cette solution des deux côtés de la comparaison. Plus la baie est grande, plus le processus et la mémoire utilisés sont longs et durs, et vous perdez l'avantage de l'évaluation des courts-circuits. J'ai fait quelques tests avec quelques idées différentes. Essayer d'éviter array_key_exists car il est coûteux, et éviter également de créer de nouveaux grands ensembles de données à comparer. Je pense que c'est un moyen simple de savoir si un tableau est séquentiel.

public function is_sequential( $arr = [] ){
    if( !is_array( $arr ) || empty( $arr ) ) return false;

    $i = 0;

    $total = count( $arr );

    foreach( $arr as $key => $value ) if( $key !== $i++ ) return false;

    return true;
}

Vous exécutez un seul décompte sur le tableau principal et stockez un seul entier. Vous parcourez ensuite le tableau et vérifiez une correspondance exacte tout en itérant le compteur. Vous devriez avoir de 1 à compter. S'il échoue, il court-circuitera ce qui vous donnera une amélioration des performances lorsqu'il est faux.

À l'origine, je l'ai fait avec une boucle for et en vérifiant Isset ($ arr [$ i]) mais cela ne détectera pas les clés nulles qui nécessitent array_key_exists, et comme nous le savons, c'est la pire fonction à utiliser pour la vitesse.

Mettre à jour constamment les variables via foreach pour vérifier que l'itérateur ne dépasse jamais sa taille entière, PHP utilise son optimisation de mémoire intégrée, la mise en cache et la collecte des ordures pour vous garder à une utilisation des ressources très faible.

En outre, je soutiendrai que l'utilisation de array_keys dans un foreach est stupide lorsque vous pouvez simplement exécuter $ key => $ value et vérifier la clé. Pourquoi créer le nouveau point de données? Une fois que vous avez retiré les clés du tableau, vous avez immédiatement consommé plus de mémoire.

les réponses sont déjà données mais il y a trop de désinformation sur les performances. J'ai écrit ce petit script de référence qui montre que la méthode foreach est la plus rapide.

Avertissement: les méthodes suivantes ont été copiées-collées à partir des autres réponses

<?php

function method_1(Array &$arr) {
    return $arr === array_values($arr);
}

function method_2(Array &$arr) {
    for (reset($arr), $i = 0; key($arr) !== $i++; next($arr));
    return is_null(key($arr));
}

function method_3(Array &$arr) {
    return array_keys($arr) === range(0, count($arr) - 1);
}

function method_4(Array &$arr) {
    $idx = 0;
    foreach( $arr as $key => $val ){
        if( $key !== $idx )
            return FALSE;
        $idx++;
    }
    return TRUE;
}




function benchmark(Array $methods, Array &$target){    
    foreach($methods as $method){
        $start = microtime(true);
        for ($i = 0; $i < 1000; $i++)
            $dummy = call_user_func($method, $target);

        $end = microtime(true);
        echo "Time taken with $method = ".round(($end-$start)*1000.0,3)."ms\n";
    }
}



$targets = [
    'Huge array' => range(0, 30000),
    'Small array' => range(0, 1000),
];
$methods = [
    'method_1',
    'method_2',
    'method_3',
    'method_4',
];
foreach($targets as $targetName => $target){
    echo "==== Benchmark using $targetName ====\n";
    benchmark($methods, $target);
    echo "\n";
}

résultats:

==== Benchmark using Huge array ====
Time taken with method_1 = 5504.632ms
Time taken with method_2 = 4509.445ms
Time taken with method_3 = 8614.883ms
Time taken with method_4 = 2720.934ms

==== Benchmark using Small array ====
Time taken with method_1 = 77.159ms
Time taken with method_2 = 130.03ms
Time taken with method_3 = 160.866ms
Time taken with method_4 = 69.946ms

Ou vous pouvez simplement utiliser ceci:

Arr::isAssoc($array)

qui vérifiera si le tableau contient une clé non numérique ou:

Arr:isAssoc($array, true)

pour vérifier si le tableau est strictement séquentiel (contient les clés int générées automatiquement 0 à n-1 )

en utilisant cette bibliothèque.

À moins que PHP n'ait une fonction intégrée pour cela, vous ne pourrez pas le faire en moins de O (n) - en énumérant toutes les clés et en vérifiant le type entier. En fait, vous voulez également vous assurer qu'il n'y a pas de trous, donc votre algorithme pourrait ressembler à:

for i in 0 to len(your_array):
    if not defined(your-array[i]):
        # this is not an array array, it's an associative array :)

Mais pourquoi s'embêter? Supposez simplement que le tableau est du type que vous attendez. Si ce n'est pas le cas, cela vous explosera au visage - c'est une programmation dynamique pour vous! Testez votre code et tout ira bien ...

Je compare la différence entre les clés du tableau et les clés du résultat de array_values ​​() du tableau, qui sera toujours un tableau avec des indices entiers. Si les clés sont les mêmes, ce n'est pas un tableau associatif.

function isHash($array) {
    if (!is_array($array)) return false;
    $diff = array_diff_assoc($array, array_values($array));
    return (empty($diff)) ? false : true;
}