JavaScript基础知识-（数组）

1，数组是值的有序集合。每一个值叫做一个元素，每个元素在数组中有一个位置，称为索引。JavaScript的数组是无类型的，数组元素可以是任意类型。

  数组的创建方法：
  （１）直接量：

var a = [1,2,3,4,5,]; // 注意：索引从0开始，最后一个是逗号可选的
复制代码

  （2）调用构造方法

var arr = new Array(10) 
var arry = new Array(1,2,3,4,5)
复制代码

2，常用的数组方法

（1）join() :将数组的所有元素都转换为字符串并连接在一起，返回生成的字符串，可以指定一个可选的字符串连接数组的每个元素，如果没有指定，默认使用逗号

var a = [1,2,3]
    a.join()  // => "1,2,3"
    a.join(" ") // => "1 2 3"
    // Array.join()方法是String.split()的逆向操作，split()是把字符串分割成若干块创建一个数组
复制代码

（2）reverse() :将数组中的元素颠倒顺序，返回逆序的数组
（3）sort() :将数组中的元素排序并返回排序后的数组，不带参数的调用sort()时，数组元素是以字母表顺序排序的。

var a = [33,4,111,222]
    a.sort() // => 111,222,33,4
    a.sort(function(a,b){
        return a-b;
    })
    a.sort(function(a,b){
        return b-a;
    })
复制代码

（4）concat() : 创建并返回一个新数组

var a = [1,2,3]
    a.concat([4,5])  // => [1,2,3,4,5]
    a.concat(4,5)  // => [1,2,3,4,5]
复制代码

（5）slice() : 返回指定数组的一个片段或者子数组，它的两个参数分别指定了片段的开始位置和结束位置，不会修改原数组。切记：包含第一个参数指定的元素，不包含最后一个参数指定的位置。 如果出现负数，-1表示最后一个元素位置

var a = [1,2,3,4,5]
a.slice(0,3) // => [1,2,3]
a.slice(3) // => [4,5]
a.slice(1,-1) // => [2,3,4]
复制代码

（6）splice() :在数组中插入或者删除元素的通用方法。会修改原数组。它的两个参数：第一个参数指定了插入或者删除的起始位置，第二个参数指定了从数组中删除的元素个数，如果省略第二个参数，表示从起点开始到数组的结尾的所有元素都删除。返回一个由删除元素组成的数组，如果没有删除元素就返回一个空数组。并且原数组也发生了改变

var a= [1,2,3,4,5]
    a.splice(2) // => 返回[3,4,5]  原数组：a=[1,2]
    a.splice(1,1) // => 返回[2] 原数组： a=[1]
复制代码

splice()的前两个参数指定了需要删除的数组元素。紧随其后的任意多个参数指定了需要插入到数组中的元素，从第一个参数指定的位置开始插入

var a = [1,2,3,4,5]
    a.splice(2,0, 'a', 'b') // => 返回[]空数组 ， 原数组：a = [1,2,'a','b',3,4,5]
复制代码

（7）push()和pop() : push():在数组尾部添加一个或者多个元素，并返回数组长度
           pop():删除数组最后一个元素，返回它删除的值

var stack = []
    stack.push(1,2,3) // 返回3长度    stack = [1,2,3]
    stack.pop();      // 返回3元素值    stack = [1,2]     
复制代码

（8）unshift()和shift()
      unshift()在数组的头部添加一个或者多个元素，并返回数组长度          shift() 删除数组第一个元素，并返回删除的值

var a = []
    a.unshift(111) // 返回1   a = [222]
    a.unshift(333,555) // 返回3  a = [333,555,111]
    a.shift()         // 返回333  a = [555,111]
复制代码

3,ES5中新增的数组方法

（1）forEach() :从头至尾遍历数组，为每个元素调用指定的函数。该方法的第一个参数就是被用的函数，并且向该函数传递了三个参数：分别是（每个数组元素，元素的索引，数组本身）。有两种写法：

var data = [1,2,3,4,5]
data.forEach(function(val){
    console.log(val)
})
data.forEach(function(val,i,data){
    a[i] = val + i  // 每个元素自增1
})
复制代码

（2）map() : 将调用的数组的每一个元素传递给指定的函数，计算，并返回一个新数组，

