Lodash _.runInContext() Method

What You’ll Learn

By the end of this tutorial, you’ll use Lodash’s _.runInContext() to spin up a separate Lodash copy—so custom mixins and experiments never leak onto the shared global _.

What Is _.runInContext()?

_.runInContext() creates a new Lodash function with its own internal context—the machinery Lodash uses for constructors, templates, and method wiring. The copy behaves like regular Lodash: you can call lodash.map, lodash.get, and lodash.mixin on it. Changes you make through _.mixin() on that copy stay on that copy.

Think of it as a sandboxed Lodash for plugin authors: extend freely, ship your plugin, and leave the app’s main _ untouched.

📝 Syntax

Most projects call it with no arguments:

_.runInContext([context])

Syntax Rules

• No arguments (usual) — returns a pristine Lodash function in a new context.
• Optional context — advanced Lodash internals; skip unless you are deep in library customization.
• Return value — a Lodash function—assign it: const lodash = _.runInContext().
• Extend with mixin — add methods via lodash.mixin({ ... }), not via the context object.
• Globals unchanged — unlike noConflict, global _ is not released or replaced.

import runInContext from "lodash/runInContext";



const lodash = runInContext();



lodash.map([1, 2, 3], (n) => n * 2);

// [2, 4, 6]

Examples Gallery

Practical _.runInContext() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.

const lodash = _.runInContext();



console.log(lodash.map([1, 2, 3], (n) => n * 2));

console.log(lodash.VERSION === _.VERSION);

// [2, 4, 6]

// true

[2, 4, 6]

true

_.mixin({ foo: _.constant("foo") });



const lodash = _.runInContext();



lodash.mixin({ bar: lodash.constant("bar") });



console.log(_.isFunction(_.foo));

console.log(_.isFunction(_.bar));

console.log(lodash.isFunction(lodash.bar));

// true, false, true

true

false

true

const pluginA = _.runInContext();

const pluginB = _.runInContext();



pluginA.mixin({ greet: () => "Hello from A" });

pluginB.mixin({ greet: () => "Hello from B" });



console.log(pluginA.greet());

console.log(pluginB.greet());

// Hello from A

// Hello from B

Hello from A

Hello from B

const lodash = _.runInContext();



lodash.mixin({

  doubleAll: (arr) => lodash.map(arr, (n) => n * 2),

});



console.log(lodash.doubleAll([1, 2, 3]));

console.log(_.isFunction(_.doubleAll));

// [2, 4, 6]

// false

[2, 4, 6]

false

function createMyLodash(base) {

  const lodash = base.runInContext();



  lodash.mixin({

    sumByProp(arr, key) {

      return lodash.sumBy(arr, key);

    },

  });



  return lodash;

}



const myLodash = createMyLodash(_);



console.log(myLodash.sumByProp(

  [{ v: 1 }, { v: 2 }],

  "v"

));

// 3

3

// Browser: Underscore owns global _ — free the name once

// const lodash = _.noConflict();



// Plugin author: extra copy, global _ unchanged

const lodash = _.runInContext();

lodash.mixin({ myPluginFn() {} });



// Modern app: plain modules — often no meta API needed

// import { map } from "lodash-es";

(see comments — pattern reference)

📝 Notes

• Do not pass { customMethods: {} } expecting plug-in APIs—the optional context is not a settings bag.
• Use lodash.mixin on the returned function to add helpers (see mixin tutorial).
• runInContext does not replace noConflict—different problems (isolation vs global naming).
• Each call produces another full copy—fine for plugins; avoid creating hundreds in hot paths.
• In bundler apps, plain modules plus named imports cover most needs without runInContext.
• Next in the series: _.stubArray()—empty array factory for defaults.

💡 Best Practices