feat: add reduce and reduceRight.

Author: ghosind

src/dynamicBuffer.ts

@@ -745,6 +745,132 @@ export class DynamicBuffer {
     return this.buffer[offset];
   }
 
+  /**
+   * Calls the specified callback function for all the bytes in an buffer. The return value of
+   * the callback function is the accumulated result, and is provided as an argument in the next
+   * call to the callback function.
+   *
+   * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
+   * callbackfn function one time for each byte in the buffer.
+   * @param initialValue If initialValue is specified, it is used as the initial value to start
+   * the accumulation. The first call to the callbackfn function provides this value as an argument
+   * instead of a byte value.
+   */
+  reduce(
+    callbackfn: (
+      previousValue: number,
+      currentValue: number,
+      currentIndex: number,
+      array: Uint8Array,
+    ) => number,
+  ): number;
+
+  reduce(
+    callbackfn: (
+      previousValue: number,
+      currentValue: number,
+      currentIndex: number,
+      array: Uint8Array,
+    ) => number,
+    initialValue: number,
+  ): number;
+
+  reduce<T>(
+    callbackfn: (
+      previousValue: T,
+      currentValue: number,
+      currentIndex: number,
+      array: Uint8Array,
+    ) => T,
+    initialValue: T,
+  ): T;
+
+  reduce(
+    callbackfn: (
+      previousValue: any,
+      currentValue: number,
+      currentIndex: number,
+      array: Uint8Array,
+    ) => any,
+    initialValue?: any,
+  ): any {
+    if (!this.buffer || this.length <= 0) {
+      if (initialValue === undefined) {
+        throw new TypeError('Reduce of empty buffer with no initial value');
+      }
+
+      return initialValue;
+    }
+
+    if (initialValue !== undefined) {
+      return this.buffer.subarray(0, this.length).reduce(callbackfn, initialValue);
+    }
+    return this.buffer.subarray(0, this.length).reduce(callbackfn);
+  }
+
+  /**
+   * Calls the specified callback function for all the bytes in the buffer, in descending order.
+   * The return value of the callback function is the accumulated result, and is provided as an
+   * argument in the next call to the callback function.
+   *
+   * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
+   * the callbackfn function one time for each byte in the buffer.
+   * @param initialValue If initialValue is specified, it is used as the initial value to start
+   * the accumulation. The first call to the callbackfn function provides this value as an
+   * argument instead of a byte value.
+   */
+  reduceRight(
+    callbackfn: (
+      previousValue: number,
+      currentValue: number,
+      currentIndex: number,
+      array: Uint8Array,
+    ) => number,
+  ): number;
+
+  reduceRight(
+    callbackfn: (
+      previousValue: number,
+      currentValue: number,
+      currentIndex: number,
+      array: Uint8Array,
+    ) => number,
+    initialValue: number,
+  ): number;
+
+  reduceRight<T>(
+    callbackfn: (
+      previousValue: T,
+      currentValue: number,
+      currentIndex: number,
+      array: Uint8Array,
+    ) => T,
+    initialValue: T,
+  ): T;
+
+  reduceRight(
+    callbackfn: (
+      previousValue: any,
+      currentValue: number,
+      currentIndex: number,
+      array: Uint8Array,
+    ) => any,
+    initialValue?: any,
+  ): any {
+    if (!this.buffer || this.length <= 0) {
+      if (initialValue === undefined) {
+        throw new TypeError('ReduceRight of empty buffer with no initial value');
+      }
+
+      return initialValue;
+    }
+
+    if (initialValue !== undefined) {
+      return this.buffer.subarray(0, this.length).reduceRight(callbackfn, initialValue);
+    }
+    return this.buffer.subarray(0, this.length).reduceRight(callbackfn);
+  }
+
   /**
    * Reverses the buffer in place and returns the reference to the buffer. The first byte in the
    * buffer now becoming the last, and the last byte in the buffer becoming the first.

test/array.spec.ts

@@ -122,6 +122,106 @@ describe('Map tests', () => {
   });
 });
 
+describe('Reduce tests', () => {
+  it('Reduce buffer', () => {
+    const buf = new DynamicBuffer('abc');
+
+    const ret = buf.reduce((prev, cur) => prev + (cur - 97));
+
+    assert.equal(ret, 100);
+  });
+
+  it('Reduce buffer with initial value', () => {
+    const buf = new DynamicBuffer('abc');
+
+    const ret = buf.reduce((prev, cur) => prev + (cur - 97), 0);
+
+    assert.equal(ret, 3);
+  });
+
+  it('Reduce buffer with other type', () => {
+    const buf = new DynamicBuffer('abc');
+
+    const ret = buf.reduce((prev, cur) => {
+      const obj: any = { ...prev };
+      obj[String.fromCharCode(cur)] = cur;
+      return obj;
+    }, {});
+
+    assert.deepEqual(ret, {
+      a: 97,
+      b: 98,
+      c: 99,
+    });
+  });
+
+  it('Reduce empty buffer without initial value', () => {
+    const buf = new DynamicBuffer();
+
+    assert.throws(() => {
+      buf.reduce((prev, cur) => prev + (cur - 97));
+    });
+  });
+
+  it('Reduce empty buffer with initial value', () => {
+    const buf = new DynamicBuffer();
+
+    const ret = buf.reduce((prev, cur) => prev + (cur - 97), 0);
+
+    assert.equal(ret, 0);
+  });
+});
+
+describe('ReduceRight tests', () => {
+  it('ReduceRight buffer', () => {
+    const buf = new DynamicBuffer('abc');
+
+    const ret = buf.reduceRight((prev, cur) => prev + (cur - 97));
+
+    assert.equal(ret, 100);
+  });
+
+  it('ReduceRight buffer with initial value', () => {
+    const buf = new DynamicBuffer('abc');
+
+    const ret = buf.reduceRight((prev, cur) => prev + (cur - 97), 0);
+
+    assert.equal(ret, 3);
+  });
+
+  it('ReduceRight buffer with other type', () => {
+    const buf = new DynamicBuffer('abc');
+
+    const ret = buf.reduceRight((prev, cur) => {
+      const obj: any = { ...prev };
+      obj[String.fromCharCode(cur)] = cur;
+      return obj;
+    }, {});
+
+    assert.deepEqual(ret, {
+      a: 97,
+      b: 98,
+      c: 99,
+    });
+  });
+
+  it('ReduceRight empty buffer without initial value', () => {
+    const buf = new DynamicBuffer();
+
+    assert.throws(() => {
+      buf.reduceRight((prev, cur) => prev + (cur - 97));
+    });
+  });
+
+  it('ReduceRight empty buffer with initial value', () => {
+    const buf = new DynamicBuffer();
+
+    const ret = buf.reduceRight((prev, cur) => prev + (cur - 97), 0);
+
+    assert.equal(ret, 0);
+  });
+});
+
 describe('Reverse tests', () => {
   it('Reverse buffer', () => {
     const buf = new DynamicBuffer('hello');