摘要：優化性能這里有個有意思的地方。在多個參數的情況下。無則跳過，支持覆蓋不可變。與原先不同的是，這里使用了一份初始化的對象引用來作為容器承載其余沒有不同

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