จะตรวจสอบว่าอาร์เรย์ของ PHP เชื่อมโยงหรือเรียงตามลำดับได้อย่างไร?

PHP ถือว่าอาร์เรย์ทั้งหมดเป็นแบบเชื่อมโยงดังนั้นจึงไม่มีฟังก์ชั่นในตัว ทุกคนสามารถแนะนำวิธีที่มีประสิทธิภาพพอสมควรในการตรวจสอบว่าอาร์เรย์มีคีย์ตัวเลขหรือไม่?

โดยทั่วไปฉันต้องการแยกความแตกต่างระหว่างสิ่งนี้:

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

และนี่:

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

คุณได้ถามคำถามสองข้อที่ไม่เท่ากัน:

• ประการแรกวิธีการตรวจสอบว่าอาร์เรย์มีเพียงปุ่มตัวเลขเท่านั้น
• ประการที่สองวิธีการตรวจสอบว่าอาร์เรย์มีคีย์ตัวเลขตามลำดับเริ่มต้นจาก 0

พิจารณาว่าคุณต้องการพฤติกรรมแบบใด (อาจเป็นได้ทั้งที่จะทำเพื่อวัตถุประสงค์ของคุณ)

คำถามแรก (เพียงตรวจสอบว่าคีย์ทั้งหมดเป็นตัวเลข) จะตอบได้ดีโดยกัปตัน Kuro

สำหรับคำถามที่สอง (ตรวจสอบว่าอาร์เรย์นั้นมีดัชนีเป็นศูนย์และเรียงตามลำดับ) หรือไม่คุณสามารถใช้ฟังก์ชันต่อไปนี้:

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

ในการตรวจสอบเพียงว่าอาเรย์นั้นมีคีย์ที่ไม่ใช่จำนวนเต็มหรือไม่ (ไม่ว่าอาเรย์นั้นจะเรียงตามลำดับดัชนีหรือเป็นศูนย์หรือไม่ก็ตาม)

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

หากมีอย่างน้อยหนึ่งคีย์สตริง$arrayจะถือว่าเป็นอาร์เรย์ที่เชื่อมโยง

แน่นอนว่านี่เป็นทางเลือกที่ดีกว่า

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

ผู้วิจารณ์หลายคนในคำถามนี้ไม่เข้าใจว่าอาร์เรย์ทำงานอย่างไรใน PHP จากเอกสารอาร์เรย์ :

คีย์อาจเป็นจำนวนเต็มหรือสตริง หากคีย์คือการแทนค่ามาตรฐานของจำนวนเต็มมันจะถูกตีความเช่นนั้น (เช่น "8" จะถูกตีความเป็น 8 ในขณะที่ "08" จะถูกตีความว่าเป็น "08") ทุ่นลอยในกุญแจจะถูกปัดเศษเป็นจำนวนเต็ม ประเภทอาร์เรย์ที่จัดทำดัชนีและเชื่อมโยงเป็นชนิดเดียวกันใน PHP ซึ่งทั้งสองสามารถมีดัชนีจำนวนเต็มและสตริง

กล่าวอีกนัยหนึ่งไม่มีสิ่งใดที่เป็นคีย์อาเรย์ของ "8" เพราะมันจะถูกแปลงเป็นจำนวนเต็ม 8 (เงียบ ๆ ) ดังนั้นการพยายามแยกแยะความแตกต่างระหว่างจำนวนเต็มและสตริงตัวเลขจึงไม่จำเป็น

หากคุณต้องการวิธีที่มีประสิทธิภาพมากที่สุดในการตรวจสอบอาร์เรย์สำหรับคีย์ที่ไม่ใช่จำนวนเต็มโดยไม่ต้องทำการคัดลอกส่วนหนึ่งของอาร์เรย์ (เช่น array_keys ()) หรือทั้งหมดของมัน (เช่น foreach ทำ):

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

สิ่งนี้ได้ผลเพราะ key () คืนค่า NULL เมื่อตำแหน่งอาเรย์ปัจจุบันไม่ถูกต้องและ NULL ไม่สามารถเป็นคีย์ที่ถูกต้องได้ (ถ้าคุณพยายามใช้ NULL เป็นคีย์อาเรย์จะถูกแปลงเป็น "")

ตามที่ระบุโดย OP :

PHP ถือว่าอาร์เรย์ทั้งหมดเป็นแบบเชื่อมโยง

