--- id: 833 card_url: "https://mdrss.com/web-mobile/web-frontend/833" permalink_url: "https://mdrss.com/m/833" thread_url: "https://mdrss.com/s/web-mobile" markdown_url: "https://mdrss.com/web-mobile/web-frontend/833/833.md" title: "React TypeScript Cheatsheet" annotation: ":wave: This repo is maintained by @eps1lon and @filiptammergard. We're so happy you want to try out React with TypeScript!" state: published thread: web-mobile domain: web-mobile category: web-frontend type: guide tags: ["cheatsheet", "guide", "react", "typescript", "web"] ontology_terms: [] relation_terms: [] license: "MIT" version: 1 snapshot_at: "2026-08-04T12:19:55.037Z" source_url: "https://github.com/typescript-cheatsheets/react" source_kind: "mdrss-final-catalog" platform_scam_risk: null platform_evidence_score: 0 evidence_urls: - "https://github.com/typescript-cheatsheets/react" --- # React TypeScript Cheatsheet Cheatsheet for using React with TypeScript. --- react + ts logo [**Web docs**](https://react-typescript-cheatsheet.netlify.app/docs/basic/setup) | [Contribute!](https://github.com/typescript-cheatsheets/react/blob/main/CONTRIBUTING.md) | [Ask!](https://github.com/typescript-cheatsheets/react/issues/new/choose) :wave: This repo is maintained by [@eps1lon](https://twitter.com/sebsilbermann) and [@filiptammergard](https://twitter.com/tammergard). We're so happy you want to try out React with TypeScript! If you see anything wrong or missing, please [file an issue](https://github.com/typescript-cheatsheets/react/issues/new/choose)! :+1: --- [![All Contributors](https://img.shields.io/github/contributors/typescript-cheatsheets/react-typescript-cheatsheet?color=orange&style=flat-square)](/CONTRIBUTORS.md) | [![Discord](https://img.shields.io/discord/508357248330760243.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/wTGS5z9) [The Cheatsheet](https://react-typescript-cheatsheet.netlify.app/docs/basic/setup) is focused on helping React devs use TypeScript effectively: - Opinionated best practices and copy+pastable examples. - Covers basic TS types and setup, plus advanced usage of generic types for people writing reusable type utilities and React+TS **libraries**. - Advice for contributing to DefinitelyTyped. --- ## Cheatsheet ### Table of Contents
Expand Table of Contents - [React TypeScript Cheatsheet](#react-typescript-cheatsheet) - [Cheatsheet](#cheatsheet) - [Table of Contents](#table-of-contents) - [Setup](#setup) - [Prerequisites](#prerequisites) - [React and TypeScript starter kits](#react-and-typescript-starter-kits) - [Try React and TypeScript online](#try-react-and-typescript-online) - [Getting Started](#getting-started) - [Function Components](#function-components) - [Hooks](#hooks) - [useState](#usestate) - [useCallback](#usecallback) - [useReducer](#usereducer) - [useEffect / useLayoutEffect](#useeffect--uselayouteffect) - [useRef](#useref) - [Option 1: DOM element ref](#option-1-dom-element-ref) - [Option 2: Mutable value ref](#option-2-mutable-value-ref) - [See also](#see-also) - [useImperativeHandle](#useimperativehandle) - [See also:](#see-also-1) - [Custom Hooks](#custom-hooks) - [More Hooks + TypeScript reading:](#more-hooks--typescript-reading) - [Example React Hooks + TypeScript Libraries:](#example-react-hooks--typescript-libraries) - [Class Components](#class-components) - [Typing getDerivedStateFromProps](#typing-getderivedstatefromprops) - [You May Not Need `defaultProps`](#you-may-not-need-defaultprops) - [Typing `defaultProps`](#typing-defaultprops) - [Consuming Props of a Component with defaultProps](#consuming-props-of-a-component-with-defaultprops) - [Problem Statement](#problem-statement) - [Solution](#solution) - [Misc Discussions and Knowledge](#misc-discussions-and-knowledge) - [Typing Component Props](#typing-component-props) - [Basic Prop Types Examples](#basic-prop-types-examples) - [`object` as the non-primitive type](#object-as-the-non-primitive-type) - [Empty interface, `{}` and `Object`](#empty-interface--and-object) - [Useful React Prop Type Examples](#useful-react-prop-type-examples) - [Types or Interfaces?](#types-or-interfaces) - [TL;DR](#tldr) - [More Advice](#more-advice) - [Useful table for Types vs Interfaces](#useful-table-for-types-vs-interfaces) - [getDerivedStateFromProps](#getderivedstatefromprops) - [Forms and Events](#forms-and-events) - [List of event types](#list-of-event-types) - [Context](#context) - [Basic example](#basic-example) - [Without default context value](#without-default-context-value) - [Type assertion as an alternative](#type-assertion-as-an-alternative) - [forwardRef/createRef](#forwardrefcreateref) - [Generic forwardRefs](#generic-forwardrefs) - [Option 1 - Wrapper component](#option-1---wrapper-component) - [Option 2 - Redeclare forwardRef](#option-2---redeclare-forwardref) - [Option 3 - Call signature](#option-3---call-signature) - [More Info](#more-info) - [Portals](#portals) - [Error Boundaries](#error-boundaries) - [Option 1: Using react-error-boundary](#option-1-using-react-error-boundary) - [Option 2: Writing your custom error boundary component](#option-2-writing-your-custom-error-boundary-component) - [Concurrent React/React Suspense](#concurrent-reactreact-suspense) - [My question isn't answered here!](#my-question-isnt-answered-here) - [Contributors](#contributors)
### Introduction #### Prerequisites You can use this cheatsheet for reference at any skill level, but basic understanding of React and TypeScript is assumed. Here is a list of prerequisites: - Basic understanding of [React](https://react.dev/). - Familiarity with [TypeScript Basics](https://www.typescriptlang.org/docs/handbook/2/basic-types.html) and [Everyday Types](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html). In the cheatsheet we assume you are using the latest versions of React and TypeScript. #### React and TypeScript starter kits React has documentation for [how to start a new React project](https://react.dev/learn/start-a-new-react-project) with some of the most popular frameworks. Here's how to start them with TypeScript: - [Next.js](https://nextjs.org/docs/basic-features/typescript): `npx create-next-app@latest --ts` - [Remix](https://remix.run/docs/tutorials/blog): `npx create-remix@latest` - [Gatsby](https://www.gatsbyjs.com/docs/how-to/custom-configuration/typescript/): `npm init gatsby --ts` - [Expo](https://docs.expo.dev/guides/typescript/): `npx create-expo-app -t with-typescript` If you just want a client-side single-page app without a framework, [Vite](https://vitejs.dev/) is the most common choice: - [Vite](https://vitejs.dev/guide/): `npm create vite@latest my-app -- --template react-ts` #### Try React and TypeScript online There are some tools that let you run React and TypeScript online, which can be helpful for debugging or making sharable reproductions. - [TypeScript playground](https://www.typescriptlang.org/play?target=8&jsx=4#code/JYWwDg9gTgLgBAbzgVwM4FMDKMCGN0A0KGAogGZnoDG8AvnGVBCHAORTo42sDcAsAChB6AB6RYcKhAB2qeAGEIyafihwAvHAAUASg0A+RILiSZcuAG0pymEQwxFNgLobiWXPi0AGHfyECTNHRyShotXQMjAJM4ABMIKmQQdBUAOhhgGAAbdFcAAwBNJUks4CoAa3RYuAASBGsVegzk1Dy-E1pfQWM4DhhkKGltHpMAHn0RmNGwfSLkErLK6vqlRrhm9FRRgHoZybGAI2QYGBk4GXlSivUECPVDe0cVLQb4AGo4AEYdWgnomJil0WcGS+zgOyOJxkfwBOxhcC6AlogiAA) - [StackBlitz](https://stackblitz.com/fork/react-ts) - [CodeSandbox](https://ts.react.new/) ### Getting Started #### Function Components These can be written as normal functions that take a `props` argument and return a JSX element. ```tsx // Declaring type of props - see "Typing Component Props" for more examples type AppProps = { message: string; }; /* use `interface` if exporting so that consumers can extend */ // Easiest way to declare a Function Component; return type is inferred. const App = ({ message }: AppProps) =>
{message}
; // You can choose to annotate the return type so an error is raised if you accidentally return some other type const App = ({ message }: AppProps): React.JSX.Element =>
{message}
; // You can also inline the type declaration; eliminates naming the prop types, but looks repetitive const App = ({ message }: { message: string }) =>
{message}
; // Alternatively, you can use `React.FunctionComponent` (or `React.FC`), if you prefer. // With latest React types and TypeScript 5.1. it's mostly a stylistic choice, otherwise discouraged. const App: React.FunctionComponent<{ message: string }> = ({ message }) => (
{message}
); // or const App: React.FC = ({ message }) =>
{message}
; ``` > Tip: You might use [Paul Shen's VS Code Extension](https://marketplace.visualstudio.com/items?itemName=paulshen.paul-typescript-toolkit) to automate the type destructure declaration (incl a [keyboard shortcut](https://twitter.com/_paulshen/status/1392915279466745857?s=20)).
Why is React.FC not needed? What about React.FunctionComponent/React.VoidFunctionComponent? You may see this in many React+TypeScript codebases: ```tsx const App: React.FunctionComponent<{ message: string }> = ({ message }) => (
{message}
); ``` However, the general consensus today is that `React.FunctionComponent` (or the shorthand `React.FC`) is not needed. If you're still using React 17 or TypeScript lower than 5.1, it is even [discouraged](https://github.com/facebook/create-react-app/pull/8177). This is a nuanced opinion of course, but if you agree and want to remove `React.FC` from your codebase, you can use [this jscodeshift codemod](https://github.com/gndelia/codemod-replace-react-fc-typescript). Some differences from the "normal function" version: - `React.FunctionComponent` is explicit about the return type, while the normal function version is implicit (or else needs additional annotation). - It provides typechecking and autocomplete for static properties like `displayName`, `propTypes`, and `defaultProps`. - Note that there are some known issues using `defaultProps` with `React.FunctionComponent`. See [this issue for details](https://github.com/typescript-cheatsheets/react/issues/87). We maintain a separate `defaultProps` section you can also look up. - _In the future_, it may automatically mark props as `readonly`, though that's a moot point if the props object is destructured in the parameter list. In most cases it makes very little difference which syntax is used, but you may prefer the more explicit nature of `React.FunctionComponent`.
#### Hooks Hooks are [supported in `@types/react` from v16.8 up](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/a05cc538a42243c632f054e42eab483ebf1560ab/types/react/index.d.ts#L800-L1031). #### useState Type inference works very well for simple values: ```tsx const [state, setState] = useState(false); // `state` is inferred to be a boolean // `setState` only takes booleans ``` If you need to use a complex type that you've relied on inference for, you can use `typeof` to capture the inferred type. However, many hooks are initialized with null-ish default values, and you may wonder how to provide types. Explicitly declare the type, and use a union type: ```tsx const [user, setUser] = useState(null); // later... setUser(newUser); ``` You can also use type assertions if a state is initialized soon after setup and always has a value after: ```tsx const [user, setUser] = useState({} as User); // later... setUser(newUser); ``` This temporarily "lies" to the TypeScript compiler that `{}` is of type `User`. You should follow up by setting the `user` state — if you don't, the rest of your code may rely on the fact that `user` is of type `User` and that may lead to runtime errors. #### useCallback You can type the `useCallback` just like any other function. ```ts const memoizedCallback = useCallback( (param1: string, param2: number) => { console.log(param1, param2) return { ok: true } }, [...], ); /** * VSCode will show the following type: * const memoizedCallback: * (param1: string, param2: number) => { ok: boolean } */ ``` Note that for React < 18, the function signature of `useCallback` typed arguments as `any[]` by default: ```ts function useCallback any>( callback: T, deps: DependencyList, ): T; ``` In React >= 18, the function signature of `useCallback` changed to the following: ```ts function useCallback(callback: T, deps: DependencyList): T; ``` Therefore, the following code will yield "`Parameter 'e' implicitly has an 'any' type.`" error in React >= 18, but not <17. ```ts // @ts-expect-error Parameter 'e' implicitly has 'any' type. useCallback((e) => {}, []); // Explicit 'any' type. useCallback((e: any) => {}, []); ``` #### useReducer You can use [Discriminated Unions](https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes-func.html#discriminated-unions) for reducer actions. Don't forget to define the return type of reducer, otherwise TypeScript will infer it. ```tsx import { useReducer } from "react"; const initialState = { count: 0 }; type ACTIONTYPE = | { type: "increment"; payload: number } | { type: "decrement"; payload: string }; function reducer( state: typeof initialState, action: ACTIONTYPE, ): typeof initialState { switch (action.type) { case "increment": return { count: state.count + action.payload }; case "decrement": return { count: state.count - Number(action.payload) }; default: throw new Error(); } } function Counter() { const [state, dispatch] = useReducer(reducer, initialState); return ( <> Count: {state.count} ); } ``` [View in the TypeScript Playground](https://www.typescriptlang.org/play?#code/LAKFEsFsAcHsCcAuACAVMghgZ2QJQKYYDGKAZvLJMgOTyEnUDcooRsAdliuO+IuBgA2AZUQZE+ZAF5kAbzYBXdogBcyAAwBfZmBCIAntEkBBAMIAVAJIB5AHLmAmgAUAotOShkyAD5zkBozVqHiI6SHxlagAaZGgMfUFYDAATNXYFSAAjfHhNDxAvX1l-Q3wg5PxQ-HDImLiEpNTkLngeAHM8ll1SJRJwDmQ6ZIUiHIAKLnEykqNYUmQePgERMQkY4n4ONTMrO0dXAEo5T2aAdz4iAAtkMY3+9gA6APwj2ROvImxJYPYqmsRqCp3l5BvhEAp4Ow5IplGpJhIHjCUABqTB9DgPeqJFLaYGfLDfCp-CIAoEFEFeOjgyHQ2BKVTNVb4RF05TIAC0yFsGWy8Fu6MeWMaB1x5K8FVIGAUglUwK8iEuFFOyHY+GVLngFD5Bx0Xk0oH13V6myhplZEm1x3JbE4KAA2vD8DFkuAsHFEFcALruAgbB4KAkEYajPlDEY5GKLfhCURTHUnKkQqFjYEAHgAfHLkGb6WpZI6WfTDRSvKnMgpEIgBhxTIJwEQANZSWRjI5SdPIF1u8RXMayZ7lSphEnRWLxbFNagAVmomhF6fZqYA9OXKxxM2KQWWK1WoTW643m63pB2u+7e-3SkEQsPamOGik1FO55p08jl6vdxuKcvv8h4yAmhAA)
Usage with Reducer from redux In case you use the [redux](https://github.com/reduxjs/redux) library to write reducer function, It provides a convenient helper of the format `Reducer` which takes care of the return type for you. So the above reducer example becomes: ```tsx import { Reducer } from 'redux'; export function reducer: Reducer() {} ```
Providing explicit types for useReducer In most cases, type inference for useReducer should work reliably. When inference fails, the state and action types can be explicitly provided using the following syntax, where the action type is wrapped in a single-element tuple. ```tsx const [state, dispatch] = useReducer( reducer, initialState, ); ```
#### useEffect / useLayoutEffect Both of `useEffect` and `useLayoutEffect` are used for performing side effects and return an optional cleanup function which means if they don't deal with returning values, no types are necessary. When using `useEffect`, take care not to return anything other than a function or `undefined`, otherwise both TypeScript and React will yell at you. This can be subtle when using arrow functions: ```ts function DelayedEffect(props: { timerMs: number }) { const { timerMs } = props; useEffect( () => setTimeout(() => { /* do stuff */ }, timerMs), [timerMs], ); // bad example! setTimeout implicitly returns a number // because the arrow function body isn't wrapped in curly braces return null; } ```
Solution to the above example ```tsx function DelayedEffect(props: { timerMs: number }) { const { timerMs } = props; useEffect(() => { setTimeout(() => { /* do stuff */ }, timerMs); }, [timerMs]); // better; use the void keyword to make sure you return undefined return null; } ```
#### useRef `useRef` always returns a `RefObject` in current `@types/react`. An initial value is required, and the returned `.current` is typed based on it. (`MutableRefObject` is deprecated and only kept for backwards compatibility.) ##### Option 1: DOM element ref **To access a DOM element:** provide the element type as a generic and pass `null` as the initial value. React manages `.current` for you, and TypeScript expects you to pass this ref to an element's `ref` prop: ```tsx function Foo() { // - If possible, prefer as specific as possible. For example, HTMLDivElement // is better than HTMLElement and way better than Element. // - Technical-wise, this returns RefObject const divRef = useRef(null); useEffect(() => { // Note that ref.current may be null. This is expected, because you may // conditionally render the ref-ed element, or you may forget to assign it if (!divRef.current) throw Error("divRef is not assigned"); // Now divRef.current is sure to be HTMLDivElement doSomethingWith(divRef.current); }); // Give the ref to an element so React can manage it for you return
etc
; } ``` If you are sure that `divRef.current` will never be null, it is also possible to use the non-null assertion operator `!`: ```tsx const divRef = useRef(null!); // Later... No need to check if it is null doSomethingWith(divRef.current); ``` Note that you are opting out of type safety here - you will have a runtime error if you forget to assign the ref to an element in the render, or if the ref-ed element is conditionally rendered.
Tip: Choosing which HTMLElement to use Refs demand specificity - it is not enough to just specify any old `HTMLElement`. If you don't know the name of the element type you need, you can check [lib.dom.ts](https://github.com/microsoft/TypeScript/blob/v3.9.5/lib/lib.dom.d.ts#L19224-L19343) or make an intentional type error and let the language service tell you: ![image](https://user-images.githubusercontent.com/6764957/116914284-1c436380-ac7d-11eb-9150-f52c571c5f07.png)
##### Option 2: Mutable value ref **To hold a mutable value across renders without re-rendering on change:** pass the initial value you want — React doesn't manage `.current` for you here, you write to it manually. ```tsx function Foo() { const intervalRef = useRef(null); useEffect(() => { intervalRef.current = window.setInterval(() => { /* ... */ }, 1000); return () => { if (intervalRef.current !== null) clearInterval(intervalRef.current); }; }, []); return ( ); } ``` ##### See also - [Related issue by @rajivpunjabi](https://github.com/typescript-cheatsheets/react/issues/388) - [Playground](https://www.typescriptlang.org/play#code/JYWwDg9gTgLgBAKjgQwM5wEoFNkGN4BmUEIcARFDvmQNwCwAUI7hAHarwCCYYcAvHAAUASn4A+OAG9GjOHAD0CBLLnKGcxHABiwKBzgQwMYGxS4WUACbBWAczgwIcSxFwBXEFlYxkxtgDoVTQBJVmBjZAAbOAA3KLcsOAB3YEjogCNE1jc0-zgAGQBPG3tHOAAVQrAsAGVcKGAjOHTCuDdUErhWNgBabLSUVFQsWBNWA2qoX2hA9VU4AGFKXyx0AFk3H3TIxOwCOAB5dIArLHwgpHcoSm84MGJJmFbgdG74ZcsDVkjC2Y01f7yFQsdjvLAEACM-EwVBg-naWD2AB4ABLlNb5GpgZCsACiO083jEgn6kQAhMJ6HMQfpKJCFpE2IkBNg8HCEci0RisTj8VhCTBiaSKVSVIoAaoLnBQuFgFFYvFEikBpkujkMps4FgAB7VfCdLmY7F4gleOFwAByEHg7U63VYfXVg2Go1MhhG0ygf3mAHVUtF6jgYLtwUdTvguta4Bstjs9mGznCpVcbvB7u7YM90B8vj9vYgLkDqWxaeCAEzQ1n4eHDTnoo2801EknqykyObii5SmpnNifA5GMZmCzWOwOJwudwC3xjKUyiLROKRBLJf3NLJO9KanV64xj0koVifQ08k38s1Sv0DJZBxIx5DbRGhk6J5Nua5mu4PEZPOAvSNgsgnxsHmXZzIgRZyDSYIEAAzJWsI1k+BCovWp58gKcAAD5qmkQqtqKHbyCexoYRecw7IQugcAs76ptCdIQv4KZmoRcjyMRaGkU28A4aSKiUXAwwgpYtEfrcAh0mWzF0ax7bsZx3Lceetx8eqAlYPAMAABa6KJskSXAdKwTJ4kwGxCjyKy-bfK05SrDA8mWVagHAbZeScOY0CjqUE6uOgqDaRAOSfKqOYgb8KiMaZ9GSeCEIMkyMVyUwRHWYc7nSvAgUQEk6AjMQXpReWyWGdFLHeBZHEuTCQEZT8xVwaV8BxZCzUWZQMDvuMghBHASJVnCWhTLYApiH1chIqgxpGeCfCSIxAC+Yj3o+8YvvgSLyNNOLjeBGhTTNdLzVJy3reGMBbTtrB7RoB3XbNBAneCsHLatcbPhdV3GrdB1WYhw3IKNZq-W2DCLYRO7QPAljgsgORcDwVJAA) - [Example from Stefan Baumgartner](https://fettblog.eu/typescript-react/hooks/#useref) - [Playground](https://www.typescriptlang.org/play/?jsx=2#code/JYWwDg9gTgLgBAJQKYEMDG8BmUIjgIilQ3wFgAoCzAVwDsNgJa4AVJADxgElaxqYA6sBgALAGIQ01AM4AhfjCYAKAJRwA3hThwA9DrjBaw4CgA2waUjgB3YSLi1qp0wBo4AI35wYSZ6wCeYEgAymhQwGDw1lYoRHCmEBAA1oYA5nCY0HAozAASLACyADI8fDAAoqZIIEi0MFpwaEzS8IZllXAAvIjEMAB0MkjImAA8+cWl-JXVtTAAfEqOzioA3A1NtC1wTPIwirQAwuZoSV1wql1zGg3aenAt4RgOTqaNIkgn0g5ISAAmcDJvBA3h9TsBMAZeFNXjl-lIoEQ6nAOBZ+jddPpPPAmGgrPDEfAUS1pG5hAYvhAITBAlZxiUoRUqjU6m5RIDhOi7iIUF9RFYaqIIP9MlJpABCOCAUHJ0eDzm1oXAAGSKyHtUx9fGzNSacjaPWq6Ea6gI2Z9EUyVRrXV6gC+DRtVu0RBgxuYSnRIzm6O06h0ACpIdlfr9jExSQyOkxTP5GjkPFZBv9bKIDYSmbNpH04ABNFD+CV+nR2636kby+BETCddTlyo27w0zr4HycfC6L0lvUjLH7baHY5Jas7BRMI7AE42uYSUXed6pkY6HtMDulnQruCrCg2oA) #### useImperativeHandle In React 19, `ref` is a regular prop on function components, so `useImperativeHandle` is called with the `ref` prop directly — no `forwardRef` needed. ```tsx // Countdown.tsx import { useImperativeHandle, Ref } from "react"; export type CountdownHandle = { start: () => void; }; type CountdownProps = { ref?: Ref; }; const Countdown = ({ ref }: CountdownProps) => { useImperativeHandle(ref, () => ({ // start() has type inference here start() { alert("Start"); }, })); return
Countdown
; }; ``` ```tsx // The component using the Countdown component import { useEffect, useRef } from "react"; import Countdown, { CountdownHandle } from "./Countdown.tsx"; function App() { const countdownEl = useRef(null); useEffect(() => { if (countdownEl.current) { // start() has type inference here as well countdownEl.current.start(); } }, []); return ; } ``` > If you still maintain code that targets React < 19, see the [forwardRef section](https://github.com/typescript-cheatsheets/react/blob/HEAD/forward-create-ref.md) for the legacy approach using `forwardRef`. #### Custom Hooks If you are returning an array in your Custom Hook, you will want to avoid type inference as TypeScript will infer a union type (when you actually want different types in each position of the array). Instead, use [TS 3.4 const assertions](https://devblogs.microsoft.com/typescript/announcing-typescript-3-4/#const-assertions): ```tsx import { useState } from "react"; export function useLoading() { const [isLoading, setState] = useState(false); const load = (aPromise: Promise) => { setState(true); return aPromise.finally(() => setState(false)); }; return [isLoading, load] as const; // infers [boolean, typeof load] instead of (boolean | typeof load)[] } ``` [View in the TypeScript Playground](https://www.typescriptlang.org/play/?target=5&jsx=2#code/JYWwDg9gTgLgBAJQKYEMDG8BmUIjgcilQ3wFgAoCpAD0ljkwFcA7DYCZuRgZyQBkIKACbBmAcwAUASjgBvCnDhoO3eAG1g3AcNFiANHF4wAyjBQwkAXTgBeRMRgA6HklPmkEzCgA2vKQG4FJRV4b0EhWzgJFAAFHBBNJAAuODjcRIAeFGYATwA+GRs8uSDFIzcLCRgoRiQA0rgiGEYoTlj4xMdMUR9vHIlpW2Lys0qvXzr68kUAX0DpxqRm1rgNLXDdAzDhaxRuYOZVfzgAehO4UUwkKH21ACMICG9UZgMYHLAkCEw4baFrUSqVARb5RB5PF5wAA+cHen1BfykaksFBmQA) This way, when you destructure you actually get the right types based on destructure position.
Alternative: Asserting a tuple return type If you are [having trouble with const assertions](https://github.com/babel/babel/issues/9800), you can also assert or define the function return types: ```tsx import { useState } from "react"; export function useLoading() { const [isLoading, setState] = useState(false); const load = (aPromise: Promise) => { setState(true); return aPromise.finally(() => setState(false)); }; return [isLoading, load] as [ boolean, (aPromise: Promise) => Promise, ]; } ``` A helper function that automatically types tuples can also be helpful if you write a lot of custom hooks: ```tsx function tuplify(...elements: T) { return elements; } function useArray() { const numberValue = useRef(3).current; const functionValue = useRef(() => {}).current; return [numberValue, functionValue]; // type is (number | (() => void))[] } function useTuple() { const numberValue = useRef(3).current; const functionValue = useRef(() => {}).current; return tuplify(numberValue, functionValue); // type is [number, () => void] } ```
Note that the React team recommends that custom hooks that return more than two values should use proper objects instead of tuples, however. #### More Hooks + TypeScript reading: - https://medium.com/@jrwebdev/react-hooks-in-typescript-88fce7001d0d - https://fettblog.eu/typescript-react/hooks/#useref If you are writing a React Hooks library, don't forget that you should also expose your types for users to use. #### Example React Hooks + TypeScript Libraries: - https://github.com/mweststrate/use-st8 - https://github.com/palmerhq/the-platform - https://github.com/sw-yx/hooks #### Class Components Within TypeScript, `React.Component` is a generic type (aka `React.Component`), so you want to provide it with (optional) prop and state type parameters: ```tsx type MyProps = { // using `interface` is also ok message: string; }; type MyState = { count: number; // like this }; class App extends React.Component { state: MyState = { // optional second annotation for better type inference count: 0, }; render() { return (
{this.props.message} {this.state.count}
); } } ``` [View in the TypeScript Playground](https://www.typescriptlang.org/play/?jsx=2#code/JYWwDg9gTgLgBAJQKYEMDG8BmUIjgcilQ3wFgAoCmATzCTgFlqAFHMAZzgF44BvCuHAD0QuAFd2wAHYBzOAANpMJFEzok8uME4oANuwhwIAawFwQSduxQykALjjsYUaTIDcFAL4fyNOo2oAZRgUZW4+MzQIMSkYBykxEAAjFTdhUV1gY3oYAAttLx80XRQrOABBMDA4JAAPZSkAE05kdBgAOgBhXEgpJFiAHiZWCA4AGgDg0KQAPgjyQSdphyYpsJ5+BcF0ozAYYAgpPUckKKa4FCkpCBD9w7hMaDgUmGUoOD96aUwVfrQkMyCKIxOJwAAMZm8ZiITRUAAoAJTzbZwIgwMRQKRwOGA7YDRrAABuM1xKN4eW07TAbHY7QsVhsSE8fAptKWynawNinlJcAGQgJxNxCJ8gh55E8QA) Don't forget that you can export/import/extend these types/interfaces for reuse.
Why annotate state twice? It isn't strictly necessary to annotate the `state` class property, but it allows better type inference when accessing `this.state` and also initializing the state. This is because they work in two different ways, the 2nd generic type parameter will allow `this.setState()` to work correctly, because that method comes from the base class, but initializing `state` inside the component overrides the base implementation so you have to make sure that you tell the compiler that you're not actually doing anything different. [See commentary by @ferdaber here](https://github.com/typescript-cheatsheets/react/issues/57).
No need for readonly You often see sample code include `readonly` to mark props and state immutable: ```tsx type MyProps = { readonly message: string; }; type MyState = { readonly count: number; }; ``` This is not necessary as `React.Component` already marks them as immutable. ([See PR and discussion!](https://github.com/DefinitelyTyped/DefinitelyTyped/pull/26813))
**Class Methods**: Do it like normal, but just remember any arguments for your functions also need to be typed: ```tsx class App extends React.Component<{ message: string }, { count: number }> { state = { count: 0 }; render() { return (
this.increment(1)}> {this.props.message} {this.state.count}
); } increment = (amt: number) => { // like this this.setState((state) => ({ count: state.count + amt, })); }; } ``` [View in the TypeScript Playground](https://www.typescriptlang.org/play/?jsx=2#code/JYWwDg9gTgLgBAJQKYEMDG8BmUIjgcilQ3wFgAoCtAGxQGc64BBMMOJADxiQDsATRsnQwAdAGFckHrxgAeAN5wQSBigDmSAFxw6MKMB5q4AXwA0cRWggBXHjG09rIAEZIoJgHwWKcHTBTccAC8FnBWtvZwAAwmANw+cET8bgAUAJTe5L6+RDDWUDxwKQnZcLJ8wABucBA8YtTAaADWQfLpwV4wABbAdCIGaETKdikAjGnGHiWlFt29ImA4YH3KqhrGsz19ugFIIuF2xtO+sgD0FZVTWdlp8ddH1wNDMsFFKCCRji5uGUFe8tNTqc4A0mkg4HM6NNISI6EgYABlfzcFI7QJ-IoA66lA6RNF7XFwADUcHeMGmxjStwSxjuxiAA) **Class Properties**: If you need to declare class properties for later use, define them directly within the class `body` without an initial assignment: ```tsx class App extends React.Component<{ message: string; }> { pointer: number; // like this componentDidMount() { this.pointer = 3; } render() { return (
{this.props.message} and {this.pointer}
); } } ``` [View in the TypeScript Playground](https://www.typescriptlang.org/play/?jsx=2#code/JYWwDg9gTgLgBAJQKYEMDG8BmUIjgcilQ3wFgAoCtAGxQGc64BBMMOJADxiQDsATRsnQwAdAGFckHrxgAeAN4U4cEEgYoA5kgBccOjCjAeGgNwUAvgD44i8sshHuUXTwCuIAEZIoJuAHo-OGpgAGskOBgAC2A6JTg0SQhpHhgAEWA+AFkIVxSACgBKGzjlKJiRBxTvOABeOABmMzs4cziifm9C4ublIhhXKB44PJLlOFk+YAA3S1GxmzK6CpwwJdV1LXM4FH4F6KXKp1aesdk-SZnRgqblY-MgA) #### Typing getDerivedStateFromProps Before you start using `getDerivedStateFromProps`, please go through the [documentation](https://reactjs.org/docs/react-component.html#static-getderivedstatefromprops) and [You Probably Don't Need Derived State](https://reactjs.org/blog/2018/06/07/you-probably-dont-need-derived-state.html). Derived State can be implemented using hooks which can also help set up memoization. Here are a few ways in which you can annotate `getDerivedStateFromProps` 1. If you have explicitly typed your derived state and want to make sure that the return value from `getDerivedStateFromProps` conforms to it. ```tsx class Comp extends React.Component { static getDerivedStateFromProps( props: Props, state: State, ): Partial | null { // } } ``` 2. When you want the function's return value to determine your state. ```tsx class Comp extends React.Component< Props, ReturnType<(typeof Comp)["getDerivedStateFromProps"]> > { static getDerivedStateFromProps(props: Props) {} } ``` 3. When you want derived state with other state fields and memoization ```tsx type CustomValue = any; interface Props { propA: CustomValue; } interface DefinedState { otherStateField: string; } type State = DefinedState & ReturnType; function transformPropsToState(props: Props) { return { savedPropA: props.propA, // save for memoization derivedState: props.propA, }; } class Comp extends React.PureComponent { constructor(props: Props) { super(props); this.state = { otherStateField: "123", ...transformPropsToState(props), }; } static getDerivedStateFromProps(props: Props, state: State) { if (isEqual(props.propA, state.savedPropA)) return null; return transformPropsToState(props); } } ``` [View in the TypeScript Playground](https://www.typescriptlang.org/play/?jsx=2#code/JYWwDg9gTgLgBAJQKYEMDG8BmUIjgcilQ3wFgAoUSWOYAZwFEBHAVxQBs5tcD2IATFHQAWAOnpJWHMuQowAnmCRwAwizoxcANQ4tlAXjgoAdvIDcFYMZhIomdMoAKOMHTgBvCnDhgXAQQAuVXVNEB12PQtyAF9La1t7NGUAESRMKyR+AGUYFBsPLzgIGGFbHLykADFgJHZ+II0oKwBzKNjyBSU4cvzDVPTjTJ7lADJEJBgWKGMAFUUkAB5OpAhMOBgoEzpMaBBnCFcZiGGAPijMFmMMYAhjdc3jbd39w+PcmwAKXwO6IJe6ACUBXI3iIk2mwO83joKAAbpkXoEfC46KJvmA-AAaOAAehxcBh8K40DgICQIAgwAAXnkbsZCt5+LZgPDsu8kEF0aj0X5CtE2hQ0OwhG4VLgwHAkAAPGzGfhuZDoGCiRxTJBi8C3JDWBb-bGnSFwNC3RosDDQL4ov4ooGeEFQugsJRQS0-AFRKHrYT0UQaCpwQx2z3eYqlKDDaq1epwABEAEYAEwAZhjmIZUNEmY2Wx2UD2KKOw1drgB6f5fMKfpgwDQcGaE1STVZEZw+Z+xd+cD1BPZQWGtvTwDWH3ozDY7A7aP82KrSF9cIR-gBQLBUzuxhY7HYHqhq4h2ceubbryLXPdFZiQA) #### Function components As of React 19, `defaultProps` is **no longer supported on function components**. Use destructuring defaults directly in the parameter list — TypeScript will infer the prop as optional automatically: ```tsx type GreetProps = { age?: number }; const Greet = ({ age = 21 }: GreetProps) => { // ... }; ``` If you prefer to declare defaults separately (for example, to share them across components), pull them into a constant and spread them when destructuring: ```tsx type GreetProps = { age?: number }; const defaultProps = { age: 21 } satisfies GreetProps; const Greet = ({ age = defaultProps.age }: GreetProps) => { // ... }; ``` > Setting `Greet.defaultProps = { age: 21 }` will not work on function components in React 19 — the value is ignored at runtime and `FunctionComponent` no longer types it. #### Class components Class components still support `static defaultProps`. The recommended approach is to type the props with the defaulted keys as required, and let `LibraryManagedAttributes` (applied automatically by JSX) make them optional at the call site: ```tsx type GreetProps = { age: number; }; class Greet extends React.Component { static defaultProps = { age: 21, }; render() { return
Hello, I am {this.props.age}
; } } // Type-checks — `age` is optional at the call site thanks to defaultProps. const el = ; ```
React.JSX.LibraryManagedAttributes nuance for library authors If you export `GreetProps` for consumers, `age` will appear required even though `defaultProps` makes it optional at the call site. `GreetProps` is the _internal_ contract — there's a separate _external_ contract that JSX computes via `React.JSX.LibraryManagedAttributes`. You can compute it explicitly: ```tsx // internal contract — don't export type GreetProps = { age: number; }; class Greet extends React.Component { static defaultProps = { age: 21 }; } // external contract export type ApparentGreetProps = React.JSX.LibraryManagedAttributes< typeof Greet, GreetProps >; ``` For most apps this isn't needed — only library authors who re-export the props type tend to hit it.
#### Typing Component Props This is intended as a basic orientation and reference for React developers familiarizing with TypeScript. #### Basic Prop Types Examples A list of TypeScript types you will likely use in a React+TypeScript app: ```tsx type AppProps = { message: string; count: number; disabled: boolean; /** array of a type! */ names: string[]; /** string literals to specify exact string values, with a union type to join them together */ status: "waiting" | "success"; /** an object with known properties (but could have more at runtime) */ obj: { id: string; title: string; }; /** array of objects! (common) */ objArr: { id: string; title: string; }[]; /** any non-primitive value - can't access any properties (NOT COMMON but useful as placeholder) */ obj2: object; /** an interface with no required properties - (NOT COMMON, except for things like `React.Component<{}, State>`) */ obj3: {}; /** a dict object with any number of properties of the same type */ dict1: { [key: string]: MyTypeHere; }; dict2: Record; // equivalent to dict1 /** function that doesn't take or return anything (VERY COMMON) */ onClick: () => void; /** function with named prop (VERY COMMON) */ onChange: (id: number) => void; /** function type syntax that takes an event (VERY COMMON) */ onChange: (event: React.ChangeEvent) => void; /** alternative function type syntax that takes an event (VERY COMMON) */ onClick(event: React.MouseEvent): void; /** any function as long as you don't invoke it (not recommended) */ onSomething: Function; /** an optional prop (VERY COMMON!) */ optional?: OptionalType; /** when passing down the state setter function returned by `useState` to a child component. `number` is an example, swap out with whatever the type of your state */ setState: React.Dispatch>; }; ``` ##### `object` as the non-primitive type `object` is a common source of misunderstanding in TypeScript. It does not mean "any object" but rather "any non-primitive type", which means it represents anything that is not `number`, `bigint`, `string`, `boolean`, `symbol`, `null` or `undefined`. Typing "any non-primitive value" is most likely not something that you should do much in React, which means you will probably not use `object` much. ##### Empty interface, `{}` and `Object` An empty interface, `{}` and `Object` all represent "any non-nullish value"—not "an empty object" as you might think. [Using these types is a common source of misunderstanding and is not recommended](https://typescript-eslint.io/rules/no-empty-interface/). ```ts interface AnyNonNullishValue {} // equivalent to `type AnyNonNullishValue = {}` or `type AnyNonNullishValue = Object` let value: AnyNonNullishValue; // these are all fine, but might not be expected value = 1; value = "foo"; value = () => alert("foo"); value = {}; value = { foo: "bar" }; // these are errors value = undefined; value = null; ``` #### Useful React Prop Type Examples Relevant for components that accept other React components as props. ```tsx export declare interface AppProps { children?: React.ReactNode; // best, accepts everything React can render childrenElement: React.JSX.Element; // A single React element style?: React.CSSProperties; // to pass through style props onChange?: React.FormEventHandler; // form events! the generic parameter is the type of event.target // more info: https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/patterns_by_usecase/#wrappingmirroring props: Props & React.ComponentPropsWithoutRef<"button">; // to impersonate all the props of a button element and explicitly not forwarding its ref props2: Props & React.ComponentPropsWithRef; // to impersonate all the props of MyButtonForwardedRef and explicitly forwarding its ref } ```
React.JSX.Element vs React.ReactNode? Quote [@ferdaber](https://github.com/typescript-cheatsheets/react/issues/57): A more technical explanation is that a valid React node is not the same thing as what is returned by `React.createElement`. Regardless of what a component ends up rendering, `React.createElement` always returns an object, which is the `React.JSX.Element` interface, but `React.ReactNode` is the set of all possible return values of a component. - `React.JSX.Element` -> Return value of `React.createElement` - `React.ReactNode` -> Return value of a component
[More discussion: Where ReactNode does not overlap with React.JSX.Element](https://github.com/typescript-cheatsheets/react/issues/129) #### Types or Interfaces? You can use either Types or Interfaces to type Props and State, so naturally the question arises - which do you use? ##### TL;DR Use Interface until You Need Type - [orta](https://twitter.com/orta/status/1356129195835973632?s=20). ##### More Advice Here's a helpful rule of thumb: - always use `interface` for public API's definition when authoring a library or 3rd party ambient type definitions, as this allows a consumer to extend them via _declaration merging_ if some definitions are missing. - consider using `type` for your React Component Props and State, for consistency and because it is more constrained. You can read more about the reasoning behind this rule of thumb in [Interface vs Type alias in TypeScript 2.7](https://medium.com/@martin_hotell/interface-vs-type-alias-in-typescript-2-7-2a8f1777af4c). The TypeScript Handbook now also includes guidance on [Differences Between Type Aliases and Interfaces](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#differences-between-type-aliases-and-interfaces). > Note: At scale, there are performance reasons to prefer interfaces ([see official Microsoft notes on this](https://github.com/microsoft/TypeScript/wiki/Performance#preferring-interfaces-over-intersections)) but [take this with a grain of salt](https://news.ycombinator.com/item?id=25201887) Types are useful for union types (e.g. `type MyType = TypeA | TypeB`) whereas Interfaces are better for declaring dictionary shapes and then `implementing` or `extending` them. ##### Useful table for Types vs Interfaces It's a nuanced topic, don't get too hung up on it. Here's a handy table: | Aspect | Type | Interface | | ----------------------------------------------- | :--: | :-------: | | Can describe functions | ✅ | ✅ | | Can describe constructors | ✅ | ✅ | | Can describe tuples | ✅ | ✅ | | Interfaces can extend it | ⚠️ | ✅ | | Classes can extend it | 🚫 | ✅ | | Classes can implement it (`implements`) | ⚠️ | ✅ | | Can intersect another one of its kind | ✅ | ⚠️ | | Can create a union with another one of its kind | ✅ | 🚫 | | Can be used to create mapped types | ✅ | 🚫 | | Can be mapped over with mapped types | ✅ | ✅ | | Expands in error messages and logs | ✅ | 🚫 | | Can be augmented | 🚫 | ✅ | | Can be recursive | ⚠️ | ✅ | ⚠️ In some cases (source: [Karol Majewski](https://twitter.com/karoljmajewski/status/1082413696075382785)) ## getDerivedStateFromProps Before you start using `getDerivedStateFromProps`, please go through the [documentation](https://reactjs.org/docs/react-component.html#static-getderivedstatefromprops) and [You Probably Don't Need Derived State](https://reactjs.org/blog/2018/06/07/you-probably-dont-need-derived-state.html). Derived State can be easily achieved using hooks which can also help set up memoization easily. Here are a few ways in which you can annotate `getDerivedStateFromProps` 1. If you have explicitly typed your derived state and want to make sure that the return value from `getDerivedStateFromProps` conforms to it. ```tsx class Comp extends React.Component { static getDerivedStateFromProps( props: Props, state: State, ): Partial | null { // } } ``` 2. When you want the function's return value to determine your state. ```tsx class Comp extends React.Component< Props, ReturnType<(typeof Comp)["getDerivedStateFromProps"]> > { static getDerivedStateFromProps(props: Props) {} } ``` 3. When you want derived state with other state fields and memoization ```tsx type CustomValue = any; interface Props { propA: CustomValue; } interface DefinedState { otherStateField: string; } type State = DefinedState & ReturnType; function transformPropsToState(props: Props) { return { savedPropA: props.propA, // save for memoization derivedState: props.propA, }; } class Comp extends React.PureComponent { constructor(props: Props) { super(props); this.state = { otherStateField: "123", ...transformPropsToState(props), }; } static getDerivedStateFromProps(props: Props, state: State) { if (isEqual(props.propA, state.savedPropA)) return null; return transformPropsToState(props); } } ``` [View in the TypeScript Playground](https://www.typescriptlang.org/play/?jsx=2#code/JYWwDg9gTgLgBAJQKYEMDG8BmUIjgcilQ3wFgAoUSWOYAZwFEBHAVxQBs5tcD2IATFHQAWAOnpJWHMuQowAnmCRwAwizoxcANQ4tlAXjgoAdvIDcFYMZhIomdMoAKOMHTgBvCnDhgXAQQAuVXVNEB12PQtyAF9La1t7NGUAESRMKyR+AGUYFBsPLzgIGGFbHLykADFgJHZ+II0oKwBzKNjyBSU4cvzDVPTjTJ7lADJEJBgWKGMAFUUkAB5OpAhMOBgoEzpMaBBnCFcZiGGAPijMFmMMYAhjdc3jbd39w+PcmwAKXwO6IJe6ACUBXI3iIk2mwO83joKAAbpkXoEfC46KJvmA-AAaOAAehxcBh8K40DgICQIAgwAAXnkbsZCt5+LZgPDsu8kEF0aj0X5CtE2hQ0OwhG4VLgwHAkAAPGzGfhuZDoGCiRxTJBi8C3JDWBb-bGnSFwNC3RosDDQL4ov4ooGeEFQugsJRQS0-AFRKHrYT0UQaCpwQx2z3eYqlKDDaq1epwABEAEYAEwAZhjmIZUNEmY2Wx2UD2KKOw1drgB6f5fMKfpgwDQcGaE1STVZEZw+Z+xd+cD1BPZQWGtvTwDWH3ozDY7A7aP82KrSF9cIR-gBQLBUzuxhY7HYHqhq4h2ceubbryLXPdFZiQA) #### Forms and Events If performance is not an issue (and it usually isn't!), inlining handlers is easiest as you can just use [type inference and contextual typing](https://www.typescriptlang.org/docs/handbook/type-inference.html#contextual-typing): ```tsx const el = (