අරාවෙහි පළමු අංගය ලබා ගන්න

මට පෙළක් තිබේ:

array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )

මෙම අරාවෙහි පළමු අංගය ලබා ගැනීමට මම කැමතියි. අපේක්ෂිත ප්‍රති result ලය: නූල් apple

එක් අවශ්‍යතාවයක්: එය යොමු කිරීමකින් කළ නොහැක , එබැවින් array_shiftහොඳ විසඳුමක් නොවේ.

මට මෙය කළ හැක්කේ කෙසේද?

මුල් පිළිතුර, නමුත් මිල අධික (O (n)):

array_shift(array_values($array));

O (1) හි:

array_pop(array_reverse($array));

වෙනත් භාවිත අවස්ථා, ආදිය ...

(අරාව දර්ශක නැවත සැකසීමේ අර්ථයෙන්) වෙනස් කිරීම $arrayගැටළුවක් නොවේ නම්, ඔබට මෙය භාවිතා කළ හැකිය:

reset($array);

අරාව "පිටපතක්" අවශ්‍ය නම් මෙය න්‍යායාත්මකව වඩා කාර්යක්ෂම විය යුතුය:

array_shift(array_slice($array, 0, 1));

PHP 5.4+ සමඟ (නමුත් හිස් නම් දර්ශක දෝෂයක් ඇතිවිය හැක):

array_values($array)[0];

මයික් පෙන්වා දුන් පරිදි (හැකි පහසුම ක්‍රමය):

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )
echo reset($arr); // Echoes "apple"

ඔබට යතුර ලබා ගැනීමට අවශ්‍ය නම්: (නැවත සැකසීමෙන් පසු එය ක්‍රියාත්මක කරන්න)

echo key($arr); // Echoes "4"

සිට PHP හි ප්රලේඛනය :

මිශ්‍ර යළි පිහිටුවීම (අරාව & $ අරාව );

විස්තර:

යළි පිහිටුවීම () අරාවේ අභ්‍යන්තර දර්ශකය පළමු මූලද්‍රව්‍යයට පෙරළා පළමු අරා මූලද්‍රව්‍යයේ අගය නැවත ලබා දෙයි, නැතහොත් අරාව හිස් නම් වැරදිය.

$first_value = reset($array); // First element's value
$first_key = key($array); // First element's key

$arr = $array = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'

වත්මන් දර්ශක ස්ථානය නැති කර ගැනීමට ඔබට අවශ්‍ය නැතිනම්, අරාව සඳහා අන්වර්ථයක් සාදන්න.

current($array)PHP අත්පොතට අනුව , අරාවෙහි පළමු අංගය ඔබට ලබා ගත හැකිය .

සෑම අරාවකටම එහි “වත්මන්” මූලද්‍රව්‍යයට අභ්‍යන්තර දර්ශකයක් ඇත, එය අරාව තුළට ඇතුළු කරන ලද පළමු මූලද්‍රව්‍යයට ආරම්භ වේ.

එබැවින් ඔබ අරාව දර්ශකය නැවත ස්ථානගත කරන තෙක් එය ක්‍රියාත්මක වන අතර එසේ නොමැතිනම් ඔබට අරාව නැවත සැකසීමට සිදුවේ.

භාෂා සැකැස්මක් සමඟ ඔබට Nth අංගය ලබා ගත හැකිය, "ලැයිස්තුව":

// First item
list($firstItem) = $yourArray;

// First item from an array that is returned from a function
list($firstItem) = functionThatReturnsArray();

// Second item
list( , $secondItem) = $yourArray;

array_keysශ්‍රිතය සමඟ ඔබට යතුරු සඳහාද එයම කළ හැකිය:

list($firstKey) = array_keys($yourArray);
list(, $secondKey) = array_keys($yourArray);

PHP 5.4+:

array_values($array)[0];

මුල් අරාව වෙනස් නොකර තාවකාලික වස්තූන් නිර්මාණය නොකර සෘජුවම අරාවෙහි පළමු හා අවසාන යතුර ලබා ගැනීම සඳහා PHP 7.3 කාර්යයන් දෙකක් එකතු කළේය :

• array_key_first
• array_key_last

අර්ථාන්විත අර්ථවත් වීම හැරුණු විට, මෙම ශ්‍රිතයන් අරාව දර්ශකය පවා ගෙන යන්නේ නැත (මෙන් foreach).

යතුරු තිබීම, යමෙකුට යතුරු මගින් අගයන් කෙලින්ම ලබා ගත හැකිය.

උදාහරණ (ඒ සියල්ලටම PHP 7.3+ අවශ්‍ය වේ)

