php - imprimir - Consigue el primer elemento de una matriz.

matrices en php

Question

Tengo una matriz:

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

Me gustaría obtener el primer elemento de esta matriz. Resultado esperado: apple

Un requisito: no se puede hacer pasando por referencia , por lo que array_shift no es una buena solución.

¿Cómo puedo hacer esto?

Answer 1

¡Mantenga esto simple! Muchas respuestas correctas aquí, pero para minimizar toda la confusión. Estos dos trabajan y reducen muchos gastos generales.

key($array) = obtiene la primera clave de un array
current($array) = obtiene el primer valor de una matriz

Answer 2

Algunas matrices no funcionan con funciones como list , reset o current . Tal vez sean matrices "falsas", como la implementación parcial de ArrayIterator, por ejemplo.

Si desea extraer el primer valor independientemente de la matriz, puede provocar un cortocircuito en un iterador:

foreach($array_with_unknown_keys as $value) break;

Su valor estará disponible en $value y el bucle se romperá después de la primera iteración. Esto es más eficiente que copiar una matriz potencialmente grande a una función como array_unshift (array_values ​​($ arr)).

Puedes agarrar la llave de esta manera también:

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

Si está llamando a esto desde una función, simplemente regrese temprano:

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

Answer 3

Como Mike señaló (la forma más fácil posible):

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

Si desea obtener la clave: (ejecútela después de reiniciar)

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

De la documentación de PHP :

reinicio mixto (array & $ array );

Descripción:

reset () rebobina el puntero interno de la matriz al primer elemento y devuelve el valor del primer elemento de la matriz, o FALSE si la matriz está vacía.

Answer 4

Creo que usar array_values sería tu mejor apuesta aquí. Podría obtener el valor en el índice cero del resultado de esa función para obtener ''apple''.

Answer 5

De los helpers de Laravel:

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

La matriz que se pasa por valor a la función, el reset() afecta al puntero interno de una copia de la matriz, no toca la matriz original. (note que devuelve false si la matriz está vacía)

Ejemplo de uso:

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

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

Además, aquí hay una alternativa. Es ligeramente más rápido, pero más interesante, permite cambiar fácilmente el valor predeterminado si la matriz está vacía:

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

    return $default;
}

Answer 6

Dos soluciones para ti.

Solución 1 - Sólo tiene que utilizar la tecla. No has dicho, que no puedes usarlo. :)

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

Solución 2 - array_flip () + clave ()

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

Solución 3 - array_keys ()

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

Answer 7

Esta no es una respuesta tan simple en el mundo real. Supongo que tenemos estos ejemplos de posibles respuestas que puedes encontrar en algunas bibliotecas.

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

Como puede ver, tenemos varias soluciones de "una línea" que funcionan bien en algunos casos, pero no en todas.

En mi opinión, debe tener ese controlador sólo con matrices.

Ahora hablando de rendimiento, asumiendo que siempre tenemos una matriz, como esta:

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

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

array_shift es más rápido que el restablecimiento, es más rápido que [count () - 1] y estos tres son más rápidos que array_values ​​y array_slice

Answer 8

Esto es un poco tarde para el juego, pero se me presentó un problema en el que mi matriz contenía elementos de matriz como elementos secundarios en su interior y, por lo tanto, no podía obtener una representación de cadena del primer elemento de matriz. Usando la función current() PHP , logré esto:

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

Gracias a todas las soluciones actuales que me ayudaron a obtener esta respuesta, ¡espero que esto ayude a alguien alguna vez!

Answer 9

Me gusta el ejemplo de "lista", pero "lista" solo funciona en el lado izquierdo de una tarea. Si no queremos asignar una variable, nos veremos obligados a inventar un nombre temporal, que en el mejor de los casos contamina nuestro alcance y en el peor de los casos sobrescribe un valor existente:

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

Lo anterior sobrescribirá cualquier valor existente de $ x, y la variable $ x se mantendrá alrededor mientras este alcance esté activo (al final de esta función / método, o para siempre si estamos en el nivel superior). Esto se puede solucionar mediante el uso de call_user_func y una función anónima, pero es un desorden:

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

Si usamos funciones anónimas como esta, podemos deshacernos de reset y array_shift, aunque usen paso por referencia. Esto se debe a que llamar a una función vinculará sus argumentos, y estos argumentos se pueden pasar por referencia:

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

Sin embargo, esto es realmente una exageración, ya que call_user_func realizará esta asignación temporal internamente. Esto nos permite tratar las funciones de paso por referencia como si fueran pasadas por valor, sin advertencias ni errores:

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

Answer 10

