React.js for A Beginners Guide : From Basics to Advanced - A Comprehensive Guide to Effortless Web Development for Beginners, Intermediates, and Experts

By Daniel Walker

Take a comprehensive journey through the world of web development with React JS, from the basics to advanced techniques, with this all-in-one guide, "React.js for A Beginners Guide : From Basics to Advanced - A Comprehensive Guide to Effortless Web Development for Beginners, Intermediates, and Experts."

 

Key Features

• Up-to-Date: Constantly updated, the material in React Explained is always current.
• Clear instruction: You will follow plain English, clear visuals, and enjoyable step-by-step instructions.
• Hands-on learning: You will master React by building a complete React application.

This book starts with an introduction to React.js, explaining its key concepts and advantages. You'll learn why React.js is widely used in web development and how it simplifies the process of creating dynamic and interactive UIs.

The first few chapters guide you through setting up a React.js development environment and creating your first React.js application. You'll gain hands-on experience by working on sample programs and gradually understanding the fundamental building blocks of React components.

As you progress, the book covers important topics such as components and JSX syntax, state and props management, event handling, conditional rendering, working with lists, and handling forms and user input. Each chapter includes practical examples and sample programs to reinforce the concepts discussed.

You'll also explore advanced topics like React Router for implementing routing in your applications, lifecycle methods, React hooks for state management and side effects, styling options, Redux for advanced state management, and fetching data from APIs.

The book concludes with chapters on testing React components, deployment strategies, performance optimization techniques, and an appendix that provides additional resources, recommended books, websites, and tutorials for further learning, as well as useful React.js libraries and tools.

Whether you're a beginner looking to dive into React.js or a web developer seeking to enhance your skills, "React.js for A Beginners Guide : From Basics to Advanced - A Comprehensive Guide to Effortless Web Development for Beginners, Intermediates, and Experts.

 

Would You Like To Know More?

 

Click Buy Now With 1-Click or Buy Now to get started!

• Language: English
• Publisher: Orchid Publishing
• Release date: Nov 7, 2023
• ISBN: 9798223059158

Book preview

ReactJS

for

Beginners

line.jpg

From Basics to Advanced - A Comprehensive  Guide to Effortless Web Development for Beginners, Intermediates, and Experts

line.jpg

Daniel Walker

Table of Contents

Introduction : Before we start...............................................................6

Assumptions: Things to have before we start.......................................................6

Disclaimer................................................................................6

Building the simplest possible React app..........................................................8

What is React?.........................................................................8

Install React Developer Tools in your Browser................................................8

Let’s build the simplest possible React app...................................................8

Run our default React app and examine it in the browser.......................................15

Inspecting the app using React Developer Tools..............................................16

What happens when we run the npx create-react-app ?...............................17

Understanding our default React app’s folder and file structure..................................18

Inspecting the contents of package.json.....................................................21

Altering the default app.................................................................27

Chapter 1 Your first React Web Application..................................................40

Building Product Hunt......................................................................40

Setting up your development environment.........................................................9

Code editor............................................................................9

Special instruction for Windows users.....................................................11

JavaScript ES6/ES7....................................................................11

Getting started........................................................................12

What’s a component?...................................................................19

React the vote (your app’s first interaction)..................................................44

Updating state and immutability..........................................................56

Refactoring with the Babel plugin.........................................................63

Congratulations!.................................................................69

Components..............................................................................70

A time-logging app....................................................................70

Getting started...................................................................71

Breaking the app into components.............................................77

The steps for building React apps from scratch...............................85

Step 2: Build a static version of the app.......................................87

Step 3: Determine what should be stateful....................................96

Step 4: Determine in which component each piece of state should live.....98

Step 5: Hard-code initial states................................................100

Step 6: Add inverse data flow..................................................111

Updating timers.................................................................117

Deleting timers..................................................................124

Adding timing functionality....................................................128

Add start and stop functionality...............................................131

Methodology review............................................................138

Components & Servers...............................................................140

Introduction.....................................................................140

The Server API..................................................................141

Playing with the API............................................................144

Loading state from the server.................................................148

Sending starts and stops to the server.......................................156

