This course gets you up and running with react in under a minute by using codesandbox.io to skip the painful process of setting up your dev environment.

Chris Achard

React Crash Course with Hooks

In this course, we’ll create an online/offline note-taking app.  We’ll use `create-react-app` to create the frontend, and node.js to create a simple backend. 

Progressive Web Apps in React with create-react-app

We’ll build a mobile app with React Native for both iOS and Android. Prior React experience is required, but you don’t have to know mobile development to participate.

Build a React Native Application for iOS and Android from Start to Finish

In this collection, you'll create a simple game with React using Recoil, to explore how you can share and update state across an app.

Getting Started with Recoil in React

Chris Achard Landing Page

 Courses from Chris Achard

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

There are two methods to append strings together in javascript, but there are edge cases that you have to watch out with each of them.

First, you can use the `+` operator to add strings together:

```
"first" + " " + "second"
```

which works, but watch out!  If one of your variables is a non-string value, then it will try to convert that to a string before adding it to the other string.

The other method is to use the `concat` method:

```
"first".concat(" ", "second")
```

but `concat` has a big problem because now if the first value is a non-string value (like `null` or `undefined`), then it will cause a runtime error, since the `concat` method is undefined on those values.

For that reason, most people use the `+` operator to add two strings together in javascript.

Append two strings together in javascript (with edge cases)

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

Instead of just returning a value from a recoil selector, you can return any promise, which means that you can do asynchronous functions in recoil selectors (this is a little like a redux thunk).

The huge bonus is that you don't have to do anything different when actually calling the selector - use can use `useRecoilValue` in the same way that you would from a normal selector.

The only thing you must do is somewhere in the component tree, wrap any component that uses an async selector with a `<React.Suspense>` tag with a `fallback` prop that will tell React what to display when the async selector isn't loaded yet.





Use Async Functions in a Recoil Selector

Recoil is a new (experimental!) library from facebook that can handle complex shared data across a large react app.

In this collection, we'll create a simple game with React using Recoil, to explore how you can share and update state across an app. 

Recoil is similar to (but different than) Context, Redux, or other shared state libraries (like MobX), but is designed to handle large (and variable) numbers of state that can update without re-rendering your entire app's component tree.

A state management library for React.

Recoil works and thinks like React. Add some to your app and get fast and flexible shared state.

recoil

To change a value in state we can do that directly (by pulling the atom with `useRecoildState`), or we can write a custom hook that will change the value for us:

```
const useResetScore = () => {
  const [score, setScore] = useRecoilState(gameScore)
  return () => {
    setScore(0)
  }
}
```

That function returns a function that we can then call from a component like any other hook:

```
  const resetScore = useResetScore()
```

and then we can use that new `resetScore` function for the `onClick` of a button:

```
<button onClick={resetScore}>Reset</button>
```

which will change the value in the Recoil state.

That's a simplistic example of a custom hook - but that hook could then be extended to do multiple state changes, and then could be imported into any component in the React tree and used.

Write a Custom Recoil Hook to Reset a Value in the Recoil State

To compute a value from one or more values stored in Recoil, we can create a "selector".

First import `selector` from Recoil, and then call it with an object that has two keys: `key` and `get`:

```
import { selector } from recoil;
...
const paperSize = selector({
  key: 'paperSize',
  get: ({get}) => {
    const score = get(gameScore)
    return 100 + (score * 5)
  }
})
```

Inside of the `get` function we can get the current value of the `gameScore` atom from recoil, and then compute a new value from that to return to our game.  Then we can get the value using `useRecoilValue`:

```
import { paperSize } from './selectors'
...
const size = useRecoilValue(paperSize)
```


Compute a Value in Recoil Using a Selector

To get a value from Recoil we can import the atom that we want and the hook `useRecoilValue` from recoil.

Then we can get the value:

```
import { useRecoilValue } from 'recoil'
...
import { gameScore } from './atoms'
...
const score = useRecoilValue(gameScore)
```

