代码编织梦想

目录

js数据类型有哪些

基本数据类型

引用数据类型

内置对象有哪些

数组方法有哪些    

数组去重几种方式

        1--双重for循环

        2--indexOf()方法

        3--splice()方法

        4--filter()方法

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

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

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

数组深拷贝几种方式

        1--for循环

        2--slice方法

        3--concat方法

        4--扩展运算符

对象深拷贝几种方式

        1--for...in...循环

        2--利用JSON,先转JSON字符串在转JSON对象

        3--扩展运算符

        4--Es6中的Object.assign方法

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

区别

说下对Promise的理解

一、Promise是什么?

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

三、Promise的两个特点

四、Promise的三个缺点

五、Promise的用法

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

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

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

数组方法

递归方法

数组排序的几种写法

数组排序方法sort()排序

冒泡排序(两层循环,两两交换)

选择排序

插入排序


js数据类型有哪些

基本数据类型

        Number 数字类型

        String 字符串类型

        Boolean布尔类型

        undefined未定义

        null 空型

        Symbol 唯一值

引用数据类型

        数组

        函数

        对象

        Set

        Map

内置对象有哪些

        Math:数学对象,数学和函数相关的

        Date:日期对象,处理日期和时间

        Array:数组对象

        String:字符串对象

数组方法有哪些    

        1--unshift------添加元素,在数组最前边添加,返回数组的长度

        2--shift------删除元素,在数组最前边删除,返回删除的元素

        3--reverse------翻转数组,返回一个新数组,会改变原来的数组

        4--sort------排序,默认从大到小排序,改变原来的数组

        5--concat------拼接,如果参数是数组,则拼接数组;如果参数是非数组,在末尾添加元素。返回新数组,原数组不变

        6--slice(start,end)------截取,从索引start开始截取,到end结束,包括start不包括end,原数组不变

        7--splice(start,length)------截取,从索引start截取length个元素,原数组改变

        8--indexOf------查询某元素的索引,从前往后查找第一次出现的索引,没有返回-1

        9--lastIndexOf------查询某元素的索引,从后往前查找第一次出现的索引,没有返回-1

        10--join------转化,通过指定分隔符连接数组所有元素,返回字符串,默认用逗号分隔

        11--forEach------遍历数组,没有返回值

        12--some-----判断元素是否满足条件,有一个满足就返回true,都不满足返回false

        13--every-----判断元素是否满足条件,都满足就返回true,有一个不满足返回false

        14--map-----用于数学计算,返回数组

        15--filter------过滤元素,过滤出符合条件的元素,返回数组

数组去重几种方式

        1--双重for循环

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;
}

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

两种,分别是 setTimeoutsetInterval

区别

        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]);

    }

数组排序的几种写法

数组排序方法sort()排序

冒泡排序(两层循环,两两交换)

选择排序

         首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置。

        再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

        重复第二步,直到所有元素均排序完毕。

插入排序

        将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。

        从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/Wr2138/article/details/127975296

20个ES6面试高频问题-爱代码爱编程

“关注  前端开发社区 ,回复“ 1” 即可加入  前端技术交流群,回复  “ 2” 即可免费领取500G前端干货!   原文 | dev.to/fullstackca 译文 | https://juejin.im/post/5dc8a231f265da4d40712f8a ECMAScript 6(以下简称ES6)是 JS 语言的下一代标准,已

JS高频面试题-爱代码爱编程

