Bagaimana cara memeriksa apakah array PHP asosiatif atau berurutan?

PHP memperlakukan semua array sebagai asosiatif, jadi tidak ada fungsi bawaan. Adakah yang bisa merekomendasikan cara yang cukup efisien untuk memeriksa apakah array hanya berisi kunci numerik?

Pada dasarnya, saya ingin dapat membedakan antara ini:

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

dan ini:

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

Anda telah mengajukan dua pertanyaan yang tidak cukup setara:

• Pertama, cara menentukan apakah array hanya memiliki kunci numerik
• Kedua, bagaimana menentukan apakah array memiliki kunci numerik berurutan , mulai dari 0

Pertimbangkan perilaku mana yang benar-benar Anda butuhkan. (Mungkin itu akan dilakukan untuk tujuan Anda.)

Pertanyaan pertama (cukup memeriksa bahwa semua kunci adalah angka) dijawab dengan baik oleh Kapten kurO .

Untuk pertanyaan kedua (memeriksa apakah array berindeks nol dan berurutan), Anda dapat menggunakan fungsi berikut:

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

Untuk sekadar memeriksa apakah array memiliki kunci non-integer (bukan apakah array diindeks secara berurutan atau diindeks nol):

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

Jika setidaknya ada satu kunci string, $arrayakan dianggap sebagai array asosiatif.

Tentunya ini adalah alternatif yang lebih baik.

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

Banyak komentator dalam pertanyaan ini tidak mengerti bagaimana array bekerja di PHP. Dari dokumentasi array :

Kunci dapat berupa bilangan bulat atau string. Jika kunci adalah representasi standar integer, itu akan ditafsirkan seperti itu (yaitu "8" akan ditafsirkan sebagai 8, sedangkan "08" akan ditafsirkan sebagai "08"). Kunci mengambang di terpotong ke bilangan bulat. Tipe array yang diindeks dan asosiatif adalah tipe yang sama dalam PHP, yang keduanya dapat berisi indeks integer dan string.

Dengan kata lain, tidak ada yang namanya kunci array "8" karena akan selalu (diam-diam) dikonversi ke bilangan bulat 8. Jadi mencoba untuk membedakan antara bilangan bulat dan string numerik tidak perlu.

Jika Anda ingin cara yang paling efisien untuk memeriksa array untuk kunci non-integer tanpa membuat salinan bagian dari array (seperti array_keys () tidak) atau semuanya (seperti foreach tidak):

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

Ini berfungsi karena kunci () mengembalikan NULL ketika posisi array saat ini tidak valid dan NULL tidak pernah bisa menjadi kunci yang valid (jika Anda mencoba menggunakan NULL sebagai kunci array, ia akan dikonversi secara diam-diam ke "").

Sebagaimana dinyatakan oleh OP :

PHP memperlakukan semua array sebagai asosiatif

itu tidak cukup masuk akal (IMHO) untuk menulis fungsi yang memeriksa apakah array asosiatif . Jadi hal pertama yang pertama: apa yang merupakan kunci dalam array PHP ?:

The key baik dapat menjadi bilangan bulat atau tali .

Itu berarti ada 3 kemungkinan kasus:

• Kasus 1. semua kunci adalah angka / bilangan bulat .
• Kasus 2. semua kunci string .
• Kasus 3. beberapa kunci adalah string , beberapa kunci adalah numerik / bilangan bulat .

Kami dapat memeriksa setiap kasus dengan fungsi-fungsi berikut.

Kasus 1: semua kunci berupa angka / bilangan bulat .

Catatan : Fungsi ini mengembalikan true untuk array kosong juga.

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

Kasus 2: semua kunci adalah string .

Catatan : Fungsi ini mengembalikan true untuk array kosong juga.

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

Kasus 3. beberapa kunci adalah string , beberapa kunci adalah numerik / bilangan bulat .

Catatan : Fungsi ini mengembalikan true untuk array kosong juga.

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

Oleh karena itu:

