Récupère le premier élément d'un tableau

J'ai un tableau:

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

Je voudrais obtenir le premier élément de ce tableau. Résultat attendu: chaîne apple

Une exigence: cela ne peut pas être fait en passant par référence , ce array_shiftn'est donc pas une bonne solution.

Comment puis-je faire ceci?

Réponse originale, mais coûteuse (O (n)):

array_shift(array_values($array));

Dans O (1):

array_pop(array_reverse($array));

Autres cas d'utilisation, etc ...

Si la modification (dans le sens de la réinitialisation des pointeurs de tableau) de $arrayn'est pas un problème, vous pouvez utiliser:

reset($array);

Cela devrait être théoriquement plus efficace, si une "copie" de tableau est nécessaire:

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

Avec PHP 5.4+ (mais peut provoquer une erreur d'index s'il est vide):

array_values($array)[0];

Comme Mike l'a souligné (de la manière la plus simple possible):

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

Si vous souhaitez obtenir la clé: (exécutez-la après la réinitialisation)

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

De la documentation de PHP :

réinitialisation mixte (tableau et $ tableau );

La description:

reset () rembobine le pointeur interne du tableau sur le premier élément et renvoie la valeur du premier élément du tableau, ou FALSE si le tableau est vide.

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

Si vous ne voulez pas perdre la position actuelle du pointeur, créez simplement un alias pour le tableau.

current($array)peut vous obtenir le premier élément d'un tableau, selon le manuel PHP .

Chaque tableau a un pointeur interne vers son élément "courant", qui est initialisé au premier élément inséré dans le tableau.

Cela fonctionne donc jusqu'à ce que vous ayez repositionné le pointeur du tableau, sinon vous devrez réinitialiser le tableau.

Vous pouvez obtenir le Nème élément avec une construction de langage, "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;

Avec la array_keysfonction, vous pouvez faire de même pour les touches:

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

PHP 5.4+:

array_values($array)[0];

PHP 7.3 a ajouté deux fonctions pour obtenir directement la première et la dernière clé d'un tableau sans modifier le tableau d'origine et sans créer d'objets temporaires:

• array_key_first
• array_key_last

En plus d'être significatives sur le plan sémantique, ces fonctions ne déplacent même pas le pointeur du tableau (comme le foreachferait).

Ayant les clés, on peut obtenir les valeurs directement par les clés.

Exemples (tous nécessitent PHP 7.3+)

Obtention de la première / dernière clé et valeur:

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

Obtention de la première / dernière valeur en une ligne, en supposant que le tableau ne peut pas être vide :

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

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

Obtention de la première / dernière valeur sous une seule ligne, avec des valeurs par défaut pour les tableaux vides:

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

Supposer:

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

Utilisez simplement:

$array[key($array)]

pour obtenir le premier élément ou

key($array)

pour obtenir la première clé.

Ou vous pouvez dissocier le premier si vous souhaitez le supprimer.

Certains tableaux ne fonctionnent pas avec des fonctions telles que list, resetoucurrent . Ce sont peut-être des tableaux "faux" - implémentant partiellement ArrayIterator, par exemple.

Si vous souhaitez extraire la première valeur quel que soit le tableau, vous pouvez court-circuiter un itérateur:

foreach($array_with_unknown_keys as $value) break;

Votre valeur sera alors disponible en $value et la boucle se cassera après la première itération. C'est plus efficace que de copier un tableau potentiellement volumineux dans une fonction comme array_unshift (array_values ​​($ arr)).

Vous pouvez également saisir la clé de cette façon:

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

Si vous appelez cela à partir d'une fonction, revenez simplement tôt:

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

Des assistants de Laravel :

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

