2024年JavaScript面试总结查错、复习(1)，web前端面试自我介绍简单大方-CSDN博客

本文链接：https://blog.csdn.net/m0_57077948/article/details/137728440

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Web前端全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024c （备注前端）

正文

a.x ={n: 2}

a = {n: 2};

console.log(a.x);

console.log(b.x);

总结：因为优先级的问题，a.x要先进行赋值操作，然后再执行a的赋值操作，日常开发中，这种连等的写法也很常见，一般这样写 a=b=c=0，当然这样写不会有什么歧义和毛病，但像上面例子中的这种情况，就会有意想不到的效果（估计这种效果也不是我们想要的），代码尽量要逻辑简单清晰，所以在使用连等的时候要小心，用起来方便，确不可滥用。

2、作用域

var a = 0,b = 0;

function A(a) {

A = function (b) {

console.log(a + b++)

}

console.log(a++)

}

A(1)

A(2)

解析

var a = 0,b = 0;

function A(a) {

//A(1)调用运行情况：

1.A函数被重置为：

function (b) {

console.log(a + b++)

}

2.执行打印console.log(a++)，因为此时的a是形参，形参的值是传入的1，所以打印1，而且形参a执行了++，此时值为2

A = function (b) {

//A(2)调用情况

这个a是采用的闭包，所以是2，b是形参也是2，所以打印的是4

console.log(a + b++)

}

console.log(a++)

}

A(1)//A(1)调用

A(2)//A(2)调用

3、变量提升

题目1：

var a = 10;

(function a(){

console.log(a)

a = 20;

console.log(window.a)

var a = 30

console.log(a)

})()

等同于

var a = 10;

(function a(){

//内部作用域

var a;//var a = 30 中的声明被提升

console.log(a)//undefined

a = 20;//内部作用域的a赋值20

console.log(window.a)//window中的a依然是10

a = 30//内部作用域的a赋值30

console.log(a)//打印内部作用域中的a 30

})()

题目2：

var name = ‘张三’;