පළමු / අවසාන යතුර සහ වටිනාකම ලබා ගැනීම:

$my_array = ['IT', 'rules', 'the', 'world'];

$first_key = array_key_first($my_array);
$first_value = $my_array[$first_key];

$last_key = array_key_last($my_array);
$last_value = $my_array[$last_key];

අරාව හිස් විය නොහැකි යැයි උපකල්පනය කරමින් පළමු / අවසාන අගය එක්-ලයිනර් ලෙස ලබා ගැනීම :

$first_value = $my_array[ array_key_first($my_array) ];

$last_value = $my_array[ array_key_last($my_array) ];

හිස් අරා සඳහා පෙරනිමි සහිතව, පළමු / අවසාන අගය එක්-ලයිනර් ලෙස ලබා ගැනීම:

$first_value = empty($my_array) ? 'default' : $my_array[ array_key_first($my_array) ];

$last_value = empty($my_array) ? 'default' : $my_array[ array_key_last($my_array) ];

සිතමු:

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

භාවිතා කරන්න:

$array[key($array)]

පළමු අංගය ලබා ගැනීමට හෝ

key($array)

පළමු යතුර ලබා ගැනීමට.

නැතහොත් ඔබට එය ඉවත් කිරීමට අවශ්‍ය නම් පළමුවැන්න ඉවත් කළ හැකිය.

සමහර අරා list, resetහෝ වැනි ක්‍රියාකාරකම් සමඟ ක්‍රියා නොකරයිcurrent . සමහර විට ඒවා "ව්‍යාජ" අරා - අර්ධ වශයෙන් ArrayIterator ක්‍රියාත්මක කිරීම.

අරාව නොතකා ඔබට පළමු අගය ඇද ගැනීමට අවශ්‍ය නම්, ඔබට කෙටිමං පරිපථයක් යෙදිය හැකිය:

foreach($array_with_unknown_keys as $value) break;

ඔබගේ අගය පසුව ලබා ගත හැකි $valueඅතර පළමු නැවත සිදුකිරීමෙන් පසු ලූපය කැඩී යයි. Array_unshift (array_values ​​($ arr)) වැනි ශ්‍රිතයකට විශාල අරා පිටපත් කිරීමට වඩා මෙය කාර්යක්ෂම වේ.

ඔබට යතුරද මේ ආකාරයෙන් අල්ලා ගත හැකිය:

foreach($array_with_unknown_keys as $key=>$value) break;

ඔබ මෙය ශ්‍රිතයකින් අමතන්නේ නම්, වේලාසනින් ආපසු යන්න:

function grab_first($arr) {
    foreach($arr as $value) return $value;
}

සිට Laravel ගේ කාරයෙක් :

function head($array)
{
    return reset($array);
}

අරාව අගය අනුව ශ්‍රිතයට ලබා දෙන අතර, යළි පිහිටුවීම () අරාවේ පිටපතක අභ්‍යන්තර දර්ශකයට බලපාන අතර එය මුල් අරාව ස්පර්ශ නොකරයි ( falseඅරාව හිස් නම් එය නැවත පැමිණෙන බව සලකන්න ).

භාවිත උදාහරණය:

$data = ['foo', 'bar', 'baz'];

current($data); // foo
next($data); // bar
head($data); // foo
next($data); // baz

එසේම, මෙන්න විකල්පයක්. එය ඉතා සුළු වේගයකින්, නමුත් වඩා රසවත් ය. අරාව හිස් නම් පෙරනිමි අගය පහසුවෙන් වෙනස් කිරීමට එය ඉඩ දෙයි:

function head($array, $default = null)
{
    foreach ($array as $item) {
        return $item;
    }
    return $default;
}

වාර්තාව සඳහා, මෙන්න මගේ තවත් පිළිතුරක් , අරාවෙහි අවසාන අංගය සඳහා.

මෙය සරලව තබා ගන්න! මෙහි නිවැරදි පිළිතුරු ගොඩක් ඇත, නමුත් සියලු ව්‍යාකූලතා අවම කිරීම සඳහා, මේ දෙක ක්‍රියා කරන අතර පොදු කාර්ය විශාල ප්‍රමාණයක් අඩු කරයි:

key($array)අරාවෙහි පළමු යතුර ලබා ගන්නේ අරාවෙහි
current($array)පළමු අගය ලබා ගනිමිනි

සංස්කරණය කරන්න:
පහත දැක්වෙන අදහස් සම්බන්ධයෙන්. පහත උදාහරණය ප්‍රතිදානය කරයි:string(13) "PHP code test"

