Obter o primeiro elemento de uma matriz

Eu tenho uma matriz:

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

Eu gostaria de obter o primeiro elemento dessa matriz. Resultado esperado: string apple

Um requisito: não pode ser feito com passagem por referência , portantoarray_shift não é uma boa solução.

Como posso fazer isso?

Resposta original, mas cara (O (n)):

array_shift(array_values($array));

Em O (1):

array_pop(array_reverse($array));

Outros casos de uso, etc ...

Se a modificação (no sentido de redefinir ponteiros de matriz) $arraynão for um problema, você poderá usar:

reset($array);

Teoricamente, isso deve ser mais eficiente, se uma matriz "cópia" for necessária:

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

Com o PHP 5.4+ (mas pode causar um erro de índice se vazio):

array_values($array)[0];

Como Mike apontou (a maneira mais fácil possível):

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

Se você deseja obter a chave: (execute-a após a redefinição)

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

Da documentação do PHP :

reset misto (array & $ array );

Descrição:

reset () rebobina o ponteiro interno da matriz para o primeiro elemento e retorna o valor do primeiro elemento da matriz, ou FALSE se a matriz estiver vazia.

$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 você não deseja perder a posição atual do ponteiro, basta criar um alias para a matriz.

current($array)você pode obter o primeiro elemento de uma matriz, de acordo com o manual do PHP .

Toda matriz possui um ponteiro interno para seu elemento "atual", que é inicializado para o primeiro elemento inserido na matriz.

Por isso, funciona até que você reposicione o ponteiro da matriz e, caso contrário, precisará redefinir a matriz.

Você pode obter o enésimo elemento com uma construção de idioma, "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;

Com a array_keysfunção, você pode fazer o mesmo com as teclas:

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

PHP 5.4+:

array_values($array)[0];

O PHP 7.3 adicionou duas funções para obter a primeira e a última chave de uma matriz diretamente sem modificar a matriz original e sem criar objetos temporários:

• array_key_first
• array_key_last

Além de serem semanticamente significativas, essas funções nem movem o ponteiro do array (como foreachfaria).

Tendo as chaves, é possível obter os valores diretamente pelas chaves.

Exemplos (todos eles requerem PHP 7.3 ou superior)

Obtendo a primeira / última chave e o 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];

Obtendo o primeiro / último valor como one-liners, assumindo que a matriz não possa estar vazia :

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

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

Obtendo o primeiro / último valor como one-liners, com padrões para matrizes vazias:

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

Suponha:

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

Apenas use:

$array[key($array)]

para obter o primeiro elemento ou

key($array)

para obter a primeira chave.

Ou você pode desvincular o primeiro se desejar removê-lo.

Algumas matrizes não funcionam com funções como list, resetou current. Talvez sejam matrizes "falsas" - implementando parcialmente o ArrayIterator, por exemplo.

Se você deseja obter o primeiro valor, independentemente da matriz, pode causar um curto-circuito em um iterador:

foreach($array_with_unknown_keys as $value) break;

Seu valor estará disponível em $value e o loop será interrompido após a primeira iteração. Isso é mais eficiente do que copiar uma matriz potencialmente grande para uma função como array_unshift (array_values ​​($ arr)).

Você também pode pegar a chave dessa maneira:

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

Se você está chamando isso de uma função, basta retornar mais cedo:

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

Dos ajudantes do Laravel :

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

A matriz que está sendo passada por valor para a função, o reset () afeta o ponteiro interno de uma cópia da matriz e não toca na matriz original (observe que ela retornafalse se a matriz estiver vazia).

Exemplo de uso:

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

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

Além disso, aqui está uma alternativa. É muito marginalmente mais rápido, mas mais interessante. Permite alterar facilmente o valor padrão se a matriz estiver vazia:

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

Para o registro, aqui está outra resposta minha , para o último elemento da matriz.

Mantenha isso simples! Há muitas respostas corretas aqui, mas para minimizar toda a confusão, essas duas funcionam e reduzem muitas despesas gerais:

key($array)obtém a primeira chave de uma matriz
current($array)obtém o primeiro valor de uma matriz

