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
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去重

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))

未完待续~