Tengo un array:

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

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

Un requisito: no se puede realizar con pasar por referencia, así array_shift no es una buena solución.

¿Cómo puedo hacer esto?

  • ¿A qué te refieres, no se puede hacer por referencia?
  • Función no funciona con &$array como parámetros.
  • Sospecho que lo que «realmente» significa «no se puede hacer por referencia», es que su matriz se devuelve dinámicamente desde una base de datos, y usted no desea pasar el array en una variable antes de tomar el primer elemento de la misma. Si estoy en lo correcto, entonces la gran mayoría de todas las soluciones que se indican a continuación (incluyendo la aceptación de la respuesta), son insuficientes.
  • Usted sólo tiene que conseguir o llegar y quitar de la matriz existente?
  • Para el uso básico de las Matrices puede revisar en este enlace technofusions.com/introduction-to-arrays-in-php
InformationsquelleAutor hsz | 2009-12-17

37 Comentarios

  1. 1251

    Respuesta Original, pero costoso (O(n)):

    array_shift(array_values($array));

    En O(1):

    array_pop(array_reverse($array));

    Otros casos de uso, etc…

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

    reset($array);

    Este debería ser teóricamente más eficiente, si una matriz de «copia» es necesario:

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

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

    array_values($array)[0];
    • +1 para la inteligente solución para impedir la modificación de la matriz original con array_values()
    • Me sale esto: <b>los Estrictos Estándares</b>: Sólo las variables deben ser pasados por referencia. Bonito solución btw
    • ¿No es un poco excesivo? ¿Qué pasa si la matriz contiene varios miles de elementos? Es justificado para crear una nueva matriz sólo para obtener su primer elemento? list() y reset() son mucho mejores soluciones para mi opinión.
    • +1 porque esto funciona evento con array_keys si necesito la primera clave
    • sí, un exceso de solución, sólo el restablecimiento de PHP función integrada, tal y como figura después.
    • Estoy de acuerdo. Total de overkill y recurso extraordinario pesado en comparación con una línea que restablece y devuelve el valor actual: reset($matriz);
    • -1 Como los anteriores comentaristas han dicho. Es incomprensible para mí que esto tiene 101 upvotes.
    • Esta respuesta es aún más incorrecto, si la suposición que hago en mi comentario a la pregunta original es correcta.
    • array_shift(array_slice($array,0,1)) // <– en teoría más rápido ya que considera que sólo el primer elemento
    • Primero de todo es que no se ejecuta con los Estrictos Estándares como se dijo antes. El uso de reset () y la tecla() después, si es necesario) es mucho más elegante y eficiente opción.
    • El reset(&$arr) post de abajo es mucho más eficiente.
    • Hay una línea muy fina entre evitar la optimización prematura y absurda desperdicio de recursos.
    • ESTA MAL! USO de echo reset($arr);
    • Si desea que el uso de la llave de la aceptó responder here.
    • +1 para array_values solución, ya que no modifica la matriz original
    • Estoy completamente asombrado por el hecho de que en el 2014 nos no puede ser mejor que una función de reset, que no puede ser usada aprobada por el valor de referencia. PHP realmente debería considerar la separación de la matriz en las listas y dictionnaries.
    • hay un desplazamiento problema con array_values($arr)[0] en el caso de la matriz de entrada $arr está vacía.
    • Todo lo que necesitaba era array_slice. Las otras cosas que era necesario para mí. Gracias!
    • la correcta y la respuesta más simple es la de abajo, e.g: corriente($arr);
    • Aquí es donde la comunidad basada en la moderación debe entrar en juego. La respuesta seleccionada no por el camino equivocado, sin embargo, recibe cientos de upvotes de todos modos. La mejor respuesta es uno publicado por el usuario lepe a continuación.
    • no estoy seguro de lo que quieres decir: mi/esta respuesta abarca diferentes casos de uso, incluyendo el uso de reset?!
    • No entiendo a todo el mundo quejarse acerca de esta respuesta. reset Los CAMBIOS de la matriz por el restablecimiento de su puntero interno, así que si usted utiliza reset método dentro de un bucle utilizando la matriz interna del puntero, luego te desorden de la esperada comportamiento del lazo y podría hacer que se ejecute para siempre. Como dijo el autor, si no se tiene cuidado con el puntero, luego reset es el camino a seguir, otra cosa es que definitivamente no es una opción
    • El problema aquí es que array_shift es caro en las matrices grandes. Es mejor utilizar array_pop(array_reverse($array)). También, el OP dice que quieren que el primer valor, no un bucle a través de todos ellos, por lo que el costo de array_shift no ofrece ningún beneficio.
    • Consulte mi respuesta para la solución definitiva. Siéntase libre de integrar en esta respuesta.
    • No puedo entender cómo array_reverse($array) podría ser O(1).
    • cómo es posible que array_reverse O(1)?, se crea una nueva matriz, las fuerzas de la función de al menos O(n).
    • Como @defectos del tubo neural dijo, creo que no es O(1). Si usted echa un vistazo en la aplicación, usted puede ver un bucle en ambos casos de la if: github.com/php/php-src/blob/…

  2. 752

    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 quieres obtener la clave: (ejecutarlo después de un reset)

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

    De La documentación de PHP:

    mixto restablecer ( matriz &$matriz );

    Descripción:

    reset() rebobina de la matriz de interna puntero al primer elemento y devuelve el valor del primer elemento de la matriz, o FALSE si la matriz es
    vacío.

    • Has leído «no se puede hacer con pasar por referencia» ?
    • Aunque se pasa por referencia a restablecer, a la matriz original no se modifica. Supongo que la razón por la que hsz no quiere pasar por referencia..?
    • La matriz del iterador es modificado. Si usted hace esto en un foreach con el tema de la matriz, te voy a meter la pata.
    • esto no es siempre (por lo general) verdadero. Generalmente en la práctica, foreach se copia la matriz que se recorre.
    • lo que si quiero conseguir el ‘4’ (asignar nombre) valores?
    • después de reiniciar, puede llamar a key($arr) y usted tendrá ‘4’ (añadido en la respuesta)
    • Ni @Zenexer ni Lucas Primos son de la derecha: 1) foreach no uso comerc puntero de una matriz – sino que crea su propio puntero. Es fácil comprobar llamando a restablecer dentro de un foreach – el bucle seguirá su camino sin efecto a partir de reset(). 2) No, foreach NO crea una copia de una matriz!!! Sólo crea su propio puntero (ni siquiera una copia de uno existente – también es fácil de comprobar, llamando next() antes de foreach).
    • Años más tarde, me doy cuenta de que definitivamente es una posibilidad, aunque yo no lo he probado. Voy a tomar su palabra para ella.
    • Bueno, usted no tiene que tomar mi palabra 🙂 está bastante bien describet en este post: stackoverflow.com/a/14854568/2828391

  3. 263
    $first_value = reset($array); //First element's value
    $first_key = key($array); //First element's key
    • En realidad no lo he probado, pero parece que esta opción sería la más eficiente.
    • El único problema es la pregunta por el valor, no la clave. Por lo tanto la corriente($matriz) se debe utilizar en lugar de la clave($matriz)
    • reset($matriz); aquí se obtiene el valor de reset() función rebobina matrices puntero interno y devuelve el primer elemento.
    • la mejor respuesta! estaba buscando la llave() equivalencia para obtener el primer valor. Esto ayuda!
  4. 90
    $arr = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
    echo reset($arr); //echoes 'apple'

    Si no quieres perder el actual puntero de posición, basta con crear un alias para la matriz.

    • no lo entendía, ¿a qué te refieres? Funciona bien si la clave de la primera es más grande que los demás.
    • +1 FYI reset() ya devuelve el primer elemento, por lo que no hay necesidad de utilizar current()echo reset($arr) debería ser suficiente
    • pero es posible que prefiera current a reset para evitar PHP/aviso de error producido en los casos de referencia, por ejemplo, current(array_filter(...)); en 3v4l.
  5. 76

    current($array) se puede obtener el primer elemento de una matriz, de acuerdo con el manual de PHP.

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

    Así funciona hasta que haya re-posiciona el puntero de matriz, y de lo contrario tendrás que restablecer la matriz.

    • No sé por qué esto no fue aceptado respuesta, ya que responde a la pregunta de una manera bastante simple y con precisión.
    • current($array) sólo funcionará si la matriz de puntero «en la actualidad» que apunta al primer elemento, de lo contrario reset($array) sería necesario.
    • Parece current() ya no se requiere una referencia, aunque en el PHP docs no reflejan esto. Así que creo que esto se ha convertido en la mejor solución.
    • de acuerdo, pero esta solución fue dada de 2 años antes de 2014 en esta otra respuesta de este mismo hilo… Raro que esta incompleta la frase tiene más upvotes.
  6. 64

    Usted puede obtener el N-ésimo elemento con una construcción del lenguaje, «lista»:

    //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 el array_keys función usted puede hacer lo mismo para las llaves:

    list($firstKey) = array_keys($yourArray);
    list(, $secondKey) = array_keys($yourArray);
    • +1, A mi opinión, list es la mejor opción
    • Esto es exactamente lo que yo hago: list($first_value) = $my_array; En mi opinión, la mejor opción. No tiene los problemas de las otras respuestas que aquí se presenta: no «overkill» porque no copia o la matriz o crear una nueva. No hay «referencias»: la matriz no es modificado. No «reset»: no hay cambios a la matriz puntero interno…
    • Solución muy elegante, pero produce una E_NOTICE cuando la matriz está vacía.
    • que se puede superar fácilmente mediante la comprobación de si count($array) > 0.
    • sí, pero entonces no es tan elegante ya 🙂
    • No esta mal?! Funciona sólo si la matriz de teclas son int, trate de hacer list($firstItem) = array('key1' => 'value1'); y aparecerá un mensaje de error Notice: Undefined offset: 0
    • usted está en lo correcto, pero siempre se puede usar array_values() función en tales casos: list($firstItem) = array_values($yourArray);
    • pero luego de perder la mayor ventaja de esta solución, y que no es copia de toda la matriz original a otro innecesariamente. Todavía, +1 de los beneficios suponiendo que se pueda garantizar un entero matriz indexada
    • Para aclarar: list($x) = foo(); es equivalente a $x = foo()[0];. Tenga en cuenta que este no es necesariamente el mismo como «el primer elemento», ya que incluso un entero-matriz indexada no puede tener un elemento con la tecla 0. En mi caso yo estaba haciendo «list($pedido) = get_order($usuario);» pero «get_order» fue la devolución de pedidos con llave por su ID, que generalmente era de 0. Como @Sergiy dice, array_values() corrige esto, pero disminuye el valor de la eficiencia, y (más importante) la legibilidad del código.

  7. 52

    PHP 5.4+:

    array_values($array)[0];
    • Esto es para la gente cool que ejecutar el último y más grande. 😉
    • Se editó su respuesta en Oct-2013 a incluir mi respuesta que he añadido en el mes de abril.
    • PHP 4: $array_values = array_values($array); $value = $array_values[0];
  8. 27

    Supongamos:

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

    Sólo tiene que utilizar:

    $array[key($array)]

    para obtener el primer elemento o

    key($array)

    para obtener la primera clave.

    O puede desvincular la primera si desea eliminarlo.

    • Wht no simplemente usar current entonces?
  9. 25

    PHP 7.3 añadido dos funciones para la obtención de la primera y la última clave de una matriz directamente sin modificación de la matriz original y sin la creación de los objetos temporales:

    Aparte de ser semánticamente significativas, estas funciones no mover el puntero de matriz (como foreach haría).

    Las llaves, se puede obtener los valores de las claves directamente.


    Ejemplos (todos ellos requieren de PHP 7.3+)

    Llegar a la primera/última clave y valor:

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

    Conseguir el primer/último valor como uno-trazadores de líneas, suponiendo que la matriz no puede estar vacío:

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

    Conseguir el primer/último valor como uno-trazadores de líneas, con valores predeterminados para matrices vacías:

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

    Algunas matrices no trabajo con funciones como list, reset o current. Tal vez son la «imitación» de las matrices – la aplicación parcial objeto de la clase arrayiterator, por ejemplo.

    Si quieres tirar el primer valor, independientemente de la matriz, se pueden corto circuito de un iterador:

    foreach($array_with_unknown_keys as $value) break;

    Su valor pasará a estar disponible en $value y el lazo se rompa después de la primera iteración. Esto es más eficaz que la copia potencialmente grande de la matriz de una función como array_unshift(array_values($arr)).

    Usted puede agarrar la llave de esta manera:

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

    Si usted está llamando a esta función, simplemente regresar temprano:

    function grab_first($arr) {
        foreach($arr as $value) return $value;
    }
    • Supongo que esta es una de las maneras más rápidas debido a que el uso de la lengua construcción foreach en lugar de una llamada a una función (que es más caro). designcise.com/web/tutorial/…
  11. 17

    De Laravel ayudantes del:

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

    La matriz que se pasa por valor a la función, el reset() afecta el puntero interno de una copia de la matriz, y de que no toque el original
    array (nota 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

    También, aquí es una alternativa. Es muy marginalmente más rápido, pero lo más interesante. Permite cambiar fácilmente el valor predeterminado si el array está vacío:

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

    Para el registro, aquí es otra respuesta de mina, para la matriz del último elemento.

  12. 11

    Yo haría echo current($array) .

    • no se puede realizar con pasar por referencia
    • No importa, current() no de error en caso de incumplimiento de las referencias se pasan. Siempre que el puntero está todavía en el comienzo de esta obra.
    • pero se produce un Aviso que hace que sus registros sucio y bueno… usted debe deshacerse de los Avisos también wven si no son críticas
    • no se no se. En realidad reset produce el «Sólo las variables debe ser pasado por referencia» aviso mientras current no: Online Editor de PHP ejemplo de current(array_filter(...));.
    • parece que están a la derecha… mira como tenía esta idea de que la corriente de los viejos tiempos de PHP 4, donde se produce realmente Fatal error: sandbox.onlinephpfunctions.com/code/… El único problema que veo en el uso actual es que no garantiza que el elemento devuelto es el primer elemento de una matriz (puntero interno podrá ser modificado por la función llamada). Prácticamente se puede devolver al azar de los elementos de una matriz.
    • Nunca fui capaz de volver al azar de los elementos de un array con current… esto es un 3v4l ejemplo que añade un elemento, se ordena la matriz y quita el 0 elemento indexado => siempre devuelve el primer elemento. Puede copia de seguridad de su posibilidad con un ejemplo?
    • Un poco artificial ejemplo, pero demuestra bien mis pensamientos: sandbox.onlinephpfunctions.com/code/… imagínese que usted recibe de su matriz de algunas de las funciones que utiliza next(), end() o de cualquier otra función que modifica la matriz de puntero interno. En mi ejemplo, current() devuelve null porque el puntero interno está «fuera de gama» de la matriz. Pero puede ‘virtualmente’ de punto a cualquier elemento aleatorio demasiado.
    • oh, me olvidé de esas funciones, uno de los puntos.

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

    De salida:

    apple
  14. 10
    $myArray = array (4 => 'apple', 7 => 'orange', 13 => 'plum');
    $arrayKeys = array_keys($myArray);
    
    //The first element of your array is:
    echo $myArray[$arrayKeys[0]];
    • Yo no siguió el camino de su aceptados descritos en la respuesta. Utiliza el tuyo gracias
  15. 9
    $array=array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
    
    $firstValue = each($array)[1];

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

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

    • because the each() function does not copy the entire array. +1
    • Pero la cosa es que usted debe de hacer un reset antes, si el puntero interno no está al principio usted no va a obtener el primer elemento.
    • Pero cada uno (a) recibe una matriz de referencia y el requisito de las preguntas iniciales es no hacerlo
  16. 8

    Un desacoplados forma es:

    $foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
    
    function get_first ($foo) {
        foreach ($foo as $k=>$v){
            return $v;
        }
    }
    
    print get_first($foo);
    • Al menos eres honesto – es desacoplados! Pero, funciona, y lo he utilizado en el pasado, hasta el aprendizaje de la lista() técnica anterior.
    • Si usted está haciendo esto, usted podría utilizar reset() como el puntero de matriz es cero antes de foreachse llama de todos modos.
  17. 7

    Obtener el primer elemento:

    array_values($arr)[0]

    Obtener el último elemento

    array_reverse($arr)[0]
    • Las teclas numéricas se conservan con array_reverse, por lo que todavía va a devolver el primer elemento. 3v4l.org/2729s
  18. 7

    La mayoría de estos trabajos! PERO para una rápida sola línea (de bajos recursos) llamar al:

    $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 decentemente bien, por favor también ver a mi adicionales de respuesta:
    https://stackoverflow.com/a/48410351/1804013

    • Esto es equivalente a utilizar current($array), que requiere que el puntero interno de la matriz de estar en el primer elemento de todas formas, en cuyo caso, echo reset($array) es el más apropiado.
    • realmente escribió otra respuesta aquí con tu sugerencia, pero omitió su explicación… Gracias.
    • Hice un adicional de respuesta/actualización de un rato de ir: stackoverflow.com/a/48410351/1804013
  19. 5

    Creo que el uso de array_values sería su mejor apuesta aquí. Usted puede devolver el valor en el índice cero a partir del resultado de la función para obtener la ‘manzana’.

  20. 5

    Mantener este sencillo! Hay un montón de respuestas correctas aquí, pero para minimizar la confusión, estos dos trabajos y reducir un montón de sobrecarga:

    key($array) obtiene la primera clave de una matriz

    current($array) obtiene el primer valor de una matriz

    • Uhh. current equivale elemento actual. Usted tiene que restablecer el puntero al principio de la matriz para asegurarse de que está realmente en el principio.
    • actual () se obtiene el elemento actual, no es el primer elemento. Es diferente.
  21. 4

    Este es un poco tarde para el juego, pero se me presentó con un problema en mi matriz contenida elementos de la matriz como de los niños dentro de ella, y por lo tanto no sólo he podido conseguir una representación de cadena del primer elemento de la matriz. Por el uso de PHP current() función, he conseguido 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 me ayudó a llegar a esta respuesta, espero que esto ayude a alguien en algún momento!

    • Erm, ¿por qué la downvote? 😐
  22. 4

    Uso:

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

    Por defecto, array_slice no conserva las llaves, por lo que podemos utilizar de forma segura el cero como el índice.

  23. 4

    Dos soluciones para usted.

    Solución 1 – Sólo tiene que utilizar la clave. No se dice que no se puede utilizar. 🙂

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

    Solución de 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 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. */');
    ?>

    Solución de 3 – array_keys()

    echo $array[array_keys($array)[0]];
  24. 2

    Esto no es tan simple la respuesta en el mundo real. Supongamos que tenemos estos ejemplos de posibles respuestas que se pueden 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 usted puede ver, tenemos varios ‘una’ línea de soluciones que funcionan bien en algunos casos, pero no en todos.

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

    Ahora hablando de rendimiento, suponiendo que tenemos siempre de la matriz, como este:

    $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 reset, que es más rápido que el [count()-1], y estos tres son más rápidos que array_values y array_slice.

  25. 1

    Me gusta la «lista» es un ejemplo, pero «lista» sólo funciona en el lado izquierdo de una asignación. Si no queremos asignar una variable, nos veríamos obligados a hacer un nombre temporal, que en el mejor de los contamina nuestro alcance y en el peor, se sobrescribe el valor existente:

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

    El anterior se sobrescribe cualquier valor de $x, y $variable x se cuelgan alrededor mientras este ámbito está activo (el final de esta función/método, o para siempre si estamos en el nivel superior). Esto puede ser solucionado utilizando call_user_func y una función anónima, pero es torpe:

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

    Si usamos funciones anónimas como este, podemos conseguir lejos con restablecimiento y array_shift, incluso a pesar de que el uso de paso por referencia. Esto es porque al llamar a una función se unen sus argumentos, y estos se pueden pasar argumentos 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 llevará a cabo esta asignación temporal internamente. Esto nos permite tratar de paso por referencia a funciones como si estuvieran de paso por valor, sin advertencias o errores:

    var_dump(call_user_func('reset', array_values(some_array())));
  26. 1

    Un pequeño cambio en lo que Sarfraz publicado es:

    $array = array(1, 2, 3, 4, 5);
    $output = array_slice($array, 0, 1);
    print_r ($output);
    • -1 Devuelve una matriz no un elemento.
  27. 1

    No me gusta tocar el violín con la matriz del puntero interno, pero también es ineficaz para construir una segunda matriz con array_keys() o array_values(), así que por lo general definir esto:

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

    Nadie ha sugerido usar el objeto de la clase arrayiterator clase:

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

    consigue alrededor de los de referencia en la estipulación de la OP.

  29. 1

    También vale la pena tener en cuenta es el contexto en el que se está haciendo esto, como una comprobación exhaustiva puede ser costoso y no siempre es necesario.

    Por ejemplo, esta solución funciona bien para la situación en la que yo estoy usando (pero, obviamente, no puede ser invocado 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));
    }
    • ¿Qué acerca de array(13, 'foo' => 'bar') ?
    • Como he dicho, no funciona en todos los casos, pero es mucho más barato que la mayoría de las otras soluciones y funciona bien en muchos (quizás la mayoría?) de las situaciones en las que es probable que usted necesite. Por favor, consulte las suposiciones del método de observación.
  30. 1

    Me imagino que el autor sólo estaba buscando una manera de obtener el primer elemento de una matriz después de llegar de alguna función (mysql_fetch_row, por ejemplo) sin generar un ESTRICTO «Sólo las variables debe ser pasado por referencia».

    Si es así, casi todas las formas descritas aquí obtendrá este mensaje… y algunos de ellos utiliza una gran cantidad de memoria adicional duplicación de una matriz (o parte de él). Una manera fácil de evitar que se acaba de asignar 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 usted no recibe el mensaje ESTRICTA en la pantalla, ni en los registros, y no crear matrices adicionales. Funciona con tanto indexados Y asociativa matrices.

  31. 0

    Uso array_keys() para tener acceso a las claves de la matriz asociativa como un numérica matriz indexada, que es, de nuevo, puede ser utilizado como clave para la matriz.

    Cuando la solución es arr[0]:

    (Nota, que desde el array con las claves es índice basado en 0, el 1 de
    es el elemento de índice 0)

    Puede utilizar una variable y luego restar uno, para conseguir su lógica, que 1 => 'apple'.

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

    De salida:

    apple

    Bien, para mayor simplicidad, sólo tiene que utilizar:

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

    De salida:

    apple

    Por el primer método no sólo el primer elemento, pero se puede tratar de una matriz asociativa como una matriz indexada.

  32. 0

    Bueno con una combinación de array_slice y 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
  33. 0

    Usted puede conseguir el primer elemento mediante el uso de esta codificación:

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

    O uso:

    $i=0;
    foreach($array as $arr)
    {
    if($i==0)
    {
    $first_element=$arr;
    break;
    }
    $i++;
    }
    echo $first_element;
    • ¿Por qué no acaba de salir del bucle? foreach ($array as $arr) { $first_element = $arr; break; }
    • sí, también es correcto
    • El $i si las declaraciones son completamente irrelevantes, y usted puede simplemente excluir a todos juntos. $i SIEMPRE será 0 en el primer bucle, SIEMPRE va a salir antes de que lleguen a $i++;
  34. -3

    Hay demasiadas respuestas aquí, y la respuesta seleccionada trabajará para la mayoría de los casos.

    En mi caso, tuve una matriz 2D, y array_values por alguna extraña razón fue la eliminación de las llaves en el interior de las matrices. Así que termino con esto:

    $keys = array_keys($myArray); //Fetches all the keys
    $firstElement = $myArray[$keys[0]]; //Get the first element using first key
  35. -6

    Encontrar el primer y el último elemento de una matriz:

    //Get the first item in the array
    print $array[0]; //Prints 1
    //Get the last item in the array
    print end($array);
    • Esto sólo funcionará si usted tiene una matriz que tiene numeradas consecutivamente las teclas, comenzando con 0 y terminando con count()-1. No funciona en el caso de la OP de la matriz.

Dejar respuesta

Please enter your comment!
Please enter your name here