React Router v5

Learning Goals:

• Understand and articulate the need for routing
• Be able to confidently implement React Router in a project
• Utilize URL params to build dynamic routes

Vocab

• BrowserRouter A <Router> that uses the HTML5 history API to keep your UI in sync with the URL
• Router The class that <BrowserRouter> is extended from
• Route Its most basic responsibility is to render some UI when a location matches the route’s path
• Link Links provide declarative, accessible navigation around your application
• NavLink A special version of the <Link> that will add styling attributes to the rendered element when it matches the current URL.
• Redirect Rendering a <Redirect> will navigate to a new location. The new location will override the current location in the history stack, like server-side redirects (HTTP 3xx) do.
• Switch Renders the first child <Route> or <Redirect> that matches the location. <Switch> is unique in that it renders a route exclusively (only one route wins).
• match A match object contains information about how a <Route path> matched the URL.

React Router

Why Routing?

Routing refers to keeping a webpage up to date with the current URL, and vice-versa.

Most of the apps you’ve written so far have been single-page applications. One HTML page whose content is updated through user interactions and JS. These DO NOT use routing.They work fine, but put some limits on the user experience of our applications.

If you have written a multi-page application, you may have wrestled with Webpack configs in order to get all your pages built successfully. Fortunately, routing with React is easier than managing Webpack configuration! We just need to use a library called React Router.

The Code

Rather than tell you about how Router works, we’ll work through a series of exercises and examples.

We’ll be using this repo to solve a series of challenges listed below.

Installation Instructions

git clone https://github.com/turingschool-examples/react-router-v5
cd react-router-v5
npm i
npm start

The App is not fully put together. It has a series of components that will serve as building blocks of the final component. You won’t be building out new components, but you will be editing existing ones.

Setting up Router

Before we break out into groups, we’ll review how to set up Router as a class.

The <Home /> component is rendering a welcome message. Right now, nothing but a nav bar is being rendered by the App. Let’s use router to render the <Home /> component as a landing page.

Remember that React Router conditionally renders components based on the current URL. So our goal is to render the component when the user is at the base URL.

Getting Started

To use React Router, we need to wrap any components that will use a React-Router-provided-component with a Router component.

We’ll use a Browser Router component because our app will be used in the browser. This Router provides access to the HTML5 History API. But we won’t worry about those details just yet.

npm install react-router-dom@5.3.0

// index.js

import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import App from './App/App';
import { BrowserRouter } from 'react-router-dom';

const router = <BrowserRouter> <App /> </BrowserRouter>;

ReactDOM.render(router, document.getElementById('root'));

import React, { Component } from 'react';
import './App.css';
import puppies from '../data/puppy-data.js';
import sharks from '../data/shark-data.js';
import Creatures from '../Creatures/Creatures';
import Home from '../Home/Home';
import CreatureDetails from '../Creatures/CreatureDetails';
import { Route } from 'react-router-dom';


export default class App extends Component {
  render() {
    return (
      <main className="App">
        <nav>
          <a href="/puppies" className="nav">Puppies</a>
          <a href="/sharks" className="nav">Sharks</a>
        </nav>
        <h1>Puppies or Sharks?</h1>
        <Route path="/" component={ Home }/>
      </main>
    );
  }
}

Exercise # 1: Render Puppies

Your goal is click on the word Puppies and see a grid of 9 puppies on the DOM. The page should look something like the picture on the lesson plan. While you may change components as needed, you shouldn’t outright delete content from the page to achieve this.

/ App.js

import './App.css';
import puppies from '../data/puppy-data.js';
import sharks from '../data/shark-data.js';
import Creatures from '../Creatures/Creatures';
import Home from '../Home/Home';
import { Route, NavLink } from 'react-router-dom';


export default class App extends Component {
  render() {
    return (
      <main className="App">
        <nav>
          <NavLink to="/puppies" className="nav">Puppies</NavLink>
          <NavLink to="/sharks" className="nav">Sharks</NavLink>
        </nav>
        <h1>Puppies or Sharks?</h1>
        <Route path="/" component={ Home }/>
        <Route path="/puppies" render={() => <Creatures name="puppies" data={puppies} />} />
      </main>
    );
  }
}

Render exact matches

Check out what happens when you add the exact prop into one of your Routes.

The exact prop can be used to make sure that partial matches of a URL don't trigger a render.

Render Methods

