How do I escape a dot in a property name with set-value?

Prefix the dot with a backslash, like 'a\.b.c'. This prevents set-value from splitting on that dot, allowing properties with dots in their names. For example, set({}, 'a\.b.c', 'd') creates { 'a.b': { c: 'd' } }.

set-value vs lodash.set: which is better for performance?

set-value consistently outperforms lodash.set in benchmarks, as shown in the README, and handles more edge cases correctly. However, lodash.set is part of the larger Lodash ecosystem, which might be preferable if you need additional utilities.

Can set-value merge objects deeply instead of just overwriting?

Yes, by setting the merge option to true, it performs a shallow merge using Object.assign. For deep merging, you must provide a custom merge function, which requires extra implementation effort.

Does set-value work with arrays or only objects?

set-value is designed for objects, but it can set properties on arrays if the path targets array indices. However, it doesn't provide specialized array manipulation features, so other libraries might be better for array-specific tasks.

How to use a custom separator like slash in set-value?

Pass an options object with the separator property, e.g., set(obj, 'auth/user', 'value', { separator: '/' }). This splits the path on slashes instead of dots, useful for formats like file paths or URLs.

Is set-value immutable or does it change the original object?

set-value mutates the original object. If you need immutable updates, you should first clone the object using methods like JSON.parse(JSON.stringify(obj)) or use a library designed for immutability.

Open-Awesome

set-value

MITJavaScript

Set nested properties on JavaScript objects using dot notation with high performance and extensive options.

Visit Website GitHub

277 stars42 forks0 contributors

What is set-value?

Set-value is a JavaScript utility library that enables setting deeply nested properties on objects using dot-notation paths. It solves the problem of safely and efficiently creating or modifying complex object structures without manual property checking and object creation. The library handles edge cases like escaping and custom separators while maintaining high performance.

Target Audience

JavaScript and Node.js developers working with configuration objects, state management, data transformation pipelines, or any code requiring deep object manipulation.

Value Proposition

Developers choose set-value for its reliability, extensive options for path handling, and proven performance advantages over alternatives like lodash.set or dot-prop. It provides a focused API for a common task with robust escape mechanisms and merge capabilities.

Overview

Set nested properties on an object using dot-notation.

Use Cases

Best For

Setting deeply nested configuration values in application settings
Dynamically building complex object structures from flat data
Updating specific properties in large state objects (like Redux or Vuex)
Transforming API response data into nested object formats
Creating object paths from user-provided strings or templates
Merging new data into existing nested objects without overwriting

Not Ideal For

Projects requiring immutable data updates, such as functional programming or Redux reducers that avoid side effects
Environments where bracket notation for property access is essential without additional configuration
Simple applications needing only shallow object manipulation where native methods like Object.assign suffice
Teams prioritizing minimal dependencies and preferring to avoid external libraries for core utilities

Pros & Cons

Pros

Benchmark-Proven Performance

Extensive benchmarks show set-value outperforms competitors like lodash.set and dot-prop in deep, medium, and shallow property sets, making it the fastest choice for nested object manipulation.

Flexible Path Handling

Supports custom separators, path escaping with backslashes, and preserves paths with '/' by default, enabling versatile use cases such as handling URL properties without unwanted splitting.

Merge Functionality

Offers a merge option to shallowly merge values with Object.assign or allow custom deep merge functions, preventing overwrites and facilitating incremental object updates.

Robust Edge Case Coverage

Handles complex scenarios like dots in property names through escaping and provides options for custom split functions, ensuring correctness where other libraries fail.

Cons

Mutates Original Object

Directly modifies the input object, which can introduce side effects and is incompatible with immutable data patterns or functional programming practices that require purity.

No Built-in Bracket Support

Bracket notation support was removed in v3.0.0 and now requires a custom split function, adding complexity for users who rely on that syntax without extra configuration.

Critical Bug History

The README warns of a critical bug fixed only in v3.0.1, indicating past stability issues that necessitate careful version management and may affect trust in older releases.

Frequently Asked Questions

Related Projects

deep-object-diff

Deep diffs two objects, including nested structures of arrays and objects, and returns the difference. ❄️

Stars1,140

Forks97

Last commit2 years ago

stringify-object

Stringify an object/array like JSON.stringify just without all the double-quotes

Stars324

Forks43

Last commit8 months ago

get-value

Use property paths (`a.b.c`) get a nested value from an object.

Stars295

Forks22

Last commit1 year ago

deep-assign

[DEPRECATED] Recursive Object.assign()

Stars246

Forks34

Last commit5 years ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub