Exploring ES6: Upgrade to the next version of JavaScript

Название: Exploring ES6: Upgrade to the next version of javascript
Автор: Axel Rauschmayer
Издательство: Lean Publishing
Год: 2015
Страниц:555
Язык: English
Формат: pdf
Размер: 4 Mb
You are reading a book about ECMAScript 6 (ES6), a new version of javascript. It’s great that we can finally use that version, which had a long and eventful past: It was first conceived as ECMAScript 4, a successor to ECMAScript 3 (whose release was in December 1999). In July 2008, plans changed and the next versions of javascript were to be first a small incremental release (which became ES5) and then a larger, more powerful release. The latter had the code name Harmony and part of it became ES6.
About the book
Exploring ES6 …
Contains reliable and in-depth information on ECMAScript 6, the next version of javascript.
Is a book for people who already know javascript.
If you are a programmer and want to learn javascript (up to and including ECMAScript 5), check out Axel’s book “Speaking javascript” .
(Even though the official name is now ECMAScript 2015, I’ll keep calling it ECMAScript 6 – for now – because that’s how everybody knows this version.)
 Table of contents
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
depositfiles.com
turbobit.net