পিএইচপি অ্যারেটি সহযোগী বা অনুক্রমিক কিনা তা কীভাবে পরীক্ষা করবেন?


780

পিএইচপি সমস্ত অ্যারেটিকে সহযোগী হিসাবে বিবেচনা করে, তাই কোনও কার্যক্রমে বিল্ট নেই। অ্যারেতে কেবল সংখ্যাসূচক কী রয়েছে কিনা তা পরীক্ষা করার জন্য কি কেউ যথেষ্ট দক্ষতার জন্য সুপারিশ করতে পারেন?

মূলত, আমি এর মধ্যে পার্থক্য করতে সক্ষম হতে চাই:

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

এবং এই:

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

382
আপনার কোডে একটি বাগ আছে: টমেটো একটি ফল fruit
ওলে হার্স্টেট

9
এই পদ্ধতিতে সতর্কতা রয়েছে তবে প্রায়ই আমি কেবল if (isset($array[0]))এটিই করি যা সহজ এবং দ্রুত। অবশ্যই, আপনার প্রথমে নিশ্চিত হওয়া উচিত যে অ্যারেটি খালি নয়, এবং অ্যারের সম্ভাব্য বিষয়বস্তু সম্পর্কে আপনার কিছুটা জ্ঞান থাকা উচিত যাতে পদ্ধতিটি ব্যর্থ হতে না পারে (যেমন মিশ্র সংখ্যাসূচক / সহযোগী বা অ-অনুক্রমিক)।
গ্রাস ডাবল

@ ওলেহর্স্টেট মার্কিন হাই কোর্ট অনুসারে নয় । ;-)
এমসি সম্রাট

উত্তর:


621

আপনি দুটি প্রশ্ন জিজ্ঞাসা করেছেন যা একেবারে সমতুল্য নয়:

  • প্রথমত, কীভাবে নির্ধারণ করতে হবে যে কোনও অ্যারেতে কেবল সংখ্যা কী রয়েছে কিনা
  • দ্বিতীয়ত, 0 থেকে শুরু করে কোনও অ্যারেটিতে ক্রমিক সংখ্যাযুক্ত কী রয়েছে কিনা তা কীভাবে নির্ধারণ করা যায়

আপনার আসলে কোনটি আচরণের প্রয়োজন তা বিবেচনা করুন। (এটি হতে পারে হয় আপনার উদ্দেশ্যে কাজ করবে))

প্রথম প্রশ্নের (কেবলমাত্র সমস্ত কীগুলি সংখ্যাসূচক কিনা তা পরীক্ষা করা) ক্যাপ্টেন কুওর দ্বারা উত্তরের উত্তর দেওয়া হয়েছে

দ্বিতীয় প্রশ্নের জন্য (অ্যারেটি শূন্য-সূচকযুক্ত এবং অনুক্রমিক কিনা তা পরীক্ষা করে), আপনি নিম্নলিখিত ফাংশনটি ব্যবহার করতে পারেন:

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

31
খুব মার্জিত সমাধান। মনে রাখবেন যে এটি খালি অ্যারের ক্ষেত্রে (অস্পষ্ট) ক্ষেত্রে সত্য দেয়।
জোনাথন লিডবেক

29
আমি মনে করি ক্রমানুসারে অ্যারেগুলি সহযোগী অ্যারেগুলির একটি বিশেষ ক্ষেত্রে হিসাবে ভাবা আরও কার্যকর। সুতরাং প্রতিটি অ্যারে সংঘবদ্ধ, তবে কেবল কয়েকটি ক্রমিক হয়। অতএব, একটি ফাংশন isSequential()তুলনায় আরও জ্ঞান করতে হবে isAssoc()। যেমন একটি ফাংশনে, খালি অ্যারেটি অনুক্রমিক হিসাবে দেখা উচিত । সূত্র হতে পারে array() === $arr || !isAssoc($arr)
donquixote

18
আমি মনে করি এটি প্রচুর সম্ভাব্য সিপিইউ সময় এবং মেমোরি এড়াতে পারে যদি কেউ পরীক্ষা করে যে কী কী ($ আরআর [0]) মিথ্যা আছে তা সমস্ত কীগুলি বের করার আগে যেমন স্পষ্টত সংশ্লেষী হয় যদি অ্যারেটি খালি না থাকে তবে 0 তে কোনও উপাদান নেই অবস্থান। "বেশিরভাগ" রিয়েল এসোসিয়েটিভ অ্যারেগুলিতে কী হিসাবে স্ট্রিং রয়েছে এটি এই জাতীয় ফাংশনটির সাধারণ ক্ষেত্রে একটি ভাল অপ্টিমাইজেশন হওয়া উচিত।
ওডারওয়াট

10
@ ওডারওয়াট - এর array_key_existsপরিবর্তে আপনার অপ্টিমাইজেশনটি ব্যবহার করা উচিত issetকারণ যদি শূন্য উপাদানটি নাল মান হয় তবে সেটটি ভুলভাবে ফিরে আসবে। একটি নাল মান সাধারণত এই জাতীয় অ্যারেতে একটি বৈধ মান হওয়া উচিত।
ওসিডিভ

@ এমসি চিত্রগ্রহ, আপনার সম্পাদনা কেন কোনও ব্যাখ্যা ছাড়াই ফাংশনটির আচরণ পরিবর্তন করেছে এবং গদ্যের বিবরণটিকে এটি আসলে কী করার কথা বলে তার বিরোধিতা করেছে। আমি এটিকে ফিরিয়ে দিয়েছি।
মার্ক অ্যামেরি

431

অ্যারেতে অ-পূর্ণসংখ্যা কী রয়েছে কিনা তা কেবল যাচাই করতে (অ্যারেটি ধারাবাহিকভাবে সূচকযুক্ত বা শূন্য-সূচকযুক্ত কিনা):

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

যদি কমপক্ষে একটি স্ট্রিং কী থাকে $arrayতবে এটি একটি সহযোগী অ্যারে হিসাবে বিবেচিত হবে।


22
এই পদ্ধতিটি মনে হয় এর চেয়ে অনেক ভাল। যদি গণনা (ফিল্টারড_আরে) == গণনা (আসল_আরে) হয় তবে এটি একটি সহযোগী অ্যারে। যদি গণনা (ফিল্টারড অ্যারে) == 0 হয় তবে এটি একটি সূচকযুক্ত অ্যারে। যদি গণনা (ফিল্টারড অ্যারে) <গণনা (মূল_আরে) হয় তবে অ্যারেতে সংখ্যাসূচক এবং স্ট্রিং কী রয়েছে has
জামোল

