From d81c363afe4f38de771721bba90c4d7fe8375c19 Mon Sep 17 00:00:00 2001 From: wanxiankai Date: Tue, 3 Nov 2026 08:35:52 +0800 Subject: [PATCH] fix(createMemo): support changing argument counts --- docs/createMemo.md | 16 ++++++ src/factory/createMemo.ts | 18 +++++-- tests/createMemo.test.ts | 106 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 137 insertions(+), 3 deletions(-) diff --git a/docs/createMemo.md b/docs/createMemo.md index 2b3f8c5da6..9dc82c3d78 100644 --- a/docs/createMemo.md +++ b/docs/createMemo.md @@ -3,6 +3,10 @@ Hook factory, receives a function to be memoized, returns a memoized React hook, which receives the same arguments and returns the same result as the original function. +Arguments are compared individually using `Object.is`. The result is recalculated +when an argument changes or the number of arguments changes. Each hook instance +keeps its own memoized result. + ## Usage @@ -28,6 +32,18 @@ const Demo = () => { }; ``` +Functions with optional or rest parameters can receive a different number of +arguments on each render: + +```jsx +const useMemoSum = createMemo((...values) => values.reduce((sum, value) => sum + value, 0)); + +const Demo = ({ values }) => { + const total = useMemoSum(...values); + return
{total}
; +}; +``` + ## Reference diff --git a/src/factory/createMemo.ts b/src/factory/createMemo.ts index 8fe16ee90a..e9ab8216f6 100644 --- a/src/factory/createMemo.ts +++ b/src/factory/createMemo.ts @@ -1,8 +1,20 @@ -import { useMemo } from 'react'; +import { useMemo, useRef } from 'react'; const createMemo = any>(fn: T) => - (...args: Parameters) => - useMemo>(() => fn(...args), args); + (...args: Parameters) => { + const argsRef = useRef(args); + + if ( + args.length !== argsRef.current.length || + args.some((argument, index) => !Object.is(argument, argsRef.current[index])) + ) { + argsRef.current = args; + } + + const memoizedArgs = argsRef.current; + + return useMemo>(() => fn(...memoizedArgs), [memoizedArgs]); + }; export default createMemo; diff --git a/tests/createMemo.test.ts b/tests/createMemo.test.ts index 0cf4e0d130..790edda52d 100644 --- a/tests/createMemo.test.ts +++ b/tests/createMemo.test.ts @@ -46,3 +46,109 @@ describe('when using created memo hook', () => { expect(getDouble).toHaveBeenCalled(); }); }); + +describe('when the number of arguments changes', () => { + let consoleError: jest.SpyInstance; + + beforeEach(() => { + consoleError = jest.spyOn(console, 'error').mockImplementation(() => {}); + }); + + afterEach(() => { + consoleError.mockRestore(); + }); + + it.each<{ initialArgs: Array; nextArgs: Array }>([ + { initialArgs: [], nextArgs: [1] }, + { initialArgs: [1], nextArgs: [] }, + { initialArgs: [1], nextArgs: [1, 2] }, + { initialArgs: [1, 2], nextArgs: [1] }, + { initialArgs: [], nextArgs: [undefined] }, + { initialArgs: [undefined], nextArgs: [] }, + ])('should recalculate when argument count changes (%j)', ({ initialArgs, nextArgs }) => { + const collect = jest.fn((...args: Array) => args); + const useCollect = createMemo(collect); + const { result, rerender } = renderHook(({ args }) => useCollect(...args), { + initialProps: { args: initialArgs }, + }); + + expect(result.current).toEqual(initialArgs); + + rerender({ args: nextArgs }); + + expect(result.current).toEqual(nextArgs); + expect(collect).toHaveBeenCalledTimes(2); + expect(consoleError).not.toHaveBeenCalled(); + + const previousResult = result.current; + rerender({ args: [...nextArgs] }); + + expect(result.current).toBe(previousResult); + expect(collect).toHaveBeenCalledTimes(2); + }); +}); + +it('should memoize a call without arguments', () => { + const fn = jest.fn(() => ({})); + const useMemoFn = createMemo(fn); + const { result, rerender } = renderHook(() => useMemoFn()); + const initialResult = result.current; + + rerender(); + + expect(result.current).toBe(initialResult); + expect(fn).toHaveBeenCalledTimes(1); +}); + +it('should compare arguments with Object.is semantics', () => { + const fn = jest.fn((value: number) => ({ value })); + const useMemoFn = createMemo(fn); + const { result, rerender } = renderHook(({ value }) => useMemoFn(value), { + initialProps: { value: NaN }, + }); + const initialResult = result.current; + + rerender({ value: NaN }); + + expect(result.current).toBe(initialResult); + expect(fn).toHaveBeenCalledTimes(1); + + rerender({ value: 0 }); + expect(result.current.value).toBe(0); + + rerender({ value: -0 }); + expect(result.current.value).toBe(-0); + expect(fn).toHaveBeenCalledTimes(3); +}); + +it('should compare object arguments by identity', () => { + const fn = jest.fn((value: object) => ({ value })); + const useMemoFn = createMemo(fn); + const value = {}; + const { result, rerender } = renderHook(({ argument }) => useMemoFn(argument), { + initialProps: { argument: value }, + }); + const initialResult = result.current; + + rerender({ argument: value }); + expect(result.current).toBe(initialResult); + expect(fn).toHaveBeenCalledTimes(1); + + const nextValue = {}; + rerender({ argument: nextValue }); + expect(result.current.value).toBe(nextValue); + expect(fn).toHaveBeenCalledTimes(2); +}); + +it('should memoize each hook instance separately', () => { + const fn = jest.fn((value: number) => ({ value })); + const useMemoFn = createMemo(fn); + const { result, rerender } = renderHook(() => [useMemoFn(1), useMemoFn(2)]); + const initialResults = result.current; + + rerender(); + + expect(result.current[0]).toBe(initialResults[0]); + expect(result.current[1]).toBe(initialResults[1]); + expect(fn).toHaveBeenCalledTimes(2); +});