각 루프에 대한 다음 요소 가져오기

각 루프에 대한 다음 요소 가져오기

각 루프에 대해 현재 요소를 비교할 수 있도록 루프에 다음 요소가 있는지 확인합니다.어떻게 해야 하나요?현재 기능과 다음 기능에 대해 읽었는데 어떻게 사용하는지 모르겠어요.

고유한 접근 방식은 배열을 반대로 한 다음 루프하는 것입니다.이 기능은 숫자로 인덱싱되지 않은 어레이에서도 작동합니다.

$items = array(
    'one'   => 'two',
    'two'   => 'two',
    'three' => 'three'
);
$backwards = array_reverse($items);
$last_item = NULL;

foreach ($backwards as $current_item) {
    if ($last_item === $current_item) {
        // they match
    }
    $last_item = $current_item;
}

여전히 사용에 관심이 있는 경우current그리고.next다음과 같은 기능을 사용할 수 있습니다.

$items = array('two', 'two', 'three');
$length = count($items);
for($i = 0; $i < $length - 1; ++$i) {
    if (current($items) === next($items)) {
        // they match
    }
}

#2가 가장 좋은 해결책일 것입니다.메모,$i < $length - 1;배열의 마지막 두 항목을 비교한 후 루프를 중지합니다.저는 이것을 예시와 함께 명확하게 하기 위해 루프에 넣었습니다.당신은 아마도 그냥 계산을 해야 할 것입니다.$length = count($items) - 1;

각 항목에 대해 루프하는 대신 루프하는 동안 사용할 수 있습니다.

while ($current = current($array) )
{
    $next = next($array);
    if (false !== $next && $next == $current)
    {
        //do something with $current
    }
}

인덱스가 연속적인 경우:

foreach ($arr as $key => $val) {
   if (isset($arr[$key+1])) {
      echo $arr[$key+1]; // next element
   } else {
     // end of array reached
   }
}

php.net/foreach 이 지적한 바와 같이:

어레이가 참조되지 않는 한, 각 어레이는 어레이 자체가 아닌 지정된 어레이의 복사본에서 작동합니다.각각 배열 포인터에 몇 가지 부작용이 있습니다.각각의 배열 포인터를 재설정하지 않고는 배열 포인터에 의존하지 마십시오.

다시 말해서, 여러분이 요청하는 것을 하는 것은 좋은 생각이 아닙니다.아마도 여러분이 왜 이것을 하려고 하는지에 대해 누군가와 이야기하고, 더 나은 해결책이 있는지 알아보는 것이 좋을 것입니다.다른 리소스가 없는 경우 irc.freenode.net 의 ##PHP에서 언제든지 문의하십시오.

키/값 및 색인을 얻을 수 있습니다.

<?php
$a = array(
    'key1'=>'value1', 
    'key2'=>'value2', 
    'key3'=>'value3', 
    'key4'=>'value4', 
    'key5'=>'value5'
);

$keys = array_keys($a);
foreach(array_keys($keys) as $index ){       
    $current_key = current($keys); // or $current_key = $keys[$index];
    $current_value = $a[$current_key]; // or $current_value = $a[$keys[$index]];

    $next_key = next($keys); 
    $next_value = $a[$next_key] ?? null; // for php version >= 7.0

    echo  "{$index}: current = ({$current_key} => {$current_value}); next = ({$next_key} => {$next_value})\n";
}

결과:

0: current = (key1 => value1); next = (key2 => value2) 
1: current = (key2 => value2); next = (key3 => value3) 
2: current = (key3 => value3); next = (key4 => value4) 
3: current = (key4 => value4); next = (key5 => value5) 
4: current = (key5 => value5); next = ( => )

숫자로 인덱싱된 경우:

foreach ($foo as $key=>$var){

    if($var==$foo[$key+1]){
        echo 'current and next var are the same';
    }
}

