Javascript常用API

数组 (array)

const Arr = [10,4,2,7,3,6]

// map：遍历数组，返回回调返回值组成的新数组，不改变原数组，不会对空数组进行检测
Arr.map((item, index, array)=>index)  [0, 1, 2, 3, 4, 5]

// forEach：无法break，可以用try/catch中throw new Error来停止，不改变原数组
Arr.forEach((item, index, array)=>index) undefined

//filter：过滤，返回过滤后的数组，不改变原数组，不会对空数组进行检测
Arr.filter((item, index, array)=>item > 5)  [10, 7, 6]

//some：有一项返回true，则整体为true，不改变原数组
Arr.some((item, index, array)=>item > 5) true

//every ：需要全部符合条件才返回true，有一项返回false，则整体为false，不改变原数组
Arr.every((item, index, array)=>item > 5)

//join：返回通过指定连接符str把数组连接成字符串，不改变原数组
arr.join(',') '10,4,2,7,3,6'

//push / pop ：数组末尾推入push和弹出pop，返回改变后数组的长度/弹出项，改变原数组

Arr.push(100)  Arr：[10, 4, 2, 7, 3, 6,100]
Arr.pop()      Arr：[10, 4, 2, 7, 3, 6]

//unshift / shift：数组头部推入unshift和弹出shift，返回改变后数组的长度/弹出项，改变原数组
Arr.unshift(200)  Arr：[200,10, 4, 2, 7, 3, 6]
Arr.shift()       Arr：[10, 4, 2, 7, 3, 6]

//sort(fn) / reverse：按规则排序与反转，改变原数组
Arr.sort((a,b)=>a > b)  Arr:[2, 3, 4, 6, 7, 10]
Arr.reverse()           Arr:[10, 7, 6, 4, 3, 2]

//splice：返回删除元素组成的数组，从start处开始删除number个值后插入valueN参数列表到数组中，改变原数组
Arr.arr.splice(0,1)    Arr：[7, 6, 4, 3, 2]
Arr.splice(3,1,'小红') Arr：[7, 6, 4, '小红', 2]

//concat：连接n（n >= 2）个数组，返回数组连接后的数组副本，浅拷贝，不改变原数组
Arr.concat(Arr,['哈哈'])    [7, 6, 4, '小红', 2, '哈哈']

//slice：返回截断后的新数组，不改变原数组
Arr.slice(1,4)   [6, 4, '小红']

//indexOf(value,index) 返回数组中某个指定的元素位置。index查找开始索引位置 返回value对应的下标
Arr.indexOf(6)  1  
 
//astIndexOf(value,index) 返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。index查找开始索引位置
Arr.lastIndexOf(4) 2

//ES6
//Array.isArray(value) 判断是否是数组 是返回true否则返回false
Array.isArray(Arr) true
Array.isArray({})  false

//find *：返回符合条件的第一个数组元素item
Arr.find(f=>f>5)  7

//findIndex *：返回符合条件的第一个数组元素的索引
Arr.findIndex(f=>f>5)

//Array.includes(val, index)：用于从fromIndex判断数组中是否包含val，可替代ES5中的 indexOf
Arr.includes('小红') true

对象

//const obj = {age:12,name:'小红',phone:132456798}

// Object.keys() 遍历可枚举的属性，只包含对象本身可枚举属性，不包含原型链可枚举属性
Object.keys(Arr)  ['0', '1', '2', '3', '4']
Object.keys(obj)  ['age', 'name', 'phone']

// Object.values() 遍历可枚举的属性值，只包含对象本身可枚举属性值，不包含原型链可枚举属性值
Object.values(Arr)  [7, 6, 4, '小红', 2]
Object.values(obj)  [12, '小红', 132456798]

//assign Object.assign( target, source, source1 )  方法用于对象的合并，方法实行的是浅拷贝，而不是深拷贝。
const source1 = { b: 2, c: 2 };
const source2 = { c: 3 };
Object.assign(obj, source1, source2)   obj：{age: 12, name: '小红', phone: 132456798, b: 2, c: 3}

// Object.entries()  分割对象

Object.entries(obj)

[
  [
        "age",
        12
    ],
    [
        "name",
        "小红"
    ],
    [
        "phone",
        132456798
    ],
    [
        "b",
        2
    ],
    [
        "c",
        3
    ]
]
 
// 字符串 string 
Object.entries('小红')
[
    [
        "0",
        "小"
    ],
    [
        "1",
        "红"
    ]
]

// Object.is() 它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致

Object.is('obj', 'obj')      true
Object.is({}, {})            false
Object.is(NaN, NaN)         // true