React is definitely one of the most talked about libraries on the web. It has become as popular as jQuery was in its prime, and more and more developers choose it to build the user interface of their web applications. Why has it become so popular? Why is this JavaScript library so innovative compared to others?

We will try to provide answers to these questions in this book by showing what the library offers, and by using it to build efficient web user interfaces.

In this chapter, we will introduce React and we will start building the basic infrastructure of a React-based application. Then, we will analyze how to design a user interface so that it can be easily mapped to React components, exploiting the best from React's internal architecture.

By the end of this chapter, you will be able to:

• Describe what React is and where it fits in the development of your applications
• Set up the infrastructure of a React-based application
• Design the UI of your application, optimizing it for use in React

To put it simply, React is a JavaScript library for building composable user interfaces. This means that we can build a user interface by composing items calledcomponents. A component is an element that contributes to building a user interface. It could be a textbox, a button, a whole form, a group of other components, and so on. Even the entire application's user interface is a component. So, React encourages the creation of components to build a user interface; it's even better if these components are reusable.

React components have the ability to present data that changes over time, and the visualization of that changing data is automatic when we follow a few guidelines.

Since the library deals with user interfaces, you may wonder which presentational design patterns React was inspired by:Model-View-Controller,Model-View-Presenter,Model-View-ViewModel, or something else. React is not bound to a specific presentational pattern. React implements theView part of the most common patterns, leaving developers free to choose the best approach to implement the model, the presenter, and everything else they need to build their application. This aspect is important, since it allows us to classify it as a library, not as a framework; therefore, comparisons with frameworks such as Angular may throw up some inconsistencies.

React is a JavaScript library, so we should be able to make a reference to it through a<script> tag in our HTML page and start writing our web application. However, this approach would prevent us from exploiting some features that are provided by a modern JavaScript development environment—features that make our lives easier. For example, we wouldn't be able to use recent features from ECMAScript 2015+, such as classes, modules, arrow functions,let andconst statements, and so on. Or, we could use those features, but only recent browsers would support them.

Fortunately, we can usecreate-react-app, acommand-line interface (CLI) tool that allows us to set up a React-based application without needing to configure any of the aforementioned tools. It is based on Node.js and provides commands to set up and modify a React application in an immediate way.

In order to installcreate-react-app, you need Node.js installed on your machine. You can install the CLI by typing the following command in a console window:

npm install -g create-react-app

After installation, you can verify whether it is properly installed by typing the following command:

create-react-app --version

If all is OK, the installed version ofcreate-react-app will be shown.

Now that the development environment is installed, let's create our first React application. We can do this by typing the following command in a console window:

create-react-app hello-react

This command tellscreate-react-app to set up all of the prerequisites for a React-based application namedhello-react. The creation process may take several minutes, since it has to download the npm packages needed for the project.

Scenario

We need to set up a development environment in order to create a product catalog application built with React.

Aim

The aim of the activity is to start becoming familiar withcreate-react-app and the content it creates.

Steps for Completion

1. Usecreate-react-app to create the development environment
2. Give the name my-shop to the sample application

Solution

There is no formal solution. You should focus on the content created by create-react-app, as we are going to analyze it in the following sections.

Let's take a look at the files generated bycreate-react-app, so that we can get an understanding of the structure of a React-based application. We will find these files and folders inside of theHELLO-REACT folder as shown in the following screenshot:

In the root folder, we can see aREADME.md file, thepackage.json file, and the .gitignore file.

TheREADME document contains references to all you need to start building a React-based application. It is written in Markdown format, and you can integrate or overwrite it with your own documentation.

Thepackage.json file contains information about the project, such as the name, the version, and so on, and references to all the npm packages used by the current project. This is a Node.js asset that allows you to download the required packages when copying the project to another machine. It also contains the definitions of scripts that allow us to manage the project itself.

The following is an example ofpackage.json file content:

{
  "name": "hello-react",
  "version": "0.1.0",
  "private": true,
  "dependencies": {
    "react": "^16.0.0",
    "react-dom": "^16.0.0",
    "react-scripts": "1.0.14"
  },
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test --env=jsdom",
    "eject": "react-scripts eject"
  }
}

As we can see, the file's content is a JSON object, with a few easy to recognize properties. In particular, we can identify the project's name, the version, and package dependencies. Apart from the name and version properties, usually, you don't need to manually change these settings.

