JS面试题

最新推荐文章于 2024-08-28 08:53:32 发布

只用IE

最新推荐文章于 2024-08-28 08:53:32 发布

阅读量527

点赞数

分类专栏：大前端文章标签： js

本文链接：https://blog.csdn.net/weixin_46628546/article/details/110500727

版权

大前端专栏收录该内容

12 篇文章 0 订阅

订阅专栏

JS面试题

1.ES6的新特性：

let(声明变量)
const(声明常量,常量不能修改的量)
var、let、const的区别

let和const声明变量不存在变量提升，如果要使用这个变量，我们需要在变量定义之后使用;
let和const不能重复声明变量，如果重复声明会报错;
用let 和 const 在全局声明变量不会给window增加属性;
let和const出现在代码块中，会把代码块(字面量声明对象除外)变成块级作用域,并且出现暂时性死区 class(创建类)
import/export(基于ES6的模块规范创建导入/导出模块(文件/组件))
new set(数组去重)
Symbol(唯一的值) var a = Symbol(‘qqq’)
…ary(展开运算符、剩余运算符)
${} 模板字符串
解构赋值 let {a} = obj; let [b] = ary
for of 循环
()=>{} 箭头函数
箭头函数与普通函数的区别：
箭头函数是匿名函数，不能作为构造函数，不能使用new
箭头函数没有原型属性
3.this指向不同，箭头函数的this是定义时所在的对象，普通函数看前面有没有.,点前面是谁this 就是谁,没有.就是window
不可以使用arguments对象，该对象在函数体内不存在。
数组新增方法：flat、find、findIndex
对象新增方法： Object.assign() Object.values() Object.keys() Object.create()…

2. JS的语言特性

运行在客户端浏览器上；
不用预编译，直接解析执行代码；
是弱类型语言，较为灵活；
与操作系统无关，跨平台的语言；
脚本语言、解释性语言

3. JS数据类型

基本类型（单类型）：除Object。 String、Number、boolean、null、Symbol 、undefined。
引用类型：object。里面包含的 function、Array、Date。

4. 比较运算符

== 相对比较：会进行默认的类型转化；若转换之后的值相等，则结果就是true
=== 绝对比较，值不但要相同、类型也得相同。
引用数据类型之间的比较，就看是不是同一个地址；

5. JS作用域的理解

JS中的作用域分为两种：
全局作用域和函数作用域。
函数作用域中定义的变量，只能在函数中调用，外界无法访问。
没有块级作用域导致了if或for这样的逻辑语句中定义的变量可以被外界访问，
因此ES6中新增了let和const命令来进行块级作用域的声明。

  //循环绑定的问题
  for (var i = 0; i < 3; i++) {
    setTimeout(() => console.log(i), 1);// 3 3 3
  }
  for (let i = 0; i < 3; i++) {
    setTimeout(() => console.log(i), 1);// 0 1 2
  }

6. 闭包的理解

简单来说闭包就是在函数里面声明函数，本质上说就是在函数内部和函数外部搭建起一座桥梁，使得子函数可以访问父函数中所有的局部变量，但是反之不可以，这只是闭包的作用之一，另一个作用，则是保护变量不受外界污染，使其一直存在内存中，在工作中我们还是少使用闭包的好，因为闭包太消耗内存，不到万不得已的时候尽量不使用。

7. 原型及原型链

原型

函数都带有一个prototype 属性，这是属性是指向构造函数的原型对象，这个对象包含所有实例共享的属性和方法。
原型对象都有一个constructor 属性，这个属性指向所关联的构造函数。
每个对象都有一个__proto__ 属性[非标准的方法]，这个属性指向构造函数的原型 prototype
原型链
当访问实例对象的某个属性时，会先在这个对象本身的属性上查找，如果没有找到，则会通过 proto 属性去原型上查找，如果还没有找到则会在构造函数的原型的__ proto__中查找，这样一层层向上查找就会形成一个作用域链，称为原型链

8. new的执行过程

• 它创建了一个全新的对象
• 它会被执行[[Prototype]]（也就是__proto__）链接
• 它使this指向新创建的对象
• 通过new创建的每个对象将最终被[[Prototype]]链接到这个函数的prototype对象上
• 如果函数没有返回对象类型Object(包含Functoin, Array, Date, RegExg, Error)，那么new表达式中的函数调用将返回该对象引用

9. 数组去重

使用splice()方法与双层循环去除重复的元素
splice()方法用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是被删除的元素。

 let a = [2, 4, 1, 2, 4, 5, 9, 5];
 function b(a) {
     for (let i = 0; i < a.length; i++) {
         for (let j = i + 1; j < a.length; j++) {
             if (a[i] === a[j]) {
                 a.splice(j,1)
                 //j--;
             }
         }
     }
 }
 b(a)
 console.log(a); //[2, 4, 1, 5, 9]