• Jika nilainya bukan array , ketiga fungsi mengembalikan false .
• Jika nilainya adalah array kosong , ketiga fungsi mengembalikan true
  (yang menurut definisi, seperti dalam " set kosong adalah subset dari setiap set A karena semua elemen milik A ").
• Jika nilainya adalah array yang tidak kosong , tepat 1 fungsi mengembalikan true .

Sekarang, untuk sebuah array menjadi array "asli" yang kita semua terbiasa, artinya:

• Kuncinya semua numerik / bilangan bulat .
• Kuncinya berurutan (yaitu meningkat pada langkah 1).
• Kuncinya mulai dari nol .

Kami dapat memeriksa dengan fungsi berikut.

Kasus 3a. kunci numerik / bilangan bulat , berurutan , dan berbasis nol .

Catatan : Fungsi ini mengembalikan true untuk array kosong juga.

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

Peringatan / Kesalahan (atau, fakta lebih aneh tentang kunci array di PHP)

Kunci integer

Kunci untuk array ini adalah bilangan bulat :

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

Kunci dawai

Kunci untuk array ini adalah string :

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!

Kunci integer yang terlihat seperti string

Jika Anda pikir kunci dalam array("13" => "b")adalah string , Anda salah . Dari dokumen di sini :

String yang berisi bilangan bulat yang valid akan dilemparkan ke tipe bilangan bulat. Misalnya kunci "8" sebenarnya akan disimpan di bawah 8. Di sisi lain "08" tidak akan dilemparkan, karena itu bukan bilangan bulat desimal yang valid.

Misalnya, kunci untuk array ini adalah bilangan bulat :

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

Tetapi kunci untuk array ini adalah string :

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.

Terlebih lagi, menurut dokter ,

Ukuran integer tergantung pada platform, meskipun nilai maksimum sekitar dua miliar adalah nilai biasa (yang 32 bit ditandatangani). Platform 64-bit biasanya memiliki nilai maksimum sekitar 9E18, kecuali untuk Windows, yang selalu 32 bit. PHP tidak mendukung bilangan bulat yang tidak ditandatangani.

Jadi kunci untuk array ini mungkin atau tidak mungkin menjadi bilangan bulat - itu tergantung pada platform Anda.

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

Lebih buruk lagi, PHP cenderung bermasalah jika integer mendekati angka 2 ³¹ = 2.147.483.648 (lihat bug 51430 , bug 52899 ). Sebagai contoh, pada lingkungan lokal saya (PHP 5.3.8 pada XAMPP 1.7.7 pada Windows 7), var_dump(array("2147483647" => "b"))berikan

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

tetapi pada demo langsung ini pada codepad (PHP 5.2.5), ekspresi yang sama memberikan

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

Jadi kuncinya adalah integer di satu lingkungan tetapi string di yang lain, meskipun 2147483647adalah 32-bit yang ditandatangani integer .

Dari segi kecepatan:

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

Memori-bijaksana:

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

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

Sebenarnya cara yang paling efisien adalah sebagai berikut:

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

Ini berfungsi karena membandingkan kunci (yang untuk array berurutan selalu 0,1,2 dll) dengan kunci tombol (yang akan selalu menjadi 0,1,2 dll).

Saya telah menggunakan keduanya array_keys($obj) !== range(0, count($obj) - 1)danarray_values($arr) !== $arr (yang merupakan dual dari satu sama lain, meskipun yang kedua lebih murah daripada yang pertama) tetapi keduanya gagal untuk array yang sangat besar.

Ini karena array_keysdan array_valueskeduanya merupakan operasi yang sangat mahal (karena mereka membangun array ukuran baru yang kira-kira sama dengan aslinya).

Fungsi berikut ini lebih kuat daripada metode yang disediakan di atas:

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

Perhatikan juga bahwa jika Anda tidak ingin membedakan array jarang dari array asosiatif, Anda cukup kembali 'assoc'dari kedua ifblok.

