js 数组常用方法以及常用算法

js 数组常用方法

            // 在数组末尾插入元素
			// arr.push(value)，在数组的末尾添加一个或多个元素，并返回数组的新长度。
			let arr=[1,2,3,4,5]
			arr.push(6)
			console.log(arr); // 1,2,3,4,5,6,7

			// 删除数组末尾的元素
			// arr.pop()删除索引值最大的元素,并返回被删除的元素
			let arr = [1, 2, 3, 4, 5]
			var delElement = arr.pop();
			console.log(arr, delElement); // [1,2,3,4] 5

            // 在数组的头部插入元素
			// unshift(value);在数组的头部添加一个或多个元素,并返回数组的新长度
			let arr = [1, 2, 3, 4, 5]
			var length = arr.unshift(0);
			console.log(arr, length); //arr的值为[0,1,2,3,4,5];length的值为更改后数组的长度6；

            // 删除数组的头部元素
			// shift();删除索引为0的元素，并返回删除的元素
			let arr = [1,2,3,4,5]
			var delElement = arr.shift();
			console.log(arr, delElement); //[2,3,4,5] 1

            // 数组和数组（或元素）的合并
			//concat()合并数组或元素，返回新的数组,原数组不会改变
			let arr = [1, 2, 3, 4, 5]
			let newArr = arr.concat([6, 7, 8], 9, 10); // 可以做深拷贝
			console.log(newArr); // [1,2,3,4,5,6,7,8,9,10]
            //concat()还可以复制一个新数组;
　　        let copyArr=arr.concat();//copyArr的值和arr的相同

            // 	在数组中添加删除或替换元素
            //  在任意位置添加或删除元素,返回删除或被替换的值,如果没有被删除或替换则返回空数组;
			// 　　splice()方法会修改原数组的值;
			// 　　只有一个值时，从当前位置删除到数组末尾
			let arr = [1, 2, 3, 4, 5];
			let num = arr.splice(2); // 这是下标是从1开始
			console.log(num, arr) //num=[3,4,5];arr=[1,2];

            // 有两个值时，第一个值为删除的位置，第二个值为删除的个数;
			let arr = [1, 2, 3, 4, 5]；
			let num1 = arr.splice(2, 3) //删除从索引值2开始的3个元素
			console.log(num1; arr); // num1=[3,4,5],arr=[1,2]

            // 有三个或者多个值时，第一个值为插入元素的位置，第二个值为替换的个数，后面的值都为插入的新元素；
			let arr=[1,2,3,4,5];
			let num2=arr.splice(2,1,6,7,8);//从索引值2开始替换掉1个元素(注:替换的值是3)，并且插入6,7,8
			//如果第二个值为0，则不替换，直接插入6,7,8;
			console.log(num2,arr);//被替换的值num2=[3]; arr=[1,2,6,7,8,4,5]


            // slice(开始位置，结束位置)；第二个参数不写默认到尾部,只能从前往后截取；返回的值为截取到的内容形成的新数组;
			let arr = [1, 2, 3, 4, 5];
			let copyArr = arr.slice(); // slice()或者slice(0)都可以复制数组；
			console.log(copyArr) // [1,2,3,4,5]
			let newArr = copyArr.slice(1,3); //截取索引1到索引3(不包括3)的值;
			console.log(newArr, arr); //newArr=[2,3];arr=[1,2,3,4,5];

