လက်ရှိတည်နေရာ: ပင်မစာမျက်နှာ> နောက်ဆုံးရဆောင်းပါးများစာရင်း> ထပ်ခါတလဲလဲအပြောင်းအလဲနဲ့ရှောင်ရှားရန်ရှည်လျားသော Array ကိုဖြတ်ဖို့ array_chunk ကိုအသုံးပြုနည်း

ထပ်ခါတလဲလဲအပြောင်းအလဲနဲ့ရှောင်ရှားရန်ရှည်လျားသော Array ကိုဖြတ်ဖို့ array_chunk ကိုအသုံးပြုနည်း

M66 2025-04-28

PHP တွင် array_chunk () function သည်အလွန်သေးငယ်သော strars များသို့ရှည်လျားသောခင်းကျင်းမှုကိုဖြတ်နိုင်သည့်အလွန်လက်တွေ့ကျသောကိရိယာတစ်ခုဖြစ်သည်။ ဤလုပ်ဆောင်မှုကိုအသုံးပြုခြင်းသည်ကြီးမားသောခင်းကျင်းမှုများကိုလုပ်ဆောင်ရန်အတွက်အထောက်အကူပြုနိုင်ပြီးကုဒ်၏ထိရောက်မှုကိုတိုးတက်စေရန်နှင့်တူညီသောအချက်အလက်များကိုထပ်ခါတလဲလဲအပြောင်းအလဲများကိုရှောင်ရှားနိုင်သည်။ အထူးသဖြင့်ဒေတာအစုများထုတ်လုပ်သည့်အခါ array_chunk () ကိုဆင်ခြင်တုံတရားအသုံးပြုခြင်းသည်ပရိုဂရမ်၏ကွပ်မျက်မှုစွမ်းဆောင်ရည်ကိုသိသိသာသာတိုးတက်စေနိုင်သည်။

1 ။ array_chunk () function ကိုခြုံငုံသုံးသပ်ချက်

array_chunk () function ကို array ကိုသေးငယ်တဲ့ arrays သို့ခွဲခြားထားပြီးသေးငယ်တဲ့ stray တစ်ခု၏အရှည်ကိုအသုံးပြုသူမှသတ်မှတ်သည်။ ဒီ function က parameters သုံးခုရရှိသည်:

 array_chunk(array $array, int $size, bool $preserve_keys = false) : array

  • $ array : ဖြတ်ခံရဖို့မူရင်းခင်းကျင်း။

  • $ အရွယ်အစား - သေးငယ်တဲ့ array တစ်ခုစီ၏အများဆုံးအရှည်။

  • $ Present_Keys : အကယ်. မှန်ကန် ပါကမူရင်းခင်းကျင်းမှု၏သော့အမည်ကိုထိန်းသိမ်းထားသည်။ အကယ်. မှားယွင်းသော် လျှင်ခင်းကျင်းခလုတ်ကိုပြန်လည်နေရာချထားသည်။

2 ။ array_chunk () code ထိရောက်မှုကိုတိုးတက်စေရန်

1 ။ ထပ်ခါတလဲလဲအပြောင်းအလဲနဲ့ရှောင်ကြဉ်ပါ

ကြီးမားသောခင်းကျင်းမှုကြီးများနှင့်ရင်ဆိုင်ရသောအခါကျွန်ုပ်တို့သည်ဤအချက်အလက်များကိုအသုတ်တွင်လေ့ကျင့်ရန်လိုအပ်သည်။ အကယ်. ကျွန်ုပ်တို့သည် array တစ်ခုလုံးကိုအချိန်အတိုင်းအတာတစ်ခုအထိလုပ်ဆောင်ပါကမှတ်ဥာဏ်အလွန်အကျွံသုံးစွဲခြင်း, Array_Chunk () အားဖြင့်ခင်းကျင်းမှုများကိုသေးငယ်သောအပိုင်းအစများသို့ဖြတ်တောက်ခြင်း () သည်မလိုအပ်သောလုပ်ဆောင်မှုများကိုလျှော့ချခြင်း,

2 ။ ကုဒ်ဥပမာ

