Holen Sie sich das erste Element eines Arrays

Ich habe ein Array:

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

Ich möchte das erste Element dieses Arrays erhalten. Erwartetes Ergebnis: Zeichenfolge apple

Eine Anforderung: Es kann nicht mit Referenzübergabe durchgeführt werden , daher array_shiftist dies keine gute Lösung.

Wie kann ich das machen?

Ursprüngliche Antwort, aber teuer (O (n)):

array_shift(array_values($array));

In O (1):

array_pop(array_reverse($array));

Andere Anwendungsfälle usw ...

Wenn das Ändern (im Sinne des Zurücksetzens von Array-Zeigern) von $arraykein Problem darstellt, können Sie Folgendes verwenden:

reset($array);

Dies sollte theoretisch effizienter sein, wenn eine Array- "Kopie" benötigt wird:

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

Mit PHP 5.4+ (kann aber einen Indexfehler verursachen, wenn leer):

array_values($array)[0];

Wie Mike betonte (der einfachste Weg):

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

Wenn Sie den Schlüssel erhalten möchten: (führen Sie ihn nach dem Zurücksetzen aus)

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

Aus der PHP-Dokumentation :

gemischter Reset (Array & $ Array );

Beschreibung:

reset () spult den internen Zeiger des Arrays auf das erste Element zurück und gibt den Wert des ersten Array-Elements zurück oder FALSE, wenn das Array leer ist.

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

Wenn Sie die aktuelle Zeigerposition nicht verlieren möchten, erstellen Sie einfach einen Alias ​​für das Array.

current($array)Sie können das erste Element eines Arrays gemäß dem PHP-Handbuch erhalten .

Jedes Array hat einen internen Zeiger auf sein "aktuelles" Element, der auf das erste in das Array eingefügte Element initialisiert wird.

Es funktioniert also so lange, bis Sie den Array-Zeiger neu positioniert haben. Andernfalls müssen Sie das Array zurücksetzen.

Sie können das N-te Element mit dem Sprachkonstrukt "list" erhalten:

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

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

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

Mit der array_keysFunktion können Sie dasselbe für Tasten tun:

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

PHP 5.4+:

array_values($array)[0];

PHP 7.3 fügte zwei Funktionen hinzu, um den ersten und den letzten Schlüssel eines Arrays direkt abzurufen ohne das ursprüngliche Array zu ändern und ohne temporäre Objekte zu erstellen:

• array_key_first
• array_key_last

Abgesehen davon, dass diese Funktionen semantisch sinnvoll sind, bewegen sie nicht einmal den Array-Zeiger (wie foreachdies der Fall wäre).

Mit den Schlüsseln kann man die Werte direkt über die Schlüssel abrufen.

Beispiele (alle erfordern PHP 7.3+)

Erhalten des ersten / letzten Schlüssels und Werts:

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

Abrufen des ersten / letzten Werts als Einzeiler, vorausgesetzt, das Array kann nicht leer sein :

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

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

Abrufen des ersten / letzten Werts als Einzeiler mit Standardeinstellungen für leere Arrays:

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

Annehmen:

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

Benutz einfach:

$array[key($array)]

erstes Element bekommen oder

key($array)

um den ersten Schlüssel zu bekommen.

Oder Sie können die erste Verknüpfung aufheben, wenn Sie sie entfernen möchten.

Einige Arrays funktionieren nicht mit Funktionen wie list, resetodercurrent . Vielleicht handelt es sich um "Faux" -Arrays, die beispielsweise teilweise ArrayIterator implementieren.

Wenn Sie den ersten Wert unabhängig vom Array abrufen möchten, können Sie einen Iterator kurzschließen:

foreach($array_with_unknown_keys as $value) break;

Ihr Wert wird dann in verfügbar sein $value und die Schleife wird nach der ersten Iteration unterbrochen. Dies ist effizienter als das Kopieren eines potenziell großen Arrays in eine Funktion wie array_unshift (array_values ​​($ arr)).

Sie können den Schlüssel auch folgendermaßen greifen:

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

Wenn Sie dies von einer Funktion aus aufrufen, kehren Sie einfach frühzeitig zurück:

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

Von Laravels Helfern :

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

Wenn das Array als Wert an die Funktion übergeben wird, wirkt sich reset () auf den internen Zeiger einer Kopie des Arrays aus und berührt das ursprüngliche Array nicht (beachten Sie, dass es zurückgegeben wirdfalseWenn das Array als wenn das Array leer ist).

Anwendungsbeispiel:

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

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

Auch hier ist eine Alternative. Es ist sehr geringfügig schneller, aber interessanter. Der Standardwert kann leicht geändert werden, wenn das Array leer ist:

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

Für die Aufzeichnung ist hier eine andere Antwort von mir , für das letzte Element des Arrays.

Halte das einfach! Hier gibt es viele richtige Antworten, aber um die Verwirrung zu minimieren, funktionieren diese beiden und reduzieren den Overhead:

key($array)Ruft den ersten Schlüssel eines Arrays ab.
current($array)Ruft den ersten Wert eines Arrays ab

EDIT:
In Bezug auf die Kommentare unten. Das folgende Beispiel wird ausgegeben: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));