มันไม่สมเหตุสมผล (IMHO) ในการเขียนฟังก์ชั่นที่ตรวจสอบว่าอาร์เรย์มีความสัมพันธ์หรือไม่ ดังนั้นสิ่งแรกแรก: สิ่งที่เป็นกุญแจสำคัญในอาร์เรย์ PHP ได้หรือ ?

สำคัญทั้งสามารถเป็นจำนวนเต็มหรือสตริง

นั่นหมายความว่ามี 3 กรณีที่เป็นไปได้:

• กรณีที่ 1. คีย์ทั้งหมดเป็นตัวเลข / จำนวนเต็ม
• กรณีที่ 2. คีย์ทั้งหมดเป็นสตริง
• กรณี 3. ปุ่มบางอย่างจะสาย , กุญแจบางคนที่เป็นตัวเลข / จำนวนเต็ม

เราสามารถตรวจสอบแต่ละกรณีด้วยฟังก์ชั่นต่อไปนี้

กรณีที่ 1: ปุ่มทั้งหมดเป็นตัวเลข / จำนวนเต็ม

หมายเหตุ : ฟังก์ชั่นนี้จะคืนค่าจริงสำหรับอาร์เรย์ว่างเช่นกัน

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

กรณีที่ 2: ปุ่มทั้งหมดเป็นสตริง

หมายเหตุ : ฟังก์ชั่นนี้จะคืนค่าจริงสำหรับอาร์เรย์ว่างเช่นกัน

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

กรณี 3. ปุ่มบางอย่างจะสาย , กุญแจบางคนที่เป็นตัวเลข / จำนวนเต็ม

หมายเหตุ : ฟังก์ชั่นนี้จะคืนค่าจริงสำหรับอาร์เรย์ว่างเช่นกัน

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

มันตามมาว่า:

• หากมีค่าเป็นไม่ได้เป็นอาเรย์ , ทั้ง 3ฟังก์ชั่นกลับเท็จ
• หากมีค่าเป็นอาร์เรย์ที่ว่างเปล่า , ทั้ง 3ฟังก์ชั่นกลับมาจริง
  (ซึ่งโดยความหมายในขณะที่ " เซตว่างเป็นส่วนหนึ่งของชุดใด ๆเพราะทุกองค์ประกอบอยู่ ")
• หากมีค่าเป็นอาร์เรย์ที่ไม่ว่างเปล่า , ว่า 1ฟังก์ชั่นผลตอบแทนที่แท้จริง

ตอนนี้สำหรับอาร์เรย์ที่จะเป็นอาร์เรย์ "ของแท้"ที่เราทุกคนคุ้นเคย

• คีย์ของมันคือทั้งหมดที่เป็นตัวเลข / จำนวนเต็ม
• คีย์ของมันเป็นลำดับ (เช่นเพิ่มขึ้นขั้นตอนที่ 1)
• ปุ่มมันเริ่มต้นจากศูนย์

เราสามารถตรวจสอบด้วยฟังก์ชั่นดังต่อไปนี้

กรณีที่ 3a คีย์จะเป็นตัวเลข / จำนวนเต็ม , ลำดับและzero-based

หมายเหตุ : ฟังก์ชั่นนี้จะคืนค่าจริงสำหรับอาร์เรย์ว่างเช่นกัน

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

Caveats / Pitfalls (หรือข้อเท็จจริงที่แปลกประหลาดยิ่งขึ้นเกี่ยวกับคีย์อาร์เรย์ใน PHP)

ปุ่มจำนวนเต็ม

กุญแจสำหรับอาร์เรย์เหล่านี้เป็นจำนวนเต็ม :

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

คีย์สตริง

กุญแจสำหรับอาร์เรย์เหล่านี้คือสตริง :

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!

ปุ่มจำนวนเต็มที่มีลักษณะเหมือนสตริง

หากคุณคิดว่าสำคัญในการarray("13" => "b")เป็นสตริง , คุณผิด จากเอกสารที่นี่ :

สตริงที่มีจำนวนเต็มที่ถูกต้องจะถูกส่งไปยังประเภทจำนวนเต็ม เช่นคีย์ "8" จะถูกเก็บไว้ที่ต่ำกว่า 8 ในทางกลับกัน "08" จะไม่ถูกโยนเนื่องจากไม่ใช่จำนวนเต็มทศนิยมที่ถูกต้อง

