• 数组去重

  // 1 - 遍历目标数组，将结果数组中尚无的项推入
  function uniq(arr) {
      let r = [];
      for (let item of arr) {
        if (r.indexOf(item) === -1) {
          r.push(item);
        }
      }
      return r
  }
  
  // 2 - ES6集合
  function uniq(arr) {
      return arr.from(new Set(arr))
      或
      return [...new Set(arr)]
  }
  
  // 3 - 推入第一项至结果数组；排序目标数组后从第二项开始遍历，只把不与结果数组的前一项相同的项推入之（问题：被排序了）
  function uniq(arr) {
      arr.sort()
      var r = [arr[0]]
      for (var i = 1; i < arr.length; i++) {
          if (arr[i] !== r[r.length - 1]) {
              r.push(arr[i])
          }
      }
      return r
  }
  
  // 4 - 推入第一项至结果数组；从第二项开始遍历目标数组，如果某项的值的indexOf不等于该项的下标，说明是重复项
  function uniq(arr) {
      var r = [arr[0]]
      for (var i = 1; i < arr.length; i++) {
          if (arr.indexOf(arr[i]) === i) {
              r.push(arr[i])
          }
      }
      return r
  }
  
  // 5 - 新建一个对象，遍历目标数组，若对象中尚无与某项的值同名的键，说明是第一次出现。添加该键，值为1，把该项推入结果数组
  function uniq(arr) {
      var o = {}
      var r = []
      arr.forEach(function(item, index) {
          if (!o[item]) {
              o[item] = 1
              r.push(item)
          }
      })
      return r
  }
  

• 深度克隆函数

  // 1 - 正常思路，递归
  function clone(tar) {
      var r
      if (typeof tar === 'object') {
          r = {}
          for (var i in tar) {
              r[i] = clone(tar[i])
          }
      } else {
          r = tar
      }
      return r
  }
  
  // 2 - 函数被忽略，无法复制；原型链没了，对象就是object，所属的类没了。
  function clone(tar) {
      return JSON.parse(JSON.stringify(tar));
  }
  

• 函数继承

  var Fn1 = function(a) {
      this.a = a
  }
  Fn1.prototype.foo = 'foo'
  Fn1.prototype.bar = 'bar'
  
  // 1 es6
  class Fn2 extends Fn1 {
      constructor(a) {
          super(a)
      }
  }
  
  // 2 继承了但无原型链关系
  var Fn2 = function() {
      Fn1.apply(this, Array.prototype.slice.call(arguments, 0))
  }
  Fn2.prototype = new Fn1()
  Fn2.prototype.constructor = Fn2
  

• 低版本浏览器的bind polyfill

    Function.prototype.bind = function(thisArg) {
        var that = this
        var args = arguments
        return function() {
            that.apply(thisArg, Array.prototype.slice.call(args, 1))
        }
    }

• 正则和模板

  // 实现以下方法:
  tpl( '<div class="{% className %}">{% name %}</div>', {name: 123, className: "hd"})
  // <div class="hd">123</div>
  

  function tpl(template, data) {
      return template.replace(/{%\s*(\w+)\s*%}/g, function(all, captured) {
          return data[captured]
      })
  }
  

• 中横线字符串转为驼峰式（如 abc-de-fg 转为 abcDeFg）

  // 1 - 重点是 replace(a1, a2) 的a1是整个匹配，a2是捕获组
  function t1(str) {
      return str.replace(/\-(\w)/g, function(all, letter) {
          return letter.toUpperCase()
      })
  }
  
  // 2 - 拆分、拼接数组
  function t2(str) {
      let arr = str.split('-')
      let r = ''
      arr.forEach(function(item, i) {
          let p =
              i === 0
              ? item
              : item.replace(item[0], function(s) {
                  return s.toUpperCase()
              })
          r += p
      })
      return r
  }
  
  // 3 - charAt和substring拼接
  function t3(str){
      var strArr = str.split('-');
      for (var i = 1; i < strArr.length; i++) {
          strArr[i] = strArr[i].charAt(0).toUpperCase() + strArr[i].substring(1);
      }
      return strArr.join('');
  }
  

• 阶乘

  function j(num) {
      if (num === 1 || num ===0) {
          return num * 1
      } else {
          return num * j(num - 1)
      }
  }
  

• 删除对象上的原型属性

  var obj = {a:1, b:2, c:3}
  Object.prototype.d = 4
  for (var i in obj) {
      if (!obj.hasOwnProperty(i)) {
          delete Object.prototype[i]
      }
  }