NodeJS 的深度扩展（如 jQuery）

Question

我正在努力处理 NodeJS 中对象的深层副本。我自己的扩展很糟糕。下划线的延伸是平坦的。 stackexchange 上有相当简单的扩展变体，但没有一个接近 jQuery.extend(true, {}, obj, obj, obj) .. （大多数实际上都很糟糕，并且破坏了 asnyc 代码的好处。）

因此，我的问题是：NodeJS 是否有一个好的深拷贝？有人移植过 jQuery 吗？

Answer 1

已经移植了。 node-extend

注意该项目没有测试，也没有太多人气，所以使用风险由您自行承担。

如前所述，您可能不需要深层副本。尝试改变你的数据结构，这样你就只需要浅拷贝。

几个月后，

我编写了一个较小的模块，建议您使用 xtend。它没有包含 jQuery 包袱的实现，也没有像 node-extend 那样的错误。

Answer 2

你想要 jQuery 的，所以只需使用它：

function extend() {
    var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {},
        i = 1,
        length = arguments.length,
        deep = false,
        toString = Object.prototype.toString,
        hasOwn = Object.prototype.hasOwnProperty,
        push = Array.prototype.push,
        slice = Array.prototype.slice,
        trim = String.prototype.trim,
        indexOf = Array.prototype.indexOf,
        class2type = {
          "[object Boolean]": "boolean",
          "[object Number]": "number",
          "[object String]": "string",
          "[object Function]": "function",
          "[object Array]": "array",
          "[object Date]": "date",
          "[object RegExp]": "regexp",
          "[object Object]": "object"
        },
        jQuery = {
          isFunction: function (obj) {
            return jQuery.type(obj) === "function"
          },
          isArray: Array.isArray ||
          function (obj) {
            return jQuery.type(obj) === "array"
          },
          isWindow: function (obj) {
            return obj != null && obj == obj.window
          },
          isNumeric: function (obj) {
            return !isNaN(parseFloat(obj)) && isFinite(obj)
          },
          type: function (obj) {
            return obj == null ? String(obj) : class2type[toString.call(obj)] || "object"
          },
          isPlainObject: function (obj) {
            if (!obj || jQuery.type(obj) !== "object" || obj.nodeType) {
              return false
            }
            try {
              if (obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
                return false
              }
            } catch (e) {
              return false
            }
            var key;
            for (key in obj) {}
            return key === undefined || hasOwn.call(obj, key)
          }
        };
      if (typeof target === "boolean") {
        deep = target;
        target = arguments[1] || {};
        i = 2;
      }
      if (typeof target !== "object" && !jQuery.isFunction(target)) {
        target = {}
      }
      if (length === i) {
        target = this;
        --i;
      }
      for (i; i < length; i++) {
        if ((options = arguments[i]) != null) {
          for (name in options) {
            src = target[name];
            copy = options[name];
            if (target === copy) {
              continue
            }
            if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
              if (copyIsArray) {
                copyIsArray = false;
                clone = src && jQuery.isArray(src) ? src : []
              } else {
                clone = src && jQuery.isPlainObject(src) ? src : {};
              }
              // WARNING: RECURSION
              target[name] = extend(deep, clone, copy);
            } else if (copy !== undefined) {
              target[name] = copy;
            }
          }
        }
      }
      return target;
    }

和一个小测试来证明它可以进行深度复制，

extend(true, 
    {
        "name": "value"
    }, 
    {
        "object": "value",
        "other": "thing",
        "inception": {
            "deeper": "deeper",
            "inception": {
                "deeper": "deeper",
                "inception": {
                    "deeper": "deeper"
                }
            }
        }
    }
)

但请记住提供归属： https://github.com/jquery/jquery/blob/master/src/core.js

Answer 3

对于深拷贝的一个快速而肮脏的答案就是用一点 JSON 来作弊。它不是性能最好的，但它确实非常好地完成这项工作。

function clone(a) {
   return JSON.parse(JSON.stringify(a));
}

Answer 4

请使用内置的util模块：

var extend = require('util')._extend;

var merged = extend(obj1, obj2);

Answer 5

我知道这是一个老问题，但我只想将 lodash 的合并 作为一个好的解决方案。对于一般的实用函数，我推荐 lodash :)

Answer 6

这适用于深层对象扩展...请注意，它替换数组而不是它们的值，但显然可以按照您的喜好进行更新。它应该保持枚举功能以及您可能希望它执行的所有其他操作

function extend(dest, from) {
    var props = Object.getOwnPropertyNames(from), destination;

    props.forEach(function (name) {
        if (typeof from[name] === 'object') {
            if (typeof dest[name] !== 'object') {
                dest[name] = {}
            }
            extend(dest[name],from[name]);
        } else {
            destination = Object.getOwnPropertyDescriptor(from, name);
            Object.defineProperty(dest, name, destination);
        }
    });
}

Answer 7

在 Node.js 中，您可以使用 Extendify 创建支持嵌套对象扩展的 _.extend 函数（深度扩展）并且对其参数也是不可变的（因此是深度克隆）。

_.extend = extendify({
    inPlace: false,
    isDeep: true
});

Answer 8

node.extend 做得很深入并且具有熟悉的 jQuery 语法

Answer 9

只需安装扩展即可。
文档：
节点扩展包
安装：

npm install extend

然后享受它：

extend ( [deep], target, object1, [objectN] )

深度是可选的。默认为 false。如果切换为 true 它将递归地合并你的对象。

Answer 10

锐化版本称为 whet.extend。

我用 CoffeeScript 重写 node-extend 并添加 travis-ci 测试套件，因为我需要深度为自己处理 Node ，所以现在它就在这里。

是的，我认为在某些情况下使用深度合并是绝对正确的，例如，当我们需要将默认分支和用户分支合并在一起时，我在配置工作中使用它。

Answer 11

您也可以使用我的扩展插件版本
https://github.com/maxmara/dextend