5
@ মাইকপ্রেটজলাও অবশ্যই এটি পুনরাবৃত্তি করে; অ্যারের সমস্ত কীগুলি অ্যারের সমস্ত কীগুলি না দেখে ইন্ট্রি হয় কিনা তা নির্ধারণ করার কোনও সম্ভাব্য উপায় নেই। আমি ধরে নিই যে অ-পুনরাবৃত্ত বিকল্পগুলি আমরা নীচে দেখতে পাব বলে মনে করি সেগুলি কি এর মতো $isIndexed = array_values($arr) === $arr;? আমি যা জিজ্ঞাসা করি: আপনি কীভাবে array_values()কাজ করেন বলে মনে করেন? আপনি কীভাবে ===অ্যারে কাজগুলিতে প্রয়োগ করেছেন বলে মনে করেন? উত্তর যে তারা অবশ্যই হয় এছাড়াও অ্যারের পুনরুক্তি উপর।
মার্ক আমেরিকা

4
@ARW "পিএইচপি মনে করতে পারে যদি এটি সম্ভব হয় তবে অ্যারে সংজ্ঞায় এটি সবকিছুই ফেলবে " " - হ্যাঁ, ঠিক তাই ঘটে। বৃহত্তম ডাব্লুটিএফ হ'ল এটি এটি ভাসমানদের জন্যও করে; যদি আপনি চেষ্টা করেন তবে var_dump([1.2 => 'foo', 1.5 => 'bar']);আবিষ্কার করবেন যে আপনি অ্যারেটি পেয়েছেন [1 => 'bar']। কীটির মূল প্রকারটি খুঁজে বের করার কোনও উপায় নেই। হ্যাঁ, এই সমস্ত ভয়ঙ্কর; পিএইচপি-র অ্যারেগুলি ভাষার সবচেয়ে খারাপ অংশ, এবং বেশিরভাগ ক্ষতি অপূরণীয় এবং প্রথাগত অ্যারে এবং aতিহ্যবাহী হ্যাশম্যাপগুলির জন্য একক নির্মাণকে প্রথম থেকেই ভয়ঙ্কর বলে ধারণা করার জন্য owণী।
মার্ক এ Amery

30
@ মার্কআমেরি উপরেরটি, সহজ সরল অবস্থায় অ্যারের 100% হাঁটার গ্যারান্টি দেয়। এটি আরও কার্যকর হবে, বিশেষত যদি আপনি বড় অ্যারেগুলির সাথে কাজ করে থাকেন, যদি আপনি স্ট্রিং বা ইন্টি পরীক্ষা করে থাকেন এবং প্রথম যেটি খুঁজে পেয়েছিলেন তা খুঁজে বের করে। উদাহরণস্বরূপ, function isAssociative($arr) { foreach ($arr as $key => $value) { if (is_string($key)) return true; } return false; }
চিন্তাধারা

1
@ ভেবেছিলেন আপনার কোডটি খুব দ্রুত কাজ করে তবে এটি অনুক্রমিক অ্যারে সনাক্ত করতে পারে না । উদাহরণ array(1 => 'a', 0 => 'b', 2 => 'c')হয়ে যাবে false(অনুক্রমিক অ্যারে) যখন এটি হওয়া উচিত true(এসসিয়েতিভ আরে)। টুলসকি.এ.ডাটা-স্ট্রাকচারস / অ্যারে- ইন- প্রোগ্রামিং আমি নিশ্চিত নই যে কী অবশ্যই অবশ্যই আরোহণের ক্রম হতে হবে? (0, 1, ...)
ভি

132

অবশ্যই এটি একটি ভাল বিকল্প।

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

52
এটি অ্যারেতে মানগুলি নকল করবে, যা সম্ভাব্যভাবে খুব ব্যয়বহুল। অ্যারে কীগুলি পরীক্ষা করা আপনি অনেক ভাল।
মেয়াগার

8
আমি সবেমাত্র ব্যবহার করেছি ==; আমি মনে করি না যে এখানে === এর প্রয়োজন আছে। তবে "আনসেটটি এবং এটি কার্যকর হয় না" এর উত্তর দেওয়ার জন্য: একবার আপনি প্রথম উপাদানটি আনসেট করে নিলে, এটি আর 0 থেকে শুরু করে পূর্ণসংখ্যা-সূচকযুক্ত অ্যারে হয় না So সুতরাং আইএমও এটি কাজ করে।
গ্রান্টপ্পার্ক ২২ শে

4
@Grantwparks এর সাথে সম্মত হন: একটি বিরল অ্যারে সূচিকৃত নয়। মজার বিষয় হল কারণ আসলে কোনও সূচকযুক্ত অ্যারে পিএইচপি এর মাঝখানে কোনও উপাদান মুছার উপায় নেই মূলত সমস্ত অ্যারেটিকে এসোসিয়েটিভ এবং সংখ্যা হিসাবে ঘোষণা করে কেবল সংস্করণটি 'আমার জন্য কী তৈরি করুন' সংস্করণ।
রিকমিশাম

7
আমার একমাত্র সমস্যাটি হ'ল ===মানগুলি সমান হয় কিনা তা যাচাই করে সময় নষ্ট করবে, যদিও আমরা কেবল কীগুলিতে আগ্রহী। এই কারণে আমি $k = array_keys( $arr ); return $k === array_keys( $k );সংস্করণটি পছন্দ করি ।
জেসি

5
একটি যুক্ত নোট, এটি ক্রমান্বয়ে অংকিত কীগুলি সহ নির্দিষ্ট করা অ্যারেগুলিতে ব্যর্থ হয়। যেমন $ myArr = অ্যারে (0 => 'এ', 3 => 'বি', 4 => 1, 2 => 2, 1 => '3'); চারপাশের একটি সম্ভাব্য কাজ পরীক্ষা চালানোর আগে ksort (r আরআর) চলছে
স্কট

77

এই প্রশ্নের অনেক মন্তব্যকারী পিএইচপি-তে কীভাবে অ্যারে কাজ করে তা বুঝতে পারেন না। থেকে অ্যারের ডকুমেন্টেশন :

কীটি হয় হয় পূর্ণসংখ্যা বা স্ট্রিং। যদি কোনও কীটি কোনও পূর্ণসংখ্যার মানক উপস্থাপনা হয় তবে এর অর্থ ব্যাখ্যা করা হবে (অর্থাত "8" টি 8 হিসাবে ব্যাখ্যা করা হবে, "08" "08" হিসাবে ব্যাখ্যা করা হবে)। কী-এর ফ্লোটগুলি পূর্ণসংখ্যার সাথে কাটা হয়। ইনডেক্সড এবং এসোসিয়েটিভ অ্যারে প্রকারগুলি পিএইচপিতে একই ধরণের, যা উভয়ই পূর্ণসংখ্যা এবং স্ট্রিং সূচকগুলি ধারণ করতে পারে।