ตัวอย่างเช่นคีย์สำหรับอาร์เรย์เหล่านี้คือจำนวนเต็ม :

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

แต่กุญแจสำหรับอาร์เรย์เหล่านี้คือสตริง :

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.

มีอะไรเพิ่มเติมตามdoc ,

ขนาดของจำนวนเต็มขึ้นอยู่กับแพลตฟอร์มแม้ว่าค่าสูงสุดประมาณสองพันล้านเป็นค่าปกติ (ที่ลงนาม 32 บิต) โดยทั่วไปแพลตฟอร์ม 64 บิตจะมีค่าสูงสุดประมาณ 9E18 ยกเว้นสำหรับ Windows ซึ่งเป็น 32 บิตเสมอ PHP ไม่รองรับจำนวนเต็มที่ไม่ได้ลงนาม

ดังนั้นคีย์สำหรับอาเรย์นี้อาจเป็นหรือไม่เป็นจำนวนเต็มก็ได้ขึ้นอยู่กับแพลตฟอร์มของคุณ

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

แม้เลว, PHP มีแนวโน้มที่จะรถถ้าจำนวนเต็มอยู่ใกล้ 2 ³¹ = 2,147,483,648 เขตแดน (ดูข้อผิดพลาด 51430 , ข้อผิดพลาด 52899 ) ตัวอย่างเช่นในสภาพแวดล้อมท้องถิ่นของฉัน (PHP 5.3.8 บน XAMPP 1.7.7 บน Windows 7) var_dump(array("2147483647" => "b"))ให้

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

แต่ในการสาธิตสดนี้บนแผ่นจดบันทึก (PHP 5.2.5) การแสดงออกเดียวกันให้

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

ดังนั้นที่สำคัญเป็นจำนวนเต็มในสภาพแวดล้อมหนึ่ง แต่สตริงอีกแม้ว่าจะ2147483647เป็นที่ถูกต้องลงนาม 32 บิตจำนวนเต็ม

ความเร็วที่ชาญฉลาด:

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

หน่วยความจำที่ชาญฉลาด:

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

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

จริงๆแล้ววิธีที่มีประสิทธิภาพที่สุดคือ:

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

งานนี้เพราะจะเปรียบเทียบคีย์ (ซึ่งสำหรับอาร์เรย์ลำดับอยู่เสมอ 0,1,2 ฯลฯ ) กับคีย์ของคีย์ (ซึ่งจะเสมอเป็น 0,1,2 ฯลฯ )

ฉันเคยใช้ทั้งสองarray_keys($obj) !== range(0, count($obj) - 1)และarray_values($arr) !== $arr(ซึ่งเป็น duals ของกันและกันแม้ว่าที่สองมีราคาถูกกว่าครั้งแรก) แต่ทั้งสองล้มเหลวสำหรับอาร์เรย์ขนาดใหญ่มาก

นี้เป็นเพราะ array_keysและarray_valuesเป็นทั้งการดำเนินการที่มีค่าใช้จ่ายสูงมาก (เนื่องจากพวกเขาสร้างอาร์เรย์ใหม่ที่มีขนาดประมาณคร่าวๆของต้นฉบับ)

ฟังก์ชั่นต่อไปนี้มีความแข็งแกร่งกว่าวิธีการที่ให้ไว้ข้างต้น:

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

นอกจากนี้โปรดทราบว่าหากคุณไม่สนใจที่จะแยกความแตกต่างของอาร์เรย์แบบเบาบางจากอาร์เรย์แบบเชื่อมโยงคุณสามารถกลับมา'assoc'จากทั้งสองแบบได้ifบล็อกได้

ในที่สุดแม้ว่าสิ่งนี้อาจดู "ฉลาด" น้อยกว่า "โซลูชั่น" จำนวนมากในหน้านี้ แต่ในทางปฏิบัติมันมีประสิทธิภาพมากกว่าอย่างมาก อาเรย์ที่สัมพันธ์กันเกือบทั้งหมดจะถูกตรวจพบในทันที เฉพาะอาร์เรย์ที่มีการจัดทำดัชนีเท่านั้นที่จะได้รับการตรวจสอบอย่างละเอียดและวิธีการที่อธิบายไว้ข้างต้นไม่เพียง แต่ตรวจสอบอาร์เรย์ที่มีการจัดทำดัชนีอย่างละเอียดเท่านั้น

