Use property paths like 'a.b.c' to get a nested value from an object. Even works when keys have dots in them (no other dot-prop library we tested does this, or does it correctly).
Please consider following this project's author, Jon Schlinkert, and consider starring the project to show your ❤️ and support.
Details
Install with npm:
$ npm install --save get-valueSee the unit tests for many more examples.
import getValue from 'get-value';
// or
import { getValue } from 'get-value';
// or
const getValue = require('get-value');
const obj = { a: { b: { c: { d: 'foo' } } } };
console.log(getValue(obj)); //=> { a: { b: { c: { d: 'foo' } } } };
console.log(getValue(obj, 'a')); //=> { b: { c: { d: 'foo' } } }
console.log(getValue(obj, 'a.b')); //=> { c: { d: 'foo' } }
console.log(getValue(obj, 'a.b.c')); //=> { d: 'foo' }
console.log(getValue(obj, 'a.b.c.d')); //=> 'foo'Unlike other dot-prop libraries, get-value works when keys have dots in them:
console.log(getValue({ 'a.b': { c: 'd' } }, 'a.b.c'));
//=> 'd'
console.log(getValue({ 'a.b': { c: { 'd.e': 'f' } } }, 'a.b.c.d.e'));
//=> 'f'console.log(getValue({ a: { b: { c: { d: 'foo' } } }, e: [{ f: 'g' }, { f: 'h' }] }, 'e.1.f'));
//=> 'h'
console.log(getValue({ a: { b: [{ c: 'd' }] } }, 'a.b.0.c'));
//=> 'd'
console.log(getValue({ a: { b: [{ c: 'd' }, { e: 'f' }] } }, 'a.b.1.e'));
//=> 'f'function foo() {}
foo.bar = { baz: 'qux' };
console.log(getValue(foo));
//=> { [Function: foo] bar: { baz: 'qux' } }
console.log(getValue(foo, 'bar'));
//=> { baz: 'qux' }
console.log(getValue(foo, 'bar.baz'));
//=> quxSlightly improves performance by passing an array of strings to use as object path segments (this is also useful when you need to dynamically build up the path segments):
console.log(getValue({ a: { b: 'c' } }, ['a', 'b']));
//=> 'c'Type: any
Default: undefined
The default value to return when get-value cannot resolve a value from the given object.
const obj = { foo: { a: { b: { c: { d: 'e' } } } } };
console.log(getValue(obj, 'foo.a.b.c.d', { default: true })); //=> 'e'
console.log(getValue(obj, 'foo.bar.baz', { default: true })); //=> true
console.log(getValue(obj, 'foo.bar.baz', { default: false })); //=> false
console.log(getValue(obj, 'foo.bar.baz', { default: null })); //=> null
// you can also pass the default value as the last argument
// (this is necessary if the default value is an object)
console.log(getValue(obj, 'foo.a.b.c.d', true)); //=> 'e'
console.log(getValue(obj, 'foo.bar.baz', true)); //=> true
console.log(getValue(obj, 'foo.bar.baz', false)); //=> false
console.log(getValue(obj, 'foo.bar.baz', null)); //=> nullType: function
Default: true
If defined, this function is called on each resolved value. Useful if you want to do .hasOwnProperty or Object.prototype.propertyIsEnumerable.
const isEnumerable = Object.prototype.propertyIsEnumerable;
const options = {
isValid: (key, obj) => isEnumerable.call(obj, key)
};
const obj = {};
Object.defineProperty(obj, 'foo', { value: 'bar', enumerable: false });
console.log(getValue(obj, 'foo', options)); //=> undefined
console.log(getValue({}, 'hasOwnProperty', options)); //=> undefined
console.log(getValue({}, 'constructor', options)); //=> undefined
// without "isValid" check
console.log(getValue(obj, 'foo', options)); //=> bar
console.log(getValue({}, 'hasOwnProperty', options)); //=> [Function: hasOwnProperty]
console.log(getValue({}, 'constructor', options)); //=> [Function: Object]Type: function
Default: String.split()
Custom function to use for splitting the string into object path segments.
const obj = { 'a.b': { c: { d: 'e' } } };
// example of using a string to split the object path
const options = { split: path => path.split('/') };
console.log(getValue(obj, 'a.b/c/d', options)); //=> 'e'
// example of using a regex to split the object path
// (removing escaped dots is unnecessary, this is just an example)
const options = { split: path => path.split(/\\?\./) };
console.log(getValue(obj, 'a\\.b.c.d', options)); //=> 'e'Type: string|regex
Default: .
The separator to use for splitting the string (this is probably not needed when options.split is used).
const obj = { 'a.b': { c: { d: 'e' } } };
console.log(getValue(obj, 'a.b/c/d', { separator: '/' }));
//=> 'e'
console.log(getValue(obj, 'a\\.b.c.d', { separator: /\\?\./ }));
//=> 'e'Type: function
Default: Array.join()
Customize how the object path is created when iterating over path segments.
const obj = { 'a/b': { c: { d: 'e' } } };
const options = {
// when segs === ['a', 'b'] use a "/" to join, otherwise use a "."
join: segs => segs.join(segs[0] === 'a' ? '/' : '.')
};
console.log(getValue(obj, 'a.b.c.d', options));
//=> 'e'Type: string
Default: .
The character to use when re-joining the string to check for keys with dots in them (this is probably not needed when options.join is used). This can be a different value than the separator, since the separator can be a string or regex.
const target = { 'a-b': { c: { d: 'e' } } };
const options = { joinChar: '-' };
console.log(getValue(target, 'a.b.c.d', options));
//=> 'e'(benchmarks were run on a MacBook Pro 2.5 GHz Intel Core i7, 16 GB 1600 MHz DDR3).
get-value is more reliable and has more features than dot-prop, without sacrificing performance.
# deep (338 bytes)
dot-prop x 5,319,159 ops/sec ±0.76% (93 runs sampled)
dotty x 3,870,706 ops/sec ±0.26% (96 runs sampled)
get-value x 8,788,576 ops/sec ±0.19% (100 runs sampled)
getobject x 1,979,207 ops/sec ±0.17% (98 runs sampled)
object-path x 1,761,814 ops/sec ±0.25% (100 runs sampled)
fastest is get-value (by 65% avg)
# root (215 bytes)
dot-prop x 41,761,355 ops/sec ±0.89% (93 runs sampled)
dotty x 29,943,256 ops/sec ±0.55% (99 runs sampled)
get-value x 65,184,370 ops/sec ±1.00% (96 runs sampled)
getobject x 13,780,598 ops/sec ±0.35% (98 runs sampled)
object-path x 21,255,148 ops/sec ±0.45% (101 runs sampled)
fastest is get-value (by 56% avg)
# shallow (91 bytes)
dot-prop x 21,019,241 ops/sec ±0.46% (93 runs sampled)
dotty x 15,912,833 ops/sec ±0.76% (96 runs sampled)
get-value x 19,824,809 ops/sec ±0.40% (91 runs sampled)
getobject x 7,537,059 ops/sec ±0.15% (97 runs sampled)
object-path x 8,519,654 ops/sec ±0.21% (99 runs sampled)
fastest is dot-prop (by 6% avg)
Clone this library into a local directory:
$ git clone https://github.com/jonschlinkert/get-value.gitThen install devDependencies and run benchmarks:
$ npm install && node benchmark- Adds support for
Map-like objects, allowing objects with agetmethod that can be used to retrieve values by key. - Removed outdated travis config, and added GitHub Actions workflow for running tests.
- Refactored to TypeScript
- Added support for handling deep property paths with arrays
- Improved performance on large nested objects
- Fixed edge case issues with keys containing special characters.
- Updated benchmarks
- Updated documentation to reflect new features and bug fixes.
- Improved support for escaping. It's no longer necessary to use backslashes to escape keys.
- Adds
options.defaultfor defining a default value to return when no value is resolved. - Adds
options.isValidto allow the user to check the object after each iteration. - Adds
options.separatorfor customizing character to split on. - Adds
options.splitfor customizing how the object path is split. - Adds
options.joinfor customizing how the object path is joined when iterating over path segments. - Adds
options.joinCharfor customizing the join character.
Contributing
Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.
Please read the contributing guide for advice on opening issues, pull requests, and coding standards.
Running Tests
Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
$ npm install && npm testBuilding docs
(This project's readme.md is generated by verb, please don't edit the readme directly. Any changes to the readme must be made in the .verb.md readme template.)
To generate the readme, run the following command:
$ npm install -g verbose/verb#dev verb-generate-readme && verbYou might also be interested in these projects:
- has-any-deep: Return true if
keyexists deeply on the given object. | homepage - has-any: Returns true if an object has any of the specified keys. | homepage
- has-value: Returns true if a value exists, false if empty. Works with deeply nested values using… more | homepage
- set-value: Set nested properties on an object using dot notation. | homepage
- unset-value: Delete nested properties from an object using dot notation. | homepage
| Commits | Contributor |
|---|---|
| 94 | jonschlinkert |
| 2 | doowb |
| 2 | felladrin |
| 1 | onokumus |
| 1 | joepie91 |
| 1 | sonofmagic |
Jon Schlinkert
Copyright © 2026, Jon Schlinkert. Released under the MIT License.
This file was generated by verb-generate-readme, v0.8.0, on June 14, 2026.