অন্য কথায়, "8" এর অ্যারে কী হিসাবে তেমন কোনও জিনিস নেই কারণ এটি সর্বদা (নিঃশব্দে) পূর্ণসংখ্যায় রূপান্তরিত হবে 8 সুতরাং পূর্ণসংখ্যা এবং সংখ্যাযুক্ত স্ট্রিংগুলির মধ্যে পার্থক্য করার চেষ্টা করা অপ্রয়োজনীয়।

আপনি যদি অ্যারের অংশের একটি অনুলিপি (অ্যারে_কিজ () করেন) বা এটির সমস্ত (যেমন ফোরাচ করেন) তৈরি না করেই অ-পূর্ণসংখ্যা কীগুলির জন্য কোন অ্যারে যাচাই করার সর্বাধিক দক্ষ উপায় চান:

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

এটি কাজ করে কারণ বর্তমান অ্যারে অবস্থানটি অবৈধ হলে কী () NULL প্রদান করে এবং NUL কখনই একটি কার্যকর কী হতে পারে না (আপনি যদি NULL কে অ্যারে কী হিসাবে ব্যবহার করার চেষ্টা করেন তবে এটি নিঃশব্দে "" রূপান্তরিত হয়ে যায়)।


এটি অ-অনুক্রমিক পূর্ণসংখ্য কীগুলির জন্য কাজ করে না। [2 => 'এ', 4 => 'বি'] দিয়ে এটি ব্যবহার করে দেখুন।
ডেভিডজে

2
@ ডেভিডজে, "কাজ করে না" বলতে কী বোঝ? এটি সফলভাবে নির্ধারণ করে যে সমস্ত কীগুলি পূর্ণসংখ্যা। আপনি কি দাবি করছেন যে আপনি পোস্ট করেছেন এমন অ্যারেটিকে "সংখ্যাসূচক অ্যারে" হিসাবে বিবেচনা করা উচিত নয়?
coredumperror

7
একটি অ এসসিয়েতিভ আরে ছোটো থেকে চাবি থাকতে হবে 0থেকে count($array)-1এই যথাযথ ক্রমে। একটি প্রাথমিক চেক is_array()সাহায্য করতে পারে। মূল ক্রমটি পরীক্ষা করতে একটি বর্ধমান পরিবর্তনশীল যুক্ত করুন: for ($k = 0, reset($array) ; $k === key($array) ; next($array)) ++$k;এটি চুক্তি স্থির করে।
ofavre

2
foreachসুস্পষ্ট পুনরাবৃত্তির পরিবর্তে ব্যবহার করা প্রায় দ্বিগুণ দ্রুত।
ofavre

1
আপনি যদি এটি কোনও ফাংশন হিসাবে তৈরি করতে চান: function isAssocStr($array) { for (reset($array); is_int(key($array)); next($array)) { if (is_null(key($array))) return false; } return true; }
গ্রীক্যাট্রিনা

39

যেমনটি ওপি জানিয়েছে :

পিএইচপি সমস্ত অ্যারেটিকে সাহসী হিসাবে বিবেচনা করে

কোনও ফাংশন লিখতে এটি যথেষ্ট বুদ্ধিমানের নয় (আইএমএইচও) যা অ্যারেটি অ্যাসোসিয়েটিভ কিনা তা পরীক্ষা করে । প্রথম সুতরাং প্রথম জিনিস: পিএইচপি অ্যারের মধ্যে একটি কী কি :

কী হয় একটি হতে পারে পূর্ণসংখ্যা বা স্ট্রিং

তার মানে 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);
}

কেস ৩. কিছু কী স্ট্রিং , কিছু কী সংখ্যাসূচক / পূর্ণসংখ্যা হয়

দ্রষ্টব্য : এই ফাংশনটি খালি অ্যারেগুলির জন্যও সত্য ফিরে আসে ।

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

এটা যে অনুসরণ করে:


এখন, অ্যারের জন্য "জেনুইন" অ্যারে হওয়ার জন্য আমরা সবাই অভ্যস্ত, যার অর্থ:

  • এর কীগুলি সমস্ত সংখ্যা / পূর্ণসংখ্যা
  • এর কীগুলি ক্রমযুক্ত (অর্থাত্ 1 ধাপে বৃদ্ধি)।
  • এর কীগুলি শূন্য থেকে শুরু হয়

আমরা নিম্নলিখিত ফাংশন দিয়ে পরীক্ষা করতে পারেন।

কেস 3 এ। কীগুলি হ'ল সংখ্যাসূচক / পূর্ণসংখ্যা , অনুক্রমিক এবং শূন্য-ভিত্তিক

দ্রষ্টব্য : এই ফাংশনটি খালি অ্যারেগুলির জন্যও সত্য ফিরে আসে ।

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

গুহাত / সমস্যা

পূর্ণসংখ্যা কীগুলি

এই অ্যারেগুলির জন্য কীগুলি পূর্ণসংখ্যা :

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" castালাই করা হবে না, কারণ এটি কোনও বৈধ দশমিক পূর্ণসংখ্যা নয়।

উদাহরণস্বরূপ, এই অ্যারেগুলির জন্য কীটি পূর্ণসংখ্যা :

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.

কি আরো অনুযায়ী ডক ,

একটি পূর্ণসংখ্যার আকার প্ল্যাটফর্ম নির্ভর, যদিও সর্বাধিক প্রায় দুই বিলিয়ন মূল্য স্বাভাবিক মান (এটি 32 বিট স্বাক্ষরিত)। -৪-বিট প্ল্যাটফর্মগুলির উইন্ডোজ বাদে সাধারণত সর্বনিম্ন 9E18 এর মান থাকে, যা সর্বদা 32 বিট থাকে। পিএইচপি স্বাক্ষরবিহীন পূর্ণসংখ্যার সমর্থন করে না।

সুতরাং এই অ্যারের কীটি কোনও পূর্ণসংখ্যার হতে পারে বা নাও হতে পারে - এটি আপনার প্ল্যাটফর্মের উপর নির্ভর করে।

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

এমনকি খারাপ, পিএইচপি হতে থাকে বগী যদি পূর্ণসংখ্যা 2 কাছে 31 = 2,147,483,648 সীমানা (দেখুন বাগ 51430 , বাগ 52899 )। উদাহরণস্বরূপ, আমার স্থানীয় পরিবেশে (উইন্ডোজ 7 এ এক্সএএমপিপি 1.7.7 এ পিএইচপি 5.3.8) var_dump(array("2147483647" => "b"))দেয় , দেয়

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

