Negative Array

A negative array lets you access array elements from the end of an array. It can use negative indices. It works by wrapping a standard array with a Proxy. This proxy intercepts requests. You access a negative index like myArray[-1]. The get logic converts the negative number to a positive index. It then returns the element at that place.

/**
 * Creates an array that can have negative indexes using a JavaScript Proxy.
 *
 * @example
 * 	```ts
 * 	  const array = new NegativeArray(1, 2, 3, 4, 5);
 * 	  console.log(array[-1]); // Output: 5
 * 	  array[-2] = 42;
 * 	  console.log(array[3]); // Output: 42
 * 	  console.log(array[10]); // Output: undefined
 * 	  ```;
 *
 * @param arrayToProxy - The array to be proxied.
 * @returns A proxied array allowing negative indexing.
 * @see A. Balane, "JavaScript array negative index using proxies," Medium,
 *   https://medium.com/uncaught-exception/javascript-array-negative-index-using-proxies-ed096dc84416
 */
export class NegativeArray<T> extends Array<T> {
  constructor(...items: T[]) {
    super(...items);

    // eslint-disable-next-line no-constructor-return
    return new Proxy(this, {
      get(target: T[], property: string | symbol, receiver: any): T | undefined {
        if (typeof property === "string" && !Number.isNaN(Number(property))) {
          let propertyValue = Number.parseInt(property, 10);
          if (propertyValue < 0) propertyValue += target.length;
          return target[propertyValue];
        }

        // Safe casting of the Reflect.get return value to expected type
        return Reflect.get(target, property, receiver) as T | undefined;
      },
      set(target: T[], property: string | symbol, value: T, receiver: any): boolean {
        if (typeof property === "string" && !Number.isNaN(Number(property))) {
          let propertyValue = Number.parseInt(property, 10);
          if (propertyValue < 0) propertyValue += target.length;
          target[propertyValue] = value; // Safe assignment of typed value
          return true;
        }

        return Reflect.set(target, property, value, receiver);
      }
    });
  }
}

import { expect, test } from "bun:test";
import { NegativeArray } from "./code";

test("testNegativeIndices", () => {
  const narr = new NegativeArray<number>(1, 2, 3, 4);
  expect(narr[-1]).toBe(4);
  expect(narr[-2]).toBe(3);
  expect(narr[-3]).toBe(2);
  expect(narr[-4]).toBe(1);
});

test("testNegativeOutOfRange", () => {
  const narr = new NegativeArray<number>(1, 2, 3, 4);
  expect(narr[-5]).toBeUndefined();
  expect(narr[-6]).toBeUndefined();
});

test("testSetNegative", () => {
  const narr = new NegativeArray<number>(1, 2, 3, 4);

  narr[-1] = 9;
  expect(narr[3]).toBe(9);

  narr[-4] = 0;
  expect(narr[0]).toBe(0);
});

test("testNominalArray", () => {
  const narr = new NegativeArray<number>(1, 2, 3, 4);

  expect(narr[0]).toBe(1);
  expect(narr[1]).toBe(2);
  expect(narr[2]).toBe(3);
  expect(narr[3]).toBe(4);

  narr[0] = 9;
  expect(narr[0]).toBe(9);
  narr[3] = 8;
  expect(narr[3]).toBe(8);
});

Naive String Matcher

Observer Pattern

Docs

computer-science.dev

Title here

Negative Array