Dapatkan elemen pertama array

Saya memiliki sebuah array:

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

Saya ingin mendapatkan elemen pertama dari array ini. Hasil yang diharapkan: string apple

Satu persyaratan: itu tidak dapat dilakukan dengan melewati referensi , jadi array_shiftitu bukan solusi yang baik.

Bagaimana saya bisa melakukan ini?

Jawaban asli, tetapi mahal (O (n)):

array_shift(array_values($array));

Dalam O (1):

array_pop(array_reverse($array));

Kasus penggunaan lainnya, dll ...

Jika memodifikasi (dalam arti mengatur ulang array array) $arraytidak menjadi masalah, Anda dapat menggunakan:

reset($array);

Ini seharusnya lebih efisien secara teoritis, jika diperlukan array "copy":

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

Dengan PHP 5.4+ (tetapi dapat menyebabkan kesalahan indeks jika kosong):

array_values($array)[0];

Seperti yang ditunjukkan Mike (cara termudah yang mungkin):

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

Jika Anda ingin mendapatkan kunci: (jalankan setelah reset)

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

Dari dokumentasi PHP :

reset campuran (array & $ array );

Deskripsi:

reset () memundurkan pointer internal array ke elemen pertama dan mengembalikan nilai elemen array pertama, atau FALSE jika array kosong.

$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'

Jika Anda tidak ingin kehilangan posisi pointer saat ini, buat saja alias untuk array.

current($array)bisa memberi Anda elemen pertama array, menurut manual PHP .

Setiap array memiliki pointer internal ke elemen "saat ini", yang diinisialisasi ke elemen pertama yang dimasukkan ke dalam array.

Jadi itu berfungsi sampai Anda telah memposisikan ulang pointer array, dan jika tidak Anda harus mengatur ulang array.

Anda bisa mendapatkan elemen ke-N dengan konstruksi bahasa, "daftar":

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

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

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

Dengan array_keysfungsi ini Anda dapat melakukan hal yang sama untuk kunci:

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

PHP 5.4+:

array_values($array)[0];

PHP 7.3 menambahkan dua fungsi untuk mendapatkan kunci pertama dan terakhir dari array secara langsung tanpa modifikasi dari array asli dan tanpa membuat objek sementara:

• array_key_first
• array_key_last

Selain bermakna secara semantik, fungsi-fungsi ini bahkan tidak memindahkan pointer array (seperti yang foreachakan dilakukan).

Memiliki kunci, seseorang bisa mendapatkan nilai dengan kunci secara langsung.

Contoh (semuanya membutuhkan PHP 7.3+)

Mendapatkan kunci dan nilai pertama / terakhir:

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

Mendapatkan nilai pertama / terakhir sebagai satu-liner, dengan asumsi array tidak boleh kosong :

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

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

Mendapatkan nilai pertama / terakhir sebagai satu-liner, dengan default untuk array kosong:

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

Seharusnya:

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

Cukup gunakan:

$array[key($array)]

untuk mendapatkan elemen pertama atau

key($array)

untuk mendapatkan kunci pertama.

Atau Anda dapat memutuskan tautan yang pertama jika Anda ingin menghapusnya.

Beberapa array tidak berfungsi dengan fungsi seperti list, resetataucurrent . Mungkin mereka array "palsu" - misalnya mengimplementasikan ArrayIterator, misalnya.

Jika Anda ingin menarik nilai pertama terlepas dari array, Anda dapat membuat hubungan pendek iterator:

foreach($array_with_unknown_keys as $value) break;

Nilai Anda kemudian akan tersedia di $value dan loop akan rusak setelah iterasi pertama. Ini lebih efisien daripada menyalin array yang berpotensi besar ke fungsi seperti array_unshift (array_values ​​($ arr)).

Anda dapat mengambil kunci dengan cara ini juga:

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

Jika Anda memanggil ini dari suatu fungsi, cukup kembali lebih awal:

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

Dari pembantu Laravel :

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

Array yang diteruskan oleh nilai ke fungsi, reset () memengaruhi pointer internal dari salinan array, dan array tersebut tidak menyentuh array asli (perhatikan bahwa ia mengembalikanfalse jika array kosong).

Contoh penggunaan:

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

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

Juga, inilah alternatifnya. Ini sedikit lebih cepat, tetapi lebih menarik. Itu memungkinkan dengan mudah mengubah nilai default jika array kosong:

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

Sebagai catatan, inilah jawaban saya yang lain , untuk elemen terakhir array.

Buat ini tetap sederhana! Ada banyak jawaban yang benar di sini, tetapi untuk meminimalkan semua kebingungan, kedua ini berfungsi dan mengurangi banyak overhead:

key($array)mendapatkan kunci pertama dari sebuah array
current($array)mendapatkan nilai pertama dari sebuah array

EDIT:
Mengenai komentar di bawah ini. Contoh berikut akan menampilkan: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));

Cukup lakukan:

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

