JS（javascript）面试题

提示：JS（javascript）面试题 => 必会之八股文 目录索引查看

面试题

• JS（javascript）面试题
• • @[TOC](面试题)
• 一、原型 和 原型链
• 二、防抖 与 节流
• • 1.防抖
  • 2.节流
• 三、闭包
• • 1.为什么不要定义全局变量？
• 四、null 和 undefined
• 五、filter 的使用
• 六、forEach() 和 map()
• • forEach()
  • map()
• 七、var let 和 const
• • var
  • let
  • const

提示：以下是本篇文章正文内容，下面案例可供参考

一、原型 和 原型链

prototype (原型) => 原型是函数所特有的

__ proto __ => [[ prototype ]] (原型链)

对象原型( _ proto _ ）指向它的构造函数的原型对象（prototype），原型对象再次指向上一层的对象原型，直至指向的原型对象为 null 或是指向 object 的原型对象（null）。null没有原型，原型链到此结束。

提示：当继承的函数被调用时，this 指向的是当前继承的对象，而不是继承的函数所在的原型对象。

	function Foo(uname,age) {
		this.uname = uname;
		this.age = age;
	}
	function Son(uname,age,score) {
		Foo.call(this,uname,age);
		this.score = score;
	}
	Son.prototype = new Foo();//Son.prototype = Foo.prototype;
	Son.prototype.constructor = Son; //Son.prototype = Son.prototype;
1
2
3
4
5
6
7
8
9
10

详细及更多解释查看 ：继承与原型链

---

二、防抖 与 节流

1.防抖

（n 秒后在执行该事件，若在 n 秒内被重复触发，则重新计时）

2.节流

（n 秒内只运行一次，若在 n 秒内重复触发，只有一次生效）

	//防抖
	function debounce(fn , wait) {
		let timeOut = null;
		return args => {
			if(timeOut) clearTimeout(timeOut)
			timeOut = setTimeout(fn,wait);
		}
	}
	//节流
	function throttle(fn, time) {
		let timer = null;
		return args => {
			if(!timer) {
				timer.setTimeout(() => {
					fn();
					timer = null;
				},timer)
			}
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

网络流传经典故事：

想象每天上班大厦底下的电梯。把电梯完成一次运送，类比为一次函数的执行和响应假设电梯有两种运行策略 debounce （防抖）和 throttle（节流），超时设定为15秒，不考虑容量限制
电梯第一个人进来后，15秒后准时运送一次，这是节流
电梯第一个人进来后，等待15秒。如果过程中又有人进来，15秒等待重新计时，直到15秒后开始运送，这是防抖

详细及更多解释查看 ：防抖与节流

---

三、闭包

JavaScript 变量可以是局部变量或全局变量。私有变量可以用到闭包。

1.为什么不要定义全局变量？

全局变量不会被回收机制回收，同时污染局部变量

	let count = function() {
		let num = 0;
		function change(val) {
			num += val
		}
		return {
			add: function() {
				change(1)
			},reduce: function() {
				change(-1)
			},show: function() {
				return num
			}
		}
	}
	let s = count()
	s.add()
	s.add()
	console.log(s.show()) // 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

详细及更多解释查看 （闭包实际中的应用）：闭包

---

四、null 和 undefined

提示：null：0，undefined ： NAN

undefined: （出现的地方）

（1）变量已声明 未赋值（2）对象属性不存在
（3）函数调用少参数 （4）方法的默认返回值（构造函数除外）

null:（用到的地方）

（1）手动释放内存（2）作为函数的参数（非对象参数）（3）原型链的顶端

---

五、filter 的使用

作用：过滤

current：过滤的当前值，index：当前值的下标，array：被过滤的数组

	let n1 = [1,2,3,4,5,6];
	let n2 = n1.filter((current, index, array) => {
		return current < 3
	})
	console.log(n1) //(6) [1, 2, 3, 4, 5, 6]
	console.log(n2) //(2) [1, 2]
1
2
3
4
5
6

详细及更多解释查看：JavaScript Array filter() 方法

---

六、forEach() 和 map()

forEach()

（1）没有返回值（2）不能用break打断（3）遍历的是value（值遍历）

	let arr = [20,30,40,50];
	let res = arr.forEach(element => {
		console.log(element); // 20，30，40，50
	})
	console.log(res) // undefined
1
2
3
4
5

map()

提示：map() 方法按照原始数组元素顺序依次处理元素 同时 不会改变原始数组 并且 不会对空数组进行检测

（1）有返回值（数组）默认返回undefined（2）接受的参数是函数（3）不能用 break 打段

	let arr = [20,30,40,50];
	let res = arr.map((value,key) => {
		return value + '1'
	})
	console.log(res) //(4) ["201", "301", "401", "501"]
1
2
3
4
5

---

七、var let 和 const

var

可以在全局范围声明或函数/局部范围内声明

var 变量可以重新声明和修改

	var s1 = '6';
	var s1 = 'Hello';
1
2

var 的变量提升

	console.log(s2);
	var s2 = 'hello';
	//实际执行：
	var s2;
	console.log(s2); // s2 is undefined
	s2= 'hello';
1
2
3
4
5
6

let

let 是块级作用域 块是由 {} 界定的代码块，大括号中有一个块。大括号内的任何内容都包含在一个块级作用域中.

let 可以被修改但是不能被重新声明.

const

const 声明的变量在块级作用域内（和 let 一样）

const 不能被修改并且不能被重新声明

提示：let 和 const 同样会变量提升但是不会对变量进行初始化，所以在变量未声明前无法使用变量

---