7 Single-Line Helpful Functions in JavaScript

Let's be honest, sometimes JavaScript code can get a bit… long. But guess what? For a lot of everyday coding tasks, you don't need pages of code! Sometimes, just one single line is enough to do the trick brilliantly. It's like finding a secret shortcut that makes your coding life way easier and faster.

Here are seven of these super-efficient, single-line JavaScript functions that can seriously boost your development skills and make your code cleaner and simpler:

1. Array Deduplication in a Snap!

Ever got an array cluttered with repeated items? This single line is your cleanup crew, instantly removing any duplicates!

javascript
const uniqueArray = arr => [...new Set(arr)];

You've got a shopping list with extra items accidentally added. This function is like quickly scanning the list and keeping only one of each item, so you don’t buy the same thing twice!

javascript
const numbers = [1, 2, 2, 3, 4, 4];
console.log(uniqueArray(numbers)); // [1, 2, 3, 4]

It works its magic by using something called a Set. Think of a Set as a special container that only holds unique things. We throw our array into this Set, and poof! Duplicates vanish. Then, the [...] part spreads those unique items back into a fresh, clean array. Super slick!

2. Object Emptiness Check in a Flash!

Need to quickly know if a JavaScript object is completely empty, like a drawer with nothing inside? This one-liner is your instant object emptiness detector:

javascript
const isEmptyObject = obj => Object.keys(obj).length === 0;

You have a box, and you want to know if it’s empty. This function is like shaking the box and listening – if there’s nothing rattling around (length === 0), it’s empty!

javascript
const obj = {};
console.log(isEmptyObject(obj)); // true

It cleverly uses Object.keys(obj) to get a list of all the ‘keys’ (or labels) in your object. If that list is empty (meaning the length is zero), then you know your object is indeed empty. Quick and to the point!

3. Grab a Random Item from an Array Instantly!

Want to randomly pick an item from a list, like choosing a random name from a hat? This single line is your lucky dip:

javascript
const getRandomElement = arr => arr[Math.floor(Math.random() * arr.length)];

You have a jar of candies, and you want to grab one without looking. This function is like reaching into the jar and picking one candy at random!

javascript
const colors = ['red', 'green', 'blue'];
console.log(getRandomElement(colors)); // e.g., 'green'

It works by generating a random number that corresponds to a position within your array. Math.random() * arr.length creates a random number, and Math.floor() makes sure it’s a whole number, perfect for picking an item at that random spot in your array. Totally random, totally easy!

4. Array Value Check in a Blink!

Need to check if a specific value is hiding inside an array? This single line function is like a quick scanner:

javascript
const arrayContains = (arr, value) => arr.includes(value);

You're searching for your keys in your bag. This function is like quickly checking if your keys (value) are ‘included’ in your bag (arr).

javascript
const fruits = ['apple', 'banana', 'cherry'];
console.log(arrayContains(fruits, 'banana')); // true

It uses the super handy includes(value) method, which is like asking the array directly, "Hey, are you holding this value?". It instantly gives you back a simple true or false answer. No fuss!

5. String to Title Case in a Jiffy!

Want to make your strings look more polished by capitalizing the first letter of each word, like turning "hello world" into "Hello World"? This one-liner is your instant style upgrade:

javascript
const toTitleCase = str => str.replace(/\b\w/g, char => char.toUpperCase());

Think of it as getting a title makeover! You have a sentence that's all lowercase, and this function is like a magic wand that capitalizes the beginning of each word, making it look like a proper title.

javascript
const title = 'hello world';
console.log(toTitleCase(title)); // 'Hello World'

It uses a bit of code wizardry with replace(/\b\w/g, ...) and a ‘regular expression’ to find the first letter of each word (\b\w) and then transforms it to uppercase (char.toUpperCase()). A little bit fancy, but incredibly effective!

6. Flatten Nested Arrays in One Go!

Dealing with arrays inside arrays inside arrays? This single line is your array de-nesting machine, turning a complicated nested array into a simple flat list:

javascript
const flattenArray = arr => arr.flat(Infinity);

Imagine you have boxes within boxes within boxes. This function is like opening up all the boxes and laying out all the contents in a single line, so everything is easy to see!

javascript
const nestedArray = [1, [2, [3, [4, [5]]]]];
console.log(flattenArray(nestedArray)); // [1, 2, 3, 4, 5]

It uses the ,mark>flat(Infinity) method, which is like saying, "Hey JavaScript, flatten this array as much as possible, no matter how deep it’s nested!". Infinity here means it’ll go as deep as it needs to, ensuring even the most deeply nested arrays become perfectly flat. Total array organization!

7. Deep Merge Objects Like a Pro!

Need to merge two JavaScript objects, even if they have nested objects inside, and make sure you combine them properly? This single line is your object-merging powerhouse:

javascript
const deepMerge = (obj1, obj2) => Object.assign({}, obj1, Object.keys(obj2).reduce((acc, key) => ({ ...acc, [key]: (typeof obj2[key] === 'object' && obj2[key] !== null && obj1[key] && typeof obj1[key] === 'object') ? deepMerge(obj1[key], obj2[key]) : obj2[key] }), {}));

Think of it like mixing two sets of ingredients for a recipe. You have two objects, each with their own properties (like ingredients). This function carefully combines them, and if they both have some of the same properties (nested ingredients), it smartly merges those too, creating a super-combined object!

javascript
const obj1 = { a: 1, b: { c: 2, d: 3 } };
const obj2 = { b: { d: 4, e: 5 }, f: 6 };
console.log(deepMerge(obj1, obj2)); // { a: 1, b: { c: 2, d: 4, e: 5 }, f: 6 }

This one is a bit more involved under the hood, using Object.assign() and reduce() to smartly handle merging. It checks if properties are objects themselves and, if so, it merges them recursively, ensuring a truly ‘deep’ merge. Powerful object combining at your fingertips!

Conclusion

These single-line functions are like little coding gems that can really simplify your JavaScript work. They’re not just about writing less code; they're about writing clearer and more efficient code. By using these concise patterns for common tasks, you make your code easier to read, easier to maintain, and just a little bit more elegant. Sometimes, less truly is more in the world of coding – and these one-liners prove it!