Saya akan lakukan echo current($array).

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

Keluaran:

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

Ini jauh lebih efisien daripada array_values()karena each()fungsi tidak menyalin seluruh array.

Untuk info lebih lanjut, lihat http://www.php.net/manual/en/function.each.php

Cara kludgy adalah:

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

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

print get_first($foo);

Dapatkan elemen pertama:

array_values($arr)[0]

Dapatkan elemen terakhir

array_reverse($arr)[0]

Sebagian besar berhasil! TETAPI untuk panggilan saluran tunggal cepat (sumber daya rendah):

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

Meskipun ini berfungsi, dan cukup baik, silakan lihat juga jawaban tambahan saya: https://stackoverflow.com/a/48410351/1804013

Saya pikir menggunakan array_values akan menjadi taruhan terbaik Anda di sini. Anda bisa mengembalikan nilai pada indeks nol dari hasil fungsi itu untuk mendapatkan 'apel'.

Ini sedikit terlambat untuk permainan, tetapi saya dihadapkan dengan masalah di mana array saya mengandung elemen array sebagai anak-anak di dalamnya, dan dengan demikian saya tidak bisa hanya mendapatkan representasi string dari elemen array pertama. Dengan menggunakan current()fungsi PHP , saya mengatur ini:

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

Berkat semua solusi saat ini membantu saya mendapatkan jawaban ini, saya harap ini membantu seseorang kapan saja!

Menggunakan:

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

Secara default, array_slicetidak menyimpan kunci, jadi kami dapat menggunakan nol dengan aman sebagai indeks.

Dua solusi untuk Anda.

Solusi 1 - Cukup gunakan kunci. Anda belum mengatakan bahwa Anda tidak dapat menggunakannya. :)

<?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. */');
?>

Solusi 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. */');
?>

Solusi 3 - array_keys ()

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

Ini bukan tanggapan yang begitu sederhana di dunia nyata. Misalkan kita memiliki contoh tanggapan yang mungkin ini yang dapat Anda temukan di beberapa perpustakaan.

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

Seperti yang Anda lihat, kami memiliki beberapa solusi 'satu baris' yang bekerja dengan baik dalam beberapa kasus, tetapi tidak semuanya.

Menurut pendapat saya, Anda harus menangani itu hanya dengan array.

Sekarang berbicara tentang kinerja, dengan asumsi bahwa kita selalu menyusun, seperti ini:

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

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

array_shiftlebih cepat dari reset, itu lebih cepat dari [hitungan () - 1], dan ketiganya lebih cepat dari array_valuesdan array_slice.

Saya membayangkan penulis baru saja mencari cara untuk mendapatkan elemen pertama dari array setelah mendapatkannya dari beberapa fungsi ( mysql_fetch_row , misalnya) tanpa menghasilkan STRICT "Hanya variabel yang harus dilewatkan dengan referensi".

Jika demikian, hampir semua cara yang dijelaskan di sini akan mendapatkan pesan ini ... dan beberapa dari mereka menggunakan banyak memori tambahan untuk menduplikasi array (atau sebagian darinya). Cara mudah untuk menghindarinya adalah dengan hanya memberikan nilai sebaris sebelum memanggil fungsi-fungsi tersebut:

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

Dengan cara ini Anda tidak mendapatkan pesan STRICT di layar, atau di log, dan Anda tidak membuat array tambahan. Ia bekerja dengan array yang diindeks DAN asosiatif.

Saya suka contoh "daftar", tetapi "daftar" hanya berfungsi di sisi kiri tugas. Jika kita tidak ingin menetapkan variabel, kita akan dipaksa untuk membuat nama sementara, yang paling mencemari ruang lingkup kita dan paling buruk menimpa nilai yang ada:

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

Di atas akan menimpa nilai $ x yang ada, dan variabel $ x akan bertahan selama lingkup ini aktif (akhir dari fungsi / metode ini, atau selamanya jika kita berada di level atas). Ini bisa dikerjakan menggunakan call_user_func dan fungsi anonim, tapi kikuk:

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

Jika kita menggunakan fungsi anonim seperti ini, kita sebenarnya bisa pergi dengan reset dan array_shift, meskipun mereka menggunakan pass-by-reference. Ini karena memanggil fungsi akan mengikat argumennya, dan argumen ini dapat dilewatkan dengan referensi:

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

Namun, ini sebenarnya berlebihan, karena call_user_func akan melakukan tugas sementara ini secara internal. Ini memungkinkan kami memperlakukan fungsi pass-by-reference seolah-olah itu adalah pass-by-value, tanpa peringatan atau kesalahan apa pun:

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

Perubahan kecil pada apa yang diposting Sarfraz adalah:

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

Saya tidak suka mengutak-atik pointer internal array, tetapi juga tidak efisien untuk membangun array kedua dengan array_keys()atau array_values(), jadi saya biasanya mendefinisikan ini:

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

Coba ini:

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