তবে কোডপ্যাডের এই লাইভ ডেমোতে (পিএইচপি 5.2.5 ), একই অভিব্যক্তি দেয়

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

সুতরাং কীটি একটি পরিবেশে একটি পূর্ণসংখ্যা তবে অন্যটিতে স্ট্রিং , যদিও 2147483647বৈধ স্বাক্ষরিত 32-বিট পূর্ণসংখ্যা হয়


2
আমি নীচের হিসাবে উল্লেখ করেছি ব্যতীত, এটিতে যাচাই করা হচ্ছে এমনটির জন্য একটি সদৃশ অ্যারে তৈরি করা, এটি বড় অ্যারেগুলির জন্য খুব ব্যয়বহুল এবং ভাগ করা হোস্টগুলিতে মেমরির ক্রাশ না হওয়ার সম্ভাব্য উত্স তৈরি করে।
পদ্দপুত্র

35

গতি-অনুযায়ী:

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

স্মৃতি-অনুযায়ী:

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

নিম্নলিখিত অ্যারে: অ্যারে (02 => 11,1,2,456); উপরের অ্যালগরিদম ব্যবহার করে সংখ্যাসূচক কী না থাকা হিসাবে দেখানো হয়েছে, এমনকি যদি 02 === 2
গ্যালিলিও_গ্যালেলি

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

2
এটিই একমাত্র উত্তর (আমার মন্তব্যের সময়) যা নিম্নলিখিত বিষয়গুলির সাথে মোকাবিলা করতে পারে: ray অ্যারে = অ্যারে (0 => 'ব্লাহ', 2 => 'হ্যাঁ', 3 => 'ওয়াহে')
শাবিরোব

তবে array('1'=>'asdf', '2'=>'too')এটি প্রকৃতপক্ষে অ্যাসোসিয়েটিভ অ্যারে হিসাবে বিবেচিত হবে (কীগুলি আসলে স্ট্রিং)
ক্যাপ্টেন kurO

1
আপনার সম্পর্কে পছন্দ এটি একটি সহযোগী অ্যারে।
ডিভিস 1

1
trueকীগুলি হ'ল: শূন্য, পূর্ণসংখ্যা (কেবল ধনাত্মক), একটি খালি স্ট্রিং বা উপরের কোনও সংমিশ্রণ, যেমন স্ট্রিং "09" হিসাবে এই ফাংশনটি ফিরে আসে । এই ফাংশনটি কীগুলির ক্রমটিকে আমলে নেয় না। সুতরাং array(0=>'blah', 2=>'yep', 3=>'wahey'), array(0=>'blah', 2=>'yep', 1=>'wahey')এবং array('blah', 'yep', 'wahey')এই ফাংশন অনুসারে সমস্ত সহযোগী হয়, যদিও array('a'=>'blah', 'b'=>'yep', 'c'=>'wahey')তা নয়।
পাং

পছন্দ করুন '1' এবং '2' পূর্ণসংখ্যা হিসাবে সংরক্ষণ করা হবে। 11 মে, 2011 থেকে 19:34 এ কাঠবিড়ালির উত্তরের উদ্ধৃত অংশটি পড়ুন। পিএইচপি কোনও সংখ্যার মতো দেখতে স্ট্রিং কীগুলি সঞ্চয় করে না। এটি পূর্ণসংখ্যায় রূপান্তর করে।
বাটাল বুটকাস

20

আসলে সবচেয়ে দক্ষ উপায় হ'ল:

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

এটি কাজ করে কারণ এটি কীগুলি (যা ক্রমানুসারে অ্যারেগুলির জন্য সর্বদা 0,1,2 ইত্যাদি থাকে) কীগুলির কীগুলির সাথে তুলনা করে (যা সর্বদা 0,1,2 ইত্যাদি)।


1
চতুর, কিন্তু ভাল না। কেন এই "সবচেয়ে দক্ষ"? কেবল অ্যারে_কিজ ($ এ) এর সাথে পরিসীমা (0, গণনা ($ এ)) তুলনা করা আরও অনেক বেশি পঠনযোগ্য। সবচেয়ে চতুর সমাধানটি আমার অভিজ্ঞতার মধ্যে খুব কমই সেরা। বিশেষত যখন চালাক হওয়ার সময় স্পষ্টত এবং পরিষ্কার বিকল্পের চেয়ে আক্ষরিক কোনও মূল্য যুক্ত হয় না।
শেন এইচ

4
এই ফাংশনটি ফেরৎ trueজন্য array(1=>"a")কিন্তু falseজন্য array("a"=>"a")!=প্রতিস্থাপন করা হলে আরও অর্থবহ হবে !==
প্যাং

1
@ প্যাং আপনি সঠিক আছেন। আমি ভেবেছিলাম আপনার মন্তব্যটি অবশ্যই প্রথমে ভুল হতে হবে, তবে আমার আশ্চর্যজনকভাবে [0] == ['a']পিএইচপি-তে (যেহেতু 0 == 'a', এবং প্রকৃতপক্ষে 0 == 'banana')। পিএইচপি এর ==অপারেটর পাগল।
মার্ক আমেরিকা

2
এটি দক্ষ ইনফোফার নয় কারণ এতে অ্যারে_কিগুলি বনাম কল করা জড়িত you আপনি যেভাবেই হুডের নীচে এটি করছেন তবে আপনি ইতিমধ্যে একটি বড় অ্যারের সদৃশ করেছেন।
পডপোনসন

17

আমি উভয় ব্যবহার করেছি array_keys($obj) !== range(0, count($obj) - 1)এবং array_values($arr) !== $arr(যা একে অপরের ডুয়াল, যদিও দ্বিতীয়টি প্রথমটির চেয়ে কম সস্তা) তবে উভয়ই খুব বড় অ্যারেতে ব্যর্থ হয়েছে।

এটি কারণ array_keysএবং array_valuesউভয়ই খুব ব্যয়বহুল ক্রিয়াকলাপ (যেহেতু তারা মোটামুটি মূলের চেয়ে সম্পূর্ণ নতুন অ্যারে তৈরি করে)।

নিম্নলিখিত প্রদত্ত পদ্ধতিগুলির তুলনায় নিম্নলিখিত ফাংশনটি আরও দৃ rob়:

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ব্লক থেকে কেবল ফিরে আসতে পারেন ।

