Jak sprawdzić, czy tablica PHP jest asocjacyjna czy sekwencyjna?

PHP traktuje wszystkie tablice jako asocjacyjne, więc nie ma żadnych wbudowanych funkcji. Czy ktoś może polecić dość skuteczny sposób sprawdzenia, czy tablica zawiera tylko klawisze numeryczne?

Zasadniczo chcę być w stanie odróżnić to:

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

i to:

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

Zadałeś dwa pytania, które nie są do końca równoważne:

• Po pierwsze, jak ustalić, czy tablica ma tylko klucze numeryczne
• Po drugie, jak ustalić, czy tablica ma sekwencyjne klucze numeryczne, zaczynając od 0

Zastanów się, które z tych zachowań naprawdę potrzebujesz. (Może być tak, że albo zrobi to dla twoich celów.)

Na pierwsze pytanie (po prostu sprawdzenie, czy wszystkie klawisze są numeryczne) odpowiada dobrze kapitan kurO .

W przypadku drugiego pytania (sprawdzenie, czy tablica jest indeksowana zerowo i sekwencyjnie), możesz użyć następującej funkcji:

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

Aby tylko sprawdzić, czy tablica ma klucze niecałkowite (a nie, czy tablica jest indeksowana sekwencyjnie czy zerowo):

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

Jeśli istnieje co najmniej jeden klucz ciągu, $arraybędzie traktowany jako tablica asocjacyjna.

Z pewnością jest to lepsza alternatywa.

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

Wielu komentujących to pytanie nie rozumie, jak tablice działają w PHP. Z dokumentacji tablicy :

Klucz może być liczbą całkowitą lub łańcuchem. Jeśli klucz jest standardową reprezentacją liczby całkowitej, zostanie zinterpretowany jako taki (tzn. „8” zostanie zinterpretowane jako 8, a „08” zostanie zinterpretowane jako „08”). Zmienne w kluczu są obcinane do liczby całkowitej. Indeksowane i asocjacyjne typy tablic są tego samego typu w PHP, które mogą zawierać zarówno indeksy całkowite, jak i łańcuchowe.

Innymi słowy, nie ma czegoś takiego jak klucz tablicy „8”, ponieważ zawsze będzie (cicho) konwertowany na liczbę całkowitą 8. Dlatego próba rozróżnienia liczb całkowitych i ciągów liczbowych jest niepotrzebna.

Jeśli chcesz najskuteczniejszego sposobu sprawdzenia tablicy pod kątem kluczy niecałkowitych bez robienia kopii części tablicy (jak robi to array_keys ()) lub wszystkich (jak foreach robi):

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

Działa to, ponieważ key () zwraca NULL, gdy bieżąca pozycja tablicy jest niepoprawna, a NULL nigdy nie może być prawidłowym kluczem (jeśli spróbujesz użyć NULL jako klucza tablicy, zostanie on po cichu przekonwertowany na „”).

Jak stwierdził PO :

PHP traktuje wszystkie tablice jako asocjacyjne

napisanie funkcji, która sprawdza, czy tablica jest asocjacyjna, nie jest rozsądne (IMHO) . Po pierwsze: co jest kluczem w tablicy PHP ?:

Klucz może być albo całkowitą lub ciąg .

Oznacza to, że są 3 możliwe przypadki:

• Przypadek 1. wszystkie klucze są liczbami / liczbami całkowitymi .
• Przypadek 2. wszystkie klucze są ciągami znaków .
• Przypadek 3. niektóre klucze są ciągami , niektóre klucze są liczbami / liczbami całkowitymi .

Możemy sprawdzić każdy przypadek za pomocą następujących funkcji.

Przypadek 1: wszystkie klucze są liczbami / liczbami całkowitymi .

Uwaga : Ta funkcja zwraca wartość true również dla pustych tablic.

//! 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);
}

Przypadek 2: wszystkie klucze są ciągami znaków .

Uwaga : Ta funkcja zwraca wartość true również dla pustych tablic.

//! 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);
}

Przypadek 3. niektóre klucze są ciągami , niektóre klucze są liczbami / liczbami całkowitymi .

Uwaga : Ta funkcja zwraca wartość true również dla pustych tablic.

//! 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;
}

