Ottieni il primo elemento di un array

Ho un array:

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

Vorrei ottenere il primo elemento di questo array. Risultato atteso: stringa apple

Un requisito: non può essere fatto con il passaggio per riferimento , quindi array_shiftnon è una buona soluzione.

Come posso fare questo?

Risposta originale, ma costosa (O (n)):

array_shift(array_values($array));

In O (1):

array_pop(array_reverse($array));

Altri casi d'uso, ecc ...

Se la modifica (nel senso di reimpostazione dei puntatori di array) di $arraynon è un problema, è possibile utilizzare:

reset($array);

Questo dovrebbe essere teoricamente più efficiente, se è necessaria una "copia" di array:

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

Con PHP 5.4+ (ma potrebbe causare un errore di indice se vuoto):

array_values($array)[0];

Come ha sottolineato Mike (il modo più semplice possibile):

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

Se si desidera ottenere la chiave: (eseguirla dopo il ripristino)

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

Dalla documentazione di PHP :

reset misto (array e $ array );

Descrizione:

reset () riavvolge il puntatore interno dell'array al primo elemento e restituisce il valore del primo elemento dell'array o FALSE se l'array è vuoto.

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

Se non si desidera perdere la posizione corrente del puntatore, è sufficiente creare un alias per l'array.

current($array)può procurarti il ​​primo elemento di un array, secondo il manuale di PHP .

Ogni array ha un puntatore interno al suo elemento "corrente", che viene inizializzato sul primo elemento inserito nell'array.

Quindi funziona fino a quando non si riposiziona il puntatore dell'array, altrimenti si dovrà reimpostare l'array.

È possibile ottenere l'ennesimo elemento con un costrutto di linguaggio, "elenco":

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

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

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

Con la array_keysfunzione puoi fare lo stesso per i tasti:

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

PHP 5.4+:

array_values($array)[0];

PHP 7.3 aggiunto due funzioni per ottenere la prima e l'ultima chiave di un array direttamente senza modifiche dell'array originale e senza creare alcun oggetto temporaneo:

• array_key_first
• array_key_last

Oltre ad essere semanticamente significative, queste funzioni non spostano nemmeno il puntatore di array (come foreach farebbe).

Avendo le chiavi, si possono ottenere direttamente i valori dalle chiavi.

Esempi (tutti richiedono PHP 7.3+)

Ottenere la prima / ultima chiave e valore:

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

Ottenere il primo / ultimo valore come una riga, supponendo che l'array non possa essere vuoto :

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

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

Ottenere il primo / ultimo valore come una riga, con valori predefiniti per array vuoti:

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

Supponiamo che:

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

Usa solo:

$array[key($array)]

per ottenere il primo elemento o

key($array)

per ottenere la prima chiave.

Oppure puoi scollegare il primo se vuoi rimuoverlo.

Alcuni array non funzionano con funzioni come list, resetocurrent . Forse sono array "falsi", ad esempio implementando parzialmente ArrayIterator.

Se si desidera estrarre il primo valore indipendentemente dall'array, è possibile cortocircuitare un iteratore:

foreach($array_with_unknown_keys as $value) break;

Il tuo valore sarà quindi disponibile in $value e il ciclo si interromperà dopo la prima iterazione. Questo è più efficiente della copia di un array potenzialmente grande in una funzione come array_unshift (array_values ​​($ arr)).

Puoi anche prendere la chiave in questo modo:

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

Se lo chiami da una funzione, torna semplicemente in anticipo:

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

Dagli aiutanti di Laravel :

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

L'array viene passato per valore alla funzione, il reset () influenza il puntatore interno di una copia dell'array e non tocca l'array originale (nota che ritornafalse se l'array è vuoto).

Esempio di utilizzo:

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

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

Inoltre, ecco un'alternativa. È molto più veloce, ma più interessante. Consente di modificare facilmente il valore predefinito se l'array è vuoto:

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

Per la cronaca, ecco un'altra mia risposta , per l'ultimo elemento dell'array.

Mantieni questo semplice! Ci sono molte risposte corrette qui, ma per ridurre al minimo tutta la confusione, questi due funzionano e riducono molte spese generali:

key($array)ottiene la prima chiave di un array
current($array)ottiene il primo valore di un array

EDIT: per
quanto riguarda i commenti qui sotto. Verrà visualizzato il seguente esempio: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));

