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

 Resources from Chris Achard in 2021

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

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

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

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

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

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

**🚨 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

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

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

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

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

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 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

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

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.

Topics

Instructors

Content Type

Free or Pro