数组的一些方法

数组的各种方法

1. 元素的添加

这两个方法会在原始数组上进行修改
push()，在数组末尾添加一个或多个元素，返回新数组的长度
unshif()，在数组的开头添加添加一个或多个元素，返回新数组的长度

var arr = ['a', 'b', 'c', 'd'];
arr[4] = 'five';		
arr.push('one');	
arr.push('two1', 'two2');
arr.unshift('first');	
arr.unshift('first1', 'first2');	

2. 元素的删除

原始数组上进行修改
pop() 删除数组最后一个元素，并返回删除的元素
shift() 删除第一个元素，并返回删除的元素

var arr = ['a', 'b', 'c', 'd'];
delete arr[2]; 	
arr.pop();	
arr.shift();	
delete arr[0];
//区别：
//delete执行完毕返回true或false，只删除元素值不会改变数组长度；
//pop()/shift()执行完毕返回删除的数组元素，改变数组长度

3. 查找元素

indexOf() 查找传进来的参数在目标数组中是否存在。如果目标数组包含该参数，就返回该元素在数组中的索引；如果不包含，就返回 -1

注意：如果数组中包含多个相同的元素，indexOf()函数总是返回第一个与参数相同的元素的索引

var names = ["a", "b", "c", "d", "e"]; 
var position = names.indexOf('a');

lastIndexOf() 该函数返回相同元素中最后一个元素的索引，如果没找到相同元素，则返回 -1

var num= ["1", "2", "3", "4", "5", "6", "7"]; 
var num= "3"; 
var lastPos = nums.lastIndexOf(num); 

4. 数组和字符串的转换

join()和toString() 这两个方法都返回一个包含数组所有元素的字符串，各元素之间用逗号分隔开

var names = ["David", "Cynthia", "Raymond", "Clayton", "Mike", "Jennifer"]; 
var namestr = names.join('-'); 
console.log(namestr);
namestr = names.toString(); 
console.log(namestr);

调用字符串对象的split(‘分隔符’) 方法也可以生成数组。

该方法通过一些常见的分隔符，比如分隔单词的空格，将一个字符串分成几部分，并将每部分作为一个元素保存于一个新建的数组中

var sentence = "this is a box"; 
//传参空格，通过空格将字符串分离成数组[]
var words = sentence.split(" "); 		
for (var i = 0; i < words.length; ++i) {   
     console.log("word " + i + ": " + words[i]);
}

5. 数组的拼接和截取

concat() 和 splice() 方法允许通过已有数组创建新数组,方法执行完毕后，原数组不变

var cisDept = ["Mike", "Clayton", "Terrill"]; 
var dmpDept = ["Raymond", "Cynthia"]; 

var itDiv = cisDept.concat(dmpDept); 
console.log(itDiv); 
console.log(cisDept);

itDiv = dmpDept.concat(cisDept);
console.log(itDiv);

arr.splice(index,length) 方法截取一个数组的子集创建一个新数组

//splice(index,length) ,其中index代表截取的起始索引，length代表
var itDiv = ["Mike","Clayton","Terrill","Raymond","Cynthia","Danny","Jennifer"]; 
var dmpDept = itDiv.splice(3,3); 
var cisDept = itDiv; 
console.log(dmpDept); 
console.log(cisDept);

6. 排序函数

reverse()，将数组中元素的顺序进行翻转

var nums = [1,5,3,2,4];
nums.reverse(); 
console.log(nums);

sort()，对字符串进行排序，字母按顺序排序（大写字母均比小写字母小）

var names =['Ana', 'ana', 'john', 'John'];
console.log(names.sort());

var nums = [3,1,2,100,4,200]; 
nums.sort(); 
console.log(nums);

sort方法接受compareFunction作为参数，然后sort会用它排序数组，使数组按升序排序,想得到顺序排列的数字数组，需要自定义方法

