[JavaScript知识库]HOOKS + TS

useState

useState如果初始值不是null/undefined的话，是具备类型推导能力的，根据传入的初始值推断出类型；初始值是 null/undefined的话则需要传递类型定义才能进行约束。一般情况下，还是推荐传入类型（通过useState的第一个泛型参数）。

// 这里ts可以推断 value的类型并且能对setValue函数调用进行约束
const [value, setValue] = useState(0);

interface MyObject {
  foo: string;
  bar?: number;
}

// 这里需要传递MyObject才能约束 value, setValue
// 一般情况下推荐传入类型
const [value, setValue] = useState<MyObject>(null);

useContext

useContext一般根据传入的Context的值就可以推断出返回值。不需要显示传递类型

type Theme = 'light' | 'dark';
// 我们在createContext就传了类型了
const ThemeContext = createContext<Theme>('dark');

const App = () => (
  <ThemeContext.Provider value="dark">
    <MyComponent />
  </ThemeContext.Provider>
)

const MyComponent = () => {
    // useContext根据ThemeContext推断出类型，这里不需要显示传
  const theme = useContext(ThemeContext);
  return <div>The theme is {theme}</div>;

useEffect useLayoutEffect
没有返回值，无需传递类型
useCallback useMemo

useMemo无需传递类型，根据函数的返回值就能推断出类型

useCallback无需传递类型，根据函数的返回值就能推断出类型。但是注意函数的入参需要定义类型，不然就是推断为any了！

const value = 10;
// 推断出result是number类型
const result = useMemo(() => value * 2, [value]);
const multiplier = 2;
// 推断出 (value: number) => number
// 注意函数入参value需要定义类型
const multiply = useCallback((value: number) => value * multiplier, [multiplier]);

useRef

useRef传非空初始值的时候可以推断类型，同样也可以通过传入第一个泛型参数来定义类型，约束ref.current的类型。

const MyInput = () => {
  // 这里约束inputRef是一个html元素
  const inputRef = useRef<HTMLInputElement>(null);
  return <input ref={inputRef} />
}

// 自动推断出 myNumberRef.current 是number类型
const myNumberRef = useRef(0);
myNumberRef.current += 1;

useReducer

只需要对传入useReducer的reducer函数的入参state和action进行类型约束就能够推断出来

interface State {
  value: number;
}

type Action =
  | { type: 'increment' }
  | { type: 'decrement' }
  | { type: 'incrementAmount'; amount: number };

const counterReducer = (state: State, action: Action) => {
  switch (action.type) {
    case 'increment':
      return { value: state.value + 1 };
    case 'decrement':
      return { value: state.value - 1 };
    case 'incrementAmount':
      return { value: state.value + action.amount };
    default:
      throw new Error();
  }
};

// 这里可以推断出state为State类型
const [state, dispatch] = useReducer(counterReducer, { value: 0 });

//能够约束传入dispatch的参数，符合Action类型
dispatch({ type: 'increment' });
dispatch({ type: 'decrement' });
dispatch({ type: 'incrementAmount', amount: 10 });

// TypeScript compilation error
dispatch({ type: 'invalidActionType' });

useImperativeHandle

useImperativeHandle一般比较少用，一般用来选择函数组件对外暴露ref属性被调用，需要配合forwardRef使用。

如下例子。需要定义对外暴露的接口MyInputHandles，函数组件使用React.RefForwardingComponent对外暴露的接口调用作为泛型参数。然后就会得到约束了

// MyInputHandles 需要给父组件的useRef作为类型使用 和 RefForwardingComponent作为泛型参数传入约束
export interface MyInputHandles {
  focus(): void;
}

// 使用RefForwardingComponent 类型进行定义组件，第一个泛型参数是对外暴露的handle，第二个是Props
const MyInput: RefForwardingComponent<MyInputHandles, MyInputProps> = (
  props,
  ref
) => {
  const inputRef = useRef<HTMLInputElement>(null);

  useImperativeHandle(ref, () => ({
    // 这里的返回会自动使用MyInputHandles进行类型约束
    focus: () => {
      if (inputRef.current) {
        inputRef.current.focus();
      }
    },
  }));

  return <input {...props} ref={inputRef} />;
};

// 函数组件必须使用forwardRef才能让外部组件使用该组件的ref
export default forwardRef(MyInput);


// 父组件
const Autofocus = () => {
  // 能够约束 myInputRef.current的类型
  const myInputRef = useRef<MyInputHandles>(null);

  useEffect(() => {
    if (myInputRef.current) {
      myInputRef.current.focus();
    }
  });

  return <MyInput ref={myInputRef} />
}

参考：

React Hooks in TypeScript