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

Question

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 , donc array_shift n’est pas une bonne solution.

Comment puis-je faire ceci?

blueyed · Accepted Answer

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

array_shift(array_values($array));

En O (1):

array_pop(array_reverse($array));

Édité avec des suggestions de commentaires à partir d'autres cas d'utilisation, etc ...

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

reset($array);

Cela devrait être théoriquement plus efficace, si un tableau "copy" 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];

lepe · Answer

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

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

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

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

De la documentation PHP :

mixte réinitialiser (tableau & $ tableau);

La description:

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

Ijas Ameenudeen · Answer

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

J'espère que cela t'aides. :)

yoda · Answer

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

Sergiy Sokolenko · Answer

Vous pouvez obtenir le Nième élément avec une construction de langage "liste":

// 1st item list($firstItem) = $yourArray; // 1st item from an array that is returned from function list($firstItem) = functionThatReturnsArray(); // 2nd item list( , $secondItem) = $yourArray;

avec la fonction array_keys vous pouvez faire la même chose pour les clés:

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

Samer Ata · Answer

PHP 5.4+:

array_values($array)[0];

Lucas · Answer

Supposer:

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

Il suffit d'utiliser:

$array[key($array)]

pour obtenir le premier élément ou

key($array)

obtenir la première clé.

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

Lee Benson · Answer

Certains tableaux ne fonctionnent pas avec des fonctions telles que list, reset ou current. Peut-être que ce sont des "faux" tableaux, mettant partiellement en œuvre ArrayIterator, par exemple.

Si vous voulez 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 dans $value et la boucle sera cassée après la première itération. Cela est plus efficace que de copier un tableau potentiellement volumineux dans une fonction telle que array_unshift (array_values ($ arr)).

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

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

Si vous appelez cela depuis une fonction, revenez simplement plus tôt:

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

Alex Shesterov · Answer

PHP 7.3 a ajouté deux fonctions pour obtenir la première et la dernière clé d'un tableau directement sans modification du tableau d'origine ni création d'objets temporaires:

Outre leur signification sémantique, ces fonctions ne déplacent même pas le pointeur de tableau (comme le ferait foreach).

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

Exemples (tous nécessitent PHP 7.3+)

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

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

Obtenir la première/dernière valeur en une ligne, avec les 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) ];

DiverseAndRemote.com · Answer

Faites simplement:

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

Gras Double · Answer

De Laravel's helpers :

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

