javascript - Correct way to import lodash - Stack Overflow

admin管理员组

文章数量:1129098

I had a pull request feedback below, just wondering which way is the correct way to import lodash?

You'd better do import has from 'lodash/has'.. For the earlier version of lodash (v3) which by itself is pretty heavy, we should only import a specidic module/function rather than importing the whole lodash library. Not sure about the newer version (v4).

import has from 'lodash/has';

vs

import { has } from 'lodash';

Thanks

I had a pull request feedback below, just wondering which way is the correct way to import lodash?

You'd better do import has from 'lodash/has'.. For the earlier version of lodash (v3) which by itself is pretty heavy, we should only import a specidic module/function rather than importing the whole lodash library. Not sure about the newer version (v4).

import has from 'lodash/has';

vs

import { has } from 'lodash';

Thanks

• javascript
• lodash
• babeljs

Share Improve this question Follow edited Feb 7, 2016 at 6:40 Bill asked Feb 7, 2016 at 6:32 BillBill 19.2k2121 gold badges8888 silver badges135135 bronze badges 2

• 7 See this answer for a more in-depth discussion as to why the latter can still incur a performance optimization in some environments such as Webpack. It's due to the use of static-analysis and tree-shaking. – Patrick Roberts Commented Jul 25, 2017 at 18:17
• Does this answer your question? How to Import a Single Lodash Function? – Henke - Нава́льный П с м Commented Feb 10, 2021 at 16:31

Add a comment  | 

10 Answers 10

Sorted by: Reset to default 347

import has from 'lodash/has'; is better because lodash holds all its functions in a single file, so rather than import the whole 'lodash' library at 100k, it's better to just import lodash's has function which is maybe 2k.

If you are using webpack 4, the following code is tree shakable.

import { has } from 'lodash-es';

The points to note;

1. CommonJS modules are not tree shakable so you should definitely use lodash-es, which is the Lodash library exported as ES Modules, rather than lodash (CommonJS).

2. lodash-es's package.json contains "sideEffects": false, which notifies webpack 4 that all the files inside the package are side effect free (see https://webpack.js.org/guides/tree-shaking/#mark-the-file-as-side-effect-free).

3. This information is crucial for tree shaking since module bundlers do not tree shake files which possibly contain side effects even if their exported members are not used in anywhere.

Edit

As of version 1.9.0, Parcel also supports "sideEffects": false, threrefore import { has } from 'lodash-es'; is also tree shakable with Parcel. It also supports tree shaking CommonJS modules, though it is likely tree shaking of ES Modules is more efficient than CommonJS according to my experiment.

Import specific methods inside of curly brackets

import { map, tail, times, uniq } from 'lodash';

Pros:

• Only one import line(for a decent amount of functions)
• More readable usage: map() instead of _.map() later in the javascript code.

Cons:

• Every time we want to use a new function or stop using another - it needs to be maintained and managed

Copied from:The Correct Way to Import Lodash Libraries - A Benchmark article written by Alexander Chertkov.

You can import them as

import {concat, filter, orderBy} from 'lodash';

or as

import concat from 'lodash/concat';
import orderBy from 'lodash/orderBy';
import filter from 'lodash/filter';

the second one is much optimized than the first because it only loads the needed modules

then use like this

pendingArray: concat(
                    orderBy(
                        filter(payload, obj => obj.flag),
                        ['flag'],
                        ['desc'],
                    ),
                    filter(payload, obj => !obj.flag),

If you are using babel, you should check out babel-plugin-lodash, it will cherry-pick the parts of lodash you are using for you, less hassle and a smaller bundle.

It has a few limitations:

• You must use ES2015 imports to load Lodash
• Babel < 6 & Node.js < 4 aren’t supported
• Chain sequences aren’t supported. See this blog post for alternatives.
• Modularized method packages aren’t supported

I just put them in their own file and export it for node and webpack:

// lodash-cherries.js
module.exports = {
  defaults: require('lodash/defaults'),
  isNil: require('lodash/isNil'),
  isObject: require('lodash/isObject'),
  isArray: require('lodash/isArray'),
  isFunction: require('lodash/isFunction'),
  isInteger: require('lodash/isInteger'),
  isBoolean: require('lodash/isBoolean'),
  keys: require('lodash/keys'),
  set: require('lodash/set'),
  get: require('lodash/get'),
}

I think this answer can be used in any project easily and brings the best result with less effort.

For Typescript users, use as following :

// lodash.utils.ts
export { default as get } from 'lodash/get';
export { default as isEmpty } from 'lodash/isEmpty';
export { default as isNil } from 'lodash/isNil';
...

And can be used the same way as importing lodash :

//some-code.ts
import { get } from './path/to/lodash.utils'

export static function getSomething(thing: any): any {
    return get(thing, 'someSubField', 'someDefaultValue')
}

Or if you prefer to keep the _ to avoid conflicts (ex. map from rxjs vs lodash)

//some-other-code.ts
import * as _ from './path/to/lodash.utils'

export static function getSomething(thing: any): any {
    return _.get(thing, 'someSubField', 'someDefaultValue')
}

UPDATE : Seems like the right way to export is :

export * as get from 'lodash/get';
export * as isEmpty from 'lodash/isEmpty';
export * as isNil from 'lodash/isNil';
...

But there is a weird collision with @types/lodash, I've removed this type package because I would get this error :

Module '"/../project/node_modules/@types/lodash/cloneDeep"' uses 'export =' and cannot be used with 'export *'.ts(2498)

UPDATE :

After some digging, I've turned tsconfig.json feature esModuleInterop to true, and it allows me to do the following :

import get from 'lodash/get';
import isEmpty from 'lodash/isEmpty';
import isNil from 'lodash/isNil';
...

export { get, isEmpty, isNil, ... };

Note that this affects all your imports in your projects that has been defined as import * as lib from 'lib'. Follow the documentation to be sure it's suitable for you.

import { cloneDeep, groupBy } from 'lodash';

I think this is simpler when you don't need to convert array to lodash object by using _.

const groupData = groupBy(expandedData, (x) => x.room.name);

For those who want to keep using _ , then just import them like this:

import groupBy from 'lodash/groupBy';
import filter from 'lodash/filter';
import get from 'lodash/get';

window._ = {groupBy, filter, get};

I think the more cleaner way of importing lodash is just like this:-

import _ from 'lodash'

then you can use what ever you want just by using this underscore just like this:-

_.has()

本文标签： javascriptCorrect way to import lodashStack Overflow