TS 类型声明

[ChelesteWang]

https://juejin.cn/post/6844904034621456398#heading-9

[ChelesteWang]

hook结合typescript可以说是很香了。本文主要介绍hook结合typescript 如何使用，享受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