数组去重，排序，重复次数，两个数组合并，两个数组去重，map(),filter(),reduce()
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
</body>
</html>
<script>
//数组，冒泡排序，把数组从小到大排序
function bubbleSort(array) {
if(Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
var len = array.length,
temp;
for(var i = 0; i < len - 1; i++) {
for(var j = len - 1; j >= i; j--) {
if(array[j] < array[j - 1]) {
temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
}
return array;
} else {
return 'array is not an Array!';
}
};
var arr = [23, 34, 3, 4, 23, 44, 333, 444];
console.log(bubbleSort(arr));
//数组，去重
function unique(arr) {
var hash = [];
for(var i = 0; i < arr.length; i++) {
if(hash.indexOf(arr[i]) == -1) {
hash.push(arr[i]);
}
}
return hash;
};
var arr2 = [2, 8, 5, 0, 5, 2, 6, 7, 2];
console.log(unique(arr2));
//数组，数组中出现最多的元素和最多元素的次数，第二多元素和第二多元素的次数
function aryMore(arr) {
var i;
var length = arr.length;
var hash = []; //使用哈希数组
for(i = 0; i < length; i++) {
if(!hash[arr[i]]) hash[arr[i]] = 1; //没有初始化的数组元素为undefined，undefined++为NaN
else hash[arr[i]]++;
}
var max = 0; //最多的次数
var maxV; //出现最多的元素
var second = 0; //第二多的次数
var secondV; //出现第二多的元素
hash.forEach(function(item, index) { //forEach函数会跳过空元素
if(item > max) {
second = max;
secondV = maxV;
max = item;
maxV = index; //用索引来保存原数组的值
} else if(item > second) {
second = item;
secondV = index;
}
});
return {
max,
maxV,
second,
secondV
};
}
var arr3 = [2, 2, 2, 2, 3, 4, 5, 4, 3, 1, 4, 4, 100, 100];
console.log(aryMore(arr3));
//两个数组对比，取出不同的值
function getArrDifference(arr1, arr2) {
return arr1.concat(arr2).filter(function(v, i, arr) {
return arr.indexOf(v) === arr.lastIndexOf(v);
});
};
var arr4 = [0, 1, 2, 3, 4, 5];
var arr6 = [0, 44, 6, 1, 3, 9];
console.log(getArrDifference(arr4, arr6));
//两个数组对比，取出相同的值
function getArrEqual(arr1, arr2) {
let newArr = [];
for(let i = 0; i < arr2.length; i++) {
for(let j = 0; j < arr1.length; j++) {
if(arr1[j] === arr2[i]) {
newArr.push(arr1[j]);
}
}
}
return newArr;
}
var arr7 = [0, 1, 2, 3, 4, 5];
var arr8 = [0, 4, 6, 1, 33, 9];
console.log(getArrEqual(arr7, arr8));
//两个数组，把数组合并，去除相同的值
//合并两个数组，去重
function concatAry(arr1, arr2) {
//不要直接使用var arr = arr1，这样arr只是arr1的一个引用，两者的修改会互相影响
var arr = arr1.concat();
//或者使用slice()复制，var arr = arr1.slice(0)
for(var i = 0; i < arr2.length; i++) {
arr.indexOf(arr2[i]) === -1 ? arr.push(arr2[i]) : 0;
}
return arr;
};
var arr9 = [0, 1, 2, 3, 4, 5];
var arr10 = [0, 4, 6, 1, 3, 9];
console.log(concatAry(arr9, arr10));
//合并多个数组，去重
function concatAryMore(arr1, arr2, arr3) {
if(arguments.length <= 1) {
return false;
}
var concat_ = function(arr1, arr2) {
var arr = arr1.concat();
for(var i = 0; i < arr2.length; i++) {
arr.indexOf(arr2[i]) === -1 ? arr.push(arr2[i]) : 0;
}
return arr;
}
var result = concat_(arr1, arr2);
for(var i = 2; i < arguments.length; i++) {
result = concat_(result, arguments[i]);
}
return result;
};
var arrMore1 = ['a', 'b'];
var arrMore2 = ['a', 'c', 'd'];
var arrMore3 = [1, 'd', undefined, true, null];
console.log(concatAryMore(arrMore1, arrMore2, arrMore3));
</script>
数组
//数组map使用
//map() 方法会创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果
//例子一
const numbers = [1, 2, 3, 4]
const numbersPlusOne = numbers.map(n => n + 1);
console.log(numbersPlusOne);
//例子二
const allBlogs = [{
title: 'CSS',
tags: ['CSS', 'Web']
}, {
title: 'JavaScript',
tags: ['JavaScript', 'Web', 'ES6']
}]
const allTitles = allBlogs.map(blog => blog.tags)
console.log(allTitles)
//数组filter使用
//filter（）当你想过滤一个数组时可以使用filter。就像map一样，它接受一个函数作为唯一的参数，该参数在数组的每个元素上调用。这个函数需要返回一个布尔值
//例子一
const numbers2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const oddNumbers = numbers2.filter(n => n % 2 !== 0)
console.log(oddNumbers);
//例子二
const participants = [{
id: 'a3f47',
username: 'john'
}, {
id: 'fek28',
username: 'mary'
}, {
id: 'n3j44',
username: 'sam'
}]
function removeParticipant(participants, id) {
return participants.filter(participant => participant.id !== id)
}
console.log(removeParticipant(participants, 'a3f47'))
//数组reduce使用
//reduce是数组提供的方法中最难理解的方法，但一旦掌握了该方法，可以做的事情就很多。reduce会取一个数组中的值并将它们合成一个值。它接受两个参数，一个回调函数（reducer函数）和一个可选的初始值（默认情况是数组的第一项）。reducer本身有四个参数：
//累计器：它在reducer中累加返回值
//数组的当前值
//当前索引值
//源数组
var result = [{
subject: 'math',
score: 88
},
{
subject: 'chinese',
score: 95
},
{
subject: 'english',
score: 80
}
];
var dis = {
math: 0.5,
chinese: 0.3,
english: 0.2
}
var sum = result.reduce(function(prev, cur) {
return cur.score + prev;
}, -10);
var qsum = result.reduce(function(prev, cur) {
return cur.score * dis[cur.subject] + prev;
}, -10)
console.log(sum, qsum);
记下点滴，等老了慢慢欣赏
