Podcasts Technology Syntax - Tasty Web Development Treats React + TypeScript

React + TypeScript

Published: June 2, 2021, 1 p.m.

In this episode of Syntax, Scott and Wes talk about using React with Typescript \u2014 how to set it up, components, state, props, passing data, custom hooks, and more!

Freshbooks - Sponsor

Get a 30 day free trial of Freshbooks at\xa0freshbooks.com/syntax\xa0and put SYNTAX in the \u201cHow did you hear about us?\u201d section.

Sentry - Sponsor

If you want to know what\u2019s happening with your code, track errors and monitor performance with Sentry. Sentry\u2019s Application Monitoring platform helps developers see performance issues, fix errors faster, and optimize their code health. Cut your time on error resolution from hours to minutes. It works with any language and integrates with dozens of other services. Syntax listeners new to Sentry can get two months for free by visiting\xa0Sentry.io\xa0and using the coupon code TASTYTREAT during sign up.

Linode - Sponsor

Whether you\u2019re working on a personal project or managing enterprise infrastructure, you deserve simple, affordable, and accessible cloud computing solutions that allow you to take your project to the next level. Simplify your cloud infrastructure with Linode\u2019s Linux virtual machines and develop, deploy, and scale your modern applications faster and easier. Get started on Linode today with a $100 in free credit for listeners of Syntax. You can find all the details at\xa0linode.com/syntax. Linode has 11 global data centers and provides 24/7/365 human support with no tiers or hand-offs regardless of your plan size. In addition to shared and dedicated compute instances, you can use your $100 in credit on S3-compatible object storage, Managed Kubernetes, and more. Visit\xa0linode.com/syntax\xa0and click on the \u201cCreate Free Account\u201d button to get started.

Show Notes

04:55 - Components

  • Strategies
  • Example:
 type Props = {    value: string; }  const App = (props: Props) => <div />
  • Return type? JSX.Element
  • FC or FunctionComponent
  • It\u2019s discouraged for this reason:\xa0It means that all components accept children, even if they're not supposed to
  • It could be useful for a return type

12:13 - Props

  • Default props:
 const defaultJoke: JokeProps = {   joke: 'LOL JOE',   id: 'YEAH',   status: 200, };  function JokeItem({ joke = defaultJoke }: JokeProps): JSX.Element {   return (     
  •        {joke.joke} = {joke.id}     
    •    ); }
    • Because props are always destructured, you often have to make a new type for your props. You can\u2019t just type each argument by itself.

    18:38 - State

    • Just like Generics, State can be inferred
    • If your type is simple and you\u2019re using useState, it just works:
      const [user, setUser] = useState(null);

    22:27 - useEffect

    • Nothing special required
    • Good use of void: If you want to use a Promise function but not worry about await or .then(), you can pop a void in front of it:
     useEffect(() => { console.log('Mounted'); // getJoke().then(console.log).catch(console.error); void getJoke(); }, [getJoke]);

    26:09 - Refs

    • Very similar to state however some interesting things with null:
      const ref1 = useRef(null!);
    • \u201cInstantiating the ref with a current value of null but lying to TypeScript that it\u2019s not null.\u201d

    29:33 - Custom Hooks

    • This is a great use case for Tuples

    31:00 - Context

    • This is probably the most complex thing in this list
    • First define the types
    • Use generic to pass in types OR null
    • This can also be non-null if you have default values in createContext:
      const AppCtx = React.createContext(null);

    35:21 - Events

    • The React events system is better than Vanilla JS
    • Can handle them inline and have it inferred:\xa0onClick={e \u21d2 yeah(e.target)}
     const onSetType = (e: React.ChangeEvent) =>     setType(e.target.value)
    • React has a bunch of events built in \u2014 many of them take a Generic argument so you can specify the type of element that triggered it. Handy for native API methods like play and pause.

    39:27 - ForwardRef

    • Again use of
    • to pass in forwarded ref type as param 1, Props types as param 2:
     type Props = { children: React.ReactNode; type: "submit" | "button" }; export type Ref = HTMLButtonElement; export const FancyButton = React.forwardRef((props, ref) => (        {props.children}    ));

    41:30 - ESLint

    • Typescript-react is good
    • Extend your own
    • Most JS rules apply to TS

    46:20 - React as Global React 17

    • Also add JSX: True to eslint globals for typing things like JSX.Element
    • global.d.ts
     import * as react from "react" import * as react_dom from "react-dom"  declare global {     type React = typeof react     type ReactDOM = typeof react_dom }

    48:08 - TSConfig

    • jsx: "react"
    • React emit .js files with JSX changed
    • Preserve .jsx file output
    • React-native \u2192 .js files with jsx not changed

    53:05 - Frameworks?

    Links \xd7\xd7\xd7 SIIIIICK \xd7\xd7\xd7 PIIIICKS \xd7\xd7\xd7 Shameless Plugs Tweet us your tasty treats!