EDIT:
Sobre os comentários abaixo. O exemplo a seguir será exibido: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));

Simplesmente faça:

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

Eu faria echo current($array).

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

Resultado:

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

Isso é muito mais eficiente do que array_values()porque a each()função não copia toda a matriz.

Para mais informações, consulte http://www.php.net/manual/en/function.each.php

Uma maneira arrogante é:

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

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

print get_first($foo);

Obtenha o primeiro elemento:

array_values($arr)[0]

Obter o último elemento

array_reverse($arr)[0]

A maioria desses trabalhos! MAS para uma chamada rápida de linha única (poucos recursos):

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

Embora isso funcione e decentemente bem, consulte também minha resposta adicional: https://stackoverflow.com/a/48410351/1804013

Eu acho que usar array_values seria sua melhor aposta aqui. Você pode retornar o valor no índice zero a partir do resultado dessa função para obter 'apple'.

Isso é um pouco tarde para o jogo, mas me foi apresentado um problema em que minha matriz continha elementos de matriz como filhos dentro dela e, portanto, não conseguia apenas obter uma representação em cadeia do primeiro elemento da matriz. Por usando PHP current()função , eu consegui isto:

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

Graças a todas as soluções atuais, me ajudaram a chegar a essa resposta, espero que isso ajude alguém em algum momento!

Usar:

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

Por padrão, array_slicenão preserva chaves, para que possamos usar com segurança zero como índice.

Duas soluções para você.

Solução 1 - Basta usar a chave. Você não disse que não pode usá-lo. :)

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

Solução 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. */');
?>

Solução 3 - array_keys ()

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

Esta não é uma resposta tão simples no mundo real. Suponha que tenhamos esses exemplos de respostas possíveis que você pode encontrar em algumas 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 você pode ver, temos várias soluções de uma linha que funcionam bem em alguns casos, mas não em todas.

Na minha opinião, você deve ter esse manipulador apenas com matrizes.

Agora falando sobre desempenho, supondo que sempre tenhamos array, assim:

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

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

array_shifté mais rápido que reset, mais rápido que [count () - 1], e esses três são mais rápidos que array_valuese array_slice.

Eu imagino que o autor apenas estava procurando uma maneira de obter o primeiro elemento de uma matriz depois de obtê-lo de alguma função ( mysql_fetch_row , por exemplo) sem gerar um STRICT "Somente variáveis ​​devem ser passadas por referência".

Nesse caso, quase todas as formas descritas aqui receberão essa mensagem ... e algumas delas usam muita memória adicional duplicando uma matriz (ou parte dela). Uma maneira fácil de evitá-lo é apenas atribuir o valor embutido antes de chamar qualquer uma dessas funções:

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

Dessa forma, você não recebe a mensagem STRICT na tela nem nos logs e não cria matrizes adicionais. Ele funciona com matrizes associativas AND indexadas .

Gosto do exemplo "list", mas "list" funciona apenas no lado esquerdo de uma tarefa. Se não quisermos atribuir uma variável, seremos forçados a criar um nome temporário, o que na melhor das hipóteses polui nosso escopo e, na pior das hipóteses, substitui um valor existente:

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

O texto acima substituirá qualquer valor existente de $ x, e a variável $ x ficará suspensa enquanto esse escopo estiver ativo (o final dessa função / método ou para sempre, se estivermos no nível superior). Isso pode ser contornado usando call_user_func e uma função anônima, mas é desajeitado:

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

Se usarmos funções anônimas como essa, poderemos nos safar de reset e array_shift, mesmo que eles usem passagem por referência. Isso ocorre porque chamar uma função vincula seus argumentos, e esses argumentos podem ser passados ​​por referência:

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

No entanto, isso é realmente um exagero, pois call_user_func executará essa atribuição temporária internamente. Isso nos permite tratar as funções de passagem por referência como se fossem passagem por valor, sem nenhum aviso ou erro:

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

Uma pequena alteração no que Sarfraz postou é:

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

Eu não gosto de mexer com o ponteiro interno da matriz, mas também é ineficiente criar uma segunda matriz com array_keys()ou array_values(), então eu geralmente defino isso:

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

Tente o seguinte:

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