You want arr[-1] to return the last element by wrapping a JavaScript array in a Proxy. What must the get handler do with the property key it receives, and what must it still forward?

## Why the key is a string In JavaScript, ordinary property keys are strings or symbols — there is no integer key type. Array indices are simply string keys that happen to look like canonical numbers, and the bracket form converts whatever you put inside to a property key first. So `arr[-1]` reads the property named `"-1"`, and `arr[0]` reads `"0"`. On a real array `"-1"` is not an index at all; it is just an ordinary property that nobody set, which is why plain `arr[-1]` is `undefined` rather than the last element. A `get` trap therefore receives `"-1"` as its `key` argument. Comparing `key < 0` happens to work through coercion, but `typeof key === 'number'` never does, and `key === -1` is always false. Convert explicitly. ## A correct implementation ```js function withNegativeIndices(array) { return new Proxy(array, { get(target, key, receiver) { if (typeof key === 'string') { const n = Number(key); if (Number.isInteger(n) && n < 0) { return target[target.length + n]; } } return Reflect.get(target, key, receiver); }, set(target, key, value, receiver) { if (typeof key === 'string') { const n = Number(key); if (Number.isInteger(n) && n < 0) { target[target.length + n] = value; return true; } } return Reflect.set(target, key, value, receiver); } }); } const xs = withNegativeIndices(['a', 'b', 'c']); xs[-1]; // 'c' xs[0]; // 'a' xs.length; // 3 [...xs]; // ['a','b','c'] ``` Four details matter here. **Guard on `typeof key === 'string'` first.** Symbols must never reach `Number()`, and `Symbol.iterator` is read on every spread and `for...of`. Coercing a symbol throws a `TypeError`, so a trap that skips the guard breaks iteration in a way that looks unrelated to the code you wrote. **Use `Number.isInteger`, not `parseInt`.** `parseInt('-1abc')` is `-1`, which would map a nonsense key onto a real element. `Number('-1abc')` is `NaN` and `Number.isInteger` rejects it, which is the behaviour you want. **Forward everything else through `Reflect.get(target, key, receiver)`.** Hand-writing `return target[key]` mostly works for arrays, but forwarding via `Reflect` keeps the `receiver` argument correct for accessor properties, and it is the habit that keeps you out of trouble on non-array targets. **Decide what out-of-range means.** `xs[-10]` on a three-element array computes index `-7` and yields `undefined`. That is usually the right answer — it matches `at(-10)` — but if you would rather throw, this is the place. ## What this does not fix The proxy only affects bracket access on the proxy itself. `xs.slice(-1)` already worked, because `slice` interprets negative arguments itself. Methods that read indices internally do so on the target through their own `this`, so they never see negative keys either. And the returned proxy is not the array: `Array.isArray(xs)` is `true` (that check deliberately sees through proxies), but `xs !== array`, so a `Map` keyed by the original array will not find the proxy, and passing it to `structuredClone` or `postMessage` fails. ## The version-aware answer Since ES2022, `Array.prototype.at` does exactly this job: `array.at(-1)` is the last element, with no wrapper, no allocation and no per-access trap cost. `String.prototype.at` and typed arrays have it too. In an interview, implementing the proxy demonstrates that you understand property keys and traps; recommending `at()` demonstrates that you know when not to reach for a proxy. Say both. The proxy is only genuinely warranted when the bracket syntax itself is a requirement — for example when the value is handed to third-party code that indexes it directly and you cannot change the call sites.