পরিশেষে, যদিও এই পৃষ্ঠায় অনেকগুলি "সমাধান" এর চেয়ে "মার্জিত" কম মনে হতে পারে, বাস্তবে এটি বেশ কার্যকর। প্রায় কোনও সাহসী অ্যারে তাত্ক্ষণিকভাবে সনাক্ত করা হবে। কেবলমাত্র সূচিকৃত অ্যারেগুলি সম্পূর্ণরূপে পরীক্ষা করা হবে এবং উপরে বর্ণিত পদ্ধতিগুলি কেবল সূচকযুক্ত অ্যারেগুলি সম্পূর্ণরূপে পরীক্ষা করে না, সেগুলি অনুলিপি করে।


13

আমি মনে করি নিম্নলিখিত দুটি ফাংশন 'যদি একটি অ্যারে সাহসী বা সংখ্যাসূচক হয় তবে' পরীক্ষা করার জন্য সেরা উপায় way যেহেতু 'সংখ্যাসূচক' বলতে কেবল সংখ্যাসূচক কী বা কেবল অনুক্রমিক সংখ্যাসূচক কীগুলি বোঝায় তাই দুটি ফাংশন নীচে তালিকাভুক্ত করা হয় যে কোনও শর্ত পরীক্ষা করে:

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

প্রতিটি কীটি একটি পূর্ণসংখ্যা মান কিনা তা প্রথম ফাংশনটি পরীক্ষা করে। দ্বিতীয় কার্যটি যাচাই করে যে প্রতিটি কীটি একটি সংখ্যার মান হয় এবং ততক্ষণে সমস্ত কীগুলি $ বেস থেকে অনুক্রমিকভাবে শুরু হয় কিনা তা যাচাই করে, যা ডিফল্ট 0 এবং যদি আপনাকে অন্য বেস মান নির্দিষ্ট করার প্রয়োজন না হয় তবে বাদ দেওয়া যেতে পারে। কী ($ my_array) শূণ্য ফিরে আসে যদি পাঠ পয়েন্টার অ্যারের শেষের দিকে চলে যায় তবে যা লুপের জন্য শেষ হয় এবং লুপের জন্য ফিরে আসার পরে বিবৃতিটি সত্য করে দেয় যদি সমস্ত কী পূর্ণসংখ্যা হয়। যদি তা না হয় তবে লুপটি অকালেই শেষ হয় কারণ একটি কী টাইপ স্ট্রিংয়ের এবং লুপের পরে বিবৃতিটি মিথ্যা প্রত্যাবর্তন করবে। পরের কীটি সঠিক মানের কিনা তা যাচাই করতে সক্ষম হওয়ার সাথে সাথে পরবর্তী তুলনায় প্রতিটি তুলনার পরে একটিতে to বেস যুক্ত করে। কঠোর তুলনা এটি কীটি টাইপ পূর্ণসংখ্যার কিনা তাও পরীক্ষা করে তোলে। ফর লুপের প্রথম বিভাগের $ বেস = (ইনট) $ বেস অংশটি বাদ দেওয়া যেতে পারে যখন $ বেসটি বাদ দেওয়া হয় বা আপনি যদি নিশ্চিত হন যে এটি কেবলমাত্র একটি পূর্ণসংখ্যা ব্যবহার করে ডাকা হবে। তবে যেহেতু আমি সবার জন্য নিশ্চিত হতে পারি না, তাই আমি এটিকে রেখে দিয়েছি any বিবৃতিটি কেবল একবারই কার্যকর করা হয়েছে, যাইহোক। আমি মনে করি এগুলি সবচেয়ে কার্যকর সমাধান:

  • স্মৃতি অনুসারে: ডেটা বা কী ব্যাপ্তির কোনও অনুলিপি নেই। একটি অ্যারে_ভ্যালু বা অ্যারে_কিগুলি করা কম মনে হতে পারে (কম কোড) তবে আপনি একবার কল করার পরে পটভূমিতে কী ঘটে তা মনে রাখবেন। হ্যাঁ অন্য কয়েকটি সমাধানের তুলনায় আরও (দৃশ্যমান) বক্তব্য রয়েছে, তবে এটিই গণ্য হয় না, তাই না?
  • সময় অনুসারে: ডেটা এবং / অথবা কীগুলি অনুলিপি / নিষ্কাশন করতে সময় লাগে তা ছাড়াও এই সমাধানটি পূর্বাভাস করার চেয়ে আরও কার্যকর। আবার কোনও ফোরচ কারও কারও কাছে বেশি দক্ষ বলে মনে হতে পারে কারণ এটি স্বাক্ষরকরণের চেয়ে কম, তবে ব্যাকগ্রাউন্ড ফরচারে রিসেট, কী এবং এর পাশের লুপিংয়ের কথাও বলে। তবে এ ছাড়া এটি শেষ শর্তটি যাচাই করার জন্য বৈধও বলে which

মনে রাখবেন যে অ্যারে কী কেবলমাত্র একটি পূর্ণসংখ্যা বা একটি স্ট্রিং হতে পারে এবং "1" (তবে "01" নয়) এর মতো কঠোরভাবে সংখ্যাসূচক স্ট্রিং একটি পূর্ণসংখ্যায় অনুবাদ করা হবে। আপনি যদি অ্যারেটিকে ক্রমিক হতে চান তবে একটি পূর্ণসংখ্যা কীটি কেবলমাত্র প্রয়োজনীয় অপারেশনটি পরীক্ষা করে তোলে makes স্বাভাবিকভাবেই, যদি is_indexed_array মিথ্যা দেয় তবে অ্যারেটিকে সহযোগী হিসাবে দেখা যেতে পারে। আমি বলি 'দেখেছি', কারণ বাস্তবে তারা সবাই।


1
এটি সেরা উত্তর। "সহযোগী" বা "সংখ্যাসূচক" অ্যারের সংজ্ঞা নির্দিষ্ট পরিস্থিতির উপর নির্ভর করে।
পাতো

যদি এখানে পূর্বে ব্যবহৃত পদ্ধতিটির তুলনায় ফোরচ কম দক্ষ হয় তবে দুটি পৃথক ফাংশন ব্যবহারের অসুবিধা বাদ দিয়ে এই দ্রষ্টব্যটির পারফরম্যান্স আমার (পূর্ববর্তী) থেকে ভাল। আমার সন্দেহ হয় এটি তা নয়, কারণ অ্যারে দিয়ে যাওয়ার দ্রুততম উপায় হিসাবে ভবিষ্যদ্বাণী সুপারিশ করা হয়।
পোষ্টারপসন

7

এই ফাংশনটি পরিচালনা করতে পারে:

  • সূচীতে গর্ত সহ অ্যারে (উদাহরণস্বরূপ 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;
}