Wynika, że:

• Jeśli wartość nie jest tablicą , wszystkie 3 funkcje zwracają wartość false .
• Jeśli wartością jest pusta tablica , wszystkie 3 funkcje zwracają wartość true
  (co jest z definicji, jak w „ pustym zestawie jest podzbiór dowolnego zestawu A, ponieważ wszystkie jego elementy należą do A ”).
• Jeśli wartość jest niepustą tablicą , dokładnie 1 funkcja zwraca true .

Teraz, aby tablica była „prawdziwą” tablicą, do której wszyscy jesteśmy przyzwyczajeni, co oznacza:

• Jej klawisze są wszystkie liczbowe / całkowitymi .
• Jego klucze są sekwencyjne (tzn. Zwiększane o krok 1).
• Jego klucze zaczynają się od zera .

Możemy to sprawdzić za pomocą następującej funkcji.

Przypadek 3a klucze są liczbowe / całkowite , sekwencyjne i zerowe .

Uwaga : Ta funkcja zwraca wartość true również dla pustych tablic.

//! 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);
}

Ostrzeżenia / pułapki (lub jeszcze bardziej osobliwe fakty na temat kluczy tablic w PHP)

Klucze całkowite

Kluczami dla tych tablic są liczby całkowite :

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

Klucze strunowe

Kluczami do tych tablic są ciągi znaków :

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!

Klucze całkowite, które wyglądają jak łańcuchy

Jeśli uważasz, że klucz array("13" => "b")jest ciągiem , jesteś w błędzie . Z dokumentu tutaj :

Ciągi zawierające prawidłowe liczby całkowite zostaną rzutowane na typ całkowity. Np. Klucz „8” faktycznie będzie przechowywany pod 8. Z drugiej strony „08” nie zostanie rzucony, ponieważ nie jest to poprawna liczba dziesiętna.

Na przykład kluczem do tych tablic są liczby całkowite :

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

Ale kluczem do tych tablic są ciągi :

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.

Co więcej, zgodnie z dokumentem ,

Rozmiar liczby całkowitej zależy od platformy, chociaż maksymalna wartość wynosząca około dwóch miliardów jest zwykle wartością (to 32 bitów ze znakiem). Platformy 64-bitowe zwykle mają maksymalną wartość około 9E18, z wyjątkiem systemu Windows, który zawsze jest 32-bitowy. PHP nie obsługuje liczb całkowitych bez znaku.

Tak więc kluczem do tej tablicy może być lub nie być liczbą całkowitą - to zależy od platformy.

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

Co gorsza, PHP ma tendencję do błędów, jeśli liczba całkowita znajduje się w pobliżu granicy 2 ³¹ = 2 147 483 648 (patrz błąd 51430 , błąd 52899 ). Na przykład w moim lokalnym środowisku (PHP 5.3.8 na XAMPP 1.7.7 na Windows 7) var_dump(array("2147483647" => "b"))daje

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

ale w tej wersji demonstracyjnej na żywo na codepad (PHP 5.2.5) daje to samo wyrażenie

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

Zatem kluczem jest liczba całkowita w jednym środowisku, ale ciąg znaków w innym, mimo że 2147483647jest to 32-bitowa liczba całkowita ze znakiem .

Pod względem prędkości:

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

Pod względem pamięci:

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

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

W rzeczywistości najbardziej efektywnym sposobem jest:

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

Działa to, ponieważ porównuje klucze (które dla tablicy sekwencyjnej są zawsze 0,1,2 itd.) Z kluczami kluczy (które zawsze będą 0,1,2 itd.).

Użyłem obu array_keys($obj) !== range(0, count($obj) - 1) i array_values($arr) !== $arr(które są podwójnymi względem siebie, chociaż drugi jest tańszy niż pierwszy), ale oba zawodzą w przypadku bardzo dużych tablic.

To dlatego, że array_keys i array_valuessą bardzo kosztowne operacje (ponieważ zbudować zupełnie nową tablicę o rozmiarze mniej więcej, że z oryginałem).

Następująca funkcja jest bardziej niezawodna niż metody przedstawione powyżej:

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

Zauważ też, że jeśli nie chcesz rozróżniać rzadkich tablic od tablic asocjacyjnych, możesz po prostu wrócić 'assoc'z obuif bloków.

