Javascript基础知识汇总——数组

• 概念：使用单独的变量名来存储一系列的值

• 作用：就是一个容器，将多个数据保存起来

声明数组的方法

• 字面量的方法

var arr = []

• 构造函数方法

var arr = new Array()
	如果参数是一个数值：代表的是数组的长度
    如果是多个数值，则是数组的内容
    
var arr = new Array(1,2,4,5,6)

数组的取值

• 利用数组的下角标 例如：arr[0]
• 数组里面的下标都是连续的

数组的遍历

• 根据数组的下标从开始往后扫描，直到结束
• for循环

var arr = [1,2,4,54,34]
for (var i = 0;i<arr.length;i++) {
    console.log(arr[i])
}

• for in 循环 （常用来遍历对象）

for (key in arr){
    console.log(arr[key])
}

数组的api

• push()：在数组最后面添加数据，数组长度会增加 会改变原数组
• pop：从数组最后取出一个数据，数组长度会减少 会改变原数组
• unshift：和push相反，从数组最前面添加数据 会改变原数组
• shift：和pop相反，从数组最前面取出一个数据 会改变原数组
• reverse：反转 改变原数组
• sort：对数组进行排序 ，参数为一个回调函数，
  • 无参数时：按照ascii码排序，从第一位开始比 arr.sort()
  • 有参数时：arr.sort(function(){}) 对数字进行大小排序，需往sort方法内传入回调函数。

var arr = [12,92,41,1,24]
arr.sort(function(a,b) {
    return a-b // 从小到大排  正序
    // return b-a // 从大到小排  倒叙
})
console.log(arr)

• concat 数组连接（拼接）不会对原数组造成影响

var arr1 = [1,23,35,3]
var arr2 = [43,53]
var newArr = arr1.concat(arr2)
console.log(newArr) // [1,23,35,3,43,53]

• join 将数组分割成字符串，按照所填的字符 不会对原数组造成影响

var arr1 = ["roy","wang","hello"]
arr1.join("*")
console.log(arr1.join("*")) // roy*wang*hello

• arr.toString() 将数组转换为字符串 不会对原数组造成影响

var arr = ["hello",'roywang']
arr.toString()
console.log(arr.toString()) // hello,roywang

• arr.slice(start,end) 按照下标截取 截取数组的一段 不操作原数组
  • 从start开始 end（不包括end）,返回数组的一段
  • start和end都不写时，返回整个数组arr，常用来快速复制数组

var arr = ["today","is","sunny","I","am","happy"]
var arr2 = arr.slice(0,3)
console.log(arr2) // ["today", "is", "sunny"]

• arr.splice(start,deleteCount,arr) 操作原数组
  • 从start开始 删除几个 arr新插入的数组元素
  • 从数组中移除一个或多个元素，如果必要，在所移除元素的位置上插入新元素

var arr1 = ["today","is","sunny","I","am","happy"]
arr1.splice(1,3)
console.log(arr1) // (3) ["today", "am", "happy"]

var arr1 = ["today","is","sunny","I","am","happy"]
arr1.splice(1,3,'newData')
console.log(arr1) // ["today", "newData", "am", "happy"]

冒泡排序

9 8 11 6 5
第一轮：
	8 9 11 6 5 
	8 9 11 6 5
	8 9 6 11 5
	8 9 6 5 11
第二轮：
	8 9 6 5
	8 6 9 5
	8 6 5 9
第三轮：
	8 6 5
	6 8 5
	6 5 8
第四轮：
	6 5
	5 6

var arr = [12, 32, 43, 23, 5, 46, 45, 26]
  function bubbleSort(arr) {
    // 确定循环次数
    for (var i = 0; i < arr.length - 1; i++) {
      // 每一轮 数值比较
      for (var j = 0; j < arr.length - i - 1; j++) {
        // 谁大谁往后排
        if (arr[j] > arr[j + 1]) {
          var temp = arr[j]
          arr[j] = arr[j + 1]
          arr[j + 1] = temp
        }
      }   
    }
    return arr
  }
  console.log(bubbleSort(arr))

选择排序

arr = [6,5,1,3,2]
   6,5,1,3,2
第一轮：
    5，6，1，3，2
    1，5，6，3，2
    1，5，6，3，2
    1，6，5，3，2
第二轮：
	6，5，3，2
    5，6，3，2
    3，6，5，2
    2，6，5，3
第三轮：
	6，5，3
    5，6，3
    3，6，5
第四轮
	6，5
    5，6