Le tableau étant transmis par valeur à la fonction, la réinitialisation () affecte le pointeur interne d'une copie du tableau et ne touche pas le tableau d'origine (notez qu'il renvoiefalse si le tableau est vide).

Exemple d'utilisation:

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

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

Voici également une alternative. C'est très légèrement plus rapide, mais plus intéressant. Il permet de changer facilement la valeur par défaut si le tableau est vide:

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

Pour mémoire, voici une autre réponse à moi , pour le dernier élément du tableau.

Gardez cela simple! Il y a beaucoup de bonnes réponses ici, mais pour minimiser toute la confusion, ces deux fonctionnent et réduisent beaucoup les frais généraux:

key($array)obtient la première clé d'un tableau
current($array)obtient la première valeur d'un tableau

EDIT:
Concernant les commentaires ci-dessous. L'exemple suivant sortira: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));

Faites simplement:

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

Je le ferais echo current($array).

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

Production:

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

C'est beaucoup plus efficace que array_values()parce que la each()fonction ne copie pas la totalité du tableau.

Pour plus d'informations, voir http://www.php.net/manual/en/function.each.php

Une façon délicate est:

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

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

print get_first($foo);

Obtenez le premier élément:

array_values($arr)[0]

Obtenir le dernier élément

array_reverse($arr)[0]

La plupart de ces travaux! MAIS pour un appel rapide sur une seule ligne (faible 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)

Bien que cela fonctionne, et décemment bien, veuillez également consulter ma réponse supplémentaire: https://stackoverflow.com/a/48410351/1804013

Je pense que l'utilisation de array_values serait votre meilleur pari ici. Vous pouvez retourner la valeur à l'index zéro à partir du résultat de cette fonction pour obtenir «pomme».

C'est un peu tard dans le jeu, mais on m'a présenté un problème où mon tableau contenait des éléments de tableau en tant qu'enfants à l'intérieur, et donc je ne pouvais pas simplement obtenir une représentation sous forme de chaîne du premier élément de tableau. En utilisant la current()fonction de PHP , j'ai réussi ceci:

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

Merci à toutes les solutions actuelles qui m'ont aidé à obtenir cette réponse, j'espère que cela aidera quelqu'un un jour!

Utilisation:

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

Par défaut, array_slicene conserve pas les clés, nous pouvons donc utiliser zéro en toute sécurité comme index.

Deux solutions pour vous.

Solution 1 - Utilisez simplement la clé. Vous n'avez pas dit que vous ne pouviez pas l'utiliser. :)

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

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

Solution 3 - array_keys ()

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

Ce n'est pas une réponse aussi simple dans le monde réel. Supposons que nous ayons ces exemples de réponses possibles que vous pouvez trouver dans certaines bibliothèques.

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

Comme vous pouvez le voir, nous avons plusieurs solutions «une ligne» qui fonctionnent bien dans certains cas, mais pas dans tous.

À mon avis, vous devez utiliser ce gestionnaire uniquement avec des tableaux.

Parlons maintenant des performances, en supposant que nous avons toujours un tableau, comme ceci:

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

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

array_shiftest plus rapide que reset, c'est plus rapide que [count () - 1], et ces trois sont plus rapides que array_valueset array_slice.

J'imagine que l'auteur cherchait simplement un moyen d'obtenir le premier élément d'un tableau après l'avoir obtenu à partir d'une fonction ( mysql_fetch_row , par exemple) sans générer de STRICT "Seules les variables doivent être passées par référence".

Si c'est le cas, presque toutes les façons décrites ici obtiendront ce message ... et certaines d'entre elles utilisent beaucoup de mémoire supplémentaire pour dupliquer un tableau (ou une partie de celui-ci). Un moyen simple de l'éviter consiste simplement à affecter la valeur en ligne avant d'appeler l'une de ces fonctions:

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

De cette façon, vous n'obtenez pas le message STRICT à l'écran, ni dans les journaux, et vous ne créez pas de tableaux supplémentaires. Il fonctionne avec les deux tableaux indexés ET associatifs .

J'aime l'exemple "list", mais "list" ne fonctionne que sur le côté gauche d'une affectation. Si nous ne voulons pas affecter une variable, nous serions obligés de créer un nom temporaire, qui au mieux pollue notre portée et au pire écrase une valeur existante:

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

Ce qui précède remplacera toute valeur existante de $ x, et la variable $ x restera aussi longtemps que cette portée sera active (à la fin de cette fonction / méthode, ou pour toujours si nous sommes au niveau supérieur). Cela peut être contourné en utilisant call_user_func et une fonction anonyme, mais c'est maladroit:

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

Si nous utilisons des fonctions anonymes comme celle-ci, nous pouvons réellement nous en sortir avec reset et array_shift, même s'ils utilisent pass-by-reference. En effet, l'appel d'une fonction liera ses arguments, et ces arguments peuvent être passés par référence:

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

Cependant, cela est en fait exagéré, car call_user_func effectuera cette affectation temporaire en interne. Cela nous permet de traiter les fonctions passe-par-référence comme si elles étaient passe-par-valeur, sans aucun avertissement ni erreur:

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

Un petit changement par rapport à ce que Sarfraz a publié est:

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

Je n'aime pas jouer avec le pointeur interne du tableau, mais il est également inefficace de construire un deuxième tableau avec array_keys()ou array_values(), donc je définis généralement ceci:

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

Essaye ça:

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