Akhirnya, walaupun ini mungkin tampak kurang "elegan" daripada banyak "solusi" pada halaman ini, dalam praktiknya ini jauh lebih efisien. Hampir semua array asosiatif akan terdeteksi secara instan. Hanya array yang diindeks yang akan diperiksa secara mendalam, dan metode yang diuraikan di atas tidak hanya memeriksa array yang diindeks secara mendalam, mereka juga menggandakannya.

Saya pikir dua fungsi berikut adalah cara terbaik untuk memeriksa 'jika array asosiatif atau numerik'. Karena 'numerik' dapat berarti hanya tombol angka atau hanya tombol angka berurutan, dua fungsi tercantum di bawah ini yang memeriksa kedua kondisi:

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

Fungsi pertama memeriksa apakah setiap kunci adalah nilai integer. Fungsi kedua memeriksa apakah setiap kunci adalah nilai integer dan selain itu memeriksa apakah semua kunci berurutan mulai dari $ base, yang defaultnya ke 0 dan dengan demikian dapat dihilangkan jika Anda tidak perlu menentukan nilai basis lain. key ($ my_array) mengembalikan null jika read pointer dipindahkan melewati akhir array, yang mengakhiri loop for dan membuat pernyataan setelah for loop mengembalikan true jika semua kunci integer. Jika tidak, loop berakhir prematur karena kunci bertipe string, dan pernyataan setelah for loop akan mengembalikan false. Fungsi terakhir di samping menambahkan satu ke $ basis setelah setiap perbandingan, untuk dapat memeriksa apakah kunci berikutnya adalah nilai yang benar. Perbandingan ketat membuatnya juga memeriksa apakah kuncinya adalah tipe integer. Bagian $ base = (int) $ base di bagian pertama loop for dapat ditinggalkan ketika $ base dihilangkan atau jika Anda memastikan itu hanya disebut menggunakan integer. Tetapi karena saya tidak bisa memastikan untuk semua orang, saya meninggalkannya. Pernyataan itu hanya dieksekusi sekali saja. Saya pikir ini adalah solusi yang paling efisien:

• Memori bijaksana: Tidak menyalin data atau rentang kunci. Melakukan array_values ​​atau array_keys mungkin tampak lebih pendek (kode kurang) tetapi perlu diingat apa yang terjadi di latar belakang setelah Anda melakukan panggilan itu. Ya, ada lebih banyak pernyataan (terlihat) daripada di beberapa solusi lain, tetapi bukan itu yang diperhitungkan, bukan?
• Dari segi waktu: Selain fakta bahwa menyalin / mengekstraksi data dan / atau kunci juga membutuhkan waktu, solusi ini lebih efisien daripada melakukan foreach. Sekali lagi foreach mungkin tampak lebih efisien untuk beberapa karena lebih pendek dalam notasi, tetapi di latar belakang foreach juga panggilan reset, kunci dan selanjutnya melakukannya perulangan. Tetapi selain itu juga panggilan valid untuk memeriksa kondisi akhir, yang dihindari di sini karena kombinasi dengan cek integer.

Ingat bahwa kunci array hanya bisa berupa integer atau string, dan string numerik seperti "1" (tetapi bukan "01") akan diterjemahkan menjadi integer. Itulah yang membuat memeriksa kunci integer satu-satunya operasi yang diperlukan selain menghitung jika Anda ingin array berurutan. Secara alami, jika is_indexed_array mengembalikan false, array dapat dianggap asosiatif. Saya katakan 'terlihat', karena sebenarnya mereka semua.

Fungsi ini dapat menangani:

• array dengan lubang dalam indeks (mis. 1,2,4,5,8,10)
• array dengan kunci "0x": mis. kunci '08' adalah asosiatif sedangkan kunci '8' berurutan.

idenya sederhana: jika salah satu kunci BUKAN bilangan bulat, itu adalah array asosiatif, jika tidak itu berurutan.

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