使用indexOf()方法去除重复的元素
indexOf方法返回给定元素在数组中第一次出现的位置，返回结果是匹配开始的位置。如果没有出现则返回-1

var arr = [2, 4, 1, 2, 4, 5, 9, 5];
var newArr = [];
for (var i = 0, len = arr.length; i < len; i++) {
if (newArr.indexOf(arr[i]) == -1) {
newArr.push(arr[i]);
}
}
console.log(newArr);//[2, 4, 1, 5, 9]
使用set与Array.from()方法去除重复的元素
Array.from方法可以将 Set 结构转为数组。

var arr = [2, 4, 1, 2, 4, 5, 9, 5];
var newArr = Array.from(new Set(arr));
console.log(newArr);//[2, 4, 1, 5, 9]

10. 统计数组中每个元素的个数

var a = [1,1,2,3,4,5,5,6];
    function f(a) {
        var obj = {};
        for (let i = 0; i < a.length; i++) {
            var t = a[i];
            if (obj.hasOwnProperty(t)){
                obj[t] = obj[t]+1;
            }else{
                obj[t] = 1;
            }
        }
        return obj;
    }
    console.log(f(a));//{1: 1, 2: 2, 4: 2, 5: 2, 9: 1}

var n = [2, 4, 1, 2, 4, 5, 9, 5];
    var m = {}
    for (var i = 0; i < n.length; i++) {
        var v = n[i];
        var counts = m[v];
        if (counts) {
            m[v] += 1;
        } else {
            m[v] = 1;
        }
    }
    console.log(m)//{1: 1, 2: 2, 4: 2, 5: 2, 9: 1}

11.防抖

// 防抖 靠定时器
    function handleClick(e) {
        console.log("点击事件...")
    }
    function debounce(callback,delay){
        let that = this;
        let args = arguments;
        return function () {
            // 清除待执行的定时器任务
            if(callback.timeoutId){
                clearTimeout(callback.timeoutId)
            }
            callback.timeoutId = setTimeout(function () {
                callback.apply(that,args)
                delete callback.timeoutId;
            },delay)
        }
    }
    // 防抖  时间段内，最后一次执行才算数
    document.getElementById("debounce").onclick = debounce(handleClick,2000);

12.节流

function handleClick(e) {
// console.log(Date.now()) // 时间戳  时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总毫秒数
        console.log("点击事件...")
    }
    // 实现节点函数   // 前提是：频繁触发   节流目的： 每隔一断时间，执行一次
    function throttle(callback,delay){
        // 第1次点击 立即调用
        let start = 0;
        return function () {
            let current = Date.now();
            // console.log(current)
            if(current - start > delay){
                callback.apply(this,arguments)
                start = current;
            }
        }
    }
    document.getElementById("throttle").onclick = throttle(handleClick,1000);

13.数组的方法

1|0 join ()
join，就是把数组转换成字符串，然后给他规定个连接字符，默认的是逗号( ，)
　　书写格式：join(" ")，括号里面写字符串 (“要加引号”),

var arr = [1,2,3];
console.log(arr.join()); 　　　　// 1,2,3
console.log(arr.join("-")); 　　// 1-2-3
console.log(arr); 　　　　　　　　// [1, 2, 3]（原数组不变）

2|0 push()和pop()
push(): 把里面的内容添加到数组末尾，并返回修改后的长度。
pop()：移除数组最后一项，返回移除的那个值，减少数组的length。
　　　　书写格式：arr.push(" ")，括号里面写内容 (“字符串要加引号”),
　　　书写格式：arr.pop( )

var arr = ["Lily","lucy","Tom"];
var count = arr.push("Jack","Sean");
console.log(count); 　　　　　　　　　　// 5
console.log(arr); 　　　　　　　　　　　// ["Lily", "lucy", "Tom", "Jack", "Sean"]
var item = arr.pop();
console.log(item); 　　　　　　　　　　 // Sean
console.log(arr); 　　　　　　　　　　  // ["Lily", "lucy", "Tom", "Jack"]

3|0 shift() 和 unshift() (和上面的push，pop相反，针对第一项内容)
shift()：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 。
unshift:将参数添加到原数组开头，并返回数组的长度。
　　　　书写格式：arr.shift(" ")，括号里面写内容 (“字符串要加引号”),

var arr = ["Lily","lucy","Tom"];
var count = arr.unshift("Jack","Sean");
console.log(count); 　　　　　　　　　　　　　　// 5
console.log(arr); 　　　　　　　　　　　　　　　//["Jack", "Sean", "Lily", "lucy", "Tom"]
var item = arr.shift();
console.log(item); 　　　　　　　　　　　　　　// Jack
console.log(arr); 　　　　　　　　　　　　　　 // ["Sean", "Lily", "lucy", "Tom"]

