了解Vue

（1）_toString

function _toString (val) {
  return val == null
    ? ''
    : typeof val === 'object'
      ? JSON.stringify(val, null, 2)
      : String(val)
}

这个函数还是比较好理解的，如果传入的值为空，则返回空字符串；否则，如果传入的是对象，则将其变为 JSON 的数据格式（强调：JSON 是字符串！）；否则以字符串的形式输出。

这里面，我们需要学习的是 JSON.stringify(val, null, 2) 这个方法，其中的 2 表示缩进为 2 个空格，其中的第二个 null 参数表示序列化，如果为 null 则表示所有属性都被序列化。
（2） toNumber

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

该函数表示将传入的值转化为数值，如果传入的不是数字，则返回这个值。这里面，我们需要了解到 parseFloat 这个函数，返回它遇到的第一个不是数字的前面的所有数字。

比如说：parseFloat('123ab')，返回的是 123；parseFloat('ab123') 则返回 NaN 。

所以，这也是为什么这里使用了 isNaN() 这个函数。当然，在 ES6 的规范中，建议还是使用 Number.isNaN() 和 Number.parseFloat() 更好。
（3）makeMap

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]; }
}
// 检查 tag 标签是否为内置的标签
var isBuiltInTag = makeMap('slot,component', true);

关于这个函数，官方的说法是：创建一个 map 并返回一个函数以确定是否该键存在于这个 map 中。至少目前，我们看不出它的作用来，后面用到了再说吧。

其中我们需要学习到 Object.create() 这个方法是干什么的，它和 new Object() 有什么区别。Object.create() 这个方法的用处就是创建一个对象，它可以继承指定的原型。比如说，我有一个对象：

Object.create(null, {
   a: {
     value: 1
   }
 }

它等价于：

const obj = {
  a: 1
}

记住，这是错误的！因为我们这里设置的第一个参数为 null，那么这个对象是没有原型的！也就是说，它没有对象原型上的方法。如果要等价的话，那么我们的参数要设置为 {}。

Object.create({}, {
   a: {
     value: 1
   }
 }

这样，才是等价的。

在这里，设置为 null 的意思就是说，创建一个没有原型的对象。
（4）remove$1

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

这个函数的意思是，从数组中移除掉一个值。这个函数很典型。首先，如果它是一个数组，那么则找到想要的这个值第一次出现时的索引值；如果数组中存在这个值，那么就使用 splice() 这个方法将其移除并返回。

我们来测试一下这个方法：

remove$1([1, 2, 3], 2)
// 返回 [2]，原数组变为[1, 3]
remove$1([1, 2, 3, 2], 2)
// 返回 [2]，原数组变为[1, 3, 2]

这个函数我们平时也是可以用到的，但是这个函数呢，只能返回第一个被查询到的值。这是 indexOf() 这个函数的局限性，记住这一点。
（5）hasOwnProperty

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

这个函数的作用是检查该属性是否是这个对象所拥有的。说的更加直白一点就是，对象是否有这个键（key），我们来测试一下：

const obj = {
   a: 1,
   b: 2
 };
 console.log(hasOwn(obj, 'c'));  // false
 console.log(hasOwn(obj, 'a'));  // true

这个 obj 中是没有 c 这个键的。这个是被封装起来的函数，平时如果单独使用的话，则可以直接调用 Object.prototype.hasOwnProperty() 这个方法的。
（6）isPrimitive

function isPrimitive (value) {
  return typeof value === 'string' || typeof value === 'number'
}

该函数是判断该值是否为原始值。

原始值有六种类型，分别为 String、Number、Boolean、Symbol、Null 和 Undefined。

当然这里只判断了该值是字符串还是数值类型。
（7）cached

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

这个方法的作用是创建一个纯函数的缓存版本。单独看，肯定是看不懂这个函数想表达一个什么意思。来，我们接着往下看：

（1）驼峰化以连字符分隔的字符串。

var camelizeRE = /-(\w)/g;
var camelize = cached(function (str) {
  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
});

（2）大写字符串。

var capitalize = cached(function (str) {
  return str.charAt(0).toUpperCase() + str.slice(1)
});

（3）连接驼峰命名的字符串。

var hyphenateRE = /([^-])([A-Z])/g;
var hyphenate = cached(function (str) {
  return str
    .replace(hyphenateRE, '$1-$2')
    .replace(hyphenateRE, '$1-$2')
    .toLowerCase()
});

我们先不看上面三个代码，我们先来试着理解 cache() 这个函数。这个函数是干什么的？在 JavaScript 中，有一个很经典的函数写法叫做 “缓存策略”，它是用来加速我们的数据的读取速度的。

它的实现原理：创建一个对象，将我们所写的东西保存到这个对象中，如果说我们后面再次用到了这个东西，那么 JavaScript 就不需要再计算一遍了，直接将这个对象中我们需要的东西提取出来就好了。

这是提高执行速度的一种十分有效的办法，可以作为了解，很多的库都会用到它。
（8）bind$1

function bind$1 (fn, ctx) {
  function boundFn (a) {
    var l = arguments.length;
    return l
      ? l > 1
        ? fn.apply(ctx, arguments)
        : fn.call(ctx, a)
      : fn.call(ctx)
  }
  // 记录原始的 fn 长度
  boundFn._length = fn.length;
  return boundFn
}

该函数的作用与原生的 bind() 方法一致，但官方说，这个函数比原生要快。其中的 ctx 参数的意思是 context，即上下文。其实也就是我们常使用的 this 指定的上下文环境。
（9）toArray

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
}

该方法将一个类数组对象转换成真正的数组对象。其中的 list 表示类数组对象，而 start 表示起始的索引值。当然，我们的 ES6 中的 Array.from() 也可以转换，可是它不能指定起始的位置。

我们来测试一下：

console.log(toArray({
   0: 'a',
   1: 'b',
   2: 'c',
   length: 3
}, 1));
// ["b", "c"]

当然了，其实我们使用 ES6 同样可以达到这个效果。我来写一个能达到同样效果的函数吧：

function toArray(list, start = 0) {
   const realArray = Array.from(list);
   return realArray.slice(start);
}

不仅如此，我还可以设置结束的位置：

function toArray(list, start = 0, end = list.length) {
  const realArray = Array.from(list);
  return realArray.slice(start, end);
}

好了，这个函数就到此结束啦。
（10）extend

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

该函数的作用是：将属性混合到目标对象中。说的直白一点就是拷贝对象的属性。

比如我这里有一个空对象，还有另一个对象，将另一个对象中的属性拷贝到这个空对象中去：

const a = {};
const b = {
  a: 1,
  b: 2
 };
extend(a, b);
console.log(a);  // {a: 1, b: 2}