Get Programming with JavaScript Next
New features of ECMAScript 2015, 2016, and beyond
JD Isaacks
  • MEAP began November 2016
  • Publication in Early 2018 (estimated)
  • ISBN 9781617294204
  • 313 pages (estimated)
  • printed in black & white

Modern browsers, Node, and major libraries have already started to adopt next generation JavaScript features. Isn't it time for you to learn ES6 and ES7? They can make your JavaScript simpler to read, less prone to common errors, and much easier to use in asynchronous programs.

Get Programming with JavaScript Next: New features for ECMAScript 2015, 2016, and beyond introduces the modern age of JavaScript programming with ES6 and ES7 without dragging you through confusing jargon and abstract examples you'll never use. In just 44 quick fire sessions, you'll quickly be coding with the latest features and functions of ES6 and ES7! Starting with the basics of the new syntax, declarations, and data types, you'll build modules, work with Promises, Classes, Iterators, and beyond with easy to follow projects and clear explanations. And you'll be confident in your new skills because each lesson offer practical exercises to help you learn JavaScript by doing JavaScript!

Table of Contents detailed table of contents

Unit 0: Getting Setup

Lesson 1 A Brief History of ECMAScript

1.1 A Brief History of ECMAScript

1.2 Why ES2015 Adds So Much

1.3 Who Decides What Gets Added?

1.3.1 Specification Stages

1.3.2 Picking a Stage

1.4 What This Book Will Cover

1.5 Summary

Lesson 2 Transpiling with Babel

2.1 What Is Transpiling?

2.1.1 Compile to JavaScript Languages

2.1.2 Where Babel Fits In

2.2 Setting Up Babel 6

2.3 The Babel Configuration Needed for This Book

2.3.1 A Note on Source Maps

2.3.2 Setup Babel as NPM Script

2.4 Summary

Lesson 3 Bundling Modules with Browserify

3.1 What Is A Module?

3.2 How Modules Work in Node.js

3.3 What is Browserify?

3.4 How Does Browserify Help with ES6 Modules?

3.5 Setting Up Browserify with Babel

3.5.1 Install Browserify

3.5.Setup A Project Using Babelify

3.6 Alternatives to Browserify

3.7 Summary

Unit 1: Variables & Strings

Lesson 4 Declaring Variables with let

4.1 How Scope Works with let

4.1.1 Why The Block Scope of let is Preferred

4.2 How Hoisting Works with let

4.3 Should I Use let Instead of var From Now On?

4.4 Summary

4.5 Quick Check Answers

Lesson 5 Declaring constants with const

5.1 How Constants Work

5.2 When to Use Constants

5.3 Summary

5.4 Quick Check Answers

Lesson 6 New String Methods

6.1 Searching Strings

6.2 Padding Strings

6.3 Summary

6.4 Exercise

4.5 Quick Check Answers

Lesson 7 Template Literals

7.1 What are Template Literals?

7.1.1 String Interpolation with Template Literals

7.1.2 Multiline Strings with Template Literals

7.2 Template Literals are not Reusable Templates

7.3 Custom Processing with Tagged Template Literals

7.4 Summary

7.5 Quick Check Answers

Lesson 8 Building a Domain Specific Language

8.1 Create Some Helper Functions

8.2 Create An HTML Escaping DSL

8.3 Create a DSL for Converting Arrays Into HTML

8.4 Summary

Unit 2: Objects & Arrays

Lesson 9 New Array Methods

9.1 Constructing Arrays with Array.from

9.2 Constructing Arrays with Array.of

9.3 Constructing Arrays with Array.prototype.fill

9.4 Searching in Arrays with Array.prototype.includes

9.5 Searching in Arrays with Array.prototype.find

9.6 Summary

9.6 Quick Check Answers

Lesson 10 Object.assign

10.1 Setting Default Values with Object.assign

10.2 Extending Objects with Object.assign

10.3 Preventing Mutations When Using Object.assign

10.4 How Object.assign Assigns Values

10.5 Summary

10.6 Quick Check Answers

Lesson 11 Destructuring

11.1 Destructuring Objects

11.2 Destructuring Arrays

11.3 Combining Array & Object Destructuring

11.4 What Types Can Be Destructured

11.5 Summary

11.6 Quick Check Answers

Lesson 12 New Object Literal Syntax

12.1 Shorthand Property Names

12.2 Shorthand Method Names

12.3 Computed Property Names

12.4 Summary

12.5 Quick Check Answers

Lesson 13 Symbol - A New Primitive

13.1 Using Symbols as Constants

13.2 Using Symbols as Object Keys

13.3 Creating Behavior Hooks with Global Symbols

13.4 Modifying Object Behavior with Well Known Symbols

13.5 Symbol Gotchas

13.6 Summary

13.7 Quick Check Answers

Lesson 14 Simulating a Lock & Key

14.1 Creating the Lock & Key System

14.2 Creating a Choose the Door Game

14.3 Summary

Unit 3: Functions

Lesson 15 Default Parameters & Rest

15.1 Default Parameters

15.2 Using Default Params to Skip Recalculating Values

15.3 Gathering Parameters with the Rest Operator

15.4 Using Rest to Pass Arguments Between Functions

15.5 Summary

15.6 Quick Check Answers

Lesson 16 Destructuring Parameters

16.1 Destructuring Array Parameters