Einfach machen:

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

Ich würde es tun echo current($array).

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

Ausgabe:

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

Dies ist viel effizienter als array_values()weil die each()Funktion nicht das gesamte Array kopiert.

Weitere Informationen finden Sie unter http://www.php.net/manual/en/function.each.php

Ein klobiger Weg ist:

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

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

print get_first($foo);

Holen Sie sich das erste Element:

array_values($arr)[0]

Holen Sie sich das letzte Element

array_reverse($arr)[0]

Die meisten davon funktionieren! ABER für einen schnellen Anruf in einer Leitung (mit geringen Ressourcen):

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

Obwohl dies funktioniert und anständig gut ist, lesen Sie bitte auch meine zusätzliche Antwort: https://stackoverflow.com/a/48410351/1804013

Ich denke, die Verwendung von array_values wäre hier die beste Wahl . Sie können den Wert am Index Null aus dem Ergebnis dieser Funktion zurückgeben, um 'apple' zu erhalten.

Dies ist etwas spät im Spiel, aber ich hatte ein Problem, bei dem mein Array Array-Elemente als untergeordnete Elemente enthielt, und daher konnte ich nicht einfach eine Zeichenfolgendarstellung des ersten Array-Elements erhalten. Mit der PHP- current()Funktion habe ich Folgendes geschafft:

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

Dank all der aktuellen Lösungen, die mir geholfen haben, zu dieser Antwort zu gelangen, hoffe ich, dass dies irgendwann jemandem hilft!

Verwenden:

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

Standardmäßig werden array_slicekeine Schlüssel beibehalten, sodass wir sicher Null als Index verwenden können.

Zwei Lösungen für Sie.

Lösung 1 - Verwenden Sie einfach den Schlüssel. Sie haben nicht gesagt, dass Sie es nicht verwenden können. :) :)

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

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

Lösung 3 - array_keys ()

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

Dies ist in der realen Welt keine so einfache Antwort. Angenommen, wir haben diese Beispiele für mögliche Antworten, die Sie in einigen Bibliotheken finden können.

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

Wie Sie sehen können, haben wir mehrere "One Line" -Lösungen, die in einigen Fällen gut funktionieren, aber nicht in allen.

Meiner Meinung nach sollten Sie diesen Handler nur mit Arrays haben.

Sprechen wir jetzt über die Leistung, vorausgesetzt, wir haben immer ein Array wie folgt:

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

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

array_shiftist schneller als reset, das ist schneller als [count () - 1], und diese drei sind schneller als array_valuesund array_slice.

Ich kann mir vorstellen, dass der Autor nur nach einer Möglichkeit gesucht hat, das erste Element eines Arrays zu erhalten, nachdem es von einer Funktion ( mysql_fetch_row) abgerufen wurde z. B. ) , ohne ein STRICT zu generieren. "Nur Variablen sollten als Referenz übergeben werden".

In diesem Fall erhalten fast alle hier beschriebenen Methoden diese Meldung ... und einige von ihnen verwenden viel zusätzlichen Speicher, um ein Array (oder einen Teil davon) zu duplizieren. Eine einfache Möglichkeit, dies zu vermeiden, besteht darin, den Wert inline zuzuweisen, bevor eine dieser Funktionen aufgerufen wird:

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

Auf diese Weise erhalten Sie weder die STRICT-Meldung auf dem Bildschirm noch in Protokollen, und Sie erstellen keine zusätzlichen Arrays. Es funktioniert sowohl mit indizierten als auch mit assoziativen Arrays.

Ich mag das Beispiel "Liste", aber "Liste" funktioniert nur auf der linken Seite einer Aufgabe. Wenn wir keine Variable zuweisen möchten, müssen wir einen temporären Namen erstellen, der bestenfalls unseren Gültigkeitsbereich verschmutzt und im schlimmsten Fall einen vorhandenen Wert überschreibt:

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

Das Obige überschreibt jeden vorhandenen Wert von $ x und die Variable $ x bleibt bestehen, solange dieser Bereich aktiv ist (das Ende dieser Funktion / Methode oder für immer, wenn wir uns in der obersten Ebene befinden). Dies kann mit call_user_func und einer anonymen Funktion umgangen werden, ist aber umständlich:

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

Wenn wir anonyme Funktionen wie diese verwenden, können wir tatsächlich mit reset und array_shift davonkommen, obwohl sie Pass-by-Reference verwenden. Dies liegt daran, dass der Aufruf einer Funktion ihre Argumente bindet und diese Argumente als Referenz übergeben werden können:

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

Dies ist jedoch tatsächlich ein Overkill, da call_user_func diese temporäre Zuweisung intern ausführt. Auf diese Weise können wir Pass-by-Reference-Funktionen so behandeln, als wären sie Pass-by-Value-Funktionen, ohne Warnungen oder Fehler:

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

Eine kleine Änderung an dem, was Sarfraz gepostet hat, ist:

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

Ich mag es nicht, mit dem internen Zeiger des Arrays herumzuspielen, aber es ist auch ineffizient, ein zweites Array mit array_keys()oder zu erstellen array_values(), daher definiere ich dies normalerweise:

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

Versuche dies:

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