var arrOld = [2, 3, 5, 4, 3, 2, 6, 8, 5, 4, 6, 2];
    var arrNew = [];
    var flag = true;
    for (var i = 0; i < arrOld.length; i++) {
      flag = true;
      for (var j = 0; j < arrNew.length; j++) {
        if (arrNew[j] == arrOld[i]) {
          flag = false;
        }
      }
      if (flag) {
        arrNew.push(arrOld[i]);
      }
    }
    console.log(arrNew);

2--indexOf()方法

function unique(arrOld) {
  var arrNew = [];
  for (var i = 0; i < arrOld.length; i++) {
    if (arrNew.indexOf(arrOld[i]) === -1) {
    arrNew.push(arrOld[i])
    }
  }
  return arrNew;
}

3--splice()方法

4--filter()方法

function unique(arrOld) {
  return arrOld.filter(function(item, index, arrOld) {
    return arrOld.indexOf(item,0) === index;
  });
}

5--includes()方法

function unique(arr) {
  if (!Array.isArray(arr)) {
    console.log('type error!')
    return
  }
  var array =[];
  for(var i = 0; i < arr.length; i++) {
    if( !array.includes( arr[i]) ) {
      array.push(arr[i]);
    }
  }
  return array
}

6--利用对象属性不能重复的特点

var arrOld = [2, 3, 5, 4, 3, 2, 6, 8, 5, 4, 6, 2];
var arrNew = [];
var obj = {};
for (var i = 0; i < arrOld.length; i++) {
  obj[arrOld[i]] = 1;
}
for (x in obj) {
  arrNew.push(Number(x));
}
console.log(arrNew);

7--利用Set结构成员不能重复的特点

function unique (arr) {
  return Array.from(new Set(arr))
}

8--利用Map结构成员不能重复的特点

9--拓展运算符 + Set

[...new Set(arr)]

数组深拷贝几种方式

for循环

var arr1 = [1, 2, 3];
var arr2 = [];
for (var i = 0; i < arr1.length; i++) {
    arr2.push(arr1[i]);
}
arr1[0] = 4;
console.log(arr1); //4, 2, 3
console.log(arr2); //1, 2, 3

slice方法

var arr1 = [1, 2, 3];
var arr2 = arr1.slice(0);
arr1[0] = 4;
console.log(arr1); //4, 2, 3
console.log(arr2); //1, 2, 3

concat方法

var arr1 = [1, 2, 3];
var arr2 = arr1.concat();
arr1[0] = 4;
console.log(arr1); //4, 2, 3
console.log(arr2); //1, 2, 3

扩展运算符

var arr1 = [1, 2, 3];
var [...arr2] = arr1;
arr1[0] = 4;
console.log(arr1); //4, 2, 3
console.log(arr2); //1, 2, 3

对象深拷贝几种方式

for...in...循环

使用JSON暴力转换

通过JSON.stringify() 和 JSON.parse() 将对象转为字符串之后在转为对象。

var obj = {name:'123'};

var obj2 = JSON.parse(JSON.stringify(obj))

这种简单粗暴的方式有局限性，当值为undefined、function、symbol会在转换过程中被忽略。

使用解构赋值

var obj = {name:'123',age:13};
var obj2 = {...obj}

只能深度拷贝对象的第一层，如果对象中的属性也是对象的话，没有办法进行深度拷贝的。

使用对象的合并

利用Object.assign(), 第一个参数必须是空对象

var obj = {name:'123',age:13};
var obj2 = Object.assign({},obj1);

只能深度拷贝对象的第一层，如果对象中的属性也是对象的话，没有办法进行深度拷贝的。

利用循环和递归的方式

function deepClone(obj, newObj) {
    var newObj = newObj || {};
    for (let key in obj) {
        if (typeof obj[key] == 'object') {
            newObj[key] = (obj[key].constructor === Array) ? [] : {}
            deepClone(obj[key], newObj[key]);
        } else {
            newObj[key] = obj[key]
        }
    }
    return newObj;
}

定时器有几种，有什么区别

两种,分别是 setTimeout 和 setInterval

区别

1--setTimeout隔一段时间之后执行,只执行一次; setInterval每个一段时间之后执行一次,执行多次

2--setTimeout用clearTimeout清;除setInterval用clearInterval清除

说下对Promise的理解

一、Promise是什么？

Promise是最早由社区提出和实现的一种解决异步编程的方案，比其他传统的解决方案（回调函数和事件）更合理和更强大。

ES6 将其写进了语言标准，统一了用法，原生提供了Promise对象。
ES6 规定，Promise对象是一个构造函数，用来生成Promise实例。

二、Promise是为解决什么问题而产生的？

promise是为解决异步处理回调金字塔问题而产生的

三、Promise的两个特点

1、Promise对象的状态不受外界影响

1）pending 初始状态

2）fulfilled 成功状态

3）rejected 失败状态

Promise 有以上三种状态，只有异步操作的结果可以决定当前是哪一种状态，其他任何操作都无法改变这个状态

2、Promise的状态一旦改变，就不会再变，任何时候都可以得到这个结果，状态不可以逆，只能由 pending变成fulfilled或者由pending变成rejected

四、Promise的三个缺点

        1）无法取消Promise,一旦新建它就会立即执行，无法中途取消
        2）如果不设置回调函数，Promise内部抛出的错误，不会反映到外部
        3）当处于pending状态时，无法得知目前进展到哪一个阶段，是刚刚开始还是即将完成

五、Promise的用法

