Bir dizinin ilk öğesini edinin

Ben bir dizi var:

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

Bu dizinin ilk elemanını almak istiyorum. Beklenen sonuç: dize apple

Bir gereklilik: referansla geçilerek yapılamaz , bu yüzden array_shiftiyi bir çözüm değildir.

Bunu nasıl yapabilirim?

Orijinal cevap, ancak maliyetli (O (n)):

array_shift(array_values($array));

O (1) 'de:

array_pop(array_reverse($array));

Diğer kullanım durumları, vb ...

Öğesinin değiştirilmesi (dizi işaretleyicilerini sıfırlama anlamında) $arraysorun değilse, aşağıdakileri kullanabilirsiniz:

reset($array);

Bir dizi "kopya" gerekliyse, bu teorik olarak daha verimli olmalıdır:

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

PHP 5.4+ ile (ancak boşsa bir dizin hatasına neden olabilir):

array_values($array)[0];

Mike'ın belirttiği gibi (mümkün olan en kolay yol):

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

Anahtarı almak istiyorsanız: (sıfırladıktan sonra yürütün)

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

Gönderen PHP'nin belgelerine :

karışık sıfırlama (dizi & $ dizi );

Açıklama:

reset (), dizinin dahili işaretçisini ilk öğeye geri sarar ve ilk dizi öğesinin değerini veya dizi boşsa FALSE değerini döndürür.

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

Geçerli işaretçi konumunu kaybetmek istemiyorsanız, dizi için bir diğer ad oluşturun.

current($array)PHP kılavuzuna göre size bir dizinin ilk elemanını verebilir .

Her dizi, diziye eklenen ilk öğeye başlatılan "geçerli" öğesine dahili bir işaretçi içerir.

Böylece dizi işaretçisini yeniden konumlandırana kadar çalışır, aksi takdirde diziyi sıfırlamanız gerekir.

Nth öğesini bir dil yapısı olan "list" ile alabilirsiniz:

// First item
list($firstItem) = $yourArray;

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

// Second item
list( , $secondItem) = $yourArray;

array_keysİşlev ile aynı işlemi tuşlar için de yapabilirsiniz:

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

PHP 5.4+:

array_values($array)[0];

PHP 7.3 , bir dizinin ilk ve son anahtarını doğrudan orijinal dizide değişiklik yapmadan ve herhangi bir geçici nesne oluşturmadan almak için iki işlev ekledi :

• array_key_first
• array_key_last

Anlamsal olarak anlamlı olmanın yanı sıra, bu işlevler dizi işaretçisini bile hareket ettirmez (olduğu gibi foreach).

Anahtarlara sahip olmak, değerleri doğrudan tuşlardan alabilir.

Örnekler (hepsi PHP 7.3+ gerektirir)

İlk / son anahtarı ve değeri elde etme:

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

Dizinin boş olamayacağını varsayarak , ilk / son değeri tek satır olarak almak :

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

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

Boş diziler için varsayılan değerlerle ilk / son değeri tek satır olarak almak:

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

varsayalım:

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

Sadece kullan:

$array[key($array)]

ilk elementi almak veya

key($array)

ilk anahtarı almak için.

Veya kaldırmak isterseniz ilk bağlantısını kaldırabilirsiniz.

Bazı diziler list, resetveya gibi işlevlerle çalışmaz.current . Belki de "sahte" dizilerdir - örneğin ArrayIterator'ı kısmen uygularlar.

Diziden bağımsız olarak ilk değeri çekmek isterseniz, bir yineleyiciye kısa devre yapabilirsiniz:

foreach($array_with_unknown_keys as $value) break;

Bu durumda değeriniz $value ve döngü ilk yinelemeden sonra kesilecektir. Bu, potansiyel olarak büyük bir diziyi array_unshift (array_values ​​($ arr)) gibi bir işleve kopyalamaktan daha etkilidir.

Anahtarı bu şekilde de alabilirsiniz:

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

Bunu bir işlevden çağırıyorsanız, erken dönmeniz yeterlidir:

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

Gönderen laravel yardımcıları :

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

İşlev tarafından değere geçirilen dizi, reset () , dizinin bir kopyasının iç işaretçisini etkiler ve orijinal diziye dokunmaz (döndürdüğünü unutmayın)false dizi boşsa ).

Kullanım örneği:

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

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

Ayrıca, işte bir alternatif. Bu var çok marjinal daha hızlı, ancak daha ilginç. Dizi boşsa varsayılan değeri kolayca değiştirmenizi sağlar:

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

Kayıt için, dizinin son elemanı için benim bir başka cevabım var.

Bunu basit tut! Burada birçok doğru cevap var, ancak tüm karışıklığı en aza indirgemek için, bu ikisi çalışıyor ve çok fazla yükü azaltıyor:

key($array)bir dizinin ilk anahtarını
current($array)alır bir dizinin ilk değerini alır

EDIT:
Aşağıdaki yorumlarla ilgili. Aşağıdaki örnek çıktı verecektir: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));