Wreszcie, chociaż może się to wydawać znacznie mniej „eleganckie” niż wiele „rozwiązań” na tej stronie, w praktyce jest znacznie wydajniejsze. Niemal każda tablica asocjacyjna zostanie wykryta natychmiast. Tylko indeksowane tablice zostaną sprawdzone wyczerpująco, a metody opisane powyżej nie tylko sprawdzą indeksowane tablice wyczerpująco, ale je powielają.

Myślę, że następujące dwie funkcje są najlepszym sposobem na sprawdzenie „czy tablica jest asocjacyjna czy numeryczna”. Ponieważ „numeryczne” może oznaczać tylko klawisze numeryczne lub tylko sekwencyjne klawisze numeryczne, poniżej wymieniono dwie funkcje, które sprawdzają jeden z warunków:

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

Pierwsza funkcja sprawdza, czy każdy klawisz jest liczbą całkowitą. Druga funkcja sprawdza, czy każdy klucz jest liczbą całkowitą, a ponadto sprawdza, czy wszystkie klucze są sekwencyjne, zaczynając od $ base, która domyślnie wynosi 0, a zatem można je pominąć, jeśli nie trzeba podawać innej wartości podstawowej. key ($ my_array) zwraca null, jeśli wskaźnik odczytu zostanie przesunięty poza koniec tablicy, co kończy pętlę for i sprawia, że ​​instrukcja po pętli for true jest prawdziwa, jeśli wszystkie klucze były liczbami całkowitymi. Jeśli nie, pętla kończy się przedwcześnie, ponieważ klucz jest typu string, a instrukcja po pętli for zwróci false. Ta ostatnia funkcja dodatkowo dodaje jeden do $ base po każdym porównaniu, aby móc sprawdzić, czy następny klucz ma poprawną wartość. Ścisłe porównanie sprawia, że ​​sprawdza się również, czy klucz jest typu liczba całkowita. $ Base = (int) $ base część w pierwszej sekcji pętli for można pominąć, gdy $ base zostanie pominięte lub jeśli upewnisz się, że jest wywoływana tylko za pomocą liczby całkowitej. Ale ponieważ nie mogę być pewien wszystkich, zostawiłem to. W każdym razie instrukcja jest wykonywana tylko raz. Myślę, że są to najbardziej wydajne rozwiązania:

• Jeśli chodzi o pamięć: brak kopiowania danych lub kluczowych zakresów. Wykonywanie wartości array_values ​​lub array_keys może wydawać się krótsze (mniej kodu), ale pamiętaj, co dzieje się w tle po wykonaniu tego wywołania. Tak, jest więcej (widocznych) stwierdzeń niż w niektórych innych rozwiązaniach, ale nie to się liczy, prawda?
• Oszczędność czasu: oprócz faktu, że kopiowanie / wyodrębnianie danych i / lub kluczy również wymaga czasu, to rozwiązanie jest bardziej wydajne niż wykonywanie foreach. Ponownie Foreach może wydawać się niektórym bardziej efektywny, ponieważ ma krótszą notację, ale w tle foreach również wywołuje reset, klucz, a następnie wykonuje pętlę. Ale dodatkowo wywołuje także sprawdzenie poprawności warunku końcowego, którego tu się unikamy ze względu na kombinację ze sprawdzaniem liczby całkowitej.

Pamiętaj, że klucz tablicy może być tylko liczbą całkowitą lub łańcuchem, a łańcuch ściśle liczbowy, taki jak „1” (ale nie „01”), zostanie przetłumaczony na liczbę całkowitą. To sprawia, że ​​sprawdzanie klucza liczb całkowitych jest jedyną potrzebną operacją oprócz liczenia, jeśli chcesz, aby tablica była sekwencyjna. Oczywiście, jeśli is_indexed_array zwraca false, tablica może być postrzegana jako asocjacyjna. Mówię „widziałem”, bo tak naprawdę wszyscy są.

Ta funkcja obsługuje:

• tablica z dziurami w indeksie (np. 1,2,4,5,8,10)
• tablica z kluczami „0x”: np. klucz „08” jest skojarzony, a klucz „8” jest sekwencyjny.

