百科.dev
全部条目在线工具AI 编程趋势榜开源项目技术资讯提交条目
登录
< 返回工具列表
M

merge-anything

> 编程语言
开源

递归合并对象和其他类型。一个简单而小巧的集成。

381 stars0 点赞0 次浏览
访问官网GitHub

工具介绍

递归合并对象和其他类型。一个简单而小巧的集成。

Merge anything

bash
npm i merge-anything

Merge objects & other types recursively. Fully TypeScript supported! A simple & small integration.

Motivation

I created this package because I tried a lot of similar packages that do merging/deepmerging/recursive object assign etc. But all had its quirks, and all of them break things they are not supposed to break...

I was looking for:

  • a simple merge function like Object.assign() but deep
  • supports merging of nested properties
  • supports TypeScript: the type of the result is what JS actually returns
  • supports symbols
  • supports enumerable & nonenumerable props
  • does not break special class instances ‼️

This last one is crucial! In JavaScript almost everything is an object, sure, but I don't want a merge function trying to merge eg. two new Date() instances! So many libraries use custom classes that create objects with special prototypes, and such objects all break when trying to merge them. So we gotta be careful!

merge-anything will merge objects and nested properties, but only as long as they're "plain objects". As soon as a sub-prop is not a "plain object" and has a special prototype, it will copy that instance over "as is". ♻️

Meet the family (more tiny utils with TS support)

  • is-what
  • is-where
  • merge-anything
  • check-anything
  • remove-anything ✂️
  • getorset-anything
  • map-anything
  • filter-anything ⚔️
  • copy-anything
  • case-anything
  • flatten-anything
  • nestify-anything

Usage

  • Unlimited — Merge will merge an unlimited amount of plain objects you pass as the arguments
  • Nested — Nested objects are merged deeply (see example below)
  • No modification — Merge always returns a new object without modifying the original, but does keep object/array references for nested props (see #A note on JavaScript object references)
javascript
import { merge } from 'merge-anything'

const starter = { name: 'Squirtle', types: { water: true } }
const newValues = { name: 'Wartortle', types: { fighting: true }, level: 16 }

const evolution = merge(starter, newValues, { is: 'cool' })
// returns {
//   name: 'Wartortle',
//   types: { water: true, fighting: true },
//   level: 16,
//   is: 'cool'
// }

TypeScript Support

In the example above, if you are using TypeScript, and you hover over evolution, you can actually see the type of your new object right then and there. This is very powerful, because you can merge things, and without needing any, TypeScript will know exactly how your newly merged objects look!

The return type of the merge() function is usable as a TypeScript utility as well:

typescript
import type { Merge } from 'merge-anything'

type A1 = { name: string }
type A2 = { types: { water: boolean } }
type A3 = { types: { fighting: boolean } }

type Result = Merge

Rules

This package will recursively go through plain objects and merge the values onto a new object.

Please note that this package recognises special JavaScript objects like class instances. In such cases it will not recursively merge them like objects, but assign the class onto the new object "as is"!

…

merge-anything properly keeps special objects intact like dates, regex, functions, class instances etc.

However, it's very important you understand how to work around JavaScript object references. Please be sure to read #a note on JavaScript object references down below.

Concat arrays

The default behaviour is that arrays are overwritten. You can import mergeAndConcat if you need to concatenate arrays. But don't worry if you don't need this, this library is tree-shakable and won't import code you don't use!

javascript
import { mergeAndConcat } from 'merge-anything'

mergeAndConcat(
  { nested: { prop: { array: ['a'] } } },
  { nested: { prop: { array: ['b'] } } }
)
// returns { nested: { prop: { array: ['a', 'b'] } } },

Compare Function when a value is merged

There might be times you need to tweak the logic when two things are merged. You can provide your own custom function that's triggered every time a value is overwritten.

For this case we use mergeAndCompare. Here is an example with a compare function that concatenates strings:

javascript
import { mergeAndCompare } from 'merge-anything'

function concatStrings(originVal, newVal, key) {
  if (typeof originVal === 'string' && typeof newVal === 'string') {
    // concat logic
    return `${originVal}${newVal}`
  }
  // always return newVal as fallback!!
  return newVal
}

mergeAndCompare(concatStrings, { name: 'John' }, { name: 'Simth' })
// returns { name: 'JohnSmith' }

Note for TypeScript users. The type returned by this function might not be correct. In that case you have to cast the result to your own provided interface

A note on JavaScript object references

Be careful for JavaScript object reference. Any property that's nested will be reactive and linked between the original and the merged objects! Down below we'll show how to prevent this.

javascript
const original = { airport: { status: 'dep. ' } }
const extraInfo = { airport: { location: 'Brussels' } }
const merged = merge(original, extraInfo)

// we change the status from departuring  to landing 
merged.airport.status = 'lan. '

// the `merged` value will be modified
// merged.airport.status === 'lan. '

// However `original` value will also be modified!!
// original.airport.status === 'lan. '

The key rule to remember is:

Any property that's nested more than 1 level without an overlapping parent property will be reactive and linked in both the merge result and the source

However, there is a really easy solution. We can just copy the merge result to get rid of any reactivity. For this we can use the copy-anything library. This library also makes sure that special class instances do not break, so you can use it without fear of breaking stuff!

See below how we integrate 'copy-anything':

javascript
import { copy } from 'copy-anything'

const original = { airport: { status: 'dep. ' } }
const extraInfo = { airport: { location: 'Brussels' } }
const merged = copy(merge(original, extraInfo))

// we change the status from departuring  to landing 
merged.airport.status = 'lan. '(merged.airport.status === 'lan. ')(
  // true
  // `original` won't be modified!
  original.airport.status === 'dep. '
) // true

You can then play around where you want to place the copy() function.

Copy Anything is also fully TypeScript supported!

Source code

It is literally just going through an object recursively and assigning the values to a new object like below. However, it's wrapped to allow extra params etc. The code below is the basic integration, that will make you understand the basics how it works.

…

* Of course, there are small differences with the actual source code to cope with rare cases & extra features. The actual source code is here.

Issues· 0 开放

查看全部 Issues在 GitHub 打开

暂无开放 Issues,或尚未同步最近议题。

> 标签

TypeScriptcombinecombine-mergecombine-objectsdeep-assign

暂无评论,来聊聊你的看法吧

> 工具信息

发布日期2026年8月1日
最后更新2026年9月17日
分类编程语言
定价开源

> 相关工具

T
TypeScript
JavaScript 的超集,为前端与全栈提供静态类型
P
Python
通用编程语言,广泛用于 Web、数据与 AI
G
Go
Google 推出的简洁高效系统语言