数组

1. 基本使用
-允许直接给后面添加值
arr[100] = 10

• 允许中间没有值，为undefined
• 通过下标访问到没有值的返回undefined
• arr.length = 0清空数组
• arr[arr.length-1] 获取到最后一位的值
• arr.push('cjj') 添加到最后
• arr.pop() 删除最后一位
• arr.unshift('xcc') 在数组第一位新增
• arr.shift() 移除第一位
  -arr.splice(a,b,c) 删除（a是从第几位开始，b是替换几位，c是替换成什么）

var arr = [1,2,5,6,9];
arr.splice(2,0,3,4)  //{1,2,3,4,5,6,9}

♡ 不进行替换只添加（b是0）的时候，是添加在a前面

• arr.slice(a,b)获取出来一个数组，原数组不变，从第a位开始，到第b位前结束（就是不包含b）

• arr.join(' ')把数组转换成字符串，可以在字符串中间添加符号
  

  

• arr.split('')把字符串转换成数组，在每个字符间添加,。

• arr.reverse()倒序，数组本身发生了变化

//字符串倒序输出
function  sortString(str){
    str = str.split("")
    str = str.reverse()
    str = str.join('')
    return str
}
var str = 'jirenguhungervalley'
var str2 = sortString(str)
console.log(str2) // 'yellavregnuhugnerij'

2. 使用

• arr[++i]下标可以是一个非负整数的变量或表达式
• concat(array)用于拼接数组，返回一个新数组，原数组不变a.concat(b)
• a.sort() 按照数字的第一位排序

var a=[1,2,10,200,3]
a.sort() //[1,10,2,200,3]

若要按照数值大小排序

a.sort(function (v1,v2){
    return v1-v2
}) //[1,2,3,10,200]

v1和v2比较，如果前一位减后一位大于0，就调换位置，小于0，就不管
按照对象里面的某个值来排序
① 按照数字大小

var users = [
  { name: "John", age: 20, company: "Baidu" },
  { name: "Pete", age: 18, company: "Alibaba" },
  { name: "Ann", age: 19, company: "Tecent" }
]
 user.sort(function(){
     return v1.age - v2.age
})
//0:{name: "Pete", age: 18, company: "Alibaba"}
//1:{name: "Ann", age: 19, company: "Tecent"}
//2:{name: "John", age: 20, company: "Baidu"}

②按字符串排序
return v1.name > v2.name字符串用大于表示

ES5 数组拓展
★ Array.isArray(obj)判断对象是不是一个数组
★ arr.indexOf(element) 看数组是否有element这个元素，并且会返回位置，从前往后找。lastIndexOf(element)从后往前找
★ 遍历数组
arr.forEach(element,index)参数可以是函数

var arr = [1,3,5,6,7]
arr.forEach(function(value,index){
    console.log(' '+value+value) //输出一个字符串加数组里的值，结果就是一个字符串
}) //遍历数组，函数里第一个参数是值，第二个是索引值， 输出[11,33,55,66,77]

★ .every(function(){})逻辑判断，返回布尔值

var arr = [1,-2,3,-5]
arr.every(function(val){
  return val > 0 ? true:false
})  //false

• .every所有函数的每个回调函数都是返回true的时候才会返回true，遇到false终止执行，返回false。
• .some有一个回调函数返回true时终止执行并返回true，否则返回false

★ .map(function(element){})遍历数组，与forEcah类似，回调函数返回值组成一个新数组返回，新数组索引结构和原数组一致，原数组不变。

var arr = [1,2,3,4,5,6,9]
var arr2 = arr.map(function(val){
    return val*val
})
//arr [1, 2, 3, 4, 5, 6, 9]
//arr2 [1, 4, 9, 16, 25, 36, 81]

★.filter(function(element))过滤

var arr = [1,2,3,4,5,6]
console.log(arr.filter(function(val){ //回调函数判断是不是返回true，是的话输出
  return val%2==0 //条件：对2取余等于0
}))  //满足条件返回值 [2,3,6]

★ reduce(function(v1,v2){},value)遍历数组，调用回调函数，讲数组元素合成一个值，reduce从索引最小值开始，reduceRight反向。value是可选的，表示初始值。
回调函数：把两个值合为一个，返回结果

var arr = [3,4,5]
arr.reduce(function(v1,v2){
    return v1+v2  //(3+4)+5  12
})

---

步骤实现

function reduce(arr,fn){
    var arr2 = arr;
    while(arr2.length > 1){
        console.log(arr2)
        arr2.splice(0,2,fn(arr2[0],arr2[1]))
    }
        return (arr2[0])
}
var arr = [3,4,5,6]
var result = reduce(arr,function(v1,v2){
  return v1 + v2
})
console.log(result)

结果

---

假如有初始值

function reduce(arr,fn,initValue){
    var arr2 = arr.concat([]);//合成两个数组（其中一个为空），变成一个新数组arr2,与arr无关
    if(initValue !== undefined){ //判断有没有初始值
        arr2.unshift(initValue) //把初始值添加到第一位
    }
    while(arr2.length > 1){
        console.log(arr2)
        arr2.splice(0,2,fn(arr2[0],arr2[1]))
    }
        return (arr2[0])
}
var arr = [3,4,5,6]
var result = reduce(arr,function(v1,v2){
  return v1 + v2
},10)
console.log(result)

---

将嵌套多层的数组，转换为只有一层的数组
方法①

var arr = [3,['4,5',7,[1]],[2,10]]

function flat(arr){
  var arr2 = [] //新建一个新数组
  arr.forEach(function(val){
    if(Array.isArray(val)){ //判断val是不是一个数组
      arr2 = arr2.concat(flat(val))//如果是数组，这个数组里面再flat一次，取到里面的值，再跟arr2合并
    }else{
      arr2.push(val) //如果不是数组，直接添加到arr2里面
    }
  })
  return arr2 //遍历完后返回arr2
}
var arr2 = flat(arr)
console.log(arr2)

方法②

function flatten2(arr){
    return arr.reduce(function(initArr,currentArr){
  return initArr.concat(Array.isArray(currentArr)?flatten2(currentArr):currentArr)
  },[]) 
}