JavaScript题 - 语言

傷城~ 2021-09-19 23:44 262阅读 0赞

*  数组去重
    
        // 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]
              }
          }复制代码