မြန်မာဘာသာ
မြန်မာဘာသာ
PHP Development တွင် Array_Slice သည်သတ်မှတ်ထားသောအရှည်အပိုင်းအစများမှသတ်မှတ်ထားသောအရှည်အပိုင်းအစများကိုကြားဖြတ်ရန်အသုံးပြုသောအလွန်အသုံးများသောခင်းကျင်းမှုလုပ်ငန်းလည်ပတ်မှုဖြစ်သည်။ ၎င်း၏အခြေခံအသုံးပြုမှုသည်ရိုးရှင်းပြီးရှင်းရှင်းလင်းလင်းရှိကြောင်း,
ဤဆောင်းပါးသည်မှတ်ဥာဏ်သုံးစွဲမှုလုပ်ငန်းစီမံခန့် ခွဲ မှု၏မှတ်ဉာဏ်အသုံးပြုမှုယန္တရားကိုဆန်းစစ်ကြည့်ရှုလိမ့်မည်။
array_slice (array $ array, int $ unraset, int $ အရှည် = null $ အရှည် = NULL $ + bool, bool $ present_keys = false
$ array : ခင်းကျင်းရေးထည့်ပါ
$ offset : အနေအထားစတင်
$ အရှည် : အရှည်ကိုကြားဖြတ် (optional ကို)
$ Present_Keys : မူရင်းခင်းကျင်းသော့ချက်ကိုဆက်လက်ထိန်းသိမ်းရန်ရှိမရှိ, ၎င်းကိုပုံမှန်အားဖြင့်မထိန်းသိမ်းနိုင်ခြင်း (အဓိကအမည်များကိုပြန်လည်ညွှန်းကိန်း)
array_slice သည် input array အပိုင်းအစတစ်ခုသို့ပြန်လာလိမ့်မည်။ function သည်ဒေတာ၏ဤအပိုင်းကိုပြန်ပို့ရန်အသစ်တစ်ခုကိုပြန်လည်ပတ်ရန်အသစ်တစ်ခုကိုကူးယူလိမ့်မည်။
Array အရွယ်အစားသည်သေးငယ်သောအခါ array_Slice ၏မှတ်ဉာဏ်ခြေရာသည်များသောအားဖြင့်အာရုံစူးစိုက်မှုကိုမဆွဲဆောင်ပါ။ သို့သော်သန်းပေါင်းများစွာသောသို့မဟုတ်သန်းပေါင်းများစွာသောဒြပ်စင်များရှိသည့်များစွာသောအရာများကိုပင်ရင်ဆိုင်နေရသောအခါ array_slice ၏မရေတွက်နိုင်သောမှတ်ဉာဏ်သည်နိုးနိုးကြားကြားရှိထိုက်သည်။
Array_Slice သည် မူရင်းခင်းကျင်းမှုကိုကိုးကားခြင်းသို့မဟုတ်ကြားဖြတ်ခြင်းမရှိပါ။ အဓိပ်ပါယျမှာ:
အကယ်. မူရင်းခင်းကျင်းသည် X ကို Memory ကိုယူလျှင်,
အရှည် y snippets,
Reweed New Array အသစ်သည်ခန့်မှန်းခြေအားဖြင့် Y ၏အရွယ်အစားနှင့်အမျှမှတ်ဥာဏ်တူညီသည်။
အကယ်. ကြားဖြတ်ပုံပျက်နေပါကမှတ်ဉာဏ်အသုံးပြုမှုသည်နှစ်ဆသို့မဟုတ်ထိုထက်မက (မူရင်းခင်းကျင်းမှုနှင့်) ။
<?php
// စူပါကြီးမားသောခင်းကျင်းမှုကိုတုပပါ
$largeArray = range(1, 10_000_000);
// Array အလယ်၌ဒေတာတစ်သန်းကိုထုတ်ယူပါ
$startTime = microtime(true);
$slice = array_slice($largeArray, 4_000_000, 1_000_000);
$endTime = microtime(true);
echo "အချိန် - စားသုံးမှုကြားဖြတ်：" . ($endTime - $startTime) . "စက်ဏန့်\n";
echo "မူရင်းခင်းကျင်းမှတ်ဉာဏ်：" . (memory_get_usage() / 1024 / 1024) . " MB\n";
// တစ်စိတ်တစ်ပိုင်းကြားဖြတ်ရလဒ်များကိုရယူပါ
echo "ပထမ ဦး ဆုံးဒြပ်စင်အချပ်：" . $slice[0] . "\n";
?>
သင်ဤကုဒ်ကိုဖွင့်သောအခါ,
ဇာတ်ညွှန်းကသိမ်းပိုက်ထားသောမှတ်ဉာဏ်သည်သိသိသာသာတိုးပွားလာသည် (မူရင်းခင်းကျင်း + + array)
ပရိုဂရမ်၏ကွပ်မျက်မှုအချိန်သည်သာမာန်သေးငယ်သည့်ခင်းကျင်းမှုလုပ်ငန်းများနှင့်နှိုင်းယှဉ်လျှင်သိသိသာသာသိသိသာသာတိုးပွားလာသည်။
array_slice သည် ကြီးမားသောခင်းကျင်းမှုများကိုကိုင်တွယ်ဖြေရှင်းသည့်အခါစူပါကြီးမားသောခင်းကျင်းမှုများကိုကိုင်တွယ်သောအခါမှတ်ဉာဏ်အသုံးပြုမှုတွင်သိသိသာသာတိုးပွားစေသည်။
Array Data သည်ဖိုင် (သို့) ဒေတာဘေ့စ်တစ်ခုမှလာသည်ဆိုပါက၎င်းကိုစာဖတ်ခြင်းအားဖြင့်စာဖတ်ခြင်းကိုစဉ်းစားပါ။
အချက်အလက်များ၏သေးငယ်သောအစိတ်အပိုင်းတစ်ခုသာလိုအပ်ပါက array_slice မှကြားဖြတ်ကြားဖြတ်သည့်အပိုင်းအစငယ်များသည်မှတ်ဥာဏ်နည်းပြီးသက်ရောက်မှုအနည်းငယ်သာရှိသည်။
PHP ၏ ITERATER Interface ( MARKERTERTERTERTATER Interface) သည်အလားတူကြားဖြတ်မြင်ကွင်းကိုမကူးယူဘဲမိတ္တူကူးခြင်းမပြုဘဲအောင်မြင်နိုင်သည်။
ဥပမာ -
<?php
$array = new ArrayIterator(range(1, 10_000_000));
$iterator = new LimitIterator($array, 4_000_000, 1_000_000);
foreach ($iterator as $value) {
// ကိုင်တွယ်ဖြေရှင်းသည်$value
}
?>
၎င်းသည် array များကိုကူးယူခြင်းနှင့်မှတ်ဉာဏ်ကိုသိမ်းဆည်းခြင်းကိုရှောင်ရှားသည်။
Array_SLICE ကို အသုံးပြုရပါက PHP ၏မှတ်ဉာဏ်အကန့်အသတ်မဲ့ သော Memory_Limit သည် ပရိုဂရမ်၏ပုံမှန်မဟုတ်သောရပ်စဲမှုကိုရှောင်ရှားရန်လုံလောက်သောကြီးမားသည်ကိုသေချာအောင်လုပ်ပါ။
String_Slice function သည် Super Cuppress ကြီးမားသောခင်းကျင်းမှုများကိုလုပ်ဆောင်သောအခါ Memory အသုံးပြုမှုသိသိသာသာတိုးပွားလာစေမည့် Strings array အပိုင်းအစများကိုကူးယူသည်။ အကယ်. သင်သည်သန်းပေါင်းများစွာသောသန်းပေါင်းများစွာများများနှင့်ရင်ဆိုင်နေရပါကမှတ်ဉာဏ်ပိတ်ဆို့မှုများနှင့်တည်ငြိမ်မှုကိုတိုးတက်စေရန် iterators သို့မဟုတ် chunked စာဖတ်ခြင်းကိုအသုံးပြုရန်စဉ်းစားရန်အကြံပြုသည်။
ပိုမို. PHP ကျွမ်းကျင်မှုများအတွက် ကျေးဇူးပြု. နောက်ဆုံးသင်ခန်းစာများနှင့်လက်တွေ့အတွေ့အကြုံများအတွက် https:/gitbox.net/php-tips များကို ဆက်သွယ်ပါ။
သက်ဆိုင်သောတက်(ဂ်)များ:
array_slice
