value - remover elemento array php




Obter o primeiro elemento de um array (20)

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

Se você quiser extrair o primeiro valor, independentemente da matriz, poderá 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 um array potencialmente grande para uma função como array_unshift (array_values ​​($ arr)).

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

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

Se você está chamando isso de uma função, simplesmente retorne cedo:

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

Eu tenho uma matriz:

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

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

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

Como posso fazer isso?


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ê quer pegar a chave: (execute depois de resetar)

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

Da documentação do PHP :

redefinição mista (array & $ array );

Descrição:

reset () retrocede o ponteiro interno do array para o primeiro elemento e retorna o valor do primeiro elemento do array, ou FALSE se o array estiver vazio.


Duas soluções para você.

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

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

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

Solução 3 - array_keys ()

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

Esta não é uma resposta simples no mundo real. Suponha que tenhamos exemplos de possíveis respostas 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 todos.

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

Agora falando sobre performance, assumindo que temos sempre 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 resetar, que é mais rápido que [count () - 1] e este três são mais rápidos que array_values ​​e array_slice


Eu faria echo current($array) .


Eu gosto do exemplo de "lista", mas "lista" só funciona no lado esquerdo de uma tarefa. Se não quisermos atribuir uma variável, seremos forçados a inventar um nome temporário, o qual, 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 acima irá sobrescrever qualquer valor existente de $ x, e a variável $ x permanecerá ativa enquanto este escopo estiver ativo (o final desta função / método, ou para sempre se estivermos no nível superior). Isso pode ser trabalhado 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 sair com reset e array_shift, mesmo que elas usem passagem por referência. Isso ocorre porque chamar uma função ligará 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, já que call_user_func executará essa atribuição temporária internamente. Isso nos permite tratar funções de passagem por referência como se elas fossem passadas por valor, sem nenhum aviso ou erro:

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

Isso é um pouco tarde para o jogo, mas me foi apresentado um problema onde meu array continha elementos de array como filhos dentro dele, e assim eu não poderia simplesmente obter uma representação de string do primeiro elemento de array. Usando a função current() do PHP , eu consegui isso:

<?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 esta resposta, espero que isso ajude alguém em algum momento!


Mantenha isso simples! Muitas respostas corretas aqui, mas para minimizar toda a confusão. Esses dois funcionam e reduzem muito a sobrecarga.

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


PHP 5.4+:

array_values($array)[0];

Post antigo, mas de qualquer forma ... Eu imagino que o autor estava procurando uma maneira de obter o primeiro elemento do array 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". Se assim for, quase todas as formas descritas aqui receberão esta 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 inline 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 arrays indexados e associativos


Simplesmente faça:

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

Suponha que:

$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 quiser removê-lo.


Uma maneira kludgy é:

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

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

print get_first($foo);

Uma pequena mudança no que Sarfraz postou é:

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

Você pode obter o elemento Nth com uma "lista" de construção de linguagem:

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

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

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

Com a função array_keys você pode fazer o mesmo para as teclas:

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

current($array)

pode obter o primeiro elemento de um array, de acordo com o PHP Manual

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

Por isso, funciona até que você tenha reposicionado ponteiro de matriz, caso contrário, você precisará redefinir a matriz.


O PHP 7.3 adicionou duas funções para obter a primeira e a última chave de um array diretamente sem modificação do array original e sem criar nenhum objeto temporário:

Além de ser semanticamente significativo, essas funções nem sequer movem o ponteiro da matriz (como faria foreach ).

Tendo as chaves, pode-se obter os valores pelas chaves diretamente.

Exemplos (todos eles requerem PHP 7.3+)

Obtendo a primeira / última chave e 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 o array não pode estar vazio :

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

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

Saída:

apple

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

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

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

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


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

Espero que isto ajude. :)





arrays