Lấy phần tử đầu tiên của một mảng

Tôi có một mảng:

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

Tôi muốn có được phần tử đầu tiên của mảng này. Kết quả dự kiến: chuỗi apple

Một yêu cầu: nó không thể được thực hiện bằng cách chuyển qua tham chiếu , vì vậy array_shiftkhông phải là một giải pháp tốt.

Tôi có thể làm cái này như thế nào?

Câu trả lời gốc, nhưng tốn kém (O (n)):

array_shift(array_values($array));

Trong O (1):

array_pop(array_reverse($array));

Các trường hợp sử dụng khác, v.v ...

Nếu sửa đổi (theo nghĩa đặt lại các con trỏ mảng) $arraykhông phải là vấn đề, bạn có thể sử dụng:

reset($array);

Điều này sẽ hiệu quả hơn về mặt lý thuyết, nếu cần một "bản sao" mảng:

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

Với PHP 5.4+ (nhưng có thể gây ra lỗi chỉ mục nếu trống):

array_values($array)[0];

Như Mike đã chỉ ra (cách dễ nhất có thể):

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

Nếu bạn muốn lấy khóa: (thực hiện nó sau khi đặt lại)

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

Từ tài liệu của PHP :

thiết lập lại hỗn hợp (mảng & $ mảng );

Sự miêu tả:

reset () tua lại con trỏ bên trong của mảng thành phần tử đầu tiên và trả về giá trị của phần tử mảng đầu tiên hoặc FALSE nếu mảng trống.

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

Nếu bạn không muốn mất vị trí con trỏ hiện tại, chỉ cần tạo bí danh cho mảng.

current($array)có thể giúp bạn có được phần tử đầu tiên của một mảng, theo hướng dẫn sử dụng PHP .

Mỗi mảng có một con trỏ bên trong tới phần tử "hiện tại" của nó, được khởi tạo cho phần tử đầu tiên được chèn vào mảng.

Vì vậy, nó hoạt động cho đến khi bạn đã định vị lại con trỏ mảng và nếu không bạn sẽ phải đặt lại mảng.

Bạn có thể lấy phần tử thứ N với cấu trúc ngôn ngữ, "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;

Với array_keyschức năng bạn có thể làm tương tự cho các phím:

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

PHP 5.4+:

array_values($array)[0];

PHP 7.3 bổ sung thêm hai chức năng để khai thác đầu tiên và quan trọng nhất của một mảng trực tiếp mà không sửa đổi của mảng ban đầu và không tạo ra bất kỳ đối tượng tạm thời:

• mảng_key_first
• mảng_key_last

Ngoài việc có ý nghĩa về mặt ngữ nghĩa, các hàm này thậm chí không di chuyển con trỏ mảng (như foreach sẽ làm).

Có các khóa, người ta có thể lấy các giá trị bằng các phím trực tiếp.

Các ví dụ (tất cả chúng đều yêu cầu PHP 7.3+)

Lấy khóa đầu tiên / cuối cùng và giá trị:

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

Lấy giá trị đầu tiên / cuối cùng dưới dạng một lớp, giả sử mảng có thể trống :

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

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

Lấy giá trị đầu tiên / cuối cùng dưới dạng một lớp, với mặc định cho các mảng trống:

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

Giả sử:

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

Chỉ dùng:

$array[key($array)]

để có được yếu tố đầu tiên hoặc

key($array)

để lấy chìa khóa đầu tiên.

Hoặc bạn có thể hủy liên kết đầu tiên nếu bạn muốn loại bỏ nó.

Một số mảng không hoạt động với các hàm như list,reset hoặc current. Có thể chúng là mảng "giả" - ví dụ triển khai ArrayIterator một phần.

Nếu bạn muốn kéo giá trị đầu tiên bất kể mảng nào, bạn có thể đoản mạch một vòng lặp:

foreach($array_with_unknown_keys as $value) break;

Giá trị của bạn sau đó sẽ có sẵn trong $value và vòng lặp sẽ bị hỏng sau lần lặp đầu tiên. Điều này hiệu quả hơn so với việc sao chép một mảng có khả năng lớn sang một hàm như Array_unshift (Array_values ​​($ Array)).

Bạn cũng có thể lấy chìa khóa theo cách này:

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

Nếu bạn đang gọi hàm này từ một hàm, chỉ cần quay lại sớm:

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

Từ những người trợ giúp của Laravel :

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

Mảng được truyền theo giá trị cho hàm, reset () ảnh hưởng đến con trỏ bên trong của một bản sao của mảng và nó không chạm vào mảng ban đầu (lưu ý rằng nó trả vềfalse nếu mảng trống).

Ví dụ sử dụng:

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

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

Ngoài ra, đây là một thay thế. Nó rất nhanh, nhưng thú vị hơn. Nó cho phép dễ dàng thay đổi giá trị mặc định nếu mảng trống:

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

Đối với bản ghi, đây là một câu trả lời khác của tôi , cho phần tử cuối cùng của mảng.

Giữ điều này đơn giản! Có rất nhiều câu trả lời đúng ở đây, nhưng để giảm thiểu tất cả sự nhầm lẫn, hai điều này hoạt động và giảm rất nhiều chi phí:

key($array)lấy khóa đầu tiên của một mảng
current($array)lấy giá trị đầu tiên của một mảng

EDIT:
Về các ý kiến ​​dưới đây. Ví dụ sau sẽ xuất ra: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));

Đơn giản chỉ cần làm:

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

