这节课是由月影老师讲的，干货满满，包括了面向对象的设计、组件封装、高阶函数（节流、防抖、批处理、可迭代化）

# 本堂课重点内容

# 写好 js 的原则

# 各司其责

举个栗子：写一段 JS，控制一个网页，让他支持浅色 / 深色两种模式。你会怎么做呢？

我的第一反应：写一个深色类，在切换按钮事件进行切换。这也是课件里讲的第二版。

第一版直接切换样式，不妥，但能用

	const btn = document.getElementById('modeBtn');
	btn.addEventListener('click', (e) => {
	const body = document.body;
	if(e.target.innerHTML === '☀️') {
	body.style.backgroundColor = 'black';
	body.style.color = 'white';
	e.target.innerHTML = '🌙';
	} else {
	body.style.backgroundColor = 'white';
	body.style.color = 'black';
	e.target.innerHTML = '☀️';
	}
	});

第二版封装了深色类

	const btn = document.getElementById('modeBtn');
	btn.addEventListener('click', (e) => {
	const body = document.body;
	if(body.className !== 'night') {
	body.className = 'nignt';
	} else {
	body.className = '';
	}
	});

第三版既然是完全的展示行为，那么可以完全由 html 和 css 实现
将切换作为一个 type 为 checkbox 控件，id 为 modeCheckBox ，使用 label 标签的 for 控件，id 为 modeCheckBox ，使用 label 标签的 for 属性将其关联到这个控件，再把 checkbox 隐藏掉即可实现点击切换模式。
" ~~只要不写代码就不会有 bug~~" ，这也是各司其责的一种体现。

总结：需要避免不必要的由 js 直接操作样式，可以用 class 来表示状态，而纯展示类的交互寻求零 JS 方案。版本 2 也是有其好处的，如适应性是不一定有版本 3 的好的。

# 组件封装

组件是指 web 页面上抽出来的一个个包含模板 (HTML)、功能（JS）和样式（CSS）的单元，好的组件具备封装性、正确性、扩展性和复用性。虽然现在由于有很多优秀的组件存在，往往我们不需要去自己设计一个组件，但我们也要去试着了解他们的实现。

举个栗子：用原生 JS 写一个电商网站的轮播图，应该怎么实现？

结构：HTML 中的无序列表（ <ul> ）
- 轮播图是典型的列表结构，可以用无序列表 <ul> 元素来实现，每个图放在一个 li 标签中。
表现：CSS 绝对定位
- 使用 CSS 的绝对定位，将图片重叠在一个位置
- 切换状态使用修饰符（modifier）
  - selected
- 轮播图切换动画使用 CSS transition 实现
行为：JS
- API 设计应保证原子操作，职责单一，满足灵活性
  - ps：原子操作就是指不可中断的一个或一系列操作，比如操作系统中的原语 wait、read 等。
- 封装一些事件：getSelectedItem ()、getSelectedItemIndex ()、slidTo ()、slideNext ()、slidePrevious ()……
- 更进一步：控制流，使用自定义事件来进行解耦。

总结：组件封装需要注意其结构设计、展现效果、行为设计（API、Event 等）是否达标

思考：如何来改进这个轮播图？

# 重构 1：插件化，解耦

将控制元素抽取成一个个插件（左右小箭头、底下的四个小圆点）等等
插件与组件之间通过依赖注入方式建立联系、

这样的好处？组件的构造器做的工作就只是将组件们一一注册了，日后复用的时候不需要的组件直接将构造器注释掉即，无需关注其他的。

再进一步扩展？

# 重构 2：模板化

将 html 也模板化，做到只需一个 <div class='slider‘></div> 就能实现图片轮播，修改控制器的构造，传入图片列表。

# 重构 3：抽象化

将通用的组件模型，抽象出来一个组件类（Component），其他组件类通过继承该类并实现其 render 方法。

	class Component{
	constructor(id, opts = {name, data: []}) {
	this.container = document.getElementById(id);
	this.options = opts;
	this.container.innerHTML = this.render(opts.data);
	}
	registerPlugins(...plugins) {
	plugins.forEach( plugin => {
	const pluginContainer = document.createElement( 'div');
	pluginContainer.className = `${name}__plugin`;
	pluginContainer.innerHTML = plugin.render(this.options.data);
	this.container.appendchild(pluginContainer);

	plugin.action(this);
	});
	}
	render(data) {
	/* abstract */
	return ''
	}
	}

