through2.js,xtend.js源码

摘要：优化性能这里有个有意思的地方。在多个参数的情况下。无则跳过，支持覆盖不可变。与原先不同的是，这里使用了一份初始化的对象引用来作为容器承载其余没有不同

</>复制代码 
through2 本质上是一种transform的流
被封装更好地操作流
var Transform = require("readable-stream/transform")
  , inherits  = require("util").inherits
  , xtend     = require("xtend")
function DestroyableTransform(opts) {
  // 继承Transform
  Transform.call(this, opts)
  this._destroyed = false
}
inherits(DestroyableTransform, Transform)
// 原型接口destory 用来关闭流
DestroyableTransform.prototype.destroy = function(err) {
  if (this._destroyed) return
  this._destroyed = true
  
  var self = this
  process.nextTick(function() {
    if (err)
      self.emit("error", err)
    self.emit("close")
    //events的使用
  })
}
// a noop _transform function
// 空操作
function noop (chunk, enc, callback) {
  callback(null, chunk)
}
// create a new export function, used by both the main export and
// the .ctor export, contains common logic for dealing with arguments
// 返回一个导出的函数接口
function through2 (construct) {
// 返回使用的匿名函数
  return function (options, transform, flush) {
    if (typeof options == "function") {
      flush     = transform
      transform = options
      options   = {}
    }
    // 这种匿名函数我们一般可以用来做二次判断触发
    if (typeof transform != "function")
      transform = noop
    if (typeof flush != "function")
      flush = null
    return construct(options, transform, flush)
  }
}
// main export, just make me a transform stream!
// 主要出口，使用through2返回一个DestroyTransform实例
module.exports = through2(function (options, transform, flush) {
  var t2 = new DestroyableTransform(options)
  t2._transform = transform
  if (flush)
    t2._flush = flush
  return t2
})
// make me a reusable prototype that I can `new`, or implicitly `new`
// with a constructor call
// 对外暴露一个可以直接 new （或者不加 new）来创建实例的的构造函数
module.exports.ctor = through2(function (options, transform, flush) {
  function Through2 (override) {
    if (!(this instanceof Through2))
        // 这里就是直接自动new
      return new Through2(override)
    this.options = xtend(options, override)
    // 添加配置
    DestroyableTransform.call(this, this.options)
  }
  inherits(Through2, DestroyableTransform)
  Through2.prototype._transform = transform
  if (flush)
    Through2.prototype._flush = flush
  return Through2
})
// Object模式的简单封装
module.exports.obj = through2(function (options, transform, flush) {
  var t2 = new DestroyableTransform(xtend({ objectMode: true, highWaterMark: 16 }, options))
  t2._transform = transform
  if (flush)
    t2._flush = flush
  return t2
})

</>复制代码 
xtend lib //简单的继承 两种，一种可变  一种不可变
module.exports = extend
var hasOwnProperty = Object.prototype.hasOwnProperty;
// 缓存老套路。优化性能
function extend(target) {
    // 这里有个有意思的地方。target第一个拿进来。在多个参数的情况下。下面从arguments[1]开始取，而下面可以直接使用target，而不用再声明一下变量
    for (var i = 1; i < arguments.length//这块其实可以缓存长度的; i++) {
        var source = arguments[i]
        
        for (var key in source) {
            if (hasOwnProperty.call(source, key)) {
                // 判断当前实例是否存在属性
                // 有则添加到target上。无则跳过，支持覆盖
                target[key] = source[key]
            }
        }
    }
    return target
}
不可变。
module.exports = extend
var hasOwnProperty = Object.prototype.hasOwnProperty;
function extend() {
// 与原先不同的是，这里使用了一份初始化的对象引用来作为容器承载
// 其余没有不同
    var target = {}
    for (var i = 0; i < arguments.length; i++) {
        var source = arguments[i]
        for (var key in source) {
            if (hasOwnProperty.call(source, key)) {
                target[key] = source[key]
            }
        }
    }
    return target
}

throught

xtend