The.gitignore file is a hidden file in Unix-based systems, and it allows us to track which file(s) to ignore when using Git as a version control system. Thecreate-react-app tool added this file because nowadays, it is essential to have a project under version control. It suggests Git, since it is one of the most popular version control systems.

Thepublic folder contains the static parts of our application:

• favicon: This is the icon shown in the browser's address bar and is used for bookmarks
• index.html: This is the HTML page containing the reference to our React code and providing a context to React rendering
• manifest.json: This is a configuration file containing metadata according to theProgressive Web Apps (PWA) criteria

In particular, theindex.html file is the starting point of our application. Let's take a look at it so that we can understand what's special about it:

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <meta name="theme-color" content="#000000">
    <link rel="manifest" href="%PUBLIC_URL%/manifest.json">
...
    <title>React App</title>
  </head>
  <body>
    <noscript>
      You need to enable JavaScript to run this app.
    </noscript>
  <div></div>
...
</html>

As we can see, it is a standard HTML page; however, a few things should be noted. First of all, we see a link to the manifest.json file:

<link rel="manifest" href="%PUBLIC_URL%/manifest.json">

This manifest contains metadata for configuring our app as a PWA.

The second thing we notice is the%PUBLIC_URL% placeholder in both link references:

<link rel="manifest" href="%PUBLIC_URL%/manifest.json">
<link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico">

This placeholder will be replaced with the actual URL of thepublic folder during the build process.

The body of the HTML page contains an emptydiv with a root identifier. This is an important item for the correct setup of our React application, as we will soon see. Apart from the<noscript> tag, we do not see any other element in the body. However, we need a binding between the HTML page and the JavaScript. The build process will be responsible for adding the required scripts to the body.

The most important folder for developing our application is thesrc folder. It contains the basic files, with the code that we can modify for our purposes.

In particular, we will find the following files:

• index.js: Contains the starting point of our application
• index.css: Stores the base styling for our application
• App.js: Contains the definition of the main component of the sample application
• App.css: Contains the styling of theApp component
• logo.svg: This is the React logo
• App.test.js: Stores the basic unit test involving theApp component
• registerServiceWorker.js: Contains the code to register the service worker in order to allow offline behavior, as per the PWA requirements

Let's analyze the content of a couple of these files, since their code is fundamental to understanding how the startup of a React application works.

Let's start with theindex.js file. Its content is shown as follows:

import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import App from './App';
import registerServiceWorker from './registerServiceWorker';

ReactDOM.render(<App />, document.getElementById('root'));
registerServiceWorker();

It is an ECMAScript 2015 module, importing other modules. In particular, it imports theReact andReactDOM objects from thereact andreact-dom modules, respectively. Both modules are part of the React library and are stored inside the node_modules folder.

Thereact module provides functionality for component creation and state management. Thereact-dom module is the glue between React components and the HTML DOM. The React library has been split into two modules in order to separate the component management from the actual rendering. This separation may be useful when we want to target a rendering platform that is not the web; for example, if we want to target native mobile rendering.

Other modules are imported from the same folder as theindex.js file. In particular, we import theApp component from theApp module. TheApp component is used by therender() method of theReactDOM object in order to bind it to thediv element in the HTML page. This magic is performed by the following statement:

ReactDOM.render(<App />, document.getElementById('root'));

For the moment, let's ignore the syntax used to render theApp component. This will be covered in the next chapter. The meaning of this statement is to associate the React App component defined inside theApp module with the HTML element identified by theroot ID.

TheregisterServiceWorker() function import and invocation enables the support for offline behavior, in line with the PWA specification, while the import ofindex.css makes the CSS styling available to the application.

TheApp.js file contains the definition of the React component representing the application. Its content looks like the following:

import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';

