数组操作

map

通过指定函数处理数组的每个元素，并返回处理后的数组。
map() 方法会将数组中元素依次传入方法中，并将方法的返回结果组成新数组返回。

传入的function可以有自己的三个形参，currentValue, index,arr分别代表当前元素，元素索引，元素所属数组对象；其中currentValue是必须的。

注意：map不会改变原数组，map不会检查空数组

filter

filter用于对数组进行过滤。
参数同map
它创建一个新数组，新数组中的元素是通过检查指定数组中符合条件的所有元素.
注意：filter()不会对空数组进行检测、不会改变原始数组

every

every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。
参数同map
every() 方法使用指定函数检测数组中的所有元素：

• 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
  如果所有元素都满足条件，则返回 true。

注意： every() 不会对空数组进行检测。
注意： every() 不会改变原始数组。

some

some 和every 正好相反：
参数同map

some方法会依次执行数组的每个元素；

• 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测
  如果没有满足条件的元素，则返回false

includes

includes() 的参数和上面几个有区别，它可以作为辅助函数判断数组中是否包含某个元素。
includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

sort

sort() 方法用于对数组的元素进行排序。
注释：该方法会改变原始数组。

arrayObject.sort(sortby)

var arr = [10,5,1000,25,1];

console.log(`arr:\n${arr}`);
//sort 在原数组的上修改顺序

console.log(`after sort arr1:\n${arr.sort()}`);  //1,10,1000,25,5

console.log(`after sort arr2:\n${arr.sort((a,b)=>{return a-b})}`);  //a-b 升序  1,5,10,25,1000

console.log(`after sort arr3:\n${arr.sort((a,b)=>{return b-a})}`);  //b-a 降序 1000,25,10,5,1

splice

splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
注释：该方法会改变原始数组。

arrayObject.splice(index,howmany,item1,…,itemX)

• index 必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
• howmany 必需。要删除的项目数量。如果设置为 0，则不会删除项目。
• item1, …, itemX 可选。向数组添加的新项目。

var arr = [1, 2, 3, 4, 5, 6];
arr.splice(2, 3); // [3, 4, 5]   删除第三个元素以后的三个数组元素
 
arr.splice(2, 0, 7, 8);  // []   在第三个元素之前插入7和8
arr; // [1, 2, 7, 8, 9]
 
arr.splice(2, 3, 9, 10);  // [7, 8, 9]  删除第三个元素以后的三个数组元素，并用9和10代替
arr;  // [1, 2, 9, 10]

indexOf

可返回某个指定的字符串值在字符串中首次出现的位置。

stringObject.indexOf(searchvalue,fromindex)

• searchvalue 必需。规定需检索的字符串值。
• fromindex 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

注释：indexOf() 方法对大小写敏感！
注释：如果要检索的字符串值没有出现，则该方法返回 -1。

类似的函数

** lastIndexOf() 方法可返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。**

join

join() 方法用于把数组中的所有元素放入一个字符串。

元素是通过指定的分隔符进行分隔的。

arrayObject.join(separator)

• separator 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

concat

concat() 方法用于连接两个或多个数组。

• 该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

arrayObject.concat(arrayX,arrayX,......,arrayX)

Object.entries Object.values

Object.entries()将一个对象中可枚举属性的键名和键值按照二维数组的方式返回，如果对象是数组，则会将数组的下标作为键值返回.
ES6中的 Object.keys() 返回的是键名，而 Object.values 则返回给定对象自己的所有可枚举属性值的数组，数组顺序，跟Object.entries()保持一致

Object.entries({ one: 1, two: 2 })    //[['one', 1], ['two', 2]]
Object.entries([1, 2])                //[['0', 1], ['1', 2]]

// === 若是键名是Symbol，编译时会被自动忽略 ====
Object.entries({[Symbol()]:1, two: 2})  //[['two', 2]]

// ==== entries()返回的数组顺序和for循环一样，即如果对象的key值是数字，则返回值会对key值进行排序====
Object.entries({ 3: 'a', 4: 'b', 1: 'c' })    //[['1', 'c'], ['3', 'a'], ['4', 'b']]

// === 利用Object.entries()创建一个真正的Map ===
var obj = { foo: 'bar', baz: 42 };

var map1 = new Map([['foo', 'bar'], ['baz', 42]]); //原本的创建方式
var map2 = new Map(Object.entries(obj));    //等同于map1

console.log(map1);// Map { foo: "bar", baz: 42 }
console.log(map2);// Map { foo: "bar", baz: 42 }

// === Object.keys() ===
Object.keys({ one: 1, two: 2 })  // ["one", "two"]
Object.keys({ 3: 'a', 4: 'b', 1: 'c' })  //  ["1", "3", "4"]

// === Object.values ===
Object.values({ one: 1, two: 2 })            //[1, 2]
Object.values({ 3: 'a', 4: 'b', 1: 'c' })    //['c', 'a', 'b']

应用

对象遍历

const users = {
    "5979942": {
        "uid": 5979942,
        "uname": "用户5979942",
        "ugender": 2
    },
    "5979945": {
        "uid": 5979945,
        "uname": "用户5979945",
        "ugender": 1
    },
    "5979946": {
        "uid": 5979946,
        "uname": "用户5979946",
        "ugender": 1
    }
}

console.log(`user:${JSON.stringify(users)}`);

//遍历方法1
console.log(`遍历方法1`);
for(let i in users){
    console.log(`i:${i},users[i]:${JSON.stringify(users[i])}`);
}

console.log(`遍历方法2`);
// 遍历方法2
Object.keys(users).map(v=>{console.log(`v:${v},info:${JSON.stringify(users[v])}`)})

数组应用

const actions = [
    {
        "uid": 5979946,
        "act": -1,
        "rate": 1,
        "time": 1596078572373,
        "delegated": false
    },
    {
        "uid": 5979942,
        "act": -1,
        "rate": 1,
        "time": 1596078575235,
        "delegated": false
    },
    {
        "uid": 5979945,
        "act": 1,
        "rate": 2,
        "time": 1596078578154,
        "delegated": false
    },
    {
        "uid": 5979945,
        "act": 3,
        "cards": [
            777,
            265,
            1033,
            515
        ],
        "rate": 2,
        "time": 1596078583879,
        "delegated": false
    }
]

console.log(`map:...................`)
actions.map( (v,i)=>{console.log(`i:${i},v:${JSON.stringify(v)}`)});

console.log(`filter:...................`)
let act1 = actions.filter((v,i)=>{return v.act > 0;})
console.log(`act1:${JSON.stringify(act1)}`);

console.log(`some:...................`)
let result = actions.some((v)=>{return v.act > 0})
console.log(`result:${result}`);

console.log(`every:...................`)
let result1 = actions.every((v)=>{return v.act > 0})
console.log(`result1:${result1}`);

数组差

let cards = [
    1035,
    270,
    779,
    526,
    1038,
    267,
    1033,
    772,
    1280,
    518,
    263,
    1037,
    1028,
    776,
    1036,
    782,
    780,
    265,
    777,
    515
];

const topCards =  [
    265,
    777,
    515
];


// 找到cards 中> 1000 的所有
let arr1 = cards.filter((value,index)=>{return value>1000});
console.log(`arr1:${arr1}`);

// 从cards 中删除topCards 的值
cards = cards.filter(v=>{return !topCards.includes(v)});
console.log(`cards:${cards}`)