10 Helpful JavaScript Utility Functions

In this discussion, we'll explore ten personalized utility functions in JavaScript designed to be useful across a variety of projects.

01. `console.log()`

Yes, the tool we all love and use for printing, debugging, etc. So, why not shorten it to reduce typing and save some time?

const { log } = console;
log("Hello world!");
// Expected output: Hello world!
// SAME AS //
console.log("Hello world!");
// Expected output: Hello world!

Explanation: we use the destructuring assignment to be able to extract the log method from the console.

---

02. `querySelector()`

In the realm of JavaScript, you've likely encountered the concept of DOM Manipulation, employing methods like getElementById(), querySelector(), and others to interact with DOM elements. To simplify this process, let's delve into a more user-friendly approach.

const select = (selector, scope = document) => {
  return scope.querySelector(selector);
};
const title = select("h1");
const className = select(".class");
const message = select("#message", formElem);
// SAME AS //
const title = document.querySelector("h1");
const className = document.querySelector(".class");
const message = formElem.querySelector("#message");

Explanation: We're passing 2 parameters in the select() function:

• 1st: DOM element you want to select
• 2nd: Scope from which you access that element (default = document);

---

03. `addEventListener()`

Handling the click, mousemove and other events are mostly implemented with the addEventListener() method.

const listen = (target, event, callback, ...options) => {
  return target.addEventListener(event, callback, ...options);
};
listen(buttonElem, "click", () => console.log("Clicked!"));
listen(document, "mouseover", () => console.log("Mouse over!"));
listen(formElem, "submit", () => {
    console.log("Form submitted!");
  }, { once: true }
);

Explanation: We're passing 4 parameters in the listen() function:

• 1st: Element you want to target (e.g. 'window', 'document' or specific DOM element)
• 2nd: Event type (e.g. 'click', 'submit', 'DOMContentLoaded', etc.)
• 3rd: Callback function
• 4th: Remaining optional options (e.g. 'capture', 'once', etc.). Also, we use the spread syntax to allow for other options if necessary. Otherwise, it can be omitted just like in the addEventListener method.

---

04. `random()`

You might probably be aware of Math.random() function that generates random numbers from 0 to 1. You might also know about other hacks, like Math.random() * 10, which should now generate random numbers from 0 to 10. However, the problem is that despite knowing the limit, we don't have much control over the minimum value.

const random = (min, max) => {
  return Math.floor(Math.random() * (max - min + 1)) + min;
};
random(5, 10);
// 7

Explanation: Here's the better explanation by MDN Docs

---

05. `times()`

Sometimes, we often find ourselves in need of running a particular function several times.

Of course, we can use setInterval() to run every interval amount of time like this:

setInterval(() => {
  randomFunction();
}, 5000); // runs every 5 seconds

The problem is that we aren't able to specify how many times we want to run it. So, let's fix it!

const times = (func, n) => {
  Array.from(Array(n)).forEach(() => {
    func();
  });
};
times(() => {
  randomFunction();
}, 3); // runs 3 times

Explanation:

• Array(n) - creates a new array with the length of n.

Array(5); // => [,,]

• Array.from() - creates a shallow copy from Array(n). It helps us to make an array to be usable, filling it with 'undefined'. You can also use the Array.prototype.fill() method to achieve the same result.

Array.from(Array(3)); // => [undefined,undefined,undefined]

Note: While researching this utility function, I realized that some programmers prefer to put the n parameter first and then the function times(n, func). But, it looked kinda weird to me, so I decided to swap their places, thus making the syntax more similar to the setInterval() function:

setInterval(func, delay);
times(func, n);

Also, you call it setTimes() instead of times() to match with the setInterval() and setTimeout() methods depending on your preferences.

---

06. `slugify()`

Have you ever found yourself in need of turning the title of your blog articles into a 'URL-like' format?

JS Utility Functions => js-utility-functions

Here is a little utility function that does so:

