Added each method and updated README links

Author: minwork

README.md

@@ -13,8 +13,9 @@ Advanced implementation of well known operations:
   * [Set](https://minwork.gitbook.io/array/common-methods/set-setnestedelement)
   * [Has](https://minwork.gitbook.io/array/common-methods/has)
   * [Map](https://minwork.gitbook.io/array/manipulating-array/mapping)
+  * [Each](https://minwork.gitbook.io/array/traversing-array/iterating)
   * [Filter](https://minwork.gitbook.io/array/manipulating-array/filtering)
-  * [Find](https://minwork.gitbook.io/array/manipulating-array/finding)
+  * [Find](https://minwork.gitbook.io/array/traversing-array/finding)
   * [Group](https://minwork.gitbook.io/array/manipulating-array/grouping)
   * [Sort](https://minwork.gitbook.io/array/manipulating-array/sorting)
   * [Check](https://minwork.gitbook.io/array/validating-array/check)

src/Arr.php

@@ -47,6 +47,27 @@ class Arr
      */
     const MAP_ARRAY_VALUE_KEY = 8;
 
+    /**
+     * Iterate using callback in form of function($value)
+     */
+    const EACH_VALUE = 0;
+    /**
+     * Iterate using callback in form of function($key, $value)
+     */
+    const EACH_KEY_VALUE = 1;
+    /**
+     * Iterate using callback in form of function($value, $key1, $key2, ...)
+     */
+    const EACH_VALUE_KEYS_LIST = 2;
+    /**
+     * Iterate using callback in form of function(array $keys, $value)
+     */
+    const EACH_KEYS_ARRAY_VALUE = 3;
+    /**
+     * Iterate using callback in form of function($value, $key)
+     */
+    const EACH_VALUE_KEY = 4;
+
     const UNPACK_ALL = 1;
     /**
      * Preserve arrays with highest nesting level (if they are not assoc) as element values instead of unpacking them
@@ -583,6 +604,52 @@ public static function mapObjects(array $objects, string $method, ...$args): arr
         return $return;
     }
 
+    /**
+     * Traverse through array or iterable object and call callback for each element (ignoring the result).<br/>
+     * <br/>
+     * <b>Warning:</b> For <tt>EACH_VALUE_KEYS_LIST</tt> and <tt>EACH_KEYS_ARRAY_VALUE</tt> modes <tt>$iterable</tt> MUST be an array.
+     *
+     * @param array|Iterator|IteratorAggregate $iterable Usually array, but can be an iterable object.
+     * @param callable $callback Callback function for each element of an iterable
+     * @param int $mode What parameters and in which order should <tt>$callback</tt> receive
+     * @return array|Iterator|IteratorAggregate Return unchanged input for chaining
+     */
+    public static function each($iterable, callable $callback, int $mode = self::EACH_VALUE)
+    {
+        switch ($mode) {
+            case self::EACH_KEY_VALUE:
+                foreach ($iterable as $key => $value) {
+                    $callback($key, $value);
+                }
+                break;
+            case self::EACH_VALUE_KEY:
+                foreach ($iterable as $key => $value) {
+                    $callback($value, $key);
+                }
+                break;
+            case self::EACH_VALUE_KEYS_LIST:
+                foreach (self::unpack($iterable) as $dotKeys => $value) {
+                    $keys = self::getKeysArray($dotKeys);
+                    $callback($value, ...$keys);
+                }
+                break;
+            case self::EACH_KEYS_ARRAY_VALUE:
+                foreach (self::unpack($iterable) as $dotKeys => $value) {
+                    $keys = self::getKeysArray($dotKeys);
+                    $callback($keys, $value);
+                }
+                break;
+            case self::EACH_VALUE:
+            default:
+                foreach ($iterable as $value) {
+                    $callback($value);
+                }
+                break;
+        }
+
+        return $iterable;
+    }
+
     /**
      * Filter array values by preserving only those which keys are present in array obtained from $keys variable
      *

src/ArrObj.php

@@ -63,6 +63,11 @@
  *
  * ---------------------------------------------------------------------------------
  *
+ * @method ArrObj each(callable $callback, int $mode = Arr::EACH_VALUE)
+ * @see Arr::each()
+ *
+ * ---------------------------------------------------------------------------------
+ *
  * @method ArrObj filterByKeys(mixed $keys, bool $exclude = false)
  * @see Arr::filterByKeys()
  *
@@ -168,6 +173,7 @@ class ArrObj implements IteratorAggregate, ArrayAccess, Countable
         'isArrayOfArrays',
         'map',
         'mapObjects',
+        'each',
         'filterByKeys',
         'filterObjects',
         'group',
@@ -199,6 +205,7 @@ class ArrObj implements IteratorAggregate, ArrayAccess, Countable
         'remove',
         'map',
         'mapObjects',
+        'each',
         'filterByKeys',
         'filterObjects',
         'group',

test/Arr/ArrTest.php

@@ -674,6 +674,52 @@ function test($arg = 0)
         $this->assertSame([3, 3, 3], $this->callMethod([$class, 'mapObjects'], $array, 'test', 2));
     }
 
+    /**
+     * @param $class string|ArrObj
+     * @dataProvider arrayClassProvider
+     */
+    public function testEach($class)
+    {
+        foreach ($this->arrayProvider() as [$array]) {
+
+            // Check both pure array and iterable object
+            foreach ([$array, new ArrayObject($array)] as $iterable) {
+                // Just value
+                $index = 0;
+                $values = array_values($iterable instanceof ArrayObject ? $iterable->getArrayCopy() : $iterable);
+                $this->callMethod([$class, 'each'], $iterable, function ($value) use ($values, &$index) {
+                    $this->assertSame($values[$index++], $value);
+                }, Arr::EACH_VALUE);
+
+                // Also check default
+                $index = 0;
+                $this->callMethod([$class, 'each'], $iterable, function ($value) use ($values, &$index) {
+                    $this->assertSame($values[$index++], $value);
+                });
+
+                // Key, Value
+                $this->callMethod([$class, 'each'], $iterable, function ($key, $value) use ($iterable) {
+                    $this->assertSame($iterable[$key], $value);
+                }, Arr::EACH_KEY_VALUE);
+
+                // Value, Key
+                $this->callMethod([$class, 'each'], $iterable, function ($value, $key) use ($iterable) {
+                    $this->assertSame($iterable[$key], $value);
+                }, Arr::EACH_VALUE_KEY);
+            }
+
+            // Value, Keys list
+            $this->callMethod([$class, 'each'], $array, function ($value, ...$keys) use ($class, $array) {
+                $this->assertSame($this->callMethod([$class, 'get'], $array, $keys), $value);
+            }, Arr::EACH_VALUE_KEYS_LIST);
+
+            // Keys array, Value
+            $this->callMethod([$class, 'each'], $array, function ($keys, $value) use ($class, $array) {
+                $this->assertSame($this->callMethod([$class, 'get'], $array, $keys), $value);
+            }, Arr::EACH_KEYS_ARRAY_VALUE);
+        }
+    }
+
     /**
      * @param $class string|ArrObj
      *

test/ArrTestCase.php

@@ -2,6 +2,7 @@
 namespace Test;
 
 use InvalidArgumentException;
+use Minwork\Helper\Arr;
 use Minwork\Helper\ArrObj;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
@@ -157,7 +158,7 @@ protected function callMethod(callable $callable, $array, ...$args)
     public function arrayClassProvider(): array
     {
         return [
-            ['\Minwork\Helper\Arr'],
+            [Arr::class],
             [new ArrObj()],
         ];
     }