var nums = [3,1,2,100,4,200]; 
function compare(a, b) {
	if (a < b) {
		return -1;
	}
	if (a > b) {
		return 1;
	}
	// a必须等于b
	return 0;
}
nums.sort(compare);

要得到字符串忽略大小写的比较数组，自定义方法

var names = ['Ana', 'ana', 'john', 'John']; 
names.sort(function(a, b){
	if (a.toLowerCase() < b.toLowerCase()){
		return -1
	}
	if (a.toLowerCase() > b.toLowerCase()){
		return 1
	}
	return 0;
});		

8. 迭代器方法

不生成新数组的迭代器方法
forEach() ：对数组中的每一项运行给定函数，没有返回值，它和使用for循环的结果相同

//item 指代元素值，index 指代元素索引，array 指代数组本身，形参位置固定
function square(num) {
    console.log(num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);			

var data=[1,2,3];
data.forEach(function(item,index,array){
    console.log(item*item);
    console.log(array.concat(array));
})

every()：对数组中的每一项运行给定函数，如果该函数对每一个项都返回true,则返回true； 反之，有一个值是false就返回false（默认返回false）

//也可参照上面匿名函数的例子，给every接收的函数传参(item,index,array)
function isEven(num) {
        return num % 2 == 0;
}
var nums = [2,3,4,6,8,10];
var even = nums.every(isEven);		//every
console.log(even);//

some()：对数组中的每一项运行给定函数，如果该函数对任一一项返回true，则返回true（默认返回false）

//也可参照匿名函数的例子，给every函数传参(item,index,array)
function isEven(num) {
    return num % 2 == 0;
}

var nums = [1,3,,,10,];
var someEven = nums.some(isEven);		//some
console.log(someEven);

生成新数组的迭代器方法
map()：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组

function curve(grade) {
    return grade += 5;
}
var grades = [77, 65, 81, 92, 83];

var newgrades = grades.map(curve);		//map
console.log(newgrades);

var data=[1,2,3];
var result4=data.map(function(item,index,array){
	return item*2;
})
console.log(result4);   

filter()：传入一个返回值为布尔类型的函数

和every()方法不同的是， 当对数组中的所有元素应用该函数，结果均为 true 时，该方法并不返回true，而是返回一个新数组，该数组包含应用该函数后结果为 true 的元素。

 function isEven(num) {
    return num % 2 == 0;
}

var nums = [];
for (var i = 0; i < 20; ++i) {
    nums[i] = i+1;
}

var evens = nums.filter(isEven);		//filter
console.log(evens);

数组类型判断

Array.isArray(arr)：判断是否是数组；

var a = [1,2,23,34,5,6,78,98, 23,900];
	//数组是特殊的对象类型
    console.log(typeof a);		//object

    console.log(Array.isArray(a)); //true
	console.log(a instanceof Array);	//true

	var b = {x:1, y:2};
	console.log(Array.isArray(b));	//false

类数组

通过对比数组、对象，我们发现完全可以使用对象来模拟数组
只要我们定义的对象的每个元素的键名都使用数字并且让其保持递增，且动态的定义一个length属性来表示元素个数，那么从效果上来说，基本就个数组相同了

类数组对象：只包含使用从零开始，且自然递增的整数做键名，并且定义了length表示元素个数的对象，我们就认为他是类数组对象

//定义数组和类数组对象
var arr = [1,2,3];
var obj = {0: 1, 1: 2, 2: 3, length: 3};

//元素读写操作
console.log(arr[0], obj[0])
console.log(arr['length'], obj['length'])
arr[0] = 9;
obj[0] = 9;
console.log(arr[0], obj[0])

//遍历
for(var i = 0, len = arr.length; i < len; i++) {
    //arr[i]....
}
for(var i = 0, len = obj.length; i < len; i++) {
    //obj[i]....
}

//类型判断
console.log(typeof arr);		
console.log(Array.isArray(arr)); 	
console.log(arr instanceof Array);	

console.log(typeof obj);		
console.log(Array.isArray(obj)); 	
console.log(obj instanceof Array);