JavaScript之再谈数组之数组方法、ES5方法

        稀疏数组

        在数组中有那个一种形式：忽略索引，显示长度。这种形式就是稀疏数组。  

        稀疏数组定义方法是：两种方式，

var a = new Array(5);
console.log(a.length);
console.log(a);
var arr = [];
arr[1000] = 0;
console.log(arr);

        数组方法

        rereverse()

           表示颠倒数组的顺序，返回逆序的数组

        

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

      

        concat()

        创建并返回一个新数组，相当于连接作用，把调用concat的原始数组和concat()方法的参数连接起来，如果参数里面有数组，不会递归扁平化数组。不改变原数组。

var arr = [1,2,3,4];
console.log(arr.concat(5,6,7,8));

        同样也可以用这个特性创建二维数组。

var arr = [];//创建二维数组console.log(arr.concat([[]],[[]],[[]],[[]]));

        ES5.0中的方法

        大多数ES5的方法的第一个参数接受一个函数，并且对数组的每一个元素调用一次该函数。如果是稀疏数组，对不存在的元素不调用传递的函数。大多数情况下调用函数使用三个参数：数组元素、数组索引、数组本身，通常只需要一个参数值，可以忽略后两个参数。大多数ES5数组的方法的第一个参数是一个函数，第二个参数是可选的，如果有第二个参数，则电泳的函数被看做第二个参数的方法。ES5中的函数都不会改变数组。

        forEach()

        从头到尾遍历数组，为每个元素调用指定的函数.
        注意：forEach()无法再所有元素都传递给调用的函数之前终止遍历，也就是说，不能像for循环那样使用break终止循环，如果要提前终止，必须把forEach()方法放在一个try块中，并能抛出一个异常，如果forEach()调用的函数抛出foreach.break异常，循环会提前终止。

var arr = [1,2,3,4];
console.log(arr.forEach(function(v,i,a){
	a[i] = v + 1;
}))

// 提前终止
function foreach(a,f,t){
	try{
		a.forEach(f,t);

	}
	catch(e){
		if(e === foreach.break){
			return ;
		}
		else{
			throw e;
		}
	}
}
function index(value,t){
	console.log(t);
	sum += value;
	if(t == 2){
			throw foreach.break;
		}
}
foreach(arr,index);

        map()

        map()返回一个新数组，函数有返回值，如果是稀疏数组，返回的也是相同方式的稀疏数组，具有相同的长度，相同的确实元素。

        

var arr = [1,2,3,4];
var arr1 = arr.map(function(value,index,arr){
	var arr1 = [];
	arr1.push(value);
	return arr1[index] = value + 1;
})
console.log(arr1);

        filter()

        fliter()方法返回的数组元素是调用的数组的一个子集。返回值为一个数组。调用函数也是和上面方法一样，第一个传入函数，但是这个函数是用来逻辑判断的，如果返回值为true或者能转化成true的值，那么传递给函数的元素就是这个子集的成员，把它添加到返回的数组中。

var arr = [1,2,3,4];
console.log(arr.filter(function(value,index,arr){
		eturn value > 2;
}))
console.log(arr.filter(function(value,index,arr){
	return value % 2 == 0;
}))

        filter()会跳过稀疏数组中缺少的元素，它的返回数组总是稠密的。常常是为了压缩稀疏数组的空缺实现。

var arr1 = [];
arr1[100] = null;
arr1[101] = undefined;
arr1[102] = null;
arr1[103] = 2;
console.log(arr1.filter(function(value,index,arr){
	return true;
}))

        有时候还可以实现剔除数组中的null和undefined.

console.log(arr1.filter(function(value,index,arr){
	return value != null || value != undefined;
}))

        every()和some()

        every()和some()方法是数组的逻辑判定，返回true或者false。
every()方法表示数学中针对“所有”的量词，对数组中所有的元素进行调用函数判断都为true，才返回true。

        