Basitçe yapın:

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

Yapardım echo current($array).

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

Çıktı:

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

Bu çok daha verimli daha array_values()çünkü each()fonksiyon dizinin tamamı kopyalamaz.

Daha fazla bilgi için http://www.php.net/manual/en/function.each.php adresine bakın.

Kludgy bir yol:

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

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

print get_first($foo);

İlk öğeyi al:

array_values($arr)[0]

Son öğeyi al

array_reverse($arr)[0]

Bu işlerin çoğu! AMA hızlı bir tek hat (düşük kaynak) çağrısı için:

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

Bu işe yarar ve terbiyeli olsa da, lütfen ek cevabımı da görün: https://stackoverflow.com/a/48410351/1804013

Ben dizi_değerleri kullanarak burada en iyi bahis olacağını düşünüyorum . 'Apple' elde etmek için bu işlevin sonucundan index dizinindeki değeri döndürebilirsiniz.

Bu oyuna biraz geç, ama benim dizi içinde çocuk olarak dizi öğeleri içeren bir sorun ile sunuldu, ve bu yüzden sadece ilk dizi elemanının bir dize temsili alamadım. By PHP'nin kullanarak current()işlevini , bu yönetilen:

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

Tüm mevcut çözümler sayesinde bu yanıtı almama yardımcı oldu, umarım bu birisine yardımcı olur!

kullanın:

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

Varsayılan olarak, array_sliceanahtarları korumaz, bu nedenle sıfır olarak dizin olarak güvenle kullanabiliriz.

Sizin için iki çözüm.

Çözüm 1 - Sadece anahtarı kullanın. Kullanamayacağınızı söylemediniz. :)

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

Çözüm 2 - array_flip () + tuşu ()

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

Çözüm 3 - Dizi_anahtarları ()

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

Bu gerçek dünyada o kadar basit bir yanıt değildir. Bazı kütüphanelerde bulabileceğiniz olası yanıt örneklerine sahip olduğumuzu varsayalım.

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

Gördüğünüz gibi, bazı durumlarda iyi çalışan, ancak hepsi değil, birkaç 'tek hat' çözümümüz var.

Bence, bu işleyiciyi sadece dizilerle yapmalısınız.

Şimdi performanstan bahsediyoruz, her zaman dizimiz olduğunu varsayarak, şöyle:

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

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

array_shiftdaha hızlıdır reset, bu [count () - 1] 'den daha hızlıdır ve bu üç array_valuesve' den daha hızlıdır array_slice.

Ben yazar sadece bazı fonksiyondan ( mysql_fetch_row) aldıktan sonra bir dizinin ilk elemanını almak için bir yol arıyordum hayal bir STRICT "Sadece değişkenler referans tarafından geçirilmelidir" üretmeden örneğin, ,) .

Öyleyse, burada açıklanan neredeyse tüm yollar bu mesajı alacaktır ... ve bazıları bir diziyi (veya bir kısmını) çoğaltan çok fazla ek bellek kullanır. Bundan kaçınmanın kolay bir yolu, bu işlevlerden herhangi birini çağırmadan önce satır içi değeri atamaktır:

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

Bu şekilde, ekranda veya günlüklerde STRICT mesajını almazsınız ve başka diziler oluşturmazsınız. Bu çalışır hem endeksli VE ilişkisel diziler.

"Liste" örneğini seviyorum, ancak "liste" yalnızca bir ödevin sol tarafında çalışır. Bir değişken atamak istemezsek, en iyi şekilde kapsamımızı kirleten ve en kötü ihtimalle mevcut bir değerin üzerine yazan geçici bir ad oluşturmak zorunda kalırız:

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

Yukarıdakiler varolan herhangi bir $ x değerinin üzerine yazacak ve $ x değişkeni bu kapsam aktif olduğu sürece (bu fonksiyonun / yöntemin sonu ya da en üst seviyedeysek sonsuza kadar) takılır. Bu, call_user_func ve anonim bir işlev kullanılarak çözülebilir, ancak karmaşıktır:

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

Bunun gibi anonim işlevler kullanırsak, doğrudan başvuru kullanıyor olsalar bile reset ve array_shift ile gerçekten kurtulabiliriz. Bunun nedeni, bir işlevin çağrılmasının bağımsız değişkenlerini bağlaması ve bu bağımsız değişkenlerin başvuru ile iletilebilmesidir:

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

Ancak, call_user_func bu geçici atamayı dahili olarak gerçekleştireceğinden, bu aslında aşırıdır. Bu, referans yoluyla işlevlere, herhangi bir uyarı veya hata olmadan, değere göre değer gibi davranmamızı sağlar:

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

Sarfraz'ın yayınladığı şeyde küçük bir değişiklik:

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

Dizinin iç işaretçisi ile uğraşmayı sevmiyorum, ama aynı zamanda array_keys()veya ile ikinci bir dizi oluşturmak da yetersiz array_values(), bu yüzden genellikle bunu tanımlarım:

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

Bunu dene:

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