总结数组常用的属性和方法

总结数组的常用属性和方法

一.常用属性length

​ length属性用于获取或者设置数组的长度

// 获取数组长度
var arr = [1,2,3,4]
console.log(arr.length)  ------> 4

// 设置数组长度
var arr = []
console.log(arr.length)  ------> 0
arr.length = 5
console.log(arr.length)  ------> 5
console.log(arr) ------> [empty × 5]

二.常用的方法

1. concat(arr1,arr2,....arrn)连接两个或更多的数组，并返回结果。

var a = [1,2,3]
var b = [4,5,6]
var c = [7,8,9]
a.concat(c,b)------->[1, 2, 3, 7, 8, 9, 4, 5, 6]
a.concat(c,("yyy"))------->[1, 2, 3, 7, 8, 9, "yyy"]

2. join(separator)其中参数separator可选，表示需要使用的分隔符，可不传，默认使用逗号作为分隔符。

var a = [1,2,3]
a.join()------>'1,2,3'
a.join("")------>'123'
a.join("/")------>'1/2/3'

3. pop()和push()

   其中pop是删除数组的最后一个元素并返回删除元素，而push是向数组末尾插入一个元素，返回插入元素后数组新的长度，两个方法都是操作原数组

   如果数组已经为空，则pop() 不改变数组，并返回 undefined值。

var a = [1,2,"pop"]
a.pop()------>pop
[].pop()------>undefined
a---------------->[1, 2]
a.push("push")------>3
a---------------->[1, 2, "push"]

3. shift()和unshift()

   其中shift是删除数组的第一个元素并返回删除元素，而unshift是向数组开头插入一个元素，返回插入元素后数组新的长度，两个方法都是操作原数组

   如果数组已经为空，则shift() 不改变数组，并返回 undefined值。

var a = [1,2,"pop"]
a.shift()------>1
[].shift()------>undefined
a---------------->[2, "pop"]
a.unshift("unshift")------>3
a----------------> ["unshift", 2, "pop"]

4. reverse(),颠倒数组元素的顺序，操作原数组

var a = [1,2,3]
a.reverse()------->[3, 2, 1]

5. slice(start,end)，用于截取数组，start表示截取的起始位置end表示截取的结束位置，start/end都是表示数组的下标，左闭右开，该方法是创建新数组，不改变原数组

   start/end如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。

var a = [1,2,3,4,5,6,7,8]
a.slice(2,4) ------> [3,4]
a.slice(-6,-4)------->[3,4]

6. splice(index,num,item1,item2,...itemn)，删除元素，并向数组添加新元素。

   其中index规定添加/删除元素的位置，使用负数可从数组结尾处规定位置。

   num要删除的项目数量。如果设置为 0，则不会删除项目。

   itemn向数组添加的新元素。

   修改原数组

var a = [1,2,3,4,5,6]
a.splice(2,3)
a------>[1, 2, 6]
a.splice(2,0,"yy","mm","xx")
a-----> [1, 2, "yy", "mm", "xx", 6]

7. sort(fn)，参数是一个函数

// 按照字符编码的顺序进行排序
var a = [100,1,20,5,4,10,304,"A"]
a.sort()------->[1, 10, 100, 20, 304, 4, 5, "A"]

// 标准进行排序，就需要自己实现比较函数sortNumber
function sortNumber(a,b){
    return a-b
}
var b = [100,1,20,5,4,10,304]
b.sort(sortNumber)------->[1, 4, 5, 10, 20, 100, 304]

8. toString()和toLocaleString()前者把数组转换为字符串，并返回结果，后者把数组转换为本地数组，并返回结果。

var a = [1,2,3,4,"ymx"]
a.toString()------>"1,2,3,4,ymx"
a.toLocaleString()------>"1,2,3,4,ymx"

9. reduce(cb,initvalue)和reduceRight(cb,initvalue)， 第一个参数是函数cb，函数cb作为累加器 ，数组中的每个值开始合并 ，第二个参数是初始值

   reduceRight()方法的功能和reduce()功能是一样的，不同的是reduceRight()从数组的末尾向前将数组中的数组项做累加

