JavaScript Just Leveled Up: ES2025 - You'll Fall in Love With

"Tired of endless conditionals? Pattern matching transforms branching logic into declarative expressions. Old approach: function handleResponse(response) { if (response.status === 200 && response.data) { return response.data; } else if (response.status === 401) { throw new Error('Unauthorized'); } else if (response.status === 404) { throw new Error('Not Found'); } else if (response.status >= 500) { throw new Error('Server Error'); } else { throw new Error('Unknown Error'); } } New ES2025 magic: function handleResponse(response) { return match (response) { when ({ status: 200, data }) -> data when ({ status: 401 }) -> throw new Error('Unauthorized') when ({ status: 404 }) -> throw new Error('Not Found') when ({ status: s if s >= 500 }) -> throw new Error('Server Error') default -> throw new Error('Unknown Error') }; } It's concise, readable, and surprisingly powerful like switch statements on steroids."

"Array pattern matching: const analyzeArray = (arr) => match (arr) { when ([]) -> Empty array when ([x]) -> `Single element: ${x}` when ([x, y]) -> `Two elements: ${x}, ${y}` when ([first, ...rest]) -> `First: ${first}, Remaining: ${rest.length}` }; The pipeline operator |> lets you chain operations without deep nesting. Old way (callback spaghetti): const result = encodeURIComponent( JSON.stringify( Object.values( Object.fromEntries( Object.entries(data).filter(([k, v]) => v != null) ) ) ) ); ES2025 way: const result = data |> Object.entries(%) |> (%.filter(([k, v]) => v != null)) |> Object.fromEntries(%) |> Object.values(%) |> JSON."

Pattern matching replaces verbose conditional chains with declarative match expressions using when clauses, object and array patterns, guards, and a default branch. Array patterns support fixed shapes, rest elements, and direct extraction of values. The pipeline operator (|> ) with a % placeholder enables linear chaining of transformations without nested calls. These features shorten common idioms like response handling and data serialization, reduce boilerplate, and improve readability. The combined effect encourages expressive, maintainable code and more functional, composition-friendly patterns for control flow and data processing in modern JavaScript.

Read at jsdevspace.substack.com