You Might Not Need Lodash
Tags: javascript
Published: 2018-03-15 05:18:06

---
title: You Might Not Need Lodash
published: true
description: My favorite Lodash methods replaced by JavaScript native methods
tags: JavaScript
---

*You can check out more of my tutorials and articles on my [main blog](https://antjanus.com/). Enjoy the article!*

While Lodash may have become a staple in any JavaScript developer's toolkit, a lot of the methods in it have slowly migrated over to being part of JavaScript itself or rather part of the EcmaScript spec.

Lodash isn't huge, in fact, it's very light, and properly imported and tree-shaken, its size can be negligible but why bother with all of that if you might not need it in the first place?

Here's a collection of my favorite Lodash methods and how to substitute them with ES2015+ native methods. Sometimes the substitution is 1-to-1, sometimes it's not. I'll make sure to note that

**Note:** Lodash methods tend to be super short and sweet. If you've never looked through an open source codebase, I highly recommend [Lodash's github repo](https://github.com/lodash/lodash)

### _.toArray: Object.values + Array.from

Simply put, you're converting *something* into an array. Most commonly, I've used this method to convert a lookup object like so:

```js
const postAuthors = {
  'Antonin Januska': { id: 1, name: 'Antonin Januska', role: 'author' },
  'JK Rowling': { id: 2, name: 'JK Rowling', role: 'real author' },
};
```

into an iterable array for display purposes. Well now, I can use this method:

```js
const postAuthorsArray = Object.values(postAuthors);

/** result:
[
  { id: 1, name: 'Antonin Januska', role: 'author' },
  { id: 2, name: 'JK Rowling', role: 'real author' }
]
**/
```

Look up objects can be handy for creating unique lists, aggregating data, and well, looking things up. More often than not, that object then has to be converted into an array to be used for other things.

What about `Array.from`? Well, `_.toArray` supports converting other variable types into arrays, not just objects. For those, `Array.from` makes more sense. Here are some examples:

```js
const dnaStrand = 'gattaca';
const dnaArray = Array.from(dnaStrand); // results in ['g', 'a', 't', 't', 'a', 'c', 'a'];

const someNumber = 3;
const result = Array.from(someNumber); // results in []. Not sure what this is used for but lodash supports this

```

Unfortunately, that's where the 1-to-1 parity ends. Neither Array.from nor Object.values supports converting nulls into empty arrays.

### _.clone: Object/Array spread

Cloning an object or an array is pretty useful. In either case, manipulating the result means that you don't affect the source data. It can also be used to create new objects/arrays based on some template. 

JavaScript does not have a shortcut for deepClone so be wary, nested objects are not cloned and the references are kept. Also, cloning an array of objects makes the array safe to manipulated, not the objects themselves.

There are several ways to achieve the same result, I'll stick to object/array spread:

```js
const clonedObject = { ...sourceObject };
const clonedArray = [ ...sourceArray ];
```

Unlike lodash, utilizing JavaScript's built-in methods requires you to know their type. You can't spread an object into an array and vice-versa to achieve a clone.

### _.assign/_.extend: Object.assign

Assign/extend allow you to essentially "merge" an object into another object, overwriting its original properties (note: this is unlike `_.merge` which has some caveats to it). I actually use this all the time!

To achieve this without lodash, you can use `Object.assign` which the lodash docs even reference.

```js
const sourceObject = { id: 1, author: 'Antonin Januska' };

Object.assign(sourceObject, {
  posts: [],
  topComments: [],
  bio: 'A very cool person',
});

/** result:
{
  id: 1,
  author: 'Antonin Januska',
  posts: [],
  topComments: [],
  bio: 'A very cool person',
}

note: this is still sourceObject
**/
```

Object.assign will fill use the 2nd (3rd, 4th, etc.) arguments to fill in the `sourceObject`. 

What if you want the result to be a new object and keep immutability? EASY, just specify an empty object as the first argument!

```js
const sourceObject = { id: 1, author: 'Antonin Januska' };

const finalObject = Object.assign({}, sourceObject, {
  posts: [],
  topComments: [],
  bio: 'A very cool person',
});

// note: sourceObject is a separate object from finalObject in this scenario

```

In fact, before object spread, you'd just use `Object.assign({}, whateverObject)` to do a shallow clone. 

### Bonus: _.flatten: Array.smoosh

Flatten is being considered to be part of EcmaScript but due to various problems and issues, there has been a (joke?) nomination to rename it `smoosh`. I have my own thoughts on the matter but hopefully, sometime soon, you'll be able to use `Array.smoosh` on your favorite deeply nested arrays.

So what does flatten/smoosh do? It takes an array of arrays, and makes it a single array. So let's say some API looked at your Twitter lists and picked the best tweets from each list and you wanted to combine them into a feed of its own, you might use flatten for this:

```js
const sourceArray = [
  [ 'tweet 1', 'tweet 2', 'tweet 3'],
  [ 'tweet 4', 'tweet 5'],
  [ 'tweet 6', 'tweet 7', 'tweet 8', 'tweet 9']
];

const feed = Array.smoosh(sourceArray);

/** result:
[ 'tweet 1', 'tweet 2', 'tweet 3', 'tweet 4', 'tweet 5', 'tweet 6', 'tweet 7', 'tweet 8 ', 'tweet 9' ];
**/
```