ကျွန်ုပ်တို့တွင်အချက်အလက်အမြောက်အများပါ 0 င်သည့်အချက်များရှိပြီးဒေတာအနည်းငယ်ကိုဒေတာဘေ့စ်မေးမြန်းချက်များမှရရှိသောအချက်အလက်များဖြစ်နိုင်သည်ဆိုပါစို့။ array_chunk () function ကို အသုံးပြု. array တစ်ခုစီကို ဖြတ်. ခင်းကျင်းမှုတစ်ခုစီကို ဖြတ်. လုပ်ဆောင်ရန်ဥပမာတစ်ခုမှာဤတွင်ဖြစ်သည်။

 <?php
// ဒေတာအမြောက်အမြားပါဝင်သောတစ် ဦး ခင်းကျင်းတစ်ခုဖန်တီးပါ
$data = range(1, 10000);  // ထံမှတစ် ဦး generate1ရောက်လာ10000၏ခင်းကျင်း

// 每次处理၏ခင်းကျင်း大小为1000
$chunkedData = array_chunk($data, 1000);

// 遍历切割后၏ခင်းကျင်း，ပိတ်ပင်တားဆီးမှုအားဖြင့်ဒေတာပိတ်ပင်တားဆီးမှုလုပ်ငန်းစဉ်
foreach ($chunkedData as $chunk) {
    // ဒေတာတစ်ခုချင်းစီကိုအပိုင်းအစများ၏ processing ကိုတုပ，ဥပမာအားဖြင့်, ဒေတာဘေ့စ်စစ်ဆင်ရေးသို့မဟုတ်ဒေတာစီစစ်ခြင်းလုပ်ဆောင်ပါ
    // ဒီမှာကရိုးရှင်းတဲ့စစ်ဆင်ရေးတစ်ခုလို့ယူဆတယ်，ဥပမာအားဖြင့်, output ခင်းကျင်း၏အရှည်
    echo "တစ် ဦး ပါဝင်ဆောင်ရွက် processing " . count($chunk) . " ပစ္စည်းဒေတာ၏သေးငယ်တဲ့ခင်းကျင်း。\n";

    // တစ်ခုချင်းစီကိုအပြောင်းအလဲနဲ့ပြီးစီးပြီးနောက်，အပိုစစ်ဆင်ရေးလုပ်ပါ，ဥပမာအားဖြင့်,HTTPမေးမြန်း
    $url = "https://m66.net/api/handleData";  // ဒီဟာကယူဆတယ်APIမေးမြန်း
    $response = file_get_contents($url . '?data=' . urlencode(json_encode($chunk)));

    // ထုတ်ယူခြင်းတုံ့ပြန်မှု
    if ($response) {
        echo "ဒေတာအပြောင်းအလဲနဲ့အောင်မြင်ခဲ့သည်！\n";
    } else {
        echo "ဒေတာအပြောင်းအလဲနဲ့ပျက်ကွက်！\n";
    }
}
?>

ဤဥပမာတွင်ကျွန်ုပ်တို့သည် (1, 10000) ကို သုံး. Elements 10000 နှင့်အတူခင်းကျင်းမှုတစ်ခုပြုလုပ်ခဲ့သည်။ ထို့နောက် array_chunk () ကို သုံး. ဤပြ array ကိုအရှည် 1000 ရှိအောင်ပြုလုပ်ရန် () ကိုဖြတ်ရန်အသုံးပြုပါ။ ထို့နောက် stating foreach loop ကိုသုံးပါ။

သေးငယ်တဲ့ခင်းကျင်းမှုကိုပြုပြင်ပြီးတဲ့နောက်မှာတော့လုပ်ငန်းများ၌အချက်အလက်များကို https://m66.net/api/handledtata သို့ပို့သည်ဟုယူဆသော HTTP တောင်းဆိုမှုကိုဖန်တီးသည်။ လက်တွေ့ကျသော application များအရဤနည်းလမ်းကိုအသုတ် data သို့တင်ရန်သို့မဟုတ်ဒေတာဘေ့စ်လုပ်ငန်းများကိုလုပ်ဆောင်ရန်သို့မဟုတ်ဒေတာဘေ့စ်လုပ်ငန်းများစသည်တို့ကိုပြုလုပ်နိုင်သည်။

3 ။ တိုးတက်အောင်လုပ်ခြင်း၏အကျိုးကျေးဇူးများ