pomysł jest prosty: jeśli jeden z kluczy NIE jest liczbą całkowitą, jest to tablica asocjacyjna, w przeciwnym razie jest sekwencyjna.

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

Zauważyłem dwa popularne podejścia do tego pytania: jedno za pomocą, array_values()a drugie za pomocą key(). Aby dowiedzieć się, co jest szybsze, napisałem mały program:

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

Dane wyjściowe dla programu w PHP 5.2 na CentOS są następujące:

Czas zajęty metodą nr 1 = 10,745 ms
Czas zajęty metodą nr 2 = 18,239 ms

Dane wyjściowe w PHP 5.3 dały podobne wyniki. Oczywiście korzystanie array_values()jest znacznie szybsze.

Jednym ze sposobów podejścia do tego jest skorzystanie z funkcji piggyback json_encode, która ma już własną wewnętrzną metodę rozróżniania między tablicą asocjacyjną a tablicą indeksowaną w celu uzyskania poprawnego JSON.

Możesz to zrobić, sprawdzając, czy pierwszy znak zwrócony po kodowaniu to {(tablica asocjacyjna) lub [(tablica indeksowana).

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

Istnieje już wiele odpowiedzi, ale oto metoda, na której Laravel polega w swojej klasie 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;
}

Źródło: 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;
}

Szybka, zwięzła i wydajna pamięć. Bez kosztownych porównań, wywołań funkcji i kopiowania tablic.

Korzystając z rozszerzenia xarray PHP

Możesz to zrobić bardzo szybko (około 30+ razy szybciej w PHP 5.6):

if (array_is_indexed($array)) {  }

Lub:

if (array_is_assoc($array)) {  }

Wiem, że dodawanie odpowiedzi do tej wielkiej kolejki jest nieco bezcelowe, ale oto czytelne rozwiązanie O (n), które nie wymaga powielania żadnych wartości:

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

Zamiast sprawdzać klucze, czy wszystkie są numeryczne, iterujesz po klawiszach, które byłyby tam dla tablicy numerycznej i upewniasz się, że istnieją.

Moje rozwiązanie:

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

array_mergena jednej tablicy reindeksuje wszystkie integerklucze, ale nie inne. Na przykład:

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

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

Więc jeśli tworzona jest lista (tablica niepowiązana), to ['a', 'b', 'c']wartość jest usuwana, unset($a[1])a następnie array_mergewywoływana, lista jest ponownie indeksowana, zaczynając od 0.

Po kilku lokalnych testach porównawczych, debugowaniu, sondowaniu kompilatora, profilowaniu i nadużywaniu 3v4l.org do porównywania kolejnych wersji (tak, dostałem ostrzeżenie, aby przestać) i porównywania z każdą odmianą, jaką mogłem znaleźć ...

Podaję ci funkcję testu macierzy asocjacyjnej opartej na analizie macierzy według najlepszego, przeciętnego i najgorszego przypadku, która w najgorszym przypadku jest w przybliżeniu tak dobra lub lepsza niż wszystkie inne scenariusze średnich przypadków.