ฉันคิดว่าทั้งสองฟังก์ชั่นต่อไปนี้เป็นวิธีที่ดีที่สุดในการตรวจสอบว่า 'อาเรย์เป็นแบบเชื่อมโยงหรือตัวเลข' เนื่องจาก 'ตัวเลข' อาจหมายถึงเฉพาะคีย์ตัวเลขหรือคีย์ตัวเลขแบบลำดับเท่านั้นฟังก์ชันทั้งสองจึงอยู่ในรายการด้านล่างซึ่งตรวจสอบเงื่อนไขอย่างใดอย่างหนึ่ง:

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

ฟังก์ชันแรกตรวจสอบว่าแต่ละคีย์เป็นค่าจำนวนเต็มหรือไม่ ฟังก์ชั่นที่สองตรวจสอบว่าแต่ละคีย์เป็นค่าจำนวนเต็มและตรวจสอบว่าคีย์ทั้งหมดเรียงตามลำดับเริ่มต้นที่ $ base ซึ่งมีค่าเริ่มต้นเป็น 0 และสามารถละเว้นได้หากคุณไม่จำเป็นต้องระบุค่าฐานอื่น key ($ my_array) ส่งคืนค่า null หากตัวชี้การอ่านถูกย้ายผ่านจุดสิ้นสุดของอาร์เรย์ซึ่งเป็นสิ่งที่สิ้นสุดสำหรับลูปและทำให้คำสั่งหลังจาก for loop ส่งคืนจริงถ้าคีย์ทั้งหมดเป็นจำนวนเต็ม มิฉะนั้นลูปจะสิ้นสุดก่อนกำหนดเนื่องจากคีย์เป็นสตริงชนิดและคำสั่งหลังจาก for for จะส่งคืนค่าเท็จ ฟังก์ชันหลังนอกเหนือจากเพิ่มหนึ่งถึง $ base หลังจากการเปรียบเทียบแต่ละครั้งเพื่อให้สามารถตรวจสอบว่าคีย์ถัดไปเป็นค่าที่ถูกต้องหรือไม่ การเปรียบเทียบแบบเข้มงวดทำให้ตรวจสอบว่าคีย์เป็นจำนวนเต็มชนิดหรือไม่ $ base = (int) $ base ส่วนในส่วนแรกของ for loop สามารถปล่อยออกมาได้เมื่อ $ base ถูกละไว้หรือถ้าคุณแน่ใจว่ามันถูกเรียกโดยใช้จำนวนเต็มเท่านั้น แต่เนื่องจากฉันไม่สามารถมั่นใจได้สำหรับทุกคนฉันจึงทิ้งไว้คำสั่งจะถูกดำเนินการเพียงครั้งเดียวเท่านั้น ฉันคิดว่านี่เป็นโซลูชั่นที่มีประสิทธิภาพที่สุด:

• หน่วยความจำฉลาด: ไม่มีการคัดลอกข้อมูลหรือช่วงคีย์ การทำ array_values ​​หรือ array_keys อาจดูเหมือนสั้นกว่า (รหัสน้อยกว่า) แต่โปรดจำไว้ว่าเกิดอะไรขึ้นในพื้นหลังเมื่อคุณโทรออก ใช่มีคำสั่ง (มองเห็น) มากกว่าในโซลูชันอื่น ๆ แต่นั่นไม่ใช่สิ่งที่นับ
• เวลาที่ชาญฉลาด: นอกจากการคัดลอก / แยกข้อมูลและ / หรือคีย์ยังใช้เวลาโซลูชันนี้มีประสิทธิภาพมากกว่าการทำ foreach อีกครั้ง foreach อาจดูมีประสิทธิภาพมากขึ้นสำหรับบางคนเพราะมันสั้นกว่าในโน้ต แต่ในพื้นหลัง foreach ยังเรียกการตั้งค่าใหม่ที่สำคัญและถัดไปจะทำมันวน แต่นอกจากนี้มันยังเรียกว่าถูกต้องเพื่อตรวจสอบสภาพสิ้นสุดซึ่งหลีกเลี่ยงที่นี่เนื่องจากการรวมกันกับการตรวจสอบจำนวนเต็ม

