创建数组

数组是特殊的Object，包含很多方法，创建数组的方法有很多：

//数组的创建
var arr  = new Array(100) //创建一个长度为100的数组,所有的值都为undefined
var arr1 = new Array('1','2',true) //创建一个包含数值和固定下标的字符串
var arr2 = [] //快捷创建一个数组 

数组的方法

获取所有的数组方法: Array.prototype 所有在原型链上的方法

• john 方法 将数组转换为字符串

  var arr = [1,2,3]
  arr.join('/') //输出"1/2/3“
  
  var arr1 = [1,2,3,undefined];
  arr.join('') //输出"123"忽略 undefined
  
  //利用join创建一个重复输出的函数
  function repeatString(str,n){
    return new Array(n+1).join(str) //创建一个n长度的数组，然后join连接符得以重复
  }
  

• reverse方法 将数组顺序颠倒

  var arr = [1,2,3]
  arr.reverse() //输出[3,2,1] 会修改原数组
  

• sort方法 将数组排序

  var arr = [15,22,17,58]
  arr.sort(); // 15,17,22,58
  
  var arr1 = [13,24,3,58]
  arr1.sort(); // 13,24,3,58 并没有按照实际的数字大小进行排序，因为sort方法先将其转换为字符串然后进行排序，解决方法：
  
  var arr1 = [13,24,3,58];
  arr1.sort(function(a,b){return a-b }) //根据大小排列
  
  var items = [
    { name: 'Edward', value: 21 },
    { name: 'Sharpe', value: 37 },
    { name: 'And', value: 45 },
    { name: 'The', value: -12 },
    { name: 'Magnetic' },
    { name: 'Zeros', value: 37 }
  ];
  
  // 根据值的大小排列
  items.sort(function (a, b) {
    return (a.value - b.value)
  });
  

• concat方法 连接返回一个数组

  var arr = [1,2,3]
  
  arr.concat(1) // [1,2,3,1]
  arr.concat([10,11],12) // [1,2,3,10,11,12]拉平数组一次
  arr.concat([10,11,[12,13]]) // [1,2,3,10,11,[12,13]] 只能拉平数组一次不能多次拉平
  

• slice方法 返回部分数组

  var arr = [1,2,3,4,5]
  arr.slice(1,3) //返回[2,3] 不包含结束的那个字符
  arr.slice(1) //[2,3,4,5]
  arr.slice(1,-1) //[2,3,4] 从索引位置到最后一个的索引 不包含最后一个字符
  arr.slice(-4,-3) // [2]
  

• splice方法 数组精简、指定位置增加

  var arr = [1,2,3,4,5]
  arr.splice(1,1)
  arr //[1,3,4,5] 从第二个字符开始删除一个
  
  arr.splice(2,2)
  arr //[1,2,5] 从第三个字符上开始删除两个
  
  arr.splice(1,1,'a','b') 
  arr //[1,'a','b',3,4,5] //从第二个索引删除一个，然后插入后续的值
  

• ES5 方法：forEach方法，遍历数组 并不会修改当前数组

  var arr = [1,2,3,4,5]
  arr.forEach(function(x,index,a){  //三个参数：x数组的值，index数组的索引，a数组本体
    console.log(x+'|'+index+'|'+ (a === arr) ) 
  })
  

• ES5方法：map方法，遍历并返回一个数组

  var arr = [1,2,3,4,5]
  var arr1 = arr.map(function(x){
    return x * 2
  })
  arr1 //[2,4,6,8,10]
  
  var kvArray = [{key: 1, value: 10}, {key: 2, value: 20}, {key: 3, value: 30}];
  
  var newKeyValueArray = kvArray.map(function(obj){
    var sObj = {};
    sObj[obj.key] = obj.value
    return sObj
  })
  
  newKeyValueArray //[{1:10},{2:20},{3:30}]
  

• ES5方法：filter方法，接受一个callback，返回一个过滤的数组

  var arr = [1,2,3,4,5];
  arr.filter(function(x,index){ //接受两个参数x为值，index为索引
    return index % 3 === 0 || index > 1
  })  // [4]
  

• ES5方法：every方法，对数组进行判断，全部符合返回一个boolean数值

• ES5方法：some方法，对数组进行判断，符合一个则返回boolean数值

  //every方法
  var arr = [1,2,3,4,5];
  arr.every(function(x){
    return x < 10 
  }) //true 因为全部小于10
  
  arr.every(function(x){
    return x > 6
  }) //false 因为没有大于6的
  
  //some方法
  arr.some(function(x){
    return x === 3
  }) //true 因为数组里面存在3
  
  arr.some(function(x){
    return x <2
  }) //true 因为1小于2
  

• ES5方法：reduce方法，对数组相邻的值进行操作

  //reduce
  var arr = [1,2,3,4,5]
  arr.reduce(function(x,y){ //此时x、y为1、2 第一个参数为索引1的值，第二个参数为索引2的值
    return x+y
  },1) //此时1先作为x，与数组内数字相加，然后从左到右进行累加
  
  reduceRight //顺序改变从右往左
  

• ES5方法：indexOf / lastIndexOf方法，查找数组是否存在该值，如果存在返回当前索引位置，如果没有则返回-1

  var arr = [1,2,3,2,1]
  arr.indexOf(1) //返回索引为0
  arr.indexOf(1,2) //从第三个位置开始查找，返回索引为4
  arr.indexOf(1,-2) //从倒数第二的位置（2）开始查找，返回索引为4
  
  arr.lastIndexOf(3,-4) //从右往左找，从倒数第四个开始（2），返回索引为2
  

判断是否为数组

• Array.isArray(obj)
• obj instanceof Array; //是否是数组实例
• ({}).toString.apply([]) === “[object Array]” //true 调用对象的toString方法
• [].constructor === Array //true 利用构造函数判断