JS 文章目录 JS数据类型什么是基本数据类型?什么是引用数据类型?以及各个数据类型是如何存储的?(5星)类型转换在JS中为什么0.2+0.1>0.3?(4星)为什么0.2+0.3=0.5呢?(4星)既然0.1不是0.1了,为什么在console.log(0.1)的时候还是0.1呢?(3星)为什么typeof null是Object?(4星

2021高频前端面试题(含答案)-爱代码爱编程

一、简单页面 1、CSS选择器样式优先级2、CSS实现三列布局(左右固定宽度,中间自适应) (1)CSS浮动 第一个float:left,第二个float:right,第三个设置margin-left和margin-right (2)绝对定位法 第一个定位到left,第二个定位到right,第三个设置margin-left和margin-right (3

11、前端面试必考:ES6之promise详解 和 高频面试题-爱代码爱编程

阮一峰博客 :https://es6.ruanyifeng.com/#docs/promise 目录 一、学习promise的前置条件 1.1 区别实例对象和函数对象 1.2 两种类型的回调函数 1.2.1 同步回调 1.2.2 异步回调 1.3 JS中的error处理(错误处理) 1.3.1 常见的内置错误 1.3.2 错误的处理 1

js面试题 高频 2021.6月底 最新整理 含答案-爱代码爱编程

整理不易,赏个三连吧 1. 讲一下 var、let、const 的区别? var 声明的变量有变量提升的特性,而 let、const 没有 var 声明的变量会挂载到 windows 对象上,所以使用 var 声明的是全局变量,而 let 和 const 声明的变量是局部变量, 块级作用域外不能访问 同一作用域下 let 和 const 不能重复声明

ES6高频面试题-爱代码爱编程

Es6高频面试题 1、var、let 及 const 区别2、Set与Map3、模块化4、Class5、Proxy6、map、fillter、reduce 各自有什么作用 1、var、let 及 const 区别 涉及面试题:什么是提升?什么是暂时性死区?var、let 及 const 区别? var声明的变量会挂载在window上,而le

JavaScript高频面试题-爱代码爱编程

JavaScript 高频面试题2021 1. js数据类型、typeof 、instanceof2. 闭包3. 原型、原型链4. this指向5. 作用域、作用域链、变量提升6. 继承(ES6 extends 、 组合继承 )7. 普通函数 和 箭头函数的区别8. 有哪些内置对象9. JSON 与 XML10. ES6新增11. 浅拷贝和深拷贝浅

es6高频面试题-爱代码爱编程

1、es5和es6的区别,说一下你所知道的es6 ECMAScript5,即ES5,是ECMAScript的第五次修订,于2009年完成标准化ECMAScript6,即ES6,是ECMAScript的第六次修订,于2015年完成,也称ES2015ES6是继ES5之后的一次改进,相对于ES5更加简洁,提高了开发效率ES6新增的一些特性: 1. let声明

JavaScript前端经典面试题之ES6面试题汇总es6-爱代码爱编程

1、es5和es6的区别,说一下你所知道的es6 ECMAScript5,即ES5,是ECMAScript的第五次修订,于2009年完成标准化 ECMAScript6,即ES6,是ECMAScript的第六次修订,于2015年完成,也称ES2015 ES6是继ES5之后的一次改进,相对于ES5更加简洁,提高了开发效率 ES6新增的一些特性

es6常见面试题-爱代码爱编程

什么是ecmascript ECMAScript 是由 Ecma 国际通过 ECMA-262 标准化的脚本程序设计语言 为什么要学习es6   ES6 的版本变动内容最多,具有里程碑意义ES6 加入许多新的语法特性,编程实现更简单、高效ES6 是前端发展趋势,就业必备技能目前市场主流前端js框架都是采用ES6的语法 let关键字

完整的es6面试题_想学好前端的小宝的博客-爱代码爱编程

let、const、var的区别 变量提升 var 声明的变量存在变量提升,即变量可以在声明前调用,值为 undefined。 let 和 const 不存在变量提升,变量一定要声明之后才能使用,否则会报错。 暂时性死区 var 不存在暂时性死区 let 和 const 存在暂时性死区,只有等到声明变量的那一行代码出现,才可以获取

es6 promise 理解(高频面试题)_老胡说前端的博客-爱代码爱编程

概述: 是一种异步解决方案,解决了地狱回调问题 特点: 三种状态:pending(进行中),fulfilled(已成功)和rejected(已失败)          只有pending变为fulfilled 和 pending变为rejected状态改变          只要处于fulfilled和rejected状态就不会再变了。 实例:

es6面试题总结最全_是张鱼小丸子鸭的博客-爱代码爱编程

说一下var、let、const之间的区别? var: var声明的变量既是全局变量,也是顶层变量(顶层对象,在浏览器环境下指的是window对象,在node中指的是global对象) var存在变量提升,可以对一个变量进行多次声明,后面声明的变量会覆盖前面的变量声明 在函数中使用var声明变量,变量是局部的,如果在函数内不使用var,那么这个变量

vtk的对象模型_sylarxillee的博客-爱代码爱编程

可以将VTK对象模型视为继承自超类vtkObject。几乎所有VTK类都派生自该类,某些特殊情况下派生自其超类vtkObjectBase。所有VTK都必须使用对象的New()方法创建,并且必须使用对象的Delete()方法销毁。无法在堆栈上分配VTK对象,因为构造函数是protected方法。使用一个通用的超类和创建和销毁对象的统一方法,VTK提供面向对象

js和es6高频面试题总结_49021391的博客-爱代码爱编程

一、js数据类型有哪些 基本类型:数字类型(NUMBER)、字符串类型(String)、布尔类型(Boolean)、空型(null)、未定义型(undef)、唯一值型(symbol) 引用数据类型:数组、函数、对象、set、map 二、内置对象有哪些 内置对象:数学对象Math、日期对象new Data()、数组对象new Arr

python实现全自动输入文本_予人三的博客-爱代码爱编程

文章目录 1. 效果图2. 示例代码3. 代码解释 1. 效果图 该Python脚本可以实现自动用Notepad++打开文本文件,然后自动输入文本,最后保存并关闭文件,从而实现全面自动化处理文本。 2.

vue+网络协议+webpack高频面试题_webpack打包vue项目面试-爱代码爱编程

文章目录 Vuevue的优点是什么?vue生命周期(重要)created和mounted的区别(重点)什么是 MVVM?双向数据绑定原理(重点)vue自定义指令vue自定义组件Vue组件之间的的通信(传值)方式

js高频面试题_js高级面试题-爱代码爱编程

一、延迟加载JS有哪些方式? 延迟加载:async、defer 例如:<script defer type="text/javascript" src='script.js'></script> defer : 等html全部解析完成,才会执行js代码,顺次执行js脚本。 async : async是和html解析同步的(