Arrow functions cannot be used as object constructors, that is, the new operator cannot be applied to them.
Apart from syntax, the value, and the new operator, everything else is the same between arrow and traditional functions, that is, they are both instances of the Function constructor.
Other differences between arrow and traditional functions
by Narayan Prusty, Mehul Mohan
Learn ECMAScript - Second Edition
- Title Page
- Copyright and Credits
- PacktPub.com
- Contributors
- Preface
- Getting Started with ECMAScript
- The let keyword
- The const keyword
- Immutability in JavaScript
- Default parameter values
- The spread operator
- The rest parameter
- Hoisting
- Destructuring assignments
- Arrow functions
- Enhanced object literals
- Trailing commas and JavaScript
- The semicolon dilemma
- Summary
- Knowing Your Library
- Working with numbers
- Doing math
- Arrays
- The Array.from(iterable, mapFunc, this) method
- The Array.of(values…) method
- The fill(value, startIndex, endIndex) method
- The includes() method
- The includes() versus the indexOf() method
- The find(testingFunc) method
- The findIndex(testingFunc) method
- The copyWithin(targetIndex, startIndex, endIndex) function
- The entries(), keys(), and values() methods
- Array iteration
- Collections
- Objects
- Summary
- Using Iterators
- Asynchronous Programming
- Modular Programming
- Implementing the Reflect API
- The Reflect object
- The Reflect.apply(function, this, args) method
- The Reflect.construct(constructor, args, prototype) method
- The Reflect.defineProperty(object, property, descriptor) method
- The Reflect.deleteProperty(object, property) method
- The Reflect.get(object, property, this) method
- The Reflect.set(object, property, value, this) method
- The Reflect.getOwnPropertyDescriptor(object, property) method
- The Reflect.getPrototypeOf(object) method
- The Reflect.setPrototypeOf(object, prototype) method
- The Reflect.has(object, property) method
- The Reflect.isExtensible(object) method
- The Reflect.preventExtensions(object) method
- The Reflect.ownKeys(object) method
- Summary
- The Reflect object
- Proxies
- Proxies in a nutshell
- Working with the Proxy API
- Proxy traps
- The get(target, property, receiver) method
- The set(target, property, value, receiver) method
- The has(target, property) method
- The isExtensible(target) method
- The getPrototypeOf(target) method
- The setPrototypeOf(target, prototype) method
- The preventExtensions(target) method
- The getOwnPropertyDescriptor(target, property) method
- The defineProperty(target, property, descriptor) method
- The deleteProperty(target, property) method
- The ownKeys(target) method
- The apply(target, thisValue, arguments) method
- The construct(target, arguments) method
- The Proxy.revocable(target, handler) method
- Proxy traps
- The uses of proxies
- Summary
- Classes
- Understanding object-oriented JavaScript
- Using classes
- Defining a class
- The class expression
- The prototype methods
- Static methods
- Implementing inheritance in classes
- Computed method names
- The attributes of properties
- Classes are not hoisted!
- Overriding the result of the constructor method
- The Symbol.species static accessor property
- The new.target implicit parameter
- Using super in object literals
- Summary
- JavaScript on the Web
- HTML5 and the rise of modern JavaScript
- Modern JavaScript browser APIs
- Page Visibility API - is the user still on the page?
- navigator.onLine API – the user's network status
- Clipboard API - programmatically manipulating the clipboard
- The Canvas API - the web's drawing board
- The Fetch API - promise-based HTTP requests
- Accessing and modifying history with the history API
- Summary
- Storage APIs in JavaScript
- Web and Service Workers
- An introduction to the concept of threads
- Introduction to web workers
- Checking if worker support is available
- Working with dedicated web workers
- Working with shared workers
- Introduction to inline web workers
- Same origin policy
- Working with service workers
- Summary
- Shared Memory and Atomics
- Basics of memory
- What is shared memory?
- Understanding parallel programming
- What are atomics?
- Information about lock and mutex
- Atomics in JavaScript
- Using the Atomics.load(typedArray, index) method
- Using the Atomics.add(typedArray, index, value) method
- Using the Atomics.sub(typedArray, index, value) method
- Using the Atomics.and(typedArray, index, value) method
- Using the Atomics.or(typedArray, index, value) method
- Using the Atomics.xor(typedArray, index, value) method
- Fixing one billion count with atomics
- A peek into Spectre
- Summary
- Other Books You May Enjoy
Other differences between arrow and traditional functions
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.