class App extends Component {
  render() {
    return (
      <div className="App">
        <header className="App-header">
          <img src={logo} className="App-logo" alt="logo" />
          <h1 className="App-title">Welcome to React</h1>
        </header>
        <p className="App-intro">
...
export default App;

Let's take a quick look at the code, since it will be covered in detail in the next chapter. For the moment, we only want to get a very basic idea of how a React component is defined. Here, we see a module importing a few items from other modules, defining theApp class by inheriting from theComponent class and exporting theApp class itself as a default export. That's all, for the moment. We will cover this code in depth in the nextchapter, understanding its meaning in detail.

Thecreate-react-app CLI provides a few commands to manage our React project. These commands appear in the formnpm <command>, since they are based on the npm.

The first command we will cover isnpm start. This command starts a development web server accepting requests athttp://localhost:3000.

So, after launching this command, we can open a browser and see the following result:

The development web server has a hot reloading system that allows us to change the code of our application and get the page refreshed in the browser after saving the file.

This following steps show how changing the content of a file causes the application to reload in the browser:

1. Open a console window.
2. Go to thehello-react folder.
3. Runnpm start.
4. Launch a browser and go tohttp://localhost:3000.
5. Launch a text editor and open theApp.js file.
6. Search for the following line of code:

To get started, edit <code>src/App.js</code> and save to reload.

7. Replace the code mentioned in step 6 with the following line of code:

Hello React!

8. Save the file.
9. Check the browser content. Now it should display the new text.

Scenario

We want to change the title of the application that was created in the previous activity.

Aim

The aim of the activity is to become familiar with launching an application and appreciating the hot reloading feature.

Steps for Completion

1. Start the application so that you can see it in a browser
2. Edit theApp.js file and set the title toMy Shop

Solution

There is no formal solution. You should focus on getting the title correctly changed and the application running.

create-react-app promotes the use of unit tests by generating a sample unit test file, as we have already seen, and by providing a set of tools to run such tests.

These tools are based onJest, and we can run the tests written within our application by running the following command:

npm test

This command will start running our test and will show the results, as shown in the following screenshot:

When we are ready to move our application into the production environment, we need the artifacts to publish. We can produce these artifacts by running the following command:

npm run build

The result of running this command is a newBUILD folder where we will find all of the files that we need to move into a production environment. The command carries out some processing on the files of our development environment. Put simply, it translates all of the ES2015 code we wrote into ES5 compatible code, so that it is also available for older browsers. This process is calledtranspilation. In addition, it reduces the size of the code itself, allowing for faster downloading over the network. This process is calledminification. Finally, it takes the files in our development environment and combines them into a few files, called bundles, in order to decrease network requests.

The following screenshot shows the content of theBUILD folder of the sample application:

To publish the production build of our application, we can just copy the content of theBUILD folder into the production server's folder.

The last command we will cover is theeject command:

npm run eject

We can use this command when we are confident in using the tools underlying create-react-app and we need to customize the environment configuration. This command takes our application out of the CLI context and gives us the power and responsibility to manage it.

Now, we are going to see how we can design our application so that it fits well when implemented with React.

The main concept introduced by React in user interface design and implementation is the component concept. A user interface is an aggregate of components, and the whole React application is an aggregate of components. We will now see in more detail what components are from a design point of view.

Consider a form in a web page. It can be treated as a component, since it has a specific role: to collect data and send it to the server. Also, a textbox inside the form can be considered a component. It has a specific role: to collect a single piece of data that will be sent to the server. So, a component may contain other components. And this is what usually happens: a user interface is a hierarchy of components, where some components contain other components.

Keep this concept in mind, since it will be useful to implement efficient and reusable user interfaces.

To better understand how to design a user interface and how to create components to implement them, we will try to decompose a well-known web user interface—the YouTube main page:

We can detect several items on this page, each having a specific role, starting with the page itself, whose role is to allow the user to interact with the system.

If we consider the header, the left sidebar, and the main area, all of these items are components of the page. You can see them highlighted in the following screenshot:

Of course, we can go ahead and detect other components. For example, we can consider each video preview box in the main area as a component. You can see them in the following screenshot:

This decomposition process allows us to focus on the specific role of each item in an interface, so that we can try to isolate each functionality and create reusable components, that is, components with just the dependencies that really matter.

We can classify the components in a user interface into container and presentational components.

The container components are components that do not have a relevant visual effect. Their main role is to group other components, that is,contain other components. For example, a form is usually a container component, since its main role is to contain other components, such as textboxes, labels, buttons, and so on.

The presentational components are components that display data in some graphical form. A textbox, a date picker, and a toolbar are examples of presentational components.

The distinction between container and presentational components is very important in order to create efficient user interfaces in React. We will exploit this distinction later, when we learn to manage the components' state and to propagate data through the components.

Scenario

In thischapter, we started to explore the React world. In particular, we:

• Established that React is a user interface library, used to implement the View part of various MV* design patterns
• Introduced thecreate-react-app tool, which helps us to set up a development environment to build React-based applications
• Explored the items composing a typical React-based application
• Analyzed the approach to designing user interfaces that best fits in the React world

In the nextchapter, we will discover how to create React components to build user interfaces for our application.