16.2 Destructuring Object Parameters

16.3 Simulating Named Parameters

16.4 Creating Aliased Parameters

16.5 Summary

16.6 Quick Check Answers

Lesson 17 Arrow Functions

17.1 Succinct Code with Arrow Functions

17.2 Maintaining Context with Arrow Functions

17.3 Arrow Function Gotchas

17.4 Summary

17.5 Quick Check Answers

Lesson 18 Intro to Generator Functions

18.1 Defining Generator Functions

18.2 Using Generator Functions

18.3 Creating Infinite Lists with Generator Functions

18.4 Summary

18.5 Quick Check Answers

Lesson 19 Capstone: The Prisoner’s Dilemma

19.1 Generating Prisoners

19.2 Getting Prisoners To Interact

19.3 Getting and Storing The Results

19.4 Putting the Simulation Together

19.5 Which Prisoner Does Best?

19.6 Summary

Unit 4 Modules

Lesson 20 Creating Modules

20.1 Module Rules

20.2 Creating Modules

20.3 When Does a JavaScript File Become a Module

20.4 Summary

20.5 Exercise

20.6 Quick Check Answers

Lesson 21 Using Modules

21.1 Specifying a Module’s Location

21.2 Importing Values From Modules

21.3 How Imported Values Are Bound

21.4 Importing Side Effects

21.5 Breaking Apart & Organizing Modules

21.6 Summary

21.7 Quick Check Answers

Lesson 22 Capstone: Hangman Game

22.1 Planning

22.2 The Words Module

22.3 The Status Module

22.4 The Game’s Interface Modules

22.5 The Index

22.6 Summary

Unit 5 Iterables

Lesson 23 Iterables

23.1 Iterables - What are they?

23.2 The for..of Statement

23.3 Spread

23.3.1 Using Spread as an Immutable Push

23.4 Iterators - Looking Under the Hood of Iterables

23.5 Summary

23.6 Exercise

23.7 Quick Check Answers

Lesson 24 Sets

24.1 Creating Sets

24.2 Using Sets

24.2 What About The WeakSet?

24.3 Summary

24.4 Quick Check Answers

Lesson 25 Maps

25.1 Creating Maps

25.2 Using Maps

25.3 When to Use Maps

25.4 What About The WeakMap?

25.5 Summary

25.6 Quick Check Answers

Lesson 26 Capstone: Blackjack

26.1 The Cards and The Deck

26.2 Making the CPU’s Turn Slow Enough To See

26.3 Putting The Pieces Together

26.4 Summary

Unit 6 Classes

Lesson 27 Classes

27.1 Class Declarations

27.2 Instantiating Classes

27.3 Exporting Classes

27.4 Class Methods are Not Bound

27.5 Setting Instance Properties in Class Definition

27.6 Static Properties

27.7 Summary

27.8 Exercise

27.9 Quick Check Answers

Lesson 28 Extending Classes

28.1 Extends

28.2 Super

28.3 Extending Gotcha

28.4 Summary

28.5 Exercise

28.6 Quick Check Answers

Lesson 29 Capstone: Comets

29.1 Creating A Controllable Sprite

29.2 Adding Comets

29.3 Shooting Rockets

29.4 When Things Collide

29.5 Adding Explosions

29.6 Summary

Unit 7 Working Asynchronously

Lesson Promises

30.1 Using Promises

30.2 Error Handling

30.3 Promise Helpers

30.4 Summary

30.5 Exercise

30.6 Quick Check Answers

Lesson 31 Advanced Promises

31.1 Creating Promises

31.2 Nested Promises

31.3 Catching Errors

31.4 Summary

31.5 Exercise

31.6 Quick Check Answers

Lesson Async Functions

32.1 Asynchronous Code with Generators

32.2 Async Functions

32.3 Error Handling in Async Functions

32.4 Summary

32.5 Exercise

32.6 Quick Check Answers

Lesson 33 Observables

33.1 Creating Observables

33.2 Composing Observables

33.3 Creating Observable Combinators

33.4 Summary

33.5 Exercise

33.6 Quick Check Answers

Lesson 34 Capstone 7: Canvas Image Gallery

34.1 Fetching Images

34.2 Painting the Images on the Canvas

34.3 Repeating the Process

34.4 Summary

What's inside

  • Learn the new features of ES6 (ES2015)
  • Use all of the newest JavaScript features right away
  • Setup an ES6/7 project using Babel and Browserify
  • Writing elegant asynchronous code with async functions, generators, and promises
  • Using classes instead of constructors
  • Creating custom iterables and modifying built in ones
  • Using and troubleshooting modules and classes to build complex applications

About the reader

This book is for developers who are comfortable writing basic Javascript code. Knowledge of the DOM and Node.js will be helpful, but not required.

About the author

J.D. Isaacks has been a developer for over 10 years, focusing on EcmaScript-based languages and is a Javascript instructor for The Iron Yard. He has contributed to projects including React, Backbone, and D3. He is also a member of both the Bower.js and Moment.js teams and the creator of GitGutter, one of the most popular Sublime Text packages.


Manning Early Access Program (MEAP) Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.
Buy
MEAP combo $39.99 pBook + eBook + liveBook
MEAP eBook $31.99 pdf + ePub + kindle + liveBook

FREE domestic shipping on three or more pBooks