일반적인 솔루션은 캐싱 반복기일 수 있습니다.적절하게 구현된 캐싱 반복기는 모든 반복기와 함께 작동하며 메모리를 절약합니다.PHP SPL은 CachingIterator를 가지고 있지만 매우 특이하고 매우 제한적인 기능을 가지고 있습니다.그러나 다음과 같이 자신만의 미리 보기 반복기를 작성할 수 있습니다.

<?php

class NeighborIterator implements Iterator
{

    protected $oInnerIterator;

    protected $hasPrevious = false;
    protected $previous = null;
    protected $previousKey = null;

    protected $hasCurrent = false;
    protected $current = null;
    protected $currentKey = null;

    protected $hasNext = false;
    protected $next = null;
    protected $nextKey = null;

    public function __construct(Iterator $oInnerIterator)
    {
        $this->oInnerIterator = $oInnerIterator;
    }

    public function current()
    {
        return $this->current;
    }

    public function key()
    {
        return $this->currentKey;
    }

    public function next()
    {
        if ($this->hasCurrent) {
            $this->hasPrevious = true;
            $this->previous = $this->current;
            $this->previousKey = $this->currentKey;
            $this->hasCurrent = $this->hasNext;
            $this->current = $this->next;
            $this->currentKey = $this->nextKey;
            if ($this->hasNext) {
                $this->oInnerIterator->next();
                $this->hasNext = $this->oInnerIterator->valid();
                if ($this->hasNext) {
                    $this->next = $this->oInnerIterator->current();
                    $this->nextKey = $this->oInnerIterator->key();
                } else {
                    $this->next = null;
                    $this->nextKey = null;
                }
            }
        }
    }

    public function rewind()
    {
        $this->hasPrevious = false;
        $this->previous = null;
        $this->previousKey = null;
        $this->oInnerIterator->rewind();
        $this->hasCurrent = $this->oInnerIterator->valid();
        if ($this->hasCurrent) {
            $this->current = $this->oInnerIterator->current();
            $this->currentKey = $this->oInnerIterator->key();
            $this->oInnerIterator->next();
            $this->hasNext = $this->oInnerIterator->valid();
            if ($this->hasNext) {
                $this->next = $this->oInnerIterator->current();
                $this->nextKey = $this->oInnerIterator->key();
            } else {
                $this->next = null;
                $this->nextKey = null;
            }
        } else {
            $this->current = null;
            $this->currentKey = null;
            $this->hasNext = false;
            $this->next = null;
            $this->nextKey = null;
        }
    }

    public function valid()
    {
        return $this->hasCurrent;
    }

    public function hasNext()
    {
        return $this->hasNext;
    }

    public function getNext()
    {
        return $this->next;
    }

    public function getNextKey()
    {
        return $this->nextKey;
    }

    public function hasPrevious()
    {
        return $this->hasPrevious;
    }

    public function getPrevious()
    {
        return $this->previous;
    }

    public function getPreviousKey()
    {
        return $this->previousKey;
    }

}


header("Content-type: text/plain; charset=utf-8");
$arr = [
    "a" => "alma",
    "b" => "banan",
    "c" => "cseresznye",
    "d" => "dio",
    "e" => "eper",
];
$oNeighborIterator = new NeighborIterator(new ArrayIterator($arr));
foreach ($oNeighborIterator as $key => $value) {

    // you can get previous and next values:

    if (!$oNeighborIterator->hasPrevious()) {
        echo "{FIRST}\n";
    }
    echo $oNeighborIterator->getPreviousKey() . " => " . $oNeighborIterator->getPrevious() . " ----->        ";
    echo "[ " . $key . " => " . $value . " ]        -----> ";
    echo $oNeighborIterator->getNextKey() . " => " . $oNeighborIterator->getNext() . "\n";
    if (!$oNeighborIterator->hasNext()) {
        echo "{LAST}\n";
    }
}

각각의 키 앞에 배열 키를 가져온 다음 카운터를 사용하여 다음과 같은 요소를 확인할 수 있습니다.