Sending creates, updates, and deletes to the server........................159

Next up..........................................................................161

JSX and the Virtual DOM...................................................................162

React Uses a Virtual DOM.............................................................162

Why Not Modify the Actual DOM?......................................................162

What is a Virtual DOM?...............................................................163

Virtual DOM Pieces...................................................................163

JSX................................................................................171

References......................................................................181

Intro...............................................................................182

How to use this chapter................................................................183

Components.........................................................................184

Context.............................................................................190

Stateless Components.................................................................208

Talking to Children Components with.....................................................212

Summary........................................................................217

References......................................................................218

Forms..................................................................................219

Forms 101..........................................................................219

Text Input...........................................................................226

Remote Data.........................................................................258

Async Persistence....................................................................270

Redux..............................................................................281

Form Modules...................................................................296

Using Webpack with Create React App..........................................................299

Exploring Create React App............................................................300

Webpack basics......................................................................312

Making modifications to the sample app...................................................319

Creating a production build.............................................................322

Ejecting............................................................................326

Using Create React App with an API server................................................329

Webpack at large.....................................................................344

Unit Testing.............................................................................346

Writing tests without a framework........................................................346

What is Jest?........................................................................357

Using Jest...........................................................................358

Testing strategies for React applications...................................................366

Testing a basic React component with Enzyme..............................................369

Writing tests for the food lookup app.....................................................405

Further reading.......................................................................453

Routing.............................................................................455

What’s in a URL?....................................................................455

Dynamic routing with React Router......................................................496

Supporting authenticated routes..........................................................528

Recap..............................................................................545

Chapter 2 ReactJS - components...........................................................546

Chapter 3 ReactJS – Validate extensions....................................................552

Chapter 4  Component API...............................................................556

Chapter 5 Component life cycle............................................................561

Converts the function to a class...............................................................567

Add life cycle dependencies to the class.........................................................571

Use the case correctly......................................................................575

React incorporates status updates..............................................................577

Data flows to lower levels....................................................................579

Item variables............................................................................583

Chapter 6 Forms........................................................................590

Chapter 7  Fields in React................................................................595

Control ingredients........................................................................596

The textarea element.................................................................598

select.................................................................................599

Handling multiple entries...................................................................602

Justified entries with Null value...............................................................605

Alternatives to controlled ingredients...........................................................606

© Copyrıght 2023 by ORCHID PUBLISHING- All rıghts reserved.

Thıs document ıs geared towards provıdıng exact and relıable ınformatıon ın regards to the topıc and ıssue covered. The publıcatıon ıs sold wıth the ıdea that the publısher ıs not requıred to render accountıng, offıcıally permıtted, or otherwıse, qualıfıed servıces. If advıce ıs necessary, legal or professıonal, a practıced ındıvıdual ın the professıon should be ordered.

- From a Declaratıon of Prıncıples whıch was accepted and approved equally by a Commıttee of the Amerıcan Bar Assocıatıon and a Commıttee of Publıshers and Assocıatıons.

In no way ıs ıt legal to reproduce, duplıcate, or transmıt any part of thıs document ın eıther electronıc means or ın prınted format. Recordıng of thıs publıcatıon ıs strıctly prohıbıted and any storage of thıs document ıs not allowed unless wıth wrıtten permıssıon from the publısher. All rıghts reserved.

The ınformatıon provıded hereın ıs stated to be truthful and consıstent, ın that any lıabılıty, ın terms of ınattentıon or otherwıse, by any usage or abuse of any polıcıes, processes, or dırectıons contaıned wıthın ıs the solıtary and utter responsıbılıty of the recıpıent reader. Under no cırcumstances wıll any legal responsıbılıty or blame be held agaınst the publısher for any reparatıon, damages, or monetary loss due to the ınformatıon hereın, eıther dırectly or ındırectly.

Respectıve authors own all copyrıghts not held by the publısher.

The ınformatıon hereın ıs offered for ınformatıonal purposes solely, and ıs unıversal as so. The presentatıon of the ınformatıon ıs wıthout contract or any type of guarantee assurance.

The trademarks that are used are wıthout any consent, and the publıcatıon of the trademark ıs wıthout permıssıon or backıng by the trademark owner.

