Отримайте перший елемент масиву

У мене є масив:

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 :

змішане скидання (масив & $ масив );

Опис:

reset () перемотає внутрішній покажчик масиву на перший елемент і повертає значення першого елемента масиву, або FALSE, якщо масив порожній.

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

Кожен масив має внутрішній покажчик на його "поточний" елемент, який ініціалізується на перший елемент, вставлений у масив.

Так він працює, поки ви не перестановите покажчик масиву, інакше вам доведеться скинути масив.

Ви можете отримати N-й елемент за допомогою мовної конструкції "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) ];

Отримання першого / останнього значення в якості однокласників із за замовчуванням для порожніх масивів:

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

Від помічників Ларавеля :

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

Масив, переданий за значенням функції, reset () впливає на внутрішній покажчик копії масиву, і він не торкається початкового масиву (зауважте, він повертається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)отримує перше значення масиву

EDIT:
Щодо коментарів нижче. Вийде наступний приклад: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

Я думаю, що найкращим варіантом тут стане використання array_values . Ви можете повернути значення в індексі нуля з результату цієї функції, щоб отримати "яблуко".

Це трохи пізно до гри, але мені постала проблема, коли мій масив містив елементи масиву як діти всередині нього, і тому я не міг просто отримати рядкове представлення першого елемента масиву. За допомогою 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, ніж [count () - 1], і ці три швидше ніж array_valuesі array_slice.

Я думаю, що автор просто шукав спосіб отримати перший елемент масиву після отримання його з якоїсь функції ( 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());

Таким чином, ви не отримуєте повідомлення STRICT ні на екрані, ні в журналах, і не створюєте додаткових масивів. Він працює як з індексованими, так і з асоціативними масивами.

Мені подобається приклад "список", але "список" працює лише зліва від завдання. Якщо ми не хочемо присвоювати змінну, ми будемо змушені скласти тимчасове ім’я, яке в кращому випадку забруднює наш обсяг і в гіршому випадку замінює наявне значення:

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

Наведене вище замінить будь-яке існуюче значення $ x, і змінна $ x буде зависати, поки ця область активна (кінець цієї функції / методу або назавжди, якщо ми знаходимося на найвищому рівні). Це можна вирішити за допомогою call_user_func та анонімної функції, але це незграбно:

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

Невелика зміна того, що опублікував Сарфраз:

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