数组去重，排序，重复次数，两个数组合并，两个数组去重，map(),filter(),reduce()...

最新推荐文章于 2023-12-09 15:27:44 发布

转载最新推荐文章于 2023-12-09 15:27:44 发布 · 1.5k 阅读

2 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/binmengxue/p/10948685.html

文章标签：

#c# #移动开发 #javascript #ViewUI

博客提及了数组，转载自https://www.cnblogs.com/binmengxue/p/10948685.html ，涉及C#、移动开发、JavaScript等信息技术领域。

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

转载于:https://www.cnblogs.com/binmengxue/p/10948685.html