var arr = [12, 32, 43, 23, 5, 46, 45, 26]
  function chooseSort(arr) {
    // 确定循环几轮
    for (var i = 0; i < arr.length - 1; i++) {
      // 每一轮都和第一个比较
      for (var j = i + 1; j < arr.length; j++) {
        // 谁小谁放前面
        if (arr[j] < arr[i]) {
          var temp = arr[i]
          arr[i] = arr[j]
          arr[j] = temp
        }
      }
    }
    return arr
  }
  console.log(chooseSort(arr))

快速排序

var arr = [12, 132, 43, 23, 15, 46, 45, 26]
  function quickSort(arr) {
    // 递归结束条件
    if (arr.length <= 1) {
      return arr
    }
    // 取中间的值以及中间的下标
    var midIndex = parseInt(arr.length / 2),
      midValue = arr[midIndex],
      leftArr = [],
      rightArr = [];
    // 遍历arr数组，每一个值和中间的值相比较，大的放右侧，小的放左侧
    for (var i = 0; i < arr.length; i++) {
      if (i == midIndex) { // 如果是中间下标，直接跳出本次循环，不用中间值比较
        continue
      }
      if (arr[i] <= midValue) {
        leftArr.push(arr[i])
      } else {
        rightArr.push(arr[i])
      }
    }
    // 利用递归处理左右数组
    var res = quickSort(leftArr).concat(midValue).concat(quickSort(rightArr))
    return res
  }
  console.log(quickSort(arr))

二维数组

var arr = [[1,2,8],[4,3,2],[3,5,7]]
console.log(arr[0][0]) // 1

for(var i = 0;i<arr.length;i++) {
    for(var k = 0;k<arr[i].length;k++) {
        console.log(arr[i][k]) // 1,2,8,4,3,2,3,5,7
    }
}

值传递和引用传递

• 值传递传递的是基本数据类型的数据，数据不会发生改变，原理：因为常量不可改变
• 引用传递：传递的是对象（数组、对象） 原理：对象存储在堆空间里，自身可以发生改变

基本数据类型：string,number,boolean,null,undefined==>存储在栈

引用类型：object 对象==》存储在堆

ES5新增数组方法

• indexOf

arr.indexOf(v)
	返回数组中v第一次出现的下标
    arr.indexOf(v,m) 从第m的下标开始查找，返回v所在的arr中的下标  如果出现两个参数 后面参数代表从那个下标查找
    如果不存在返回 -1
var arr = [1,2,3,4,5,6,2,7,8]
console.log(arr.indexOf(2)) // 1
console.log(arr.indexOf(2,3)) // 6
console.log(arr.indexOf(9)) //-1

var arr = [1, 2, 3, 4, 5, 6, 2, 7, 8]
// indexOf实现数组去重
function noRepeate(arr) {
    var tempArr = []
    for (var i = 0; i < arr.length; i++) {
        if (tempArr.indexOf(arr[i]) == -1) {
            tempArr.push(arr[i])
        }
    }
    return tempArr
}
console.log(noRepeate(arr))

• lastIndexOf(v)

返回数组中v最后一次出现得下标
如果油两个参数arr.lastIndexOf(v,m)从第m得下标开始向前查找，返回v所在arr中得下标，如果没有就返回-1

var arr = [1, 2, 3, 4, 5, 6, 2, 7, 8]
console.log(arr.lastIndexOf(2)) // 6
console.log(arr.lastIndexOf(2, 3)) // 1
console.log(arr.lastIndexOf(9)) //-1

以下方法，参数都是回调函数：

• forEach遍历数组 (forEach没有返回值，要用一个变量接收)

arr.forEach(function(value,index,arr){
    console.log(value) // 把数组值都遍历出来了
    console.log(index) // 把数组索引遍历出来
    console.log(arr) // 把数组本身打印出来
})

• map

var arr = [1, 23, 42, 453, 3]
var arr2 = arr.map(function (value, index, arr) {
    // 把数组中的每一项加1，然后映射到一个新数组，不影响原数组
    return value + 1
})
console.log(arr2) // [2, 24, 43, 454, 4]

• reduce

// 不改变原数组
arr.reduce(function(acc,value,index,arr){
    // 参数1：累加器
    // 参数2：数组的值
    // 参数3：数组索引
    // 参数4：源数组
    return acc + value // 累加
    return acc * value // 累乘
    return acc / value // 累除
    return acc - value // 累减
})

var arr = [1,232,42,5]
var res = arr.reduce(function(acc,value){
    return acc + value // 累加
})
console.log(res) // 280

• filter

arr.filter(function(vale,index,arr){
    return 过滤条件
})

var arr = [1,232,42,52,3234,22,4,5]
var res = arr.filter(function(value,index,arr){
    return value>22
})
console.log(res) //  [232, 42, 52, 3234]