6 Powerful Ramda Functions For JavaScript | by Tate Galbraith | Apr, 2022

A quick and useful library for supercharging your code

Photograph by Markus Spiske on Unsplash

If you happen to haven’t heard of the Ramda library for JavaScript you then’re lacking out on a good looking enhancement to the language. This library is filled with a ton of helpful features and utilities that not solely remedy frequent issues, however make JavaScript higher at useful programming.

Ramda was developed as a functional library and offers concise, elegant however most significantly useful utilities. Which means that most of the included features have little to no side-effects, are curried and supply a versatile pipeline interface. With Ramda you may lastly notice useful programming rules in JavaScript.

On this article, we’ll discover just a few of my favourite features supplied by the library and present examples of how they’ll make your code extra useful and fewer repetitive. Let’s get began.


If there may be one job that comes up on a regular basis in JavaScript it’s “digging” into nested objects. Take into consideration what number of occasions you’ve needed to seize a price from a deeply nested object. What number of occasions has that object mutated barely or had a lacking key? Must you actually must manually examine for the existence of each single intermediate key within the chain?

That sounds tedious.

Use the pathOr operate from Ramda as an alternative. This single operate can exchange a handful of spaghetti code. Test it out:

const R = require('ramda');let myObject = 
key3: targetKey: 1234

let path = ['key1', 'key2', 'key3', 'targetKey'];
let end result = R.pathOr(0, path, myObject);
console.log(end result);

Let’s break down what is going on right here:

  • First, we setup a easy nested object with some knowledge. Our objective is to drag out the targetKey worth.
  • Subsequent, we setup an array that accommodates the ordered key names we’ll dig into.
  • Lastly, we apply the pathOr operate, passing a default worth, the trail and the article to key into.

If targetKey was not current or one of many intermediate keys was lacking then pathOr would return the primary default argument, which is 0.

The subsequent time it’s good to dig right into a nested object safely, simply use pathOr.


It is a brutally easy operate, however so helpful to have. The clamp operate ensures {that a} quantity falls inside a specific vary. Which means that should you move a quantity that’s too excessive or too low the operate will “clamp” that quantity to the closest acceptable quantity within the vary you present.

Right here is an easy instance:

const R = require('ramda');let end result = R.clamp(10, 20, 5);console.log(end result);

On this instance we’re clamping our vary between 10 and 20. After we move in 5, that is beneath the bottom-end of the vary so it clamps to 10 as an alternative. If we have been to move in something above 20 it might clamp to twenty.

It’s also possible to curry clamp into its personal customized validation operate like this:

let clampBetweenRange = R.clamp(10, 20);let end result = clampBetweenRange(5);console.log(end result)

There are a ton of functions for this specific operate. You would clamp person enter to a selected vary or use this to protect towards messy knowledge outputs from different processing pipelines.


What number of occasions have you ever been burned by a wild undefined or a null? What number of occasions have you ever had to return and construct some elaborate attempt/catch assertion for a seemingly easy characteristic?

Utilizing the defaultTo operate you may keep away from a few of these complications.

The defaultTo operate will settle for a default worth as the primary argument and something because the second. If the second argument is null, undefined, or NaN then the primary argument will get returned. This can be curried into its personal wrapper operate for rather more readable, concise code:

const R = require('ramda');let resultNotCurried = R.defaultTo('error', undefined);console.log(resultNotCurried);let defaulted = R.defaultTo('error');
let resultCurried = defaulted(undefined);

Now all it’s important to do to guard towards unhealthy values is wrap your operate or knowledge within the curried defaulted operate.


Though that is similar to the built-in hasOwnProperty operate of JavaScript, there may be one key distinction. You may curry this operate and make it extra elegant (and clearly, useful).

const R = require('ramda');let hasAge = R.has('age');let myObject =  title: 'Bob', age: 24 console.log(hasAge(myObject));

Merely passing a key title to has will put together the curried operate. Now all it’s important to do to examine for the presence of the hot button is wrap objects within the new operate. Comfort at its best.

You would even mix this with the earlier defaultTo operate utilizing a Ramda pipe. This may create a strong knowledge validation pipeline that may simply be reused. Take a look at the following part for an instance.


Have you ever ever wished you would faucet into the center of a pipeline to see whats occurring at a specific stage? With the faucet operate you are able to do simply that.

When you will have a ton of features chained collectively, it might get complicated as to the state of some knowledge in the course of it. By leveraging faucet you may log some output or save the info elsewhere for evaluate.

Right here is an instance of “tapping” into the center of a pipeline with Ramda:

const R = require('ramda');let logOutput = val => console.log(val);let pipeline = R.pipe(
let end result = pipeline(100);console.log(end result);

Right here’s a breakdown of the steps:

  • First, we setup a operate to log our output to the console. It is a easy operate that accepts a price and logs it.
  • Subsequent we construct our pipeline. It is a easy Ramda pipe that can step by step increment a quantity. In actuality, this could most likely be a way more advanced pipeline that manipulates knowledge, however for this instance we’ll hold it easy.
  • In the midst of our pipeline we stick our faucet operate and move our logging operate into it.
  • Lastly, we name our pipeline and supply it with a price.

If you happen to have been to run the instance above, you’d see two values logged to the console: 101 and 103.

Utilizing faucet with pipelines we are able to simply examine what’s going on between steps and scale back the general effort it takes to examine advanced operate chains.


This operate is one that’s deceptively easy at first look. A standard theme in JavaScript is working with lists of objects. Whether or not that is knowledge getting back from a database or some static JSON objects, manipulating these fashions is an all too frequent job.

The pluck operate permits you to manipulate these lists of objects by “plucking” knowledge out of every one. You may generate a brand new checklist of values from a listing of objects by specifying the important thing you wish to “pluck” from every object.

const R = require('ramda');let myObjects = [
name: 'Bob', age: 22 ,
name: 'Sally', age: 32
let outcomes = R.pluck('title', myObjects);console.log(outcomes);

By specifying the important thing to pluck and passing within the checklist of objects you’re in a position to construct a brand new checklist containing solely these keys.

The very best half is that the pluck operate additionally works towards several types of constructions as properly. You may pluck from checklist of lists and common objects simply as simply.

The world of useful programming could be extremely huge and complicated. The Ramda library offers a transparent and easy technique to convey this world into JavaScript with out overwhelming builders.

Even should you’re not ingesting the useful programming Kool-Help but, there are nonetheless a complete lot of helpful features on this library for extra conventional improvement kinds.

For a deeper dive into each Ramda and the essential rules of useful programming, try Ramda your JavaScript by Marius Ibsen.

More Posts