In recent years, new features in JavaScript have been rolling out at a rapid pace. The deficiencies that are filled in by other libraries before have become built-in features of plain JavaScript.

In this article, we’ll look at the methods in Lodash that are now available in plain JavaScript, like function currying, partially applied functions and more.

Some features are better with Lodash but for others, plain JavaScript will suffice.

# Curry

The `curry`

method in Lodash returns a function that has one or more arguments of the function originally passed in. We can use it as follows:

```
const subtract = (a, b) => a - b;
const currySubtract = _.curry(subtract);
const subtract1 = currySubtract(1);
const diff = subtract1(5);
console.log(diff);
```

In the code above, we defined the subtract function which returns the first parameter subtracted by the second.

Then we called the `curry`

method with the subtract method passed in to create a new method that makes one argument and returns the `subtract`

function with the first argument set by the parameter. That’s the `currySubtract`

function.

Then we call the `currySubtract`

to set the argument of the `subtract`

function and return the function with the first argument set. Finally, we call the `subtract1`

function with the second argument of `subtract`

to get the final result.

We can do the same thing with plain JavaScript by writing:

```
const currySubtract = a => b => a - b;
const subtract1 = currySubtract(1);
const diff = subtract1(5);
console.log(diff);
```

It does exactly the same thing, but without calling the `curry`

method.

# Partial

Lodash also has a method for partially applying a function, which is different from curry since some of the arguments of the function are passed into the function directly and the new function is returned.

For example, we can write the following:

```
const add = (a, b) => a + b;
const add1 = _.partial(add, 1);
const sum = add1(2);
console.log(sum);
```

The `partial`

method passed in the first argument and returns the function with the first argument passed in. This gets us the `add1`

function.

Then when can call the `add1`

function with the second argument, which is 2 in the code above, and we get 3 for the `sum`

.

In plain JavaScript, we can write:

```
const add = (a, b) => a + b;
const add1 = b => add(1, b);
const sum = add1(2);
console.log(sum);
```

Again, we can skip the Lodash `partial`

method call like we did with the `curry`

method call.

# Eq

Lodash has the `eq`

method to compare values. For example, we can write:

```
const equal = _.eq(1, 1);
```

It does the same thing as the `Object.is`

, so we can just use that.

# Add

It also has the `add`

method, which we can use as we do in the following code:

```
const sum = _.add(1, 1);
```

We see the value is 2. It does the same thing as the `+`

operator, so we can use that instead.

# Nesting Operators

The good thing is that we can pass these methods straight into other Lodash methods like `map`

and `reduce`

as follows:

```
const mult = _.map([1, 2, 3], n => _.multiply(n, 2));
```

We get `[2, 4, 6]`

from the code above, and we get 6 from:

```
const sum = _.reduce([1, 2, 3], _.add);
```

# At

The `at`

method lets us access the value of the properties of an object or an entry of an array by its index.

For example, given the following object, we can write the following:

```
const obj = { a: [{ b: { c: 2 } }, 1] };
```

We can get the value of the `c`

property with `at`

by writing:

```
const c = _.at(obj, ["a[0].b.c"]);
```

Then we get 2 for `c`

.

Also, we can access more than one property of an object by passing more paths into the array above:

```
const vals = _.at(obj, ["a[0].b.c", "a[0].b"]);
```

Then we et:

```
2
{c: 2}
```

In JavaScript, we can access the paths directly:

```
const vals = [obj.a[0].b.c, obj.a[0].b];
```

However, it’s good for access paths that may not exist. For example, given the same object, if we write the following:

```
const vals = _.at(obj, ["a[0].b.c", "d.e"]);
```

Then we get `undefined`

for the second entry instead of crashing the app.

As we can see, Lodash still has some advantages, with object path access. However, other operators like add, multiply, curry and partial, we can define easily with plain JavaScript ourselves, so Lodash still has some value.