数组

数组创建方式

//1)字面量(推荐)
var arr = [1,2,3];

//2)使用构造函数创建
var arr = new Array();//创建一个空数组
var arr = new Array('k', 12, true);//创建数组并同时写入数据

数组操作

常用数组方法

push()： 往数组尾部添加一个或多个元素，返回数组新的长度
pop()：删除数组最后一个元素，返回删除的元素

var arr = [1,2,3,4,5,6];
    arr.push(0); //末尾增加数组元素
    console.log(arr);  //1 2 3 4 5 6 0
    arr.pop(); //末尾删除数组元素
    console.log(arr); //1 2 3 4 5 6

unshift()：往数组开头添加一个或多个元素，返回数组新的长度
shift()：删除数组第一个元素，返回删除的元素

var arr = [1,2,3,4,5,6];
	arr.unshift(233，666); //开头添加数组元素
    console.log(arr); //233 666 1 2 3 4 5 6
    arr.shift();
    console.log(arr); //666 1 2 3 4 5 6

splice(start,deleteNum,…items)：在数组中添加、删除、替换的通用方法
start：起始索引位置
deleteNum：要删除的数量
items：插入的元素（可以是多个）

var arr = [1,2,3,4,5,6];
	//删除
    arr.splice(2,2); 
    console.log(arr); // 1 2 5 6
    //添加
    arr.splice(0,0,'kasami','katsuki');
    console.log(arr); //kasami katsuki 1 2 5 6
    //替换，实际上是删除后再添加
    arr.splice(2,4,'amne',true);
    console.log(arr); // kasami katsuki amne true

slice(start[,end])：返回数组的片段或子数组，从start开始到end(不包括end所对应的元素)
如果省略end参数，则截取到数组的最后一项（支持负数即倒数第几位数，-1倒数1位）

var arr = [1,2,3,4,5,6];
var son = arr.slice(1,3);
//slice返回新的数组，截取不影响原数组
console.log(son); // 2 3
console.log(arr); // 1 2 3 4 5 6

sort()：将数组中的元素排序，并返回排序后的数组，详情见下

reverse()：将数组中的元素颠倒顺序，返回逆序后的数组

join(separator) 返回字符串值，其中包含了连接到一起的数组的所有元素
separator为分隔符，默认为逗号

数组排序

冒泡排序（重在过程）

当前元素跟下一个元素对比
把最大的逐个往后排列

选择排序法（重在过程）

把当前元素分别跟后面的元素对比
把最小的逐个往前排列

排序代码推理总结

外层循环控制需要排序的所有数组元素次数
冒泡不需要最后的元素进行比较，次数-1

内层循环控制当前元素需要比较的次数

sort()（重在使用）

将数组中的元素排序，并返回排序后的数组
默认:以字符串的排列方式（转换成ASCII码进行对比）
参数fn（比较函数）：利用fn的返回值来确定数组中两个数的位置（假设两个数为a,b）
返回负数：确定a在b前，[a,b…]
返回0：不改变现有位置
返回正数：确定a在b后面，[b,a…]

var arr = [10,2,8,55,32,18,9,11,30,16,19,20];
		console.log(arr);
		// 回调函数
		arr.sort(function(a,b){
			// if(a>b){
			// 	return 1;
			// }else if(a<b){
			// 	return -1;
			// }else{
			// 	return 0;
			// }
		//对于上面的if判断，可简化为a-b,为小到大排序
			return a-b;
		//大到小 return b-a	
		});
		console.log(arr);//小到大排序打印
		// reverse()：倒序
		arr.reverse();
		console.log(arr);//倒序后为大到小打印

数组复制

引用类型详情查看博文：引用类型与基本类型内存对比
第一种：遍历法

• 创建新数组
• 遍历写入

var arr = ['ka','tsu','ki'];
var copyArr1 = [];  //创建新空数组存储
	for(var i=0;i<arr.length;i++){
			copyArr1[i] = arr[i];
		}
		copyArr1.push('Grisaia');
		console.log('arr:',arr); //ka tsu ki
		console.log('copy:',copyArr1);//ka tsu ki Grisaia

第二种：slice(0)

• 从第一项截取到最后

var arr = ['ka','tsu','ki'];
var copyArr2 = arr.slice(0);
copyArr2.push('666');
console.log('arr:',arr); //ka tsu ki
console.log('copy:',copyArr2); //ka tsu ki 666

多维数组（数组里包含数组）（了解）

