Underscore: Глубокое расширение и глубокое копирование

Боюсь, в JavaScript нет действительно хорошей семантики для операции глубокого копирования. Существующие реализации имеют различные ошибки, такие как изменение вложенных массивов и невозможность копирования вложенных объектов Date. Если вы хотите предложить эту функцию, вам придется сопровождать ее надежной реализацией.

Правда, глубокие копии определенно беспорядочны в javascript. Должен быть какой-то момент, когда вы говорите, что преимущества перевешивают недостатки, верно? Когда люди постоянно пишут убогие методы глубокого копирования, которые не работают должным образом, это хуже, чем использование тщательно закодированного метода глубокого копирования, но имеющего хорошо задокументированные ограничения. Например, отличное решение этого парня: http://stackoverflow.com/questions/728360/copying-an-object-in-javascript/728694#728694

Он охватывает большинство основ и документирует то, что не будет корректно обрабатываться. Он предполагает, что объект содержит только эти типы: Object, Array, Date, String, Number и Boolean, и он предполагает, что любые объекты или массивы будут содержать только одно и то же.

Да, и даже решение этого парня недостаточно хорошо. Если мы не можем реализовать это правильно, мы не должны это реализовывать.

Но неужели пользователям лучше накатить собственную, возможно, еще более ломаную реализацию?

Нет. Пользователям лучше не выполнять глубокое копирование в JavaScript. Обычно вы можете найти способ достичь той же цели, не имея надежной функции глубокого копирования... заранее зная структуру объекта, который вы хотите скопировать.

Ах, так вы предлагаете пользователю заполнить новый экземпляр объекта необходимыми значениями? Я вижу.

Jquery.extend имеет глубокую опцию.

+1 за глубокий вариант, независимо от того, насколько сложно его реализовать.

+2 за это - это не сложно реализовать, это дело принципа (т.е. не реализовывать менее совершенное решение). Однако, как упоминалось выше, он используется в библиотеке jQuery и весьма полезен во всех случаях, кроме нескольких пограничных. Было бы неплохо иметь его доступным в облегченной библиотеке, подобной этой.

@kmalakoff написал реализацию , вы должны дать ему отзыв! :)

Вы даже можете объединить мой оригинальный _.cloneToDepth с _clone и просто добавить параметр глубины....

  // Create a duplicate of a container of objects to any zero-indexed depth.
  _.cloneToDepth = _.clone = function(obj, depth) {
    if (typeof obj !== 'object') return obj;
    var clone = _.isArray(obj) ? obj.slice() : _.extend({}, obj);
    if (!_.isUndefined(depth) && (depth > 0)) {
      for (var key in clone) {
        clone[key] = _.clone(clone[key], depth-1);
      }
    }
    return clone;
  };

Кроме того, я написал _.own и _.disown, которые вводят соглашение о владении (либо пары сохранить/выпустить, либо клонировать/уничтожить). Он рекурсирует только на один уровень вниз, но я полагаю, что может быть добавлена ​​​​опция для полной рекурсии (я бы хотел увидеть вариант использования!).

  _.own = function(obj, options) {
    if (!obj || (typeof(obj)!='object')) return obj;
    options || (options = {});
    if (_.isArray(obj)) {
      if (options.share_collection) { _.each(obj, function(value) { _.own(value, {prefer_clone: options.prefer_clone}); }); return obj; }
      else { var a_clone =  []; _.each(obj, function(value) { a_clone.push(_.own(value, {prefer_clone: options.prefer_clone})); }); return a_clone; }
    }
    else if (options.properties) {
      if (options.share_collection) { _.each(obj, function(value, key) { _.own(value, {prefer_clone: options.prefer_clone}); }); return obj; }
      else { var o_clone = {}; _.each(obj, function(value, key) { o_clone[key] = _.own(value, {prefer_clone: options.prefer_clone}); }); return o_clone; }
    }
    else if (obj.retain) {
      if (options.prefer_clone && obj.clone) return obj.clone();
      else obj.retain();
    }
    else if (obj.clone) return obj.clone();
    return obj;
  };

  _.disown = function(obj, options) {
    if (!obj || (typeof(obj)!='object')) return obj;
    options || (options = {});
    if (_.isArray(obj)) {
      if (options.clear_values) { _.each(obj, function(value, index) { _.disown(value); obj[index]=null; }); return obj; }
      else {
        _.each(obj, function(value) { _.disown(value); });
        obj.length=0; return obj;
      }
    }
    else if (options.properties) {
      if (options.clear_values) { _.each(obj, function(value, key) { _.disown(value); obj[key]=null; }); return obj; }
      else {
        _.each(obj, function(value) { _.disown(value); });
        for(key in obj) { delete obj[key]; }
        return obj;
      }
    }
    else if (obj.release) obj.release();
    else if (obj.destroy) obj.destroy();
    return obj;
  };