โปรดจำไว้ว่าคีย์อาเรย์จะต้องเป็นจำนวนเต็มหรือสตริงเท่านั้นและสตริงตัวเลขอย่างเคร่งครัดเช่น "1" (แต่ไม่ใช่ "01") จะถูกแปลเป็นจำนวนเต็ม ซึ่งเป็นสิ่งที่ทำให้การตรวจสอบคีย์จำนวนเต็มเป็นการดำเนินการที่จำเป็นเพียงอย่างเดียวนอกเหนือจากการนับถ้าคุณต้องการให้อาร์เรย์เรียงตามลำดับ โดยธรรมชาติถ้า is_indexed_array ส่งคืนค่าเท็จอาร์เรย์สามารถถูกเชื่อมโยงเป็น ฉันพูดว่า 'เห็น' เพราะจริงๆแล้วพวกเขาทั้งหมดเป็น

ฟังก์ชั่นนี้สามารถจัดการ:

• อาร์เรย์ที่มีรูในดัชนี (เช่น 1,2,4,5,8,10)
• อาร์เรย์ที่มีคีย์ "0x": เช่นคีย์ '08' มีการเชื่อมโยงในขณะที่คีย์ '8' นั้นเรียงตามลำดับ

ความคิดนั้นง่าย: หากหนึ่งในคีย์ไม่ได้เป็นจำนวนเต็มมันเป็นอาเรย์แบบเชื่อมโยงมิฉะนั้นจะเรียงตามลำดับ

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

ผมสังเกตเห็นสองวิธีที่นิยมสำหรับคำถามนี้: หนึ่งใช้array_values()และอื่น ๆ key()ที่ใช้ หากต้องการทราบว่าเร็วกว่านี้ฉันเขียนโปรแกรมขนาดเล็ก:

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

ผลลัพธ์สำหรับโปรแกรมบน PHP 5.2 บน CentOS มีดังนี้:

เวลาที่ถ่ายด้วยวิธี # 1 = 10.745ms
เวลาที่ถ่ายด้วยวิธี # 2 = 18.239ms

ผลลัพธ์บน PHP 5.3 ให้ผลลัพธ์ที่คล้ายกัน เห็นได้ชัดว่าการใช้array_values()เร็วกว่ามาก

วิธีหนึ่งในการเข้าถึงสิ่งนี้คือการ piggyback บนjson_encodeซึ่งมีวิธีการภายในที่แตกต่างกันระหว่างอาเรย์แบบเชื่อมโยงกับอาเรย์แบบดัชนีเพื่อส่งออก JSON ที่ถูกต้อง

คุณสามารถทำได้โดยตรวจสอบเพื่อดูว่าอักขระตัวแรกที่ส่งคืนหลังจากการเข้ารหัสคือ{(อาเรย์แบบเชื่อมโยง) หรือ[(อาเรย์แบบดัชนี)

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

มีคำตอบมากมายอยู่แล้ว แต่นี่เป็นวิธีการที่ Laravel ไว้วางใจในคลาส 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;
}

ที่มา: 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;
}

รวดเร็วกระชับและหน่วยความจำมีประสิทธิภาพ ไม่มีการเปรียบเทียบราคาแพงการเรียกใช้ฟังก์ชันหรือการคัดลอกอาเรย์

โดยใช้ส่วนขยาย PHP xarray

คุณสามารถทำได้เร็วมาก (เร็วกว่าประมาณ 30+ ใน PHP 5.6):

if (array_is_indexed($array)) {  }

หรือ:

if (array_is_assoc($array)) {  }

ฉันรู้ว่ามันไม่มีจุดหมายเพิ่มคำตอบให้กับคิวขนาดใหญ่นี้ แต่นี่เป็นโซลูชัน O (n) ที่อ่านได้ซึ่งไม่จำเป็นต้องทำซ้ำค่าใด ๆ :

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

แทนที่จะตรวจสอบคีย์เพื่อดูว่าเป็นตัวเลขทั้งหมดหรือไม่คุณต้องวนซ้ำคีย์ที่จะอยู่ในอาร์เรย์ตัวเลขและตรวจสอบว่ามีอยู่หรือไม่

ทางออกของฉัน:

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

array_mergeในอาเรย์เดียวจะทำดัชนีintegerคีย์ทั้งหมดแต่จะไม่ทำคีย์อื่น ตัวอย่างเช่น:

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

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