const slugify = (string, separator = "-") => {
  return string
    .toString() // Cast to string (optional)
    .toLowerCase() // Convert the string to lowercase letters
    .trim() // Remove whitespace from both sides of a string (optional)
    .replace(/\s+/g, separator) // Replace spaces with -
    .replace(/[^\w\-]+/g, "") // Remove all non-word chars
    .replace(/\_/g, separator) // Replace _ with -
    .replace(/\-\-+/g, separator) // Replace multiple - with single -
    .replace(/\-$/g, ""); // Remove trailing -
};
slugify("Hello, World!");
// Expected output: "hello-world"
slugify("Hello, Universe!", "_");
// Expected output: "hello_universe"

Explanation: Here is the discussion by the GitHub community

---

07. `validateEmail()`

When working on small projects and trying out email validation for your form, you can use this super simple method to achieve your goal. Also, it can be very handy for small tests.

const validateEmail = (email) => {
  const regex = /^\S+@\S+\.\S+$/;
  return regex.test(email);
};
validateEmail("youremail@org.com"); // true
validateEmail("youremail@com"); // false
validateEmail("youremail.org@com"); // false

Explanation: You can play around with the regex here.

• RegExp.test() searches if the provided regex expression matches with the string

Note: For larger projects, I would recommend using libraries like validator.js to handle heavy lifting for you.

---

08. `capitalize()`

We have built-in toUpperCase() and toLowerCase() methods in JavaScript. However, we don't have built-in support for capitalization. So, let's build one!

const capitalize = (str) => {
  const arr = str.trim().toLowerCase().split(" ");
  for (let i = 0; i < arr.length; i++) {
    arr[i] = arr[i].charAt(0).toUpperCase() + arr[i].slice(1);
  }
  return arr.join(" ");
};
capitalize("hello, world!");
// Expected output: "Hello, World!"

Explanation:

• split() - turns the string into an array
• arr[i].charAt(0).toUpperCase() - upper cases the 1st letter of each word
• arr[i].slice(1) - returns the remaining word letters.
• arr.join(" ") - turns the array back into string

---

09. `sanitizeHTML()`

Ever heard of Cross-site scripting (XSS) attacks? If not, it's a type of attack that occurs on most websites. For example, when submitting a form, an attacker might try to send malicious scripts to break into the system. To prevent this from happening on your forms, you can use this handy function that will "sanitize" the script code.

const sanitizeHTML = (str) => {
  const div = document.createElement("div");
  div.textContent = str;
  return div.innerHTML;
};
sanitizeHTML("<h1>Hello, World!</h1>");
// Expected output: "&lt;h1&gt;Hello, World!&lt;/h1&gt;"

Explanation: Unlike innerHTML, textContent does not parse the string as HTML, while innerText only shows "human-readable" elements.

Moreover, using textContent can prevent XSS attacks. - MDN Docs

---

10. `localStorage`

You might have used localStorage in your to-do list applications or any other projects to save the particular data in the user's computer memory. When getting and setting items, you have to use JSON parse() and stringify() methods to achieve the desired result. So, let's make it easier to work with them.

const storage = {
  get: (key, defaultValue = null) => {
    const value = localStorage.getItem(key);
    return value ? JSON.parse(value) : defaultValue;
  },
  set: (key, value) => localStorage.setItem(key, JSON.stringify(value)),
  remove: (key) => localStorage.removeItem(key),
  clear: () => localStorage.clear(),
};
storage.set("motto", "Eat, Sleep, Code, Repeat");
storage.get("motto");

Explanation: If you aren't aware of JSON parse() and stringify() methods, check out the MDN Docs for a better explanation.

Note: It was quite tough for me to come up with a good name that would make much more sense than just storage. Because at first glance, developers might not know whether it's referring to the 'localStorage' or something else. However, you can name it whatever you want. Also, if you've found any good names, please do let me know in the comments section.

Conclusion

If you've any questions or suggestions, the comment section is all yours. We might make part 2 of this article with your suggestions.

Thanks for reading!