//$arr is the array you wish to cycle through
$keys = array_keys($arr);
$num_keys = count($keys);
$i = 1;
foreach ($arr as $a)
{
    if ($i < $num_keys && $arr[$keys[$i]] == $a)
    {
        // we have a match
    }
    $i++;
}

이는 다음과 같은 단순 어레이에 모두 적용됩니다.array(1,2,3)다음과 같은 키 배열array('first'=>1, 'second'=>2, 'thrid'=>3).

php의 각 루프에 대해 원래 배열의 복사본 위에 반복하여 만듭니다.next()그리고.prev()쓸모없는 기능.연관 배열이 있고 다음 항목을 가져와야 하는 경우, 대신 배열 키를 통해 반복할 수 있습니다.

foreach (array_keys($items) as $index => $key) {
    // first, get current item
    $item = $items[$key];
    // now get next item in array
    $next = $items[array_keys($items)[$index + 1]];
}

결과 키 배열에는 연속 인덱스 자체가 있으므로 이 인덱스를 사용하여 원래 배열에 액세스할 수 있습니다.

알아두시기 바랍니다.$next▁▁be 될 것입니다.null마지막 항목 뒤에 다음 항목이 없기 때문에 마지막 반복의 경우.존재하지 않는 배열 키에 액세스하면 php 알림이 표시됩니다.이를 방지하려면 다음 중 하나를 수행합니다.

1. 합니다.$next
2. 키가 다음과 같은지 확인합니다.index + 1와 함께 존재합니다.array_key_exists()

방법 2를 사용하면 각각의 전체가 다음과 같이 보일 수 있습니다.

foreach (array_keys($items) as $index => $key) {
    // first, get current item
    $item = $items[$key];
    // now get next item in array
    $next = null;
    if (array_key_exists($index + 1, array_keys($items))) {
        $next = $items[array_keys($items)[$index + 1]];
    }
}

    $next_data = $data;

    $prev_key = null;
    $prev_value = null;

    foreach($data as $key => $value)
    {
        array_shift($next_data);

        $next_key = key($next_data);
        $next_value = $next_data[$next_key] ?? null;

        // Do something here...

        $prev_key = $key;
        $prev_value = $value;
    }

또는 배열이 연관되어 있으면 사용할 수 있습니다.current()안드레이 크라수츠키의 솔루션과 유사하며key()

$values = [];
array_push($values, ["XYZ"=>100]);
array_push($values, ["ABC"=>10]);
array_push($values, ["XYZ"=>130]);
array_push($values, ["DEF"=>4]);
array_push($values, ["XYZ"=>5]);

$count = count($values);

foreach ($values as $index => $currentValue) {

    if ($index < $count - 1) {

        $nextValue = $values[$index + 1];
        echo key($currentValue) . "=" . current($currentValue) . " followed by  " . key($nextValue) . "/" . current($nextValue) . "<br>\n";

    } else {

        echo key($currentValue) . "=" . current($currentValue);

    }
}

실행 예는 https://onlinephp.io/c/dc58d 을 참조하십시오.

또는 어레이가 명명된 쌍을 사용하는 경우:

$values = [];
array_push($values, ["type"=>"XYZ", "value"=>100]);
array_push($values, ["type"=>"ABC", "value"=>10]);
array_push($values, ["type"=>"XYZ", "value"=>130]);
array_push($values, ["type"=>"DEF", "value"=>"Lorem"]);
array_push($values, ["type"=>"XYZ", "value"=>5]);

$count = count($values);

foreach ($values as $index => $currentValue) {
    if ($index < $count - 1) {
        $nextValue = $values[$index + 1];
        echo $currentValue['type'] . "=" . $currentValue['value'] 
        . "  followed by  " . $nextValue['type'] . "/" . $nextValue['value'] . "<br>\n";
    } else {
        echo $currentValue['type'] . "=" . $currentValue['value'];
    }
}

언급URL : https://stackoverflow.com/questions/5096791/get-next-element-in-foreach-loop