Modern JavaScript Web Development Cookbook

By : Federico Kereki

Modern JavaScript Web Development Cookbook

By: Federico Kereki

Overview of this book

JavaScript has evolved into a language that you can use on any platform. Modern JavaScript Web Development Cookbook is a perfect blend of solutions for traditional JavaScript development and modern areas that developers have lately been exploring with JavaScript. This comprehensive guide teaches you how to work with JavaScript on servers, browsers, mobile phones and desktops. You will start by exploring the new features of ES8. You will then move on to learning the use of ES8 on servers (with Node.js), with the objective of producing services and microservices and dealing with authentication and CORS. Once you get accustomed to ES8, you will learn to apply it to browsers using frameworks, such as React and Redux, which interact through Ajax with services. You will then understand the use of a modern framework to develop the UI. In addition to this, development for mobile devices with React Native will walk you through the benefits of creating native apps, both for Android and iOS. Finally, you’ll be able to apply your new-found knowledge of server-side and client-side tools to develop applications with Electron.

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

Free Chapter

Working with JavaScript Development Tools

Introduction

Installing Visual Studio Code for development

Extending Visual Studio Code

Adding Fira Code font for better editing

Adding npm for package management

Doing version control with Git

Formatting your source code with Prettier

Documenting your code with JSDoc

Adding code quality checks with ESLint

Adding Flow for data types checks

Using Modern JavaScript Features

Programming functionally

Doing async calls compactly

Working with objects and classes

Organizing code in modules

Determining a feature's availability

Developing with Node

Introduction

Checking Node's setup

Working with modules

Using Flow with Node, directly

Using Flow with Node through preprocessing

Running your Node code with Nodemon

Using promises instead of error first callbacks

Working with streams to process requests

Compressing files with streams

Working with a database

Executing external processes with exec()

Using spawn() to run a command, and communicating with it

Using fork() to run Node commands

Implementing RESTful Services with Node

Introduction

Developing a server with Express

Adding middleware

Getting request parameters

Serving static files

Adding routes

Implementing secure connections

Adding security safeguards with Helmet

Implementing CORS

Adding authentication with JWT

Tying it all together – building a REST server

Testing and Debugging Your Server

Introduction

Adding logging with Winston

Adding HTTP logging with Morgan

Configuring your server for different environments

Unit testing your code

Measuring your test coverage

Debugging your code

Testing simple services from the command line

Testing more complex sequences of calls with Postman

Documenting and testing your REST API with Swagger

Developing with React

Introduction

Starting out with React

Reinstalling your tools

Defining components

Handling state

Composing components

Handling life cycle events

Simplifying component development with Storybook

Enhancing Your Application

Introduction

Adding SASS for separate styling

Creating StyledComponents for inline styling

Making your application responsive to screen sizes

Making your application adaptive for enhanced usability

Making a global application with internationalization and localization

Setting up for accessibility (a11y)

Expanding Your Application

Introduction

Managing state with Redux

Doing async actions with redux-thunk

Adding routing with react-router

Adding authorization to routes

Code splitting for performance

Debugging Your Application

Introduction

Logging with style

Debugging with the React Developer Tools

Debugging with the standalone tool

Logging Redux with redux-logger

Debugging Redux with the Redux Developer Tools

Connecting routing for debugging

Testing Your Application

Introduction

Testing components with Jest and Enzyme

Testing reducers and mappings

Testing actions and thunks

Testing changes with Snapshots

Measuring test coverage

Creating Mobile Apps with React Native

Introduction

Setting things up

Adding development tools

Using native components

Adapting to devices and orientation

Styling and laying out your components

Adding platform-specific code

Routing and navigating

Testing and Debugging Your Mobile App

Introduction

Writing unit tests with Jest

Adding snapshot testing

Measuring test coverage

Using Storybook to preview components

Debugging your app with react-native-debugger

Debugging in an alternate way with Reactotron

Creating a Desktop Application with Electron

Introduction

Setting up Electron with React

Adding Node functionality to your app

Building a more windowy experience

Testing and debugging your app

Making a distributable package

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

4 star

3 star

2 star

1 star

What this book covers

In this book, we will cover several subjects and the book is divided into five parts. In part
one, in the first two chapters we'll get an overview of JavaScript tools and features:

Chapter 1, Working with JavaScript Development Tools, is where we'll study and install several tools that will help our development, such as Visual Studio Code for development, npm for package management, Git for version control, Prettier for source code formatting, ESLint for code quality checks, and Flow for data type checks, among others.
Chapter 2, Using Modern JavaScript Features, we will see how to use types in your code, and also go into more recent additions to JavaScript, dealing with strings, scopes, functions, async calls, class-oriented programming, modules, and even a touch of Functional Programming (FP).

In part two, the next three chapters, we'll move on to developing server-side code using Node, ending by writing a complete RESTful server:

Chapter 3, Developing with Node, covers the basics of Node, and learn how to use JavaScript for server development. We'll cover themes such as streaming, accessing databases, and executing external processes, among others.
Chapter 4, Implementing RESTful Services with Node, we'll see how to develop a server with Express, serving static files, and dealing with Cross-Origin Resource Sharing (CORS) permissions and with authentication rules, tying it all together by building a RESTful set of services.
Chapter 5, Testing and Debugging Your Server, will teach you how to debug your code and write unit tests for it by using more tools, including Winston, Morgan, Jest, Postman, and Swagger.

After having worked on the server, we'll move to browsers, which makes up part three of this book. We devote the next five chapters to developing web applications with React and using the server we just developed as our backend, so we'll be going full stack with our development:

Chapter 6, Developing with React, we'll learn about the React framework, set it up to use the development tools, and then we'll create a Single Page Application (SPA), which we'll expand in the following chapters.
Chapter 7, Enhancing Your Application, deals with styling your application with SASS and StyledComponents, making it adaptive and responsive, and covers accessibility and internationalization concerns.

Chapter 8, Expanding Your Application, we'll see how to handle state with Redux, a powerful tool that will be necessary for larger-scale websites, and we'll also include topics such as routing, authorization, and code splitting for performance.
Chapter 9, Debugging Your Application, we'll cover themes such as logging and using browser and standalone tools for enhanced debugging.
Chapter 10, Testing Your Application, is where we will write unit tests for our code using Jest, and we'll also see how to use Storybook to simplify both development and testing.

It so happens that a variant of React, React Native, can be used to develop mobile
applications, and that will be our next topic for the following two chapters which make up
for part four of this book:

Chapter 11, Creating Mobile Apps with React Native, we'll see how to install and use React Native to build a mobile version of our web pages, which will work with different sized devices, in landscape or portrait mode, taking advantage of native features.
Chapter 12, Testing and Debugging Your Mobile App, we'll cover how to debug and test our code, using some tools we have already seen, such as Jest and Storybook, plus a few new ones, specific for mobile development.

Finally in part five, for the last chapter of the book we'll use both our server and client-side
knowledge, to develop native desktop applications with Electron:

Chapter 13, Creating a Desktop Application with Electron, is where we'll see that we can use Electron together with the tools we have already seen, React and Node, to produce, debug, and test native desktop applications, which you can distribute to users, who will be able to install them on their own machines just as they'd do with any other desktop program.

Modern JavaScript Web Development Cookbook

By : Federico Kereki

Modern JavaScript Web Development Cookbook

By: Federico Kereki

Overview of this book

Related Content you might be interested in

Current Title:

Modern JavaScript Web Development Cookbook

React 16 Tooling

Mastering JavaScript Functional Programming

Mastering JavaScript Functional Programming