it-swarm.com.de

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 ist array_shift keine gute Lösung.

Wie kann ich das machen?

949
hsz

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

array_shift(array_values($array));

In O (1):

array_pop(array_reverse($array));

Bearbeitet mit Vorschlägen aus Kommentaren für andere Anwendungsfälle usw.

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

reset($array);

Dies sollte theoretisch effizienter sein, wenn ein Array "Kopieren" benötigt wird:

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

Mit PHP 5.4+ (kann jedoch einen Indexfehler verursachen, wenn er leer ist):

array_values($array)[0];
1189
blueyed

Wie Mike darauf hingewiesen hat (der einfachste Weg):

$arr = array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' )
echo reset($arr); //echoes "Apple"

Wenn Sie den Schlüssel erhalten wollen: (Nach Reset ausführen)

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

Aus PHP Dokumentation :

gemischtreset (Array & $ array);

Beschreibung:

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

742
lepe
$first_value = reset($array); // First Element's Value
$first_key = key($array); // First Element's Key

Hoffe das hilft. :)

254
Ijas Ameenudeen
$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.

88
yoda

current($array) kann Ihnen das erste Element eines Arrays liefern, gemäß PHP manual .

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

So funktioniert es, bis Sie den Array-Zeiger neu positioniert haben, andernfalls müssen Sie das Array zurücksetzen.

79
Tofeeq

Sie können das N-te Element mit einem Sprachkonstrukt "Liste" erhalten:

// 1st item
list($firstItem) = $yourArray;

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

// 2nd item
list( , $secondItem) = $yourArray;

mit der Funktion array_keys können Sie dasselbe für Schlüssel tun:

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

PHP 5.4+:

array_values($array)[0];
52
Samer Ata

Annehmen:

$array = array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' );

Benutz einfach:

$array[key($array)]

erstes Element zu 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.

27
Lucas

Einige Arrays funktionieren nicht mit Funktionen wie list, reset oder current. Möglicherweise handelt es sich dabei um "faux" Arrays, die zum Beispiel 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 steht dann in $value zur Verfügung 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 so packen:

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

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

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

PHP 7.3 fügte zwei Funktionen hinzu, um den ersten und den letzten Schlüssel eines Arrays direkt ohne Änderung des ursprünglichen Arrays und ohne das Erstellen temporärer Objekte zu erhalten:

Abgesehen von ihrer semantischen Bedeutung verschieben diese Funktionen nicht einmal den Arrayzeiger (wie foreach dies tun würde). 

Wenn Sie die Tasten haben, können Sie die Werte direkt über die Tasten abrufen.


Beispiele (alle erfordern PHP 7.3+)

Den ersten/letzten Schlüssel und Wert abrufen:

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

Den ersten/letzten Wert als Einzeiler erhalten, vorausgesetzt, das Array darf nicht leer sein:

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

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

Den ersten/letzten Wert als Einzeiler erhalten, mit Standardwerten 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) ];
14
Alex Shesterov

Einfach machen:

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

Von Laravel's Helfern :

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

Das Array wird als Wert an die Funktion übergeben, der reset () beeinflusst den internen Zeiger einer Kopie des Arrays und berührt nicht das ursprüngliche Array. (Hinweis: es gibt false zurück, 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 etwas marginal schneller, aber interessanter, lässt sich der Standardwert leicht ändern, wenn das Array leer ist:

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

    return $default;
}



Hier ist eine andere Antwort von mir , für das letzte Element des Arrays.

12
Gras Double

Ich würde echo current($array) machen. 

11
user1485518
$myArray = array (4 => 'Apple', 7 => 'orange', 13 => 'Plum');
$arrayKeys = array_keys($myArray);

// the first element of your array is:
echo $myArray[$arrayKeys[0]];  
10
Jacob Topping
$array=array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' );

$firstValue = each($array)[1];

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

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

9
rustyx
$arr = array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' );
foreach($arr as $first) break;
echo $first;

Ausgabe:

Apple
9
tekin

Ein kludgy 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);
8

Die meisten davon arbeiten! ABER für einen schnellen Aufruf mit einer einzigen Leitung (geringe Ressource):

$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 gut funktioniert, sehen Sie bitte auch meine zusätzliche Antwort: https://stackoverflow.com/a/48410351/1804013

7
tfont

Holen Sie sich das erste Element:

array_values($arr)[0]

Holen Sie sich das letzte Element

array_reverse($arr)[0]
6
Adobe

Behalte das einfach! Viele richtige Antworten hier, aber um alle Verwirrungen zu minimieren. Diese beiden arbeiten und reduzieren viel Aufwand.

key($array) = erhält den ersten Schlüssel eines Arrays
current($array) = liefert den ersten Wert eines Arrays

5
tfont

Benutzen:

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

Standardmäßig behält array_slice keine Schlüssel bei, sodass wir Null als Index verwenden können.

4
Bazi

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

<?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, diese Antwort zu finden, hoffe ich, dass dies jemandem irgendwann hilft!

4
Chris Kempen

Zwei Lösungen für Sie.

Lösung 1 - Verwenden Sie einfach die Taste. Sie haben nicht gesagt, dass Sie es nicht verwenden können. :)

<?php
// get 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 an reset in
// just to make sure that the array pointer is at first element
// also reset return the first element
// reset($myArray);