Tôi sẽ làm gì echo current($array).

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

Đầu ra:

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

Đây là hiệu quả hơn array_values()vì each()chức năng không sao chép toàn bộ mảng.

Để biết thêm thông tin, hãy xem http://www.php.net/manual/en/feft.each.php

Một cách đơn giản là:

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

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

print get_first($foo);

Lấy phần tử đầu tiên:

array_values($arr)[0]

Lấy phần tử cuối cùng

array_reverse($arr)[0]

Hầu hết các công việc này! NHƯNG cho một cuộc gọi nhanh chóng (tài nguyên thấp):

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

Mặc dù điều này hoạt động tốt và tốt, nhưng vui lòng xem câu trả lời bổ sung của tôi: https://stackoverflow.com/a/48410351/1804013

Tôi nghĩ rằng sử dụng mảng_values sẽ là lựa chọn tốt nhất của bạn ở đây. Bạn có thể trả về giá trị ở chỉ số 0 từ kết quả của hàm đó để lấy 'apple'.

Điều này hơi muộn với trò chơi, nhưng tôi đã gặp phải một vấn đề trong đó mảng của tôi chứa các phần tử mảng khi còn nhỏ bên trong nó, và do đó tôi không thể có được biểu diễn chuỗi của phần tử mảng đầu tiên. Bằng cách sử dụng current()chức năng của PHP , tôi đã quản lý điều này:

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

Cảm ơn tất cả các giải pháp hiện tại đã giúp tôi có được câu trả lời này, tôi hy vọng điều này sẽ giúp được ai đó!

Sử dụng:

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

Theo mặc định, array_slicekhông bảo toàn các khóa, vì vậy chúng ta có thể sử dụng zero một cách an toàn làm chỉ mục.

Hai giải pháp cho bạn.

Giải pháp 1 - Chỉ cần sử dụng phím. Bạn đã không nói rằng bạn không thể sử dụng nó. :)

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

Giải pháp 2 - mảng_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. */');
?>

Giải pháp 3 - mảng_keys ()

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

Đây không phải là phản ứng đơn giản trong thế giới thực. Giả sử rằng chúng tôi có những ví dụ về các phản hồi có thể có mà bạn có thể tìm thấy trong một số thư viện.

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

Giống như bạn có thể thấy, chúng tôi có một số giải pháp "một dòng" hoạt động tốt trong một số trường hợp, nhưng không phải tất cả.

Theo tôi, bạn nên xử lý chỉ với mảng.

Bây giờ nói về hiệu suất, giả sử rằng chúng ta luôn luôn mảng, như thế này:

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

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

array_shiftnhanh hơn reset, nhanh hơn [đếm () - 1] và ba cái này nhanh hơn array_valuesvà array_slice.

Tôi tưởng tượng tác giả chỉ đang tìm cách lấy phần tử đầu tiên của một mảng sau khi lấy nó từ một số hàm ( ví dụ: mysql_fetch_row ) mà không tạo ra một chuỗi "Chỉ các biến được truyền qua tham chiếu".

Nếu đúng như vậy, gần như tất cả các cách được mô tả ở đây sẽ nhận được thông báo này ... và một số trong số chúng sử dụng rất nhiều bộ nhớ bổ sung nhân đôi một mảng (hoặc một phần của nó). Một cách dễ dàng để tránh nó chỉ là gán giá trị nội tuyến trước khi gọi bất kỳ hàm nào trong số đó:

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

Bằng cách này, bạn không nhận được thông báo STRICT trên màn hình, cũng như trong nhật ký và bạn không tạo thêm bất kỳ mảng nào. Nó hoạt động với cả mảng được lập chỉ mục và kết hợp .

Tôi thích ví dụ "danh sách", nhưng "danh sách" chỉ hoạt động ở phía bên trái của bài tập. Nếu chúng ta không muốn gán một biến, chúng ta sẽ buộc phải tạo một tên tạm thời, điều này làm ô nhiễm tốt nhất phạm vi của chúng ta và tệ nhất là ghi đè lên một giá trị hiện có:

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

Ở trên sẽ ghi đè lên bất kỳ giá trị hiện tại nào của $ x và biến $ x sẽ tồn tại chừng nào phạm vi này hoạt động (kết thúc chức năng / phương thức này hoặc mãi mãi nếu chúng ta ở cấp cao nhất). Điều này có thể được giải quyết bằng cách sử dụng call_user_func và một hàm ẩn danh, nhưng thật rắc rối:

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

Nếu chúng ta sử dụng các hàm ẩn danh như thế này, chúng ta thực sự có thể thoát khỏi thiết lập lại và Array_shift, mặc dù chúng sử dụng tham chiếu qua. Điều này là do việc gọi một hàm sẽ liên kết các đối số của nó và các đối số này có thể được truyền bằng tham chiếu:

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

Tuy nhiên, điều này thực sự quá mức cần thiết, vì call_user_func sẽ thực hiện nhiệm vụ tạm thời này trong nội bộ. Điều này cho phép chúng tôi xử lý các hàm chuyển qua tham chiếu như thể chúng là từng giá trị, không có bất kỳ cảnh báo hoặc lỗi nào:

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

Một thay đổi nhỏ đối với những gì Sarfraz đăng là:

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

Tôi không thích nghịch với con trỏ bên trong của mảng, nhưng cũng không hiệu quả khi xây dựng một mảng thứ hai bằng array_keys()hoặc array_values(), vì vậy tôi thường định nghĩa điều này:

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

Thử cái này:

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