According to the docs, Routes have three possible methods for rendering a component on match:

• component
• render
• children

We recommend to use render or children – they work more efficiently when re-rendering components. We’ll take a look at some more benefits they provide after the next exercise.

Here’s an example of their syntax: Component

<Route path='/unicorns' component={ Unicorns } />

Render

<Route path='/unicorns' render={ () => <Unicorns /> }

This also allows you to define and pass specific properties to a component dynamically. For example:

<Route path='/ideas/:id' render={({ match }) => {
  const idea = ideas.find(idea => idea.id === parseInt(match.params.id));

  if (!idea) {
    return (<div>This idea does not exist! </div>);  
  }
  return <ListItem match={match} {...idea} />

}} />

Children children works exactly like render except that it gets called whether the path is a match or not.

<Route path='/other-unicorns' children={ () => <Unicorns /> } />

Exercise # 2: Rendering Sharks

Get the sharks link working as well!

// App.js
import './App.css';
import puppies from '../data/puppy-data.js';
import sharks from '../data/shark-data.js';
import Creatures from '../Creatures/Creatures';
import Home from '../Home/Home';
import { Route, NavLink } from 'react-router-dom';

export default class App extends Component {
  render() {
    return (
      <main className="App">
        <nav>
          <NavLink to="/puppies" className="nav">Puppies</NavLink>
          <NavLink to="/sharks" className="nav">Sharks</NavLink>
        </nav>
        <h1>Puppies or Sharks?</h1>
        <Route exact path="/" render={ Home }/>
        <Route exact path="/puppies" render={() => <Creatures name="puppies" data={puppies} />} />
        <Route exact path="/sharks" render={() => <Creatures name="sharks" data={sharks} />} />
      </main>
    );
  }
}

Route Props

Let’s take a close look at what happens when a Route renders.

Route render methods all provide access to route props, either automatically to the component they render, or via the callback function that the methods take.

These props include:

• history
• location
• match

<Route path='/unicorns' render={ ({ history, location, match }) => <Unicorns /> }

history and location are worth looking into on your own, but today we’ll focus on match.

The match gives us information about how and why the application matched. And it allows us to do some pretty cool stuff.

<Route path="/puppies" render={({ match }) => { console.log(match)}} />

<Route path="/:animal" render={({ match }) => { console.log(match)}} />

match.params

The params property of the match prop gives us an object with key value pairs of dynamic URL parameters, and any strings that match them.

For instance, we could make our routes for animals more dynamic by doing this:

<Route
  exact path="/:animal"
  render={({ match }) => {
    const whichAnimal = match.params.animal === 'sharks' ? sharks : puppies
    return <Creatures name={match.params.animal} data={whichAnimal} />
  }}
/>

and then navigate to either /puppies or /sharks, we can see that the <Creatures /> component is rendering the correct data based on the params from the URL.

params allows us to define shapes of a URL that will cause a match, then access the data from that URL in our components.

This can be great for dynamically rendering content based on things in the URL, like an id. Let’s do that!

Exercise #3: Dynamic Routing

Take a look at the CreatureDetails Component. It takes in all data for a given creature, and displays it on the page.

// **Creature.js**
// ...
const Creatures = ({ data, name }) => {
  const creatureImages = data.map(creature => {
    const { id, image } = creature;
    return (
      <NavLink key={id} to={`/${name}/${id}`}>
        <img src={image} alt={name} className="app-img" />
      </NavLink>
    );
  });
// ...
  
// **App.js**
// ...
<Route
  exact path="/puppies/:id"      
  render={({match}) => {
    const creatureToRender = puppies.find(creature => creature.id === parseInt(match.params.id));   
    return <CreatureDetails {...creatureToRender} />
  }}
/>
// ...

Extra Resources:

Tutorials / Guides:

• React Training’s 13 minute overview of React Router
• A Beginner’s Tutorial - 5 Minutes
• Router Cheatsheet

Helpful Articles / Docs:

• Routing and Form Submission

<Link to='/unicorns' />

<Link to='/unicorns'> Unicorns </Link>

<NavLink to='/about'>About</NavLink>

<Redirect to='/not/unicorns' />

<Switch>
  <Route exact path='/' component={Home} />
  <Route path='/users/add' component={UserAddPage} />
  <Route path='/users' component={UsersPage} />
  <Redirect to='/' />
</Switch>