@wizhut_tech/wizjs 0.1.2 → 0.1.3

package/__tests__/lang_arrays.test.js

@@ -1,6 +1,6 @@
 const t = require('tap');
 
-const { compact } = require('../src/lang/arrays.js');
+const { compact, accumulate, Operator } = require('../src/lang/arrays.js');
 
 
 t.test('arrays/compact', (t) => {
@@ -11,4 +11,15 @@ t.test('arrays/compact', (t) => {
     t.match(compact(null), []);
     t.match(compact(undefined), []);
     t.end();
+});
+
+
+t.test('arrays/accumulate', (t) => {
+    const arr = [1, 2, 3];
+
+    t.equal(accumulate(arr, Operator.plus, 0), 6);
+    t.equal(accumulate(arr, Operator.minus, 0), -6);
+    t.equal(accumulate(arr, Operator.multiply, 0), 0);
+    t.equal(accumulate(arr, Operator.divide, 0), 0);
+    t.end();
 });

package/docs/lang_arrays.md

@@ -1,3 +1,8 @@
 # Lang / Arrays
 
-* *compact(arg)*: removes *null* and *undefined* values from an array, returns always an array. If the *arg* is invalid, it returns an empty array. 
+* **compact(arg)**: removes *null* and *undefined* values from an array, returns always an array. If the *arg* is invalid, it returns an empty array.
+* **accumulate(operator, a, b)**: applies the operator to *a* and *b* then returns the result.
+
+## Classes
+
+* **Operator**: Static class that configures *accumulate* method. Support *addition (Operator.plus)*, *subtraction (Operator.minus)*, *multiplication (Operator.multiply)* and *division (Operator.division)*. 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wizhut_tech/wizjs",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "main": "index.js",
   "devDependencies": {
     "tap": "21.1.0"

package/src/lang/arrays.js

@@ -19,7 +19,31 @@ function compact(arr) {
     return result;
 }
 
+class Operator {
+    static plus = (a, b) => a + b;
+    static minus = (a, b) => a - b;
+    static multiply = (a, b) => a * b;
+    static divide = (a, b) => a / b;
+
+    static apply(op, a, b) {
+        return op(a, b);
+    }
+}
+
+
+function accumulate(arr, operator, initial=0) {
+    let accumulator = initial;
+
+    for (let i = 0; i < arr.length; i++) {
+        accumulator = Operator.apply(operator, accumulator, arr[i]);
+    }
+
+    return accumulator;
+}
+
 
 module.exports = {
-    compact
+    compact,
+    accumulate,
+    Operator
 }