Modern JavaScript ES2024: New Features and Improvements

JavaScript continues to evolve with exciting new features. Let's explore what ES2024 brings to the table.

New Array Methods

Array.prototype.toSorted()

Create a sorted copy without mutating the original:

const numbers = [3, 1, 4, 1, 5];
const sorted = numbers.toSorted(); // [1, 1, 3, 4, 5]
console.log(numbers); // [3, 1, 4, 1, 5] (unchanged)

Array.prototype.toReversed()

Create a reversed copy:

const arr = [1, 2, 3];
const reversed = arr.toReversed(); // [3, 2, 1]
console.log(arr); // [1, 2, 3] (unchanged)

Array.prototype.with()

Create a copy with one element changed:

const arr = ['a', 'b', 'c'];
const newArr = arr.with(1, 'x'); // ['a', 'x', 'c']

Pattern Matching (Proposal)

Pattern matching provides a more elegant way to handle complex conditionals:

const result = match (value) \{
  when (0) -> 'zero',
  when (n if n > 0) -> 'positive',
  when (n if n < 0) -> 'negative',
  default -> 'unknown'
\};

Improved Error Handling

Error.cause

Chain errors with better context:

try \{
  doSomething();
\} catch (error) \{
  throw new Error('Operation failed', { cause: error \});
}

Record and Tuple (Proposal)

Immutable data structures:

const record = #\{ name: 'John', age: 30 \};
const tuple = #[1, 2, 3];

// These are deeply immutable
const newRecord = #\{ ...record, age: 31 \};

Temporal API

Better date and time handling:

const now = Temporal.Now.plainDateTimeISO();
const birthday = Temporal.PlainDate.from('1990-05-15');
const age = now.toPlainDate().since(birthday).years;

Private Fields in Classes

True privacy in JavaScript classes:

class User \{
  #password;
  
  constructor(username, password) {
    this.username = username;
    this.#password = password;
  \}
  
  #validatePassword() \{
    return this.#password.length >= 8;
  \}
  
  login() \{
    if (this.#validatePassword()) {
      return 'Login successful';
    \}
    return 'Invalid password';
  }
}

Best Practices

1. Use immutable methods when possible
2. Leverage pattern matching for complex logic
3. Implement proper error chaining
4. Adopt the Temporal API for date operations
5. Use private fields for true encapsulation

These features make JavaScript more powerful and developer-friendly than ever before.