รับองค์ประกอบแรกของอาร์เรย์

ฉันมีอาเรย์:

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

ฉันต้องการรับองค์ประกอบแรกของอาร์เรย์นี้ ผลลัพธ์ที่คาดหวัง: สตริง 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( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'

หากคุณไม่ต้องการสูญเสียตำแหน่งตัวชี้ปัจจุบันเพียงสร้างนามแฝงสำหรับอาร์เรย์

current($array)คุณจะได้รับองค์ประกอบแรกของอาร์เรย์ตามคู่มือของ PHP

ทุกอาร์เรย์มีตัวชี้ภายในไปยังองค์ประกอบ "ปัจจุบัน" ของมันซึ่งจะเริ่มต้นองค์ประกอบที่แทรกเข้าไปในอาร์เรย์

ดังนั้นมันจะทำงานจนกว่าคุณจะได้ตำแหน่งตัวชี้อาร์เรย์อีกครั้งและมิฉะนั้นคุณจะต้องรีเซ็ตอาร์เรย์

คุณสามารถรับองค์ประกอบ Nth ด้วยโครงสร้างภาษา "list":

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

รับค่าแรก / สุดท้ายเป็นหนึ่งใน liners โดยมีค่าเริ่มต้นสำหรับอาร์เรย์ที่ว่างเปล่า:

$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

วิธี kludgy คือ:

$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

ฉันคิดว่าการใช้array_valuesจะเป็นทางออกที่ดีที่สุดของคุณที่นี่ คุณสามารถคืนค่าที่ศูนย์ดัชนีจากผลลัพธ์ของฟังก์ชันนั้นเพื่อรับ 'apple'

นี่มันช้าไปหน่อยสำหรับเกม แต่ฉันได้พบกับปัญหาที่อาเรย์ของฉันมีองค์ประกอบอาเรย์เป็นเด็กอยู่ข้างในและดังนั้นฉันจึงไม่สามารถรับการแทนค่าสตริงขององค์ประกอบอาเรย์แรกได้ ด้วยการใช้current()ฟังก์ชั่นของ PHPฉันจัดการสิ่งนี้:

<?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 () + แป้น ()

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

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

$array1 = array();
$array2 = array(1,2,3,4);
$array3 = array('hello'=>'world', 'foo'=>'bar');
$array4 = null;

var_dump('reset1', reset($array1));
var_dump('reset2', reset($array2));
var_dump('reset3', reset($array3));
var_dump('reset4', reset($array4)); // Warning

var_dump('array_shift1', array_shift($array1));
var_dump('array_shift2', array_shift($array2));
var_dump('array_shift3', array_shift($array3));
var_dump('array_shift4', array_shift($array4)); // Warning

var_dump('each1', each($array1));
var_dump('each2', each($array2));
var_dump('each3', each($array3));
var_dump('each4', each($array4)); // Warning

var_dump('array_values1', array_values($array1)[0]); // Notice
var_dump('array_values2', array_values($array2)[0]);
var_dump('array_values3', array_values($array3)[0]);
var_dump('array_values4', array_values($array4)[0]); // Warning

var_dump('array_slice1', array_slice($array1, 0, 1));
var_dump('array_slice2', array_slice($array2, 0, 1));
var_dump('array_slice3', array_slice($array3, 0, 1));
var_dump('array_slice4', array_slice($array4, 0, 1)); // Warning

list($elm) = $array1; // Notice
var_dump($elm);
list($elm) = $array2;
var_dump($elm);
list($elm) = $array3; // Notice
var_dump($elm);
list($elm) = $array4;
var_dump($elm);

อย่างที่คุณเห็นเรามีโซลูชัน 'หนึ่งบรรทัด' หลายตัวที่ทำงานได้ดีในบางกรณี แต่ไม่ใช่ในทุกกรณี

ในความคิดของฉันคุณควรจัดการกับอาร์เรย์เท่านั้น

ตอนนี้พูดคุยเกี่ยวกับประสิทธิภาพการทำงานสมมติว่าเรามีอาร์เรย์เสมอเช่นนี้

$elm = empty($array) ? null : ...($array);

...you would use without errors:
$array[count($array)-1];
array_shift
reset
array_values
array_slice

array_shiftจะเร็วกว่าreset, ที่มีมากขึ้นอย่างรวดเร็วกว่า [นับ () - 1] และที่สามเหล่านี้จะเร็วกว่าและarray_valuesarray_slice

ฉันคิดว่าผู้แต่งกำลังมองหาวิธีรับองค์ประกอบแรกของอาร์เรย์หลังจากรับจากฟังก์ชั่นบางอย่าง ( mysql_fetch_rowตัวอย่างเช่น ) โดยไม่สร้าง STRICT "เฉพาะตัวแปรที่ควรผ่านการอ้างอิง"

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

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

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

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

list($x) = some_array();
var_dump($x);

ด้านบนจะเขียนทับค่าที่มีอยู่ของ $ x และตัวแปร $ x จะวนไปมาตราบใดที่ขอบเขตนี้แอ็คทีฟ (จุดสิ้นสุดของฟังก์ชัน / เมธอดนี้หรือตลอดไปหากเราอยู่ในระดับบนสุด) สิ่งนี้สามารถแก้ไขได้โดยใช้ call_user_func และฟังก์ชั่นที่ไม่ระบุชื่อ แต่มัน clunky:

var_dump(call_user_func(function($arr) { list($x) = $arr; return $x; },
                        some_array()));

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

var_dump(call_user_func(function($arr) { return reset($arr); },
                        array_values(some_array())));

อย่างไรก็ตามนี่เป็นความจริงที่เกินจริงเนื่องจาก call_user_func จะทำการมอบหมายชั่วคราวนี้ภายใน สิ่งนี้ช่วยให้เราปฏิบัติต่อฟังก์ชั่นการส่งต่ออ้างอิงได้ราวกับว่าเป็นรหัสผ่านโดยไม่มีคำเตือนหรือข้อผิดพลาด:

var_dump(call_user_func('reset', array_values(some_array())));

การเปลี่ยนแปลงเล็กน้อยในสิ่งที่ Sarfraz โพสต์คือ:

$array = array(1, 2, 3, 4, 5);
$output = array_slice($array, 0, 1);
print_r ($output);

ฉันไม่ชอบเล่นซอกับตัวชี้ภายในของอาเรย์ แต่ก็ไม่มีประสิทธิภาพในการสร้างอาเรย์ที่สองด้วย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";