总结：

组件设计的原则 —— 封装性、正确性、拓展性和复用性
实现步骤：结构设计、展现效果、行为设计
三次重构
- 插件化
- 模板化
- 抽象化
改进：CSS 模板化、父子组件的状态同步和消息通信等等

# 过程抽象

处理局部细节控制的一些方法
函数式编程思想的基础应用

# 应用：操作次数限制

一些异步交互
一次性的 HTTP 请求

有这样一段代码，在每次点击时延时 2s 后移除该节点，但如果用户在该节点还没完全移除的时候又点了几次则会报错。

	const list = document.querySelector('ul');
	const buttons = list.querySelectorAll('button');
	buttons.forEach((button)=>{
	button.addEventListener('click', (evt) => {
	const target = evt.target;
	target.parentNode.className = 'completed';
	setTimeout(()=>{
	list.removeChild(target.parentNode);
	},2000);
	})
	});

而这个操作次数的限制，则可以抽象出来一个高级函数

	function once(fn) {
	return function(...args) {
	if(fn) {
	const ret = fn.apply(this, args);
	fn = null;
	return ret;
	}
	}
	}
	const list = document.querySelector('ul');
	const buttons = list.querySelectorAll('button');
	buttons.forEach((button)=>{
	button.addEventListener('click', once((evt) => {
	const target = evt.target;
	target.parentNode.className = 'completed';
	setTimeout(()=>{
	list.removeChild(target.parentNode);
	},2000);
	}))
	});

如代码中显示的那样，这个函数 once 接受一个函数，返回的也是一个函数，判断接受的函数是否为 null，若不为 null 则执行这个函数并返回其结果，若接受的函数为 null 则返回一个不进行任何操作的函数。click 事件注册的实际上是 once 返回的函数，这样再怎么点击也不会报错了。

ps：好精彩的应用例子！

为了让 ” 只执行一次 “ 这个需求覆盖不同的事件处理，将这个需求剥离出来，这个过程就称之为 过程抽象

# 高阶函数

以函数作为参数
以函数作为返回值
常用于作为 函数装饰器

	funtion HOF(fn) {
	return function(...args) {
	return fn.apply(this, args);
	}
	}

# 常用高阶函数

# Once 只执行一次

前文讲过，这里不再阐述

# Throttle 节流

为函数添加一个间隔 time，每隔 time 事件调用一次函数，节省其需求，比如某个事件很容易持续的发生（如鼠标移上去就触发），那么他会一直速度特别快的调用这个事件函数，这个时候为其加一个节流函数则可以防止崩溃节约流量。

	function throttle(fn, time = 500) {
	let timer;
	return function(...args) {
	if(!timer) {
	fn.apply(this, args);
	timer = setTimeout(() => {
	timer = null;
	}, time);
	}
	}
	}
	btn.onclick = throttle(function(e){
	/* 事件处理 */
	circle.innerHTML = parseInt(circle.innerHTML)+1;
	circle.className = 'fade';
	setTimeout(() => circle.className = '', 250);
	});

对原始的函数进行包装，没有 timer 的话就注册一个 timer，500ms 后取消，因为在这 500ms 中这个 timer 都还存在，所以不会去执行函数（或者说执行空函数），500ms 后 timer 取消了，函数就可以被调用执行了。

# Debounce 防抖

在上面的节流中，timer 存在期间是不会去执行函数，而防抖是在每次事件一开始的时候清空 timer，然后设置 timer 为 dur，当事件调用 dur 时间并且没有新的事件再次调用时（比如鼠标移动后悬停一段时间），函数就可以被调用执行了。

	function debounce(fn, dur) {
	dur = dur \|\| 100; //dur 若不存在则设置 dur 为 100ms
	var timer;
	return function() {
	clearTimeout(timer);
	timer = setTimeout(() => {
	fn.apply(this, arguments);
	}, dur);
	}
	}

# Consumer