Saya memperhatikan dua pendekatan populer untuk pertanyaan ini: satu menggunakan array_values()dan lainnya menggunakan key(). Untuk mengetahui mana yang lebih cepat, saya menulis sebuah program kecil:

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

Output untuk program pada PHP 5.2 di CentOS adalah sebagai berikut:

Waktu yang diambil dengan metode # 1 = 10.745 ms
Waktu yang diambil dengan metode # 2 = 18.239 ms

Output pada PHP 5.3 menghasilkan hasil yang serupa. Jelas menggunakan array_values()jauh lebih cepat.

Salah satu cara untuk mendekati ini adalah dengan mendukung json_encode, yang sudah memiliki metode internal sendiri untuk membedakan antara array asosiatif dan array yang diindeks untuk menghasilkan JSON yang benar.

Anda dapat melakukan ini dengan memeriksa untuk melihat apakah karakter pertama yang dikembalikan setelah pengkodean adalah {(array asosiatif) atau [(array yang diindeks).

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

Sudah ada banyak jawaban, tetapi inilah metode yang diandalkan Laravel dalam kelas Arr-nya:

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

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

Cepat, ringkas, dan efisien memori. Tidak ada perbandingan mahal, panggilan fungsi atau penyalinan array.

Dengan menggunakan xarray ekstensi PHP

Anda dapat melakukannya dengan sangat cepat (sekitar 30+ kali lebih cepat di PHP 5.6):

if (array_is_indexed($array)) {  }

Atau:

if (array_is_assoc($array)) {  }

Saya tahu ini sedikit sia-sia menambahkan jawaban untuk antrian besar ini, tapi inilah solusi O (n) yang dapat dibaca yang tidak memerlukan duplikasi nilai apa pun:

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

Daripada memeriksa kunci untuk melihat apakah semuanya numerik, Anda beralih ke kunci yang akan ada untuk array numerik dan pastikan ada.

Solusi saya:

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

array_mergepada satu array akan mengindeks ulang semua integerkunci, tetapi tidak yang lain. Sebagai contoh:

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

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

Jadi jika daftar (array non-asosiatif) dibuat ['a', 'b', 'c']maka nilai dihapus unset($a[1])kemudian array_mergedipanggil, daftar tersebut dimulai kembali mulai dari 0.

Setelah melakukan beberapa pembandingan lokal, debugging, pencarian compiler, profiling, dan menyalahgunakan 3v4l.org untuk membuat tolok ukur di lebih banyak versi (ya, saya mendapat peringatan untuk berhenti) dan membandingkan setiap variasi yang dapat saya temukan ...

Saya memberi Anda fungsi array asosiatif skenario kasus rata-rata terbaik terburuk yang diturunkan secara organik yang paling buruk kira-kira sama baiknya atau lebih baik daripada semua skenario kasus rata-rata lainnya.

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

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

Inilah metode yang saya gunakan:

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

Perhatikan bahwa ini tidak memperhitungkan kasus khusus seperti:

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

unset($a[1]);

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

Maaf, tidak dapat membantu Anda dengan itu. Ini juga agak berkinerja untuk array ukuran yang layak, karena tidak membuat salinan yang tidak perlu. Hal-hal kecil inilah yang membuat Python dan Ruby jauh lebih baik untuk dituliskan ...: 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);
}

?>

Kedua contoh ini, yang mencetak poin terbanyak tidak bekerja dengan benar dengan susunan seperti $array = array('foo' => 'bar', 1)

Ini juga akan berfungsi ( demo ):

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

Harap perhatikan bahwa poin utama dari jawaban ini adalah untuk memberi tahu Anda tentang keberadaan SplFixedArraydan tidak mendorong Anda untuk menggunakan Pengecualian untuk jenis tes ini.

Saya pikir definisi skalar akan bervariasi berdasarkan aplikasi. Artinya, beberapa aplikasi akan memerlukan pengertian yang lebih ketat tentang apa yang memenuhi syarat sebagai skalar array, dan beberapa aplikasi akan membutuhkan pengertian yang lebih longgar.