var a =  [1, 3, 4, 6, 8, 9, 3, 5, 6]
// 返回所有元素的总和
a.reduce((pre,cur) => { return pre+cur },0) ---------->45

// 返回奇数项数组
const a1 = a.reduce((pre,cur) => {
    console.log(pre,cur)
    pre的初始值(参数二)--------->[] 1
                    --------->[1] 3
                    --------->[1, 3] 4
                    --------->[1, 3] 6
                    --------->[1, 3] 8
                    --------->[1, 3] 9
                    --------->[1, 3, 9] 3
                    --------->[1, 3, 9, 3] 5
                    --------->[1, 3, 9, 3, 5] 6
    if(cur%2){
        pre.push(cur)
    }
    return pre
},[])
a1 -------------> [1, 3, 9, 3, 5]
a------------->[1, 3, 4, 6, 8, 9, 3, 5, 6]

10. indexOf和lastIndexOf

    其中indexOf返回从左开始数组的下标，lastIndexOf返回从右开始数组的下标，找不到匹配的元素则返回-1

var a = [1,2,3,45,1,4,6]
a.indexOf(1)------>0
a.indexOf("mmm")------>-1
a.lastIndexOf(1)------>4
a.lastIndexOf("yyy")------>-1

11. map和forEach，遍历数组的方法，其中map会有返回新数组，不操作原数组，every没有返回值

var mapa = a.map(each => each + 2)
a--------> [1, 2, 3, 45, 1, 4, 6]
mapa------->[3, 4, 5, 47, 3, 6, 8]

var mapa = a.forEach(each => each + 2)
a--------> [1, 2, 3, 45, 1, 4, 6]
mapa------->undefined

12. some/every /find/includes

    其中some用于验证数组里面是否存在一项元素满足条件，返回布尔值

    其中every 用于验证数组里面所有的元素是否满足条件，返回布尔值

    其中find查找数组里面符合条件的第一个元素，返回满足条件的第一个元素

    其中includes数组里面是否包含某个元素条件，返回布尔值

var a = [1,2,3,45,1,4,6]
// 查看数组里面是否存在一项为1
a.some(each =>each === 1) -----> true
// 查看数组里面是否所有元素都是1
a.every(each =>each === 1) -----> false
// 数组里面是否有大于2的元素，并返回第一个满足条件的元素
a.find(each =>each > 2) -----> 3
// 数组里面是否包含元素3
a.includes(3)------->true
// 数组里面是否包含元素33
a.includes(33)------->false

13. filter，数组的过滤，过滤出满足数组条件的元素，创建出新的数组，不操作原数组

var a = [1,3,4,6,8,9,3,5,6]
// 筛选出奇数元素
var afilter = a.filter(each => each%2 === 1) -------->[1, 3, 9, 3, 5]
a-------->[1, 3, 4, 6, 8, 9, 3, 5, 6]

14. from，将一个类数组对象或者可遍历对象转换成一个真正的数组。

    要将一个类数组对象转换为一个真正的数组，必须具备以下条件：

    1、该类数组对象必须具有length属性，用于指定数组的长度。如果没有length属性，那么转换后的数 组是一个空数组。

    2、该类数组对象的属性名必须为数值型或字符串型的数字

    ps: 该类数组对象的属性名可以加引号，也可以不加引号

let arrayLike = {
    0: 'ymx', 
    "1tyty": '25',
    "2": '女'
    3: ['yy','mm','xx'],
    'length': 4
}
let arr = Array.from(arrayLike)------ ["ymx", undefined, "女",  ["yy", "mm", "xx"]]

15. flatMap()和flat()多维数组拉平

    其中flatMap()只能展开一层数组。

    其中flat()默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想要拉平的层数，默认为1。

    如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。

[1, 2, [3, 4]].flat() ------------>[1, 2, 3, 4]
[1, 2, [3, [4, 5]]].flat()------------>[1, 2, 3, [4, 5]]
[1, 2, [3, [4, 5]]].flat(2)-------------->[1, 2, 3, 4, 5]
[1, 2, [3, [4, [5]]]].flat(Infinity)-------------->[1, 2, 3, 4, 5]