目录
一.JS中判断字符串中出现次数最多的字符及出现的次数
二.JS数组去重
三.类的继承
四.排序算法
一.JS中判断字符串中出现次数最多的字符及出现的次数
<script type="text/javascript">
var str = 'qwertyuilo.,mnbvcsarrrrrrrrtyuiop;l,mhgfdqrtyuio;.cvxsrtyiuo';
var json = {};
//遍历str拆解其中的每一个字符将其某个字符的值及出现的个数拿出来作为json的kv
for (var i = 0; i < str.length; i++) {
//判断json中是否有当前str的值
if (!json[str.charAt(i)]) {
//如果不存在 就将当前值添加到json中去
json[str.charAt(i)] = 1;
} else {
//else的话就让数组中已有的当前值的index值++；
json[str.charAt(i)]++;
}
}
//存储出现次数最多的值和次数
var number = '';
var num=0;
//遍历json 使用打擂算法统计需要的值
for (var i in json) {
//如果当前项大于下一项
if (json[i]>num) {
//就让当前值更改为出现最多次数的值
num = json[i];
number = i;
}
}
//最终打印出现最多的值以及出现的次数
alert('出现最多的值是'+number+'出现次数为'+num);
</script>
二.JS数组去重
方法1：简单粗暴的ES6方法Set，Set数据结构，它类似于数组，其成员的值都是唯一的。
Set对象用于存储唯一值，无论是值类型还是引用类型。但是使用new Set后将返回Set实例，而Set本身只是一个集合类的对象，并非数组，所以如果使用此方法去重后没办法继续使用数组本身的方法，如map, reduce, filter, indexOf等，因此，建议在使用new Set去重后将其转化为数组。
var arr = [1, 2, 3, 2, 1, 3];
console.log(Array.from(new Set(arr)))//打印结果：Set(3) {1, 2, 3}
[...(new Set([1, 2, 3, 1, 2, 3, 4, 6]))]
var arr = [];
(new Set([1, 2, 3, 1, 2, 3, 4, 6])).forEach(v => { arr.push(v) })
方法2：使用filter过滤函数去重。
var arr = [1, 2, 3, 2, 1, 3];
console.log(arr.filter((v, i, arr) => arr.indexOf(v) === i))//打印结果：(3) [1, 2, 3]
方法3：遍历数组法。
实现的思路：新建一个数组，遍历传入的数组，值不在新数组中就加入到该新数组；
注意：判断值是否在数组中可以用indexOf是ES5 方法，IE9以下不支持，需兼容低版本浏览器。
function unique(array) {
var n = []; //一个新的临时数组
//遍历当前数组
for (var i = 0; i < array.length; i++) {
if (n.indexOf(array[i]) == -1) n.push(array[i]);
//如果当前数组的第i已经保存进了临时数组，那么跳过，
//否则把当前项push到临时数组里面
}
return n;
}
console.log(unique([1, 2, 3, 1, 2, 3])) //打印结果：(3) [1, 2, 3]
解决indexOf的兼容方法：
原生JS兼容：
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function (el) {
for (var i = 0, n = this.length; i < n; i++) {
if (this[i] === el) {
return i;
}
}
return -1;
}
}
用Jquery中inArray方法兼容：
if ($.inArray(randIndex, appearAnimals) == -1) {}
方法4：利用splice()方法直接在原数组进行操作。
双层循环，外层循环元素，内层循环时比较值。
值相同时，则删去这个值。
注意:删除元素之后，需要将数组的长度也减1。
优点：简单易懂。
缺点：占用内存高，速度慢。
Array.prototype.unique = function () {
var arr = this,
i,
j,
len = arr.length;
for (i = 0; i < len; i++) {
for (j = i + 1; j < len; j++) {
if (arr[i] == arr[j]) {
arr.splice(j, 1);
len--;
j--;
}
}
}
return arr;
};
var a = [1, 2, 3, 1, 2, 3];
var b = a.unique();
console.log(b); //打印结果：(3) [1, 2, 3]
方法5：利用对象的属性不能相同的特点进行去重
Array.prototype.unique = function () {
var arr = this,
i,
obj = {},
result = [],
len = arr.length;
for (i = 0; i < arr.length; i++) {
if (!obj[arr[i]]) { //如果能查找到，证明数组元素重复了
obj[arr[i]] = 1;
result.push(arr[i]);
}
}
return result;
};
var a = [1, 2, 3, 1, 2, 3];
var b = a.unique();
console.log(b); //打印结果：(3) [1, 2, 3]
方法6：数组递归去重
Array.prototype.unique = function () {
var arr = this,
len = arr.length;
arr.sort(function (a, b) { //对数组进行排序才能方便比较
return a - b;
})
function loop(index) {
if (index >= 1) {
if (arr[index] === arr[index - 1]) {
arr.splice(index, 1);
}
loop(index - 1); //递归loop函数进行去重
}
}
loop(len - 1);
return arr;
};
var a = [1, 2, 3, 1, 2, 3];
var b = a.unique();
console.log(b); //打印结果：(3) [1, 2, 3]
待续。。。