And display it in a lablel:

```
<h3>Score: {score}</h3>
```

That value will update every time the button is clicked (and `setScore` is called) automatically!

Read a Value from Recoil with useRecoilValue

We'll create a new bit of shared state (called an "atom" in Recoil) by importing `atom` from Recoil and setting a unique key and default value:

```
import {
  atom
} from 'recoil'

const gameScore = atom({
  key: 'gameScore',
  default: 0
})
```

Then we can use that `gameScore` by calling the Recoil hook `useRecoilState`

```
import {
  useRecoilState
} from 'recoil'

...

  const [score, setScore] = useRecoilState(gameScore)
```

That looks a lot like a local `useState` call - but is different because it creates the state in Recoil, which can then be used in this component, or in any other component in the tree (underneath the same `RecoilRoot`)

Create Shared State with Recoil in a React App

We'll create a new React game with:

```
npx create-react-app paper-game
cd paper-game
```

and then install Recoil with:

```
npm install recoil
```

and start the server:

```
npm start
```

Then, to wrap the entire app in the recoil root, we'll import `RecoilRoot` from `recoil` and wrap the app:

```
    <RecoilRoot>
      <Game />
    </RecoilRoot>
```

And the app is now up and running - ready to use Recoil



Set Up Recoil in a new React App

Get started with React! (with Hooks)

This course gets you up and running with react in **under a minute** by using codesandbox.io to skip the painful process of setting up your dev environment. 

You'll learn:

- How to write React code with JSX
- How to "think in React"
- How to use local state to store changing data
- How to pass data from parent components to children components using props

So get started now!  You need some javascript and HTML experience, but no prior React experience is needed.

**🚨 The correct url is now "https://swapi.dev/api/people/"**

Whenever doing a side effect (like fetching data) in React, we can use the `useEffect` hook to perform that action and then set state afterwards.

So we'll fetch some data inside of useEffect like this:

```
  useEffect(() => {
    console.log(props.id)
    fetch("https://swapi.co/api/people/"+props.id)
      .then(response => response.json())
      .then(result => setData(result))
  }, [props.id])
```

Caution! make sure to set the dependency array (the second argument to useEffect) to contain any data that you use inside of the `useEffect`.  Otherwise you could end up with an infinite loop as the useEffect will run every time the component in re-rendered.



Perform Asynchronous Actions (like fetching http data) in React with useEffect

There are two main (default) ways to add styles to React components:

First, just normal CSS classes can be added to react components by setting a `className` attribute:

```
<p className='big-text'>BIG</p>
```

