Merge pull request #7 from rpgeeganage/bug_in_fix_reduce

fix bug in reduce right and reduce
rpgeeganage · Oct 25, 2018 · a73e517 · a73e517
2 parents 8f0a8d1 + 70f9ca1
commit a73e517
Show file tree

Hide file tree

Showing 5 changed files with 20 additions and 31 deletions.
diff --git a/lib/methods/reduce.ts b/lib/methods/reduce.ts
@@ -27,16 +27,17 @@ export async function reduce<T, R>(
   }
 
   let reducedValue: T | R;
-  const copiedElements = [...elements];
+  let index = 0;
 
   if (initialValue === undefined) {
-    reducedValue = copiedElements.shift() as T;
+    reducedValue = elements[0] as T;
+    index++;
   } else {
     reducedValue = initialValue;
   }
 
-  for (const [index, element] of copiedElements.entries()) {
-    reducedValue = await cb(reducedValue, element, index, copiedElements);
+  for (; index < elements.length; index++) {
+    reducedValue = await cb(reducedValue, elements[index], index, elements);
   }
 
   return reducedValue;

diff --git a/lib/methods/reduce_right.ts b/lib/methods/reduce_right.ts
@@ -27,16 +27,17 @@ export async function reduceRight<T, R>(
   }
 
   let reducedValue: T | R;
-  const reversedElements = [...elements].reverse();
+  let index = elements.length - 1;
 
   if (initialValue === undefined) {
-    reducedValue = reversedElements.shift() as T;
+    reducedValue = elements[index] as T;
+    index--;
   } else {
     reducedValue = initialValue;
   }
 
-  for (const [index, element] of reversedElements.entries()) {
-    reducedValue = await cb(reducedValue, element, index, reversedElements);
+  for (; index >= 0; index--) {
+    reducedValue = await cb(reducedValue, elements[index], index, elements);
   }
 
   return reducedValue;

diff --git a/package.json b/package.json
@@ -3,7 +3,7 @@
   "description": "Allow perform every, filter, find, findIndex, forEach, map, reduce, reduceRight and some on array using Async callback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "scripts": {
     "pretest": "npm run build",
     "test": "mocha -r ts-node/register/type-check test/*.ts",

diff --git a/test/find_index.ts b/test/find_index.ts
@@ -52,11 +52,9 @@ describe('AsyncRay', () => {
     });
 
     it('should return -1 as index if array is empty', async () => {
-      const output: number = await AsyncRay([]).aFindIndex(
-        async () => {
-          return true;
-        }
-      );
+      const output: number = await AsyncRay([]).aFindIndex(async () => {
+        return true;
+      });
 
       should(output).eql(-1);
     });

diff --git a/test/reduce_right.ts b/test/reduce_right.ts
@@ -21,13 +21,11 @@ describe('AsyncRay', () => {
   describe('reduceRight', () => {
     describe('with initial value', () => {
       it('should return reduceRight values for number', async () => {
-        const reversedArray = [...inputArray].reverse();
-
         const outputElement = await AsyncRay(inputArray).aReduceRight<number>(
           async (acc, i, index, collection) => {
             should(collection)
               .instanceOf(Array)
-              .containDeepOrdered(reversedArray);
+              .containDeepOrdered(inputArray);
             should(i)
               .not.undefined()
               .Number();
@@ -43,13 +41,12 @@ describe('AsyncRay', () => {
 
       it('should return reduceRight values for string', async () => {
         const inputString: string[] = ['s', 't', 'r', 'i', 'n', 'g'];
-        const reversedArray = [...inputString].reverse();
 
         const outputElement = await AsyncRay(inputString).aReduceRight<string>(
           async (acc, i, index, collection) => {
             should(collection)
               .instanceOf(Array)
-              .containDeepOrdered(reversedArray);
+              .containDeepOrdered(inputString);
             should(i)
               .not.undefined()
               .String();
@@ -65,14 +62,13 @@ describe('AsyncRay', () => {
 
       it('should return reduceRight values for array containing arrays', async () => {
         const inputArrayOfArrays: [number, number][] = [[0, 1], [2, 3], [4, 5]];
-        const reversedArray = [...inputArrayOfArrays].reverse();
 
         const outputElement = await AsyncRay(inputArrayOfArrays).aReduceRight<
           number[]
         >(async (acc, i, index, collection) => {
           should(collection)
             .instanceOf(Array)
-            .containDeepOrdered(reversedArray);
+            .containDeepOrdered(inputArrayOfArrays);
           should(i)
             .instanceOf(Array)
             .containDeepOrdered(i);
@@ -87,14 +83,11 @@ describe('AsyncRay', () => {
 
     describe('without initial value', () => {
       it('should return reduceRight values for number', async () => {
-        const reversedArray = [...inputArray].reverse();
-        reversedArray.shift();
-
         const outputElement = await AsyncRay(inputArray).aReduceRight<number>(
           async (acc, i, index, collection) => {
             should(collection)
               .instanceOf(Array)
-              .containDeepOrdered(reversedArray);
+              .containDeepOrdered(inputArray);
             should(i)
               .not.undefined()
               .Number();
@@ -109,14 +102,12 @@ describe('AsyncRay', () => {
 
       it('should return reduceRight values for string', async () => {
         const inputString: string[] = ['s', 't', 'r', 'i', 'n', 'g'];
-        const reversedArray = [...inputString].reverse();
-        reversedArray.shift();
 
         const outputElement = await AsyncRay(inputString).aReduceRight<string>(
           async (acc, i, index, collection) => {
             should(collection)
               .instanceOf(Array)
-              .containDeepOrdered(reversedArray);
+              .containDeepOrdered(inputString);
             should(i)
               .not.undefined()
               .String();
@@ -131,15 +122,13 @@ describe('AsyncRay', () => {
 
       it('should return reduceRight values for array containing arrays', async () => {
         const inputArrayOfArrays: [number, number][] = [[0, 1], [2, 3], [4, 5]];
-        const reversedArray = [...inputArrayOfArrays].reverse();
-        reversedArray.shift();
 
         const outputElement = await AsyncRay(inputArrayOfArrays).aReduceRight<
           number[]
         >(async (acc, i, index, collection) => {
           should(collection)
             .instanceOf(Array)
-            .containDeepOrdered(reversedArray);
+            .containDeepOrdered(inputArrayOfArrays);
           should(i)
             .instanceOf(Array)
             .containDeepOrdered(i);