Fai semplicemente:

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

Lo farei echo current($array).

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

Produzione:

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

Questo è molto più efficiente rispetto al array_values()fatto che la each()funzione non copia l'intero array.

Per maggiori informazioni vedi http://www.php.net/manual/en/function.each.php

Un modo kludgy è:

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

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

print get_first($foo);

Ottieni il primo elemento:

array_values($arr)[0]

Ottieni l'ultimo elemento

array_reverse($arr)[0]

Molti di questi funzionano! MA per una chiamata rapida a linea singola (risorsa bassa):

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

Anche se funziona, e discretamente bene, per favore vedi anche la mia risposta aggiuntiva: https://stackoverflow.com/a/48410351/1804013

Penso che usare array_values sia la soluzione migliore qui. È possibile restituire il valore all'indice zero dal risultato di quella funzione per ottenere 'apple'.

Questo è un po 'tardi per il gioco, ma mi è stato presentato un problema in cui il mio array conteneva elementi array come bambini al suo interno, e quindi non potevo semplicemente ottenere una rappresentazione in forma di stringa del primo elemento array. Usando la current()funzione di PHP , ho gestito questo:

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

Grazie a tutte le soluzioni attuali mi hanno aiutato ad arrivare a questa risposta, spero che questo aiuti qualcuno a volte!

Uso:

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

Per impostazione predefinita, array_slicenon conserva le chiavi, quindi possiamo tranquillamente utilizzare zero come indice.

Due soluzioni per te.

Soluzione 1: basta usare il tasto. Non hai detto che non puoi usarlo. :)

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

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

Soluzione 3 - array_keys ()

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

Questa non è una risposta così semplice nel mondo reale. Supponiamo di avere questi esempi di possibili risposte che puoi trovare in alcune librerie.

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

Come puoi vedere, abbiamo diverse soluzioni "a una linea" che funzionano bene in alcuni casi, ma non in tutti.

Secondo me, dovresti avere quell'handler solo con array.

Ora parlando di prestazioni, supponendo che abbiamo sempre array, in questo modo:

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

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

array_shiftè più veloce di reset, cioè più veloce di [count () - 1], e questi tre sono più veloci di array_valuese array_slice.

Immagino che l'autore stesse solo cercando un modo per ottenere il primo elemento di un array dopo averlo ottenuto da una funzione ( mysql_fetch_row , ad esempio) senza generare un STRICT "Solo le variabili devono essere passate per riferimento".

In tal caso, quasi tutti i modi qui descritti riceveranno questo messaggio ... e alcuni di essi utilizzano molta memoria aggiuntiva per duplicare un array (o parte di esso). Un modo semplice per evitarlo è semplicemente assegnare il valore in linea prima di chiamare una di queste funzioni:

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

In questo modo non viene visualizzato il messaggio STRICT né sullo schermo né nei registri e non si creano array aggiuntivi. Funziona con array indicizzati E associativi .

Mi piace l'esempio "list", ma "list" funziona solo sul lato sinistro di un compito. Se non vogliamo assegnare una variabile, saremmo costretti a creare un nome temporaneo, che nella migliore delle ipotesi inquina il nostro ambito e nel peggiore dei casi sovrascrive un valore esistente:

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

Quanto sopra sovrascriverà qualsiasi valore esistente di $ x, e la variabile $ x rimarrà attiva fintanto che questo ambito è attivo (la fine di questa funzione / metodo, o per sempre se siamo al livello superiore). Questo può essere aggirato usando call_user_func e una funzione anonima, ma è goffo:

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

Se utilizziamo funzioni anonime come questa, possiamo effettivamente cavarcela con reset e array_shift, anche se usano il pass-by-reference. Questo perché la chiamata di una funzione vincolerà i suoi argomenti e questi argomenti possono essere passati per riferimento:

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

Tuttavia, questo è in realtà eccessivo, poiché call_user_func eseguirà questa assegnazione temporanea internamente. Questo ci consente di trattare le funzioni pass-by-reference come se fossero pass-by-value, senza avvisi o errori:

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

Una piccola modifica a ciò che Sarfraz ha pubblicato è:

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

Non mi piace armeggiare con il puntatore interno dell'array, ma è anche inefficiente costruire un secondo array con array_keys()o array_values(), quindi di solito lo definisco:

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

Prova questo:

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