copy-to源码解析

介绍

copy an object’s properties to another one, include propertiy, getter and setter.

意思是从另一个对象中复制属性，其中包括属性，getter和setter访问器函数。

demo:

var copy = require('copy-to');
 
var src = {
  _name: 'foo',
  set name(val) {
    this._name = val;
  },
  get name() {
    return this._name;
  },
  show: function () {
    console.log(this._name);
  }
};
 
var des = {
  _name: 'bar'
};
 
copy(src).to(des);
copy(src).toCover(des);
copy(src).pick('_name', 'name').to(des);
copy(src).pick('_name', 'name').toCover(des);

copy(src).withAccess().and(other).to(des); // 包括构造器属性

源码 copy-to.js 2.0.1

'use strict';
var slice = Array.prototype.slice;

/**
 * Expose copy
 *
 * ```
 * copy({foo: 'nar', hello: 'copy'}).to({hello: 'world'});
 * copy({foo: 'nar', hello: 'copy'}).toCover({hello: 'world'});
 * ```
 *
 * @param {Object} src
 * @return {Copy}
 */

module.exports = Copy;

/**
 * 核心的copy方法
 * @param {Object} src
 * @param {Boolean} withAccess
 */
function Copy(src, withAccess) {
  // 一种写法的兼容，可以直接调用Copy相当于new Copy
  if (!(this instanceof Copy)) return new Copy(src, withAccess);
  // 设置源对象和目标对象
  this.src = src;
  this._withAccess = withAccess;
}

/**
 * 复制属性包括 getter 和 setter
 * @param {[type]} val [description]
 * @return {[type]} [description]
 */
Copy.prototype.withAccess = function (w) {
  this._withAccess = w !== false;
  return this;
};

/**
 * 指定 src 对象的某些属性
 * @api: public
 */
Copy.prototype.pick = function (keys) {
  if (!Array.isArray(keys)) {
    keys = slice.call(arguments);
  }
  if (keys.length) {
    this.keys = keys;
  }
  return this;
};

/**
 * copy src to target,
 * do not cover any property target has
 * @param {Object} to
 * @api: public
 */
Copy.prototype.to = function (to) {
  to = to || {};

  if (!this.src) return to;
  var keys = this.keys || Object.keys(this.src);

  // _withAccess默认undefined即不考虑构造器，调用
  if (!this._withAccess) {
    for (var i = 0; i < keys.length; i++) {
      var key = keys[i];
      if (to[key] !== undefined) continue;
      to[key] = this.src[key];
    }
    return to;
  }

  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    // 如果该属性存在跳过，即不覆盖
    if (!notDefined(to, key)) continue;
    var getter = this.src.__lookupGetter__(key);
    var setter = this.src.__lookupSetter__(key);
    if (getter) to.__defineGetter__(key, getter);
    if (setter) to.__defineSetter__(key, setter);

    if (!getter && !setter) {
      to[key] = this.src[key];
    }
  }
  return to;
};

/**
 * 从src对象复制到to对象，并且覆盖目标对象已有的属性
 * @param {Object} to
 * @api: public
 */
Copy.prototype.toCover = function (to) {
  var keys = this.keys || Object.keys(this.src);

  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    delete to[key];
    var getter = this.src.__lookupGetter__(key);
    var setter = this.src.__lookupSetter__(key);
    if (getter) to.__defineGetter__(key, getter);
    if (setter) to.__defineSetter__(key, setter);

    if (!getter && !setter) {
      to[key] = this.src[key];
    }
  }
};

Copy.prototype.override = Copy.prototype.toCover;

/**
 * 添加其他对象到src中
 * @param {Obj} obj
 * @return {Copy}
 */
Copy.prototype.and = function (obj) {
  var src = {};
  this.to(src);
  this.src = obj;
  this.to(src);
  this.src = src;

  return this;
};

/**
 * 检查 obj[key] 是否存在
 * @param {Object} obj
 * @param {String} key
 * @return {Boolean}
 */
function notDefined(obj, key) {
  return obj[key] === undefined
    && obj.__lookupGetter__(key) === undefined
    && obj.__lookupSetter__(key) === undefined;
}

__lookupGetter__

该方法会返回当前对象上指定属性的属性读取访问器函数（getter）。目前已废弃，不推荐使用。

__defineGetter__

该方法可以将一个函数绑定在当前对象的指定属性上，当那个属性的值被读取时，你所绑定的函数就会被调用。目前已废弃，不推荐使用。

参考链接：

打赏