update

update模块用于快速作数据处理。

 

'use strict';

var _prodInvariant = require('./reactProdInvariant'),
    _assign = require('object-assign');

var invariant = require('fbjs/lib/invariant');
var hasOwnProperty = {}.hasOwnProperty;

function shallowCopy(x) {
  if (Array.isArray(x)) {
    return x.concat();
  } else if (x && typeof x === 'object') {
    return _assign(new x.constructor(), x);// 使用x对象的构造函数创建对象
  } else {
    return x;
  }
}

var COMMAND_PUSH = '$push';
var COMMAND_UNSHIFT = '$unshift';
var COMMAND_SPLICE = '$splice';
var COMMAND_SET = '$set';
var COMMAND_MERGE = '$merge';
var COMMAND_APPLY = '$apply';

var ALL_COMMANDS_LIST = [COMMAND_PUSH, COMMAND_UNSHIFT, COMMAND_SPLICE, COMMAND_SET, COMMAND_MERGE, COMMAND_APPLY];

var ALL_COMMANDS_SET = {};

ALL_COMMANDS_LIST.forEach(function (command) {
  ALL_COMMANDS_SET[command] = true;
});

function invariantArrayCase(value, spec, command) {
  // value需要为数组形式
  !Array.isArray(value) ? 
    process.env.NODE_ENV !== 'production' ? 
      invariant(false, 'update(): expected target of %s to be an array; got %s.', command, value) 
      : _prodInvariant('1', command, value) 
    : void 0;

  // spec[command]需要为数组形式
  var specValue = spec[command];
  !Array.isArray(specValue) ? 
    process.env.NODE_ENV !== 'production' ? 
      invariant(false, 'update(): expected spec of %s to be an array; got %s.' 
        + ' Did you forget to wrap your parameter in an array?', command, specValue) 
      : _prodInvariant('2', command, specValue) 
    : void 0;
}

// 配置形式快速作数据处理后返回，支持'$push'、'$unshift'、'$splice'、'$set'、'$merge'、'$apply'
// const newData = update(myData, {
//   x: {y: {z: {$set: 7}}},
//   a: {b: {$push: [9]}}
// });
function update(value, spec) {
  // spec不能是非对象
  !(typeof spec === 'object') ? 
    process.env.NODE_ENV !== 'production' ? 
      invariant(false, 
        'update(): You provided a key path to update() that did not contain one of %s. ' 
        + 'Did you forget to include {%s: ...}?', ALL_COMMANDS_LIST.join(', '), COMMAND_SET) 
      : _prodInvariant('3', ALL_COMMANDS_LIST.join(', '), COMMAND_SET) : void 0;

  // spec含$set属性时，只能接受单个属性
  if (hasOwnProperty.call(spec, COMMAND_SET)) {
    !(Object.keys(spec).length === 1) ? 
      process.env.NODE_ENV !== 'production' ? 
        invariant(false, 'Cannot have more than one key in an object with %s', COMMAND_SET) 
        : _prodInvariant('4', COMMAND_SET) : void 0;

    return spec[COMMAND_SET];
  }

  var nextValue = shallowCopy(value);

  // spec含$merge属性时，将sepc["$merge"]对象合并到value对象中
  if (hasOwnProperty.call(spec, COMMAND_MERGE)) {
    var mergeObj = spec[COMMAND_MERGE];

    // sepc["$merge"]需要为对象形式
    !(mergeObj && typeof mergeObj === 'object') ? 
      process.env.NODE_ENV !== 'production' ? 
        invariant(false, 'update(): %s expects a spec of type \'object\'; got %s', 
          COMMAND_MERGE, mergeObj) 
        : _prodInvariant('5', COMMAND_MERGE, mergeObj) 
      : void 0;

    // value需要为对象形式
    !(nextValue && typeof nextValue === 'object') ? 
      process.env.NODE_ENV !== 'production' ? 
        invariant(false, 'update(): %s expects a target of type \'object\'; got %s', 
          COMMAND_MERGE, nextValue) 
        : _prodInvariant('6', COMMAND_MERGE, nextValue) 
      : void 0;

    _assign(nextValue, spec[COMMAND_MERGE]);
  }

  // spec含$push属性时，将sepc["$push"]数组添加到value数组的尾部
  if (hasOwnProperty.call(spec, COMMAND_PUSH)) {
    invariantArrayCase(value, spec, COMMAND_PUSH);
    spec[COMMAND_PUSH].forEach(function (item) {
      nextValue.push(item);
    });
  }

  // spec含$unshift属性时，将sepc["$unshift"]数组添加到value数组的顶部
  if (hasOwnProperty.call(spec, COMMAND_UNSHIFT)) {
    invariantArrayCase(value, spec, COMMAND_UNSHIFT);
    spec[COMMAND_UNSHIFT].forEach(function (item) {
      nextValue.unshift(item);
    });
  }

  // spec含$splice属性时，对value作splice处理后返回
  if (hasOwnProperty.call(spec, COMMAND_SPLICE)) {
    // value需要为数组
    !Array.isArray(value) ? 
      process.env.NODE_ENV !== 'production' ? 
        invariant(false, 'Expected %s target to be an array; got %s', COMMAND_SPLICE, value) 
        : _prodInvariant('7', COMMAND_SPLICE, value) 
      : void 0;

    // spec["$splice"]须是数组
    !Array.isArray(spec[COMMAND_SPLICE]) ? 
      process.env.NODE_ENV !== 'production' ? 
        invariant(false, 'update(): expected spec of %s to be an array of arrays;' 
          + ' got %s. Did you forget to wrap your parameters in an array?', 
          COMMAND_SPLICE, spec[COMMAND_SPLICE]) 
        : _prodInvariant('8', COMMAND_SPLICE, spec[COMMAND_SPLICE]) 
      : void 0;


    spec[COMMAND_SPLICE].forEach(function (args) {
      // spec["$splice"]数组元素须是数组
      !Array.isArray(args) ? 
        process.env.NODE_ENV !== 'production' ? 
          invariant(false, 'update(): expected spec of %s to be an array of arrays;' 
            + ' got %s. Did you forget to wrap your parameters in an array?', 
            COMMAND_SPLICE, spec[COMMAND_SPLICE]) 
          : _prodInvariant('8', COMMAND_SPLICE, spec[COMMAND_SPLICE]) 
        : void 0;

      // 使用apply方法将args拆解为单参数传给splice方法，args须是起始项序号、删除元素个数、待添加的元素
      nextValue.splice.apply(nextValue, args);
    });
  }

  // spec含$apply属性时，调用spec["$apply"]函数处理value后返回
  if (hasOwnProperty.call(spec, COMMAND_APPLY)) {
    // spec["$apply"]须是函数
    !(typeof spec[COMMAND_APPLY] === 'function') ? 
      process.env.NODE_ENV !== 'production' ? 
        invariant(false, 'update(): expected spec of %s to be a function; got %s.', 
          COMMAND_APPLY, spec[COMMAND_APPLY]) 
        : _prodInvariant('9', COMMAND_APPLY, spec[COMMAND_APPLY]) 
      : void 0;

    nextValue = spec[COMMAND_APPLY](nextValue);
  }

  // 递归调用
  for (var k in spec) {
    if (!(ALL_COMMANDS_SET.hasOwnProperty(k) && ALL_COMMANDS_SET[k])) {
      nextValue[k] = update(value[k], spec[k]);
    }
  }

  return nextValue;
}

module.exports = update;