$array = array
(
   '1'           => 'PHP code test',  
   'foo'         => 'bar', 5 , 5 => 89009, 
   'case'        => 'Random Stuff: '.rand(100,999),
   'PHP Version' => phpversion(),
   0             => 'ending text here'
);

var_dump(current($array));

සරලව කරන්න:

array_shift(array_slice($array,0,1));

මම කරන්නම් echo current($array).

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
foreach($arr as $first) break;
echo $first;

ප්‍රතිදානය:

apple

$myArray = array (4 => 'apple', 7 => 'orange', 13 => 'plum');
$arrayKeys = array_keys($myArray);

// The first element of your array is:
echo $myArray[$arrayKeys[0]];

$array=array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

$firstValue = each($array)[1];

ශ්‍රිතය සමස්ත අරාව පිටපත් නොකරන array_values()නිසා මෙය වඩා කාර්යක්ෂම each()වේ.

වැඩි විස්තර සඳහා http://www.php.net/manual/en/function.each.php බලන්න

විහිළු සහගත ක්‍රමයක් නම්:

$foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

function get_first ($foo) {
    foreach ($foo as $k=>$v){
        return $v;
    }
}

print get_first($foo);

පළමු අංගය ලබා ගන්න:

array_values($arr)[0]

අවසාන අංගය ලබා ගන්න

array_reverse($arr)[0]

මේවායින් බොහොමයක් වැඩ කරයි! නමුත් ඉක්මන් තනි පේළියක් (අඩු සම්පත්) ඇමතුමක් සඳහා:

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $array[key($array)];

// key($array) -> will return the first key (which is 4 in this example)

මෙය හොඳින් ක්‍රියාත්මක වුවද, කරුණාකර මගේ අමතර පිළිතුර ද බලන්න: https://stackoverflow.com/a/48410351/1804013

මුල් අරාව වෙනස් නොකර තාවකාලික වස්තූන් නිර්මාණය නොකර සෘජුවම අරාවෙහි පළමු හා අවසාන යතුර ලබා ගැනීම සඳහා PHP 7.3 කාර්යයන් දෙකක් එකතු කළේය :

• array_key_first
• array_key_last

"PHP 7.3.0 ට පෙර අනුවාද සඳහා මෙම ක්‍රියාකාරීත්වය සැපයීමට ක්‍රම කිහිපයක් තිබේ. Array_keys () භාවිතා කළ හැකි නමුත් එය තරමක් අකාර්යක්ෂම විය හැකිය. යළි පිහිටුවීම () සහ යතුර () භාවිතා කිරීමට ද හැකිය, නමුත් එය අභ්‍යන්තර අරාව දර්ශකය වෙනස් කළ හැකිය. පොලිෆිල් ලෙස ලියා ඇති අභ්‍යන්තර අරාව දර්ශකය වෙනස් නොකරන කාර්යක්ෂම විසඳුමක්: "

<?php
if (!function_exists('array_key_first')) {
    function array_key_first($arr) {
        foreach($arr as $key => $unused) {
            return $key;
        }
        return NULL;
    }
}

if (!function_exists('array_key_last')) {
    function array_key_last($arr) {
        return array_key_first(array_reverse($arr, true));
    }
}
?>

මම හිතන්නේ array_values භාවිතා කිරීම මෙහි ඔබේ හොඳම ඔට්ටුව වනු ඇත. 'ඇපල්' ලබා ගැනීම සඳහා එම ශ්‍රිතයේ ප්‍රති result ලයෙන් ඔබට දර්ශක ශුන්‍යයේ අගය ආපසු ලබා දිය හැකිය.

මෙය ක්‍රීඩාවට ටිකක් ප්‍රමාදයි, නමුත් මගේ අරාව තුළ ළමයින් ලෙස අරාව අංග අඩංගු ගැටළුවක් මට ඉදිරිපත් කරන ලද අතර එමඟින් පළමු අරාව මූලද්‍රව්‍යයේ සංගීත නිරූපණයක් ලබා ගැනීමට මට නොහැකි විය. විසින් PHP හි භාවිතා current()කාර්යය , මම මේ කළමනාකරණය:

<?php
    $original = array(4 => array('one', 'two'), 7 => array('three', 'four'));
    reset($original);  // to reset the internal array pointer...
    $first_element = current($original);  // get the current element...
?>

මෙම සියලු පිළිතුරුවලට ස්තූතිවන්ත වන අතර, මෙම පිළිතුර ලබා ගැනීමට මට හැකි විය.

භාවිත:

$first = array_slice($array, 0, 1);  
$val= $first[0];

පෙරනිමියෙන්, array_sliceයතුරු සංරක්ෂණය නොකරයි, එබැවින් අපට දර්ශකය ලෙස ශුන්‍යව ආරක්ෂිතව භාවිතා කළ හැකිය.

