Top JavaScript One-Liners in 2025

JavaScript is not just a versatile programming language; it’s also a playground for clever hacks and concise expressions. In 2025, developers continue to utilize one-liners effectively for various tasks, demonstrating the power of JavaScript’s syntax and functionality. This article highlights some of the most useful JavaScript one-liners that can make your code cleaner and easier to read.

Why Use One-Liners?

One-liners are not just about brevity; they can enhance code readability, reduce the chance of errors, and encapsulate logic in a more maintainable way. They are also great for writing quick scripts or functions that need to perform a task without requiring many lines of code. As developers, embracing one-liners can lead to more efficient programming practices.

Common JavaScript One-Liners

1. Array Manipulation

JavaScript provides a wealth of built-in methods for array manipulation, many of which can be neatly expressed as one-liners.

Flatten an Array

const flatArray = arr.flat(); // Flattens a nested array

For example, if you have a nested array and want to flatten it:

const nestedArray = [[1, 2], [3, 4], [5]];
const flatArray = nestedArray.flat(); // Output: [1, 2, 3, 4, 5]

Filter Out Duplicates

const uniqueItems = [...new Set(arr)]; // Remove duplicates

This one-liner converts your array into a Set (which excludes duplicates) and then back to an array:

const items = [1, 2, 2, 3, 4, 4];
const uniqueItems = [...new Set(items)]; // Output: [1, 2, 3, 4]

2. Conditional Operations

JavaScript is famous for its conditional (ternary) operator that allows you to execute conditions succinctly.

Check for Value

const isEven = (num) => num % 2 === 0 ? 'Even' : 'Odd';

A simple function to check if a number is even or odd:

console.log(isEven(3)); // Output: 'Odd'

Fuzzy Search

const found = arr.some(item => item.includes('keyword')) ? 'Found' : 'Not Found';

This one-liner checks if any of the array items contain a certain keyword:

const words = ['apple', 'banana', 'grape'];
const found = words.some(word => word.includes('an')) ? 'Found' : 'Not Found'; // Output: 'Found'

3. Object Manipulation

Working with objects can be made easier with compact syntax and one-liners.

Clone an Object

const clone = {...originalObject}; // Shallow clone

Cloning objects has never been easier:

const originalObject = { a: 1, b: 2 };
const clone = {...originalObject}; // Output: { a: 1, b: 2 }

Merge Two Objects

const merged = {...obj1, ...obj2}; // Merges obj1 and obj2

This simple approach merges two objects into one:

const obj1 = { a: 1 };
const obj2 = { b: 2 };
const merged = {...obj1, ...obj2}; // Output: { a: 1, b: 2 }

4. String Manipulation

JavaScript offers various ways to work with strings effectively.

Reverse a String

const reverseString = str => str.split('').reverse().join('');

A quick way to reverse a string:

console.log(reverseString('hello')); // Output: 'olleh'

Title Case a String

const titleCase = str => str.toLowerCase().split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');

This one-liner capitalizes the first letter of each word:

console.log(titleCase('hello world')); // Output: 'Hello World'

5. Functional Programming

JavaScript’s support for functional programming allows for elegant solutions with concise syntax.

Map with Condition

const mapped = arr.map(x => (x > 10 ? x * 2 : x));

This one-liner doubles values greater than 10 while leaving others unchanged:

const arr = [5, 15, 25, 3];
const mapped = arr.map(x => (x > 10 ? x * 2 : x)); // Output: [5, 30, 50, 3]

Reduce with Initialization

const sum = arr.reduce((acc, val) => acc + val, 0);

Calculating the sum of an array with an initial value:

const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((acc, val) => acc + val, 0); // Output: 10

6. DOM Manipulation

DOM manipulation is another area where one-liners shine, allowing for rapid adjustments to the web page structure.

Add a Class to an Element

document.querySelector('#element').classList.add('new-class');

This will add a new class to a specified element:

<div id="element">Content</div>

document.querySelector('#element').classList.add('highlight');

Remove all Child Elements

document.querySelector('#parent').innerHTML = ''; // Clear children

A quick way to clear all child elements of a parent:

<div id="parent"><div>Child 1</div><div>Child 2</div></div>

7. Promise Handling

Handling asynchronous operations can also be done elegantly with one-liners.

Fetch Data

fetch(url).then(res => res.json()).then(data => console.log(data));

A neat way to fetch and log data:

const url = 'https://api.example.com/data';
fetch(url).then(res => res.json()).then(data => console.log(data));

Wait for Multiple Promises

Promise.all([promise1, promise2]).then(results => console.log(results));

This one-liner waits for all promises to resolve:

const promise1 = Promise.resolve(5);
const promise2 = new Promise((resolve) => setTimeout(resolve, 1000, 10));
Promise.all([promise1, promise2]).then(results => console.log(results)); // Output: [5, 10]

Best Practices for Writing JavaScript One-Liners

While one-liners can be handy, it’s essential to follow best practices to ensure readability and maintainability:

• Keep Them Simple: Avoid overly complex one-liners that may confuse others reading your code.
• Utilize Readable Names: Use clear variable names that help convey the functionality of the code.
• Comment When Necessary: If a one-liner is doing something non-obvious, a brief comment can help others understand your thought process.
• Avoid Side Effects: It’s generally better to avoid side effects in one-liners to keep your functions predictable.

Conclusion

JavaScript one-liners can be a powerful tool in your coding arsenal. They can make your code cleaner, more efficient, and easier to read. As you continue to explore the capabilities of JavaScript, don’t hesitate to experiment with one-liners that can simplify your tasks. Remember, coding is not only about making it work, but also about making it clear and maintainable.

Happy coding! Feel free to share your favorite JavaScript one-liners in the comments below!