 Courses from Elijah Manor

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

A new Higher Order Component (HOC) was recently released in [React v16.6.0](https://reactjs.org/blog/2018/10/23/react-v-16-6.html) called `React.memo`. This behavior of the HOC is similar to what you’d get when using `React.PureComponent` or `shouldComponentUpdate` in a React Class Component. However, now with the introduction of `React.memo`, you can leverage this behavior for React Function Components. The end result is that React will skip rendering the component if the props have not changed and will reuse the last rendered result.

Use React.memo with a Function Component to get PureComponent Behavior

React just announced a new [Hooks]([Introducing Hooks – React](https://reactjs.org/docs/hooks-intro.html)) proposal enabling React Function Components to handle state and side-effects, which was previously only possible with React Class Components. In this lesson, we will be using a prerelease of React to convert a React Class Component to a Function Component using hooks, and then at the very end we'll introduce a custom hook to simplify the component even further.

Use React Hooks to Convert a Class Component to a Function Component

In this lesson, we’ll make sure we have a sufficient environment in order to start using the experimental Hooks API that comes with React. Currently you need a prerelease version of React since it hasn’t yet been introduced into an official release.

Environment Setup for React Hooks

Historically, you had to use a React Class Component in order to maintain state in a component. However, with Hooks, you can now add state to a Function Component using the useState hook. In this lesson, we will explain how to use this API and then convert a portion of an existing Class Component to a Function Component.

Add State with the useState Hook to a React Function Component

In order to use Hooks there are a certain set of rules you need to follow. Thankfully, the React Team has provided an ESLint Plugin that will help enforce these rules when using Hooks.


Add Linting to Help Enforce Rules when Using React Hooks

React has provided the useEffect Hook to add side-effects to a Function Component. In this lesson, we'll add hooks to manage localStorage and listen to window keydown events. We’ll also unpack how to clean-up after these effects and also control how often they are executed.

Add a Lifecycle Event with the useEffect Hook to a React Function Component

Refs have been a handy way to reference DOM elements in Class Components, but did you know you can use refs for other things as well? In this lesson, we’ll examine how to leverage the useRef hook inside a Function Component. We’ll first use this ref to attach to a React element, which you may already be familiar with, but then we’ll examine how to use a ref to simulate a Class instance variable.

Use the React useRef Hook to Reference a DOM Element or Simulate an Instance Variable

A common way to share code across Components has been Render Prop Components or Higher Order Components (HOC), but extracting code with Hooks is much more straightforward. You can take code from an existing Component and pull out the hook logic into its own function for reuse.

Write Custom Hooks to Share Logic Between React Function Components

As an alternate to useState, you could also use the useReducer hook that provides state and a dispatch method for triggering actions. In this lesson, we’ll centralize logic that is spread across a web application and centralize it using the useReducer hook.


Use the useReducer Hook and Dispatch Actions to Update State 

Since the announcement of React Hooks a lot of community hooks have already been created. We will take a look at a list of these hooks and leverage a couple of them to use in our web application. The site https://nikgraf.github.io/react-hooks/ is a great round-up of current community hooks that you can use today.


Leverage an Existing Community Hook in Your React Function Component

React changed their Context API in version 16.3 to include Provider and Consumer components. Inside of a Function Component you can leverage the useContext hook to wire-up a consumer instead of using the Render Props Consumer component.


Use the useContext Hook to Wire-up the React Context API 

Historically, only Class Components could extend PureComponent or implement their own shouldComponentUpdate method to control when it's render was actually invoked. However, now you can use React.memo HOC to provide this same type of control with Function Components. This isn't specific to Hooks, but was released in React 16.6 and complements the hooks API.


Simulate PureComponent with a React Function Component

Certain calculations or operations can take a long time. React provides a useMemo hook that will return cached results from previous calculations, which can dramatically speed up render time.

Leverage the React useMemo Hook for Expensive Operations

Render Props is a popular pattern in React, but sometimes the nesting of Components can get quite deep. Thankfully, React Hooks can help provide an alternate way to structure your code for reuse. In this lesson, we will take an existing Render Props Component and convert it to use a hooks instead.

Convert a Render Props Component using a Custom React Hook

In this course we start by getting your environment setup for hooks and then we’ll introduce the idea of adding state to a function component and unpacking several ways to interact with that state.

There are a few rules that you need to follow when you start using hooks, but thankfully there's a custom ESLint plugin that’ll help enforce these rules. I’ll show how to setup the hooks plugin and talk about some of the rules that should be followed.

Things get more interesting and involved once we introduce side-effects to our function component with the useEffect hook. We’ll uncover numerous things to consider while using this particular hook.

One of the cool features of hooks is that it’s easy to abstract out code for reuse with custom hooks. The React community has already created lots of custom hooks that you can start playing with today.

Once I've introduced the main concepts of useState and useEffect, I'll start to unpack other hooks such as useRef, useReducer, useContext, useMemo, and useCallback.

Introduction to Reusable State and Effects with React Hooks

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

node

When you or your team work on various npm or yarn projects it gets hard to remember which one is which. This lesson shows you how to create a custom `npm` zsh function alias to remind yourself to use yarn commands when there is a `yarn.lock` file in the directory.

Make a zsh function alias to enforce using yarn commands when in a yarn project

Cascading Style Sheets bring order and beauty to our applications.

Firefox DevTools has an awesome feature that helps you determine Inactive CSS, to know why it's inactive, it gives you hints on how to fix it, and even links to documentation for additional help.

Understand why CSS has no effect with the Inactive CSS rules indicator in Firefox DevTools

In this lesson we focus on toggling animations on and off using the prefers-reduced-motion media query. The sample web app has 3 types of animations (CSS, SVG SMIL, and JavaScript) and we will toggle these animations using different techniques such as @media, matchMedia, and a custom hook.

Use the `prefers-reduced-motion` media query to toggle CSS and JavaScript animations

In this lesson we are going to build a React Teleprompter web application using the [`Web Speech API`](https://developer.mozilla.org/en-US/docs/Web/API/Web_Speech_API). In particular, we'll use the [`SpeechRecognition`](https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition) interface to recognize the user's voice, match the words to a predefined script, and automatically scroll to the next unspoken position. 

Create a React Teleprompter using SpeechRecognition, string-similarity, and scrollIntoView

In this lesson we will start to create a terminal React application with [`react-blessed`](https://github.com/Yomguithereal/react-blessed), which is a custom renderer for React. If you already know how to use React with the DOM, then you should be able to leverage a lot of what you already know to build an app for the terminal.

Bootstrap a `react-blessed` Terminal Application

This code at this point in the React Terminal Dashboard series is minimal, but as code starts to accumulate it'll be helpful to statically analyze the validity of our code going forward with ESLint and several plugins that are specific to React.

Search Results