All trademarks and brands wıthın thıs book are for clarıfyıng purposes only and are the owned by the owners themselves, not affılıated wıth thıs document.

About Author

––––––––

Daniel Walker is a front-end developer, product designer, and tech evangelist. He has worked with numerous technologies over the years. Currently, he is working with HTML, CSS, JavaScript, and React. He absolutely loves sharing his knowledge with people interested in front-end development. He has more than 3000 hours of fresher training experience. He also has online courses with more than 1.7 million enrollments.

Disclaimer

––––––––

While all attempts have been made to verify the information provided in this book, the author does assume any responsibility for errors, omissions, or contrary interpretations of the subject matter contained within. The information provided in this book is for educational and entertainment purposes only.

The reader is responsible for his or her own actions and the author does not accept any responsibilities for any liabilities or damages, real or perceived, resulting from the use of this information.

The trademarks that are used are without any consent, and the publication of the trademark is without permission or backing by the trademark owner. All trademarks and brands within this book are for clarifying purposes only and are the owned by the owners themselves, not affiliated with this document.

Introduction : Before we start

Prerequisites: Items to have in place before beginning

If you’re starting this book, I expect you at least have Node.js and NPM installed on your machine.

If you’re unsure of what Node.js is or how it works, please refer to this article.

If you need to install Node.js on your machine, please read my article on installing Node.js on Ubuntu 18.04. Although the software versions might be different, the basics of this installation should be almost the same.

For more info, please refer to the official Node.js website.

I’m also assuming that you did use a code editor before, and that you’re comfortable, or at least familiar with VS Code. If not, then this book might be too advanced for you - but still, give it a try. I’ve written it with the intention of making it accessible even for almost a complete web development beginner.

Still, a level of knowledge of HTML, CSS, and JS will go a long way.

The more you know the above three technologies, the easier this book will be.

Addendum: I’ve decided to focus on working with CodeSandbox a lot more in this book. The reason why: it’s really easy to hit the ground running, for the following reasons:

You only need a browser and an internet connection

You can easily fork whatever CodeSandbox project is needed

It’s got almost the same workflow as a local VS Code setup - so the switch is almost seamless

You’ve got built-in GitHub support, meaning: you can commit your changes directly from CodeSandbox, which makes for a very smooth workflow

What this means for you? Well, it means that there’ll be an interesting mix of local development and online PaaS-powered development in this book. This will not make it harder to learn the subject, though. On the contrary, it should make it easier, more productive, and less time-consuming. This is the result of my constant striving of building as good of learning resources as possible.

Disclaimer

Here goes the not-so-obligatory information that most people skip - but, I kept it really short and sweet - under one page.

Give it a try - I’ve tried my best to give you some context in this section and some of my thoughts before we go into the topic of the book.

Here goes.

I’ve tried my best to make this book a success.

But, I’m only another guy, and, like the vast majority of people, I do make mistakes.

I hope that you, dear reader, will be able to appreciate the intention and the effort I have put into writing this book. It is a product of many, many hours spent in front of a computer monitor, either writing about code, thinking about code, debugging some code, or just plain coding. I don’t take this effort lightly. It’s my source of pride - and the reason why I feel competent to write this book.

I’d say I’m way past the 10 thousand hours of deliberate practice, the concept popularised by Malcolm Gladwell in his book Outliers.

So, who am I and why should you listen to my advice?

Well, I’ve already sort of answered that question above. I’m just another guy; a self-taught web developer who has spent years mastering my craft.

In some parts of the web development world, I’m a seasoned veteran. In some other parts of it, I’m a newbie.

I’m not a know-it-all, if such a person exists.

But I have dedicated a large part of my professional career to writing tutorials on web development, writing books about it, and thinking about best ways to transfer knowledge. Reading up on it too!

So I’d say I’ve become competent to teach this subject, based on my experience.

If you find this book not to your liking, luckily, Leanpub has a really generous 60-day return policy. You might say that’s as risk-free as it can get. You can’t really say that it cost a fortune to begin with, and the return policy is working in your favor anyway. So if you strongly feel that this book is doing you no good - please, by all means, return it. No reason to get worked up about it, either on my side or on yours.

