Learn how the latest JavaScript features can help you improve your codebase. 

[Array Grouping](https://github.com/tc39/proposal-array-grouping) is the new feature of JavaScript/ECMAScript, which splits an array (or, generally, an iterable), into smaller sub-arrays. Grouping is different than other JS array methods - it's *not* a part of the array prototype, but a static method.

Group data by keys using JavaScript Array Grouping (Object.groupBy)

Finding elements starting from the end of an array has gotten a lot easier with the introduction of the `at`, `findLast`, and `findLastIndex` methods!

With `at` you no longer need to remember to access the end of the array like `array[array.length - 1]` trick. You can just call `.at[-1]` to get the last element!

`findLast` and `findLastIndex` work the same as their `find` and `findIndex` counterparts. But, they work backwards from the end of the array. This is useful if you know what you're accessing is going to be closer to the end.

Find Items from the end of the JavaScript Array using at, findLast and findLastIndex

The ["Set Methods"](https://github.com/tc39/proposal-set-methods) proposal introduces 7 new methods to JavaScript/ECMAScript:
- `union`
- `intersection`,
- `difference`,
- `symmetricDifference`,
- `isSubsetOf`
- `isSupersetOf`
- `isDisjointFrom`

Thanks to them, complex operations using JavaScript sets will become much easier.

Perform Set Operations using JavaScript Set Methods

You no longer need to write generator functions to create basic lazy iterator functions.

Now, ECMAScript supports iterator helpers that you can call on `Array.values()`. With these helpers, the values of an array will be operated on lazily, and will only run when the values are needed.



Make JavaScript computations lazy using Iterator Helpers

The new [Array.with](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/with) method gives you an immutable syntax for changing values of an array at a specified index. 

Sometimes `.map` will be more efficient. So, in this lesson we'll compare both methods while replacing an object at a specific index.


Simplify array immutable changes with the new array.with method

The [Logical Assignment Operators](https://github.com/tc39/proposal-logical-assignment) bring syntactic sugar over verbose syntax which enforced us to write explicit `if` statements. Thanks to the new operators `||=`, `&&=` and `??=` we can express the conditional logic in a more concise way.

Simplify JavaScript code with Logical, Assignment and Optional Operators

If we want to be able to modify the state of a promise from outside the constructor, we can use the [Promise.withResolvers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers) method to get access to the promise, and its `resolve` and `reject ` functions. 



Manually settle a promise using Promise.withResolvers

[Promise.any](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any) takes an iterable of promises and returns a promise that fulfills with the first promise that fulfills, and rejects when ALL of the promises in the iterable reject. 

[Promise.allSettled](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled) takes an iterable of promises, and returns an array of objects. The objects have a `status` property which is a string that is either `"fulfilled"` or `"rejected"`. If the `status` is `"fulfilled"` the object will contain a `value` property with the resolved value of the promise, and if the `status` is `"rejected"` the object will have a `reason` property with the reason for the promise's rejection. 

Manage Asynchronous JavaScript code with any, allSettled new Promise Methods

You can finally make your numbers more readable in JavaScript. Add underscores in all types of numbers including BigInt, floats, hexes, octals, and binary to improve their readability. 

Just don't add the underscores to the beginning or end!

Make JavaScript Numbers more readable using Numeric Separators

The new [cause](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause) data property that you can add to a thrown `Error` can be used to retain access to the original error caught in a promise rejection. 

Learn the Latest ECMAScript Features (ES2024, ES2023, ...)

Instructor

Course Content