Lodash is a very useful utility library that lets us work with objects and arrays easily.
However, now that the JavaScript standard library is catching up to libraries such as Lodash, we can implement many of the functions in simple ways.
In this article, we’ll look at some Lodash object and function methods that we can replace with our own plain JavaScript implementation.
unary
The Lodash unary method returns a function that only calls the original function with one argument.
We can just create our own function that returns a function that calls the original function ourselves as follows:
const unary = (fn) => (val) => fn(val);
In the code above, we have our own unary function, which takes a function that returns (val) => fn(val) , which is a function that only takes one argument and then calls fn with that argument.
Then we can call it as follows:
const result = ['6', '8', '10'].map(unary(parseInt));
And we get:
[
6,
8,
10
]
as the value of result .
wrap
The Lodash wrap method takes a wrapper function another function fn that we want to call with the wrapper as the first argument.
It returns a function that takes in a value val as the parameter and calls the function in the second argument with the wrapper as the first argument and val as the 2nd argument.
For instance, we can implement our own wrap function as follows:
const wrap = (wrapper, fn) => (val) => fn(wrapper, val)
In the code above, the wrap function takes wrapper and fn , which are functions. Then we return a function that takes in an argument, which is val and then calls fn with wrapper and val .
Then we can call it as follows with the Lodash _.escape method as the first argument and our own function to wrap our text around p tags as follows:
const p = wrap(_.escape, (func, text) => `<p>${func(text)}</p>`);
In the code above, the escape method escapes the text and our own function wraps func(text) , where func is the escape method since that’s the first argument and text is the text that we’ll pass into the returned p function.
Then we can call p as follows:
const result = p('foo bar');
and we get that result is <p>foo bar</p> .
forIn
The Lodash forIn method loops through the own and inherited enumerable string keyed properties of an object and run an iteratee function on each property.
The iteratee is a function that takes the value , key , and object parameters and we can stop the loop by returning false explicitly
We can implement our own forIn function as follows:
const forIn = (object, iteratee) => {
for (const key in object) {
const result = iteratee(object[key], key, object);
if (result === false) {
break;
}
}
}
In the code above, we have the forIn function that takes an object and an iteratee function.
Then inside the function, we used the for...in loop to loop through all the enumerable own and enumerable string keys of object .
Inside the loop, we call the iteratee function with the value, which we get by using object[key] , the key itself, and the object . We assign the return value of iteratee to result .
Then if result is false , then we break the loop. Otherwise, it continues running.
We can then call our forIn function as follows:
function Foo() {
this.a = 1;
this.b = 2;
}
Foo.prototype.c = 3;
forIn(new Foo(), (value, key) => console.log(key));
In the code above, we have the Foo constructor, which has 2 own properties a and b . It also has an additional inherited property c .
Then we called forIn with a Foo instance, and pass in a callback that logs the keys of the Foo instance.
In the end, we should see a , b and c logged in the console log output.
Conclusion
The unary and wrap Lodash methods both return a function that takes in some arguments and call the original function that’s passed in as the argument from the returned function.
Lodash’s forIn method is like the for...in loop, except that we can return false with our iteratee function to break the loop. The iteratee is run on every iteration until it returns false .