Array_chunk () ကိုခင်းကျင်းပြီးနောက်အချက်အလက်အားလုံးကိုတစ်ပြိုင်နက်တည်းဖွင့ ်. ပြုပြင်ခြင်းနှင့်ပြုပြင်ခြင်းကိုရှောင်ကြဉ်ခြင်း, ထို့အပြင် chunking တွင်ပြုပြင်ခြင်းအချက်အလက်များသည်အချက်အလက်အမြောက်အများကိုပြုပြင်ခြင်းကြောင့်ဆာဗာကိုထိရောက်စွာတုန့်ပြန်မှုသို့မဟုတ်နှေးကွေးစွာတုံ့ပြန်မှုများမှလည်းထိရောက်စွာတားဆီးနိုင်သည်။

3 ။ လက်တွေ့ကျသော application အခြေအနေများ

  1. ကြီးမားသောဒေတာအပြောင်းအလဲနဲ့ <br> <br> ဒေတာအစုအမျိုးမျိုးကိုထုတ်လုပ်သည့်အခါအများအပြား data_chunk () ဖျက်ပစ်ရန်အတွက်ဒေတာဘေ့စ်မှမှတ်တမ်းအမြောက်အများကို အသုံးပြု. မှတ်တမ်းများကို အသုံးပြု. array_chunk () ကိုဖြတ်တောက်ခြင်းကဲ့သို့သောမှတ်တမ်းများကို အသုံးပြု. လုပ်ငန်းလည်ပတ်မှုများကိုပိုမိုထိရောက်စွာသုံးစွဲနိုင်သည်

  2. Batch API တောင်းဆိုမှုများ <br> <br> အကယ်. API လိပ်စာအချို့ကိုဒေတာအမြောက်အများကိုပေးပို့ရန်လိုအပ်ပါကအချက်အလက်များကိုသေးငယ်သောလုပ်ကွက်များအဖြစ်ဖြတ်တောက်နိုင်ပြီးအလွန်အကျွံအချက်အလက်များကြောင့်ကွန်ယက်တောင်းဆိုမှုအချိန်ကုန်သို့မဟုတ်ဆာဗာ overload ကိုရှောင်ရှားရန်အချိန်အတန်ကြာပို့ဆောင်နိုင်သည်

  3. File Batch Prunterning <br> <br> ဖိုင်အမြောက်အများ (ဖိုင်တင်ခြင်း, download, download စသည်တို့) ကိုလုပ်ဆောင်သောအခါဖိုင်စာရင်းကိုအပိုင်းပိုင်း ဖြတ်. ဖိုင်များအားလုံးကိုတစ်ပြိုင်နက်တည်းတင်ခြင်းမှရှောင်ရှားနိုင်သည်။

4 ။ အကျဉ်းချုပ်

array_chunk () PHP တွင်အလွန်အစွမ်းထက်သော function တစ်ခုဖြစ်သည်။ ဒေတာအမြောက်အများကိုပြုပြင်ပြီးမလိုအပ်သောထပ်တူပြုခြင်းကိုရှောင်ရှားရာတွင်ကျွန်ုပ်တို့၏ code ၏စွမ်းဆောင်ရည်ကိုပိုမိုထိရောက်စွာအသုံးပြုခြင်းသည်ကျွန်ုပ်တို့အားကျိုးကြောင်းဆီလျော်စွာကူညီနိုင်သည်။ ဒေတာများကိုသေးငယ်သောအပိုင်းပိုင်းသို့ဖြတ်တောက်ခြင်းအားဖြင့်ကျွန်ုပ်တို့သည်မှတ်ဉာဏ်အသုံးပြုမှုကိုလျှော့ချနိုင်ရုံသာမကတုန့်ပြန်မှုမြန်နှုန်းနှင့်တည်ငြိမ်မှုကိုတိုးတက်စေသည်။

၎င်းသည်ကြီးမားသောအချက်အလက်များပြုပြင်ခြင်း, အသုတ် API တောင်းဆိုမှုများ, သို့မဟုတ်ဖိုင်စစ်ဆင်ရေး, array_chunk () file_chunk () သည်အလွန်အသုံးဝင်သောကိရိယာတစ်ခုဖြစ်သည်။ အမှန်တကယ်ဖွံ့ဖြိုးတိုးတက်မှုဖြစ်စဉ်တွင်ကျွန်ုပ်တို့သည်တိကျစွာ application အခြေအနေများအရ၎င်းကိုပြောင်းလွယ်ပြင်လွယ်ပြုတ်ကျနိုင်သည်, ပရိုဂရမ်စွမ်းဆောင်ရည်ကိုကောင်းမွန်အောင်ပြုလုပ်နိုင်သည်။

ဆက်စပ်အကြောင်းအရာ