1、Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，由 JavaScript 引擎提供，不用自己部署。

2、resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。

3、Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。

then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用。其中，第二个函数是可选的，不一定要提供。这两个函数都接受Promise对象传出的值作为参数

六、Promise.race()方法

Promise.all( )方法：接受一个数组作为参数，数组的元素是Promise实例对象，当参数中的实例对象的状态都为fulfilled时，Promise.all( )才会有返回。

//创建实例pro1
    let pro1 = new Promise(function(resolve){
        setTimeout(function () {
            resolve('实例1操作成功');
        },5000);
    });
    
    //创建实例pro2
    let pro2 = new Promise(function(resolve){
        setTimeout(function () {
            resolve('实例2操作成功');
        },1000);
    });

    
    Promise.all([pro1,pro2]).then(function(result){
        console.log(result);
    });
    //打印结果：["实例1操作成功", "实例2操作成功"]

Promise.all获得的成功结果的数组里面的数据顺序和Promise.all接收到的数组顺序是一致的，即p1的结果在前，即便p1的结果获取的比p2要晚。这带来了一个绝大的好处：在前端开发请求数据的过程中，偶尔会遇到发送多个请求并根据请求顺序获取和使用数据的场景，使用Promise.all毫无疑问可以解决这个问题。

我们执行某个操作，这个操作需要得到需要多个接口请求回来的数据来支持，但是这些接口请求之前互不依赖，不需要层层嵌套。这种情况下就适合使用Promise.all( )方法，因为它会得到所有接口都请求成功了，才会进行操作。

七、Promise.all()方法

Promise.race()方法：它的参数要求跟Promise.all( )方法一样，不同的是，它参数中的promise实例，只要有一个状态发生变化（不管是成功fulfilled还是异常rejected），它就会有返回，其他实例中再发生变化，它也不管了

//初始化实例pro1
    let pro1 = new Promise(function(resolve){
        setTimeout(function () {
            resolve('实例1操作成功');
        },4000);
    });

    //初始化实例pro2
    let pro2 = new Promise(function(resolve,reject){
        setTimeout(function () {
            reject('实例2操作失败');
        },2000);
    });

    Promise.race([pro2,pro1]).then(function(result){
        console.log(result);
    }).catch(function(error){
        console.log(error);
    });
    //打印结果：实例2操作失败

由于pro2实例中2000毫秒之后就执行reject方法，早于实例pro1的4000毫秒，所以最后输出的是：实例2操作失败。

说下对模块导入导出的理解

模块化的初衷

现在的web系统越来越庞大、复杂，需要团队分工，多人协作，大型系统的javascript文件经常存在复杂的依赖关系，后期的维护成本会越来越高。

JavaScript模块化正式为了解决这一需求而诞生。

1--导出: 选择性地给其他模块暴露（提供）自己的属性和方法，供其他模块使用。

2--导入: 可以根据需要，引入其他模块的提供的属性或者方法，供自己模块使用。

3--批量导出: export {name,age} 批量导入import {name,age} from “url”;

4--整体导入: import * as obj from “url” 变量作为obj的属性

5--重命名导出入的变量：import {旧名字 as 新名字} from “url”;

6--默认导出：export default 变量 (导出没有名字的变量，只能有一个)

7--在导入时 import 自定义名 from ”url” 自定义名字不用大括号包住

8--注意

1. 声明的变量，对外都是只读的。但是，如果模块B导出的是对象类型的值，就可修改。

2. 导入不存在的变量，会报错。

箭头函数和普通函数的区别

1--箭头函数更简洁，不需要function，需要在()后加=> 如果只有一个参数可以省略()，如果函数只有一个return语句，可以省略return 和 {}

2--箭头函数都是匿名函数，普通函数有匿名函数和具名函数

3--箭头函数没有arguments，caller，callee；普通函数调用后会有argument对象

4--箭头函数不能作为构造函数，不能使用new；普通函数可以作为构造函数创建对象实例

5—箭头函数没有原型prototype属性

6--箭头函数的this永远指向父作用域，箭头函数通过call和apply调用，不会改变this指向，只会传入参数。普通函数的this指向可以通过call和apply改变。

7--箭头函数不能作为Generator函数，不能使用yield关键字

8--箭头函数返回对象时，要加一个小括号

9--箭头函数在ES6 class中声明的方法为实例方法，不是原型方法

Js实现约瑟夫环问题（m个人留1个或者留n-1个）

数组方法

         function countOff(num, m) {

      let players = [];

      for (let i = 1; i <= num; i++) {

        players.push(i);

      }

      let flag = 0;

      while (players.length > 1) {

        // 剩下一人，结束条件

        let outPlayerNum = 0,

          len = players.length;

        for (let i = 0; i < len; i++) {

          flag++;

          if (flag === m) {

            flag = 0;

            console.log("出局：" + players[i - outPlayerNum]);

            players.splice(i - outPlayerNum, 1);

            outPlayerNum++;

          }

        }

      }

      console.log("剩下：" + players[0]);

    }

递归方法

function countOff(N, M) {

      if (N < 1 || M < 1) {

        return;

      }

      let source = [];

      for (let i = 1; i <= N; i++) {

        source.push(i);

      }

      // const source = Array(...Array(N)).map((_, i) => i + 1);

      let index = 0;

      while (source.length > 1) {

        // 剩下一人，结束条件

        index = (index + M - 1) % source.length;

        console.log("出局：" + source[index]);

        source.splice(index, 1);

      }

      console.log("剩下：" + source[0]);

    }