1
"কীগুলির মধ্যে একটি যদি পূর্ণসংখ্যা না হয় তবে এটি সাহসী অ্যারে হয়, অন্যথায় এটি ক্রমিক হয়" - হু? না, এটি কেবল ভুল। "সহযোগী" অ্যারের গঠন কী তা নিয়ে তর্ক করার জায়গা রয়েছে তবে "ক্রমবর্ধমান" এর অর্থটি বেশ স্পষ্ট নয়, এবং এটি সমস্ত কী সংখ্যার মতো নয়।
মার্ক আমেরিকা

কীগুলির মধ্যে একটি যদি পূর্ণসংখ্যা না হয় এটি প্রকৃতির দ্বারা সংযুক্তিযুক্ত, তবে, কীগুলি 0 - দৈর্ঘ্য (অ্যারে) - 1 থেকে চলে গেলে এটি কেবল অনুক্রমিক হয় তবে সমস্ত কীগুলি কেবলমাত্র সংখ্যাযুক্ত থাকলেও এটি হতে পারে বা অনেক অ্যারে ফাংশনগুলির সাথে কাজ না করতে পারে যার জন্য অনুক্রমের অ্যারে প্রয়োজন। আপনি যদি তার উপর অ্যারে_ভ্যালু (অ্যারে) চালিয়ে গর্তের সাথে সংখ্যাসূচক অ্যারেটিকে ক্রমিক হিসাবে রূপান্তর করেন তবে এটি ক্রমিকের ক্ষেত্রে রূপান্তরিত হবে।
জেল

7

আমি এই প্রশ্নের জন্য দুটি জনপ্রিয় পন্থা লক্ষ্য করেছি: একটি ব্যবহার 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";

CentOS এ পিএইচপি 5.2 এ প্রোগ্রামের আউটপুট নিম্নরূপ:

পদ্ধতির সাথে নেওয়া সময় # 1 = 10.745ms
সময় # 2 = 18.239ms পদ্ধতিতে নেওয়া

পিএইচপি 5.3 এ আউটপুট অনুরূপ ফলাফল পেয়েছে। স্পষ্টতই ব্যবহার array_values()করা আরও দ্রুত।


খারাপ মানদণ্ড। আপনি বড় অ্যারে পরীক্ষা করেননি। আমার কম্পিউটারে 10K + এলিমেন্ট পদ্ধতিতে শুরু # 2 দ্রুত হয়। দিয়ে চেষ্টা$arrays = Array( 'Array #1' => range(0, 50000), );
nonsensei

7

এর নিকটবর্তী হওয়ার একটি উপায় হল পিগিগ্যাক অন json_encode, যা ইতিমধ্যে সঠিক জেএসওএন আউটপুট দেওয়ার জন্য একটি এসোসিয়েটিভ অ্যারে এবং একটি সূচকযুক্ত অ্যারের মধ্যে পার্থক্য করার নিজস্ব অভ্যন্তরীণ পদ্ধতি রয়েছে।

এনকোডিংয়ের পরে প্রথম অক্ষরটি {(এসোসিয়েটিভ অ্যারে) বা একটি [(সূচকযুক্ত অ্যারে) কিনা তা পরীক্ষা করে আপনি এটি পরীক্ষা করে দেখতে পারেন ।

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

Ksort () আমার মতে প্রয়োজনীয় নয়। এই সমাধানটি কাজ করছে তবে এটি পরীক্ষা করতে হবে যদি $ অর নাল হয় এবং যদি json_encode ব্যর্থ হয়, তাই চেষ্টা করুন / ধরুন। $ আরআর বড় হলে এটি সর্বোত্তম নয়।
lucbonnin

7

ইতিমধ্যে অনেক উত্তর রয়েছে, তবে লারাভেল তার আরার শ্রেণীর মধ্যে নির্ভর করে এমন পদ্ধতিটি এখানে:

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


1
@ ক্যাসি array_keys($keys)সংখ্যার ক্রমানুসারে অ্যারে (0 ... এক্স) ফিরিয়ে দেবে যার মূল অ্যারের একই দৈর্ঘ্য রয়েছে। উদাহরণস্বরূপ array_keys(["a", "b", "c"]) = [0, 1, 2]; array_keys([0, 1, 2]) = [0, 1, 2](এটি একটি ক্রমযুক্ত অ্যারে কারণ [0, 1, 2] !== [0, 1, 2])। আর একটি উদাহরণ: array_keys(["a" => 5, "b" => 7, "c" => 10]) = ["a", "b", "c"]; array_keys(["a", "b", "c"]) = [0, 1, 2](এটি একটি সহযোগী অ্যারে কারণ ["a", "b", "c"] !== [0, 1, 2])। আশা করি এটি পরিষ্কার (কমেন্টে আমার পক্ষে কমেন্টে বিস্তারিত ব্যাখ্যা করা কঠিন)
ভ্যালপু

এই অ্যালগরিদমটি পাগল, সহজ, বোধগম্য।
বেনি

আপনার যদি সহযোগী সারিগুলির ক্রমিক ক্রম থাকে তবে এটি কাজ করবে না।
lucbonnin

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

দ্রুত, সংক্ষিপ্ত এবং মেমরি দক্ষ। কোনও ব্যয়বহুল তুলনা, ফাংশন কল বা অ্যারে অনুলিপি নেই।


4

এক্সারে পিএইচপি এক্সটেনশন ব্যবহার করে

আপনি এটি খুব দ্রুত করতে পারেন (পিএইচপি 5.6-এ প্রায় 30+ গুণ বেশি দ্রুত):

if (array_is_indexed($array)) {  }

বা:

if (array_is_assoc($array)) {  }

3

আমি জানি যে এই বিশাল কাতারে একটি উত্তর যুক্ত করা কিছুটা অর্থহীন, তবে এখানে একটি পঠনযোগ্য ও (এন) সমাধান যা কোনও মানকে নকল করার প্রয়োজন নেই:

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

কীগুলি সমস্ত সংখ্যাসূচক কিনা তা পরীক্ষা করার পরিবর্তে আপনি যে কীগুলি সংখ্যাসূচক অ্যারে থাকবেন সেগুলি দিয়ে পুনরাবৃত্তি করুন এবং নিশ্চিত করুন যে সেগুলি বিদ্যমান আছে।


আরও একটি বিষয়। আকারে অ্যারে [1,2,null,4]ব্যর্থ হবে, তবে এটি সঠিক অ্যারে। তাই আমি কিছু বর্ধিতকরণ জুড়েছেন stackoverflow.com/a/25206156/501831 সঙ্গে উপরন্তু array_key_existsচেক)
lazycommit

-1; isset()এটি এখানে ভুল সরঞ্জাম কারণ মানটি সেট করা থাকলে এটি মিথ্যা ফিরে আসবে তবে null@ লাজিকমিট দ্বারা নির্দেশিত হিসাবে এটি রয়েছে।
মার্ক আমেরিকা

3

আমার সমাধান:

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 থেকে শুরু করে পুনরায় সংশ্লেষ করা হয়।


-1; এটি O(n)অতিরিক্ত ব্যবহৃত স্মৃতিতে ব্যবহৃত হয়েছে (যেহেতু এটি অনেকগুলি উপাদান সহ একাধিক নতুন অ্যারে তৈরি করেছে $array), উত্তরটি জিজ্ঞাসা করা প্রশ্নটির অস্পষ্টতাকে সম্বোধন করে না বা এটি তালিকা / অ-অ্যাসোসিয়েটিভ অ্যারে কীভাবে সংজ্ঞায়িত করছে ঠিক তা ব্যাখ্যা করে না even যদি এই পয়েন্টগুলির দুটিই সত্য না হয় তবে এটি পরিষ্কার নয় যে এটি ইতিমধ্যে পোস্ট করা অন্যান্য উত্তরগুলির তুলনায় কোনও মান যুক্ত করে।
মার্ক আমেরিকা

3

কিছু স্থানীয় বেঞ্চমার্কিং, ডিবাগিং, সংকলক অনুসন্ধান, প্রোফাইলিং, এবং আরও 3 টি সংস্করণ জুড়ে 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";
}

