JavaScript中的数组遍历总结

JavaScript中的数组遍历总结

for循环

	for(i=0; i<arr.length; i++) {
	}
	//对于对象数组来说 也可以用for 来遍历数组
	obj = {"userName" = "zq", "userPwd" = 123456}
	for(var key in obj) {
		conslole.log = obj[key];// zq*/-/// 123456
	}

forEach()

• 对数组进行遍历操作
• 循环数组，不会改变元素，不会返回新数组

array.forEach((value,index) => { 
	})

map()

• 遍历数组，对每个元素进行处理，之后返回元素；会返回一个新数组。

var arr2 = arr.map((value,index) => {
	value++ 
	return value
})

some()

• 查找数组中对应的某个特定的值是 用some（）
• 遍历数组，在回调函数里进行条件的判断，返回 true 或 false 。当有一个元素满足条件时就停止遍历并返回true；当全部的元素都不满足要求时，返回false
• 使用some函数，some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。some() 方法会依次执行数组的每个元素。 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。 如果没有满足条件的元素，则返回false。注意： some() 不会对空数组进行检测。 some() 不会改变原始数组。

var bool = arr.some((value,index) => {
	return value>3
})

arr.some((item, i) => {
     if (item.i == id) {
     this.list.splice(i, 1);
     return true;
   }
 })

every()

• 遍历数组，同上。当有一个元素不满足条件时就停止遍历并返回false；当全部元素都满足时，返回true

var bool = arr.every((value,index) => { 
	return value>3
})

filter()

• 查找数组中对应的多个值是 用filter
• 遍历数组，在回调函数里进行条件判断，当结果为true时，将该元素返回，组成一个新数组。

var arr2 = arr.filter((value,index) => {
	return value>3
})

var arr2 = arr.filter((value,index) => { 
	if (value>3) {
		return true
	}  
})

reduce()

• reduce(callback,init) init为初始值。
• 当init为空时，回调函数第一次执行的res是数组的第一个元素，value是第二个；第二次执行的时候res是第一次执行返回的内容，value是第三个元素；之后同第二次
• 当init不为空时，回调函数第一次执行的res是init，value是第一个元素；当第二次执行时res是第一次执行返回的内容，value是第二个元素；第三次的value是第三个元素

var result = arr.reduce((res,value) => {
	res = res + value 
	return res
})

var result = arr.reduce((res,value) => {
　　res = res + value 
　　return res
},100)

数组中的其他方法

arr.length()

• 返回或设置一个数组中的元素个数
• 设置 length 属性的值来截断任何数组

arr.from() //？？？？

• 对伪数组或可迭代对象(包括arguments Array,Map,Set,String…)转换成数组对象
• 语法 var arr = Array.from(arrayLike, mapFn, thisArg)
  • arrayLike 想要转换成数组的伪数组对象或可迭代对象。
  • mapFn (可选参数) 如果指定了该参数，新数组中的每个元素会执行该回调函数。
  • thisArg (可选参数) 可选参数，执行回调函数 mapFn 时 this 对象。
  • 返回值 一个新的数组实例

arr.isArray()

• 用于确定传递的值是否是一个 Array

    Array.isArray([]) => true;
    Array.isArray({}) => false;

arr.of(count)

• 根据传入的count 创建一个数字数组

	Array.of(7);       // [7] 
	Array.of(1, 2, 3); // [1, 2, 3]

	Array(7);          // [ , , , , , , ]
	Array(1, 2, 3);    // [1, 2, 3]

concat()

• 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

    var arr1 = ['a', 'b', 'c'];
    var arr2 = ['d', 'e', 'f'];
    var arr3 = ['f'];
    var arr4 = arr1.concat(arr2,arr3);
    // arr4 is a new array [ "a", "b", "c", "d", "e", "f" ]

copyWithin(target, start, end)

• 浅复制数组的一部分到同一数组中的另一个位置

every(callback)

• 方法测试数组的所有元素是否都通过了指定函数的测试

fill()

• 用一个固定值填充一个数组中从起始索引到终止索引内的全部元素

	arr.fill(value, start, end)
	ar numbers = [1, 2, 3]
	numbers.fill(1);
	// results in [1, 1, 1]

filter()

• 将会创建一个新数组, 其包含通过所提供函数实现的测试的所有元素

	var arr= [1,10,20,30]
	var brr = arr.filter((item)=>{
    	return item>10;
	})
	//[20,30]