If you have complaints about the book, please write to me at [e-mail] and I’ll do my best to deal with the issue.

Also, any comments and kind words, as well as harsh criticisms, are all welcome.

Kind words from readers mean a lot.

Harsh criticisms, while I do find them usually not really neccessary, are a way to point me in the right direction - and ultimately help me become a better technical writer and a better developer.

So I thank you either way.

Chapter 1 Your first React Web Application

Building Product Hunt

In this chapter, you’re going to get a crash course on React by building a simple voting application inspired by Product Hunt¹³. You’ll become familiar with how React approaches front-end development and all the fundamentals necessary to build an interactive React app from start to finish. Thanks to React’s core simplicity, by the end of the chapter you’ll already be well on your way to writing a variety of fast, dynamic interfaces.

Page |  

Completed version of the app

We’ll focus on getting our React app up and running fast. We take a deeper look at concepts covered in this section throughout the book.

Configuring the environment for development

Code editor

As you’ll be writing code throughout this book, you’ll need to make sure you have a code editor you’re comfortable working with. If you don’t already have a preferred editor, we recommend installing VS Code¹⁴.

Page |  

Node.js and npm

For all the projects in this book, we’ll need to make sure we have a working Node.js¹⁵ development environment along with npm.

There are a couple different ways you can install Node.js so please refer to the Node.js website for detailed information: https://nodejs.org/download/¹⁶

If you’re on a Mac, your best bet is to install Node.js directly from the Node.js website instead of through another package manager (like Homebrew). Installing Node.js via Homebrew is known to cause some issues.

The Node Package Manager (npm for short) is installed as a part of Node.js. To check if npm is available as a part of our development environment, we can open a terminal window and type:

1 $ npm -v

If a version number is not printed out and you receive an error, make sure to download a Node.js installer that includes npm.

Install Git

The app in this chapter requires Git to install some third-party libraries.

If you don’t have Git installed, see these instructions¹⁷ for installing Git for your platform.

After installing Git, we recommend restarting your computer.

Browser

Last, we highly recommend using the Google Chrome Web Browser¹⁸ to develop React apps. We’ll use the Chrome developer toolkit throughout this book. To follow along with our development and debugging we recommend downloading it now.

Page |  

Particular guidance for Windows users

All the code in this book has been tested on Windows 10 with PowerShell.

Ensure IIS is installed

If you’re on a Windows machine and have yet to do any web development on it, you may need to install IIS (Internet Information Services) in order to run web servers locally.

See this tutorial¹⁹ for installing IIS.

JavaScript ES6/ES7

JavaScript is the language of the web. It runs on many different browsers, like Google Chrome, Firefox, Safari, Microsoft Edge, and Internet Explorer. Different browsers have different JavaScript interpreters which execute JavaScript code.

Its widespread adoption as the internet’s client-side scripting language led to the formation of a standards body which manages its specification. The specification is called ECMAScript or ES.

The 5th edition of the specification is called ES5. You can think of ES5 as a version of the JavaScript programming language. Finalized in 2009, ES5 was adopted by all major browsers within a few years.

The 6th edition of JavaScript is referred to as ES6. Finalized in 2015, the latest versions of major browsers are still finishing adding support for ES6 as of 2017. ES6 is a significant update. It contains a whole host of new features for JavaScript, almost two dozen in total. JavaScript written in ES6 is tangibly different than JavaScript written in ES5.

ES7, a much smaller update that builds on ES6, was ratified in June 2016. ES7 contains only two new features.

Page |  

As the future of JavaScript, we want to write our code in ES6/ES7 today. But we also want our JavaScript to run on older browsers until they fade out of widespread use. We see later in this chapter how we can enjoy the benefits of ES6/ES7 today while still supporting the vast majority of the world’s browsers.

This book is written with JavaScript ES7. Because ES6 ratified a majority of these new features, we’ll commonly refer to these new features as ES6 features.

We’ve included an appendix on the ES6 syntax that we use, Appendix B: ES6. We’ll often refer to the appendix when encountering ES6 syntax for the first time, but if ever syntax seems unfamiliar to you it’s worth checking Appendix B to see if it’s new ES6 JavaScript syntax.