Le tableau étant passé par valeur à la fonction, le reset () affecte le pointeur interne d'une copie du tableau, il ne touche pas le tableau d'origine. (notez qu'il renvoie false si le tableau est vide)

Exemple d'utilisation:

$data = ['foo', 'bar', 'baz']; current($data); // foo next($data); // bar head($data); // foo next($data); // baz

Aussi, voici une alternative. C'est très marginalement 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 de mes réponses , pour le dernier élément du tableau.

user1485518 · Answer

Je ferais echo current($array).

Jacob Topping · Answer

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

rustyx · Answer

$array=array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' ); $firstValue = each($array)[1];

Ceci est beaucoup plus efficace que array_values() car la fonction each() ne copie pas l'intégralité du tableau.

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

tekin · Answer

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

Sortie:

Apple

William Macdonald · Answer

Une façon kludgy est:

$foo = array( 4 => 'Apple', 7 => 'orange', 13 => 'Plum' ); function get_first ($foo) { foreach ($foo as $k=>$v){ return $v; } } print get_first($foo);

tfont · Answer

La plupart d'entre eux fonctionnent! MAIS pour un appel rapide simple ligne (ressources faibles):

$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 voir ma réponse supplémentaire: https://stackoverflow.com/a/48410351/1804013

Adobe · Answer

Obtenir le premier élément:

array_values($arr)[0]

Obtenir le dernier élément

array_reverse($arr)[0]

tfont · Answer

Gardez cela simple! Beaucoup de réponses correctes ici, mais pour minimiser toute la confusion. Ces deux travaillent et réduisent beaucoup de frais généraux.

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

Bazi · Answer

Utilisation:

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

Par défaut, array_slice ne conserve pas les clés. Nous pouvons donc utiliser zéro en toute sécurité.

Chris Kempen · Answer

C’est un peu tard pour le jeu, mais j’ai eu un problème: mon tableau contenait des éléments de tableau en tant qu’enfants, et je ne pouvais donc pas obtenir une représentation sous forme de chaîne du premier élément de tableau. En en utilisant la fonction current() 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 m'a aidé à obtenir cette réponse, j'espère que cela aide quelqu'un de temps en temps!

Jens A. Koch · Answer

Deux solutions pour vous.

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

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

Solution 2 - array_flip () + clé ()

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

Solution 3 - array_keys ()

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

jmking · Answer

Je pense que l’utilisation de array_values serait votre meilleur choix ici. Vous pouvez renvoyer la valeur d'index zéro à partir du résultat de cette fonction pour obtenir "Apple".

Steven Koch · Answer

Ce n'est pas si simple réponse dans le monde réel. C’est pourquoi nous avons cet exemple 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 constater, nous avons plusieurs solutions «en une seule ligne» qui fonctionnent bien dans certains cas, mais pas dans toutes.

À mon avis, ce gestionnaire ne devrait utiliser que des tableaux.

Parlons maintenant des performances, en supposant que nous ayons toujours des tableaux, comme ceci:

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

array_shift est plus rapide que reset, plus rapide que [count () - 1] et ces trois sont plus rapides que array_values et array_slice

Dan King · Answer

Il convient également de garder à l’esprit le contexte dans lequel vous vous trouvez, car une vérification exhaustive peut être coûteuse et pas toujours nécessaire.

Par exemple, cette solution fonctionne bien pour la situation dans laquelle je l’utilise (mais ne peut évidemment pas être utilisée dans tous les cas ...)

 /** * 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)); }

dmikam · Answer

Ancien post mais quand même ... J'imagine que l'auteur cherchait simplement un moyen d'obtenir le premier élément d'un tableau après l'avoir obtenu depuis 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 tel est le cas, presque tous les moyens décrits ici recevront ce message ... et certains utilisent beaucoup de mémoire supplémentaire pour dupliquer un tableau (ou une partie de celui-ci). Un moyen facile de l'éviter consiste simplement à attribuer 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, le message STRICT n'est pas affiché à l'écran ni dans les journaux et vous ne créez pas de tableaux supplémentaires. Cela fonctionne avec à la fois indexé et associatif tableaux

$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, le message STRICT n'est pas affiché à l'écran ni dans les journaux et vous ne créez pas de tableaux supplémentaires. Cela fonctionne avec à la fois indexé et associatif tableaux

Wakar Ahmad Khan · Answer

Essaye ça:

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

Jan Detlefsen · Answer

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

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

Jesse · Answer

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

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

Warbo · Answer

J'aime bien l'exemple "liste", mais "liste" ne fonctionne que sur le côté gauche d'une affectation. Si nous ne souhaitons pas affecter une variable, nous serions obligés de créer un nom temporaire, qui polluerait au mieux notre portée et, au pire, écraserait 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 en mémoire tant que cette étendue sera active (fin de cette fonction/méthode, ou indéfiniment 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 nous échapper avec reset et array_shift, même s'ils utilisent la méthode de référence par passe. En effet, l'appel d'une fonction lie 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, il s’agit effectivement d’un dépassement, car call_user_func effectuera cette affectation temporaire en interne. Cela nous permet de traiter les fonctions avec référence comme si elles étaient avec valeur, sans aucun avertissement ni erreur:

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

pgee70 · Answer

Personne n'a suggéré d'utiliser la classe ArrayIterator:

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

contourne la stipulation par référence du PO.

Ataboy Josef · Answer

Utilisezarray_keys()pour accéder aux clés de votre tableau associatif sous forme de tableau indexé numériquement, qui peut ensuite être utilisé comme clé pour le tableau.

Lorsque la solution est arr[0] :

(Notez que puisque le tableau avec les clés est un index basé sur 0, le 1er élément Est l'index 0)

Vous pouvez utiliser une variable, puis en soustraire une, pour obtenir votre logique, ce 1 => 'Apple'.

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

Sortie:

Apple

Eh bien, pour simplifier, utilisez simplement:

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

Sortie:

Apple

Par la première méthode, pas seulement le premier élément, mais peut traiter un tableau associatif comme un tableau indexé.

Nabil Kadimi · Answer

Nice one avec une combinaison de array_slice et 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

karthikeyan ganesan · Answer

vous pouvez obtenir le premier élément en utilisant ce codage

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

Ou utiliser

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