Wie überprüfe ich, ob das PHP-Array assoziativ oder sequentiell ist?

PHP behandelt alle Arrays als assoziativ, daher sind keine Funktionen integriert. Kann jemand eine ziemlich effiziente Methode empfehlen, um zu überprüfen, ob ein Array nur numerische Schlüssel enthält?

Grundsätzlich möchte ich in der Lage sein, Folgendes zu unterscheiden:

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

und das:

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

Sie haben zwei Fragen gestellt, die nicht ganz gleichwertig sind:

• Erstens, wie man bestimmt, ob ein Array nur numerische Schlüssel hat
• Zweitens, wie man bestimmt, ob ein Array sequentielle Zifferntasten hat, beginnend mit 0

Überlegen Sie, welches dieser Verhaltensweisen Sie tatsächlich benötigen. (Es kann sein, dass beides für Ihre Zwecke ausreicht.)

Die erste Frage (einfach überprüfen, ob alle Schlüssel numerisch sind) wird von Captain KurO gut beantwortet .

Für die zweite Frage (Überprüfen, ob das Array nullindiziert und sequentiell ist) können Sie die folgende Funktion verwenden:

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

So überprüfen Sie lediglich, ob das Array nicht ganzzahlige Schlüssel enthält (nicht, ob das Array sequenziell oder nullindiziert ist):

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

Wenn mindestens ein Zeichenfolgenschlüssel vorhanden ist, $arraywird dies als assoziatives Array betrachtet.

Dies ist sicherlich eine bessere Alternative.

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

Viele Kommentatoren in dieser Frage verstehen nicht, wie Arrays in PHP funktionieren. Aus der Array-Dokumentation :

Ein Schlüssel kann entweder eine Ganzzahl oder eine Zeichenfolge sein. Wenn ein Schlüssel die Standarddarstellung einer Ganzzahl ist, wird er als solcher interpretiert (dh "8" wird als 8 interpretiert, während "08" als "08" interpretiert wird). Gleitkommazahlen in Schlüssel werden auf Ganzzahl abgeschnitten. Der indizierte und der assoziative Array-Typ sind in PHP vom selben Typ, der sowohl Ganzzahl- als auch Zeichenfolgenindizes enthalten kann.

Mit anderen Worten, es gibt keinen Array-Schlüssel von "8", da er immer (stillschweigend) in die Ganzzahl 8 konvertiert wird. Daher ist es nicht erforderlich, zwischen Ganzzahlen und numerischen Zeichenfolgen zu unterscheiden.

Wenn Sie die effizienteste Methode zum Überprüfen eines Arrays auf nicht ganzzahlige Schlüssel suchen, ohne eine Kopie eines Teils des Arrays (wie bei array_keys ()) oder des gesamten Arrays (wie bei foreach) zu erstellen:

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

Dies funktioniert, weil key () NULL zurückgibt, wenn die aktuelle Array-Position ungültig ist und NULL niemals ein gültiger Schlüssel sein kann (wenn Sie versuchen, NULL als Array-Schlüssel zu verwenden, wird es stillschweigend in "" konvertiert).

Wie vom OP angegeben :

PHP behandelt alle Arrays als assoziativ

Es ist nicht ganz sinnvoll (IMHO), eine Funktion zu schreiben, die prüft, ob ein Array assoziativ ist . Also als erstes: Was ist ein Schlüssel in einem PHP-Array ?

Der Schlüssel kann entweder eine Ganzzahl oder eine Zeichenfolge sein .

Das heißt, es gibt 3 mögliche Fälle:

• Fall 1. Alle Schlüssel sind numerisch / ganzzahlig .
• Fall 2. Alle Schlüssel sind Zeichenfolgen .
• Fall 3. Einige Schlüssel sind Zeichenfolgen , einige Schlüssel sind numerische / ganze Zahlen .

Wir können jeden Fall mit den folgenden Funktionen überprüfen.

Fall 1: Alle Schlüssel sind numerisch / ganzzahlig .

Hinweis : Diese Funktion gibt auch für leere Arrays true zurück .

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

Fall 2: Alle Schlüssel sind Zeichenfolgen .

Hinweis : Diese Funktion gibt auch für leere Arrays true zurück .

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

Fall 3. Einige Schlüssel sind Zeichenfolgen , einige Schlüssel sind numerische / ganze Zahlen .

Hinweis : Diese Funktion gibt auch für leere Arrays true zurück .

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

Es folgt dem:

• Wenn der Wert kein Array ist , geben alle 3 Funktionen false zurück .
• Wenn der Wert ein leeres Array ist , geben alle 3 Funktionen true zurück
  (was per Definition der Fall ist, wie in " Die leere Menge ist eine Teilmenge einer beliebigen Menge A, da alle ihre Elemente zu A gehören ").
• Wenn der Wert ein nicht leeres Array ist , gibt genau 1 Funktion true zurück .

Nun, damit ein Array ein "echtes" Array ist , an das wir alle gewöhnt sind, was bedeutet:

• Die Schlüssel sind alle numerisch / ganzzahlig .
• Die Tasten sind sequentiell (dh um Schritt 1 erhöht).
• Die Tasten beginnen bei Null .

Wir können mit der folgenden Funktion überprüfen.

Fall 3a. Schlüssel sind numerisch / ganzzahlig , sequentiell und nullbasiert .

Hinweis : Diese Funktion gibt auch für leere Arrays true zurück .

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

Vorsichtsmaßnahmen / Fallstricke (oder noch eigentümlichere Fakten zu Array-Schlüsseln in PHP)

Ganzzahlige Schlüssel

Die Schlüssel für diese Arrays sind Ganzzahlen :

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

String-Schlüssel

Die Schlüssel für diese Arrays sind Zeichenfolgen :