var arr = [1,2,3,4];
console.log(arr.every(function(value,index,arr){
	return value < 5;
}))
console.log(arr.every(function(value,index,arr){
	return value < 4;
}))

        some()方法就像数学中存在的量词，当数组中元素调用函数至少有一个返回true时，返回true，当数组中所有元素返回false时，才返回false。

console.log(arr.some(function(value,index,arr){
	return value <2;
}))
console.log(arr.some(function(value,index,arr){
	return value <1;
}))

        注意：一旦every()和some()确认返回是什么值之后就会停止遍历数组，就是说，当every()确定有一次返回false时，就会停止，直接返回false。some()当数组元素有一次返回true时，停止遍历，直接返回true。根据数学上的惯例：在空数组上调用时，every()返回true，some()返回false。

var arr1 = [];
console.log(arr1.every(function(value,index,arr1){}))
console.log(arr1.some(function(value,index,arr1){}))

  

        reduce()和reduceRight

        使用指定的函数将数组元素进行整合，生成单个值。这是在函数式编程中是常见的操作，也可以称为‘注入’和‘折叠’。
reduce() 需要两个参数。第一个是执行化简操作的函数。像化简函数中传入两个值，进行函数操作把两个值转换成一个值并返回。第一个函数（可选）的参数是传递给函数的初初始值。

var arr = [1,2,3,4];
var sum = arr.reduce(function(x,y){
	return x + y;
})
console.log(sum);
console.log(arr.reduce(function(x,y){
	return x * y;
},2));

        在空数组上，不带初始值参数调用reduce()会出现类型错误异常,如果调用数组时候只有一个值，并且没有返回值，或者是一个空数组并且指定一个返回值。reduce()方法只返回这个值。

var arr1 = [];
console.log(arr1.reduce(function(x,y){
	return x + y;
}))

        educeRight()和reduce()一样，唯一不同的是reduce是从前往后计算，reduceRight是从后往前计算。

         在这两个函数，数学计算并不是它们的唯一意图。

        

function extend(o,p){
	for(var prop in p){
		o[prop] = p[prop];
	}
	return o;
}
function union(o,p){
	return extend(extend({},o),p);
}
var obj = [{x:1},{y:2},{z:3}];
console.log(obj.reduce(union));
var obj1 = [{x : 1,a : 2},{a : 3},{y : 4}];
console.log(obj1.reduce(union));

   

        由此可见 工作原理和化简函数一样，并且把任意数目的对象并集化。

        indexOf()和lastIndexOf()

        这两个方法是搜索整个数组中具有给定值的元素，搜索到返回索引。如果没有找到就返回-1.由此可见：indexOf()从头到尾搜索，lastIndexOf()从尾到头搜素。
这两个方法不接受函数作为参数，有两个参数，第一个参数是要查询元素的值，第二个参数是可选的，它指定数组中的一个索引，从此索引处开始搜索，如果不设置第二个参数的话，则从头或从尾开始搜索。

        

var arr = [1,2,3,4,5,2,3,5];
console.log(arr.indexOf(2)); 
console.log(arr.lastIndexOf(2));

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

         也可以通过封装函数返回所指定元素的索引。

function findall(a,x){
	var results = [],
	    len = a.length,
	    pos = 0;
	while(pos < len){
	    pos = a.indexOf(x,pos);
	    if(pos == -1){
		break;
	    }
	    results.push(pos);
	    pos ++;
	}
	return results;
}
console.log(findall（arr,2）;

        在字符串中也可以通过indexOf来查找某个字符的索引

var str = "qweqrrtetyrtqqeqrw";
function findStr(str,prop){
	var results = [],
	    len = str.length,
	    pos = 0;
	while(pos < len){
	    pos = str.indexOf(prop,pos);
	    if(pos == -1){
	        break;
	    }
	    results.push(pos);
	    pos ++;
	}
	return results;
}
console.log(findStr(str,"q"));

        喜欢的话就收藏下吧。

         --主页传送门--