摘要：創建一個自調用匿名函數，設計參數，并傳入對象。表示獨一無二的值聲明時不能使用，而是聲明時可以加參數，用于描述作為時不能被遍歷這個函數主要是檢測當前對象是否有某種屬性。給變量賦值一個空的對象返回一個的函數，將函數的參數的帶入并賦值，返回。

(function (global, factory) {
  typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() :
  typeof define === "function" && define.amd ? define(factory) :
  (global = global || self, global.Vue = factory());
}(this, function () { "use strict";

創建一個自調用匿名函數，設計參數window，并傳入window對象。不污染全局變量，也不會別的代碼污染

var emptyObject = Object.freeze({});

字面上意義：空對象=凍結掉這個對象

Object.freeze({})這個方法核心在于對于這個對象將無法修改，添加。

function isUndef (v) {return v === undefined || v === null}

是否未被定義,如果參數等于undefined或者為空，返回true

function isDef (v) {return v !== undefined && v !== null}

是否定義,如果參數不等于undefined或者為空，返回true

function isTrue (v) {return v === true}

是否真，參數為真是返回true

function isFalse (v) {return v === false}

是否假，參數為真是返回true

function isPrimitive (value) {
    return (
    typeof value === "string" ||
    typeof value === "number" ||
    // $flow-disable-line
    typeof value === "symbol" ||
    typeof value === "boolean"
    )
}

是否為原始類型，typeof 返回

function isObject (obj) {return obj !== null && typeof obj === "object"}

是否為對象，如果對象不等于空且typeof返回為object，返回true

var _toString = Object.prototype.toString;

該方法返回描述某個對象數據類型的字符串，如自定義的對象沒有被覆蓋，則會返回“[object type]”，其中，type則是實際的對象類型。在使用該方法檢測的時候，可以使用Object.prototype.toString.call()或者Object.prototype.toString.apply()進行測試，如

function toRawType (value) {return _toString.call(value).slice(8, -1)}

slice(startIndex,endIndex)，從0開始索引，其中8代表從第8位（包含）開始截取（本例中代表空格后面的位置），-1代表截取到倒數第一位（不含），所以正好截取到[object String]中的String。

function isPlainObject (obj) {return _toString.call(obj) === "[object Object]"}

isPlainObject 靜態函數 判斷指定參數是否是一個純粹的對象

function isRegExp (v) {return _toString.call(v) === "[object RegExp]"}

判斷指定參數是否是一個正則

function isValidArrayIndex (val) {
    var n = parseFloat(String(val));
    return n >= 0 && Math.floor(n) === n && isFinite(val)
}

是否為一個有效的數組，現將值轉為字符串，然后用parseFloat解析，字符串中的首個字符是否是數字。如果是，則對字符串進行解析，直到到達數字的末端為止，然后以數字返回該數字，而不是作為字符串。
如果n>=0以及向下取整等于n以及isFinite是一個有限數。如1/0

function isPromise (val) {
    return (
      isDef(val) &&
      typeof val.then === "function" &&
      typeof val.catch === "function"
    )
}

首先檢測這個值是否被定義，然后判斷它的then和catch是否為一個函數

function toString (val) {
    return val == null
      ? ""
      : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
        ? JSON.stringify(val, null, 2)
        : String(val)
}

首先判斷val是否為空，如果為空輸出""否則
Array.isArray() 先確定是否值為一個Array
或者前面的isPlainObject方法判定是否為一個對象
和值轉成字符串是否等于Object.prototype.toString返回該對象的字符串；
如果條件滿足JSON.stringify(val, null, 2)
stringify是有3個參數，

第一個，參數是傳入的值可以是String|Object|String|Number|Boolean|null

第二個，則是過濾器，過濾器可以是數組，也可以是函數

第三個，可以是空的格子(4)也可以是特殊符號/t

否則將val轉成字符串

function toNumber (val) {
    var n = parseFloat(val);
    return isNaN(n) ? val : n
}

先使用parseFloat函數轉換值，然后isNaN檢查是否為一個數值，如果是輸出val，否則輸出parseFloat(val)基本也就輸出NaN了

function makeMap (
    str,
    expectsLowerCase
  ) {
    var map = Object.create(null);
    var list = str.split(",");
    for (var i = 0; i < list.length; i++) {
      map[list[i]] = true;
    }
    return expectsLowerCase
      ? function (val) { return map[val.toLowerCase()]; }
      : function (val) { return map[val]; }
}

  var isBuiltInTag = makeMap("slot,component", true);
  var isReservedAttribute = makeMap("key,ref,slot,slot-scope,is");

官方解釋：制作一個映射并返回一個函數，用于檢查鍵是否在該映射中。
創建一個空的對象復制給map
將值根據‘,’分割成字符串數組
遍歷循環檢測這個數組
如果expectsLowerCase有值且為true，將map中的數組轉換為小寫，否則直接輸出map中的值
實際上主要就是檢查map中是否存在某個key
檢查標記是否為內置標記
檢查屬性是否為保留屬性

function remove (arr, item) {
    if (arr.length) {
      var index = arr.indexOf(item);
      if (index > -1) {
        return arr.splice(index, 1)
      }
    }
}

從數組中移除
indexOf獲取數組中參數的位置
如果index > -1 存在，刪除當前
.splice(index,howmany,item1,.....,itemX)補充，index為位置，howmany為刪除數量如果為0不刪除，這2個參數為必填。第三個則是向數組中添加

var hasOwnProperty = Object.prototype.hasOwnProperty;
function hasOwn (obj, key) {
return hasOwnProperty.call(obj, key)
}

這個是很有意思的案例
首先hasOwnProperty();這個方法，它的參數很有意思，字符串或者Symbol。然后返回true或false
Symbol是es6一種新的類型，所以有的時候問js有多少類型啊，記得多了一個。

表示獨一無二的值；

聲明時不能使用new Symbol()，而是 Symbol()；

聲明時可以加參數，用于描述；

作為key時不能被遍歷；

hasOwn這個函數主要是檢測當前對象是否有某種屬性。
這個地方還可以做一些衍生
如果你想要實現支持setter和getter特性的拷貝，該怎么實現？
Object.defineproperties （定義屬性） 
Object.getOwnPropertyDescriptors（es2017，獲取對象的多個屬性）
Object.getOwnPropertyDescriptor（老一點，獲取對象的單個屬性的屬性），但babel可以解決。

function cached (fn) {
    var cache = Object.create(null);
    return (function cachedFn (str) {
      var hit = cache[str];
      return hit || (cache[str] = fn(str))
    })
  }

給變量cache賦值一個空的對象
返回一個cacheFn的函數，將函數的參數的key帶入cache并賦值，返回hit。
如果cache中存在str那么返回hit，反之將其賦值到cache中返回

  var camelizeRE = /-(w)/g;
  var camelize = cached(function (str) {
    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ""; })
  });
    
  var hyphenateRE = /B([A-Z])/g;
  var hyphenate = cached(function (str) {
    return str.replace(hyphenateRE, "-$1").toLowerCase()
  });

注釋寫著將字符串駝峰化
匹配一個-組成單詞的字符
調用前面cached函數,并將字符串replace(egexp/substr,replacement)中做一個判斷
里面的函數 c這個參數理解不清楚。
補充_是占位符，c是組1
思考：.substring(0,1).toUpperCase()不知道是否可以這樣寫。或者直接用字符串型數組？.toUpperCase()

function polyfillBind (fn, ctx) {
    function boundFn (a) {
      var l = arguments.length;
      return l
        ? l > 1
          ? fn.apply(ctx, arguments)
          : fn.call(ctx, a)
        : fn.call(ctx)
    }

    boundFn._length = fn.length;
    return boundFn
}

獲取boundFn中的arguments的長度

if(l){
    if(l>1){
        fn.apply(ctx, arguments)
    }else{
        fn.call(ctx, a)
    }    
 }else{ 
    fn.call(ctx)
}

如果參數不存在，直接綁定作用域調用該函數fn.call(ctx)
如果存在且只有一個，那么調用fn.call(ctx, a), a是入參
如果存在且不止一個，那么調用fn.apply(ctx, arguments)
call與apply的區別，call接受參數是一個一個接收，apply是作為數組來接收。如:

fn.call(this, 1,2,3)
fn.apply(this, [1,2,3])

對于不支持它的環境，使用簡單的綁定polyfill，
例如，Phantomjs 1.x。從技術上講，我們不再需要這個了。
因為在大多數瀏覽器中，本機綁定的性能已經足夠了。
但是刪除它意味著破壞能夠運行的代碼
PhantomJS 1.x，所以為了向后兼容，必須保留它。

function nativeBind (fn, ctx) {
  return fn.bind(ctx)
}
var bind = Function.prototype.bind
    ? nativeBind
    : polyfillBind;

原生的bind。以及判定這個bind是原生的還是polyfill

function toArray (list, start) {
    start = start || 0;
    var i = list.length - start;
    var ret = new Array(i);
    while (i--) {
      ret[i] = list[i + start];
    }
    return ret
}

數據轉換。感覺就是遍歷循環一個個存儲到一個新的ret上。

function extend (to, _from) {
    for (var key in _from) {
      to[key] = _from[key];
    }
    return to
}

檢查有多少個屬性，然后賦值返回到to上

function toObject (arr) {
    var res = {};
    for (var i = 0; i < arr.length; i++) {
      if (arr[i]) {
        extend(res, arr[i]);
      }
    }
    return res
}

定義了一個res對象
遍歷傳遞的arr數組。然后通過上面那個extend函數傳遞到res

function noop (a, b, c) {}

一個空函數？。。。不知道干啥。往下再看看

var no = function (a, b, c) { return false; };

一個no？？綁定了一個函數返回false？再看看

var identity = function (_) { return _; };

一個傳什么返回自己的東西？

function genStaticKeys (modules) {
    return modules.reduce(function (keys, m) {
      return keys.concat(m.staticKeys || [])
    }, []).join(",")
}

從編譯器模塊生成包含靜態鍵的字符串

function looseEqual (a, b) {
    if (a === b) { return true }
    //如果：參數a和參數b恒等于返回true；
    //isObject這個函數已經看到過了，不為空且恒等于object  
    var isObjectA = isObject(a);
    var isObjectB = isObject(b);
    if (isObjectA && isObjectB) {
      //判定a和b是否滿足
      try {
        var isArrayA = Array.isArray(a);
        var isArrayB = Array.isArray(b);
        //a和b是否為一個數組
        if (isArrayA && isArrayB) {
        //如果如果滿足，檢測a是否滿足條件
        //補充every()函數 e是當前元素值，索引
        //array.every(function(currentValue,index,arr), thisValue)
          return a.length === b.length && a.every(function (e, i) {
            return looseEqual(e, b[i])
          })
          
        } else if (a instanceof Date && b instanceof Date) {
          return a.getTime() === b.getTime()
        } else if (!isArrayA && !isArrayB) {
          var keysA = Object.keys(a);
          var keysB = Object.keys(b);
          return keysA.length === keysB.length && keysA.every(function (key) {
            return looseEqual(a[key], b[key])
          })
        } else {
          /* istanbul ignore next */
          return false
        }
      } catch (e) {
        /* istanbul ignore next */
        return false
      }
    } else if (!isObjectA && !isObjectB) {
      return String(a) === String(b)
    } else {
      return false
    }
  }

這一段有點長，我看下注釋打在代碼里.作用判斷兩個值是否相等。結構是否相同

function looseIndexOf (arr, val) {
    for (var i = 0; i < arr.length; i++) {
      if (looseEqual(arr[i], val)) { return i }
    }
    return -1
  }

返回索引，如果沒找到-1，否則用上面的looseEqual()函數

function once (fn) {
    var called = false;
    return function () {
      if (!called) {
        called = true;
        fn.apply(this, arguments);
      }
    }
  }

一個閉包函數，只有在called = false時執行，如果調用過后，返回true。只能用一次。