Uzyskaj pierwszy element tablicy

Mam tablicę:

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

Chciałbym uzyskać pierwszy element tej tablicy. Oczekiwany wynik: ciąg apple

Jedno wymaganie: nie można tego zrobić z przekazaniem referencji , więc array_shiftnie jest to dobre rozwiązanie.

W jaki sposób mogę to zrobić?

Oryginalna odpowiedź, ale kosztowna (O (n)):

array_shift(array_values($array));

W O (1):

array_pop(array_reverse($array));

Inne przypadki użycia itp.

Jeśli modyfikacja (w sensie resetowania wskaźników tablicy) $arraynie stanowi problemu, możesz użyć:

reset($array);

Powinno to być teoretycznie bardziej wydajne, jeśli potrzebna jest „kopia” tablicy:

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

W PHP 5.4+ (ale może powodować błąd indeksu, jeśli jest pusty):

array_values($array)[0];

Jak zauważył Mike (najłatwiejszy możliwy sposób):

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

Jeśli chcesz zdobyć klucz: (uruchom go po resecie)

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

Z dokumentacji PHP :

mieszany reset (tablica & $ tablica );

Opis:

reset () przewija wewnętrzny wskaźnik tablicy do pierwszego elementu i zwraca wartość pierwszego elementu tablicy, lub FALSE, jeśli tablica jest pusta.

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

Jeśli nie chcesz stracić bieżącej pozycji wskaźnika, po prostu utwórz alias dla tablicy.

current($array)może dostarczyć ci pierwszy element tablicy, zgodnie z instrukcją PHP .

Każda tablica ma wewnętrzny wskaźnik do swojego „bieżącego” elementu, który jest inicjowany do pierwszego elementu wstawionego do tablicy.

To działa, dopóki nie zmienisz położenia wskaźnika tablicy, w przeciwnym razie będziesz musiał zresetować tablicę.

Możesz uzyskać N-ty element z konstrukcją językową „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;

Za pomocą tej array_keysfunkcji możesz zrobić to samo dla klawiszy:

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

PHP 5.4+:

array_values($array)[0];

PHP 7.3 dodał dwie funkcje do uzyskania pierwszego i ostatniego klucza tablicy bezpośrednio bez modyfikacji oryginalnej tablicy i bez tworzenia jakichkolwiek tymczasowych obiektów:

• tablica_klucz_pierwszy
• array_key_last

Oprócz tego, że mają znaczenie semantyczne, funkcje te nawet nie przesuwają wskaźnika tablicy (jak foreachby to robił).

Posiadając klucze, można uzyskać wartości bezpośrednio po kluczach.

Przykłady (wszystkie wymagają PHP 7.3+)

Uzyskiwanie pierwszego / ostatniego klucza i wartości:

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

Uzyskiwanie pierwszej / ostatniej wartości jako jednowierszowych, przy założeniu , że tablica nie może być pusta :

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

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

Uzyskiwanie pierwszej / ostatniej wartości jako jednowierszowych, z wartościami domyślnymi dla pustych tablic:

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

Przypuszczać:

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

Po prostu użyj:

$array[key($array)]

zdobyć pierwszy element lub

key($array)

zdobyć pierwszy klucz.

Lub możesz odłączyć pierwszy, jeśli chcesz go usunąć.

Niektóre tablice nie działają funkcje podoba list, resetalbo current. Być może są to „sztuczne” tablice - na przykład częściowo implementujące ArrayIterator.

Jeśli chcesz pobrać pierwszą wartość niezależnie od tablicy, możesz zewrzeć iterator:

foreach($array_with_unknown_keys as $value) break;

Twoja wartość będzie wtedy dostępna w $value a pętla zostanie przerwana po pierwszej iteracji. Jest to bardziej wydajne niż kopiowanie potencjalnie dużej tablicy do funkcji takiej jak array_unshift (array_values ​​($ arr)).

Możesz także pobrać klucz w ten sposób:

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

Jeśli wywołujesz to z funkcji, po prostu wróć wcześniej:

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

Od pomocników Laravela :

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

Tablica przekazywana przez wartość do funkcji, reset () wpływa na wewnętrzny wskaźnik kopii tablicy i nie dotyka oryginalnej tablicy (zwróć uwagę, że zwracafalse jeśli tablica jest pusta).

Przykład użycia:

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

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

Również tutaj jest alternatywa. Jest bardzo nieznacznie szybszy, ale bardziej interesujący. Pozwala łatwo zmienić wartość domyślną, jeśli tablica jest pusta:

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

Dla przypomnienia, oto moja kolejna odpowiedź na ostatni element tablicy.

Niech to będzie proste! Istnieje wiele poprawnych odpowiedzi, ale aby zminimalizować zamieszanie, te dwa działają i zmniejszają koszty ogólne:

key($array)pobiera pierwszy klucz tablicy
current($array)pobiera pierwszą wartość tablicy