2

আমি যে পদ্ধতিটি ব্যবহার করি তা এখানে:

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

দুঃখিত, এটি আপনাকে সাহায্য করতে পারে না। এটি শালীন আকারের অ্যারেগুলির জন্য কিছুটা পারফর্ম্যান্ট, কারণ এটি অনাবশ্যক অনুলিপিগুলি তৈরি করে না। এই ছোট্ট জিনিসগুলি পাইথন এবং রুবিকে লিখতে এত সুন্দর করে তোলে ...: পি


2
<?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)


+1 আপনার is_list () হ'ল IMO সেরা উত্তর। কিছু লোকের সময় ও স্থানের জটিলতা, এবং নেটিভ বনাম পিএইচপি স্ক্রিপ্টেড ফাংশন সম্পর্কে কোনও ধারণা থাকে না ...
e2-e4

2

এটি খুব কার্যকর হবে ( ডেমো ):

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

দয়া করে নোট করুন যে এই উত্তরের মূল বিষয়টি আপনাকে SplFixedArrayএই ধরণের পরীক্ষার জন্য ব্যতিক্রমগুলি ব্যবহার করতে উত্সাহিত করা এবং তার অস্তিত্ব সম্পর্কে অবহিত করা নয়।


2

আমি মনে করি একটি স্কেলারের অ্যারের সংজ্ঞা প্রয়োগ অনুসারে পৃথক হবে। এটি হ'ল, কিছু অ্যাপ্লিকেশনের ক্ষেত্রে স্কেলারের অ্যারে হিসাবে কী যোগ্যতা অর্জন করা যায় তার আরও কঠোর বোধ প্রয়োজন এবং কিছু অ্যাপ্লিকেশনগুলিকে আরও শিথিল বোধের প্রয়োজন হয়।

নীচে আমি পৃথকীকরণের কঠোরতার 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;
}

2

উত্স থেকে আরও একটি দ্রুত । 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__)
        );
    }
}

1
কেন issetএবং array_key_exists? পরেরটি কি যথেষ্ট হবে না?
এমসিএফিডার

@ এমসিএফিডার হ্যাঁ, এটি হবে - isset()চেকটি সম্পূর্ণ অপ্রয়োজনীয়।
মার্ক আমেরিকা

@ এমসিএফিডার, কার্য সম্পাদনের কারণে @ মার্ক-অ্যামেরি। isset()তুলনায় দ্রুত array_key_exists()। দেখতে ilia.ws/archives/...
lazycommit

@ লাজি কমিট এটি আপনার অ্যারের উপর নির্ভর করে তার উপর নির্ভর করে তার সাথে আরও ভাল বা না ছাড়াই, এটির প্রচুর পরিমাণে অ্যারে থাকার সম্ভাবনা নেই, তবে এটিরও nullসম্ভবত আপনার যথেষ্ট পরিমাণে অ্যারে নেই যে লক্ষণীয় পারফরম্যান্স পার্থক্য হতে পারে উভয় চেক ব্যবহার করে
ম্যাকফেডার

