js常用的数组和对象的方法(后续待添加)

---

js常用的数组和对象的方法(后续待添加)

数组的方法

1.Array.map()

2.Array.foreach()

3.Array.filter()

4.Array.every()

5.Array.some()

6.Array.reduce()

7.Array.push()

8.Array.pop()

9.Array.shift()

10.Array.unshift()

11.Array.isArray()

12.Array.concat()

13.Array.toString()

14.Array.join()

15.Array.splice()

16.Array.slice()

17.Array.includes()

18.Array.indexOf()

19.Array.sort()

20.Array.fill()

21.str.charCodeAt()

//本章总结数组中的各种常用的方法
//1.map方法
//此方法是给数组中的每项数据都添加一个方法，结果作为一个新的数组返回，并不会改变原来的数组。
let arr = [1,3,4,5]
let arrCopy = arr.map(value => value *2)
console.log(arrCopy) //[ 2, 6, 8, 10 ]
console.log(arr) //[ 1, 3, 4, 5 ]

// 2.foreach方法
// 此方法是给数组的每一项数据循环添加一个方法，和map不同的是，forEach改变原数组，没有返回值。
let arr2 = [1,1,23,3]
arr2.forEach(function(value, item) {
    arr[item] = value * 10
})
console.log("2:",arr2)  //[ 10, 10, 230, 30 ]

// 3.filter 过滤大于2的数值
// 此方法类似于筛选向方法中传入一个判断条件，将满足条件的值变成一个新的数组返回。
let arr3 = [1,2,3,4,5]
let res3 = arr3.filter(item=> item > 2)
console.log(res3) //[ 3, 4, 5 ]
console.log(arr3)  //[ 1, 2, 3, 4, 5 ]

// 4. every函数 所有的值都满足条件返回true
// 此方法是将所有元素进行判断返回一个布尔值，如果所有元素都满足判断条件的话
// 则返回true，如果不满足就返回 false。遍历数组每一项，若全部为true，才返回true ,否则返回false
let arr4 = [1,2,3,4,5]
let res4 = arr.every(item=> item > 0)
console.log(res4)  //true
let resx4 = arr.every(item => item >1)
console.log(resx4) //false

// 5. Array.some()
// 此方法和every类似，唯一区别就是some遍历数组中的每一项，
// 若其中一项为true,则返回值是true，every遍历数组每一项，若全部为true，才返回true ,否则返回false。
let arr5 = [1,2,3,4,5]
let res5 = arr.some(item=> item > 6)
console.log(res5)  //false
let resx5 = arr.some(item => item >4)
console.log(resx5) //true

// 6.Array.reduce()
// reduce 为数组中的每一个元素依次执行回调函数，不包括数组中被删除或从未被赋值的元素，
// 接受四个参数：初始值（或者上一次回调函数的返回值），当前元素值，当前索引，调用 reduce 的数组。可以用来写求和求积。
let arr6 = [1,2,3,4,5]
let res6 = arr6.reduce((pre,item)=>pre+ item)
console.log(res6) //15 求和
let resx6 = arr6.reduce((pre,item)=>pre * item) 
console.log(resx6) //120  求积

// 7.Array.push()
// 此方法用来向数组末尾添加一个或多个元素，返回新增后数组的长度。
let arr7 = [1,2,3,4,5]
let length7 = arr7.push(6)
console.log(length7,arr7)//6 [ 1, 2, 3, 4, 5, 6 ]

// 8.Array.pop()
// 此方法删除数组中的最后一位元素，并返回数组，改变数组的长度。
let arr8 = [1,2,3,4,5]
let length8 = arr8.pop() 
console.log(length8,arr8) //5 [ 1, 2, 3, 4 ]

// 9.Array.shift()
// 此方法删除数组中的第一个元素，并返回数组，此方法会改变数组长度。
let arr9 = [1,2,3,4,5]
let length9 = arr9.shift()
console.log(length9, arr9) //1 [ 2, 3, 4, 5 ]

// 10.Array.unshift()
// 此方法向数组前添加一个或多个元素，并返回数组，此方法会改变数组长度。
let arr10 = [1,2,3,4,5]
let length10 = arr10.unshift(3,2,1,0)
console.log(length10, arr10) // 9 [3, 2, 1, 0, 1,2, 3, 4, 5]

// 11.Array.isArray()
// 此方法是用来判断一个对象是不是数组，是的话返回true，不是返回false。
let obj = {}
let arr11 =[1,2,3,4,5]
console.log(Array.isArray(arr11),Array.isArray(obj)) //true  false

// 12.Array.concat()
// 此方法是一个可以将多个数组合并成一个数组的方法。
let arr12 = [1,2,3,4,5]
let arrsub12 = [6,7,8,9]
let length12= arr12.concat(arrsub12)
console.log(arr12,length12) //[ 1, 2, 3, 4, 5 ] [1, 2, 3, 4, 5,6, 7, 8, 9]

// 13.Array.toString()
// 此方法是用来将数组转变为字符串格式。
let arr13 = [1,2,3,4,5]
let str = arr13.toString()
console.log("13:",str,typeof str) //1,2,3,4,5 string

// 14.Array.join()
// 此方法也是将数组转换为字符串，但和toString不同的是join可以设置元素之间的间隔。
let arr14 = [1,2,3,4,5]
let str14 = arr13.join('-')
console.log("14:",str14,typeof str14) //1-2-3-4-5 string