EDYCJA:
W odniesieniu do poniższych komentarzy. Wyjdzie następujący przykład: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));

Po prostu wykonaj:

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

Zrobiłbym echo current($array).

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

Wynik:

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

Jest to o wiele bardziej wydajne niż array_values()ponieważ each()funkcja nie kopiuje całej tablicy.

Aby uzyskać więcej informacji, zobacz http://www.php.net/manual/en/function.each.php

Kludgy sposób to:

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

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

print get_first($foo);

Zdobądź pierwszy element:

array_values($arr)[0]

Zdobądź ostatni element

array_reverse($arr)[0]

Większość z nich działa! ALE dla szybkiego połączenia z jedną linią (mało zasobów):

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

Chociaż to działa i całkiem dobrze, proszę zobaczyć moją dodatkową odpowiedź: https://stackoverflow.com/a/48410351/1804013

Myślę, że najlepszym rozwiązaniem byłoby użycie array_values . Możesz zwrócić wartość o indeksie zero od wyniku tej funkcji, aby uzyskać „jabłko”.

Trochę za późno na grę, ale pojawił się problem polegający na tym, że moja tablica zawierała elementy tablicy jako dzieci, a zatem nie mogłam po prostu uzyskać reprezentacji ciągu pierwszego elementu tablicy. Przez użyciem PHP current()funkcji , to udało mi:

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

Dzięki wszystkim obecnym rozwiązaniom pomógł mi dojść do tej odpowiedzi, mam nadzieję, że kiedyś to komuś pomoże!

Posługiwać się:

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

Domyślnie array_slicenie zachowuje kluczy, więc możemy bezpiecznie używać zera jako indeksu.

Dwa rozwiązania dla Ciebie.

Rozwiązanie 1 - Wystarczy użyć klucza. Nie powiedziałeś, że nie możesz go użyć. :)

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

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

Rozwiązanie 3 - array_keys ()

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

To nie jest taka prosta reakcja w prawdziwym świecie. Załóżmy, że mamy te przykłady możliwych odpowiedzi, które można znaleźć w niektórych bibliotekach.

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

Jak widać, mamy kilka rozwiązań „jednowierszowych”, które działają dobrze w niektórych przypadkach, ale nie we wszystkich.

Moim zdaniem ten moduł obsługi powinien mieć tylko tablice.

Teraz mówimy o wydajności, zakładając, że zawsze mamy tablicę, w następujący sposób:

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

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

array_shiftjest szybszy niż reset, czyli szybszy niż [count () - 1], a te trzy są szybsze niż array_valuesi array_slice.

Wyobrażam sobie, że autor szukał sposobu na uzyskanie pierwszego elementu tablicy po uzyskaniu go z jakiejś funkcji ( na przykład mysql_fetch_row ) bez generowania STRICT „Tylko zmienne powinny być przekazywane przez referencję”.

Jeśli tak, prawie wszystkie opisane tutaj sposoby otrzymają ten komunikat ... a niektóre z nich wykorzystują dużo dodatkowej pamięci powielającej tablicę (lub jej część). Łatwym sposobem na uniknięcie tego jest przypisanie wartości inline przed wywołaniem którejkolwiek z tych funkcji:

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

W ten sposób nie wyświetla się komunikat STRICT na ekranie ani w dziennikach i nie tworzy się żadnych dodatkowych tablic. Działa zarówno z tablicami indeksowanymi, jak i asocjacyjnymi.

Podoba mi się przykład „lista”, ale „lista” działa tylko po lewej stronie zadania. Jeśli nie chcemy przypisywać zmiennej, bylibyśmy zmuszeni stworzyć tymczasową nazwę, która w najlepszym razie zanieczyszcza nasz zakres, aw najgorszym przypadku zastępuje istniejącą wartość:

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

Powyższe zastąpi istniejącą wartość $ x, a zmienna $ x będzie się zawieszać, dopóki ten zakres będzie aktywny (koniec tej funkcji / metody, lub na zawsze, jeśli będziemy na najwyższym poziomie). Można to obejść za pomocą call_user_func i anonimowej funkcji, ale jest niezręczna:

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

Jeśli użyjemy takich anonimowych funkcji, będziemy w stanie uciec od resetowania i array_shift, nawet jeśli używają pass-by-referencji. Wynika to z tego, że wywołanie funkcji wiąże jej argumenty, a argumenty te można przekazać przez odwołanie:

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

Jest to jednak w rzeczywistości przesada, ponieważ call_user_func wykona to tymczasowe zadanie wewnętrznie. Pozwala to traktować funkcje przekazywania według referencji tak, jakby były wartościami przekazywanymi bez wartości ostrzegawczych lub błędów:

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

Mała zmiana w tym, co opublikował Sarfraz, to:

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

Nie lubię majstrować przy wewnętrznym wskaźniku tablicy, ale również nieefektywne jest budowanie drugiej tablicy za pomocą array_keys()lub array_values(), więc zwykle definiuję to:

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

Spróbuj tego:

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