var a = [1,2,3,4,5]
    b = a.map(function(val){
        return val * val
    })
    // 注意：map()返回的是新数组，它不修改调用的数组
复制代码

（3）filter() : 返回的数组元素是调用数组的一个子集，传递的函数是过滤和判断的条件，返回true和false。 如果函数返回值为true,那么传递给函数的元素就会被放到返回的数组中，如果函数返回值为false,就过滤到该元素

var a = [1,2,3,4,5]
    b = a.filter(function(val){
        return x < 3
    })  // b = [1,2]
// 对稀疏数组，压缩空缺并删除undefined和null元素
a = a.filter(function(val){
    return x !== undefined && x !=null
})
复制代码

（3）every()和some()
  every(): 函数中所有元素判断条件都为true,才返回true
  some(): 函数中所有元素判断条件只要有一个为true,就返回true

var a = [1,2,3,4,5]
    a.every(function(val){
        return val < 10     // 返回true
    })
    a.every(function(val){
        return val % 2 === 0     // 返回false ,存在不符合的元素
    })
    a.some(function(val){
        return val % 2 ===0 ;  // 返回 true, 有一个元素满足就可以了
    })
    a.some(isNaN)   // 返回false, 遍历数组，不存在这样非数值的元素
复制代码

（4）reduce()和reduceRight() : 使用指定的函数将数组元素进行组合计算，生成单个值，并返回。reduce()需要两个参数。第一个参数是执行的函数，对元素继续计算组合，并返回简化之后的值。第二个参数可选，是一个传递给函数的初始值

var a = [1,2,3,4,5]
var sum = a.reduce(function(x,y){
    return x + y;
},0)
// 0是第一个传递个函数的初始值，所以第一次 0 + 1 = 1， 返回值1
// 第二次计算： 返回值加上第二个元素： 1 + 2 = 3 返回值3，依次计算
var product = a.reduce(function(x,y){
    return x * y;
},1)
var max = a.reduce(function(x,y){
   return x > y ? x : y;
})
// 如果reduce()没有第二个参数，它就使用数组的第一个元素作为初始值
复制代码

  reduceRight()和reduce()工作原理一样，区别是：reduceRight()按照数组索引从高到底，从右到左处理数组，并进行计算

// 把p中的可枚举属性复制到oz中，并返回o
function extend(o,p) {
    for (prop in p) {
        o[prop] = p[prop];
    }
    return o;
}
// 返回一个新对象，同时拥有o对象和p对象属性
function union(o,p) {
    return extend(extend({},o),p)
}
//对象的并集
var object = [{x:1},{y:2},{z:3}]
var merged = object.reduct(union) // 返回 => {x;1,y:2,z:3}
// 如果简化的时候，有相同属性，union函数是使用第一个参数的属性
var objects = [{x:1,a:1},{y:2,a:2},{z:3,a:3}];
var leftUnion = objects.reduct(union) // =>{x:1,y:2,z:3,a:1}
var rightUnion = objects.reductRight(union) // =>{x:1,y:2,z:3,a:3}
复制代码

（5）indexOf和lastIndexOf : 搜索整个数组中具有给定值的元素，并返回找到的第一个元素的索引或者如果没有找到就返回-1。indexOf():从头至尾搜索 lastIndexOf():从后往前搜索

var a = [0,1,2,3,3,2,1,0]
    a.indexOf(1) // 返回索引位置：1
    a.lastIndexOf(1) // 返回索引位置：6
    a.indexOf(9)    //返回 -1
// 在数组中查找所有出现的b,并返回一个包含匹配索引的数组
var c = [0,1,2,3,3,2,1,0,6,2,4]
	function findall(a,b) {
		var results = [];
		var len = a.length;
		var pos = 0;
		while(pos < len){
			pos = a.indexOf(b,pos) // 从索引0的地方查找元素
			if(pos === -1) break;
			results.push(pos)
			pos = pos + 1
		}
		console.log(results) // => 输出 [8]
		return results;
	}
	findall(c,6)  
复制代码

（6）数组类型检测：ES5新增方法 isArray()

Array.isArray([]) // =>true
Array.isArray({}) // =>false
复制代码

转载于:https://juejin.im/post/5c7e3f9df265da2dda696fbd