ES6 is sometimes referred to as ES2015, the year of its finalization. ES7, in turn, is often referred to as ES2016.

––––––––

Getting started

Sample Code

All the code examples you find in each chapter are available in the code package that came with the book. In that code package you’ll find completed versions of each app as well as boilerplates that we will use to build those apps together. Each chapter provides detailed instruction on how to follow along on your own.

While coding along with the book is not necessary, we highly recommend doing so. Playing around with examples and sample code will help solidify and strengthen concepts.

Previewing the application

We’ll be building a basic React app that will allow us to touch on React’s most important concepts at a high-level before diving into them in subsequent sections. Let’s begin by taking a look at a working implementation of the app.

Open up the sample code folder that came with the book. Change to the voting_app/

directory in the terminal:

Page |  

$ cd voting_app/

––––––––

If you’re not familiar with cd, it stands for change directory. If you’re on a Mac, do the following to open terminal and change to the proper directory:

Open up /Applications/Utilities/Terminal.app.

Type cd, without hitting enter.

Tap the spacebar.

In the Finder, drag the voting_app/ folder on to your terminal window.

Hit Enter.

Your terminal is now in the proper directory.

––––––––

Throughout the book, a code block starting with a $ signifies a command to be run in your terminal.

––––––––

First, we’ll need to use npm to install all our dependencies:

$ npm install

With our dependencies installed, we can boot the server using the npm start

command

$ npm start

The boot process will print some text to the console:

Page |  

Boot process output

In addition, your browser might automatically launch and open the app. If it doesn’t, you can view the running application at the URL http://localhost:3000:

Completed version of the app

This demo app is a site like Product Hunt²⁰ or Reddit²¹. These sites have lists of links that users can vote on. Like those sites, in our app we can up-vote products. All

Page |  

products are sorted instantaneously by number of votes.

The keyboard command to quit a running Node server is CTRL+C.

Prepare the app

In the terminal, run ls to see the project’s layout:

$ ls README.md

disable-browser-cache.js nightwatch.json node_modules/ package.json

public/ tests/

––––––––

If you’re running on macOS or Linux, you can run ls -1p to format your output as we do above.

––––––––

Node apps contain a package.json which specifies the dependencies of the project. When we ran npm install, npm used our package.json to determine which dependencies to download and install. It installed them to the folder node_modules/.

We explore the format of package.json in later chapters.

––––––––

The code we’ll be working with is inside the folder public/. Look inside that folder:

Page |  

$ ls public favicon.ico images/ index.html js/

semantic-dist/ style.css vendor/

The general layout here is a common one for web apps. Inside public/ is index.html, the file that we serve to browsers that request our website. As we’ll see shortly, index.html is the centerpiece of our app. It loads in the rest of our app’s assets.

Let’s look inside public/js next:

$ ls public/js app-1.js

app-2.js app-3.js app-4.js app-5.js app-6.js app-7.js app-8.js app-9.js

app-complete.js app.js

seed.js

Inside public/js is where we’ll put our app’s JavaScript. We’ll be writing our React app inside app.js. app-complete.js is the completed version of the app that we’re working towards, which we viewed a moment ago.

In addition, we’ve included each version of app.js as we build it up throughout this chapter (app-1.js, app-2.js, etc). Each code block in this chapter will reference which app version you can find it in. You can copy and paste longer code insertions from these app versions into your app.js.

Page |  

All projects include a handy README.md that have instructions on how to run them.

––––––––

To get started, we’ll ensure app-complete.js is no longer loaded in index.html. We’ll then have a blank canvas to begin work inside app.js.

Open up public/index.html in your text editor. It should look like this:

voting_app/public/index.html

<html>

<head>

charset=utf-8>

<title>Project One</title>

rel=stylesheet href=./semantic-dist/semantic.css />

rel=stylesheet href=./style.css />

src=vendor/babel-standalone.js></script>

src=vendor/react.js></script>

src=vendor/react-dom.js></script>

</head>

<body>

class=main ui text container>

class=ui dividing centered header>Popular Products</h1>

