1,javascript获取字符串中出现最多的字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
var str = 'afaafdff';
var obj ={};											//定义一个obj对象
//利用str.charAt(i)进行字符串截取  
for(var i=0;i<str.length;i++){
	if(!obj[str.charAt(i)]){        //判断对象中是否有这个字符
		obj[str.charAt(i)] = 1;				//没有就保存一个
	}else{
		obj[str.charAt(i)]++;					//有的话就加一
	}
}
var time = 0,index = '';
//用打擂算法循环输出obj中保存的数据
for(var i in obj){							 //i都代表着obj对象的键值(也就是字符)				
	if(obj[i]>time){
		time = obj[i];
		index = i;
	}
}
alert('次数'+time +',字符：'+index)

2,javascript去重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
var arr1 = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
// 一、利用ES6 Set去重（ES6中最常用）   不考虑兼容性，这种去重的方法代码最少。这种方法还无法去掉“{}”空对象。
function toHeavy1 (arr) {
  return Array.from(new Set(arr))
}
// 二、利用for嵌套for，然后splice去重（ES5中最常用）   //NaN和{}没有去重，两个null直接消失了

function toHeavy2(arr){
  for(var i=0; i<arr.length; i++){
      for(var j=i+1; j<arr.length; j++){
          if(arr[i]==arr[j]){         //第一个等同于第二个，splice方法删除第二个
              arr.splice(j,1);
              j--;
          }
      }
  }
  return arr;
}
//   三、利用indexOf去重

<!-- more -->

function toHeavy3(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array = [];
    for (var i = 0; i < arr.length; i++) {
        if (array .indexOf(arr[i]) === -1) {
            array .push(arr[i])
        }
    }
    return array;
}
//    四、利用sort()

function toHeavy4(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return;
    }
    arr = arr.sort()
    var arrry= [arr[0]];
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] !== arr[i-1]) {
            arrry.push(arr[i]);
        }
    }
    return arrry;
}
//     五、利用includes

function toHeavy5(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array =[];
    for(var i = 0; i < arr.length; i++) {
        if( !array.includes( arr[i]) ) {//includes 检测数组是否有某个值
            array.push(arr[i]);
        }
    }
    return array
}

// 六、利用hasOwnProperty 所有的都去重了
function toHeavy6(arr) {
    var obj = {};
    return arr.filter(function(item, index, arr){
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
    })
}

// 七、利用filter
function toHeavy7(arr) {
    return arr.filter(function(item, index, arr) {
        //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
        return arr.indexOf(item, 0) === index;
    });
}
// 八、利用递归去重
function toHeavy8(arr) {
    var array= arr,len = array.length;

    array.sort(function(a,b){   //排序后更加方便去重
        return a - b;
    })
    
    function loop(index){
        if(index >= 1){
            if(array[index] === array[index-1]){
                array.splice(index,1);
            }
            loop(index - 1);    //递归loop，然后数组去重
        }
    }
    loop(len-1);
    return array;
}

// 九、利用Map数据结构去重
function toHeavy9(arr) {
    let map = new Map();
    let array = new Array();  // 数组用于返回结果
    for (let i = 0; i < arr.length; i++) {
        if(map .has(arr[i])) {  // 如果有该key值
            map .set(arr[i], true);
        } else {
            map .set(arr[i], false);   // 如果没有该key值
            array .push(arr[i]);
        }
    }
    return array ;
}

// 十、利用reduce+includes
function toHeavy10(arr){
    return arr.reduce((prev,cur) => prev.includes(cur) ? prev : [...prev,cur],[]);
}
// 十一、[...new Set(arr)]
function toHeavy11(arr) {
    return [...new Set(arr)]
}
console.log("y",arr1,1,toHeavy1(arr),2,toHeavy2(arr),3,toHeavy3(arr),4,toHeavy4(arr),5,toHeavy5(arr),6,toHeavy6(arr),7,toHeavy7(arr)
,8,toHeavy8(arr),9,toHeavy9(arr),10,toHeavy10(arr),11,toHeavy11(arr))

未完待续～