No me gusta jugar con el puntero interno de la matriz, pero también es ineficiente construir una segunda matriz con array_keys() o array_values() , así que generalmente defino esto:

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

Answer 11

Obtener primer elemento:

array_values($arr)[0]

Obtener el último elemento

array_reverse($arr)[0]

Answer 12

PHP 5.4+:

array_values($array)[0];

Answer 13

Publicación anterior, pero de todos modos ... Me imagino que el autor estaba buscando una manera de obtener el primer elemento de la matriz después de obtenerla desde alguna función (mysql_fetch_row, por ejemplo) sin generar un ESTRICTO "Solo las variables deben pasarse por referencia". Si es así, casi todas las formas aquí descritas recibirán este mensaje ... y algunas de ellas usan mucha memoria adicional que duplica una matriz (o parte de ella). Una forma fácil de evitarlo es simplemente asignando el valor en línea antes de llamar a cualquiera de esas funciones:

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

De esta manera, no se obtiene el mensaje ESTRICTO en la pantalla ni en los registros y no se crean matrices adicionales. Funciona con matrices indexadas y asociativas.

Answer 14

Puede obtener el elemento Nth con una construcción de lenguaje "lista":

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

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

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

Con la función array_keys puedes hacer lo mismo con las teclas:

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

Answer 15

Respuesta original, pero costosa (O (n)):

array_shift(array_values($array));

En O (1):

array_pop(array_reverse($array));

Editado con sugerencias de comentarios para otros casos de uso, etc ...

Si la modificación (en el sentido de restablecer los punteros de la matriz) de $array no es un problema, puede usar:

reset($array);

Esto debería ser teóricamente más eficiente, si se necesita una "copia" de matriz:

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

Con PHP 5.4+ (pero podría causar un error de índice si está vacío):

array_values($array)[0];

Answer 16

Simplemente haz:

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

Answer 17

Suponer:

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

Solo usa:

$array[key($array)]

para obtener el primer elemento o

key($array)

para obtener la primera llave

O puedes desvincular el primero si quieres eliminarlo.

Answer 18

También vale la pena tener en cuenta el contexto en el que está haciendo esto, ya que una verificación exhaustiva puede ser costosa y no siempre es necesaria.

Por ejemplo, esta solución funciona bien para la situación en la que la estoy usando (pero obviamente no se puede confiar en todos los casos ...)

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

Answer 19

Un pequeño cambio a lo publicado por Sarfraz es:

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

Answer 20

Una forma torpe es:

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

Answer 21

Utilizar:

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

De forma predeterminada, array_slice no conserva las claves, por lo que podemos usar cero como índice de forma segura.

Answer 22

Yo haría echo current($array) .

Answer 23

current($array)

Puede obtener el primer elemento de una matriz, de acuerdo con el Manual de PHP.

Cada matriz tiene un puntero interno a su elemento "actual", que se inicializa con el primer elemento insertado en la matriz.

Así que funciona hasta que haya reubicado el puntero de la matriz, de lo contrario tendrá que restablecer la matriz.

Answer 24

La mayoría de estos trabajos! PERO para una llamada rápida de una sola línea (bajo recurso):

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

Aunque esto funciona, y bastante bien, también vea mi respuesta adicional: https://.com/a/48410351/1804013

Answer 25

PHP 7.3 agregó dos funciones para obtener la primera y la última clave de una matriz directamente sin modificar la matriz original y sin crear ningún objeto temporal:

• array_key_first
• array_key_last

Además de ser semánticamente significativas, estas funciones ni siquiera mueven el puntero de matriz (como lo haría foreach ).

Teniendo las claves, uno puede obtener los valores directamente de las claves.

Ejemplos (todos ellos requieren PHP 7.3+)

Obteniendo la primera / última clave y valor:

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

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

print get_first($foo);

Obtener el primer / último valor como una sola línea, asumiendo que la matriz no puede estar vacía :

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

Obtención del primer / último valor como de una sola línea, con valores predeterminados para matrices vacías:

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

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

Answer 26

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

Salida:

apple

Answer 27

$arr = array( 9 => ''apple'', 7 => ''orange'', 13 => ''plum'' );
echo reset($arr); // echoes ''apple''

Si no desea perder la posición actual del puntero, simplemente cree un alias para la matriz.

Answer 28

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

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

Esto es mucho más eficiente que array_values() porque la función each() no copia la matriz completa.

Para obtener más información, visite http://www.php.net/manual/en/function.each.php

Answer 29

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

Espero que esto ayude. :)

Answer 30

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

// the first element of your array is:
echo $myArray[$arrayKeys[0]];