4|0 sort()
sort()：将数组里的项从小到大排序
　　　书写格式：arr.sort( )

var arr1 = ["a", "d", "c", "b"];
console.log(arr1.sort()); 　　　　　　　　　　// ["a", "b", "c", "d"]
sort()方法比较的是字符串，没有按照数值的大小对数字进行排序，要实现这一点，就必须使用一个排序函数
function sortNumber(a,b)
{
　　return a - b
}
arr = [13, 24, 51, 3]; console.log(arr.sort()); 　　　　　　　　　　// [13, 24, 3, 51] 
console.log(arr.sort(sortNumber)); 　　　　// [3, 13, 24, 51](数组被改变)

5|0 reverse()
reverse()：反转数组项的顺序。
　　　书写格式：arr.reverse( )

var arr = [13, 24, 51, 3];
console.log(arr.reverse()); 　　　　　　　　//[3, 51, 24, 13]
console.log(arr); 　　　　　　　　　　　　　　//[3, 51, 24, 13](原数组改变)

6|0 concat()
concat() ：将参数添加到原数组中。这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。
　　　　书写格式：arr.concat()，括号里面写内容 (“字符串要加引号”),

var arr = [1,3,5,7];
var arrCopy = arr.concat(9,[11,13]);
console.log(arrCopy); 　　　　　　　　　　　　//[1, 3, 5, 7, 9, 11, 13]
console.log(arr); 　　　　　　　　　　　　　　// [1, 3, 5, 7](原数组未被修改)

7|0 slice()
slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。
　　　　书写格式：arr.slice( 1 , 3 )

var arr = [1,3,5,7,9,11];
var arrCopy = arr.slice(1);
var arrCopy2 = arr.slice(1,4);
var arrCopy3 = arr.slice(1,-2);
var arrCopy4 = arr.slice(-4,-1);
console.log(arr); 　　　　　　　　　　　　　　//[1, 3, 5, 7, 9, 11](原数组没变)
console.log(arrCopy); 　　　　　　　　　　　 //[3, 5, 7, 9, 11]
console.log(arrCopy2); 　　　　　　　　　　　//[3, 5, 7]
console.log(arrCopy3); 　　　　　　　　　　　//[3, 5, 7]
console.log(arrCopy4); 　　　　　　　　　　　//[5, 7, 9]

arrCopy只设置了一个参数，也就是起始下标为1，所以返回的数组为下标1（包括下标1）开始到数组最后。
　　arrCopy2设置了两个参数，返回起始下标（包括1）开始到终止下标（不包括4）的子数组。
　　arrCopy3设置了两个参数，终止下标为负数，当出现负数时，将负数加上数组长度的值（6）来替换该位置的数，因此就是从1开始到4（不包括）的子数组。
　　arrCopy4中两个参数都是负数，所以都加上数组长度6转换成正数，因此相当于slice(2,5)。
8|0 splice()
splice()：删除、插入和替换。
删除：指定 2 个参数：要删除的第一项的位置和要删除的项数。
　　　　书写格式：arr.splice( 1 , 3 )
插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。
　　　　书写格式：arr.splice( 2,0,4,6 )
替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。
　　　　书写格式：arr.splice( 2,0,4,6 )

var arr = [1,3,5,7,9,11];
var arrRemoved = arr.splice(0,2);
console.log(arr); 　　　　　　　　　　　　　　　//[5, 7, 9, 11]
console.log(arrRemoved); 　　　　　　　　　　　//[1, 3]
var arrRemoved2 = arr.splice(2,0,4,6);
console.log(arr); 　　　　　　　　　　　　　　　// [5, 7, 4, 6, 9, 11]
console.log(arrRemoved2); 　　　　　　　　　　// []
var arrRemoved3 = arr.splice(1,1,2,4);
console.log(arr); 　　　　　　　　　　　　　　　// [5, 2, 4, 4, 6, 9, 11]
console.log(arrRemoved3); 　　　　　　　　　　//[7]

9|0 indexOf()和 lastIndexOf()
indexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中，从数组的开头（位置 0）开始向后查找。
　　　　书写格式：arr.indexof( 5 )
lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中，从数组的末尾开始向前查找。
　　　　书写格式：arr.lastIndexOf( 5,4 )

var arr = [1,3,5,7,7,5,3,1];
console.log(arr.indexOf(5)); 　　　　　　//2
console.log(arr.lastIndexOf(5)); 　　　 //5
console.log(arr.indexOf(5,2)); 　　　　 //2
console.log(arr.lastIndexOf(5,4)); 　　//2
console.log(arr.indexOf("5")); 　　　　 //-1