ดังนั้นหากมีการสร้างรายการ (อาร์เรย์ที่ไม่มีการเชื่อมโยง) ['a', 'b', 'c']ดังนั้นค่าจะถูกลบออกunset($a[1])ดังนั้นชื่อนั้นarray_mergeจะถูกสร้างใหม่รายการจะเริ่มทำดัชนีใหม่ตั้งแต่ 0

หลังจากการเปรียบเทียบในระดับท้องถิ่นการดีบักคอมไพเลอร์ละเอียดการทำโปรไฟล์และการใช้ 3v4l.org เพื่อเปรียบเทียบกับเวอร์ชันอื่น ๆ (ใช่ฉันได้รับคำเตือนให้หยุด) และเปรียบเทียบกับทุกรูปแบบที่ฉันพบ ...

ฉันให้คุณฟังก์ชั่นการทดสอบอาเรย์แบบเชื่อมโยงสถานการณ์ที่ดีที่สุดโดยเฉลี่ยที่แย่ที่สุดที่ได้รับมาแย่ที่สุดแย่ที่สุดดีกว่าหรือดีกว่าสถานการณ์เฉลี่ยเคสอื่น ๆ ทั้งหมด

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

จาก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";
}

นี่คือวิธีที่ฉันใช้:

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

โปรดทราบว่านี่ไม่ได้พิจารณากรณีพิเศษเช่น:

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

unset($a[1]);

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

ขออภัยไม่สามารถช่วยคุณได้ มันค่อนข้างมีประสิทธิภาพสำหรับอาร์เรย์ที่มีขนาดค่อนข้างเหมาะสมเนื่องจากมันไม่ได้ทำสำเนาโดยไม่จำเป็น มันเป็นสิ่งเล็ก ๆ น้อย ๆ เหล่านี้ที่ทำให้ Python และ Ruby ดีกว่าที่จะเขียนใน ... : 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);
}

?>

ทั้งสองตัวอย่างเหล่านี้ซึ่งได้คะแนนมากที่สุดไม่ทำงานอย่างถูกต้องกับอาร์เรย์เช่น $array = array('foo' => 'bar', 1)

สิ่งนี้จะใช้ได้เช่นกัน ( ตัวอย่าง ):

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

โปรดทราบว่าประเด็นหลักของคำตอบนี้คือการแจ้งให้คุณทราบเกี่ยวกับการมีอยู่ของSplFixedArrayและไม่สนับสนุนให้คุณใช้ข้อยกเว้นสำหรับการทดสอบประเภทนี้

ฉันคิดว่านิยามของอาร์เรย์สเกลาร์จะแตกต่างกันไปตามแอปพลิเคชัน นั่นคือบางแอปพลิเคชันจะต้องใช้ความรู้สึกที่เข้มงวดมากขึ้นของสิ่งที่มีคุณสมบัติเป็นอาร์เรย์สเกลาร์และบางแอปพลิเคชันจะต้องใช้ความรู้สึกที่หลวมมากขึ้น

ด้านล่างฉันนำเสนอ 3 วิธีในการเปลี่ยนแปลงความเข้มงวด

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

หนึ่งได้อย่างรวดเร็วมากขึ้นจากแหล่งที่มา พอดีกับการเข้ารหัสของjson_encode(และbson_encode) ดังนั้นจึงมีความสอดคล้องกับจาวาสคริปต์

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

นี่อาจเป็นทางออกหรือไม่

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

ข้อแม้เห็นได้ชัดว่าเคอร์เซอร์อาร์เรย์ถูกรีเซ็ต แต่ฉันอาจจะใช้ฟังก์ชั่นก่อนที่อาร์เรย์จะถูกสำรวจหรือใช้งาน

โซลูชันจำนวนมากที่นี่มีความสวยงามและน่ารัก แต่ไม่ได้ปรับขนาดได้ดีและใช้หน่วยความจำมากหรือใช้ CPU มาก ส่วนใหญ่กำลังสร้างจุดข้อมูลใหม่ 2 จุดในหน่วยความจำด้วยวิธีนี้จากการเปรียบเทียบทั้งสองด้าน อาเรย์ที่ใหญ่ขึ้นจะทำให้กระบวนการและหน่วยความจำที่ใช้งานหนักขึ้นและยาวนานขึ้นและคุณเสียประโยชน์จากการประเมินการลัดวงจร ฉันทำการทดสอบด้วยแนวคิดที่แตกต่างกันเล็กน้อย พยายามหลีกเลี่ยง array_key_exists เนื่องจากมีค่าใช้จ่ายสูงและหลีกเลี่ยงการสร้างชุดข้อมูลขนาดใหญ่ใหม่เพื่อเปรียบเทียบ ฉันรู้สึกว่านี่เป็นวิธีที่ง่ายในการบอกว่าอาร์เรย์เรียงตามลำดับหรือไม่

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