(It's called `className` instead of `class` because "class" is a reserved keyword in javascript)

Second, "inline styles can be added as javascript objects to the `style` attribute of a component:

```
<p style={{ fontSize: 20, color: 'blue' }}>Blue</p>
```

Notice that the "double curly braces" represent a javascript object being created _inside_ of JSX, and also that the css attributes are camel cased.

Adding Styles to React Components with CSS or Inline Styles

To display a list of items in react, we can `map` (or loop) over that list and return JSX from inside the map function:

```
    <div>
      {
        props.items.map(item => {
          return <p key={item.id}>{item.title}</p>
        })
      }
    </div>
```

Remember to always include a `key` attribute though! That lets React keep track of each list item internally, which gives you better performance, and may save you from subtle bugs

Display a List in React by Looping Over an Array of Items

After creating some state with `useState`, we can call the set function to update the data in local state, which will automatically "re-render" the component, and update the UI.

To do that, we'll first create a new function that will update the state that we want:

```
const updateCount = () => {
  setCount(count + 1)
}
```

and then we can pass that `updateCount` function into the `onClick` of a button:

```
<button onClick={updateCount}>Click Me!</button>
```

which will then call `updateCount` once clicked, which will call `setCount`, which will update the `count` state, and automatically display that update on the UI.

Create a Button in React that Changes Local State and Automatically Updates the UI

Data inside of a react component that can change (with user or server interaction) is called `state`.

import `useState` from react, and then we can use that function to create some local state by calling it with a default value:

```
const [count, setCount] = useState(5)
```

`useState` returns an array of two items: the first is the current value of the state, and the second is a function that we can use to update that state.

Create State Data that can Change in a React Component with useState

To pass data from a parent react component to a child react component, we can supply "attributes" to the JSX tags like:

```
<Greeting name="React" />
```

That `name` attribute is then available in the `Greeting` component as a `prop` (which is an object passed in as the first argument to the react function component.

That means we can display that name from the `props` argument like this:

```
function Greeting(props) {
  return(<p>{props.name}</p>)
}
```

And so you can customize any react component by passing data down in the form of that props argument.

Reusing Custom React Components by Passing Data Down as Props

You can reuse your custom react components multiple times and build them into a tree of components like this:

```
<Greeting />
<div>
  <Greeting />
</div>
```

Notice that the `<div>` tag contains the `Greeting` tag as a child, but the `Greeting` tag contains no children - so it requires the trailing slash (`/>`) so it can be a "self closing" tag

Building a Tree of UI Components in React with Children or with Self-closing tags

React components are functions that return JSX (which looks like HTML, but is actually a flavor of javascript).

Once you create a new function component that returns JSX, you can then use it from inside of another component by returning it like any other component.

Write a Custom Function Component in React with JSX

Every UI on the web can be thought of as a tree of "components".

Break down your UI in your mind by separating out "like" components.  Those are what you'll turn into React components for displaying your data.

Think in React by Breaking Your UI into Components

The React UI loop follows these steps:

1. You have data
2. That data gets displayed
3. The data updates (by user input, or a fetch from the server, etc)
4. The UI updates

The React "magic" is in step 4 - React automatically updates the UI based on your changing data in a performant way.  That means you can focus on your data and UI layout, and NOT on how you would have to update the DOM to show those changes.

How React Works

Go to codesandbox.io and start a new sandbox using the "React" template

Then, you can edit the HTML (which is actually a special form of javascript called JSX) to make your first custom component!

CodeSandbox is great because it skips the need to set up your on development environment - so you can get started super quickly.

Write Your First React Component with CodeSandbox.io

Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.

If you want to pull over just a single commit from one branch onto another, you can do that with `git cherry-pick [HASH-TO-MOVE]`

We'll demonstrate that by making a commit on a feature branch, and then copying that commit (but not the entire branch) onto master.

Copy a Commit from One Branch to Another

How you build with Angular has changed quite a lot over the years.

For example, the `inject` function was introduced in version 14 but you might still be familiar with Angular's constructor injection.

Similarly, structural directives like `ngif` or `ngfor` have been replaced with `@if` and `@for` blocks since version 17 and beyond.

These are patterns that need to be adjusted if you want to stay up-to-date with the latest Angular has to provide.

Luckily, Angular gives you great tools in the form of a migration CLI for supporting your migration efforts as you incrementally update your App from older version features and patterns. 

When you're done with this course you'll know how to target specific features, folders, and files to migrate to the latest Angular version.

You'll learn how to 'migrate':
- Structural directives with control flow syntax
- Constructor dependency inject to inject function
- Make components standalone
- Lazy load routes
- Input/Output decorators to signal-based API


Angular Migrations in Practice

Migrate old Angular patterns for version 18 and beyond

When we import assets in React components outside of the `public` folder that Nitro reads for assets by default when running the development server we need to tell Nitro how to find them with the `devProxy` configuration option.

```typescript
export default defineNitroConfig({
  renderer: './renderer.ts',
  devProxy: {
    '/app/assets': 'http://localhost:5173/app/assets'
  }
})
```

This is ultimately inadequate in scenarios where you want to import assets arbitrarily and have them "just work" but works in a pinch.



Use devProxy in Nitro Config to Serve Static Imported Assets in Dev Mode via Vite

Learn how to use devProxy in Nitro Config with Vite to serve static assets in React components in dev mode.

Start with a basic Vite React TypeScript app and enhance it for production use by integrating Nitro as the server. 

This requires a custom Vite plugin for nitro as well as a custom renderer and manually creating Nitro config.

The other way to approach this would be to add Vite to a Nitro app instead. Same basic result.

The [Nitro config reference](https://nitro.unjs.io/config) is a great read of you'd like to explore more options.


Configure a Vite React TypeScript Application on a Basic Nitro Server

Configure a Vite React TypeScript app by integrating Nitro for production, using custom plugins, renderers, and configs.

Quick Get Started style introduction to Vite using `pnpm create vite` with the React TypeScript template.

See [more in the official docs](https://vite.dev/guide/).

Create a Vite App with the React TypeScript Preset

Quick guide to start a Vite app using React TypeScript template with pnpm.

Over the years, your application have grown huge. Sometimes, really HUGE.

Many developers have contributed to the codebase. One day they pushed one coding style, a different one another day. Sometimes even different patterns and solutions for similar problems.

You want to keep your codebase consistent. In the Angular ecosystem, there were well established patterns for doing things the right way ™️. But the old solutions are being challenged by signal-based approach.

Eventually, you ask yourself the key question: **Should you integrate with the NEW solutions or stick to the battle-tested ones, but already considered LEGACY**?

That's a very good question indeed. Don't rush with architectural decisions 🤓.

## First, think of what problems you want to solve by introducing the change.

Do you have 1k LoC Angular components? Maybe even 2k? Do you and your team enjoy working with these? 😏

Where does the **domain logic and state management code** belong to - do you have a clear guidance on which code should be put where? Have you spot that different devs implement similar features in totally different ways?

Do you keep on asking the same questions over and over again: **whether this certain piece of code** should be **imperative** (plain old object properties and variables) or **reactive** (streams)? It'd be nice to keep all thinga reactive, but more often than not, it introduces complexity.

## Second, think of long-term consequences.

You are going to have more than one way to **manage the state**. But is that really an issue? If your codebase is modular, separate modules should not depend on each other in any way. Inner abstractions of one should be invisible to the other, etc.

You are going to introduce a **new tool**. On one hand, you need to learn it, and so does your team. But on the other hand, it's a breathe of fresh air. And it's useful to question the way you've been doing things so far. Maybe there's a more effective way?

You are going to embrace signal-based APIs. And that means taking taking advantage of Zoneless Angular. This means using all modern Angular APIs. And you know that signals are the future. Why would you want to stick to the **less performant, less type-safe, less flexible and, objectively, less effective solutions**?

## Finally, plan your INCREMENTAL integration.

INCREMENTAL is the absolute keyword here. You don't want to tell your PM you need to stop delivering features because of a refactor.

Actually, there's no need for a "refactor". Just pick the first new feature to be implemented. Or pick the one that needs to be extended.

NGRX Signal Store allows you to create both very simple & small stores, as well as bigger ones. **Composition** is the key here.

**Start simple**.

Create a `withState` section with the signals that hold the state. That's already reactive. And relatively simple.

```ts
const initialState: CartState = {
  items: ...,
  rebate: ...,
}

export const CartStore = signalStore(
  withState(initialState)
);
```

Create a `withMethods` section to provide ways to change the state:

```ts
export const CartStore = signalStore(
  ...
  withMethods((store) => ({
    addItem(item: ShoppingItem): void {
      patchState(store, (state) => ({ items: [ ...state.items, item ] }));
    },
    ...
);
```

Create a `withComputed` section to provide all derived computations:

```ts
export const CartStore = signalStore(
  ...
  withComputed(({ items }) => ({
    totalPrice: computed(() => items().reduce(...))
    ...
);
```

**Start simple**.

Now you can (literally) **`inject` this code into your existing solution**. All you need is to inject your brand new NGRX Signal Store implementation into a component, or a service:

```ts
@Injectable()
class ExistingBigService {
  cartStore = inject(CartStore)
  //...  
}
```

and that's it! What's beatiful is that NGRX Signal Store should remain an implementation details (of a component, service, etc). It **shouldn't leak outside to the entire application unintentionally**. Small NGRX Signal Stores help us to **keep logic more modular**.

Don't hesitate - give NGRX Signal Store a try! Start with the [_**Scalable Signals Angular Architecture with NGRX Signal Store**_](https://egghead.io/courses/scalable-signals-angular-architecture-with-ngrx-signal-store-a33abd39) course now!

Integrating NGRX Signal Store with an existing Angular application

Integrate NGRX Signal Store into your Angular app incrementally for modular, reactive state management. Improve consistency and performance with modern APIs.

In React 19, managing script tags efficiently within components can lead to performance enhancements and simpler code structures.

Originally, using script tags directly in a React component involved complex setups, like using `useEffect` to dynamically add JavaScript code. For instance, a component might dynamically inject script tags to load external widgets. This approach, while functional, resulted in multiple script tags and duplicate iframe elements. This duplication not only cluttered the output but also negatively impacted performance by loading scripts multiple times.

The workaround for this would be to manually hoist any common scripts and maybe load them when they weren't needed by any components.

With React 19 we now have a more effective method. This involves directly placing the script tag within the React component's return statement. This approach ensures that React handles the script loading, avoiding the duplication of script tags.

By implementing the script tags this way, the loading initiator becomes React DOM, which efficiently manages script loading and deduplication. This setup prevents multiple requests for the same script when the component is rendered multiple times, enhancing the overall application performance.

Furthermore, directly embedding the script tag simplifies the code, making the component cleaner and more maintainable.

Efficiently Render Script Tags in React 19 Components

Learn how to efficiently render script tags in React 19 components to improve performance by avoiding duplicate script loads and simplifying your code.

Let's learn how to dynamically manage title tags in React 19 applications. Rendering `<title>` dynamically is simple enough, however, a challenge arises when multiple title tags are present in the document, which can lead to issues with screen readers and search engine optimization (SEO). The solution presented involves ensuring that only one title tag is rendered at a time by using conditional rendering.

Also we need to make sure to have a single string within the title tag using a template literal, ensuring our HTML remains valid and optimized.


Deduplicate Title tags with React 19

Learn to manage multiple title tags in React 19 dynamically. Ensure accessibility and SEO by preventing duplicate title tags with clear examples.

In React 19, we can easily add a title tag like "Starship Deets" which then appears in the head section of the HTML even when we render it inside our components. This method also applies to meta tags such as character set and viewport settings, which are also lifted to the head section automatically.

This is an awesome feature because it maintains the same composition style we are familiar with in React components. It simplifies the handling of HTML head elements without needing extra setups like `useEffect` for accessing the head section. Even in situations where our components are rendering within a body element, like within a div, we can manage our head content directly within our components. React takes care of hoisting these elements where they need to go.


Hoist Title and Meta tags in React 19

Hoisting title and meta tags directly in React 19 components allows for simpler composition, similar to other React elements. Manage meta and title tags.

<PodcastLinks />

Dax Raad, known for his strong opinions on Twitter, sat down for a chat about web dev, career moves, and building cool stuff. He's not afraid to throw some heat at popular tools like [Next.js](https://nextjs.org/), though he still helps people use it. Dax is particularly excited about local-first development, which he thinks isn't getting enough attention. He argues that sometimes the best web dev move is to step away from web dev entirely and explore other areas of programming.

When it comes to career growth, Dax encourages developers to think beyond the "web dev" label and see themselves as programmers capable of tackling any challenge. He advocates for trying out weird stuff and learning unusual languages, as these experiences can lead to unexpected opportunities. Taking smart risks in your career can open doors to awesome possibilities.

In the business world, Dax is a fan of making "asymmetric bets" - moves with low downside but huge potential upside. He applies this philosophy to his work on [SST](https://sst.dev/), reasoning that even if it fails, he'll walk away with valuable experience. He also emphasizes the importance of resisting quick payouts in favor of potentially bigger wins down the road.

Looking to the future of tech, Dax is betting on local-first development. He sees potential in getting in early on emerging technologies like [Solid.js](https://www.solidjs.com/). Building in public and making connections in new tech communities can pay off in unexpected ways.

Dax also challenges the notion of constant hyper-productivity in tech. He suggests balancing focused work with time for exploration and learning. Sometimes, he points out, what seems like a "dumb" choice (like learning a niche language) can turn out to be a smart career move in the long run.

## Good Stuff Mentioned

- [Next.js](https://nextjs.org/)
- [Vercel](https://vercel.com/)
- [SST](https://sst.dev/)
- [Elixir](https://elixir-lang.org/)
- [Solid.js](https://www.solidjs.com/)
- [RepliCache](https://replicache.dev/)
- [Linear](https://linear.app/)
- [Remix](https://remix.run/)
- [Shopify](https://www.shopify.com/)
- [React](https://react.dev/)

Developer Career Growth and Asymmetric Bets with Dax Raad

<PodcastLinks />

Dev and Joel discuss React Miami conference, praising its fun atmosphere and location. They chat about React Server Components, with Dev sharing his experience building a mini framework. They talk about Vinxi, Nitro, and the unjs ecosystem as tools for creating custom frameworks. The conversation touches on Vue's popularity outside web dev circles and non-web dev conferences. They discuss the benefits of TypeScript and strongly-typed APIs. Dev mentions his upcoming talk on durable objects at [a conference in Dallas](https://x.com/DThompsonDev/status/1829674506237194456). They end by discussing WebSockets, PartyKit, and platform-specific frameworks.

## What's Good?

- [React Miami Conference](https://www.reactmiami.com/) 
- [Brenley Dueck's blog post on Simple RSC with Vinxi:](https://www.brenelz.com/posts/simple-rsc-with-vinxi/)
- [Vinxi](https://github.com/nksaraf/vinxi)
- [Nitro](https://nitro.unjs.io/guide/configuration)
- [unjs ecosystem](https://unjs.io/)
- [Solid Start](https://start.solidjs.com/)
- [TanStack Router](https://tanstack.com/router/latest) 
- [PartyKit](https://github.com/partykit/partykit) 
- [Durable Objects (Cloudflare)](https://developers.cloudflare.com/durable-objects/)
- [Flightcontrol](https://www.flightcontrol.dev/) 
- [SST](https://sst.dev/)
- [OpenNext](https://open-next.js.org/)

Chris Achard

React Crash Course with Hooks

Featured Courses

Search Results

Append two strings together in javascript (with edge cases)

Use Async Functions in a Recoil Selector

Getting Started with Recoil in React

Write a Custom Recoil Hook to Reset a Value in the Recoil State

Compute a Value in Recoil Using a Selector

Read a Value from Recoil with useRecoilValue

Create Shared State with Recoil in a React App

Set Up Recoil in a new React App

React Crash Course with Hooks

Perform Asynchronous Actions (like fetching http data) in React with useEffect

Adding Styles to React Components with CSS or Inline Styles

Display a List in React by Looping Over an Array of Items

Create a Button in React that Changes Local State and Automatically Updates the UI

Create State Data that can Change in a React Component with useState

Reusing Custom React Components by Passing Data Down as Props

Building a Tree of UI Components in React with Children or with Self-closing tags

Write a Custom Function Component in React with JSX

Think in React by Breaking Your UI into Components

How React Works

Write Your First React Component with CodeSandbox.io

Copy a Commit from One Branch to Another