10|0 forEach()
forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。
　　　　书写格式：arr.forEach()

var arr = [1, 2, 3, 4, 5];
arr.forEach(function(x, index, a){
console.log(x + '|' + index + '|' + (a === arr));
});
// 输出为：
// 1|0|true
// 2|1|true
// 3|2|true
// 4|3|true
// 5|4|true

11|0 map()
map()：指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
　　　　书写格式：arr.map()

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.map(function(item){
return item*item;
});
console.log(arr2); 　　　　　　　　//[1, 4, 9, 16, 25]

12|0 filter()
filter()：“过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。
　　　　书写格式：arr.filter()

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function(x, index) {
return index % 3 === 0 || x >= 8;
}); 
console.log(arr2); 　　　　　　　　//[1, 4, 7, 8, 9, 10]

13|0 every()
every()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。
　　　　书写格式：arr.every()

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
return x < 10;
}); 
console.log(arr2); 　　　　　　　　//true
var arr3 = arr.every(function(x) {
return x < 3;
}); 
console.log(arr3); 　　　　　　　　// false

14|0 some()
some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。
　　　　书写格式：arr.some()

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
return x < 3;
}); 
console.log(arr2); 　　　　　　　　//true
var arr3 = arr.some(function(x) {
return x < 1;
}); 
console.log(arr3); 　　　　　　　　// false

14. JS写斐波那契数列

斐波那契数，指的是这样一个数列：1、1、2、3、5、8、13、21、……在数学上，斐波那契数列以如下被以递归的方法定义：F0=0，F1=1，Fn=Fn-1+Fn-2（n>=2，n∈N*），用文字来说，就是斐波那契数列由 0 和 1 开始，之后的斐波那契数列系数就由之前的两数相加。　　
常用的计算斐波那契数列的方法分为两大类：递归和循环。
递归

function f (n) {
    if (n == 1 || n == 2) {
        return 1
    };
    return f (n - 2) + f (n - 1);
}
f(30)

循环
方法一：普通for循环

function f (n) {
    var n1 = 1, n2 = 1, sum;
    for (let i = 2; i < n; i++) {
        sum = n1 + n2
        n1 = n2
        n2 = sum
    }
    return sum
}
f (30)

方法二：for循环+解构赋值

var f= function (n) {
    let n1 = 1; n2 = 1;
    for (let i = 2; i < n; i++) {
        [n1, n2] = [n2, n1 + n2]
    }
    return n2
}
f (30)

15.深拷贝与浅拷贝

一、浅拷贝
对于浅拷贝而言，就是只拷贝对象的引用，而不深层次的拷贝对象的值，多个对象指向堆内存中的同一对象，任何一个修改都会使得所有对象的值修改，因为它们公用一条数据
二、深拷贝
我们在实际的项目中，肯定不能让每个对象的值都指向同一个堆内存，这样的话不便于我们做操作，所以自然而然的诞生了深拷贝
深拷贝作用在引用类型上！例如：Object，Array
深拷贝不会拷贝引用类型的引用，而是将引用类型的值全部拷贝一份，形成一个新的引用类型，这样就不会发生引用错乱的问题，使得我们可以多次使用同样的数据，而不用担心数据之间会起冲突

var obj1 = {
    a: 1,
    b: 2,
    c: 3
}
var obj2 = Object.assign({}, obj1);
obj2.b = 5;
console.log(obj1.b); // 2
console.log(obj2.b); // 5

16. promise

Promise是一个对象，保存着未来将要结束的事件，她有两个特征:
1、对象的状态不受外部影响，Promise对象代表一个异步操作，有三种状态，pending进行中，fulfilled已成功，rejected已失败，只有异步操作的结果，才可以决定当前是哪一种状态，任何其他操作都无法改变这个状态，这也就是promise名字的由来
2、一旦状态改变，就不会再变，promise对象状态改变只有两种可能，从pending改到fulfilled或者从pending改到rejected，只要这两种情况发生，状态就凝固了，不会再改变，这个时候就称为定型resolved,

17. 事件委托以及冒泡原理

事件委托是利用冒泡阶段的运行机制来实现的，就是把一个元素响应事件的函数委托到另一个元素，一般是把一组元素的事件委托到他的父元素上，委托的优点是
减少内存消耗，节约效率
动态绑定事件
事件冒泡，就是元素自身的事件被触发后，如果父元素有相同的事件，如onclick事件，那么元素本身的触发状态就会传递，也就是冒到父元素，父元素的相同事件也会一级一级根据嵌套关系向外触发，直到document/window，冒泡过程结束。