TypeScript Array(数组操作)

数组方法
1、concat(); 连接两个或更多的数组，并返回结果。

		以下代码连接两个数组：
		
			const letters = ['a', 'b', 'c'];
			const numbers = [1, 2, 3];
			letters.concat(numbers);
			// result in ['a', 'b', 'c', 1, 2, 3]
			
			以下代码连接三个数组：

			const num1 = [1, 2, 3];
			const num2 = [4, 5, 6];
			const num3 = [7, 8, 9];
			const numbers = num1.concat(num2, num3);	
			console.log(numbers); 
			// results in [1, 2, 3, 4, 5, 6, 7, 8, 9]
			
			以下代码将三个值连接到一个数组：

			const letters = ['a', 'b', 'c'];
			const alphaNumeric = letters.concat(1, [2, 3]);
			console.log(alphaNumeric); 
			// results in ['a', 'b', 'c', 1, 2, 3]

			以下代码连接嵌套数组并演示了引用的保留：

			const num1 = [[1]];
			const num2 = [2, [3]];
			const numbers = num1.concat(num2);
			console.log(numbers);
			// results in [[1], 2, [3]]
			// modify the first element of num1
			num1[0].push(4);
			console.log(numbers);
			// results in [[1, 4], 2, [3]]

2、every() 遍历数组每一项，若全部为true，则返回true；

	function isBigEnough(element, index, array) { 
    return (element >= 10); 
	}         
	
 var passed = [12, 5, 8, 130, 44].every(isBigEnough); 
 console.log("Test Value : " + passed ); // false

3、filter() 检查数组中数值元素，并返回符合条件的所有的元素

	function isBigEnough(element, index, array) { 
 	 return (element >= 10); 
	} 
      
var passed = [12, 5, 8, 130, 44].filter(isBigEnough); 
console.log("Test Value : " + passed ); // 12,130,44

4、forEach()用于调用数组的每个元素，并将元素传递给回调函数。

	var num = [7, 8, 9];
	num.forEach(function (value) {
   console.log(value);  // 7   8   9
	});

5、indexOf() 搜索数组中的元素，并返回它在数组中所在位置

var index = [12, 5, 8, 130, 44].indexOf(8); 
console.log("index is : " + index );  // 2

6、join（） 用于把数组中的所有元素放入一个字符串。

var arr = new Array("First","Second","Third"); 
      
var str = arr.join(); 
console.log("str : " + str );  // First,Second,Third 
      
var str = arr.join(", "); 	//元素是通过指定的分隔符 , 进行分隔的。
console.log("str : " + str );  // First, Second, Third
      
var str = arr.join(" + "); 	//元素是通过指定的分隔符 + 进行分隔的。
console.log("str : " + str );  // First + Second + Third

7、lastIndexOf() 返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。

var index = [12, 5, 8, 130, 44].lastIndexOf(8); 
console.log("index is : " + index );  // 2

8、map() 通过指定的函数处理数组中的每个元素，并返回处理后的数组

var numbers = [1, 4, 9]; 
var roots = numbers.map(Math.sqrt);   //Math.sqrt  取平方根
console.log("roots is : " + roots );  // 1,2,3

9、pop() 删除数组中的最后一个元素，并返回删除的元素

var numbers = [1, 4, 9]; 
      
var element = numbers.pop(); 
console.log("element is : " + element );  // 9
      
var element = numbers.pop(); 
console.log("element is : " + element );  // 4

10、push() 向数组的末尾添加一个或者多个元素，并返回新的长度

	var numbers = new Array(1, 4, 9); 
	var length = numbers.push(10); 
	console.log("new numbers is : " + numbers );  // 1,4,9,10 
	
	length = numbers.push(20); 
	console.log("new numbers is : " + numbers );  // 1,4,9,10,20

11、reduce() 将数组中的元素计算成一个值（从左往右）

	ar total = [0, 1, 2, 3].reduce(function(a, b){ return a + b; }); 
	console.log("total is : " + total );  // 6

12、reduceRight() 将数组中的元素计算成一个值（从右往左）

	var total = [0, 1, 2, 3].reduceRight(function(a, b){ return a + b; }); 
	console.log("total is : " + total );  // 6

13、reverse() 将数组中的元素进行反转

	var arr = [0, 1, 2, 3].reverse(); 
	console.log("Reversed array is : " + arr );  // 3,2,1,0

14、shift() 删除并返回数组中的第一个元素

	var arr = [10, 1, 2, 3].shift(); 
	console.log("Shifted value is : " + arr );  // 10

