<<Nodejs>> 一些方法总结备份1

<<循环中等待异步>>

function setAgvList() {
  const commonAgv = async() => {
    for (var agvCount = 0; agvCount < groupConst.ScheduleConfig.MaxAgvCount; agvCount++) {
      var agvName = await agvMissStatus.getRobotByIndex(agvCount)
      var agvStatus = {
        robotIndex: agvCount,
      }
      GParamGroup.UseAgvList.push(agvStatus)
    }
    console.log(‘---------UseAgvList---------‘)
    console.log(GParamGroup.UseAgvList)
  }
  commonAgv()
}

<<数组去重>>

数组去重的方法
function dedupe(array) {
  return [...new Set(array)]
}
var arr = [1,2,2,3,3,4,4,5,5]
console.log(dedupe(arr))

<<深拷贝>>

1（在nodeJS项目中，有一个lodash模块，我们可以利用它提供的方法来实现深度克隆，或者将其下载到本地，引入它对应的js文件也可如下）
lodash中文网 https://www.lodashjs.com/docs/latest

const cloneDeep = require(‘lodash/clonedeep‘)
// スケジュールステータス初期化
function setScheduleList() {
  for (var index = 0; index < groupConst.ScheduleConfig.ScheduleMaxRunCount; index++) {
    // 深いCopy
    GParamGroup.ScheduleObj.missionParams = cloneDeep(missionParams)
    var obj = cloneDeep(GParamGroup.ScheduleObj)
    obj.index = index
    GParamGroup.ScheduleList.push(obj)
    GParamGroup.changeMainState(index, GStatus.GMainState.GStart)
  }
  console.log(‘ScheduleList ‘, GParamGroup.ScheduleList)
}

方法2（JSON.parse和JSON.stringify）
async function bAgvMoveEvNode (missionModuleParam) {
  mModuleParam = JSON.parse(JSON.stringify(missionModuleParam))
  startFlow()
}

// 3. 构造一个深拷贝函数
function deepClone(obj) {
    var result = Array.isArray(obj) ? [] : {}; // 判断当前传进来的是对象还是数组
    for(var key in obj) {
        if (obj.hasOwnProperty(key)) { // 该key是否存在
            if (typeof obj[key] === ‘object‘ && obj[key] !== null) { // obj[key]如果为object,递归调用该方法，obj[key] = arr || obj[key] = {}都为‘object‘
                result[key] = deepClone(obj[key]);
            } else {
                result[key] = obj[key];
            }
        }
    }
    return result;
}

4 遍历实现数组的多层深拷贝
var arr = [1,2,3,4,5]
var arr2 = copyArr(arr)
function copyArr(arr) {
    let res = []
    for (let i in arr) {
     res.push(arr[i])
    }
    return res;
}

<<浅拷贝>>

浅拷贝，双向改变,指向同一片内存空间

1 直接赋值
var arr1 = [1, 2, 3];
var arr2 = arr1;
arr1[0] = ‘change‘;
console.log(‘shallow copy: ‘ + arr1 + " );   //shallow copy: change,2,3
console.log(‘shallow copy: ‘ + arr2 + " );   //shallow copy: change,2,3

所以把它放在深拷贝里，是因为它看起来像是深拷贝。而实际上它是浅拷贝。原数组的元素会按照下述规则拷贝：·

如果该元素是个对象引用 （不是实际的对象），slice 会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数组中的这个元素也会发生改变。

对于字符串、数字及布尔值来说（不是 String、Number 或者 Boolean 对象），slice 会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响另一个数组。

1.slice 方法实现数组的单层深拷贝
将原数组中抽离部分出来形成一个新数组。我们只要设置为抽离全部，即可完成数组的深拷贝。代码如下：
var arr = [1,2,3,4,5]
var arr2 = arr.slice(0)
arr[2] = 5
console.log(arr)
console.log(arr2)

2 concat 方法实现数组的一层深拷贝
原理更加粗暴 它是用于连接多个数组组成一个新的数组的方法。那么，我们只要连接它自己，即可完成数组的深拷贝。代码如下：
var arr = [1,2,3,4,5]
var arr2 = arr.concat()
arr[2] = 5
console.log(arr)
console.log(arr2)

如果向两个数组任一中添加了新元素，则另一个不会受到影响。例子如下：

var array = [1,2,3];
var array_shallow = array;
var array_concat = array.concat();
var array_slice = array.slice(0);
console.log(array === array_shallow); //true
console.log(array === array_slice); //false，“看起来”像深拷贝
console.log(array === array_concat); //false，“看起来”像深拷贝
可以看出，concat和slice返回的不同的数组实例，这与直接的引用复制是不同的。而从另一个例子可以看出Array的concat和slice并不是真正的深复制，数组中的对象元素(Object,Array等)只是复制了引用。如下：

var array = [1, [1,2,3], {name:"array"}];
var array_concat = array.concat();
var array_slice = array.slice(0);
array_concat[1][0] = 5;  //改变array_concat中数组元素的值
console.log(array[1]); //[5,2,3]
console.log(array_slice[1]); //[5,2,3]
array_slice[2].name = "array_slice"; //改变array_slice中对象元素的值
console.log(array[2].name); //array_slice
console.log(array_concat[2].name); //array_slice

原文地址：https://www.cnblogs.com/liusj/p/12375984.html