id=content></div>

</div>

src=./js/seed.js></script>

src=./js/app.js></script>

type=text/babel

data-plugins=transform-class-properties src=./js/app-complete.js

></script>

</body>

Page |  

</html>

We’ll go over all the dependencies being loaded under the tag later. The heart of the HTML document is these few lines here:

voting_app/public/index.html

class=main ui text container>

class=ui dividing centered header>Popular Products</h1>

id=content></div>

</div>

––––––––

For this project, we’re using Semantic UI²² for styling.

Semantic UI is a CSS framework, much like Twitter’s Bootstrap²³. It provides us with a grid system and some simple styling. You don’t need to know Semantic UI in order to use this book. We’ll provide all the styling code that you need. At some point, you might want to check out the docs Semantic UI docs²⁴ to get familiar with the framework and explore how you can use it in your own projects.

The class attributes here are just concerned with style and are safe to ignore. Stripping those away, our core markup is succinct:

<div>

<h1>Popular Products</h1>

id=content></div>

</div>

We have a title for the page (h1) and a div with an id of content. This div is where we will ultimately mount our React app. We’ll see shortly what that means.

The next few lines tell the browser what JavaScript to load. To start building our own application, let’s remove the ./app-complete.js script tag completely:

²²http://semantic-ui.com/

²³http://getbootstrap.com/

²⁴http://semantic-ui.com/introduction/getting-started.html

Page |  

type=text/babel

data-plugins=transform-class-properties

src=./js/app-complete.js

>

After we save our updated index.html and reload the web browser, we’ll see that our app has disappeared.

What’s a component?

Building a React app is all about components. An individual React component can be thought of as a UI component in an app. We can break apart the interface of our app into two classes of components:

The app’s components

We have a hierarchy of one parent component and many child components. We’ll call these ProductList and Product, respectively:

Page |  

ProductList: Contains a list of product components

Product: Displays a given product

Not only do React components map cleanly to UI components, but they are self- contained. The markup, view logic, and often component-specific style is all housed in one place. This feature makes React components reusable.

Furthermore, as we’ll see in this chapter and throughout this book, React’s paradigm for component data flow and interactivity is rigidly defined. In React, when the inputs for a component change, the framework simply re-renders that component. This gives us a robust UI consistency guarantee:

With a given set of inputs, the output (how the component looks on the page) will always be the same.

Our first component

Let’s start off by building the ProductList component. We’ll write all our React code for the rest of this chapter inside the file public/js/app.js. Let’s open app.js and insert the component:

voting_app/public/js/app-1.js

class ProductList extends React.Component { render() {

return (

Hello, friend! I am a basic React component.

);

}

}

React components are ES6 classes that extend the class React.Component. We’re referencing the React variable. index.html loads the React library for us so we’re able to reference it here:

Page |  

voting_app/public/index.html

src=vendor/react.js></script>

Our ProductList class has a single method, render(). render() is the only required method for a React component. React uses the return value from this method to determine what to render to the page.

While JavaScript is not a classical language, ES6 introduced a class declara- tion syntax. ES6 classes are syntactical sugar over JavaScript’s prototype- based inheritance model.

We cover the important details you need to know about classes with respect to building React components. If you’d like to learn more about ES6 classes, refer to the docs on MDN²⁵.

––––––––

There are two ways to declare React components:

As ES6 classes (as above)

Function components

An example of using an ES6 class:

class HelloWorld extends React.Component { render() { return

Hello, world!

; }

}

The same component written in a functional component style:

function HelloWorld() {

return

Hello, world!

;

}

At the time of writing, both types of declarations are in widespread use. While they both do essentially the same thing, there are some important differences that we’ll get to later in the book.

Page |  

If you have some familiarity with JavaScript, the return value may be surprising:

voting_app/public/js/app-1.js

return (

Hello, friend! I am a basic React component.

);

The syntax of the return value doesn’t look like traditional JavaScript. We’re using JSX (JavaScript eXtension syntax), a syntax extension for JavaScript written by Facebook. Using JSX enables us to write the markup for our component views in a familiar, HTML-like syntax. In the end, this JSX code compiles to vanilla JavaScript. Although using JSX is not a necessity, we’ll use it in this book as it pairs really well with React.