function fn() {

if (typeof name === ‘undefined’) {

var name = ‘李四’;

console.log('辛苦了： ’ + name);

} else {

console.log('吃饭没： ’ + name);

}

fn();

等同于

var name = ‘张三’;

function fn() {

var name ;// var name = ‘李四’; 中的声明被提前到函数作用域里面

if (typeof name === ‘undefined’) {//此时成立

name = ‘李四’;

console.log('辛苦了： ’ + name);

} else {

console.log('吃饭没： ’ + name);

}

fn();

题目3：

var a=10,b=20,c=30;

function fn(a){

a=1;

var b=2;

c=3

}

fn(100)

console.log(a,b,c);

等同于

var a=10,b=20,c=30;

function fn(a){

//函数调用，形成局部作用域，形参a在内部局部作用域 a=100

var b;//b在内部变量提升

a=1;//内部局部作用域 a设置为1

b=2;//内部局部作用域 b设置为2

c=3;//全局作用与c被设置值3

}

fn(100)

//可以看到只有c被局部作用域修改了

console.log(a,b,c);//10 20 3

题目4：

if(!(“a” in window)){

var a = 10

}

console.log(a);

等同于

var a;//变量提升了

if(!(“a” in window)){//“a” in window 成立了，所以这个条件不执行

a = 10

}

console.log(a);//'undefined

题目5：

var fn = ‘hello’;

(function(fn){

console.log(fn);

var fn=fn||‘world’;

console.log(fn)

})(fn)

console.log(fn);

等同于

var fn = ‘hello’;

(function(fn){

//内部作用域

//形参先被定义所以fn=hello

//var fn;//var fn=fn||‘world’;变量提升到这里，但是会被忽略，因为形参的fn先被定义

console.log(fn);//打印hello

fn=fn||‘world’;//这句fn还是等于hello

console.log(fn)//打印hello

})(fn)//hello作为实参传入

console.log(fn);//打印hello

//最终结果是：hello hello hello

题目6：

var n=10;

function fn(n){

console.log(n);

var n= 20;

console.log(n);

function n(){

}

console.log(n);

}

fn(n);

console.log(n);

等同于

var n=10;

function fn(n){

//局部作用域

//n根据形参首先定义 n=10

//函数会提升，覆盖了n，此时n为函数

function n(){

}

//var n;//var n =20中的var n 被提升到此处，但是会被忽略

console.log(n);//打印函数

n= 20;//n被赋值为20

console.log(n);//打印20

//函数已经提升

console.log(n);//打印20

}

fn(n);//实参n=10传入调用

console.log(n);//打印10

题目7：

function fn(fn){

console.log(fn);

var fn = 20;

console.log(fn);

function fn(){

console.log(fn);

}

fn(30);

var fn = 10;

console.log(fn);

等同于

function fn(fn){

//局部作用域 fn被形参设置 fn为30

function fn(){//函数被提升到此次，并且fn设置为函数

console.log(fn);

}

var fn ;//var fn = 20;中的var变量提升到这里，但是会被忽略

console.log(fn);//打印函数

fn = 20;//赋值20

console.log(fn);//打印20

}

var fn;//var fn = 10;这句中的var变量提升到这里，但是会被忽略，因为已经存在函数 fn 了

fn(30);//执行函数

fn = 10;//赋值fn为10

console.log(fn);//打印10

最终会依次打印出：fn函数 20 10

4、闭包相关

题目1：返回值（最常用）

function fn(){

var name=“hello”;

return function(){

return name;

}

var fnc = fn();

console.log(fnc())//hello

这个很好理解就是以闭包的形式将 name 返回。

题目2：函数赋值

var fn2;

function fn(){

var name=“hello”;

//将函数赋值给fn2

fn2 = function(){

return name;

}

fn()//要先执行进行赋值，

console.log(fn2())//执行输出fn2

在闭包里面给fn2函数设置值，闭包的形式把name属性记忆下来，执行会输出 hello。

题目3：函数参数

function fn(){

var name=“hello”;

return function callback(){

return name;

}

var fn1 = fn()//执行函数将返回值（callback函数）赋值给fn1，

function fn2(f){

//将函数作为参数传入

console.log(f());//执行函数，并输出

}

fn2(fn1)//执行输出fn2

用闭包返回一个函数，把此函数作为另一个函数的参数，在另一个函数里面执行这个函数，最终输出 hello

题目4：IIFE（自执行函数）

(function(){

var name=“hello”;

var fn1= function(){

return name;

}

//直接在自执行函数里面调用fn2，将fn1作为参数传入

fn2(fn1);

})()

function fn2(f){

//将函数作为参数传入

console.log(f());//执行函数，并输出

}

直接在自执行函数里面将封装的函数fn1传给fn2，作为参数调用同样可以获得结果 hello

题目5：循环赋值

//每秒执行1次，分别输出1-10

for(var i=1;i<=10;i++){

(function(j){

//j来接收

setTimeout(function(){

console.log(j);

},j*1000);

})(i)//i作为实参传入

}

题目6：getter和setter

function fn(){

var name=‘hello’

setName=function(n){

name = n;

}

getName=function(){

return name;

}

//将setName，getName作为对象的属性返回

return {

setName:setName,

getName:getName

}

var fn1 = fn();//返回对象，属性setName和getName是两个函数

console.log(fn1.getName());//getter

fn1.setName(‘world’);//setter修改闭包里面的name

console.log(fn1.getName());//getter

第一次输出 hello 用setter以后再输出 world ，这样做可以封装成公共方法，防止不想暴露的属性和函数暴露在外部。

题目7：迭代器（执行一次函数往下取一个值）

var arr =[‘aa’,‘bb’,‘cc’];

function incre(arr){

var i=0;

return function(){

//这个函数每次被执行都返回数组arr中 i下标对应的元素

return arr[i++] || ‘数组值已经遍历完’;

}

var next = incre(arr);

console.log(next());//aa

console.log(next());//bb

console.log(next());//cc

console.log(next());//数组值已经遍历完

题目8：首次区分（相同的参数，函数不会重复执行）

var fn = (function(){

var arr=[];//用来缓存的数组

return function(val){

if(arr.indexOf(val)==-1){//缓存中没有则表示需要执行

arr.push(val);//将参数push到缓存数组中

console.log(‘函数被执行了’,arr);

//这里写想要执行的函数

}else{

console.log(‘此次函数不需要执行’);

}

console.log(‘函数调用完打印一下，方便查看已缓存的数组：’,arr);

}

})();

fn(10);

fn(1000);

fn(200);

fn(1000);

执行结果

可以明显的看到首次执行的会被存起来，再次执行直接取。

题目9：缓存

//比如求和操作，如果没有缓存，每次调用都要重复计算，采用缓存已经执行过的去查找，查找到了就直接返回，不需要重新计算

var fn=(function(){

var cache={};//缓存对象

var calc=function(arr){//计算函数

var sum=0;

//求和

for(var i=0;i<arr.length;i++){

sum+=arr[i];

}

return sum;

}

return function(){

var args = Array.prototype.slice.call(arguments,0);//arguments转换成数组

var key=args.join(“,”);//将args用逗号连接成字符串

var result , tSum = cache[key];

if(tSum){//如果缓存有

console.log(‘从缓存中取：’,cache)//打印方便查看

result = tSum;

}else{

//重新计算，并存入缓存同时赋值给result

result = cache[key]=calc(args);

console.log(‘存入缓存：’,cache)//打印方便查看

}

return result;

}

})();

fn(1,2,3,4,5);

fn(1,2,3,4,5,6);

fn(1,2,3,4,5,8);

fn(1,2,3,4,5,6);

输出结果：

题目10：节流函数

节流函数的作用是在限定的时间内函数只执行一次，比如：

1.按钮提交（可以避免重复提交，当然不只这种方法，将按钮设置为不可用也可以）。

2.scroll、mousehover、mousemove等触发频率高的时候。

主要的原理就是在闭包内设置一个标记，在限定的时间内这个flag设置为true，函数再次点击则不让执行，setTimeout函数执行以后将flag设置为flase，就可以继续执行。

test

这里限定了按钮的点击时间，2000毫秒之内只有第一次会被执行，多次点击的话无效。

总结：闭包可以说无处不在，所以闭包这些场景，还是很值得研究一番。

5、原型与原型链

题目1：

function F() {

this.a = 1;

}

var obj = new F();

console.log(obj.prototype);//打印undefined 对象只有 __proto__属性没有prototype属性，函数才有

题目2：

Object.prototype.a = 1;

var obj = {

b: 2

};

for(var i in obj) {

console.log(i); //能迭代出原型链里面的属性，所以会打印出 b和a

}

题目3：

Object.prototype.a = 1;

var obj = {

b: undefined

};

console.log(obj.a);//1

console.log(‘b’ in obj);//true //能找到处于原型链里面的bar属性

console.log(obj.hasOwnProperty(‘a’));//false 不是自身的属性

console.log(obj.hasOwnProperty(‘b’));//true 是自身的属性

题目4：

function A(){

}

function B(a){

this.a = a;

}

function C(a){

if(a){

this.a = a;

}

A.prototype.a = 1;

B.prototype.a = 1;

C.prototype.a = 1;

//实例对象都能访问构造函数的原型对象，可以明确的是以上3个都是能拿到a的

console.log(new A().a);//1 拿到的是原型上的a=1

console.log(new B().a);//undefined this.a = a;将new B()这个实例对象的a属性这是为undefined，所以拿到的是undefined

console.log(new C(2).a);//2 将new C(2)这个实例对象的a属性这是为2，所以拿到的是2

题目5：

function A () {

}

A.prototype.n = 1;

var b = new A();//b实例对象已经建立原型连接

//原型对象指向被改变，不会切断b实例对象的

A.prototype = {

n: 2,

m: 3

}

var c = new A();//c实例对象将根据新的原型建立连接

console.log(b.n, b.m); //1 undefined 这里拿到是改变prototype之前的

console.log(c.n, c.m); //2 3 这里拿到是改变prototype之后的

题目6：

var F = function(){};

Object.prototype.a = function(){

console.log(‘a’)

}

Function.prototype.b = function(){

console.log(‘b’)

}

var f = new F();

F.a(); //打印a 对象都能访问Object.prototype中的属性和方法

F.b(); //打印b F是函数，原型链 F => F.proto => Function.prototype => Function.prototype.proto => Object.prototype

f.a(); //打印a 对象都能访问Object.prototype中的属性和方法

f.b(); //报错f.b is not a function 因f是F实例对象，原型链 f=>f.proto=>F.prototype=>F.prototype.proto => Object.prototype

**总结：**在JavaScript中，对象都有__proto__属性（隐式原型），指向构造该对象的构造函数的原型，而函数Function比较特殊，它除了和其他对象一样有__proto__属性，还有自己特有的属性----prototype称之为原型对象，原型对象有一个constructor属性，该属性指回该函数。

6、this的理解