ඔබට විසඳුම් දෙකක්.

විසඳුම 1 - යතුර භාවිතා කරන්න. ඔබට එය භාවිතා කළ නොහැකි බව ඔබ පවසා නැත. :)

<?php
    // Get the first element of this array.
    $array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

    // Gets the first element by key
    $result = $array[4];

    // Expected result: string apple
    assert('$result === "apple" /* Expected result: string apple. */');
?>

විසඳුම 2 - array_flip () + key ()

<?php
    // Get first element of this array. Expected result: string apple
    $array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

    // Turn values to keys
    $array = array_flip($array);

    // You might thrown a reset in just to make sure
    // that the array pointer is at the first element.
    // Also, reset returns the first element.
    // reset($myArray);

    // Return the first key
    $firstKey = key($array);

    assert('$firstKey === "apple" /* Expected result: string apple. */');
?>

විසඳුම 3 - array_keys ()

echo $array[array_keys($array)[0]];

මම හිතන්නේ කතුවරයා අරාවෙහි පළමු මූලද්‍රව්‍යය යම් ශ්‍රිතයකින් ලබා ගැනීමෙන් පසුව එය ලබා ගැනීමට ක්‍රමයක් සොයමින් සිටියේය ( mysql_fetch_row , උදාහරණයක් ලෙස) උත්පාදනය නොකර බවයි.

එය එසේ නම්, මෙහි විස්තර කර ඇති සෑම ආකාරයකින්ම පාහේ මෙම පණිවිඩය ලැබෙනු ඇත ... තවද ඔවුන්ගෙන් සමහරක් අරාව (හෝ එහි යම් කොටසක්) අනුපිටපත් කිරීම සඳහා අමතර මතකයක් භාවිතා කරයි. එය වළක්වා ගත හැකි පහසු ක්‍රමයක් නම්, එම කාර්යයන් කිසිවක් ඇමතීමට පෙර පේළියේ අගය ලබා දීම පමණි:

$first_item_of_array = current($tmp_arr = mysql_fetch_row(...));
// or
$first_item_of_array = reset($tmp_arr = func_get_my_huge_array());

මේ ආකාරයෙන් ඔබට තිරයේ හෝ ල logs ු-සටහන් වල STRICT පණිවිඩය නොලැබෙන අතර ඔබ අතිරේක අරා නිර්මාණය නොකරයි. එය සුචිගත කළ සහ අනුබද්ධ අරා සමඟ ක්‍රියා කරයි .

array_keys()සංඛ්‍යාත්මක සුචිගත කරන ලද අරාව ලෙස ඔබේ සහායක අරාවේ යතුරු වෙත ප්‍රවේශ වීමට භාවිතා කරන්න , එය නැවත අරාව සඳහා යතුර ලෙස භාවිතා කළ හැකිය.

විසඳුම විටarr[0] :

(සටහන, යතුරු සමඟ අරාව 0 පාදක දර්ශකයක් බැවින් 1 වන මූලද්‍රව්‍යය දර්ශක 0 වේ)

ඔබේ තර්කය ලබා ගැනීම සඳහා ඔබට විචල්‍යයක් භාවිතා කර එකක් අඩු කළ හැකිය 1 => 'apple'.

$i = 1;
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[$i-1]];

ප්‍රතිදානය:

apple

හොඳයි, සරල බව සඳහා- භාවිතා කරන්න:

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[0]];

ප්‍රතිදානය:

apple

පළමු ක්‍රමය මඟින් පළමු මූලද්‍රව්‍යය පමණක් නොව, සුචිගත කරන ලද අරාවක් වැනි සහායක අරාවකට ප්‍රතිකාර කළ හැකිය.

අරාවෙහි අභ්‍යන්තර දර්ශකය සමඟ ගැටගැසීමට මා කැමති නැත, නමුත් එය සමඟ දෙවන අරාව සෑදීම array_keys()හෝ අකාර්යක්ෂම වේ array_values(), එබැවින් මම සාමාන්‍යයෙන් මෙය අර්ථ දක්වන්නෙමි:

function array_first(array $f) {
    foreach ($f as $v) {
        return $v;
    }
    throw new Exception('array was empty');
}

මේක උත්සාහ කරන්න:

$fruits = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($fruits)."\n";

ArrayIterator පන්තිය භාවිතා කිරීමට කිසිවෙකු යෝජනා කර නැත:

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
$first_element = (new ArrayIterator($array))->current();
echo $first_element; //'apple'

OP හි සමුද්දේශ නියමයන් අනුව ය.