Sign In Start Free Trial

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

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

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

Using Modern JavaScript Features

Introduction

Adding types

Working with strings

Enhancing your code

Defining functions

Programming functionally

Doing async calls compactly

Working with objects and classes

Organizing code in modules

Determining a feature's availability

Developing with Node

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

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

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

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

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

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

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

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

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

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

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

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Logging with style

Logging is still a very good tool, but you cannot just depend on using tools such as console.log() or console.error(). Even though they do the work for a short debugging run, if you plan to include logging more seriously and want to disable it in production, you'll have a lot of work chasing down every logging call—or monkey patching the console object so .log() or .error() won't do their thing, and that's even worse!

Back in the Adding logging with Winston section of Chapter 5, Testing and Debugging Your Server, we used Winston for logging (and also Morgan, but that was specific for HTTP logging, so it doesn't count) and that library had features that enabled us to easily start or stop logging. There's no version of Winston for browsers, but we can fall back to debug, an old standard (we referred to in the There's more...

Search

Your notes and bookmarks