Exploring ES6

  •  
    • What you need to know about this book
      • Audience: JavaScript programmers
      • Why should I read this book?
      • How to read this book
      • Glossary and conventions
        • Documenting classes
        • Capitalization
      • Demo code on GitHub
      • Sidebars
      • Footnotes
    • Preface
    • Acknowledgements
  • I Background
    • 1. About ECMAScript 6 (ES6)
      • 1.1 TC39 (Ecma Technical Committee 39)
      • 1.2 How ECMAScript 6 was designed
        • 1.2.1 The design process after ES6
      • 1.3 JavaScript versus ECMAScript
      • 1.4 Upgrading to ES6
      • 1.5 Goals for ES6
        • 1.5.1 Goal: Be a better language
        • 1.5.2 Goal: Improve interoperation
        • 1.5.3 Goal: Versioning
      • 1.6 An overview of ES6 features
      • 1.7 A brief history of ECMAScript
        • 1.7.1 The early years: ECMAScript 1–3
        • 1.7.2 ECMAScript 4 (abandoned in July 2008)
        • 1.7.3 ECMAScript Harmony
    • 2. FAQ: ECMAScript 6
      • 2.1 Isn’t ECMAScript 6 now called ECMAScript 2015?
      • 2.2 How much of ES6 is supported natively by current engines?
      • 2.3 How do I migrate my ECMAScript 5 code to ECMAScript 6?
      • 2.4 Does it still make sense to learn ECMAScript 5?
      • 2.5 Is ES6 bloated?
      • 2.6 Isn’t the ES6 specification very big?
      • 2.7 Does ES6 have array comprehensions?
      • 2.8 Is ES6 statically typed?
      • 2.9 Should I avoid classes?
      • 2.10 Does ES6 have traits or mixins?
      • 2.11 Why are there “fat” arrow functions (=>) in ES6, but no “thin” arrow functions (->)?
      • 2.12 Where can I find more ES6 resources?
    • 3. One JavaScript: avoiding versioning in ECMAScript 6
      • 3.1 Versioning
        • 3.1.1 Evolution without versioning
      • 3.2 Strict mode and ECMAScript 6
        • 3.2.1 Supporting sloppy (non-strict) mode
        • 3.2.2 let declarations in sloppy mode
        • 3.2.3 Block-level function declarations in sloppy mode
        • 3.2.4 Other keywords
        • 3.2.5 Implicit strict mode
        • 3.2.6 Things that can’t be fixed
      • 3.3 Conclusion
      • 3.4 Further reading
    • 4. First steps with ECMAScript 6
      • 4.1 Trying out ECMAScript 6
        • 4.1.1 The Babel REPL
        • 4.1.2 babel-node
      • 4.2 From var to let/const
      • 4.3 From IIFEs to blocks
      • 4.4 From concatenating strings to template literals
        • 4.4.1 String interpolation
        • 4.4.2 Multi-line strings
      • 4.5 From function expressions to arrow functions
      • 4.6 Handling multiple return values
        • 4.6.1 Multiple return values via arrays
        • 4.6.2 Multiple return values via objects
      • 4.7 From for to forEach() to for-of
      • 4.8 Handling parameter default values
      • 4.9 Handling named parameters
        • 4.9.1 Making the parameter optional
      • 4.10 From arguments to rest parameters
      • 4.11 From apply() to the spread operator (...)
        • 4.11.1 Math.max()
        • 4.11.2 Array.prototype.push()
      • 4.12 From concat() to the spread operator (...)
      • 4.13 From constructors to classes
        • 4.13.1 Base classes
        • 4.13.2 Derived classes
      • 4.14 From custom error constructors to subclasses of Error
      • 4.15 From function expressions in object literals to method definitions
      • 4.16 From objects to Maps
      • 4.17 From CommonJS modules to ES6 modules
        • 4.17.1 Multiple exports
        • 4.17.2 Single exports
      • 4.18 What to do next
    • 5. Deploying ECMAScript 6
      • 5.1 Using ECMAScript 6 today
        • 5.1.1 Using ECMAScript 6 natively
      • 5.2 Transpilation tools
        • 5.2.1 Choosing a transpiler
        • 5.2.2 Choosing a package manager
        • 5.2.3 Choosing a module system
      • 5.3 Other useful ES6 tools and libraries
      • 5.4 ES6 REPLs
      • 5.5 Are there ES6 features that can’t be transpiled to ES5?
        • 5.5.1 Better syntax for existing features
        • 5.5.2 New functionality in the standard library
        • 5.5.3 Completely new features
      • 5.6 Example transpilation setups
      • 5.7 Example setup: Client-side ES6 via webpack and Babel
        • 5.7.1 webpack features
        • 5.7.2 Installing webpack
        • 5.7.3 Using webpack and ES6 in a project
      • 5.8 Example setup: Dynamically transpiled ES6 on Node.js via Babel
        • 5.8.1 Running normal Node.js code via Babel
        • 5.8.2 Running Jasmine unit tests via Babel
      • 5.9 Example setup: Statically transpiled ES6 on Node.js via Babel and gulp
        • 5.9.1 Installation
        • 5.9.2 Source maps
        • 5.9.3 The gulp file
        • 5.9.4 Transpilation
        • 5.9.5 Running the transpiled code
  • II Data
    • 6. New number and Math features
      • 6.1 Overview
      • 6.2 New integer literals
        • 6.2.1 Use case for octal literals: Unix-style file permissions
        • 6.2.2 parseInt() and the new integer literals
      • 6.3 New static Number properties
        • 6.3.1 Previously global functions
        • 6.3.2 Number.EPSILON
        • 6.3.3 Number.isInteger(number)
        • 6.3.4 Safe Integers
      • 6.4 Math
        • 6.4.1 Various numerical functionality
        • 6.4.2 Using 0 instead of 1 with exponentiation and logarithm
        • 6.4.3 Logarithms to base 2 and 10
        • 6.4.4 Support for compiling to JavaScript
        • 6.4.5 Bitwise operations
        • 6.4.6 Trigonometric methods
      • 6.5 FAQ: numbers
        • 6.5.1 How can I use integers beyond JavaScript’s 53 bit range?
    • 7. New string features
      • 7.1 Overview
      • 7.2 Unicode code point escapes
      • 7.3 String interpolation, multi-line string literals and raw string literals
      • 7.4 Iterating over strings
        • 7.4.1 Iteration honors Unicode code points
        • 7.4.2 Counting code points
        • 7.4.3 Reversing strings with non-BMP code points
      • 7.5 Numeric values of code points
      • 7.6 Checking for containment and repeating strings
      • 7.7 All new string methods
    • 8. Symbols
      • 8.1 Overview
        • 8.1.1 Use case 1: unique property keys
        • 8.1.2 Use case 2: constants representing concepts
      • 8.2 A new primitive type
        • 8.2.1 Symbols as property keys
        • 8.2.2 Enumerating own property keys
      • 8.3 Using symbols to represent concepts
      • 8.4 Symbols as keys of properties
        • 8.4.1 Symbols as keys of internal properties
        • 8.4.2 Symbols as keys of meta-level properties
      • 8.5 Crossing realms with symbols
      • 8.6 Wrapper objects for symbols
        • 8.6.1 Property access via [ ]
      • 8.7 Converting symbols to other primitive types
        • 8.7.1 Pitfall: coercion to string
        • 8.7.2 Making sense of the coercion rules
        • 8.7.3 Explicit and implicit conversion in the spec
      • 8.8 JSON and symbols
        • 8.8.1 Generating JSON via JSON.stringify()
        • 8.8.2 Parsing JSON via JSON.parse()
      • 8.9 FAQ: symbols
        • 8.9.1 Can I use symbols to define private properties?
        • 8.9.2 Are symbols primitives or objects?
        • 8.9.3 Do we really need symbols? Aren’t strings enough?
        • 8.9.4 Are JavaScript’s symbols like Ruby’s symbols?
      • 8.10 The symbol API
        • 8.10.1 The function Symbol
        • 8.10.2 Well-known symbols
        • 8.10.3 Global symbol registry
    • 9. Template literals and tagged templates
      • 9.1 Overview
      • 9.2 Introduction
        • 9.2.1 Template literals
        • 9.2.2 Tagged templates
      • 9.3 Examples of using tagged templates
        • 9.3.1 Raw strings
        • 9.3.2 Escaping parts of a regular expression
        • 9.3.3 Tagged templates for more powerful regular expressions
        • 9.3.4 Query languages
        • 9.3.5 React JSX via tagged templates
        • 9.3.6 Text localization (L10N)
      • 9.4 Implementing tag functions
        • 9.4.1 Escaping in tagged templates: cooked vs. raw
        • 9.4.2 Example: implementing a tag function for HTML templating
        • 9.4.3 Example: quoting parts of regular expressions
      • 9.5 FAQ: template literals and tagged templates
        • 9.5.1 Where do template literals and tagged literals come from?
        • 9.5.2 What is the difference between macros and tagged templates?
        • 9.5.3 Can I load a template literal from an external source?
        • 9.5.4 Why are backticks the delimiters for template literals and tagged templates?
        • 9.5.5 Weren’t template literals once called template strings?
    • 10. Variables and scoping
      • 10.1 Overview
        • 10.1.1 let
        • 10.1.2 const
        • 10.1.3 Ways of declaring variables
      • 10.2 Block scoping via let and const
      • 10.3 const creates immutable variables
        • 10.3.1 Pitfall: const does not make the value immutable
        • 10.3.2 const in loop bodies
      • 10.4 The temporal dead zone
        • 10.4.1 typeof and the temporal dead zone
      • 10.5 let and const in loop heads
        • 10.5.1 for loop
        • 10.5.2 for-of loop and for-in loop
      • 10.6 Parameters
        • 10.6.1 Parameters versus local variables
        • 10.6.2 Parameter default values and the temporal dead zone
        • 10.6.3 Parameter default values don’t see the scope of the body
      • 10.7 The global object
      • 10.8 Function declarations and class declarations
      • 10.9 Coding style: var vs. let vs. const
    • 11. Destructuring
      • 11.1 Overview
      • 11.2 Background: Constructing data (object and Array literals) vs. extracting data (destructuring)
      • 11.3 Patterns
        • 11.3.1 Pick what you need
      • 11.4 How do patterns access the innards of values?
        • 11.4.1 Object patterns coerce values to objects
        • 11.4.2 Array patterns work with iterables
      • 11.5 If a part has no match
        • 11.5.1 Default values
      • 11.6 More object destructuring features
        • 11.6.1 Property value shorthands
        • 11.6.2 Computed property keys
      • 11.7 More Array destructuring features
        • 11.7.1 Elision
        • 11.7.2 Rest operator (...)
      • 11.8 You can assign to more than just variables
      • 11.9 Pitfalls of destructuring
        • 11.9.1 Don’t start a statement with a curly brace
        • 11.9.2 You can’t mix declaring and assigning to existing variables
      • 11.10 Examples of destructuring
        • 11.10.1 Destructuring return values
        • 11.10.2 Multiple return values
      • 11.11 The destructuring algorithm
        • 11.11.1 The algorithm
        • 11.11.2 Applying the algorithm
        • 11.11.3 Conclusion
    • 12. Parameter handling
      • 12.1 Overview
        • 12.1.1 Spread operator (...)
      • 12.2 Parameter handling as destructuring
      • 12.3 Parameter default values
        • 12.3.1 Why does undefined trigger default values?
        • 12.3.2 Referring to other parameters in default values
        • 12.3.3 Referring to “inner” variables in default values
      • 12.4 Rest parameters
        • 12.4.1 No more arguments!
      • 12.5 Simulating named parameters
        • 12.5.1 Named Parameters as Descriptions
        • 12.5.2 Optional Named Parameters
        • 12.5.3 Simulating Named Parameters in JavaScript
      • 12.6 Examples of destructuring in parameter handling
        • 12.6.1 Reminder: parentheses around single parameters of arrow functions
        • 12.6.2 forEach() and destructuring
        • 12.6.3 Transforming Maps
        • 12.6.4 Handling an Array returned via a Promise
      • 12.7 Coding style tips
        • 12.7.1 Optional parameters
        • 12.7.2 Required parameters
        • 12.7.3 Enforcing a maximum arity
      • 12.8 The spread operator (...)
        • 12.8.1 Spreading into function and method calls
        • 12.8.2 Spreading into constructors
        • 12.8.3 Spreading into Arrays
  • III Modularity
    • 13. Callable entities in ECMAScript 6
      • 13.1 Callable entities in ES6
        • 13.1.1 Ways of calling in ES6
        • 13.1.2 Traditional functions
        • 13.1.3 Generator functions
        • 13.1.4 Method definitions
        • 13.1.5 Generator method definitions
        • 13.1.6 Arrow functions
        • 13.1.7 Classes
      • 13.2 Thoughts on style
        • 13.2.1 Prefer arrow functions as callbacks
        • 13.2.2 Be careful with function declarations
        • 13.2.3 Prefer method definitions for methods
        • 13.2.4 Methods versus callbacks
        • 13.2.5 Avoid IIFEs in ES6
        • 13.2.6 Use classes
      • 13.3 Dispatched and direct method calls in ECMAScript 5 and 6
        • 13.3.1 Background: prototype chains
        • 13.3.2 Dispatched method calls
        • 13.3.3 Direct method calls
        • 13.3.4 Use cases for direct method calls
        • 13.3.5 Abbreviations for Object.prototype and Array.prototype
    • 14. Arrow functions
      • 14.1 Overview
      • 14.2 Traditional functions are bad non-method functions, due to this
        • 14.2.1 Solution 1: that = this
        • 14.2.2 Solution 2: specifying a value for this
        • 14.2.3 Solution 3: bind(this)
        • 14.2.4 ECMAScript 6 solution: arrow functions
      • 14.3 Arrow function syntax
      • 14.4 Lexical variables
        • 14.4.1 Sources of variable values: static versus dynamic
        • 14.4.2 Variables that are lexical in arrow functions
      • 14.5 Syntax pitfalls
        • 14.5.1 Arrow functions bind very loosely
        • 14.5.2 Immediately-invoked arrow functions
        • 14.5.3 Omitting parentheses around single parameters
        • 14.5.4 You can’t use statements as expression bodies
        • 14.5.5 Returning an object literal
      • 14.6 Arrow functions versus normal functions
    • 15. New OOP features besides classes
      • 15.1 Overview
        • 15.1.1 New object literal features
        • 15.1.2 New methods in Object
      • 15.2 New features of object literals
        • 15.2.1 Method definitions
        • 15.2.2 Property value shorthands
        • 15.2.3 Computed property keys
      • 15.3 New methods of Object
        • 15.3.1 Object.assign(target, source_1, source_2, ···)
        • 15.3.2 Object.getOwnPropertySymbols(obj)
        • 15.3.3 Object.is(value1, value2)
        • 15.3.4 Object.setPrototypeOf(obj, proto)
      • 15.4 Iterating over property keys in ES6
        • 15.4.1 Iteration order of property keys
      • 15.5 FAQ: object literals
        • 15.5.1 Can I use super in object literals?
    • 16. Classes
      • 16.1 Overview
      • 16.2 The essentials
        • 16.2.1 Base classes
        • 16.2.2 Inside the body of a class definition
        • 16.2.3 Subclassing
      • 16.3 The details of classes
        • 16.3.1 Various checks
        • 16.3.2 Attributes of properties
      • 16.4 The details of subclassing
        • 16.4.1 Prototype chains
        • 16.4.2 Allocating and initializing instances
        • 16.4.3 Why can’t you subclass built-in constructors in ES5?
        • 16.4.4 Referring to super-properties in methods
      • 16.5 Constructor calls explained via JavaScript code
        • 16.5.1 Internal variables and properties
        • 16.5.2 Environments
        • 16.5.3 Constructor calls
        • 16.5.4 Super-constructor calls
      • 16.6 The species pattern
        • 16.6.1 The standard species pattern
        • 16.6.2 The species pattern for Arrays
        • 16.6.3 The species pattern in static methods
        • 16.6.4 Overriding the default species in subclasses
      • 16.7 FAQ: classes
        • 16.7.1 Why can’t classes be function-called?
        • 16.7.2 How do instantiate a class, given an Array of arguments?
        • 16.7.3 How do I manage private data for classes?
        • 16.7.4 What is next for classes?
      • 16.8 The pros and cons of classes
        • 16.8.1 Complaint: ES6 classes obscure the true nature of JavaScript inheritance
        • 16.8.2 Complaint: Classes provide only single inheritance
        • 16.8.3 Complaint: Classes lock you in, due to mandatory new
      • 16.9 Further reading
    • 17. Modules
      • 17.1 Overview
        • 17.1.1 Multiple named exports
        • 17.1.2 Single default export
        • 17.1.3 Browsers: scripts versus modules
      • 17.2 Modules in JavaScript
        • 17.2.1 ECMAScript 5 module systems
        • 17.2.2 ECMAScript 6 modules
      • 17.3 The basics of ES6 modules
        • 17.3.1 Named exports (several per module)
        • 17.3.2 Default exports (one per module)
        • 17.3.3 Imports are hoisted
        • 17.3.4 Imports are read-only views on exports
        • 17.3.5 Support for cyclic dependencies
        • 17.3.6 Module files are normal JavaScript files
        • 17.3.7 Be careful with ES6 transpilers
      • 17.4 Importing and exporting in detail
        • 17.4.1 Importing styles
        • 17.4.2 Exporting styles: inline versus clause
        • 17.4.3 Re-exporting
        • 17.4.4 All exporting styles
        • 17.4.5 Having both named exports and a default export in a module
      • 17.5 The ECMAScript 6 module loader API
        • 17.5.1 Loaders
        • 17.5.2 Loader method: importing modules
        • 17.5.3 More loader methods
        • 17.5.4 Configuring module loading
      • 17.6 Using ES6 modules in browsers
        • 17.6.1 Browsers: asynchronous modules versus synchronous scripts
        • 17.6.2 Bundling
      • 17.7 Details: imports as views on exports
        • 17.7.1 In CommonJS, imports are copies of exported values
        • 17.7.2 In ES6, imports are live read-only views on exported values
        • 17.7.3 Implementing views
        • 17.7.4 Imports as views in the spec
      • 17.8 Design goals for ES6 modules
        • 17.8.1 Default exports are favored
        • 17.8.2 Static module structure
        • 17.8.3 Support for both synchronous and asynchronous loading
        • 17.8.4 Support for cyclic dependencies between modules
      • 17.9 FAQ: modules
        • 17.9.1 Can I use a variable to specify from which module I want to import?
        • 17.9.2 Can I import a module conditionally or on demand?
        • 17.9.3 Can I use destructuring in an import statement?
        • 17.9.4 Are named exports necessary? Why not default-export objects?
        • 17.9.5 Can I eval() modules?
      • 17.10 Benefits of ECMAScript 6 modules
      • 17.11 Further reading
  • IV Collections
    • 18. New Array features
      • 18.1 Overview
      • 18.2 New static Array methods
        • 18.2.1 Array.from(arrayLike, mapFunc?, thisArg?)
        • 18.2.2 Array.of(...items)
      • 18.3 New Array.prototype methods
        • 18.3.1 Iterating over Arrays
        • 18.3.2 Searching for Array elements
        • 18.3.3 Array.prototype.copyWithin()
        • 18.3.4 Array.prototype.fill()
    • 19. Maps and Sets
      • 19.1 Overview
        • 19.1.1 Maps
        • 19.1.2 Sets
        • 19.1.3 WeakMaps
      • 19.2 Map
        • 19.2.1 Basic operations
        • 19.2.2 Setting up a Map
        • 19.2.3 Keys
        • 19.2.4 Iterating
        • 19.2.5 Looping over entries
        • 19.2.6 Mapping and filtering Maps
        • 19.2.7 Combining Maps
        • 19.2.8 Map API
      • 19.3 WeakMap
        • 19.3.1 Using WeakMaps for private data
        • 19.3.2 WeakMap API
      • 19.4 Set
        • 19.4.1 Basic operations
        • 19.4.2 Setting up a Set
        • 19.4.3 Comparing Set elements
        • 19.4.4 Iterating
        • 19.4.5 Mapping and filtering
        • 19.4.6 Union, intersection, difference
        • 19.4.7 Set API
      • 19.5 WeakSet
        • 19.5.1 WeakSet API
      • 19.6 FAQ: Maps and Sets
        • 19.6.1 Why do Maps and Sets have the property size and not length?
        • 19.6.2 Why can’t I configure how Maps and Sets compare keys and values?
        • 19.6.3 Is there a way to specify a default value when getting something out of a Map?
        • 19.6.4 When should I use a Map, when an object?
    • 20. Typed Arrays
      • 20.1 Overview
      • 20.2 Introduction
        • 20.2.1 Element types
        • 20.2.2 Handling overflow and underflow
        • 20.2.3 Endianness
        • 20.2.4 Negative indices
      • 20.3 ArrayBuffers
        • 20.3.1 ArrayBuffer constructor
        • 20.3.2 Static ArrayBuffer methods
        • 20.3.3 ArrayBuffer.prototype properties
      • 20.4 Typed Arrays
        • 20.4.1 Typed Arrays versus normal Arrays
        • 20.4.2 Typed Arrays are iterable
        • 20.4.3 Converting Typed Arrays to and from normal Arrays
        • 20.4.4 The Species pattern for Typed Arrays
        • 20.4.5 The inheritance hierarchy of Typed Arrays
        • 20.4.6 Static TypedArray methods
        • 20.4.7 TypedArray.prototype properties
        • 20.4.8 «ElementType»Array constructor
        • 20.4.9 Static «ElementType»Array properties
        • 20.4.10 «ElementType»Array.prototype properties
        • 20.4.11 Concatenating Typed Arrays
      • 20.5 DataViews
        • 20.5.1 DataView constructor
        • 20.5.2 DataView.prototype properties
      • 20.6 Browser APIs that support Typed Arrays
        • 20.6.1 File API
        • 20.6.2 XMLHttpRequest
        • 20.6.3 Fetch API
        • 20.6.4 Canvas
        • 20.6.5 WebSockets
        • 20.6.6 Other APIs
      • 20.7 Extended example: JPEG SOF0 decoder
        • 20.7.1 The JPEG file format
        • 20.7.2 The JavaScript code
      • 20.8 Availability
    • 21. Iterables and iterators
      • 21.1 Overview
      • 21.2 Iterability
      • 21.3 Iterable data sources
        • 21.3.1 Arrays
        • 21.3.2 Strings
        • 21.3.3 Maps
        • 21.3.4 Sets
        • 21.3.5 arguments
        • 21.3.6 DOM data structures
        • 21.3.7 Iterable computed data
        • 21.3.8 Plain objects are not iterable
      • 21.4 Iterating language constructs
        • 21.4.1 Destructuring via an Array pattern
        • 21.4.2 The for-of loop
        • 21.4.3 Array.from()
        • 21.4.4 The spread operator (...)
        • 21.4.5 Maps and Sets
        • 21.4.6 Promises
        • 21.4.7 yield*
      • 21.5 Implementing iterables
        • 21.5.1 Iterators that are iterable
        • 21.5.2 Optional iterator methods: return() and throw()
      • 21.6 More examples of iterables
        • 21.6.1 Tool functions that return iterables
        • 21.6.2 Combinators for iterables
        • 21.6.3 Infinite iterables
      • 21.7 FAQ: iterables and iterators
        • 21.7.1 Isn’t the iteration protocol slow?
        • 21.7.2 Can I reuse the same object several times?
        • 21.7.3 Why doesn’t ECMAScript 6 have iterable combinators?
        • 21.7.4 Aren’t iterables difficult to implement?
      • 21.8 The ECMAScript 6 iteration protocol in depth
        • 21.8.1 Iteration
        • 21.8.2 Closing iterators
        • 21.8.3 Checklist
    • 22. Generators
      • 22.1 Overview
        • 22.1.1 Implementing iterables via generators
        • 22.1.2 Blocking on asynchronous function calls
      • 22.2 What are generators?
        • 22.2.1 Ways of creating generators
        • 22.2.2 Roles played by generators
      • 22.3 Generators as iterators (data production)
        • 22.3.1 Ways of iterating over a generator
        • 22.3.2 Returning from a generator
        • 22.3.3 Example: iterating over properties
        • 22.3.4 You can only yield in generators
        • 22.3.5 Recursion via yield* (for output)
      • 22.4 Generators as observers (data consumption)
        • 22.4.1 Sending values via next()
        • 22.4.2 yield binds loosely
        • 22.4.3 return() and throw()
        • 22.4.4 return() terminates the generator
        • 22.4.5 throw() signals an error
        • 22.4.6 Example: processing asynchronously pushed data
        • 22.4.7 yield*: the full story
      • 22.5 Generators as coroutines (cooperative multitasking)
        • 22.5.1 The full generator interface
        • 22.5.2 Cooperative multitasking
        • 22.5.3 The limitations of cooperative multitasking via generators
      • 22.6 Examples of generators
        • 22.6.1 Implementing iterables via generators
        • 22.6.2 Generators for lazy evaluation
        • 22.6.3 Cooperative multi-tasking via generators
      • 22.7 Inheritance within the iteration API (including generators)
        • 22.7.1 IteratorPrototype
        • 22.7.2 The value of this in generators
      • 22.8 Style consideration: whitespace before and after the asterisk
        • 22.8.1 Generator function declarations and expressions
        • 22.8.2 Generator method definitions
        • 22.8.3 Formatting recursive yield
        • 22.8.4 Documenting generator functions and methods
      • 22.9 Conclusion
      • 22.10 Further reading
  • V Standard library
    • 23. New regular expression features
      • 23.1 Overview
      • 23.2 New flag /y (sticky)
        • 23.2.1 RegExp.prototype.exec(str)
        • 23.2.2 RegExp.prototype.test(str)
        • 23.2.3 String.prototype.search(regex)
        • 23.2.4 String.prototype.match(regex)
        • 23.2.5 String.prototype.split(separator, limit)
        • 23.2.6 String.prototype.replace(search, replacement)
        • 23.2.7 Example: using sticky matching for tokenizing
        • 23.2.8 Example: manually implementing sticky matching
      • 23.3 New flag /u (unicode)
        • 23.3.1 Consequence: lone surrogates in the regular expression only match lone surrogates
        • 23.3.2 Consequence: you can put code points in character classes
        • 23.3.3 Consequence: the dot operator (.) matches code points, not code units
        • 23.3.4 Consequence: quantifiers apply to code points, not code units
      • 23.4 New data property flags
      • 23.5 RegExp() can be used as a copy constructor
      • 23.6 String methods using regular expressions delegate to regular expression methods
    • 24. Asynchronous programming (background)
      • 24.1 The JavaScript call stack
      • 24.2 The browser event loop
        • 24.2.1 Timers
        • 24.2.2 Displaying DOM changes
        • 24.2.3 Run-to-completion semantics
        • 24.2.4 Blocking the event loop
        • 24.2.5 Avoiding blocking
      • 24.3 Receiving results asynchronously
        • 24.3.1 Asynchronous results via events
        • 24.3.2 Asynchronous results via callbacks
        • 24.3.3 Continuation-passing style
        • 24.3.4 Composing code in CPS
        • 24.3.5 Pros and cons of callbacks
      • 24.4 Looking ahead
      • 24.5 Further reading
    • 25. Promises for asynchronous programming
      • 25.1 Overview
        • 25.1.1 Handling Arrays of Promises
      • 25.2 Promises
      • 25.3 A first example
      • 25.4 Creating and using Promises
        • 25.4.1 Producing a Promise
        • 25.4.2 Consuming a Promise
        • 25.4.3 Only handling fulfillments or rejections
      • 25.5 Examples
        • 25.5.1 Example: promisifying fs.readFile()
        • 25.5.2 Example: promisifying XMLHttpRequest
        • 25.5.3 Example: delaying an activity
        • 25.5.4 Example: timing out a Promise
      • 25.6 Chaining Promises
        • 25.6.1 Resolving Q with normal values
        • 25.6.2 Resolving Q with thenables
        • 25.6.3 Resolving Q from onRejected
        • 25.6.4 Rejecting Q by throwing exceptions
        • 25.6.5 Exceptions in executors
        • 25.6.6 Chaining errors
      • 25.7 Composition
        • 25.7.1 map() via Promise.all()
        • 25.7.2 Timing out via Promise.race()
      • 25.8 Promises are always async
      • 25.9 Cheat sheet: the ECMAScript 6 Promise API
        • 25.9.1 Glossary: Promises
        • 25.9.2 Promise constructor
        • 25.9.3 Static Promise methods
        • 25.9.4 Promise.prototype methods
      • 25.10 Pros and cons of Promises
        • 25.10.1 The pros
        • 25.10.2 The cons
      • 25.11 Promises and generators
      • 25.12 Debugging Promises
      • 25.13 The internals of Promises
        • 25.13.1 A stand-alone Promise
        • 25.13.2 Chaining
        • 25.13.3 Flattening
        • 25.13.4 Promise states in more detail
        • 25.13.5 Exceptions
        • 25.13.6 Revealing constructor pattern
      • 25.14 Two useful additional Promise methods
        • 25.14.1 done()
        • 25.14.2 finally()
      • 25.15 ES6-compatible Promise libraries
      • 25.16 Interfacing with legacy asynchronous code
        • 25.16.1 Interfacing with Node.js
        • 25.16.2 Interfacing with jQuery
      • 25.17 Further reading
  • VI Miscellaneous
    • 26. Unicode in ES6
      • 26.1 Unicode is better supported in ES6
      • 26.2 Escape sequences in ES6
        • 26.2.1 Where can escape sequences be used?
        • 26.2.2 Escape sequences in the ES6 spec
    • 27. Tail call optimization
      • 27.1 What is tail call optimization?
        • 27.1.1 Normal execution
        • 27.1.2 Tail call optimization
      • 27.2 Checking whether a function call is in a tail position
        • 27.2.1 Tail calls in expressions
        • 27.2.2 Tail calls in statements
        • 27.2.3 Tail call optimization can only be made in strict mode
        • 27.2.4 Pitfall: solo function calls are never in tail position
      • 27.3 Tail-recursive functions
        • 27.3.1 Tail-recursive loops
    • 28. Meta programming with proxies
      • 28.1 Overview
      • 28.2 Programming versus meta programming
        • 28.2.1 Kinds of meta programming
      • 28.3 A first look at proxies
        • 28.3.1 Function-specific traps
        • 28.3.2 Revocable proxies
        • 28.3.3 Proxies as prototypes
        • 28.3.4 Forwarding intercepted operations
      • 28.4 Use cases for proxies
        • 28.4.1 Implementing the DOM in JavaScript
        • 28.4.2 Accessing a restful web service
        • 28.4.3 Tracing property accesses
        • 28.4.4 Warning about unknown properties
        • 28.4.5 Negative Array indices
        • 28.4.6 Data binding
        • 28.4.7 Revocable references
        • 28.4.8 Other use cases
      • 28.5 The design of the proxy API
        • 28.5.1 Stratification: keeping base level and meta level separate
        • 28.5.2 Virtual objects versus wrappers
        • 28.5.3 Transparent virtualization and handler encapsulation
        • 28.5.4 The meta object protocol and proxy traps
        • 28.5.5 Enforcing invariants for proxies
      • 28.6 Reference: the proxy API
        • 28.6.1 Creating proxies
        • 28.6.2 Handler methods
        • 28.6.3 Invariants of handler methods
        • 28.6.4 Operations that affect the prototype chain
        • 28.6.5 Reflect
      • 28.7 Conclusion
      • 28.8 Further reading
    • 29. Coding style tips for ECMAScript 6

Read More