class Test implements Iterator{
    private $item = array('a' => 4, 1, 2, 3);

    public function rewind() {
        reset($this->item);
    }

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

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

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

    public function valid() {
        return($this->current() !== false);
    }
 }

 $t = new Test;
 foreach($t as $k => $v){
     var_dump($k, $v);
 }

$start = microtime(true);
foreach($array as $value){$value;};
printf('%.6f' . PHP_EOL, microtime(true) - $start);

$start = microtime(true);
$count = count($array);
for($i=0;$i<$count;$i++){$array[$i];}
printf('%.6f' . PHP_EOL, microtime(true) - $start);

$start = microtime(true);
foreach($array as $key => $value) {
        $array[$key] += 1;
}
printf('%.6f' . PHP_EOL, microtime(true) - $start);

$start = microtime(true);
$count = count($array);
for($i=0;$i<$count;$i++) {
        $array[$i] += 1;
}
printf('%.6f' . PHP_EOL, microtime(true) - $start);

foreach($array as &$value) {
    $value += 1;
}
unset($value);

typedef struct _hashtable { 
    uint nTableSize;        // hash Bucket的大小，最小为8，以2x增长。
    uint nTableMask;        // nTableSize-1 ， 索引取值的优化
    uint nNumOfElements;    // hash Bucket中当前存在的元素个数，count()函数会直接返回此值 
    ulong nNextFreeElement; // 下一个数字索引的位置
    Bucket *pInternalPointer;   // 当前遍历的指针（foreach比for快的原因之一）
    Bucket *pListHead;          // 存储数组头元素指针
    Bucket *pListTail;          // 存储数组尾元素指针
    Bucket **arBuckets;         // 存储hash数组
    dtor_func_t pDestructor;    // 在删除元素时执行的回调函数，用于资源的释放
    zend_bool persistent;       //指出了Bucket内存分配的方式。如果persisient为TRUE，则使用操作系统本身的内存分配函数为Bucket分配内存，否则使用PHP的内存分配函数。
    unsigned char nApplyCount; // 标记当前hash Bucket被递归访问的次数（防止多次递归）
    zend_bool bApplyProtection;// 标记当前hash桶允许不允许多次访问，不允许时，最多只能递归3次
#if ZEND_DEBUG
    int inconsistent;
#endif
} HashTable;

typedef struct bucket {
    ulong h;            // 对char *key进行hash后的值，或者是用户指定的数字索引值
    uint nKeyLength;    // hash关键字的长度，如果数组索引为数字，此值为0
    void *pData;        // 指向value，一般是用户数据的副本，如果是指针数据，则指向pDataPtr
    void *pDataPtr;     //如果是指针数据，此值会指向真正的value，同时上面pData会指向此值
    struct bucket *pListNext;   // 整个hash表的下一元素
    struct bucket *pListLast;   // 整个哈希表该元素的上一个元素
    struct bucket *pNext;       // 存放在同一个hash Bucket内的下一个元素
    struct bucket *pLast;       // 同一个哈希bucket的上一个元素
    // 保存当前值所对于的key字符串，这个字段只能定义在最后，实现变长结构体
    char arKey[1];              
} Bucket;

reset($array);
while(list($key, $value) = each($array));

$value = reset($array);
do {
} while($value = next($array));

$array = array(1,2,3,4);
echo next($array);

foreach ($array as $value) {
  if (!next($array)) reset($array);
}

echo current($array);

$array = array(1,2,3,4);
foreach($array as $key => $value) {
        $array[$key] = &$value;        
}

$array = array(1,2,3,4);
foreach($array as $key => $value) {
        $value = &$array[$key];        
}

$array = array(599 => 'PHP', 'JAVA');
$search = 'P';
$result = array_filter(array_map(function($value) use ($search) {
                return is_numeric(strpos($value, $search)) ? $value :  false;
}, $array));

    $grade = array("score" => array(70, 95, 70.0, 60, "70"),
                   "name" => array("Zhang San", "Li Si", "Wang Wu",
                                   "Zhao Liu", "Liu Qi"));
    array_multisort($grade["score"], SORT_NUMERIC, SORT_DESC,
                    // 将分数作为数值，由高到低排序
                    $grade["name"], SORT_STRING, SORT_ASC);
                    // 将名字作为字符串，由小到大排序

$data[] = array('volume' => 67, 'edition' => 2);
$data[] = array('volume' => 86, 'edition' => 1);
$data[] = array('volume' => 85, 'edition' => 6);
$data[] = array('volume' => 98, 'edition' => 2);
$data[] = array('volume' => 86, 'edition' => 6);
$data[] = array('volume' => 67, 'edition' => 7);

$volume  = array_column($data, 'volume');
$edition = array_column($data, 'edition');

array_multisort($volume, SORT_DESC, $edition, SORT_ASC, $data);

array_map(function($value) {}, $array);

$n = 254;
$a = [];
while($n > 1) {
        $a[] = $n % 2;
        $n >>= 1;
}
echo implode('', array_reverse($a));

function recursiveDirectory($dir) {
        if (is_dir($dir) && $db = opendir($dir)) {
                while ($file = readdir($db)) {
                        $path = $dir . '/' . $file;
                        if (in_array($file, array('.', '..'))) {
                                $files[] = $file;
                                continue;
                        } elseif (is_dir($path)) {
                                RecursiveDirectory($path);
                        } elseif (is_file($path)) {
                        }
                }        
                closedir($db);
        }
}

function queueDirectory($dir) {
        $queue = array('');
        while (($file = array_shift($queue)) !== null) {
                $path = join(DIRECTORY_SEPARATOR, array($dir, $file));
                if (in_array($file, array('.', '..'))) {
                        $files[] = $file;
                        continue;
                } elseif (is_dir($path) && $dh = opendir($path)) {
                        while ($file = readdir($dh)) {
                                $queue[] = $file;
                        }
                        closedir($dh);
                } elseif (is_file($path)) {
                }
        }
}

$objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::SELF_FIRST);
foreach($objects as $name => $object){
}

function josephus($n, $m) {
    $i = 1;
    while (count($n) > 1) {
        foreach ($n as $k => $v) {
            if ($i++ == $m) {
                unset($n[$k]);
                $i = 1;
            }
        }
    }

    return array_pop($n);
}

function josephus($total, $index) {
    $result = 0;
    for($i=2; $i<= $total; $i++) {
        $result = ($result + $index) % $i;
    }
    $num = $result + 1;
    
    return $num;
}