find()

• 返回数组中满足提供的测试函数的第一个元素的值

    function isBigEnough(element) {
   	 	return element >= 15;
    }
    [12, 5, 8, 130, 44].find(isBigEnough); // 130

findIndex()

• 返回数组中满足提供的测试函数的第一个元素的索引

	function isBigEnough(element) {
 		 return element >= 15;
	}
	[12, 5, 8, 130, 44].findIndex(isBigEnough); 
	//'3'

forEach()

• 方法对数组的每个元素执行一次提供的函数

	array.forEach(callback(currentValue, index, array){
    	//do something
	}, this)

includes()

*用来判断一个数组是否包含一个指定的值，存在返回true 不存在返回false

• arr.includes（2）
• string.prototype.includes(‘要包含的字符串’)

	let a = [1, 2, 3];
	a.includes(2); 
	// true 
	a.includes(4); 
	// false

indexOf()

• 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1

	let a = [2, 9, 7, 8, 9]; 
	a.indexOf(2); // 0 
	a.indexOf(6); // -1
	a.indexOf(7); // 2
	a.indexOf(8); // 3
	a.indexOf(9); // 1
	if (a.indexOf(3) === -1) {
  		// 数组中不包含3
	}

join()

• 将数组（或一个类数组对象）的所有元素连接到一个字符串中

	let a = ['Wind', 'Rain', 'Fire'];
	a.join(); 
	// 默认为 ","
	// 'Wind,Rain,Fire'

lastIndexOf()

• 返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找

map()

• 创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果

pop()

• 从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度

	let a = [1, 2, 3];
	a.length; // 3
	a.pop(); // 3

push()

• 将一个或多个元素添加到数组的末尾

reduce()

• 累加器和数组中的每个元素（从左到右）应用一个函数

	var total = [0, 1, 2, 3].reduce(function(sum, value) {
 		 return sum + value;
	}, 0);
	// total is 6

reduceRight()

• 接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。

	let flattened = [
    	[0, 1], 
    	[2, 3], 
    	[4, 5]
	].reduceRight((a, b) => {
    	return a.concat(b);
	}, []);

reverse()

• 方法将数组中元素的位置颠倒。

shift()

• 从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度

slice()

• 返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象

some()

• 测试数组中的某些元素是否通过由提供的函数实现的测试。

	const isBiggerThan10 = (element, index, array) => {
  		return element > 10;
	}

	[2, 5, 8, 1, 4].some(isBiggerThan10);  
	// false

	[12, 5, 8, 1, 4].some(isBiggerThan10); 
	// true

array.sort(sortby)

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

var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"

document.write(arr + "<br />")
document.write(arr.sort())

// George,John,Thomas,James,Adrew,Martin
//Adrew,George,James,John,Martin,Thomas

splice()

• 通过删除现有元素和/或添加新元素来更改一个数组的内容
• 语法arrayObject.splice(index,howmany,item1,.....,itemX)
• 参数
  • index 必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
  • howmany 必需。要删除的项目数量。如果设置为 0，则不会删除项目。
  • item1, …, itemX 可选。向数组添加的新项目。

	var arr = new Array(6)
	arr[0] = "George"
	arr[1] = "John"
	arr[2] = "Thomas"
	arr[3] = "James"
	arr[4] = "Adrew"
	arr[5] = "Martin"

	document.write(arr + "<br />")
	arr.splice(2,0,"William")
	document.write(arr + "<br />")
	//George,John,Thomas,James,Adrew,Martin
	//George,John,William,Thomas,James,Adrew,Martin

toLocaleString()

• 返回一个字符串表示数组中的元素。数组中的元素将使用各自的 toLocaleString 方法转成字符串，这些字符串将使用一个特定语言环境的字符串（例如一个逗号 “,”）隔开

	var number = 1337;
	var date = new Date();
	var myArr = [number, date, "foo"];
	var str = myArr.toLocaleString(); 
	console.log(str); 
// 输出 "1,337,2017/8/13 下午8:32:24,foo"
// 假定运行在中文（zh-CN）环境，北京时区

toString()

• 返回一个字符串，表示指定的数组及其元素

unshift()

• 将一个或多个元素添加到数组的开头，并返回新数组的长度

forEach, some, indexOf, filter, findIndex 等都会对数组进行一次遍历操作，再进行相关的操作。