js之每日一题

发表于


基本类型

对String做扩展，实现如下方式获取字符串中频率最高的字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次
String.prototype.getMostOften=function(){
  var obj={};
  for(var i=0;i<this.length;i++){
    if(obj[this[i]]) {
      obj[this[i]]++;
    }
    else obj[this[i]]=1;
  }
  var num=0; str1='';
  for(var key in obj){
    if(obj[key]>num) {
      num=obj[key]; str1=key;
    }
  }
  return str1;
}
实现一个函数，将浮点数左边的数每三位添加一个逗号

ex:commafy(12000000.11)=>12,000,000.11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function commafy(num){
  var integer=parseInt(num)
  var float=num.toString().match(/\.\d*/g).join("")
  var str=integer.toString()
  var yuShu=str.length%3
  var result=""
  if(str.length/3<=1){
    return result+=num
  }
  if(yuShu>0){
    result+=str.slice(0,yuShu)+','
    str=str.slice(yuShu)
  }
  for(var i=0;i<Math.floor(str.length/3);i++){
    result+=str.slice(i*3,i*3+3)
    if(i==Math.floor(str.length/3)-1){
      result+=float
    }
    else {
      result+=','
    }
  }
  return result
}

数组

实现一个invoke函数，invoke(list, methodName, *arguments)

在list的每个元素上执行methodName方法。 任何传递给invoke的额外参数，invoke都会在调用methodName方法的时候传递给它。
Ex：invoke([[5,1,7],[3,2,1]],’sort’); =>[[1,5,7],[1,2,3]]

1
2
3
4
5
6
7
8
9
10
11
function isFun(obj){
  return typeof obj=='function'
}
function invoke(list,method){
  var args=Array.prototype.slice.call(arguments,2)
  var isFunc=isFun(method)
  return list.map(function(value){
    var func=isFunc?method:value[method]
    return func==null?func:func.apply(value,args)
  })
}

有两个从小到大已经排序完成的数组，长度分别是n和m，单个数组的不存在重复元素，问如何在m+n次操作下，完成去重，得到一个完整的非重数组。

ex:var arr1=[1,2,5,10,12,15], arr2=[2,3,4,6,8,20,22,24,26]
distinctArr(arr1,arr2)=>[1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 22, 24, 26]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function distinctArr(arr1,arr2){
  var arr3=[];
  for(var i=0,j=0;;i++){
    if(i==arr1.length&&j!=arr2.length){
      arr3=arr3.concat(arr2.slice(j))
      break
    }
    else if(i!=arr1.length&&j==arr2.length){
      arr3=arr3.concat(arr1.slice(i))
      break
    }
    if(arr1[i]<arr2[j]){
      arr3.push(arr1[i]);continue;
    }
    else if(arr1[i]==arr2[j]){
      arr3.push(arr1[i]);j++;continue;
    }
    else if(arr1[i]>arr2[j]){
      arr3.push(arr2[j]);j++;--i;continue;
    }
  }
  return arr3;
}

实现一个函数，能够枚举出数组中元素的所有可能的组合。(170919)

ex:[1,2,3]=>”排列组合的结果：”[1, 2, 3]
“排列组合的结果：”[1, 3, 2]
“排列组合的结果：”[2, 1, 3]
“排列组合的结果：”[2, 3, 1]
“排列组合的结果：”[3, 1, 2]
“排列组合的结果：”[3, 2, 1]

1
2
3
4
5
6
7
8
9
10
11
function arrange(result,arr,deep){
  for(var i=0;i<arr.length;i++){
    result[deep]=arr[i]
    arrange(result,arr.filter(function(item,index){return index!==i}),deep+1)
  }
  if(arr.length==0){
    console.log('排列组合的结果：',result)
    return
  }
}
arrange([],[1,2,3],0)

Function

实现一个create函数,效果如下(170914)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var observable=create(function(obs){
  obs.next(1)
  obs.complete()
  obs.next('still work')
})
var observer={
  next:function(value){
    console.log(value)
  },
  complete:function(){
    console.log('completed')
  }
}
observable.subscribe(observer)
//1
//"completed"
//"still work"
1
2
3
4
5
6
7
8
//create函数
function create(fn){
  return {
    subscribe:function(obj){
      fn(obj)
    }
  }
}
使用 localStorage封装一个 Storage 对象，达到如下效果：

ex:Storage.set(“name”,’Ethan6’,1);Storage.get(“name”)=>”Ethan”
如何不超过1s, 返回字符串Ethan6，超过1s,返回undefined,并且localStorage清楚name字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var Storage=(function(){
  return{
    set:function(key,value,seconds){
      localStorage[key]=JSON.stringify({
        value:value,
        second:seconds?Date.now()+1000*seconds:undefined
      })
    },
    get:function(key){
      if(localStorage[key]===undefined){
        return
      }
      var obj=JSON.parse(localStorage[key])
      if(obj.second&&Date.now()<obj.second){
        return obj.value
      }
      else{
        delete localStorage[key]
      }
    }
  }
})()