คุณเรียกใช้การนับครั้งเดียวในอาร์เรย์หลักและเก็บจำนวนเต็มเดียว จากนั้นคุณวนรอบอาร์เรย์และตรวจสอบการจับคู่ที่แน่นอนในขณะที่วนซ้ำตัวนับ คุณควรมีตั้งแต่ 1 ถึงนับ ถ้ามันล้มเหลวมันจะลัดวงจรซึ่งจะช่วยเพิ่มประสิทธิภาพให้คุณเมื่อมันเป็นเท็จ

เดิมทีฉันทำสิ่งนี้พร้อมกับ for loop และตรวจสอบ isset ($ arr [$ i]) แต่สิ่งนี้จะไม่ตรวจพบคีย์ null ซึ่งต้องการ array_key_exists

อัปเดตตัวแปรอย่างต่อเนื่องผ่าน foreach เพื่อตรวจสอบพร้อมกับตัววนซ้ำที่ไม่เคยเติบโตขนาดของจำนวนเต็มมาใช้ PHP ในการเพิ่มประสิทธิภาพหน่วยความจำแคชและการรวบรวมขยะเพื่อให้คุณใช้ทรัพยากรน้อยมาก

นอกจากนี้ฉันจะยืนยันว่าการใช้ array_keys ใน foreach นั้นโง่เมื่อคุณสามารถเรียกใช้ $ key => $ value และตรวจสอบคีย์ได้ เหตุใดจึงสร้างจุดข้อมูลใหม่ เมื่อคุณตัดทอนอาเรย์คีย์คุณจะใช้หน่วยความจำเพิ่มขึ้นทันที

ได้รับคำตอบแล้ว แต่มีการบิดเบือนข้อมูลมากเกินไปเกี่ยวกับประสิทธิภาพ ฉันเขียนสคริปต์เกณฑ์มาตรฐานขนาดเล็กนี้ซึ่งแสดงว่าวิธี foreach นั้นเร็วที่สุด

คำเตือน: วิธีการต่อไปนี้คัดลอกวางจากคำตอบอื่น ๆ

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

ผล:

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

หรือคุณสามารถใช้สิ่งนี้:

Arr::isAssoc($array)

ซึ่งจะตรวจสอบว่าอาร์เรย์มีคีย์ที่ไม่ใช่ตัวเลขหรือ:

Arr:isAssoc($array, true)

เพื่อตรวจสอบว่าอาร์เรย์เรียงตามลำดับอย่างเคร่งครัดหรือไม่ (ประกอบด้วยคีย์ int ที่สร้างขึ้นอัตโนมัติ0ถึงn-1 )

โดยใช้นี้ห้องสมุด

เว้นแต่ว่า PHP มี builtin สำหรับสิ่งนั้นคุณจะไม่สามารถทำได้ในเวลาน้อยกว่า O (n) - การแจกแจงคีย์ทั้งหมดและการตรวจสอบชนิดจำนวนเต็ม ในความเป็นจริงคุณต้องการให้แน่ใจว่าไม่มีช่องโหว่ดังนั้นอัลกอริทึมของคุณอาจมีลักษณะดังนี้:

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

แต่ทำไมตื๊อ เพียงสมมติว่าอาร์เรย์เป็นประเภทที่คุณคาดหวัง หากไม่เป็นเช่นนั้นก็จะระเบิดในหน้าของคุณ - นั่นคือการเขียนโปรแกรมแบบไดนามิกสำหรับคุณ! ทดสอบรหัสของคุณและทุกอย่างจะดี ...

ฉันเปรียบเทียบความแตกต่างระหว่างคีย์ของอาร์เรย์และคีย์ของผลลัพธ์ของ array_values ​​() ของอาร์เรย์ซึ่งจะเป็นอาร์เรย์ที่มีดัชนีจำนวนเต็มเสมอ หากคีย์เหมือนกันมันไม่ใช่อาเรย์ที่เชื่อมโยงกัน

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