var arr = [1,2,'html5',[3,4,'css3'],[5,6,'javascript']]
arr[3][2]; //=>'css3'

ECMAScript5(ES5)Array新增方法

静态方法

Array.isArray() 判断是否为数组，返回true/false

Array.isArray({});// false
Array.isArray(10);// false
Array.isArray([10,2]);//true

索引方法

indexOf/lastIndexOf(keyword [,startIndex])
keyword: 要查找的项，
startIndex：查找起点位置的索引，该参数可选，默认0

方法返回keyword在数组中的索引值，如果数组不存在keyword，则返回-1

indexOf/lastIndexOf的区别就是一个从前往后找，一个从后往前找

var arr = ['ka','tsu','ki'];
arr.indexOf('ka');// 有该元素值返回1
arr.indexOf('yu');// 没有该元素值返回-1
//去重应用
var arr2 = ['ka','tsu','ki','ki'];
var newArr = [];
for(var i=0;i<arr2.length;i++){
	if(newArr.indexOf(arr2[i])===-1){
		newArr.push(arr2[i]);
	}
}
console.log(newArr); // 得到['ka','tsu','ki']

迭代（遍历）方法

forEach(fn) 遍历方法

for循环没有太大差别，比for循环方便

var arr = ['ka','tsu','ki'];
arr.forEach(function(item,index,array){
// 这里的代码：有几个数组元素就跑几遍
 /* item: 数组元素
	index:索引值
	array:数组的引用 */
	console.log(item);	
});

map(fn)

返回一个数量相等的数组，内容是什么取决于在fn中返回的值

var arr1 = [39,14,77,10];
	console.log(arr2);
var res1 = arr1.map(function(item){
	return item*1.2
});
var res2 = arr1.map(function(item){
	return item*2;
});
var res3 = arr1.map(function(item){
	return item+10;
});
	console.log('1.2倍：',res1);
	console.log('2倍：',res2);
	console.log('+10：',res3);
var arr2 = ['ka','tsu','ki'];
var res4 = arr2.map(function(item){
	return '<strong>'+item+'</strong>';
});
	console.log(res4);
	
//使用map输出HTML结构问题
<script>
var showlist = document.getElementById('showlist');
var msglist = ['katsuki','amane','makina'];
//不加.join直接将lis显示到HTML里，会以数组的形式显示，之间会有逗号
var lis = msglist.map(function (msg,ind){
    return '<li><a href="#">' + (ind+1) + '.' + msg + '</a></li>';
}).join('');
showlist.innerHTML = lis;
</script>
<body>
	<ul id="showlist"></ul>
</body>

数组复制第三种：

// 复制数组
var arr = [10,20,30];
var res = arr.map(function(item){
	return item;
});
res.push(40); 
console.log(arr); // 10 20 30
console.log(res); // 10 20 30 40

filter(fn)

得到执行fn后返回true时对应的数组元素，利用这个方法可对数组元素进行过滤筛选

数组复制第四种:

// 返回true时，元素返回，复制数组
var arr = [10,77,39，9];
var res1 = arr.filter(function(item){
	return true;
});
//返回false时，元素不返回，获得空数组
var res2 = arr.filter(function(){
	return false;
});
// 找出所有小于10的数
var res3 = arr.filter(function(item){
	return item<10;
});

some&every

some(fn) 如果该函数中任何一项返回 true，则返回true（相当于 ||）

var arr = [10,77,39，9];
//false true false false => true
//false false false false => false
var res1 = arr.some(function(item){
	return item>75;
});
console.log(res1); // true

every(fn) 如果该函数对每一项都返回 true，则返回true（相当于&&）

var arr = [10,77,39，9];
//true true true true => true
//true true true false => false
var res2 = arr.every(function(item){
	return item>9;
});
console.log(res2); // false
// 应用：判断数组中是否存在某个值
var res3 = arr.some(function(item){
	return item===39;
});

归并方法

迭代数组中的所有项，然后生成一个最终返回值。
reduce(fn, initVal)

第一个参数
fn(prev, cur, index, array): fn是每一项调用的函数，函数接受4个参数分别是
prev：前一次返回值，
cur：当前值，
index：索引值，
array：当前数组， 函数需要返回一个值，这个值会在下一次迭代中作为prev的值

第二个参数
initVal: 迭代初始值（可选），如果缺省，prev的值为数组第一项

// 求和
var arr = [18, 77, 17];
var total = arr.reduce(function(prev,item,idx){
	// prev：前一次fn的返回值
	console.log(prev,item,idx)
	return prev + item
}, 0);