15、slice(start,end)选取数组中的一部分，并返回一个新数组
start 必需。
从零开始的索引，开始提取
可以使用负索引，表示距离数组末尾的偏移量。slice（-2）表示提取数组中最后两个元素
如果start未定义，默认从0开始索引
如果start大于数组长度，则返回一个空数组
end 可选。
在此之前结束提取，不包括end；
可以使用负索引，表示距离数组末尾的偏移量，slice(2,-1)通过序列中倒数第二个元素提取第三个元素。
如果end省略，则slice提取到数组末尾。
如果end大于序列的长度，则slice提取到数组末尾。

	var arr = ["orange", "mango", "banana", "sugar", "tea"]; 
	console.log("arr.slice( ) : " + arr.slice( ) );  // "orange", "mango", "banana", "sugar", "tea"
	console.log("arr.slice( 1, 2) : " + arr.slice( 1, 2) );  // mango       截取下标为1到下标为2之间的元素，但不包括下标2的元素
	console.log("arr.slice( 8, 2) : " + arr.slice( 8, 2) );  // 空数组
	console.log("arr.slice( 2,-1) : " + arr.slice( 2,-1) );  // banana，sugar 	 截取下标为2到倒数第一之间的元素，但不包括倒数第一的元素
	console.log("arr.slice( 2,-2) : " + arr.slice( 2,-2) );  // banana			截取下标为2到倒数第二之间的元素，但不包括倒数第二的元素
	console.log("arr.slice( 2,-3) : " + arr.slice( 2,-3) );  // 空数组

16、some() 遍历数组的每一项，若其中一项为 true，则返回true；
与filiter()的区别是：filiter返回的是符合条件的元素，some返回的是true或者false；

	function isBigEnough(element, index, array) { 
	return (element >= 10);          
	} 
      
	var retval = [2, 5, 8, 1, 4].some(isBigEnough);
	console.log("Returned value is : " + retval );  // false
      
	var retval = [12, 5, 8, 1, 4].some(isBigEnough); 
	console.log("Returned value is : " + retval );  // true

17、sort() 对数组的元素进行排序
如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，
说得更精确点，是按照字符编码的顺序进行排序。
要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。
如果想按照其他标准进行排序，就需要提供比较函数，
该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。函数应该具有两个参数 a 和 b，其返回值如下：

	若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
	若 a 等于 b，则返回 0。
	若 a 大于 b，则返回一个大于 0 的值。
	
	var items = [
	  { name: 'Edward', value: 21 },
	 { name: 'Sharpe', value: 37 },
	{ name: 'And', value: 45 },
	{ name: 'The', value: -12 },
	  { name: 'Magnetic', value: 13 },
	{ name: 'Zeros', value: 37 }
	];

	// sort by value
	items.sort(function (a, b) {
	  return a.value - b.value;
	});

	// sort by name
	items.sort(function(a, b) {
	  var nameA = a.name.toUpperCase(); // ignore upper and lowercase
	  var nameB = b.name.toUpperCase(); // ignore upper and lowercase
	if (nameA < nameB) {
	   return -1;
	  }
	 if (nameA > nameB) {
		   return 1;
	 }
	
	 // names must be equal
		return 0;
	});

18、splice()从数组中删除或者添加元素

	从索引2中删除0（零）元素，并插入“drum”Section
	
    var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
    var removed = myFish.splice(2, 0, 'drum');
  // myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"] 
  // removed is [], no elements removed
  
    从索引2中删除0（零）元素，并插入“drum”和“guitar”Section
    
   var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
   var removed = myFish.splice(2, 0, 'drum', 'guitar');
  // myFish is ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"] 
 // removed is [], no elements removed
 
  从索引3中删除1个元素Section
  
 var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
 var removed = myFish.splice(3, 1);
  // removed is ["mandarin"]
 // myFish is ["angel", "clown", "drum", "sturgeon"]
 
 从索引2中删除1个元素，然后插入“trumpet”Section
 
 var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
 var removed = myFish.splice(2, 1, 'trumpet');
 // myFish is ["angel", "clown", "trumpet", "sturgeon"]
 // removed is ["drum"]
 
 从索引0中删除2个元素，并插入“parrot”，“anemone”和“blue”Section
 
   var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];
   var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');
   // myFish is ["parrot", "anemone", "blue", "trumpet", "sturgeon"] 
  // removed is ["angel", "clown"]
  
  从索引2中删除2个元素Section
  
 var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];
 var removed = myFish.splice(myFish.length - 3, 2);
  // myFish is ["parrot", "anemone", "sturgeon"] 
 // removed is ["blue", "trumpet"]

 从索引-2中删除1个元素Section
 
 var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
 var removed = myFish.splice(-2, 1);
 // myFish is ["angel", "clown", "sturgeon"] 
 // removed is ["mandarin"]
 
 删除索引2（包括）后的所有元素Section
 
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
var removed = myFish.splice(2);
// myFish is ["angel", "clown"] 
// removed is ["mandarin", "sturgeon"]

19、toString()把数组的元素转换为字符串，并返回结果

	var arr = new Array("orange", "mango", "banana", "sugar");         
	var str = arr.toString(); 
	console.log("Returned string is : " + str );  // orange,mango,banana,sugar

20、unshift() 向数组开头添加一个或多个元素，并返回新的长度

	var arr = new Array("orange", "mango", "banana", "sugar"); 
	var length = arr.unshift("water"); 
	console.log("Returned array is : " + arr );  // water,orange,mango,banana,sugar 
	console.log("Length of the array is : " + length ); // 5