JS数组

数组是一个特殊的对象

创建数组

  1.         let arr = [1,2,3,4]
  2.         let arr = new Array(1,2,3)
  4.         // 转化为数组
  5.         let str = '1,2,3,4';
  6.         str.split(',')
  8.         str.split('');
  9.         //  Array.from 变数组的条件 1必须要有0,1,2等数字的字符串下标 2 必须有length的属性
  10.         Array.from{0:'a',1:'b',2:'c',length:3}

伪数组的原型链中没有数组的原型

  1. // 这样获取的数组就是伪数组 不能使用push 等属性
  2. let divList = document.querySelectorAll('div')

注意new和undefined创建的数组是有区别的

  1. var a = new Array(3);
  2. var b = [undefined, undefined, undefined];
  4. 0 in a // false
  5. 0 in b // true

合并数组（contact）

将2个数组合并为一个新的数组 原来的不变

  1. let arr = [1,2,3]
  2. let arr2 = [4,5,6]
  3. arr.concat(arr2)
  4. // 返回：  [1, 2, 3, 4, 5, 6]

截取数组(slice)

截取数组 获得一个新的数组 原数组不变

  1. let arr3 =  [1, 2, 3, 4, 5, 6]
  2. arr3.slice(2)
  3. // 返回：  [3, 4, 5, 6]
  4. let arr4 = arr3.slice(0)
  5. // 复制一个数组

删

以下删除方法有问题 ：

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. delete arr[0]
  3. arr
  4. // 返回： [空, 2, 3, 4, 5, 6]  保留长度
  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. arr.length = 5
  3. arr
  4. // 返回 [1, 2, 3, 4, 5]

删除方法:

shift 删除头部元素

  1. let arr =  [1, 2, 3, 4, 5]
  2. arr.shift(1)
  3. // 返回： [2, 3, 4, 5]

pop 删除尾部元素

  1. let arr =  [1, 2, 3, 4, 5]
  2. arr.pop(1)
  3. // 返回： [1,2, 3, 4]

splice 删除中间元素

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. arr.splice(1,2) // 开始位置 截取长度
  3. // 返回： [1, 4, 5, 6]
  5. arr.splice(1,2,22,33) // 修改中间元素  删除后 重新添加
  6. // 返回： [1, 22, 33, 4, 5, 6]

查

// 遍历数组的属性名 和 属性值

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. for(let i = 0; i< arr.length; i++){
  3. console.log(`${i} : ${arr[i]}`)
  4. }
  5. // 返回：
  6. // 0 : 1
  7. // 1 : 2
  8. // 2 : 3
  9. // 3 : 4
  10. // 4 : 5
  11. // 5 : 6

foreach 遍历

  1. let arr =  [1, 2, 3, 4, 5, 6]    
  2. arr.forEach(function(xxx,yyy){  //参数名字随便 第一个参数是值 第二个是属性名
  3.     console.log(`${yyy} : ${xxx}`)
  4.     })

用for循环

1： 可以使用 break 和continue 自定义循环

2： for循环是一个块级作用域

而 foreach

1：只能一头走到尾

2：是一个函数作用域

查看单个属性

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. arr.indexOf(055)
  3. // 返回： -1 不存在 1 存在在数组

使用条件查看元素

  1. arr.find((x)=>x%2 ===0) // 返回第一个偶数
  2. arr.findIndex((x)=>x%2 ===0) // 返回第一个偶数的索引

增

在尾部添加 arr.push

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. arr.push(66,77,88)
  3. arr
  4. // 返回：[1, 2, 3, 4, 5, 6, 66, 77, 88]

在头部添加 arr.unshift

  1. arr.unshift(22,55,66)
  2. arr
  3. // 返回：[22, 55, 66, 1, 2, 3, 4, 5, 6, 66, 77, 88]

在中间添加 arr.splice

  1. arr.splice(2,0,'x','y')
  2. arr
  3. // 返回： [22, 55, "x", "y", 66, 1, 2, 3, 4, 5, 6, 66, 77, 88]

反转数组 arr.reverse()

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. arr.reverse()
  3. // 返回：  [6, 5, 4, 3, 2, 1]

反转字符串

  1. var a  = 'abcde'
  2. a.split('').reverse().join('')
  3. // 返回：  "edcba"

排序 sort()

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. // 升序
  3. arr.sort(function (a, b) {
  4.             if (a > b) {
  5.                 return 1
  6.             } else if (a === b) {
  7.                 return 0
  8.             } else {
  9.                 return -1
  10.             }
  11.         })
  12.          // 简写
  13.         arr.sort((a, b) =>{
  14.             return a-b
  15.         }) 
  16. // 降序   
  17. arr.sort(function (a, b) {
  18.             if (a > b) {
  19.                 return -1
  20.             } else if (a === b) {
  21.                 return 0
  22.             } else {
  23.                 return 1
  24.             }
  25.         })
  26.         // 简写
  27.          arr.sort((a, b) =>{
  28.             return b-a
  29.         })

数组变换

map

n 变 n

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. arr.map(item => item *item)
  3. // 返回 : [1, 4, 9, 16, 25, 36]

filter

n 变少

  1. let arr =  [1, 2, 3, 4, 5, 6]
  2. arr.filter(item => item %2 ===0 ? true : false) // 返回偶数
  3. // 返回 :  [2, 4, 6]

reduce

n 变 1

  1.     arr.reduce((sum, item) => {
  2.             return sum + item
  3.         }, 0) // 算总和
  4. // 返回 ： 21
  6. // 只要偶数
  7.  arr.reduce((a1, a2) => {
  8.             if (a2 % 2 === 1) {
  9.                 return a1
  10.             } else {
  11.                 return a1.concat(a2)
  12.             }
  13.         }, [])
  14. // 返回 ：[2, 4, 6]

对象转数组

方法一：Array.from()

  1.         var a = {
  2.             0: '你好',
  3.             1: '不好',
  4.             'length': 2
  5.         }
  6.         var c = Array.from(a);
  7.         console.log(c);

小贴士：

  1. object中必须有length属性，返回的数组长度取决于length长度
  2. key 值必须是数值

方法二： Object.values() 获取键值

  1.         var a = {
  2.             0: '你好',
  3.             1: '不好' 
  4.         }
  5.         var c = Object.values(a)
  6.         console.log(c);

小贴士：

  1. 与第一种不同的是不需要length属性，返回一个对象所有可枚举属性值

方法三： Object.keys() 获取键名

  1.         var a = {
  2.             0: '你好',
  3.             1: '不好' 
  4.         }
  5.         var c = Object.keys(a)
  6.         console.log(c);

方法四：Object.entries()

  1.         var a = {
  2.             0: '你好',
  3.             1: '不好',
  5.         }
  6.         var c = Object.entries(a)
  7.         console.log(c);
  8.         //

返回一个给定对象自身可枚举属性的键值对数组

数组转对象

  1.         var list = {};
  2.         var arr = ["123", "456", "789"];
  3.         for (var key in arr) {
  4.             list[key] = arr[key];
  5.         }
  6.         console.log(list);