Di bawah ini saya menyajikan 3 metode kekerasan yang bervariasi.

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

Satu lagi lebih cepat dari sumber . Cocok penyandian json_encode(dan bson_encode). Begitu juga kepatuhan 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__)
        );
    }
}

Mungkinkah ini solusinya?

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

Peringatan jelas bahwa kursor array diatur ulang tetapi saya akan mengatakan mungkin fungsi ini digunakan sebelum array bahkan dilintasi atau digunakan.

Banyak solusi di sini yang elegan dan cantik, tetapi tidak skala dengan baik, dan intensif memori atau intensif CPU. Sebagian besar membuat 2 titik data baru dalam memori dengan solusi ini dari kedua sisi perbandingan. Semakin besar susunan semakin sulit dan lebih lama proses dan memori yang digunakan, dan Anda kehilangan manfaat dari evaluasi hubung singkat. Saya melakukan beberapa pengujian dengan beberapa ide berbeda. Mencoba menghindari array_key_exists karena mahal, dan juga menghindari membuat dataset besar baru untuk dibandingkan. Saya merasa ini adalah cara sederhana untuk mengetahui apakah array berurutan.

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

Anda menjalankan hitungan tunggal pada array utama dan menyimpan integer tunggal. Anda kemudian loop melalui array dan memeriksa kecocokan tepat saat iterating the counter. Anda harus mulai dari 1 untuk menghitung. Jika gagal maka akan terjadi hubungan pendek yang memberi Anda peningkatan kinerja ketika itu salah.

Awalnya saya melakukan ini dengan for loop dan memeriksa isset ($ arr [$ i]) tetapi ini tidak akan mendeteksi kunci null yang memerlukan array_key_exists, dan seperti yang kita tahu itu adalah fungsi terburuk untuk digunakan untuk kecepatan.

Terus-menerus memperbarui variabel melalui foreach untuk memeriksa bersama dengan iterator yang tidak pernah tumbuh melebihi ukuran integer, mari PHP gunakan itu dibangun dalam optimasi memori, caching dan pengumpulan sampah untuk membuat Anda menggunakan sumber daya yang sangat rendah.

Juga, saya akan berpendapat bahwa menggunakan array_keys di foreach adalah konyol ketika Anda dapat menjalankan $ key => $ value dan memeriksa kuncinya. Mengapa membuat titik data baru? Setelah Anda abstrak, kunci array Anda telah menghabiskan lebih banyak memori dengan segera.

jawaban sudah diberikan tetapi ada terlalu banyak informasi yang keliru tentang kinerja. Saya menulis skrip benchmark kecil ini yang menunjukkan bahwa metode foreach adalah yang tercepat.

Penafian: metode berikut disalin dari jawaban lain

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

hasil:

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

Atau Anda bisa menggunakan ini:

Arr::isAssoc($array)

yang akan memeriksa apakah array berisi kunci non-numerik atau:

Arr:isAssoc($array, true)

untuk memeriksa apakah array benar-benar berurutan (berisi kunci int yang dibuat secara otomatis 0 hingga n-1 )

menggunakan perpustakaan ini .

Kecuali PHP memiliki builtin untuk itu, Anda tidak akan dapat melakukannya dalam waktu kurang dari O (n) - menghitung semua kunci dan memeriksa tipe integer. Bahkan, Anda juga ingin memastikan tidak ada lubang, sehingga algoritme Anda mungkin terlihat seperti:

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

Tapi kenapa repot-repot? Anggap saja array adalah tipe yang Anda harapkan. Jika tidak, itu hanya akan meledak di wajah Anda - itu pemrograman dinamis untuk Anda! Uji kode Anda dan semuanya akan baik-baik saja ...

Saya membandingkan perbedaan antara kunci-kunci array dan kunci-kunci hasil array_values ​​() dari array, yang akan selalu berupa array dengan indeks integer. Jika kunci sama, itu bukan array asosiatif.

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