js 常用排序算法

            //sort()将数组进行排序(升序),返回新数组，原数组也会改变; 
			let arr = [2, 3, 5, 1, 4];
			let newArr = arr.sort();
			console.log(newArr, arr) //newArr=[1,2,3,4,5]; arr r=[1,2,3,4,5]



            // 冒泡排序
		    var arr = [29,45,51,68,72,97];
		    //外层循环，控制趟数，每一次找到一个最大值
		    for (var i = 0; i < arr.length - 1; i++) {
		        // 内层循环,控制比较的次数，并且判断两个数的大小
		        for (var j = 0; j < arr.length - 1 - i; j++) {
		            // 白话解释：如果前面的数大，放到后面(当然是从小到大的冒泡排序)
		            if (arr[j] > arr[j + 1]) {
		                var temp = arr[j];
		                arr[j] = arr[j + 1];
		                arr[j + 1] = temp;
		            }
		        }
		 
		    }
		    console.log(arr);//[2, 4, 5, 12, 31, 32, 45, 52, 78, 89]



            // 选择排序
            var arr = [8, 94, 15, 88, 55, 76, 21, 39];
			function selectSort(arr) {
				var len = arr.length;
				var minIndex, temp;
				console.time('选择排序耗时');
				for (let i = 0; i < len - 1; i++) {
					minIndex = i;
					for (let j = i + 1; j < len; j++) {
						if (arr[j] < arr[minIndex]) {
							minIndex = j;
						}
					}
					temp = arr[i];
					arr[i] = arr[minIndex];
					arr[minIndex] = temp;
				}
				console.timeEnd('选择排序耗时');
				return arr;
			}
			console.log(selectSort(arr));


                // 快速排序
                var quicksort = function(arr) {
				if (arr.length <= 1) {
					return arr;
				}
				var pivotIndex = Math.floor(arr.length / 2);
				var pivot = arr.splice(pivotIndex, 1)[0];
				var left = [];
				var right = [];
				for (var i = 0; i < arr.length; i++) {
					if (arr[i] < pivot) {
						left.push(arr[i]);
					} else {
						right.push(arr[i]);
					}
				}
				return quicksort(left).concat([pivot], quicksort(right));
			};
			var array = [99, 7, 10, 66, 5, 2, 51,12, 69];
			console.log(quicksort(array)) //[0,1,2,3,5,5,7,7,8]


            /**
			 * 插入排序
			 */
			var arr = [2, 4, 3, 8, 10, 5, 4, 9];
			for (var j = 1, l = arr.length; j < l; j++) {
				var key = arr[j]; //需要插入到前面已经拍好序的数字
				var i = j - 1;
				while (i >= 0 && arr[i] > key) { //从当前下标开始往前比较，如果当前的大于key则往后移动下标，直到找到小于key的项
					arr[i + 1] = arr[i];
					i = i - 1;
				}
				//把key插入当前位置
				arr[i + 1] = key;
			}
			console.info("insert ", key, "后:", arr);//[2, 3, 4, 4, 5, 8, 9, 10]



			//sort() //对象排序
			let arr = [{id:8,name:'小明'},{id:6,name:'小明'},{id:7,name:'小明'}];
			let newArr = arr.sort(function(a,b){
				return a.id - b.id;
			});
			console.log(newArr, arr) //[{id:6,name:'小明'},{id:7,name:'小明'},{id:8,name:'小明'}]

js 常用去重方法

            // 使用 Set 进行去重
            let arr = [2,2,3,4,5];
			console.log([...new Set(arr)]) // [2,3,4,5]

            // 对象去重
           let arr = [{id:2,name:'小米'},{id:2,name:'小米'},{id:3,name:'小米'},{id:5,name:'小米'}];
			function onlyArr(arr,key){
				let newArr = [];
				let obj = {};
				arr.forEach((item) =>{
					if(!obj[item[key]]){
						newArr.push(item);
						obj[item[key]] = true;
					}
				})
				return newArr;
			}
			console.log(onlyArr(arr,'id'))

js 洗牌算法

			//利用Array的sort方法可以更简洁的实现打乱，对于数量小的数组来说足够。因为随着数组元素增加，随机性会变差。
			let arr = [1,2,3,4,5,6];
			arr.sort(function(){
			    return .5 - Math.random();
			})
			console.log(arr)

            // 通用于 数组 或 对象 乱序
            let arr = [2,3,4,5,6,7,8,9];
			let newArr = [];
			while(arr.length > 0){
				let random = Math.floor(Math.random() * arr.length);
				newArr.push(arr[random]);
				arr.splice(random,1);
			}
			console.log(newArr)

js 数组分组

            let data = [
						{"name": "John", "Average": 15, "High": 10, "DtmStamp": 1358226000000},
						{"name": "Jane", "Average": 16, "High": 92, "DtmStamp": 1358226000000},
						{"name": "Jane", "Average": 17, "High": 45, "DtmStamp": 1358226000000},
						{"name": "John", "Average": 18, "High": 87, "DtmStamp": 1358226000000},
						{"name": "Jane", "Average": 15, "High": 10, "DtmStamp": 1358226060000},
						{"name": "John", "Average": 16, "High": 87, "DtmStamp": 1358226060000},
						{"name": "John", "Average": 17, "High": 45, "DtmStamp": 1358226060000},
						{"name": "Jane", "Average": 18, "High": 92, "DtmStamp": 1358226060000},
						{"name": "AAAA", "Average": 18, "High": 92, "DtmStamp": 1358226060000},
			        ];
			//data是要被分组的数据[]，key是分组依据的关键字
			let getGroup = (data, key) => {
				let groups = {};
				data.forEach(c => {
					let value = c[key];
					groups[value] = groups[value] || [];
					groups[value].push(c);
				});
				return Object.keys(groups).map(item =>{
					return groups[item]
				})
			}
			console.log(getGroup(data, 'name'))