// 15.Array.splice(开始位置， 删除的个数，元素)
// 万能的方法可以实现数组的增、删、改。
// 删数组内的元素：
let arr15 = [1,2,3,4,5]
let res15 = arr15.splice(0,3)
console.log("15",res15 , arr15) //[ 1, 2, 3 ]  [ 4, 5 ]
let arrsub15 = [1,2,3,4,5]
let ressub15 = arrsub15.splice(1,0,6) //增加一个元素
console.log("15:",ressub15 , arrsub15) //[] [ 1, 6, 2, 3, 4, 5 ]

// 16.Array.slice()
// 此方法返回从原数组中指定开始下表到结束下表之间的项组成的新数组（原数组不变）截取数组。
let arr16 = [1,2,3,4,5]
let res16 = arr16.slice(0,3)
console.log("16:",arr16,res16)  //[ 1, 2, 3, 4, 5 ] [ 1, 2, 3 ]

// 17.Array.includes()
// 此方法用来判断数组中是否有传入的元素，有的话返回true，没有的话返回false。
let arr17 = [1,2,3,4,5]
let res17 = arr17.includes(1);
let ressub17 = arr17.includes(6)
console.log("17:",res17,ressub17) //true false

// 18.Array.indexOf()
// 从数组的开头向后查找，接受两个参数，要查找的项和查找起点的位置索引。
let arr18 = [1,2,3,4,5]
let res18 = arr18.indexOf(3,1)
console.log("18:",res18,arr18) //18: 2 [ 1, 2, 3, 4, 5 ]

// 19.Array.sort()
// 按指定的参数对数组进行排序，返回的值是经过排序后的数组（无参，函数）
let arr19 = [1,123,2,2,123,231,3,4,5]
let res19 = arr19.sort((a,b)=>a-b)
console.log("19:",res19) //19: [ 1,   2,   2,   3, 4, 5, 123, 123, 231]
let ressub19 = arr19.sort((a,b)=>b-a)
console.log("19:",ressub19) //19: [ 231, 123, 123, 5, 4, 3,   2,   2, 1]

// 20.Array.fill()
// 此方法用来替换数组中的元素，会改变原数组
// 。接受三个参数，第一个参数为替换的值，如果只传入一个值会吧数组中的值全部替换。
let arr20 = [1,2,3,4,5]
arr20.fill(1,3,5) //[ 1, 2, 3, 1, 1 ]
console.log("20:",arr20) 
let arrsub20 = [1,2,3,4,5]
console.log("20:",arrsub20.fill(1)) //[ 1, 1, 1, 1, 1 ]


// 21.str.charCodeAt()
// 字符串字符转化为数字
let ch ="a"
let resch = ch.charCodeAt()
console.log("21:",ch.charCodeAt(),typeof ch.charCodeAt() ,resch) //21: 97 number 97

对象的方法

1.Object.assign()

2.Object.is()

3.Object.keys()

4.Object.defineProperty()

5.Object.defineProperties()

6.Object.isPrototypeOf()

// {/* <>------------------------------------- */}
// {/* <>------------------------------------- */}
// {/* <>------------------------------------- */}

// 总结对象的方法
// 1.Object.assign()
// 此方法用于克隆对象，传入两个参数，
// 第一个参数为原对象，第二个参数为需要克隆的对象。会合并为一个新的对象，改变第一个参数的对象。

let obj1 = {name:"aodi",age:19}
let objsub1 = {sex:"man"}
let resobj1 = Object.assign(obj1,objsub1)
console.log("1:",resobj1)//1: { name: 'aodi', age: 19, sex: 'man' }

// 2.Object.is()
// 此方法是用来比较的接受两个参数，第一个参数是需要比较的第一个值，第二个参数是需要比较的第二个值。
// 返回值：布尔值，如果两个值相同返回true，不相同返回false。
// 注意，该函数与==运算符不同，不会强制转换任何类型，
// 应该更加类似于**===，但值得注意的是它会将+0和-0视作不同值**
let obj2 = 1;
let objsub2 = 1
let objsub22 = 3
console.log("2:",Object.is(obj2,objsub2),Object.is(objsub22,objsub2),) //true false

// 3.Object.keys()
// 此方法是用来获取对象的key值的。返回一个包含key值的数组。
let obj3 = {name:"aodi",age:19}
let rse3s= Object.keys(obj3)
console.log(rse3s) //[ 'name', 'age' ]

// 4.Object.defineProperty()
// defineProperty为设置对象的属性的属性特征 value设置属性名，enumerable设置该属性是否可以被枚举。未设置的枚举的属性不能被for in遍历和keys获取。
// 该方法接受三个参数，第一个参数为要加入属性的对象，第二个参数为属性的key值，第三个参数为一个对象。
let obj4 = {}
let objsub4 = {}
Object.defineProperty(obj4,"name",{
    value:"aodi",
    enumerable:true
})
console.log(obj4) //{ name: 'aodi' }
console.log(objsub4) //{}

// 5.Object.defineProperties()
// 可添加多个属性,与Object.defineProperty()对应。
let obj5 ={}
Object.defineProperties(obj5,{
    name:{
        value:"aodi",
        enumerable:true
    },
    age:{
        value:10,
        enumerable:true
    }
})
console.log(obj5) //{ name: 'aodi', age: 10 }

// 6.Object.isPrototypeOf()
// 此方法是用来检查一个对象是否存在另一个对象的原型链中。
function func(){}
let obj6 = new func()
console.log(Object.prototype.isPrototypeOf(obj6)) // true