И если вам нужен расширяемый клон общего назначения:

  // Create a duplicate of all objects to any zero-indexed depth.
  _.deepClone = function(obj, depth) {
    if (typeof obj !== 'object') return obj;
    if (_.isString(obj)) return obj.splice();
    if (_.isDate(obj)) return new Date(obj.getTime());
    if (_.isFunction(obj.clone)) return obj.clone();
    var clone = _.isArray(obj) ? obj.slice() : _.extend({}, obj);
    if (!_.isUndefined(depth) && (depth > 0)) {
      for (var key in clone) {
        clone[key] = _.deepClone(clone[key], depth-1);
      }
    }
    return clone;
  };

Я не уверен, что это хорошая идея, пока не будет приведен пример использования, в котором глубокая копия на самом деле является лучшим решением. Думаю найти будет сложно.

Я не был полностью удовлетворен своим вчерашним ответом (не следует писать код после полуночи)... Я придумал две версии ( _.cloneToDepth в основном просто клонирует контейнер, сохраняя ссылки на исходные объекты и _.deepClone , который копирует экземпляры):

  // Create a duplicate of a container of objects to any zero-indexed depth.
  _.cloneToDepth = _.containerClone = _.clone = function(obj, depth) {
    if (!obj || (typeof obj !== 'object')) return obj;  // by value
    var clone;
    if (_.isArray(obj)) clone = Array.prototype.slice.call(obj);
    else if (obj.constructor!=={}.constructor) return obj; // by reference
    else clone = _.extend({}, obj);
    if (!_.isUndefined(depth) && (depth > 0)) {
      for (var key in clone) {
        clone[key] = _.clone(clone[key], depth-1);
      }
    }
    return clone;
  };

  // Create a duplicate of all objects to any zero-indexed depth.
  _.deepClone = function(obj, depth) {
    if (!obj || (typeof obj !== 'object')) return obj;  // by value
    else if (_.isString(obj)) return String.prototype.slice.call(obj);
    else if (_.isDate(obj)) return new Date(obj.valueOf());
    else if (_.isFunction(obj.clone)) return obj.clone();
    var clone;
    if (_.isArray(obj)) clone = Array.prototype.slice.call(obj);
    else if (obj.constructor!=={}.constructor) return obj; // by reference
    else clone = _.extend({}, obj);
    if (!_.isUndefined(depth) && (depth > 0)) {
      for (var key in clone) {
        clone[key] = _.deepClone(clone[key], depth-1);
      }
    }
    return clone;
  };

Как указывает @michaelficarra , варианты использования могут быть неясными. Лично я использую:

1) _.own / _.disown , когда я хочу поделиться объектами со сложными жизненными циклами и/или моделями владения (например, подсчет ссылок для правильной обработки очистки)
2) Я использовал _.cloneToDepth / _.containerClone (редко!), когда у меня были сложные вложенные опции для функции.
3) Мне никогда не нужен _.deepClone , но предположим, что он может быть полезен в качестве метода общего назначения _.clone , если вы пишете общую функцию, которая гибко поддерживает типы (например, я не мне все равно, что вы мне передадите, но я собираюсь изменить это и не хочу иметь побочных эффектов на оригинале, хотя строки - это особый неизменяемый случай).