/**
 * 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;
}

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

Oto metoda, której używam:

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')) );

Pamiętaj, że nie uwzględnia to szczególnych przypadków, takich jak:

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

unset($a[1]);

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

Niestety nie mogę ci w tym pomóc. Jest również dość wydajny w przypadku tablic o przyzwoitych rozmiarach, ponieważ nie tworzy niepotrzebnych kopii. To te małe rzeczy sprawiają, że Python i Ruby są o wiele ładniejsi w pisaniu ...: 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);
}

?>

Oba te przykłady, które uzyskały najwięcej punktów, nie działają poprawnie z takimi tablicami $array = array('foo' => 'bar', 1)

To też działałoby ( demo ):

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

Należy pamiętać, że głównym celem tej odpowiedzi jest poinformowanie Cię o istnieniu SplFixedArrayi nie zachęcanie do korzystania z wyjątków dla tego rodzaju testów.

Myślę, że definicja tablicy skalarnej będzie się różnić w zależności od aplikacji. Oznacza to, że niektóre aplikacje będą wymagały bardziej ścisłego wyczucia tego, co kwalifikuje się jako tablica skalarna, a niektóre aplikacje będą wymagały bardziej luźnego wyczucia.

Poniżej przedstawiam 3 metody o różnej surowości.

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

Jeszcze jeden szybki ze źródła . Dopasuj kodowanie json_encode(i bson_encode). Podobnie jak zgodność z javascript Array.

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__)
        );
    }
}

Czy to może być rozwiązanie?

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

Zastrzeżeniem jest oczywiście to, że kursor tablicy został zresetowany, ale powiedziałbym, że prawdopodobnie funkcja jest używana, zanim tablica zostanie jeszcze przemierzona lub użyta.

Wiele z tych rozwiązań jest eleganckich i ładnych, ale nie skaluje się dobrze i wymaga dużej ilości pamięci lub procesora. Większość tworzy 2 nowe punkty danych w pamięci za pomocą tego rozwiązania z obu stron porównania. Im większa matryca, tym trudniejszy i dłuższy proces i używana pamięć oraz utrata korzyści z oceny zwarcia. Zrobiłem kilka testów z kilkoma różnymi pomysłami. Próba uniknięcia tablicy_klucza_istnieje, ponieważ jest to kosztowne, a także unikanie tworzenia nowych dużych zestawów danych do porównania. Wydaje mi się, że jest to prosty sposób na stwierdzenie, czy tablica jest sekwencyjna.

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

Uruchamiasz jedną liczbę na głównej tablicy i zapisujesz jedną liczbę całkowitą. Następnie zapętlasz tablicę i sprawdzasz dokładne dopasowanie podczas iteracji licznika. Powinieneś mieć od 1, aby liczyć. Jeśli zawiedzie, nastąpi zwarcie, co daje wzrost wydajności, gdy jest fałszywy.

Pierwotnie robiłem to z pętlą for i sprawdzaniem isset ($ arr [$ i]), ale to nie wykryje pustych kluczy, które wymagają tablicy_klucz_istniejących, a jak wiemy, jest to najgorsza funkcja do użycia dla prędkości.

Ciągłe aktualizowanie zmiennych za pomocą foreach w celu sprawdzenia wraz z iteratorem, który nigdy nie rośnie, jego rozmiar jest liczbą całkowitą, wykorzystajmy PHP, jest on wbudowany w optymalizację pamięci, buforowanie i wyrzucanie elementów bezużytecznych, aby utrzymać bardzo niskie zużycie zasobów.

Będę również argumentować, że użycie kluczy tablicowych w foreach jest głupie, kiedy można po prostu uruchomić $ key => $ wartość i sprawdzić klucz. Po co tworzyć nowy punkt danych? Po wyodrębnieniu kluczy macierzy natychmiast zużyłeś więcej pamięci.

odpowiedzi są już podane, ale zbyt wiele dezinformacji dotyczących wydajności. Napisałem ten mały skrypt porównawczy, który pokazuje, że metoda Foreach jest najszybsza.

Uwaga: następujące metody zostały skopiowane z innych odpowiedzi

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

wyniki:

==== 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

Lub możesz po prostu użyć tego:

Arr::isAssoc($array)

który sprawdzi, czy tablica zawiera jakiś klucz nienumeryczny lub:

Arr:isAssoc($array, true)

aby sprawdzić, czy tablica jest ściśle sekwencyjna (zawiera automatycznie generowane klucze int od 0 do n-1 )

za pomocą tej biblioteki.

Jeśli PHP nie ma wbudowanego do tego celu, nie będziesz w stanie tego zrobić w mniej niż O (n) - wyliczając wszystkie klucze i sprawdzając typ liczb całkowitych. W rzeczywistości chcesz również upewnić się, że nie ma żadnych dziur, więc Twój algorytm może wyglądać następująco:

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

Ale po co zawracać sobie głowę? Załóżmy, że tablica jest tego typu, którego oczekujesz. Jeśli tak nie jest, po prostu wybuchnie ci w twarz - to dla ciebie dynamiczne programowanie! Przetestuj swój kod, a wszystko będzie dobrze ...

Porównuję różnicę między kluczami tablicy a kluczami wyniku array_values ​​() tablicy, która zawsze będzie tablicą z indeksami liczb całkowitych. Jeśli klucze są takie same, nie jest to tablica asocjacyjna.

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