2
যদি এটি মাপসই করা হবে চেক করতে হবে যদি json_encode, আপনি কেবল স্ট্রিং এর প্রথম প্রতীক, দ্বারা ফিরে চেক পারে json_encode($your_arr)- এটা কিনা [বা {;-)
pilat

2

এটি কি সমাধান হতে পারে?

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

ক্যাভিয়েট স্পষ্টতই অ্যারে কার্সারটি পুনরায় সেট করা হয়েছে তবে আমি বলব অ্যারে এমনকি ট্র্যাভারসড বা ব্যবহারের আগে সম্ভবত ফাংশনটি ব্যবহৃত হয়েছিল।


এই ফাংশনটি উভয়ের জন্যই মিথ্যা প্রত্যাবর্তন করে array("a", "b")এবং array("a", "b" => "B")এটি কেবল প্রথম কীটি পরীক্ষা করে। বিটিডাব্লু, is_longএর মাত্র একটি উপনামis_int
পাইং

1
বেশ খোলামেলাভাবে আমি মনে করি এটি সংখ্যাগরিষ্ঠ ক্ষেত্রে কার্যকর হবে এবং বিকল্পগুলির চেয়ে অনেক বেশি কার্যকর। যদি আপনি এই পদ্ধতির পরিণতি বুঝতে পেরে থাকেন এবং বুঝতে পারেন যে এটি আপনার পক্ষে কার্যকর হবে তবে এটি সম্ভবত সেরা পছন্দ।
গেরশম

এটি কেবল ভুল; এটি কেবল প্রথম কীটি দেখায়।
মার্ক আমেরিকা

@MarkAmery প্রশ্ন পার্থক্য কিভাবে জিজ্ঞাসা বিশুদ্ধরূপে থেকে অনুক্রমিক অ্যারে বিশুদ্ধরূপে মিশুক অ্যারে। এই উত্তরটি হুবহু এটি করে এবং সেগুলির মধ্যে সবচেয়ে দক্ষ। মিশ্র অ্যারেগুলির জন্য অপরিজ্ঞাত আচরণ করা প্রশ্নের প্রসঙ্গে পুরোপুরি সূক্ষ্ম। +1
টোবিয়া

@ টোবিয়া আমি ভাবি না যে বেশিরভাগ লোকেরা আপনার সাথে শ্রেণিবদ্ধের সাথে একমত হবেন, বলুন, [7 => 'foo', 2 => 'bar']একটি "মিশ্র" অ্যারে হিসাবে যা আংশিক কিন্তু "খাঁটি" অনুক্রমিক নয়। এটি আমার কাছে স্পষ্টভাবে ভুল শব্দের ব্যবহার বলে মনে হচ্ছে।
মার্ক আমেরিকা

2

এখানে অনেকগুলি সমাধান মার্জিত এবং সুন্দর, তবে ভাল স্কেল করে না এবং মেমরি নিবিড় বা সিপিইউ নিবিড়। তুলনা উভয় পক্ষ থেকে এই সমাধান সহ বেশিরভাগ 2 টি নতুন ডেটা পয়েন্ট তৈরি করছে। আরও বেশি অ্যারে ব্যবহার করা শক্ত এবং দীর্ঘতর প্রক্রিয়া এবং মেমরি ব্যবহৃত হয় এবং আপনি শর্ট সার্কিট মূল্যায়নের সুবিধা হারাবেন। আমি কয়েকটি ভিন্ন ধারণা দিয়ে কিছু পরীক্ষা করেছি। ব্যয়বহুল হওয়ায় অ্যারে_কি_এক্সেস্টগুলি এড়াতে চেষ্টা করা এবং তুলনা করার জন্য নতুন বড় ডেটাসেট তৈরি করা এড়ানো। আমি মনে করি এটি অ্যারে ক্রমযুক্ত কিনা তা বলার একটি সহজ উপায়।

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 থেকে গণনা করা উচিত। যদি এটি ব্যর্থ হয় তবে এটি শর্ট সার্কিট হয়ে যাবে যা এটি মিথ্যা হলে আপনাকে পারফরম্যান্স বাড়িয়ে তোলে।

মূলত আমি এটি লুপের জন্য এবং আইসেটের জন্য পরীক্ষা করে ($ আরআর [$ i]) দিয়েছিলাম তবে এটি নাল কীগুলি সনাক্ত করতে পারে না যার জন্য অ্যারে_কি_এক্সবাদীদের প্রয়োজন হয় এবং আমরা জানি যে গতির জন্য ব্যবহার করা সবচেয়ে খারাপ কাজ।

পুনরাবৃত্তির পূর্বে কখনও এটির পূর্ণসংখ্যার আকার বাড়তে পারে না তার সাথে পরীক্ষা করার জন্য নিয়মিতভাবে ভেরিয়েবলগুলি আপডেট করে আসুন পিএইচপি আপনাকে মেমরি অপটিমাইজেশন, ক্যাশে এবং আবর্জনা সংগ্রহের ক্ষেত্রে এটি তৈরি করে আপনাকে খুব কম সংস্থান ব্যবহারের জন্য ব্যবহার করে।

এছাড়াও, আমি তর্ক করব যে অগ্রভাগে অ্যারে_কিগুলি ব্যবহার করা নির্বোধ যখন আপনি কেবল $ কী => $ মান চালাতে পারেন এবং কীটি পরীক্ষা করতে পারেন। নতুন ডাটা পয়েন্ট কেন তৈরি করবেন? একবার আপনি অ্যারে কীগুলি বিমূর্ত করে ফেললে আপনি তত্ক্ষণাত আরও মেমরি গ্রাস করলেন।


1

উত্তরগুলি ইতিমধ্যে দেওয়া হয়েছে তবে কর্মক্ষমতা সম্পর্কে খুব বেশি ডিসিনফর্মেশন রয়েছে। আমি এই ছোট্ট বেঞ্চমার্ক স্ক্রিপ্টটি লিখেছি যা দেখায় যে ফোরচ পদ্ধতিটি দ্রুততম।

দাবি অস্বীকার: নিম্নলিখিত পদ্ধতিগুলি অন্য উত্তরগুলি থেকে অনুলিপি করা হয়েছিল

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

1

অথবা আপনি কেবল এটি ব্যবহার করতে পারেন:

Arr::isAssoc($array)

অ্যারেতে কোনও অ-সংখ্যাসূচক কী রয়েছে কিনা তা যাচাই করবে :

Arr:isAssoc($array, true)

অ্যারে কঠোরভাবে ক্রমযুক্ত কিনা তা পরীক্ষা করতে ( 0 থেকে এন -1 পর্যন্ত স্বয়ংক্রিয় উত্পন্ন কী কী রয়েছে) )

এই লাইব্রেরি ব্যবহার করে ।


0

যদি পিএইচপি-র জন্য কোনও বিল্টিন না থাকে, আপনি এটি ও (এন) এর চেয়ে কম করতে পারবেন না - সমস্ত কীগুলির উপর অঙ্ক করা এবং পূর্ণসংখ্যার ধরণের জন্য পরীক্ষা করা। প্রকৃতপক্ষে, আপনি এটিও নিশ্চিত করতে চান যে কোনও ছিদ্র নেই, তাই আপনার অ্যালগরিদমটি দেখতে দেখতে পারে:

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

তবে কেন বিরক্ত করবেন? শুধু ধরুন অ্যারেটি আপনি যে ধরণের প্রত্যাশা করেন তা হল। যদি তা না হয় তবে এটি কেবল আপনার মুখে ফুঁকবে - এটি আপনার জন্য গতিশীল প্রোগ্রামিং! আপনার কোডটি পরীক্ষা করুন এবং সবকিছু ঠিকঠাক হবে ...


1
সাধারণত অ্যারে ধরে নেওয়া পছন্দসই ধরণটি যেতে হবে। তবে আমার ক্ষেত্রে আমি একটি বহুমাত্রিক অ্যারেটি লুপ করছি এবং প্রদত্ত নোডটি কোন ধরণের অ্যারের উপর নির্ভর করে আউটপুট ফর্ম্যাট করছি।
উইলকো

0

আমি অ্যারের কী এবং অ্যারের ফলাফলের কীগুলির (অ্যারে_ভ্যালু ()) এর মধ্যে পার্থক্যটি তুলনা করি, যা সর্বদা পূর্ণসংখ্যার সূচকগুলির সাথে একটি অ্যারে থাকবে। কীগুলি যদি একই হয় তবে এটি কোনও সহযোগী অ্যারে নয়।

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

-1; আইটেমগুলি থাকা O(n)অবস্থায় $arrayএটি অতিরিক্ত মেমরি ব্যবহার করে nএবং (someboolean) ? false : trueপরিবর্তে লেখাটি !somebooleanভয়াবহ এবং কৃতজ্ঞভাবে ভার্জোজ হয়।
মার্ক আমেরিকা
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.