Я отправил код и тесты здесь: https://github.com/kmalakoff/underscore-awesomer/commit/0cf6008f16ad6e6daf60caf456021693ef33fec5 .

Примечание: те, кто застрял в поисках однострочного неполного глубокого клонирования для простых объектов с предсказуемой семантикой, могут просто JSON.parse(JSON.stringify(object)) .

@adamhooper Этот метод имеет тенденцию терять свойства или что-то в этом роде? Почему он неполный?

@diversario Он не будет копировать прототип объекта и не будет копировать функции. Это применяется рекурсивно, поэтому он также не будет правильно копировать прототипы или функции вложенных объектов.

В частности: он не будет правильно копировать любую дату в вашем дереве объектов. И если вы хотите исправить это для работы с датами, ну, вы просто решаете небольшой симптом гораздо более серьезной проблемы.

О верно. В основном я использую его, чтобы сломать ссылки на такие вещи, как «шаблонные» объекты, поэтому я не сталкивался ни с чем подобным. Но я вижу потребность в реальном глубоком копировании.

Я превратил миксин deepExtend Курта Милама в пакет npm.

https://github.com/pygy/undescoreDeepExtend/

@michaelficarra , пожалуйста, объясните, почему глубокое копирование не является хорошим решением для клонирования общей древовидной структуры?

Для всех, кто пытается использовать однострочную глубокую копию
JSON.parse(JSON.stringify(объект))
на самом деле он преобразует любой объект Date в строку

-1 для глубокого копирования. Использование цепочки прототипов для объектов конфигурации всегда будет лучше подходить для вашего API, чем вложенные параметры.

На самом деле есть место для глубокого копирования, но оно должно совпадать с проверкой типов, так что, на мой взгляд, это очень специфический вариант использования, а не общего назначения. Лучше подходит для библиотек схем JSON или загрузчиков конфигурации. Не пояс инструментов javascript.

В большинстве случаев _.extend({}, obj1, { prop1: 1, prop2: 2 }) - это то, что мне действительно нужно сделать:

• дает мне новый объект
• не изменяет мой исходный объект и
• не является глубокой копией

_.deepClone = function(obj) {
      return (!obj || (typeof obj !== 'object'))?obj:
          (_.isString(obj))?String.prototype.slice.call(obj):
          (_.isDate(obj))?new Date(obj.valueOf()):
          (_.isFunction(obj.clone))?obj.clone():
          (_.isArray(obj)) ? _.map(obj, function(t){return _.deepClone(t)}):
          _.mapObject(obj, function(val, key) {return _.deepClone(val)});
  };

В нашей рабочей среде мы часто сталкиваемся с вариантами использования, которые выиграют от глубокого клонирования.

Иногда вам приходится выполнять миграцию базы данных, когда функции сложного веб-приложения обновляются и расширяются до новой парадигмы. Глубокая копия наших данных очень полезна, когда приходится выполнять такие операции, как создание хэшей из данных, когда исходная ссылка предпочтительнее, чтобы не манипулировать ею. Я не думаю, что хоть один документ в нашей огромной базе данных является «плоским». Вложенные свойства существуют везде.

Кроме того, иногда вы хотите отправить копию объекта в другую службу в вашем веб-приложении, чтобы обработать ее, прежде чем решить, что с ней делать. Наличие вложенных свойств по ссылке противоречит цели наличия клонированного объекта. ВЕСЬ смысл, imo, клонированного объекта состоит в том, чтобы оставить исходную ссылку нетронутой. Как только вы вводите ссылки на более глубокие уровни, вся цель становится спорной.

Я уверен, что есть достойный способ сделать это, когда объект можно перемещать в его глубины, а затем реконструировать от самого глубокого слоя до корня.

У Lodash есть это - https://lodash.com/docs/4.17.5#cloneDeep