Understanding ECMAScript 6
The Definitive Guide for JavaScript Developers
Published on 16. August 2016
352 pages
978-1-59327-798-7 (ISBN)
Description
ECMAScript 6 represents the biggest update to the core of JavaScript in the history of the language. In Understanding ECMAScript 6, expert developer Nicholas C. Zakas provides a complete guide to the object types, syntax, and other exciting changes that ECMAScript 6 brings to JavaScript. Every chapter is packed with example code that works in any JavaScript environment so you'll be able to see new features in action.
You'll learn:
-How ECMAScript 6 class syntax relates to more familiar JavaScript concepts
-What makes iterators and generators useful
-How arrow functions differ from regular functions
-Ways to store data with sets, maps, and more
-The power of inheritance
-How to improve asynchronous programming with promises
-How modules change the way you organize code
Whether you're a web developer or a Node.js developer, you'll find Understanding ECMAScript 6 indispensable on your journey from ECMAScript 5 to ECMAScript 6.
You'll learn:
-How ECMAScript 6 class syntax relates to more familiar JavaScript concepts
-What makes iterators and generators useful
-How arrow functions differ from regular functions
-Ways to store data with sets, maps, and more
-The power of inheritance
-How to improve asynchronous programming with promises
-How modules change the way you organize code
Whether you're a web developer or a Node.js developer, you'll find Understanding ECMAScript 6 indispensable on your journey from ECMAScript 5 to ECMAScript 6.
More details
Other editions
Additional editions
Book
08/2016
1st Edition
No Starch Press
€33.00
Article in reprint
Person
Nicholas C. Zakas has been working on web applications since 2000, focusing on frontend development, and is known for writing and speaking about frontend best practices. He honed his experience during his five years at Yahoo!, where he was principal frontend engineer for the Yahoo! home page. He is the author of several books, including The Principles of Object-Oriented JavaScript (No Starch Press) and Professional JavaScript for Web Developers (Wrox).
Content
- Intro
- Title Page
- Copyright Page
- About the Author
- About the Technical Reviewer
- Brief Contents
- Contents in Detail
- Foreword
- Acknowledgments
- Introduction
- The Road to ECMAScript 6
- About This Book
- Browser and Node.js Compatibility
- Who This Book Is For
- Overview
- Conventions Used
- Help and Support
- Chapter 1: Block Bindings
- var Declarations and Hoisting
- Block-Level Declarations
- let Declarations
- No Redeclaration
- const Declarations
- The Temporal Dead Zone
- Block Bindings in Loops
- Functions in Loops
- let Declarations in Loops
- const Declarations in Loops
- Global Block Bindings
- Emerging Best Practices for Block Bindings
- Summary
- Chapter 2: Strings and Regular Expressions
- Better Unicode Support
- UTF-16 Code Points
- The codePointAt() Method
- The String.fromCodePoint() Method
- The normalize() Method
- The Regular Expression u Flag
- Other String Changes
- Methods for Identifying Substrings
- The repeat() Method
- Other Regular Expression Changes
- The Regular Expression y Flag
- Duplicating Regular Expressions
- The flags Property
- Template Literals
- Basic Syntax
- Multiline Strings
- Making Substitutions
- Tagged Templates
- Summary
- Chapter 3: Functions
- Functions with Default Parameter Values
- Simulating Default Parameter Values in ECMAScript 5
- Default Parameter Values in ECMAScript 6
- How Default Parameter Values Affect the arguments Object
- Default Parameter Expressions
- Default Parameter TDZ
- Working with Unnamed Parameters
- Unnamed Parameters in ECMAScript 5
- Rest Parameters
- Increased Capabilities of the Function Constructor
- The Spread Operator
- The name Property
- Choosing Appropriate Names
- Special Cases of the name Property
- Clarifying the Dual Purpose of Functions
- Determining How a Function Was Called in ECMAScript 5
- The new.target Metaproperty
- Block-Level Functions
- Deciding When to Use Block-Level Functions
- Block-Level Functions in Non-Strict Mode
- Arrow Functions
- Arrow Function Syntax
- Creating Immediately Invoked Function Expressions
- No this Binding
- Arrow Functions and Arrays
- No arguments Binding
- Identifying Arrow Functions
- Tail Call Optimization
- How Tail Calls Are Different in ECMAScript 6
- How to Harness Tail Call Optimization
- Summary
- Chapter 4: Expanded Object Functionality
- Object Categories
- Object Literal Syntax Extensions
- Property Initializer Shorthand
- Concise Methods
- Computed Property Names
- New Methods
- The Object.is() Method
- The Object.assign() Method
- Duplicate Object Literal Properties
- Own Property Enumeration Order
- Enhancements for Prototypes
- Changing an Object's Prototype
- Easy Prototype Access with Super References
- A Formal Method Definition
- Summary
- Chapter 5: Destructuring for Easier Data Access
- Why Is Destructuring Useful?
- Object Destructuring
- Destructuring Assignment
- Default Values
- Assigning to Different Local Variable Names
- Nested Object Destructuring
- Array Destructuring
- Destructuring Assignment
- Default Values
- Nested Array Destructuring
- Rest Items
- Mixed Destructuring
- Destructured Parameters
- Destructured Parameters Are Required
- Default Values for Destructured Parameters
- Summary
- Chapter 6: Symbols and Symbol Properties
- Creating Symbols
- Using Symbols
- Sharing Symbols
- Symbol Coercion
- Retrieving Symbol Properties
- Exposing Internal Operations with Well-Known Symbols
- The Symbol.hasInstance Method
- The Symbol.isConcatSpreadable Property
- The Symbol.match, Symbol.replace, Symbol.search, and Symbol.split Properties
- The Symbol.toPrimitive Method
- The Symbol.toStringTag Property
- The Symbol.unscopables Property
- Summary
- Chapter 7: Sets and Maps
- Sets and Maps in ECMAScript 5
- Problems with Workarounds
- Sets in ECMAScript 6
- Creating Sets and Adding Items
- Removing Items
- The forEach() Method for Sets
- Converting a Set to an Array
- Weak Sets
- Maps in ECMAScript 6
- Map Methods
- Map Initialization
- The forEach() Method for Maps
- Weak Maps
- Summary
- Chapter 8: Iterators and Generators
- The Loop Problem
- What Are Iterators?
- What Are Generators?
- Generator Function Expressions
- Generator Object Methods
- Iterables and for-of Loops
- Accessing the Default Iterator
- Creating Iterables
- Built-In Iterators
- Collection Iterators
- String Iterators
- NodeList Iterators
- The Spread Operator and Nonarray Iterables
- Advanced Iterator Functionality
- Passing Arguments to Iterators
- Throwing Errors in Iterators
- Generator Return Statements
- Delegating Generators
- Asynchronous Task Running
- A Simple Task Runner
- Task Running with Data
- An Asynchronous Task Runner
- Summary
- Chapter 9: Introducing JavaScript Classes
- Class-Like Structures in ECMAScript 5
- Class Declarations
- A Basic Class Declaration
- Why Use the Class Syntax?
- Class Expressions
- A Basic Class Expression
- Named Class Expressions
- Classes as First-Class Citizens
- Accessor Properties
- Computed Member Names
- Generator Methods
- Static Members
- Inheritance with Derived Classes
- Shadowing Class Methods
- Inherited Static Members
- Derived Classes from Expressions
- Inheriting from Built-Ins
- The Symbol.species Property
- Using new.target in Class Constructors
- Summary
- Chapter 10: Improved Array Capabilities
- Creating Arrays
- The Array.of() Method
- The Array.from() Method
- New Methods on All Arrays
- The find() and findIndex() Methods
- The fill() Method
- The copyWithin() Method
- Typed Arrays
- Numeric Data Types
- Array Buffers
- Manipulating Array Buffers with Views
- Similarities Between Typed and Regular Arrays
- Common Methods
- The Same Iterators
- The of() and from() Methods
- Differences Between Typed and Regular Arrays
- Behavioral Differences
- Missing Methods
- Additional Methods
- Summary
- Chapter 11: Promises and Asynchronous Programming
- Asynchronous Programming Background
- The Event Model
- The Callback Pattern
- Promise Basics
- The Promise Life Cycle
- Creating Unsettled Promises
- Creating Settled Promises
- Executor Errors
- Global Promise Rejection Handling
- Node.js Rejection Handling
- Browser Rejection Handling
- Chaining Promises
- Catching Errors
- Returning Values in Promise Chains
- Returning Promises in Promise Chains
- Responding to Multiple Promises
- The Promise.all() Method
- The Promise.race() Method
- Inheriting from Promises
- Promise-Based Asynchronous Task Running
- Summary
- Chapter 12: Proxies and the Reflection API
- The Array Problem
- Introducing Proxies and Reflection
- Creating a Simple Proxy
- Validating Properties Using the set Trap
- Object Shape Validation Using the get Trap
- Hiding Property Existence Using the has Trap
- Preventing Property Deletion with the deleteProperty Trap
- Prototype Proxy Traps
- How Prototype Proxy Traps Work
- Why Two Sets of Methods?
- Object Extensibility Traps
- Two Basic Examples
- Duplicate Extensibility Methods
- Property Descriptor Traps
- Blocking Object.defineProperty()
- Descriptor Object Restrictions
- Duplicate Descriptor Methods
- The ownKeys Trap
- Function Proxies with the apply and construct Traps
- Validating Function Parameters
- Calling Constructors Without new
- Overriding Abstract Base Class Constructors
- Callable Class Constructors
- Revocable Proxies
- Solving the Array Problem
- Detecting Array Indexes
- Increasing length When Adding New Elements
- Deleting Elements When Reducing length
- Implementing the MyArray Class
- Using a Proxy as a Prototype
- Using the get Trap on a Prototype
- Using the set Trap on a Prototype
- Using the has Trap on a Prototype
- Proxies as Prototypes on Classes
- Summary
- Chapter 13: Encapsulating Code with Modules
- What Are Modules?
- Basic Exporting
- Basic Importing
- Importing a Single Binding
- Importing Multiple Bindings
- Importing an Entire Module
- A Subtle Quirk of Imported Bindings
- Renaming Exports and Imports
- Default Values in Modules
- Exporting Default Values
- Importing Default Values
- Re-exporting a Binding
- Importing Without Bindings
- Loading Modules
- Using Modules in Web Browsers
- Browser Module Specifier Resolution
- Summary
- Appendix A: Minor Changes in ECMAScript 6
- Working with Integers
- Identifying Integers
- Safe Integers
- New Math Methods
- Unicode Identifiers
- Formalizing the __proto__ Property
- Appendix B: Understanding ECMAScript 7 (2016)
- The Exponentiation Operator
- Order of Operations
- Operand Restriction
- The Array.prototype.includes() Method
- How to Use Array.prototype.includes()
- Value Comparison
- A Change to Function-Scoped Strict Mode
- Index
- The Electronic Frontier Foundation (EFF)
- Updates
- Level Up Your JavaScript