array("fish and chips" => "b");
array("" => "b");                                   // An empty string is also a string.
array("[email protected]" => "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!

Ganzzahlige Schlüssel, die wie Zeichenfolgen aussehen

Wenn Sie glauben, dass der Schlüssel array("13" => "b")eine Zeichenfolge ist , liegen Sie falsch . Aus dem Dokument hier :

Zeichenfolgen, die gültige Ganzzahlen enthalten, werden in den Ganzzahltyp umgewandelt. ZB wird der Schlüssel "8" tatsächlich unter 8 gespeichert. Andererseits wird "08" nicht umgewandelt, da es sich nicht um eine gültige Dezimalzahl handelt.

Der Schlüssel für diese Arrays sind beispielsweise Ganzzahlen :

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

Der Schlüssel für diese Arrays sind jedoch Zeichenfolgen :

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.

Was mehr ist, laut dem Dokument ,

Die Größe einer Ganzzahl ist plattformabhängig, obwohl ein Maximalwert von etwa zwei Milliarden der übliche Wert ist (das sind 32 Bit Vorzeichen). 64-Bit-Plattformen haben normalerweise einen Maximalwert von etwa 9E18, mit Ausnahme von Windows, das immer 32-Bit ist. PHP unterstützt keine vorzeichenlosen Ganzzahlen.

Der Schlüssel für dieses Array kann also eine Ganzzahl sein oder auch nicht - dies hängt von Ihrer Plattform ab.

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

Noch schlimmer ist , neigt dazu , PHP zu sein Buggy , wenn die ganzen Zahl in der Nähe der 2 ³¹ = 2147483648 Grenze (siehe Bug 51430 , bug 52899 ). Zum Beispiel in meiner lokalen Umgebung (PHP 5.3.8 unter XAMPP 1.7.7 unter Windows 7) var_dump(array("2147483647" => "b"))gibt

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

In dieser Live-Demo auf dem Codepad (PHP 5.2.5) gibt es jedoch den gleichen Ausdruck

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

Der Schlüssel ist also eine Ganzzahl in einer Umgebung, aber eine Zeichenfolge in einer anderen, obwohl 2147483647es sich um eine gültige vorzeichenbehaftete 32-Bit- Ganzzahl handelt .

In Bezug auf die Geschwindigkeit:

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

In Bezug auf das Gedächtnis:

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

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

Eigentlich ist der effizienteste Weg also:

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

Dies funktioniert, weil die Schlüssel (die für ein sequentielles Array immer 0,1,2 usw. sind) mit den Schlüsseln der Schlüssel (die immer 0,1,2 usw. sind) verglichen werden.

Ich habe beide array_keys($obj) !== range(0, count($obj) - 1)und array_values($arr) !== $arr(die Duals voneinander sind, obwohl die zweite billiger als die erste ist) verwendet, aber beide scheitern bei sehr großen Arrays.

Dies liegt daran , array_keysund array_valuessind beide sehr teuer Operationen (da sie eine ganz neue Reihe von Größe in etwa die den ursprünglichen bauen).

Die folgende Funktion ist robuster als die oben angegebenen Methoden:

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

Beachten Sie auch, dass Sie einfach 'assoc'von beiden ifBlöcken zurückkehren können, wenn Sie keine spärlichen Arrays von assoziativen Arrays unterscheiden möchten .

Während dies auf dieser Seite weniger "elegant" erscheint als viele "Lösungen", ist es in der Praxis weitaus effizienter. Fast jedes assoziative Array wird sofort erkannt. Nur indizierte Arrays werden ausführlich geprüft, und die oben beschriebenen Methoden prüfen indizierte Arrays nicht nur ausführlich, sondern duplizieren sie auch.

Ich denke, die folgenden zwei Funktionen sind der beste Weg, um zu überprüfen, ob ein Array assoziativ oder numerisch ist. Da 'numerisch' nur Zifferntasten oder nur sequentielle Zifferntasten bedeuten kann, sind nachfolgend zwei Funktionen aufgeführt, die beide Bedingungen überprüfen:

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

Die erste Funktion prüft, ob jeder Schlüssel ein ganzzahliger Wert ist. Die zweite Funktion prüft, ob jeder Schlüssel ein ganzzahliger Wert ist, und prüft außerdem, ob alle Schlüssel ab $ base sequentiell sind. Der Standardwert ist 0 und kann daher weggelassen werden, wenn Sie keinen anderen Basiswert angeben müssen. key ($ my_array) gibt null zurück, wenn der Lesezeiger über das Ende des Arrays hinausbewegt wird. Dies beendet die for-Schleife und macht die Anweisung nach der for-Schleife true, wenn alle Schlüssel ganzzahlig sind. Wenn nicht, endet die Schleife vorzeitig, da ein Schlüssel vom Typ string ist und die Anweisung nach der for-Schleife false zurückgibt. Die letztere Funktion addiert zusätzlich nach jedem Vergleich eine zu $ ​​base, um zu überprüfen, ob der nächste Schlüssel den richtigen Wert hat. Durch den strengen Vergleich wird auch geprüft, ob der Schlüssel vom Typ Integer ist. Der $ base = (int) $ base-Teil im ersten Abschnitt der for-Schleife kann weggelassen werden, wenn $ base weggelassen wird oder wenn Sie sicherstellen, dass er nur mit einer Ganzzahl aufgerufen wird. Aber da ich nicht für alle sicher sein kann, habe ich es belassen. Die Anweisung wird sowieso nur einmal ausgeführt. Ich denke, das sind die effizientesten Lösungen:

• Speicher weise: Kein Kopieren von Daten oder Schlüsselbereichen. Das Ausführen von array_values ​​oder array_keys mag kürzer erscheinen (weniger Code), aber denken Sie daran, was im Hintergrund passiert, wenn Sie diesen Aufruf tätigen. Ja, es gibt mehr (sichtbare) Aussagen als in einigen anderen Lösungen, aber das ist nicht das, was zählt, oder?
• Zeitlich gesehen: Neben der Tatsache, dass das Kopieren / Extrahieren von Daten und / oder Schlüsseln auch Zeit in Anspruch nimmt, ist diese Lösung effizienter als ein Foreach. Wiederum mag ein foreach für manche effizienter erscheinen, weil er in der Notation kürzer ist, aber im Hintergrund ruft foreach auch reset, key und als nächstes eine Schleife auf. Zusätzlich wird aber auch gültig aufgerufen, um die Endbedingung zu überprüfen, was hier aufgrund der Kombination mit der Ganzzahlprüfung vermieden wird.

Denken Sie daran, dass ein Array-Schlüssel nur eine Ganzzahl oder eine Zeichenfolge sein kann und eine streng numerische Zeichenfolge wie "1" (aber nicht "01") in eine Ganzzahl übersetzt wird. Aus diesem Grund ist die Suche nach einem Ganzzahlschlüssel neben dem Zählen die einzige erforderliche Operation, wenn das Array sequentiell sein soll. Wenn is_indexed_array false zurückgibt, kann das Array natürlich als assoziativ angesehen werden. Ich sage "gesehen", weil sie es tatsächlich alle sind.

Diese Funktion kann Folgendes verarbeiten:

• Array mit Löchern im Index (zB 1,2,4,5,8,10)
• Array mit "0x" -Tasten: zB ist der Schlüssel '08' assoziativ, während der Schlüssel '8' sequentiell ist.

Die Idee ist einfach: Wenn einer der Schlüssel KEINE Ganzzahl ist, handelt es sich um ein assoziatives Array, andernfalls handelt es sich um ein sequentielles Array.

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

Ich habe zwei beliebte Ansätze für diese Frage bemerkt: einen mit array_values()und einen mit key(). Um herauszufinden, was schneller ist, habe ich ein kleines Programm geschrieben:

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

Die Ausgabe für das Programm unter PHP 5.2 unter CentOS lautet wie folgt:

Zeitaufwand mit Methode 1 = 10,745 ms
Zeitaufwand mit Methode 2 = 18,239 ms

Die Ausgabe von PHP 5.3 ergab ähnliche Ergebnisse. Offensichtlich ist die Verwendung array_values()viel schneller.

Eine Möglichkeit, dies zu erreichen, ist das Huckepack- json_encodeVerfahren, das bereits über eine eigene interne Methode zur Unterscheidung zwischen einem assoziativen Array und einem indizierten Array verfügt, um den richtigen JSON auszugeben.

Sie können dies tun, indem Sie überprüfen, ob das erste nach der Codierung zurückgegebene Zeichen ein {(assoziatives Array) oder ein [(indiziertes Array) ist.

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

Es gibt bereits viele Antworten, aber hier ist die Methode, auf die sich Laravel in seiner Arr-Klasse stützt:

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

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

Schnell, präzise und speichereffizient. Keine teuren Vergleiche, Funktionsaufrufe oder Array-Kopien.

Mit der xarray PHP-Erweiterung

Sie können dies sehr schnell tun (ungefähr 30+ mal schneller in PHP 5.6):

if (array_is_indexed($array)) {  }

Oder:

if (array_is_assoc($array)) {  }

Ich weiß, dass es ein bisschen sinnlos ist, eine Antwort auf diese große Warteschlange hinzuzufügen, aber hier ist eine lesbare O (n) -Lösung, bei der keine Werte dupliziert werden müssen:

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

Anstatt die Schlüssel zu überprüfen, um festzustellen, ob sie alle numerisch sind, durchlaufen Sie die Schlüssel, die für ein numerisches Array vorhanden wären , und stellen sicher, dass sie vorhanden sind.

Meine Lösung:

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

array_mergeAuf einem einzelnen Array werden alle integerSchlüssel neu indiziert , andere jedoch nicht. Zum Beispiel:

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

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

Wenn also eine Liste (ein nicht assoziatives Array) erstellt wird, ['a', 'b', 'c']wird ein Wert entfernt und unset($a[1])dann array_mergeaufgerufen. Die Liste wird ab 0 neu indiziert.

Nach einigem lokalen Benchmarking, Debugging, Compiler-Testen, Profiling und Missbrauch von 3v4l.org, um über mehrere Versionen hinweg Benchmarks zu erstellen (ja, ich habe eine Warnung zum Stoppen erhalten) und mit jeder Variation zu vergleichen, die ich finden konnte ...

Ich gebe Ihnen eine organisch abgeleitete assoziative Array-Testfunktion für das Best-Average-Worst-Case-Szenario , die im schlimmsten Fall ungefähr so ​​gut oder besser ist als alle anderen Average-Case-Szenarien.

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

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

Hier ist die Methode, die ich benutze:

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

Beachten Sie, dass dies keine Sonderfälle wie Folgendes berücksichtigt:

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

unset($a[1]);

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

Entschuldigung, ich kann dir dabei nicht helfen. Es ist auch für Arrays mit anständiger Größe etwas performant, da es keine unnötigen Kopien erstellt. Es sind diese kleinen Dinge, die Python und Ruby so viel schöner machen, in ...: 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);
}

?>

Beide Beispiele, die die meisten Punkte erzielt haben, funktionieren mit Arrays wie nicht richtig $array = array('foo' => 'bar', 1)

Dies würde auch funktionieren ( Demo ):

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

Bitte beachten Sie, dass der Hauptpunkt dieser Antwort darin besteht, Sie über die Existenz von zu informieren SplFixedArrayund Sie nicht zu ermutigen, Ausnahmen für diese Art von Tests zu verwenden.

Ich denke, die Definition eines skalaren Arrays variiert je nach Anwendung. Das heißt, einige Anwendungen erfordern ein strengeres Verständnis dessen, was als skalares Array qualifiziert ist, und einige Anwendungen erfordern ein lockereres Verständnis.

Im Folgenden stelle ich 3 Methoden unterschiedlicher Strenge vor.

<?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 <[email protected]>
 */

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

Noch eine schnelle von der Quelle . Passen Sie die Codierung von json_encode(und bson_encode) an. Dies gilt auch für die Konformität mit Javascript-Arrays.

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

Könnte dies die Lösung sein?

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

Die Einschränkung ist offensichtlich, dass der Array-Cursor zurückgesetzt wird, aber ich würde sagen, dass die Funktion wahrscheinlich verwendet wird, bevor das Array überhaupt durchlaufen oder verwendet wird.

Viele der hier aufgeführten Lösungen sind elegant und hübsch, lassen sich jedoch nicht gut skalieren und sind speicher- oder CPU-intensiv. Die meisten erstellen mit dieser Lösung von beiden Seiten des Vergleichs zwei neue Datenpunkte im Speicher. Je größer das Array, desto schwieriger und länger werden der Prozess und der Speicher verwendet, und Sie verlieren den Vorteil einer Kurzschlussbewertung. Ich habe einige Tests mit verschiedenen Ideen durchgeführt. Es wird versucht, zu vermeiden, dass array_key_exists teuer ist, und es wird auch vermieden, neue große Datensätze zum Vergleichen zu erstellen. Ich denke, dies ist eine einfache Möglichkeit, um festzustellen, ob ein Array sequentiell ist.

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

Sie führen eine einzelne Zählung für das Hauptarray aus und speichern eine einzelne Ganzzahl. Anschließend durchlaufen Sie das Array und prüfen, ob eine genaue Übereinstimmung vorliegt, während Sie den Zähler durchlaufen. Sie sollten von 1 zu zählen haben. Wenn es fehlschlägt, wird es kurzgeschlossen, was zu einer Leistungssteigerung führt, wenn es falsch ist.

Ursprünglich habe ich dies mit einer for-Schleife gemacht und nach isset gesucht ($ arr [$ i]), aber dies erkennt keine Nullschlüssel, für die array_key_exists erforderlich ist, und wie wir wissen, ist dies die schlechteste Funktion für die Geschwindigkeit.

Durch die ständige Aktualisierung von Variablen über foreach, um zu überprüfen, ob der Iterator nie über seine ganzzahlige Größe hinaus wächst, kann PHP die integrierte Speicheroptimierung, das Caching und die Speicherbereinigung verwenden, um den Ressourcenverbrauch sehr gering zu halten.

Außerdem werde ich argumentieren, dass die Verwendung von array_keys in einem foreach dumm ist, wenn Sie einfach $ key => $ value ausführen und den Schlüssel überprüfen können. Warum den neuen Datenpunkt erstellen? Sobald Sie die Array-Schlüssel entfernt haben, haben Sie sofort mehr Speicher verbraucht.

Antworten sind bereits gegeben, aber es gibt zu viele Desinformationen über die Leistung. Ich habe dieses kleine Benchmark-Skript geschrieben, das zeigt, dass die foreach-Methode die schnellste ist.

Haftungsausschluss: Die folgenden Methoden wurden aus den anderen Antworten kopiert

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

Ergebnisse:

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

Oder Sie können einfach Folgendes verwenden:

Arr::isAssoc($array)

Hiermit wird überprüft, ob das Array einen nicht numerischen Schlüssel enthält oder:

Arr:isAssoc($array, true)

um zu überprüfen, ob das Array streng sequenziell ist (enthält automatisch generierte int-Schlüssel 0 bis n-1 )

mit dieser Bibliothek.

Wenn PHP nicht über eine integrierte Funktion verfügt, können Sie dies nicht in weniger als O (n) tun - indem Sie alle Schlüssel auflisten und nach dem Integer-Typ suchen. In der Tat möchten Sie auch sicherstellen, dass keine Löcher vorhanden sind, sodass Ihr Algorithmus möglicherweise folgendermaßen aussieht:

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

Aber warum sich die Mühe machen? Nehmen Sie einfach an, dass das Array vom erwarteten Typ ist. Wenn nicht, wird es nur in Ihrem Gesicht explodieren - das ist dynamische Programmierung für Sie! Testen Sie Ihren Code und alles wird gut ...

Ich vergleiche den Unterschied zwischen den Schlüsseln des Arrays und den Schlüsseln des Ergebnisses von array_values ​​() des Arrays, das immer ein Array mit ganzzahligen Indizes sein wird. Wenn die Schlüssel identisch sind, handelt es sich nicht um ein assoziatives Array.

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