Promise.prototype.finally()

The `Promise.prototype.finally` method, introduced in ES9, is used to execute a specified callback after a Promise settles, regardless of fulfillment or rejection. It does not accept arguments nor alter the original Promise's value, primarily addressing code duplication in `then` and `catch`. It is commonly used for resource cleanup and state management. The key differences between `finally` and `then`/`catch` lie in parameter handling and return value impact. Its implementation is based on a special `then` call. When using it, be mindful of errors in the callback and asynchronous cleanup. It can be combined with async/await and other asynchronous features, but in performance-sensitive scenarios, microtask queue and memory overhead should be considered. Modern environments generally support it, while older ones may require a polyfill.

Asynchronous iterator (for-await-of)

ECMAScript 9 introduced asynchronous iterators and the `for await...of` loop, providing a more intuitive syntax for handling asynchronous data streams. Asynchronous iterators return their `next` method via the `Symbol.asyncIterator` method, which returns a Promise. The `for await...of` loop automatically waits for Promise resolution, making it suitable for scenarios like paginated APIs and streaming data. The article details the basic concepts of asynchronous iterators, practical applications such as fetching paginated data and stream processing, error handling methods, differences from synchronous iterators, implementation of custom asynchronous iterable objects, performance considerations, environment support, and comparisons with other asynchronous patterns. It highlights the advantages of asynchronous iterators in processing data incrementally and saving memory.

The dotAll mode in regular expressions translates this sentence into English.

ECMAScript 8 introduced the dotAll mode for regular expressions via the `s` flag, solving the issue where the traditional dot could not match line breaks. This feature enables the dot to truly match any character, including line breaks, eliminating the need for workarounds like `[\s\S]` when processing multiline text. The article details the technical implementation of dotAll mode, changes in engine parsing rules, and how to detect this mode using the `dotAll` property of regular expressions. Practical applications include parsing multiline logs, processing HTML templates, and extracting complex text. It also discusses browser compatibility considerations, performance impact analysis, and interactions with other regex features. Finally, it provides solutions to common issues and demonstrates how dotAll mode appears in regex visualization tools.

Regular expression lookbehind assertion

ECMAScript 8 introduced the reverse assertion feature in regular expressions, including positive lookbehind assertions and negative lookbehind assertions. A positive lookbehind assertion uses the syntax `(?<=...)` to match content that precedes a certain pattern, where the pattern itself is not included in the match result. A negative lookbehind assertion uses the syntax `(?<!...)` to match content that does not precede a certain pattern. These features are particularly useful in scenarios involving specific prefixes or suffixes, such as extracting currency values or excluding matches with specific prefixes. Reverse assertions can be combined with capturing groups to achieve complex matching logic, but it’s important to note that the pattern must be of fixed length. Practical applications include extracting configuration parameters, validating password strength, and more. When using these features, considerations such as browser compatibility and performance issues should be taken into account. Reverse assertions, when combined with other regular expression features, enable more powerful matching capabilities. However, common pitfalls, such as using non-fixed-length patterns, should be avoided.

Regular expression named capture groups

ECMAScript 8 introduced named capture groups in regular expressions, which significantly improved code readability and maintainability through semantic identifiers. The basic syntax defines the group name using a question mark and angle brackets inside parentheses. The matching results appear in the `groups` property. Compared to traditional numeric indices, named groups eliminate ambiguity in meaning. This feature supports destructuring assignment to simplify data extraction. In string replacement, named groups can be referenced via a dollar sign and angle brackets. Nested structures and backreferences are also well-supported. While modern browsers generally offer compatibility, older environments may require transpilation. Practical applications, such as log parsing, demonstrate clear advantages. In terms of performance, named capture groups are on par with regular capture groups. TypeScript also provides full type inference. Named capture groups can work seamlessly with all existing regex features, including non-capturing groups and various assertions.

Tail call optimization

Tail Call Optimization (TCO) is an important feature in functional programming. When the last step of a function calls another function, it is called a tail call. ECMAScript 8 introduced TCO support, enabling recursive functions to avoid stack overflow. Traditional calls create a new stack frame each time, which may lead to stack overflow. TCO optimizes by reusing the current stack frame, requiring that the call is the last step and does not need to access current variables, with the result directly returned. The ECMAScript 8 specification requires engines to implement TCO, allowing infinite recursion and making functional programming more efficient, with cleaner algorithms suitable for recursive algorithms, state machines, function composition, and other scenarios. Browser support varies: Safari fully supports it, while Chrome and Firefox require strict mode. Node.js has supported TCO since version 6.5.0, significantly improving performance, as seen in comparisons between traditional recursion and optimized versions. Common misconceptions include assuming all recursion is automatically optimized, ignoring strict mode requirements, and incomplete call stacks during debugging. Compared to other languages, JavaScript's TCO is part of the specification rather than a compiler optimization. Advanced applications include trampoline functions, CPS (Continuation-Passing Style) transformation, tail recursion template patterns, and more.

Object.values() and Object.entries()

Object.values and Object.entries are static methods added in ES8 for handling object properties. Object.values returns an array of the object's own enumerable property values, while Object.entries returns an array of key-value pairs. Neither method traverses prototype chain properties, making them suitable for scenarios like data transformation, object filtering, and form processing. Unlike Object.keys, they directly operate on property values or key-value pairs. Compared to for...in loops, they are safer as they do not access prototype chain properties. In frameworks like React and Vue, they simplify data processing. While they may impact performance with large objects, the effect is usually negligible. These methods can be combined with ES6 features like destructuring assignment and the spread operator. They are well-supported in modern browsers, but older environments require a polyfill.

SharedArrayBuffer and Atomics

ECMAScript 8 introduced SharedArrayBuffer and the Atomics object to support multithreaded programming in JavaScript. SharedArrayBuffer allows multiple Web Workers to share memory, while Atomics provides atomic operations to ensure thread safety. The article explains the basic concepts in detail, including creating shared buffers and atomic operation methods. It introduces practical application scenarios such as counter synchronization and inter-thread communication, discusses the memory model and sequential consistency, and emphasizes security considerations and browser restrictions. It also provides performance optimization techniques and debugging methods, covers browser compatibility best practices, and explores integration with WebAssembly. Finally, it examines advanced usage patterns, performance testing, and interoperability with other languages.

Trailing commas in function parameter lists and calls

The trailing comma feature for function parameter lists introduced in ECMAScript 8 allows adding a comma after the last parameter in function declarations and calls without causing errors. This change improves code maintainability and version control friendliness, particularly when maintaining multi-line parameter lists or reordering parameters. The feature aligns with the trailing comma conventions for objects and arrays, maintaining consistency with TypeScript and other programming languages. In practical engineering, it reduces merge conflicts and code generation complexity. While mainstream code style guides offer varying recommendations on trailing commas, the toolchain now fully supports this feature with no performance impact. Frequently asked questions clarify related concerns such as the function `length` property and arrow functions.

The string padding methods padStart() and padEnd()

ECMAScript 8 introduced the `padStart` and `padEnd` string padding methods, which are used to pad the beginning or end of the original string with specified characters until the target length is reached. `padStart` pads at the beginning, while `padEnd` pads at the end. Both methods share similar syntax, accepting a target length and an optional padding string parameter (defaulting to spaces). If the original string's length exceeds the target length, it is returned directly. If the padding string is too long, it will be truncated. These methods are highly practical for scenarios like formatting output, aligning text, padding numbers with leading zeros, or generating fixed-length IDs. Compared to manual implementations, they provide a more concise and efficient solution. For example, they can be used to format dates, align table data, or create fixed-length identifiers.