If you don’t have much familiarity with JavaScript, we recommend you follow along and use JSX in your React code too. You’ll learn the boundaries between JSX and JavaScript with experience.

––––––––

JSX

React components ultimately render HTML which is displayed in the browser. As such, the render() method of a component needs to describe how the view should be represented as HTML. React builds our apps with a fake representation of the Document Object Model (DOM). React calls this the virtual DOM. Without getting deep into details for now, React allows us to describe a component’s HTML representation in JavaScript.

Page |  

The Document Object Model (DOM) refers to the browser’s HTML tree that makes up a web page.

––––––––

JSX was created to make this JavaScript representation of HTML more HTML-like. To understand the difference between HTML and JSX, consider this JavaScript syntax:

React.createElement('div', {className: 'ui items'}, 'Hello, friend! I am a basic React component.'

)

Which can be represented in JSX as:

Hello, friend! I am a basic React component.

The code readability is slightly improved in the latter example. This is exacerbated in a nested tree structure:

React.createElement('div', {className: 'ui items'},

React.createElement('p', null, 'Hello, friend! I am a basic React com\ ponent.')

)

In JSX:

Hello, friend! I am a basic React component.

JSX presents a light abstraction over the JavaScript version, yet the legibility benefits are huge. Readability boosts our app’s longevity and makes it easier to onboard new developers.

Page |  

Even though the JSX above looks exactly like HTML, it’s important to remember that JSX is actually just compiled into JavaScript (ex: React.createElement('div')).

During runtime React takes care of rendering the actual HTML in the browser for each component.

––––––––

The console for developers

Our first component is written and we now know that it uses a special flavor of JavaScript called JSX for improved readability.

After editing and saving our app.js, let’s refresh the page in our web browser and see what changed:

Nothing?

Every major browser comes with a toolkit that helps developers working on JavaScript code. A central part of this toolkit is a console. Think of the console as JavaScript’s primary communication medium back to the developer. If JavaScript encounters any errors in its execution, it will alert you in this developer console.

Our web server, live-server, should refresh the page automatically when it detects that app.js has changed.

Page |  

To open the console in Chrome, navigate to View > Developer > JavaScript Console.

Or, just press Command + Option + J on a Mac or Control + Shift + L on Windows/Linux.

Opening the console, we are given a cryptic clue:

Uncaught SyntaxError: Unexpected token <

Error in the console

This SyntaxError prevented our code from running. A SyntaxError is thrown when the JavaScript engine encounters tokens or token order that doesn’t conform to the syntax of the language when parsing code. This error type indicates some code is out of place or mistyped.

The issue? Our browser’s JavaScript parser tripped when it encountered the JSX. The parser doesn’t know anything about JSX. As far as it is concerned, this < is completely out of place.

As we discussed, JSX is an extension to standard JavaScript. Let’s have our browser’s JavaScript interpreter use this extension.

Page |  

Babel

We mentioned at the beginning of the chapter that all the code in the book would be using ES6 JavaScript. However, most browsers in use today do not fully support ES6.

Babel is a JavaScript transpiler. Babel turns ES6 code into ES5 code. We call this process transpiling. So we can enjoy the features of ES6 today yet ensure our code still runs in browsers that only support ES5.

Another handy feature of Babel is that it understands JSX. Babel compiles our JSX into vanilla ES5 JS that our browser can then interpret and execute. We just need to instruct the browser that we want to use Babel to compile and run our JavaScript code.

The sample code’s index.html already imports Babel in the head tags of index.html:

<head>

src=vendor/babel-standalone.js></script>

</head>

All we need to do is tell our JavaScript runtime that our code should be compiled by Babel. We can do this by setting the type attribute when we import the script in index.html to text/babel.

Open index.html and change the script tag that loads ./js/app.js. We’re going to add two attributes:

data-plugins=transform-class-properties src=./js/app.js

>

The attribute type=text/babel indicates to Babel that we would like it to handle the loading of this script. The attribute data-plugins specifies a special Babel plugin we use in this book. We discuss this plugin at the end of the