这是将一个函数变成类似 setTimeout 这样的异步操作的函数，如调用了很多次某事件，将这些事件丢到一个列表中，按设定好的时间隔一段时间并执行返回其结果。先来看代码：

	function consumer(fn, time) {
	let tasks = [],
	timer;
	return function (...args) {
	tasks.push(fn.bind(this, ...args));
	if(timer == null) {
	timer = setInterval(() => {
	tasks.shift().call(this);
	if(tasks.length <= 0) {
	clearInterval(timer);
	timer = null;
	}
	}, time);
	}
	}
	}
	btn.onclick = consumer((evt) => {
	/*
	* 事件处理如每次调用了很多次某事件，将这些事件丢到
	* 一个列表中，按设定好的时间隔一段时间并执行返回其结果。
	*/
	let t = parseInt(count.innerHTML.slice(1)) + 1;
	count.className = 'hit';
	let r = t * 7 % 256,
	g = t * 17 % 128,
	b = t * 31 % 128;
	count.style.color = `rgb(${r}, ${g}, ${b})`.trim();
	setTimeout(() => {
	count.className = 'hide';
	}, 500);
	}, 800);

这里的事件处理实现了点击按钮时执行这个不断显示 + count 并在 500ms 后渐隐，而快速点击时，则将这个点击事件存储到是事件列表中每隔 800ms 执行（不然上一个 + count 还未消失）。

要弄明白函数原理，得从其中的 bind 函数和 shift 函数和 call 说起：

bind() 方法创建一个新的函数，在 bind() 被调用时，这个新函数的 this 被指定为 bind() 的第一个参数，而其余参数将作为新函数的参数，供调用时使用。

shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。与之相反的则是 unshift() 插入第一个元素。
与之相似的一对方法还有， pop() 和 push() ，他们作用于数组最后一个元素

call() 方法使用一个指定的 this 值和单独给出的一个或多个参数来调用一个函数。

那么不难看出上面这个函数的用途，将每次准备调用的函数放入 tasks 列表中，若定时器为空则设置一个定时器执行内容 定时执行tasks出队，若全部tasks已经清空（当前没有任务了）则将定时器清除 ，若定时器不为空则不做操作（但放到 tasks 列表中了）。

# Iterative

将一个函数，变成可迭代使用的的，这通常用于一个函数要给一组对象执行批量操作的时候。如批量设置颜色，代码如下：

	const isIterable = obj => obj != null && typeof obj[Symbol.iterator] === 'function';
	function iterative(fn) {
	return function(subject, ...rest) {
	if(isIterable(subject)) {
	const ret = [];
	for(let obj of subject) {
	ret.push(fn.apply(this, [obj, ...rest]));
	}
	return ret;
	}
	return fn.apply(this, [subject, ...rest]);
	}
	}
	const setColor = iterative((el, color) => {
	el.style.color = color;
	})
	const els = document.querySelectorAll('li:nth-child(2n+1)');
	setColor(els, 'red');

# Toggle

切换状态，也可以封装成一个高级函数，这样有多少种状态只要添加到里面就可以了。

例子：

	function toggle(...actions) {
	return function (...args) {
	let action = actions.shift();
	action.push(action);
	return action.apply(this, args);
	}
	}
	// 多少态都可以！
	switcher.onclick = toggle(
	evt => evt.target.className = 'off',
	evt => evt.target.className = 'on'
	);

# 思考

为什么要使用高阶函数？

了解一个概念：纯函数，是指一个函数的返回结果只依赖于它的参数，并且在执行过程里面没有副作用

这也就意味着，纯函数是非常靠谱的，不会对外界产生影响。

方便进行单元测试！
减少系统中非纯函数的数量，从而使得系统可靠性增加

# 其他一些思考

命令式与声明式，没有优劣之分
过程抽象 / HOF / 装饰器
命令式 / 声明式
代码风格、效率、质量的权衡。
- 根据场景来权衡

# 总结感想

太牛了！！

看完这节课，收获非常多，实现一个真正意义上的组件原来需要这么多步骤，原来 js 也能实现如此面向对象的设计，结合之前学过的 c++/java 的设计模式，发现都是有共通之处的，一个组件可以向下细分为许许多多的子组件。后面的高阶函数更是知识盲区，原来 js 还能实现这些方法

本文引用的内容大部分来自月影老师的课以及 MDN。