// return first key 
$firstKey = key($array); 

assert('$firstKey === "Apple" /* Expected result: string Apple. */');
?>

Lösung 3 - array_keys ()

echo $array[array_keys($array)[0]];
4
Jens A. Koch

Ich denke mit 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.

4
jmking

Dies ist keine so einfache Antwort in der realen Welt. Vor allem haben wir 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 "einzeilige" Lösungen, die in einigen Fällen gut funktionieren, jedoch nicht in allen.

Meiner Meinung nach sollte man diesen Handler nur mit Arrays haben.

Wenn wir jetzt über Leistung sprechen, nehmen wir an, 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_shift ist schneller als reset, dh schneller als [count () - 1] und diese drei sind schneller als array_values ​​und array_slice

2
Steven Koch

Berücksichtigen Sie auch den Kontext, in dem Sie dies tun, da eine umfassende Überprüfung teuer und nicht immer notwendig ist.

Zum Beispiel funktioniert diese Lösung gut für die Situation, in der ich sie benutze (aber offensichtlich nicht auf alle Fälle ...)

 /**
 * A quick and dirty way to determine whether the passed in array is associative or not, assuming that either:<br/>
 * <br/>
 * 1) All the keys are strings - i.e. associative<br/>
 * or<br/>
 * 2) All the keys are numeric - i.e. not associative<br/>
 * 
 * @param array $objects
 * @return boolean
 */
private function isAssociativeArray(array $objects)
{
    // This isn't true in the general case, but it's a close enough (and quick) approximation for the context in
    // which we're using it.

    reset($objects);
    return count($objects) > 0 && is_string(key($objects));
}
1
Dan King

Alter Post aber trotzdem ... Ich denke, der Autor suchte nur nach einem Weg, um das erste Element eines Arrays zu erhalten, nachdem es von einer Funktion (z. B. mysql_fetch_row) abgerufen wurde, ohne einen STRICT zu erzeugen. Wenn dies der Fall ist, wird almos auf alle hier beschriebenen Arten diese Meldung erhalten ... und einige von ihnen benötigen viel zusätzlichen Speicher, der ein Array (oder einen Teil davon) dupliziert. Dies lässt sich auf einfache Weise vermeiden, indem Sie den Wert vor dem Aufruf einer dieser Funktionen inline zuweisen:

$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 wird die STRICT-Meldung weder in Protokollen auf dem Bildschirm angezeigt, noch werden zusätzliche Arrays erstellt. Es funktioniert mit sowohl mit indizierten als auch mit assoziativen Arrays

1
dmikam

Versuche dies:

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

1

Eine kleine Änderung gegenüber dem, was Sarfraz gepostet hat, ist:

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

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

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

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

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

Der obige Wert überschreibt jeden vorhandenen Wert von $ x, und die Variable $ x hängt herum, solange dieser Bereich aktiv ist (das Ende dieser Funktion/Methode oder für immer, wenn wir uns auf der obersten Ebene befinden). Dies kann mit call_user_func und einer anonymen Funktion umgangen werden, ist aber unübersichtlich:

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

Wenn wir anonyme Funktionen wie diese verwenden, können wir mit reset und array_shift tatsächlich durchkommen, 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 durchführt. Dadurch können wir Referenz-Referenz-Funktionen so behandeln, als wären sie Wert-Pass-Werte ohne Warnungen oder Fehler:

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

Niemand hat vorgeschlagen, die ArrayIterator-Klasse zu verwenden:

$array = array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' );
$first_element = (new ArrayIterator($array))->current();
echo $first_element; //'Apple'

umgeht die durch Referenzvereinbarung des OP.

0
pgee70

Verwenden Siearray_keys(), um als numerisch indiziertes Array auf die Schlüssel Ihres assoziativen Arrays zuzugreifen, das dann wiederum als Schlüssel für das Array verwendet werden kann.

Wenn die Lösung arr[0] ist :

(Da das Array mit den Schlüsseln auf 0 basiert, ist das 1. Element Index 0.)

Sie können eine Variable verwenden und dann eine davon subtrahieren, um Ihre Logik 1 => 'Apple' zu erhalten.

$i = 1;
$arr = array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' );
echo $arr[array_keys($arr)[$i-1]];

Ausgabe:

Apple

Zur Vereinfachung verwenden Sie einfach:

$arr = array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' );
echo $arr[array_keys($arr)[0]];

Ausgabe:

Apple

Mit der ersten Methode kann nicht nur das erste Element, sondern ein assoziatives Array wie ein indiziertes Array behandelt werden.

0
Ataboy Josef

Nizza mit einer Kombination aus array_slice und implode:

$arr = array(1, 2, 3);
echo implode(array_slice($arr, 0, 1));
// Outputs 1

/*---------------------------------*/

$arr = array(
    'key_1' => 'One',
    'key_2' => 'Two',
    'key_3' => 'Three',
);
echo implode(array_slice($arr, 0, 1));
// Outputs One
0
Nabil Kadimi

sie können das erste Element mit dieser Codierung erhalten

$array_key_set = array_keys($array);
$first_element = $array[$array_key_set[0]];

Oder verwenden

$i=0;
foreach($array as $arr)
{
  if($i==0)
  {
    $first_element=$arr;
    break;
  }
 $i++;
}
echo $first_element;
0