上文说到，联结主义是今天人工智能领域最主流的实现方式。

相比于“符号主义”将知识理解为符号，在“联结主义”中，知识是一组方程（函数），它们之间互相关联，形成一个类似于“大脑”的结构，所以亦称作神经网络。

和人类大脑的机制非常相似，一个神经网络在刚诞生的时候，它也是一张白纸，什么知识都没有，需要通过后天的学习，才能掌握知识。

可是神经网络本质上只是一些方程啊？方程也会学习吗？

为了理解这个问题，让我们从最简单的一元一次方程开始聊起。

方程中的参数

一个典型的一元一次方程，如下所示：

其中x是自变量，y是因变量，a和b是方程的参数。

通常情况下，我们会很关注方程中的x和y，比如在求解方程的解时等。但在这里，我们将更加关注参数部分。

参数很有用，不同的参数决定了方程的功能和效果。

这就像使用洗衣机的时候，我们虽然目的是将衣服洗干净，但为此我们需要首先在洗衣机面板上设定好合适的参数，比如时长、水量、转速等等，不同的参数会影响洗衣的效果。

方程的参数正决定了它所描述的规律。比如在这个猜数字的题中，我们就可以使用$y=2x-2$来描述，这时参数$a=2$，参数$b=-2$。

有了这个方程，我们就可以预测出这个数列中任意一位的数字，也就意味着掌握了知识。

使用可视化的方法在平面直角坐标系中绘制出一元一次方程，它将被表示为一条直线，这时可以更加直观的看到不同的参数对直线形态的影响。

神经网络学习的本质，就是在寻找方程的最佳参数，使其尽可能最拟合数据的真实规律，这个过程又称作回归。

特别的，一元一次方程在坐标系中表现为一条直线，因此针对一元一次方程的回归问题，也称作线性回归。

线性回归

线性回归是最简单的回归模型，非常适合用于发现事物之间的线性关系。

比如在下图所示的电路中，如果增加成倍电压，可以看到电流也会成倍增加。

通过观察测量结果，我们发现电压与电流的比总为一个常数，aka欧姆定律。

其中，I为电流，V为电压，R为电阻。

如果仍然使用x、y、a字母来表示电流、电压和电阻的话，还可以写做：

这是一个典型的一元一次方程，说明x和y之间（也就是电流和电压之间）存在着线性关系。

由于受测量方法和工具的限制，我们并不一定总能测得最精确的数据。随着测量次数的增加，会发现测量数据并不总是保持相同比例。

将所有数据可视化到坐标系中，会发现无论如何都不可能找不到一条直线，将所有的点连起来。

我们相信这些数据点的偏差是由误差导致的，本质上电压和电流一定成线性关系，我们是否可以拨开遮挡真相的迷雾，找到那条本质的直线呢？

最小二乘法

让我们尝试着调整参数a的取值，绘制出多条直线，如图所示。

我们能直观的感受到，a=1的直线，相比a=0.9和a=1.1的直线更好，相对来说a=1更好的串联了这些数据点，尽管还有一些数据点“损失”掉了。

为了计算比较不同直线的优劣，我们定义一个函数来量化“损失”的大小，这就是损失函数！

损失函数是神经网络中最重要的概念之一，我们会在后面的文章中经常碰到它。最常用的一种损失函数是均方误差。

所谓误差，使指测量点到回归直线之间的距离（差值） $(ax_i - y_i)$ 。

考虑到这个距离（差值）有正有负，可以通过平方统一他们的符号，因为任何实数的平方都大于等于0。

然后$ \frac{\sum(各点的误差)^2}{n} $，即求误差平方和的平均值，以避免数字过大不方便后续运算。

我们要寻找的真相就是“使均方误差最小时的参数a的值”，因此这个方法被称作“最小二乘法”。

整体的公式如下：

求解最小二乘

如果对均方误差去括号化简，合并同类项，会得到一个形如这样的结果：

这说明，当测量数据确定的情况下，损失函数是一个关于a的二次函数，即抛物线。

此外，$ a^2 $的系数是一些平方项的和，一定大于零，因此抛物线一定开口向上。因此，“使均方误差最小时的参数a的值”就是抛物线的顶点。

我们可以根据顶点坐标公式，快速的求得最优解。

在代码中引入了numpy库，以方便进行向量的运算：

import matplotlib.pyplot as plt

# 引入numpy方便进行向量运算
import numpy as np

# 测量数据转化为np格式
data = np.array([[5, 10, 20, 2.5, 5, 12, 8, 4.8, 18.2, 14.6, 19], [5, 10, 20, 2.8, 4.6, 12.3, 7.3, 5, 18, 15, 18.3 ]])

x = data[0]
y = data[1]

# 顶点坐标公式
a = np.sum(x * y) / np.sum(x ** 2)
print(a)

# 绘制散点图
plt.scatter(data[0], data[1], label="Data")
# 绘制直线图
plt.plot([0,20], [0,20*a], c='red', label=f"a={a}")

# 显示图例
plt.legend()
# 显示图像
plt.show()

我将本专栏所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 人工智能，查看和获取本课程的全部代码。

上文说到，人工智能在诞生的初期就形成了符号主义学派。他们认为，既然知识可以用各种各样的符号来表示，发现新的知识的本质就是符号之间的转化。

如果经由机器遍历完成所有合法的转化，那么我们就可以机械式的穷尽世间所有的知识，如此就可实现“人工智能”。

但是问题也随之而来了，“合法转化”中的“合法”所要符合的“法则”从何而来呢？

显然，符号之间的转化“法则”也是一种知识。可是这些“更高一层”的知识也可以通过遍历得到吗？

1931年数学家哥德尔提出了“不完备定理”，证明了这是不可能完成的任务。

那人工智能的出路在哪里呢？答案也许就藏在数字里。

模式识别

让我们来看这样一道简单的小学数学题。

不要想的太复杂，答案就是你心中的那个数字“6”，这组数字都是十以下的偶数。当然，在高中数学中，这也是一个等差数列。

题目看似很简单，但寓意非常深刻。

因为题目中并没有任何一个字说明这是一组偶数，或者这是一个等差数列。我们仅仅通过观察和直觉就识别了其中潜在的“模式”，并利用“模式”完成了“推理”。

如果我们面对的数字是来自于对真实世界的测量，那他们的内在模式不就是“知识”吗？！

原来知识就藏在数字里！

这个思路颠覆了以往科学研究的顺序：与其先提出假设，再用实验数据验证假设；不如先做实验收集数据，再识别数据中的特定模式，从而总结为知识。

这就是所谓的“模式识别”。

不过通过模式识别得到的“知识”也会有一些弊端，因为其经常看起来莫名其妙，无法理解。

对此，薛定谔表示有话想说。他通过总结量子现象提出了薛定谔方程和波函数理论，尽管可以非常好的进行预测，但实在与我们宏观世界的生活经验差距太大，让人无法理解。

甚至薛定谔本人都无法真正的理解方程的含义，为了让大众能同理到他的困惑，薛定谔还提出了那只著名的“既生又死”的猫。

不过理不理解呐，也没那么重要。知识嘛，能用就行。

联结主义

薛定谔终归还是幸运的，至少他给出了一个非常简洁的方程。（这也许说明了世界的本质很简单）。

但是很多其它的问题，就无法使用简单的方程来描述我们发现的模式，比如预测股票的涨跌，就涉及到非常多复杂的因素，如当前的股价、过去的走势、标的公司的股份组成和经营状况、金融环境与周期、国家的政策、国际上的经济形势等等。

每一个因素都可能与其它的因素之间蕴含着千丝万缕的联系，各种因素结合起来，最终影响了股价的走势。

既然使用单个方程难以描述其中的模式，数学家们想到了一个办法，就是使用一组相互联结的方程来“拟合”。

所谓“拟合”是说，这组方程描述的可能不是真相，但是其与实验和观测数据相符，我们就用这组方程来“模拟”真相。

这就诞生了人工智能的另外一个学派——“联结主义”。

如果我们暂时忽略具体方程，而只看他们形成的结构，会发现它无论是形态还是功能，它都神似人类中枢神经——大脑，于是命名为“神经网络”。

联结主义和神经网络是今天人工智能技术的主流，我们也会在接下来的文章中，使用大量的篇幅来讨论神经网络是如何构建出来的。

在此之前，为了避免被大量的抽象数字包围，我们还需要先了解一下名为“数据可视化”的重要方法。

数据可视化

数据是人类对客观世界的记录。

数据的形式也许是数字，也许是文字，甚至还有可能是图像、视频什么的，但在计算机里他们通通会被转化为数字。可以认为，数据就是被赋予了意义的数字。

比如身高170cm，体重65kg就是一组关于某人身体情况的基本数据，这里的170和65都有着特定的实际含义，分别代表着身高和体重。

计算机只关心数字本身，这组数据会被抽象为类似[170,65]这样形式，称之为“长度为2的数组”，或者在数学中称其为“2维向量”。

vector = [170, 65] # 2维向量

如果我们看到另外一个向量[185,76]，也能很容易的知道这是一位身高185cm，体重76kg的朋友。

我们还可以使用“2维数组”或“2阶向量”同时表示多条数据，看起来将会像这样：

# 每行表示一个人的数据
vectors = [[170, 65], 
           [185,  76]]

或者这样：

# 每列表示一个人的数据
vectors = [[170, 185], 
           [65,  76]]

这两种写法互为转置，在代码中可以很容易的转化，所以使用那种都可以，取决于应用场景。

下面的向量中存储了10个人的数据，那么请问哪位最“胖”？

vectors = [[170, 185, 183, 164, 177, 159, 182, 176, 168, 173],
           [65,  76,  80,  85,  65,  66,  70,  81,  69,  69]]

可以把向量画到坐标系中：

因为x轴为体重，y轴为身高，所以越靠近右下角的向量就越“胖”，结果非常的直观。

这里用到的画图库为matplotlib（需要单独安装），代码如下：

import matplotlib.pyplot as plt
# 数据向量
vectors = [[170, 185, 183, 164, 177, 159, 182, 176, 168, 173],
           [65,  76,  80,  85,  65,  66,  70,  81,  69,  69]]
# 绘制散点图
plt.scatter(vectors[1], vectors[0])
# 显示图像
plt.show()

这就是数据可视化，可以帮助我们通过视觉更好的理解数据背后的含义。

我将本专栏所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 人工智能，查看和获取本课程的全部代码。

聊起人工智能，就不得不提到1956年在达特茅斯学院的那个夏天。

在两个月的时间里，一群计算机界的大佬和即将成为大佬的预备大佬共聚一堂，探讨着“如何用机器模拟智能”的问题。

会议的主要召集人，约翰·麦卡锡（John McCarthy），将这个会议命名为“人工智能夏季研讨会”，从此诞生了“人工智能”这个词。

大佬们之所以要讨论这个问题，是因为著名的计算机科学家图灵在不久前发表了一片论文《计算机器与智能》。

在文章中图灵讨论了使用计算机来模拟人类智能的可能性，并提到了一个用于评价模拟效果如何的方法，称之为“模拟游戏”（游戏Game一词也有比赛的含义）。

把一个人和一台计算机分别关在两个小房间里，房间外有多少比例的人可以通过与它们对话（传递小纸条），判断出来其中哪个是人，哪个是机器。

这也就是后来更为人们所知的“图灵测试”。

信息论

可是，计算机怎么能和人对话呢？

问题的重点不在于如何发声或打印小纸条，因为不论是留声机还是打字机，在当时都是非常成熟的技术了。

重点在于计算机如何能“听懂人话”并作出适当的反应，即便是在60多年后的今天，这依然是人工智能领域还在摸索的问题。

如你所知，我们给机器起名字的时候，是根据它的功能来的。比如洗衣机，就是一种用来洗衣服的机器；电视机，是一种用来看电视的机器；咖啡机，是一种用来做咖啡的机器。

计算机，不过只是一种很擅长计算的机器。

计算是对“数字”的处理，可是人类的语言却是“文字”。这即计算机科学家，也是人工智能科学家们要解决的第一个问题。

与会的另一个大佬，香农，是信息论的奠基人，他巧妙的提出了“信息量”的概念。

我们人类在表达一个意图的时候，可以用很多种不同的表达方式，甚至使用完全不同的语言。

• 今日有雨。
• 今天空中将落下雨滴。
• It rains today.

尽管这些文字如此不同，但是他们在传递着某种相似甚至相同的东西，这就是信息。

香农认为，一句话中所携带的信息有多少，可以通过计算来量化，并且给到了一个非常简洁的公式：

I = -log p

其中p就是这句话中事件发生的概率，而I就是它的信息量了。

让我们在此处做一个简单假设，假如天气只会出现“晴”“雨”两种情况，且发生的概率都一样，即都是1/2。那么如“今日有雨”这样的句子中，所携带的信息量可以通过公式得到答案:

-log(1/2) = 1 bit

也就是说，这句话所携带的信息量为1个比特。

“比特嘛，我熟！”，计算机说。在（二进制）计算机中，一切都是比特。

于是，在计算机中，就可以拿出1个比特，来表达”今日有雨“这句话所携带的信息。比如，用1来表示确实下雨了，而用0来表示不会下雨。

如果我们拿出来365个比特，就可以存储下一整年的天气情况了！这表达效率比文字高多了！

当然，真实的天气情况会更复杂，而信息论的学科大厦也更为庞大，我们这里只是讨论一个最简单的假设。

站在更高的层面来看，中文也好，拉文字母也好，数学符号也好，不过是人们在表达信息时的不同符号体系罢了。

香农通过信息论，在理论层面搭建出一条符号体系之间转化的桥梁。

符号主义

计算的本质，就是符号之间的相互转化。

上过小学的我们，大概都能感受到计算是由数值和运算两类符号组成的。

然后我们可以使用一个新的数值符号“2”来标记“1+1”的计算结果。

还有其它的变化方式，比如引入新的运算符号“X”乘法。

根据信息论的原理，符号的转化并不影响信息量。但是不同的符号对于人们的“阅读体验”来说可太不一样了。

对于而对于数学家来说，这个不只是“阅读体验的问题”，可以想象解方程的过程、定理证明的过程，本质上也都是一种符号转化。

既然如此，是不是可以设计这样一个机器，通过我们给定的初始条件和符号之间的转化规则，它就可以自行遍历出所有合法的表达方式。

这个设想简直太棒了，如果可行的话，我们只需要定义好基本公理，机器就自己可以推导出所有的推论和定理，这样的话机器岂不是就能掌握了所有的知识了？！（甚至比人类已知的还多）

在为期两个月的研讨会中，纽厄尔和西蒙两位大佬，编写程序让机器自己推导出了《数学原理》第2章52个定理中的38个定理。

从这个思路出发，逐渐形成了最早的一个人工智能流派，即符号主义。

基于符号主义衍生出了早期的人工智能的系统——“专家系统”。专家把自己行业中的“基本公理”提炼出来，程序员将其改写为计算机能理解的符号，即代码，来基于“基本公理”来进行推理，来实现对应的功能。

历史上著名的人工智能“深蓝”就是一个国际象棋的“专家系统”，它便是通过遍历出所有可能的落子，然后在1997年打败了人类棋王，登顶冠军。

不过符号主义之路并没有那么顺利，早在1931年，数学家哥德尔就通过他发现的不完备定理，证明了上述设想不可能穷举出所有知识。

图灵为了说明不完备定理，而设计出的一个思维实验机器——图灵机。图灵机在很大程度上启发了冯诺依曼，后者在此基础上设计出了我们今天在使用的计算机的基本构型。

（在未来上线的《计算机原理》专栏中，你可以看到更多关于图灵机和冯诺依曼构型的介绍）

符号主义在今天已不是人工智能界的主流，所以本文不打算继续深入，如果你对这些内容感兴趣，推荐去读侯世达的《集异璧》，去深入理解更多关于符号主义的思想。

人工智能在今天是一个非常炙手可热的研究领域，仿佛人人都在谈论它，却又难以看清楚它的面目。

我也不能免俗，建立起这个新的专栏，打算使用一系列的文章帮你搞清楚人工智能到底是咋回事。

这些文章会从很多的角度来讨论人工智能，但作为一个科技博客，我们还是会更加聚焦在其背后的原理。

相信在你读这些内容之后，无论你是否在未来踏上人工智能的道路，都会加深对世界的真相的理解。

人工的智能

说回人工智能这个词，它分为人工与智能两个部分。

“人工”，或者“人工制品”，这个词很好理解，即人类通过一定的工艺制造出来的产品。

这些产品可以是日常生活的一部分。

也可以是工业生产中的重要环节。

甚至是人造的地理和气候。

或者成为我们身体的一部分。

但人们制造的产品有那么多，为何只有某一些产品会冠以“人工”前缀呢？

这是因为这些产品是自然界里原本就有的东西，而人类在进行模仿！

所以，所谓人工智能就是人类通过一定工艺制造出来的，用于模仿人类自己“智能”的产品。

就像“中华料理，八大菜系，各成一派”一样，实现人工智能的工艺也有很多，也逐渐形成了很多流派（也称作学派），我们也会在之后文章逐渐的介绍其中一些流派，本篇暂且不提。

从傻瓜到智能

那么，什么又是智能呢？

今天的智能机器，在我小时候那会儿，大家更习惯叫作“傻瓜XX”，意思是“即是你是个傻瓜，你也能使用这个机器”。

当我拿起傻瓜相机拍照的时候，重点不在于我到底是不是一个傻瓜，而是我不再需要去深入了解关于摄影的很多知识了，什么快门、焦距、光圈、曝光度、白平衡等等，这些参数都会由傻瓜相机自己调整。我所需要做的，就是按下快门，然后得到一张还算不错的照片。

今天的智能修图也基本上是同样的意思，我不再需要懂什么选区、图层、蒙版、液化、曲线、自由变换等等这些图像编辑知识，我只需要按下按钮，魔法就生效了。

看吧，智能机器的智能，是机器掌握了那些原本用户应该知道的“知识”。

这听起来就很高科技，果然“傻瓜XX”不再流行，有它的道理。

机器学习与智能

我们人类可以通过学习掌握知识，机器也可以吗？

这话题至少可以追溯到17世纪，第一次工业革命那会儿，那时候各种各样的机械装置如雨后春笋般出现。

那时候的哲学家，比如笛卡尔就在他的著作《方法论》中设想了一种模仿人类的机器，不过笛卡尔并不认为这种机器可以被造出来，因为机器无法具有“自由意识”。

相比“自由意识”这种玄而又玄的东西，知识其实是更加客观的存在，因为知识无非是事实或对事实的总结而已。

如果我们可以想办法用一些特殊的机器结构来表示这些知识，那么…机器不就能学习了？

随着之后几百年的发展，人们逐渐意识到知识价值在于其反应了规律（模式），规律的发现依赖统计，统计是一种数学，而数学的基础是计算。

于是，计算机成为了那个天选之子。使用计算机来进行机器学习成为了今天人工智能技术发展的基石。

进一步阅读的建议

如上文所说，我们的人工智能系列文章会围绕着机器学习为核心展开，这难免会对你的计算机科学和数学能力有一定的要求。

数学的部分，我会假设你有着高中生相应的水平，尽可能把问题的复杂度下降到可以接受的水平，如果不得不涉及更加复杂数学概念，我也会在文章中进行讲解。

计算机科学的部分，我会在本博客更新另外一系列的文章供你阅读，但遗憾的是目前还没有上线，内容我已经整理完毕，应该不会鸽很久，你可以期待一下。

在本专栏中编程并不是必须的，如果你并不了解如何编程，可以跳过相关的小结。

当然如果你有很好的编程能力，我会在每篇文章的下方放入相关代码的连接，欢迎你下载探索。对了，这里使用的语言为Python，一个在人工智能领域很强势的语言。我也会在不知道多久将来，去更新Python的文章。

好了，就是这些，我们在正文里见！

本文是网页开发入门系列的最后一篇。

在长达20篇文章的内容之后，相信你已经对网页究竟是如何开发有了最基本的理解。更重要的是，希望通过网页这一简单、常见且可视化的形式，让你理解了程序，以及代码究竟是如何工作的。

正如在最初所讲到的那样，掌握一种思维方式，远比记住具体语法要重要的多的多。

MVC思想：模型-视图-控制

总结来说，在浩瀚的互联网上，无论多么复杂，多么绚丽的网页，但他们在本质上都是使用 HTML，CSS，JS开发出来的。

HTML负责描述页面的内容和结构，也就是元素和元素之间关系。从更加抽象的角度来看，HTML在网页中承担了存储数据和数据模型的作用。所谓数据模型，可以简单理解为数据及其相互关系的存储规范，也称作Model。

CSS负责定义元素的样式，从而调整页面的可视化效果。也就是说，CSS决定了如何把数据呈现给用户的界面，也称作视图，即View。

最后，JS负责定义页面功能，决定了如何处理包含页面本身和用户输入等数据，以及决定将哪些数据显示给用户，实现了控制或者控制器Controller。

模型，视图，控制将一个项目的代码按照其目的和功能，分成了相对独立3个部分，不但规范了代码的开发流程，也促进了团队分工。

这种思想称作MVC，被广泛的应用于各种类型、各种规模、各个层级的软件开发中，不论他们在使用什么开发语言，工作在什么样的平台上。

软件工程：开发-集成-部署

截至目前为止，我们在课程上开发的所有页面，都存储在自己的电脑上，也无法被网络上的其他人访问，很难称其为“网页”。

在真实软件开发过程中，这是很正常的情况。

开发人员首先需要在自己的设备上编写代码，这个阶段称作开发。这个设备也称作开发环境。

大型的项目通常会有多个开发人员分工完成，所以在发布产品之前，还需要将大家的代码集中在一起，并进行测试。这个阶段称作集成。做这件事的设备也称作集成环境。

最终通过了测试的程序，将被发布到网络上的某个特定的URL位置后，用户即可进行访问和使用，即完成了部署。

对网页来说，部署是比较容易的一件事，只需要在有互联网公网IP的设备上开启对HTTP或HTTPS协议即可，这样的设备就是服务器，也称作生产环境。

如果你自己的电脑有公网IP，你的电脑也可以是一台服务器。不过处于安全、管理、成本等角度考虑，通常会用一些专用配置的服务器。

具体的部署方法涉及较多的网络知识，此处不再展开。

B/S架构

网页一旦被部署到了网络上，就可以为网络上的用户提供服务。

但不同用户的身份、角色、权限都不一样，我们的网页如何区分他们，然后提供不同的服务呢？

这些其实是由在服务器上运行的一个特定的程序来进行处理的，在服务器收到网页请求时，这个程序负责识别用户的身份，并据此提供特定的网页，或动态生产网页。

也就是说，从整体来看，网页又分成了2个部分，一部分运行在用户的浏览器里，也称作前端。另一部分运行在服务器上，也称作后端。

这样的软件架构模式，就是B/S架构，即浏览器Browser-服务器Server架构。

运行在服务器的程序，其配置在于开发者的选择，所以不必考虑浏览器的兼容性，可以更加灵活的使用其它编程语言来实现，JAVA、PHP、Python以及JS都是常见的选择。

Web开发框架

基于这样的一些思想和架构，在开发者之间逐渐形成了一些特定的编程习惯，也因此产生了很多共通问题的解决方法。

如果将这些解决方案集中起来，就形成了Web开发的框架。如果你使用同样的编程习惯，就可以享受到整个框架所带来的能力。

在前端常用的框架有VUE, React等。后端根据不同的编程语言也有很多不同的框架，比如基于JS的Express等。

如果你还想进一步提升自己关于网页开发的能力，这些都是我建议可以进一步学习的内容。如果有机会，我也会去更新一些相关的教程。

再见

作为入门，《网页开发入门》系列并不期待你可以立即上手开发属于自己的网页，但希望其内容足够你理解网页工作的基本原理，让你有能进行深入学习的能力。

希望在其它的文章中再见！See you then！

经历了漫长知识性学习，又来到了综合练习时间。

这一次我们将综合使用之前课程中所学习到内容，一起来开发一个用户注册的页面，在实践中感受一下网页三大要素 HTML，CSS，JS如何在一起工作。

卡片的实现

从设计图中可以看到，这是一个简单的用户注册页面，整体上呈卡片形式。

卡片是在网页中比较常见的设计语言。

卡片可以给用户边界感，让用户知道它所需要关注的内容在有限的空间内，同时分隔开了其它内容，让用户更加的聚焦。

在HTML中使用CSS实现卡片也很容易，在固定宽高的块级元素的基础上，增加边框和阴影就可以呈现一种卡片的感觉。

<div class="card">
</div>

/* 
    body是所有元素的父元素，
    使用body标签选择器，设定整个页面的基础样式。
    此处将页面背景设定为灰色，以突出白色的卡片。
*/
body {
	background-color: #e5e5e5;
}
/* 
    使用类选择器，对卡片元素样式进行设定，
    固定宽高800*600，并增加边框圆角和阴影。
    overflow属性可以在内部元素溢出卡片的圆角边界时，隐藏溢出的部分。
*/
.card {
	background-color: white;
    width: 800px;
    height: 600px;
    border-radius: 10px;
    overflow: hidden;
    box-shadow: 0 0 2px #bfbfbf;
}

因为页面里没有其它元素，将卡片居中显示可以改善页面平衡。

为此，我们为卡片元素再设定另外一个类，专门用于让卡片居中。

<div class="card card-center">
</div>

在HTML中，元素可以有多个类，多个类中定义的样式会依次生效。这样的好处是可以将页面上某类元素的公共属性放在一个类中，如卡片的尺寸、颜色等，而其它特定的效果放到另外一个类中，如定位等，修改起来互不影响。

/* 
    使用绝对定位将卡片定位到页面中心。
    left和top的50%，指的左边和上边移动到整个页面（浏览器窗口）的一半。
    transform和translate(-50%,-50%)，指将元素向左和上移动元素尺寸的一半。
    联合使用这一组样式，即可让元素页面居中
*/
.card-center {
    position: absolute;
    left: 50%;
    top: 50%;
    transform: translate(-50%, -50%);
}

卡片分栏

接下来，可以看到设计稿中的卡片又分为左右两栏，左侧使用图片丰富了页面的色彩，右侧为用户要填写的表单。

使用flex或grid布局可以快速完成分栏效果，因为页面中元素的尺寸是固定的，此处选择使用更加简单的flex布局。

<div class="card card-center">
    <div class="card-layout">
        <div class="card-layout-left">
            图片
        </div>
        <div class="card-layout-right">
            表单
        </div>
    </div>
</div>

.card-layout {
    display: flex;
}
/* 
    左边图片部分宽350px
*/
.card-layout-left {
    width: 350px;
}
/* 
    右边表单部分宽450px
*/
.card-layout-right {
    width: 450px;
}

这样就完成了左右分栏。

放入图片

先完成卡片左侧的图片，使用img标签即可插入图片。

<!-- 省略其它部分代码 --> 
<div class="card-layout-left">
    <img class="theme-img" src="assets/dustin.jpg" alt="theme">
</div>

原始图的尺寸不一定会与卡片中需要的尺寸一致，需要对图片进行裁剪。

/* 
    设定图片尺寸，默认效果是对图片进行缩放
    将object-fit设定为cover，将缩放效果改为裁剪
*/
.theme-img {
    object-fit: cover;
    width: 350px;
    height: 600px;
}

放入表单

右侧的表单主要由三部分组成，大标题、表单项、提交按钮。

<!-- 省略其它部分代码 --> 
<div class="card-layout-right">
    <form class="signup-form">
        <div class="signup-form-title">标题</div>
        <div class="signup-form-items">表单项</div>
        <div class="signup-form-submit">提交按钮</div>
    <form>
</div>

/*
    设定表单整体的宽度和边距等基本属性
*/
.signup-form {
    width: 450px;
    margin: 50px 20px;
}

美化表单标题

表单标题的内容为居中显示，为了进一步突出，还需要加大字号和字重。

同时，默认的文字是黑色，对比度过于强烈。为了让视觉更加柔和，将字体颜色改为墨色。

<!-- 省略其它部分代码 --> 
<div class="signup-form-title">
    Sign up to discover<br>your dream
</div>

/*
    设定标题的基本属性
*/
.signup-form-title {
    text-align: center;
    color: #3b3b3b;
    font-size: xx-large;
    font-weight: bolder;
}

接下来，在标题下方放一个短线段，从视觉上可以起到支撑的效果，提升页面整体的结构感。

<!-- 省略其它部分代码 --> 
<div class="signup-form-title">
    Sign up to discover<br>your dream
</div>
<div class="signup-form-spliter"></div>

/*
    使用css绘制一条线段
*/
.signup-form-spliter {
    width: 100px;
    border: 1px solid #4e66b1;
    margin: 2px auto;
}

基础图形的使用在平面设计中非常有用，运用得当可以极大的提升页面的质感。

美化表单项

用于注册的表单内容较少，使用垂直排列可以让页面看起来会更加流畅。

用于表单项的label和input都是行内元素，默认情况下将横向排列。通过修改它们的样式属性display: block可以将其强行转化为块级元素，即可以实现纵向排列。

<!-- 省略其它部分代码 --> 
<div class="signup-form-items">
    <div class="signup-form-item">
        <label for="username" class="signup-form-item-block">
            Username
        </label>
        <input name="username" class="signup-form-item-block"
        placeholder="Enter your username">
    </div>
	<!-- 省略其它表单项 --> 
</div>

.signup-form-item {
    margin: 20px;
}
/* 
    将表单项改为块级元素
*/
.signup-form-item-block {
    display: block;
}

然后分别调整label和input的样式，使之与页面风格统一。

.signup-form-item-label {
    display: block;
    color: #3b3b3b;
    font-weight: bold;
}

.signup-form-item-input {
    display: block;
    outline: none;
    border: 0;
    border-bottom: 1px solid #bfbfbf;
    padding: 0;
    width: 370px;
    line-height: 3em;
}

由于我们将label的字体颜色调浅了，于是input元素的placeholder的颜色看起来太黑了。

placeholder在页面上并不是一个独立的元素，调整placeholder需要使用一个新的CSS选择器，伪元素选择器。

/*
    伪元素选择器，可以选中一些不为元素的特殊内容
*/
.signup-form-item-input::placeholder {
    color: #bfbfbf;
}

最后调整一下这部分整体的边距。

.signup-form-items {
    margin: 50px 0;
}

美化提交按钮

提交按钮的美化与上述方法类似，直接看代码：

<!-- 省略其它部分代码 --> 
<div class="signup-form-submit">
	<input name="submit" type="submit" class="signup-form-submit-button" value="Sign up">
</div>

.signup-form-submit {
    margin: 20px;
}

.signup-form-submit-button {
    display: block;
    width: 150px;
    margin: 20px auto;
    line-height: 3em;
    color: white;
    background-color: #4e66b1;
    border: 0;
    border-radius: 20px;
    box-shadow: 0 0 5px #4e66b1;
}

装饰

现在，整体上看起来表单的下方看起来有些空，视觉上画面向左上角倾斜。最后我们使用CSS绘制一些基本形状平衡一下页面。

<div class="signup-form-footer">
    <div class="signup-form-footer-circle-1"></div>
    <div class="signup-form-footer-circle-2"></div>
    <div class="signup-form-footer-circle-3"></div>
</div>

.signup-form-footer-circle-1 {
    position: absolute;
    right: 0;
    bottom: 0;
    transform: translate(50%, 50%);
    width: 150px;
    height: 150px;
    background-color: rgba(78, 102, 177, 0.3);
    border-radius: 50%;
}

/* 省略其它相似代码 */

至此，我们页面的样式部分完成。

提交表单前的检查

在用户注册时，为了避免用户意外的输入了错误密码，导致账户再也无法登录，所以通常会要求用户输入两边密码予以确认。

我们需要使用脚本代码，在用户提交表单时，检查用户的两次输入是否一致。如果不一致应该阻止表单的提交，并提醒用户错误原因。

在<form>标签中使用onsubmit属性，可以监听到用户提交表单的事件。并且当事件发生时，还会产生一个event变量，可以作为参数传入自定义函数，以获取用户的输入，或阻止事件的发生。

<form class="signup-form" onsubmit="checkPassword(event)">

通过event.target可以获取用户的表单输入。表单中密码input元素的name为password，就可以使用event.target['password']得到用户输入的密码。

通过将event.returnValue = false即可在脚本中取消事件的发生，即阻止用户提交表单。

function checkPassword(event) {
    // 获取表单中用户输入的内容
    password = event.target['password'].value
    confirmPassword = event.target['confirm-password'].value
    if(password !== confirmPassword){
        // 提醒用户输入有误
        alert("Please confirm your password!")
        // 阻止表单继续提交
        event.returnValue = false
    } 
}

为了进一步提升用户体验，我们还可以在用户输入有误时，使用特殊的样式标记出有问题的表单项。这可以通过为相应input元素添加新的样式类来实现。

.signup-form-body-item-input-error {
    border-bottom: 1px solid red;
}

function checkPassword(event) {
    // 获取表单中用户输入的内容
    password = event.target['password'].value
    confirmPassword = event.target['confirm-password'].value
    if(password !== confirmPassword){
        // 提醒用户输入有误
        alert("Please confirm your password!")
        // 修改密码输入框的样式，让用户注意到出错处
        event.target['password'].classList.append("signup-form-body-item-input-error")
        event.target['confirm-password'].classList.append("signup-form-body-item-input-error" )
        // 阻止表单继续提交
        event.returnValue = false
    } 
}

小结

通过本次的练习，我们了解了如何综合使用 HTML，CSS，JS完成一个有实际功能的页面，相信你对如何进行网页开发有了更深的认识。

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

在上一节课，我们了解了如何在网页中加入表单组建，使得用户可以在页面输入内容，获得更加完整的交互体验。

用户的输入未必总是合理的。

比如在注册用户帐号时，需要用户输入登录密码。但因为密码输入框的字符会以密文显示，很难保证用户确实输入了自己预想的内容。

因此，绝大部分的网站都会要求用户再次输入密码进行确认，如果两次输入内容不一样，则说明用户的输入出现了问题，应该要求用户重新输入，而不是继续提交表单。

如何判断用户的两次输入是否一致，并且在完成判断后执行不同的动作呢？

判断语句

判断语句是在JS脚本中实现对两个值进行比较的运算。

比如：

// 运算结果为true
3 < 5
// 运算结果为false
4 > 8

与赋值号=相似，这里的>、<也不同于数学中的“大于”或“小于”的概念，不意味着左边一定“大于”或“小于”右边，而是一次判断动作，比较两边值的大小，并返回是否与之相符的结果，如果相符则返回正确true，否则返回错误false。

true和false是一种专有的数据类型，称作布尔类型，所以也可以将其赋值给常量或者变量。

const t = true
const f = false
let result1 = 3 < 5
let result2 = 4 > 8

除了>、<之外，还有其它一些常用的判断运算符号：

• >=大于等于
• <=小于等于
• ===等于
• !==不等于

布尔类型之间也可以进行逻辑运算：

• &&与运算，即两个布尔值都为true，结果为true，否则为false；
• ||或运算，即两个布尔值都为false，结果为false，否则为true；
• !非运算，对一个布尔值取反，即将true变为false，将false变为true

const t = true
const f = false
// 结果为false
const and = t && f
// 结果为true
const or = t || f
// 结果为false
const not = !t

|符号在日常生活中不太常用，它通常位于键盘回车键的上方。

如果想要比较用户的两个次输入之间的内容是否相同，就可以使用判断语句：

<label>password</label>
<input id="input1">
<label>confirm password</label>
<input id="input2">
<button onclick="testSame()">the same?</button>

// 定义一个函数方便从input元素中获取用户输入
function getValueFromInput(id) {
    const dom = document.getElementById(id)
    const value = dom.value
    return value
}

// 判断两个输入是否相同
function testSame() {
    const input1 = getValueFromInput('input1')
    const input2 = getValueFromInput('input2')
    const result = input1 === input2
    alert(result)
}

流程控制

完成了判断，接下来要根据判断的结果执行不同的动作，这也称作流程控制。

我们知道脚本在正常的情况下是从上向下依次运行的，只有在遇到函数时会跳转至函数定义的位置，运行函数体内部的脚本，在函数运行结束后还要返回原来的位置继续向下执行。

这样的流程称作顺序结构。

顺序结构很有用，就像在听音乐的时候，我们可以把多首歌放到播放列表中，依次欣赏。

突然，听到了一首特别喜欢的歌曲，想反复收听。也就是说，这首歌曲播放结束后，不要切换到下一曲，而是进行单曲循环。

这样的流程被称为“循环结构”。

循环结构

在js中实现循环结构很简单。

比如，下面这段代码中，我们让一个初始值为0的变量x的值+1；

// 为x设定一个初始的值
let x = 0;
// 让x的值+1
x = x + 1;

通过循环结构，让+1这个动作反复运行。

首先，我们需要使用{}把需要反复运行的脚本包裹起来：

// 为x设定一个初始的值
let x = 0;
{
    // 让x的值+1
    x = x + 1;
}

然后，我们需要使用do关键字，通知浏览器{}中的这段脚本，需要被反复运行：

// 为x设定一个初始的值
let x = 0;
do {
    // 让x的值+1
    x = x + 1;
}

循环一旦开始，浏览器就会反复运行这段代码，周而复始，直到地老天荒。这通常不是我们想要的效果，所以最后也是最关键的，需要使用while关键字和一个判断语句，告诉浏览器是否还要继续循环下去。

比如当x的值不大于100时，即x<100为true，需要继续进行循环。

// 为x设定一个初始的值
let x = 0;
do {
    // 让x的值+1
    x = x + 1;
} while(x < 100)

上面这段代码中，x=x+1将会被反复运行100次，直到x的值被增加到100时，x<100为false，循环结束。

通常在一段循环中，都会一个类似x的变量，随着循环的进行值一直会的改变，用于在合适的时候退出循环结构。这样的变量被称作标记flag，定义它的动作，也被形象的称作“立flag”。

你所立flag最后都会被改变，这就是网络梗“立flag”的来历。

flag很必要，但除了维持循环，通常没有功能上作用，所以为了方便阅读，可以使用for关键字将与flag相关的代码写在一起：

// for循环中的三句话分别是：
// flag是谁，flag倒下的条件，每次循环flag如何变化
for(let x = 0; x < 100; x = x + 1) {
    // do something...
}

选择结构

除了单曲循环，还有的时候也许我们会想切歌，即跳过一段脚本。

如果有一段脚本每次都要跳过，其实可以不写的，所以是否要跳过某段脚本前，通常需要进行一次判断。判断结果为true则执行，否则则跳过。

有选择的执行，这样的流程被称作选择结构。

比如，我们希望实现对变量y求绝对值的效果，即如果y的值小于0，则让y设定为相反数：

let y = -100
y = 0 - y

首先，同样需要使用{}来包裹需要选择执行的脚本：

let y = -100;
{
    y = 0 - y;
}

接下来使用if关键字，表示是否执行的该脚本的条件：

let y = -100;
if (y < 0) {
    y = 0 - y;
}

最终因为y的初始值为-100，于是取相反数的语句被执行，最终y值为100。

加入页面

我们可以在页面中加入合适的流程控制，以在用户提供了不同的输入时，给到不同的响应。

例如，对用户的两次输入进行判断：

<label>password</label>
<input id="input1">
<label>confirm password</label>
<input id="input2">
<button onclick="submit()">submit</button>

function submit() {
    const input1 = getValueFromInput('input1')
    const input2 = getValueFromInput('input2')
    // 判断两个输入是否相同
    // 如果相同  
    if(input1 === input2) {
      alert("Confirm successfully!")
    }
    // 如果不同 
    if(input1 !== input2) {
       alert("Failed! Check your inputs!")
    }
}

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

在上节课，我们了解了使用<input>输入框，让用户可以在网页进行输入，并在代码中获取用户输入的内容。

不过可以输入任意字符的输入框也带来了很多问题，比如上节课中在计算平均值时，产生的数据类型问题，导致无法得到正确的计算结果。

相信你一定在某些网页上见过只能输入数字的输入框，或其它特定类型的输入框，比如日期、时间等等。

形式也不只是敲入文字，也可能是下拉菜单、复选框等等。

这些形式丰富的输入方式，通常会成组出现，要求用户一次性的填写多个输入，并提供一个完成或提交按钮，表示用户完成了所有的输入。

因此这样的一组输入就称为表单Form，这些相关的输入元素也称为表单组件。

输入类型

想要实现其它类型的输入框，在不久以前是非常麻烦的事情，需要工程师自己编写大量代码去实现，不过HTML5的出现，把多种常用的输入框类型纳入了标准，让事情变得非常简单。

HTML5在<input>标签中拓展了type属性，直接支持了丰富的组件类型。

比如我们需要一个日期组件，设置type属性为date即可：

<label>Select Date:</label>
<input type="date">

类似的，时间组件：

<label>Select time:</label>
<input type="time">

颜色组件：

<label>Select color:</label>
<input type="color">

文件选择组件，通常用于让用户上传文件：

<label>Select file:</label>
<input type="file">

数值输入，只允许输入数字：

<label>Input number:</label>
<input type="number">

密码输入，输入的内容将以密文样式显示，通常是·或者*：

<label>Input password:</label>
<input type="password">

选项输入

如果希望用户可以从我们给到的选项中选择其中一个或多个，这样就需要在页面中提供预设的选项。

下拉菜单（自动补全）

最直接的方法是使用下拉菜单（自动补全）。

使用<input>标签的list属性，配合<datalist>及其子标签<option>使用。注意，list属性的值要与<datalist>的id一致，以说明该输入框对应的列表是哪个。

<label>Select an option:</label>
<input list="options">
<datalist id="options">
    <option>Alice</option>
    <option>Bob</option>
    <option>Cindy</option>
    <option>David</option>
</datalist>

单选框

单选框也可以实现选项的效果，而且这样用户就不能自由输入内容了，以确保内容与选项严格相同。

由于单选框是HTML早期标准中定义的，代码看起来会和上面提到的其它输入框略所不同。

每一个选项都需要使用一个<input>来定义，并且将type设定为radio。一组选项之间要共享同一个name，以确保浏览器知道那几个选项是相关的，同时只能选中其中的一个。选中后的值，来自于value属性，而不是页面中<label>元素显示内容。

<input type="radio" name="radio" value="Alice"> 
<label>Alice</label>
<input type="radio" name="radio" value="Bob"> 
<label>Bob</label>
<input type="radio" name="radio" value="Cindy"> 
<label>Cindy</label>
<input type="radio" name="radio" value="David"> 
<label>David</label>

多选框

多选框允许用户一次选中多个选项，语法与单选框基本相同，只不过type需要换成checkbox。

<input type="checkbox" name="checkbox" value="Alice"> 
<label>Alice</label>
<input type="checkbox" name="checkbox" value="Bob"> 
<label>Bob</label>
<input type="checkbox" name="checkbox" value="Cindy"> 
<label>Cindy</label>
<input type="checkbox" name="checkbox" value="David"> 
<label>David</label>

提交表单

和上节课所提到的方法一样，任何一个表单组件都可以通过对应的DOM对象，在js代码中获取用户的输入。

但相比一个组件一个组件处理，更加方便的是将表单作为一个整体，一次性提交。

首先，需要使用<form>将所有需要一次性提交组件包裹在一起：

<form>
    <label>Select Date:</label>
    <input type="date">
    <!-- 这里省略若干代码 -->
</form>

其次，要给每一个<input>命名，即添加name属性，有时也称作表单的字段，以保证收到表单的“人”可以知道每个输入来自于哪个输入框。

<form>
    <label for="date">Select Date:</label>
    <input type="date" name="date">
    <!-- 这里省略若干代码 -->
</form>

值得一提的是，也可以使用id属性实现相同的效果，不过name的语义在此处更加明确。

然后，需要在表单中增加一个提交按钮，是一个type为submit的特殊输入框，这个输入框的value将显示在按钮上。

<form>
    <label for="date">Select Date:</label>
    <input type="date" name="date">
    <!-- 这里省略若干代码 -->
    <input type="submit" value="submit">
</form>

最后，为了获取用户的输入，还需在<form>标签中添加action属性，以通知浏览器将表单数据提交到哪个地址。

<form action="form-accepter.html">
    <label for="date">Select Date:</label>
    <input type="date" name="date">
    <!-- 这里省略若干代码 -->
    <input type="submit" value="submit">
</form>

默认情况下，表单中的数据将以URL参数的形式进行传递。服务器在收到这个URL请求时，会对数据进行一些处理，比如进行存储，然后再将处理结果以新的页面显示给用户。

具体如何在服务器端处理表单数据，涉及较多的后端知识，此处不再展开。

表单的应用

有了这些类型丰富的表单组件，你组建几乎任何类型的表单了，而表单可以说是网页中最重要的功能。

小到只有一个输入的搜索框：

用户注册时要提交的各种基本信息：

甚至我们在电商、外卖平台下的每一个订单其实都是在提交表单：

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

在上节课，我们了解了函数可以封装批量的脚本代码，使得复杂功能可以一处定义，多处使用，使得调用更加简单。

调用函数时，需要向函数传递一些参数，以实现对应的功能。比如，在上节课实现的求平均数的函数：

// 定义平均数函数
function mean(a, b) {
    let sum = a + b
    let avg = sum / 2
    return avg
}

// 调用函数求1和2的平均数
c = mean(1,2)

现在这个函数还仅仅只能在代码中被调用，如果可以将它通过某种形式开放给用户，网页就提供了一个求平均数的功能。

这时函数的参数应该来自于用户的输入，但是如何获取来自用户的输入呢？

输入框

HTML中提供了<input>的标签，用于在页面上提供基本的输入框。

<input>

与图片标签相似，<input>是一个inline行内元素，不会独自占有一行。又因为不能包裹其它的元素，它只有开始标签，没有结束标签。

莫名出现的输入框会让用户感到困惑，为了提醒用户该用户框的作用，<input>标签提供了placeholder属性，以提供占位内容。当该输入框内没有用户输入时，将显示占位内容。

<input placeholder="type somethings here">

另一个常见的做法是在输入框前面加上提示的文字或图标，你可以使用任何的行内元素实现这个效果，W3C推荐使用语义更加明确的<label>标签。

<label>1st Number:</label> 
<input>
<span>2nd Number:</span> 
<input placeholder="type somethings here">

除了语义更加明确，<label>标签可以在被用户点击时，自动跳转到对应的输入位置，方便在较小的屏幕下进行操作。

为了在代码层面指明<label>与其对应的<input>是哪一个，要指明<input>的id的同时，在<label>中使用for属性。

<label for="a">1st Number:</label> 
<input id="a">
<span>2nd Number:</span> 
<input placeholder="type somethings here">

获取输入

有了输入框元素，便可以在脚本中获取用户输入的内容，方法同样是通过document.getElementById()获取输入框元素对应的DOM对象。

我们定义一个获取输入框A内输入的函数，并绑定在按钮上，以便查看运行效果。

function getValueFromInputA() {
    // 获取InputA的Dom对象
    const input_a = document.getElementById('a')
    // input_a.value就是用户在输入框中输入的内容
    const a = input_a.value
    // 弹出a的值
    alert(a)
    // 将值返回到函数调用处
    return a
}

<button onclick="getValueFromInputA()">show content</button>

同样的方法也可以获取第二个输入框中内容，代码非常的相似，可以改造一下getValueFromInputA()函数，可以通过传递参数获取任一输入框的内容。

// 参数为输入框DOM的id
function getValueFromInput(id) {
    // 获取Input的Dom对象
    const input = document.getElementById(id)
    // 输入框中输入的内容
    const value = input.value
    // 弹出值
    alert(value)
    // 将值返回到函数调用处
    return value
}

第二个输入框也需要配置id属性。

<span>2nd Number:</span> 
<input placeholder="type somethings here" id="b">

添加一个新的按钮，同时修改原来的按钮监听属性中的脚本。

<button onclick="getValueFromInput('a')">show content in 1st</button>
<button onclick="getValueFromInput('b')">show content in 2nd</button>

数据类型

现在我们可以获取用户的输入了，就可以计算平均值了么？

别急，先尝试使用代码将获取到的两个数值求和，看一下计算结果。

function sum() {
   const a = getValueFromInput('a')
   const b = getValueFromInput('b')
   alert(a+b)
}

<button onclick="sum()">sum</button>

123+321=123321 ？？这么简单的计算怎么出错了呢？

这是数据类型导致的问题！

用户在输入框内输入的内容未必是数字，可以是任意的内容，比如是’hello’和’world’。这些由若干字符组成的内容，称作字符串。

字符串如何求和呢？JS将会把两部分内容直接前后连接起来，作为计算结果，如’helloworld’。

因为无法确定用户会输入什么，因此会把任何输入内容，即使是数字，也看作字符串进行处理，于是就出现了123+321=123321。

数字和字符串就是不同数据类型，数据类型会影响计算时的运算规则。相比C和Java语言，JS是一个弱类型的语言，语法中不强调常量、变量的类型，但依然有所区分。

下面代码分别定义了数字123和字符串123：

// 定义一个数字常量
const num = 123
// 定义一个字符串常量(单引号、双引号都可以)
const string = '123'

JS也提供了函数可以将两种数据类型相互转化：

// 将字符串转变为整数
const string_to_num = parseInt(string)
// 将字符串转变为浮点数（含小数点的数）
const string_to_num = parseFloat(string)
// 将数字转变为字符串
const num_to_string = num.toString()

实现求平均值

我们继续改造一下getValueFromInput()函数，让其直接返回数字类型的数据。

// 参数为输入框DOM的id
function getValueFromInput(id) {
    // 获取Input的Dom对象
    const input = document.getElementById(id)
    // 输入框中输入的内容
    const value = input.value
    // 弹出值
    alert(value)
    // 将输入转变为数字（浮点数）
	const num = parseFloat(value)
    // 将数字值返回到函数调用处
    return num
}

求平均数：

function avg() {
   const a = getValueFromInput('a')
   const b = getValueFromInput('b')
   const avg = (a+b) / 2
   alert(avg)
   return avg
}

绑定按钮：

<button onclick="avg()">avg</button>

我们终于实现了一个简单的平均数计算问题，过程中使用了数据类型的转化，使得用户输入的字符串转变为数字。但我们无法确保用户输入的一定是数字，依然可能会出现计算问题，我们下节课来解决这个问题。

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

通过上节课的学习，我们知道了把脚本代码统一放到<script>标签里，可以以更加舒服的姿势来写脚本。

但还遗留了一个问题：<script>标签里的脚本在页面加载时会立刻运行，而不是监听到用户的操作后再运行。

有时候这很有用，比如当我们打开一个网页看视频，会希望视频在页面打开后立刻播放，而不是等用户点击播放按钮后播放。

但是在更多的时候，我们还是希望当监听到用户的操作时，再运行对应的脚本。

本节课，我们就来解决这个问题。

自定义函数

先回顾一下使用on*****进行监听启用脚本时的代码。

<button onclick="alert('hello')">点我</button>

根据这行代码，用户在点击这个按钮元素时，浏览器将弹出提示窗口。

这里的alert()就是浏览器提供的功能，在更多时候会称作函数，这是个习惯问题，在英语里都是function。

一个函数可以看作由若干基本的脚本组成的整体，有特定的效果并且有一个专属的名字。除了浏览器定义好的函数，我们也可以自定义一些函数。

自定义的函数需要写在<script>标签里，基础语法如下：

<script>
	function func_name(arg) { do something }
</script>

function与定义常量时写的const类似，也是一个关键字，告诉浏览器，这行代码要定义一个函数。

尽管你可以随意的给函数起名字，但最好还是与函数实际要做的事情一致为好，否则过了一段时间之后，可能自己也会忘记定义的函数是做什么用的了。

在括号内列出函数所需要的参数，多个参数可以使用,隔开。

参数对函数很重要，它是函数运行时要参考的值，也直接影响了函数运行的效果。比如在alert('hello')中的'hello'就是alert()函数的参数，它直接决定了要在页面上弹出的内容是什么。

在定义函数的时候，我们并不知道未来会传入的参数会是什么，于是在定义函数时会使用一个常量来指代参数的值，以方便书写函数功能时使用，这里的常量也称作参数名。

有的书上，称参数名为型参parameter，参数值为实参argument。

最后的代码片段是函数的主体，里面是所定义的函数的功能，里面的代码将会依次运行。

作为例子，这里我们定义了一个名为greet的函数。

<script>
	function greet(name) { alert('hello'); alert(name); }
</script>

这个函数主体中有两句代码，都是alert()函数。第一个alert()函数将会要求浏览器弹出一个'hello'，第二句要求浏览器弹出参数name所具有的参数值。

接下来，就可以在元素的监听属性中使用这个自定义函数。

<button onclick="greet('world')">点我</button>

这个函数被调用的时候，浏览器将依次弹出两个提示窗口，分别为hello和world。其中world即为name的参数值。

在一行里写太长的代码不方便阅读，最好将每一句代码放到单独的一行中，例如：

<script>
	function greet(name) { 
        alert('hello'); 
        alert(name); 
    }
</script>

现在，我们写在<script>标签中的代码就不会在页面加载时立刻运行了，而是当监听到用户操作时，触发了相应的函数，才会运行函数中的代码。

简便起见，在本课程后面的部分，当我们再写JS代码时，就省略<script>标签，直接写内部的代码了。

函数把批量的代码封装在一起，对外给出一个更加清爽的调用方式，实现了复杂功能的“一处定义，多处使用”，增强了代码的可读性和可维护性。

计算与变量

函数还很擅长实现复杂计算。

计算是计算机最基本的能力了，在网页中也会大量使用。比如在渲染页面元素时，需要根据其样式属性计算它们在页面中的（绝对）位置，浏览器才知道如何进行正确的渲染。

再比如在网页中实现购物功能，需要能根据商品单价和数量算出总价。

在JS中实现计算非常的容易，以下代码实现了对两个常量的求和：

const num1 = 3
const num2 = 7
// 求和
const sum = num1 + num2
// 求差
// const diff = num1 - num2
// 求积
// prod = num1 * num2
// 求商
// quot = num1 / quot
alert(sum)

请切记，这里代码中的=并不是数学上的等于，而是赋值，即令sum的值为右侧的计算结果10。

如果需要把第三个常量也加进去。

const num3 = 2
const sum_ = sum + num3
alert(sum_)

因为常量的值无法修改，于是每进行一步计算都要定义一个新的常量，这也实在是太不方便了。

于是我们引入一个新的概念，变量variable。与常量不同，变量所存储的值是可以被修改的，也就是可以被多次赋值。

初次定义变量，需要使用let关键字。之后，如果对变量再次赋值（即修改变量值）则不必再写let

let v = 1
alert(v)
v = 3
alert(v)

这样当我们再次实现多个数相加时，只需定义一个变量记录结果即可。

let s = num1 + num2
s = s + num3
alert(s)

再次强调，=不是数学上的等于，而是赋值，即令s的值为右边的计算结果。

关键词var也可以用于定义变量，鉴于在较新的JS标准中，已经不再鼓励使用var，此处不再展开说明。

返回值与作用域

变量可以把计算的结果暂存，以便在其它需要的地方使用。

但如果计算的过程发生在函数内部，根据封装的思想，我们不希望在函数之外，还需要了解内部定义的变量名。

为此，函数提供了返回值的能力，即将函数的运算结果以匿名（不起名）的方式对外部提供。在外部可以使用任意的名字，将返回值定义为常量或变量。

例如，定义一个求平均数的函数mean：

function mean(a, b) {
    let sum = a + b
    let avg = sum / 2
    return avg
}

在函数的主体中，定义了变量sum和avg分别存储两个参数的和，以及其平均值。为了让外部程序可以获取avg的值，在函数的最后一行，使用了return语句将avg的值进行返回。

于是在函数外部，可以使用如下代码获取mean函数的返回值。

let c = mean(num1, num2)
alert(c)

返回值使得我们无须关心函数内部的变量名，即可使用函数的计算结果。

既然函数内部的变量名不再需要暴露给外部，更进一步，我们希望函数封装的更加严密一些，使得内部的变量名都只在函数内部有效，而不要穿透到函数外部去，“污染”公共空间。

这样的变量（常量）称作局部变量（常量）。在函数内部，使用let（const）定义的变量（常量），都是局部变量（常量）。这个变量（常量）有效的工作范围，也称作作用域或者 闭包。

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

在上节课，我们了解了一些脚本的基本用法。

使用脚本可以让我们有能力重写页面，或者通过获取页面中元素对局部进行修改。但无论要重写页面，还是要进行局部修改，我们都需要借助DOM对象。

再次强调「对象」是一个很重要的概念。

可以把「对象」理解为虚拟世界中的物体或者东西，比如浏览器、页面、页面中的元素等等，甚至一个用户、一则浏览记录、一组数据都是「对象」。

每个对象都有一些字段field与功能function，在js中统称为属性property。

在更多的场合里，大家更习惯称对象的功能为方法或函数，称字段为属性。我们的课程也将采取后者，即更加符合习惯的叫法。

为了区别我们之前已经学到的「标签属性attribute」和「样式属性property」，我们将使用「对象属性field」来称呼对象的字段。

比如，document是w3c标准中规定好的，用来指代整体页面的DOM对象，所以我们在脚本中可以直接使用它的属性或者方法。

document对象有一个属性URL，它的属性值便是当前页面的网址，在代码中可以通过document.URL来获取这个属性值。

配合alert()功能，可以把这个信息弹出来看一下：

alert(document.URL)

document对象还有一个方法getElementById()，完整的写法为document. getElementById()，通过它可以获取指定id的页面元素。具体使用方法，在上节课已经有所演示，这里不再重复。

可以看到，无论是属性还是方法，都可以在对象的后面紧接着使用.来进行访问access。

大多数情况下，在方法名字的后面，我们会紧接着使用一对()，表明立刻执行这个方法，这个过程有的时候也称作方法的调用call。

你可以通过阅读W3C的文档了解更多的属性和方法。

本节课，我们将通过对页面中的局部元素进行修改，了解如何使用DOM对象的属性和方法。

修改元素内容

让我们回到上节课script.html的代码里。

<p id="greeting">hello, world!</p>
<button onclick="
    const paragraph = document.getElementById('greeting'); 
    alert(paragraph)
">click here</button>

这段代码，通过document.getElementById('greeting')获取到页面的一个p元素的DOM对象，并使用常量paragraph来代指它，然后通过alert()弹出来。

p元素的DOM对象有一个innerText属性，存储着元素内部的文本，我们可以把上面代码的最后一句改为alert(paragraph.innerText)来看一下效果。

<p id="greeting">hello, world!</p>
<button onclick="
    const paragraph = document.getElementById('greeting'); 
    alert(paragraph.innerText)
">click here</button>

可以看到我们确实获取到了p元素中的文本内容。

你可以通过查询w3c的官方文档来了解每一类DOM对象的方法和属性。

如何修改文本内容呢？我们又要用到神奇的=。

paragraph.innerText = 'hi, world!'

这段代码可以将paragraph的内部文字改为hi, world!。

在常见的计算机语言中，=的含义都不同于数学上等于，而更加接近于<=，意思为赋值，即将等号右边的内容所代表的值，传递到左边。

我们在等号的后边使用了一个字面量'hi, world!'，它所代表的值即是hi, world!。=将这个值传递到左边，覆盖p元素的innerText对象属性原本的值，于是便实现了p元素内部文本内容的修改。

使用下面的代码可以看到整体的效果。

<p id="greeting">hello, world!</p>
<button onclick="
    const paragraph = document.getElementById('greeting'); 
    paragraph.innerText = 'hi, world!'
">change text</button>

修改元素样式

当然，除了修改元素的内容以外，我们还可以修改它的样式。

修改样式需要用到DOM对象的style属性，用法与上面的innerText非常类似。

将css代码的字面量赋值给paragraph.style，便可以改变元素的样式。

paragraph.style = 'color: white; background-color: red'

有些时候，我们并不希望将元素的整个样式改掉，而只是希望修改它的一些样式属性。

幸运的是，paragraph.style也是一个DOM对象，几乎每一个可用的css样式属性，都在这个DOM对象里以对象属性的形式存在，我们可以轻易的使用。

paragraph.style.width = '200px'

如果配合css的类选择器，还可以通过向p元素增加class的方式来修改元素的样式。

.title {
  text-align: center;
  font-size: 50px;
  background-color: black;
  color: white;
}

paragraph.className = 'title'

添加和删除元素

除了丰富的对象属性，DOM还有很多的对象方法，通常用于把对象看作一个整体时的一些操作。

比如remove()方法，可以用来删除元素。

paragraph.remove()

这个方法将会从页面把p元素整体移除，不仅是元素内部的文字，也包含着元素在页面上所占的位置，以及我们对其设定的任何样式，都会消失不见，不留下任何痕迹，仿佛从来没有出现过一样。

添加元素会比删除相对复杂一些。

首先，我们要创建一个新元素，这需要使用docment.createElement()。

const goodbye = document.createElement('p')
goodbye.innerText = 'Byebye!'

这时虽然元素被创建了，但是目前并没有被放置到页面的任何一个位置里。

这有点像在我们经营着一家饭店，目前后厨已经做好了菜，接下来还需要让服务员上菜。

所以接下来，我们需要使用document.getElementById()，获取一个元素，也就是「服务员」，通过它来定位上菜的位置。

const greeting = document.getElementById('greeting')

现在我们可以选择将菜上到服务员的前面，或者后面。

greeting.before(goodbye)
greeting.after(goodbye)

还有的时候，我们是要向某个父元素中插入子元素。

const secendGreeting = document.createElement('i')
secendGreeting.innerText = 'How are you?'
const greeting = document.getElementById('greeting');
greeting.append(secendGreeting)

script标签

与我们在讲CSS样式代码时提到的<style>标签类似，脚本也有自己的专属标签<script>。

使用<script>标签，可以让我们的脚本代码与HTML分离，提高了代码整体的可维护性。

比如，我们将上面插入子元素的脚本放到<script>标签中：

<script>
    const greeting = document.getElementById('greeting')
    const secendGreeting = document.createElement('i')
    secendGreeting.innerText = 'How are you?'
    greeting.append(secendGreeting)
</script>

重新加载一下页面你会发现，我们并没有点击按钮，脚本就已经生效了。

在<script>标签中的脚本，与在on******监听属性中的不同，它不会等待某个事件发生才执行，而是在加载load时会立刻执行。

但如果仅仅是这样的话，<script>标签好像就不能代替on******监听属性，无法实现我们分离JS和HTML的初衷了。

没关系，我们会在下一节课解决这个问题。

<script>标签应该写在哪呢？

理论上<script>标签也是一种元信息，应该放到<head>标签下，但实践中并非如此。

因为用于网页传输的http协议，是一种「流式」传输协议。所谓流式传输，就像我们在线看视频的缓冲，我们并不需要等待整个视频下载完毕才能播放，而是可以边看边缓冲。

网页也是类似的，它不会等待整个网页的代码全部传输完毕才显示页面内容，而是传输了多少，就加载多少。

这样的一种「流式」的特性，与上述的「加载即执行」的特性，结合在一起带来一个问题：脚本中所要获取的DOM元素，很有可能还没有传输过来，导致脚本执行失败。

所以在实践中，经常可以看到包含了操作DOM元素脚本的<script>标签，被放到<body>的最最后。其他的辅助脚本，比如一些三方库会放到<head>标签中。

如果你忘记了元信息和<header>标签，你可以回到《06 层叠样式》一节中查看一下。

延伸阅读：脚本与程序

通过本节课的学习，我们可以看到对象，特别是DOM对象，是JS脚本中最为核心的概念。

这样的一种思想，被称作面向对象编程（OOP，object-oriented programming ），JS语言也被称作是一种面向对象的语言。

但是也经常会在网络看到质疑JS语言是编程语言的说法，这是怎么回事呢？

这是因为这里有一个经常会被人忽略，从而引起误会的点：脚本中描述的动作，实际上是浏览器做出的，而不是脚本自身。

也可以这样理解，脚本里面列出了诸多命令。而浏览器按照约定的顺序阅读脚本，对脚本的含义进行「解释」，从而做出对应的反应。

这里的约定便是「脚本语言」的语法。

这样的特性，使脚本区别于经典意义上的「程序」——即那些二进制的可执行文件，也就是那些可以被电脑硬件直接理解的家伙们。

直接控制硬件，而不需要「解释」的过程，使得程序的工作效率非常的高。

浏览器就是一个「程序」，我们从网络上下载回来的是它的可执行文件，而不是它的源代码。

敲黑板：「程序」是二进制可执行文件，不是代码！

但我们如果想要开发一个程序，也不太可能直接编写二进制，而是先写成适合人类阅读的语言，然后翻译成二进制。

这种语言就是「编程语言」，翻译的过程称作「编译」。

这样看来，「脚本语言」确实不是严格意义上的「编程语言Programming language」。

脚本语言本身并不执行什么，而是用于串联其他的程序，因此有时候也会被称为「胶水语言Glue language」。

但时至今日，编程语言与脚本语言的边界越来越模糊：

有一些非常流行脚本语言，例如JS，为了提高运行的效率，也是会被编译的。

最早在Chrome浏览器中引入的V8引擎，就采用了这样一种机制，它接收JS代码，会先进行编译，得到可运行的程序，然后再执行程序。

V8使得网页处理脚本的速度获得飞跃，也才使得Web App网页应用成为现实，为网页技术的发展掀开了新的篇章。

而没有采用类似机制的IE6，从此逐渐走上了末路。

基于V8引擎的NodeJs，将JS语言带入到后端开发的世界里，它在高IO场景下的出色表现，使其如今以及成为最流行的后端技术路线之一。

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

上节课，我们了解了网页的交互能力，我们说到交互的三要素是事件、监听和脚本。

整个的交互过程特别像是在钓鱼：

网页元素开启的「监听」，仿佛是用来捕获「事件」的「钩子Hook」，静静地等待着咬钩。一旦「事件」上钩，就会立刻通知浏览器启动接下来的收网动作。

收网动作通常会由很多的步骤组成，起杆、收线、起鱼等等，而这些步骤就是我们所预设的「脚本」。

在网页上实现交互，需要使用脚本语言Script language来编写脚本。

脚本语言有很多，比如高度流行的Python、优雅的Ruby、在游戏开发中常用的Lua等等。

专为浏览器而生的Javascript，简称JS，被W3C选入Web标准，成为今天在网页中几乎唯一能用的脚本语言。

我们本节课就来初步了解一下JS。

重写页面

在上节课，我们写了一个非常简单的脚本alert()，用来在浏览器窗口中弹出一个提示框。

​脚本还可以让页面根据用户的操作发生一些变化，比如说当用户点击了一个按钮，就让页面显示出新的内容。

使用document.write()脚本，可以让我们向页面添加内容。

创建一个新的文件script.html来体验一下这个脚本。

在页面中放置一个按钮，并为它添加鼠标点击的监听以及响应事件的脚本。

<button onclick="document.write()">click here</button>

在浏览器中点击按钮，发现页面变成了一片空白，页面被脚本重写了。

请注意，这里网页的URL没有发生变化，说明我们的页面确实是被JS重写了，而不是通过超链接打开了新页面。

和alert()类似，我们可以通过添加额外的参数来告诉浏览器，要向页面中写入什么内容。

修改按钮监听中的脚本：

<button onclick="document.write('hello world')">click here</button>

可以看到，当我们点击下按钮，页面上的内容就被重写为了hello world。

除了写入简单的字符，还可以向页面中写入带标签的内容。

<button onclick="document.write('hello <b>world</b>')">click here</button>

可想而知，如果我们把另外一个网页的全部HTML代码都作为参数放到到这个脚本中，点击这个按钮就可以为用户重写一个全新的页面。

选取元素

通常，我们并不需要把整个页面全部重写，而只是需要修改页面中的局部内容，也就是修改某个元素，这就要求我们必须准确的指明要修改的元素是哪个。

还记得我们在CSS中也有类似的需求么？我们在CSS使用选择器，就可以告诉浏览器将对应样式应用在选择器选中的元素上。

遗憾的是，JS没有提供通过CSS选择器来选中元素的功能，但是元素标签中的id属性，仍然可以帮助JS获取元素。

一些JS的扩展库，如jQuery提供了使用CSS选择器选中元素的功能。

我们先为元素添加上id属性。

<p id="greeting">hello, world!</p>

这时，便可以使用document.getElementById()，来获取我们需要的元素了。

<button onclick="document.getElementById('greeting')">click here</button>

参数'greeting'帮助我们获取到了id为greeting的这个p元素。

但是如果这时按下按钮，什么都不会发生。因为我们仅仅是得到了一个元素，并没有告诉浏览器要对这个元素做些什么。

在对元素做进一步的操作之前，我们可以先用alert()来确认一下，是否成功选中了p元素。

请注意，使用alert()弹出内容，需要将内容作为参数放进括号里，所以我们需要把document.getElementById('greeting')这整句话放进括号里，像这样：

<button onclick="alert(document.getElementById('greeting'))">click here</button>

点击按钮看一下，它显示的不是hello world，而是[object HTMLParagraphElement]。

object指明了我们获取到是一个对象Object。对象可以理解为虚拟的物体，类似于我们现实中的桌子、汽车、鼠标等等，会有一些属性，还有一些功能。

比如汽车，就有尺寸、品牌、油耗等属性，还有行驶、刹车等功能。

在JS中，元素被看作是一种对象，而且是一种DOM（文档对象模型Document Object Model）对象，HTMLParagraphElement便是DOM中的一种，也就是p元素。

DOM对象的属性和功能都是由W3C制定好的，方便我们在脚本中使用。

代码document.getElementById()中的document也是一种是DOM对象，它拥有一个名为getElementById的功能。使用.便可以从对象中获取属性或功能。

我们会在下节课展开讲解DOM，并利用它们对页面内容进行修改。

常量

在下节课，我们将多次使用这个p元素，并对它进行操作和修改。

如果每次都用document.getElementById('greeting')来获取它，实在是太长太不方便了。所以先别着急，让我们先为它起一个临时的代号。

比如，我们可以用字母p来作为代号，代码如下：

const p = document.getElementById('greeting')

我们来看一下这里的新语法。

等号=的右边是原本获取元素的脚本document.getElementById('greeting') ，通过=，将它所得到的元素传递到左边的p中。

等号=的左边，p前面还有一个const，是常量constant的缩写，意为永远不变，不许修改的意思。

什么意思呢？

我们知道，在代数中经常使用字母x来表示变量，x的值是可以发生变化的，可以x=1也可以x=-0.5，有时候也可以用x ∈ [-1,1]表示x的取值范围。

相对的，const所指的常量，类似于我们给圆周率起名叫π，只要说到π就等于3.1415......，永远不会改变。

在我们的脚本中，使用const来约定了字母p作为一个常量指代p元素，这个过程也称作常量的定义defined。

如果尝试在脚本中使用一个没有被定义的常量，将会获得undefined。

当然，在命名常量时可以不止使用一个字母，我们也鼓励使用单词或词组来对常量命名，增强代码的可读性。

const paragraph = document.getElementById('greeting')
const paragraphElement = document.getElementById('greeting')

当使用词组时，可以使用驼峰法（Camel-Case）命名，即除了第一个单词以外，后面的单词首字母都使用大写。用这样的方法命名，一会高一会低，很像骆驼的驼峰，因此得名。

联合alert()，代码可以变成这样：

const paragraph = document.getElementById('greeting');
alert(paragraph)

让我们放进整体脚本中，看一下效果：

<button onclick="const paragraph = document.getElementById('greeting'); alert(paragraph)">click here</button>

提醒你，多个语句之间要使用;分割哦！

问题又来了，paragraph是常量的代号，那如果我们想要paragraph这个单词本身，也称作字面量literal，该怎么办呢？

给它加上单引号！

<button onclick="const paragraph = document.getElementById('greeting'); alert('paragraph')">click here</button>

这就是我们上节课中给参数加上'单引号的原因，用于区分常量和字面量。

延伸阅读：JS的诞生

JS名字里有个Java，却和那个著名的Java语言没有亲戚关系，甚至JS之父Brendan Eich还挺看不上Java的。

上世纪90年代，网景公司（Netscape）发布了历史上一个有商业意义的浏览器Navigator，但当时的网页就像咱们之前的网页一样，没有交互能力，只能用来浏览。

这个时候Java语言正是大红大紫，网景的高层就决定：未来的网页脚本语言必须"看上去与Java足够相似"，但是比Java简单，并起名叫Javascript。

网景员工Brendan Eich接到这一「简化Java」的重任。但是，他是一个函数式编程语言的忠实粉丝，对采用了对象式编程的Java并不喜欢。

为了应付公司安排的任务，他只用10天时间就把Javascript设计出来了。

它借鉴C语言的基本语法；借鉴Java语言的数据类型和内存管理；借鉴Scheme语言，将函数提升到"第一等公民"（first class）的地位；借鉴Self语言，使用基于原型（prototype）的继承机制。

"与其说我爱Javascript，不如说我恨它。它是C语言和Self语言一夜情的产物。十八世纪英国文学家约翰逊博士说得好：'它的优秀之处并非原创，它的原创之处并不优秀。'（the part that is good is not original, and the part that is original is not good.）"

参考资料：

阮一峰的网络日志 《Javascript诞生记》

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

经过前面的课程学习，我们已经基本上了解了网页中最重要的两个技术HTML和CSS了。

尽管还有很多有意思的标签和样式属性，我们没能在课程中展开，但是作为一个入门课程，现在的内容已经足够充分了🐶

但是如果我们花了这么大功夫只是让页面变得好看一些，我们大可去学习Sketch、Illustrator、Photoshop等设计软件，这些专门的设计软件可以让我们花费更少的时间和更少代码，却能达到更好的效果。

我们到底为什么要学习通过代码开发网页呢？

答案其实也很简单，网页作为一种媒体，在传达内容的时候有一种无与伦比的优势：可以与用户交互Interact！

所谓「交互」，就是说网页可以针对用户的一些操作进行「响应response」，或者说是「反馈feedback」。

比如，点击一个按钮、输入一些文字、手指进行缩放等等，用户的这些操作会触发网页中的「功能function」，使得页面显示的内容发生变化。

视频网站上的按钮可以打开或关闭弹幕。

「2048」游戏中，用户按下键盘的「上下左右」可以移动方块。

当然还有我们在综合练习中遗留下来的，当鼠标划过时显示导航栏的隐藏菜单。

这种好像启动隐藏功能的感觉，与使用超链接跳转到另一个URL完全不同，我们并没有打开一个新的页面，响应用户操作的就是当前页面本身。

可以说，正是因为网页有了这样「交互」能力，才使得它脱颖而出，成为网络资源中最流行的载体。

有一些网页设计的非常复杂，且功能强大，甚至有时候我们会称它叫做「网页应用」或「Web APP」。

好了，说了这么多，我们接下来就来看看如何在网页中实现交互。

交互三要素：事件、监听和脚本

交互的发生需要三个关键要素：

其一，用户的操作。会触发响应的操作称作事件Event，比如，鼠标单击事件click，双击事件doubleclick，触摸事件touch等等；

其二，用户操作的元素。网页中有大量的元素，通常只有其中的一些会去响应事件，而且只会响应一些特定的事件，比如，按钮button会响应单击，输入框input会响应键盘输入等等。如果一个元素有响应事件的能力，我们称这个元素开启了对应事件的监听Listen；

其三，用户操作所触发的响应，也就是页面内容所发生的变化。页面应该如何发生变化，则会被写进脚本Script里。脚本就像电影的剧本，当导演喊了「Action！」，各部门都将严格按照脚本中所写的内容和顺序执行动作，于是一场大戏就在我们的眼前上演。

事件是一切的起点，但却是我们开发人员没有办法控制的。鼠标、键盘都握在用户的手中，我们所能期待只能是用户会按照我们的预设逻辑使用页面。

为了达到这样的目的，需要网页的设计人员与用户斗智斗勇，将页面设计的更加符合人们的操作习惯和心理预期。这会是一个大话题，本课程不做展开。

我们接下来呢，要重点研究一下如何为元素开启事件监听，以及如何写脚本。

开启监听

为元素开启监听事件很容易的事情，只需要在开始标签的属性中添加进去要进行监听的事件和对应的脚本即可。

让我们在workspace中创建一个新的文件interact.html来体验一下。

我们在页面上添加一个按钮，为它添加鼠标单击事件的监听，并让它触发一个最简单的脚本——让网页弹出一个空白的提醒框。

<button onclick="alert()">点我</button>

如上面的代码所示，button标签可以向页面添加一个按钮，标签内包裹的内容，成为了按钮上的文字。

标签的on****属性就是为元素添加对应事件监听的属性，onclick意为「当单击事件发生时」。

类似的监听双击的属性为ondblclick，这里的dbl是double的缩写。

我们将监听属性修改为双击事件监听，看一下效果。

<button ondblclick="alert()">点我</button>

脚本

接下来，我们来看一下脚本部分。

监听属性的属性值，也就是双引号里的内容，就是对应事件的响应脚本。

<button onclick="alert()">点我</button>

在这段代码中，当按钮被单击时对应的脚本内容是alert()，这一段短短的脚本触发了网页的一个功能——弹出提醒框。

alert为「弹出提醒框」这个功能的名字，后面紧跟着的()意思为：不使用任何参数argument，立刻执行这个功能。

参数是什么意思呢？

当我们去使用一个功能的时候，通常提供一些额外的信息，比如使用alert弹出提示框时，通常不会是一个空白的提示框，我们总该告诉用户一些什么才对。

这时就需要在()中写入对应的内容，而这就是功能的参数。

<button onclick="alert('hello')">点我</button>

代码里的'hello'便是参数。

细心的你也许发现了，这段代码里的'hello'被单引号包裹了。你现在可以简单的理解为这就是语法的要求，更加详细的解释会在下一节课放出。

这时再单击按钮，则会弹出一个写有hello的提示框。

当然，脚本之所以为脚本，还要允许依次执行多个功能。

与style属性类似，在on****中也可以使用分号;来分割多个功能。

<button onclick="alert('hello'); alert('world')">点我</button>

这段代码会弹出两次提示框，内容分别为hello和world。

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

在之前的课程中，我们探讨的大多是一些元素级别的问题，这次让我们放眼整个网页，来研究一下网页的布局Layout问题。

布局的意义在于让网页中丰富的内容有机的组织起来，让用户更快的找到需要的信息。

说到布局，最经典的布局就是圣杯布局（Holy Grail Layout）了：

大概是因为头部和底部比较大，腰比较瘦，有那么一点像是圣杯的造型，因此得名。

圣杯布局也因为中间部分分割为了3个纵向排列的区域，所以也称作三栏式布局。

圣杯布局非常经典，所以很多很多的网站都采用了圣杯布局。

还有一些是简化版的圣杯布局，在中间部分省略为2个纵向排列的区域，也称作双栏式布局。

还有干脆只留下一个核心区的单栏式布局。

大部分的网页布局都可以通过综合使用「盒模型+定位+（我们没有讲的）浮动」来实现，在网络上很多教程里也是这样教的。

但是这个实现方法，多少会有一些「凑巧奏效」的感觉，经常会埋下很多的隐患，在后续的使用和维护中带来莫名其妙的Bug。

为了不让你陷入困境，本课程完全不打算向你讲解「浮动Float」是怎么回事，更不打算展开讲解「盒模型+定位+浮动」布局实现，而是向你介绍两个更现代的、更方便的布局实现方案：

Flex弹性布局和Grid网格布局。

弹性布局Flex

弹性布局是靠一种叫做「弹性元素」的容器来实现的。

「弹性元素」是一种特殊的「块级元素」，不过与块级元素强调的是「本元素要独占一行」不同，弹性元素强调的是它作为容器时的特性，即它的子元素们应该按照什么方式排列。

所谓容器呢，就是允许有子元素的元素。尽管很多元素都可以充当容器，但没有其它任何效果的div，是一个更受欢迎的容器。

通过将某个div的display: flex，即可将其变为弹性元素，也可以称为弹性容器Flex Container，其子元素则会自动变成弹性项目Flex Item。

让我们在workspace中创建一个新的文件layout.html来看体验一下效果。

.flex-container {
    display: flex;
}

.red-item {
    background-color: red;
    width: 120px;
    height: 120px;
}

.green-item {
    background-color: green;
    width: 120px;
    height: 240px;
}

.blue-item {
    background-color: blue;
    width: 60px;
    height: 120px;
}

<div class="flex-container">
    <div class="red-item"></div>
    <div class="green-item"></div>
    <div class="blue-item"></div>
</div>

可以看到在弹性布局下，最显著的变化是：原本应该独占一行的div子元素们，现在现在变成了横向排列，就好像把它们设置成了inline-block一样。

不用inline-block的好处除了减少了代码量以外，还体现了在软件设计中重要的哲学：「低耦合」，可以简单理解为「各司其职」。即容器里的子元素们管好自己的样式就好，如何排列这些子元素应该由容器来决定。

弹性容器就是这样一种负责任的容器，可以很方便的设定子元素应该如何排列。

比如说，可以设定子元素的排列方向：

.flex-container {
    display: flex;
    flex-direction: row-reverse; /* 反向排列 */
}

.flex-container {
    display: flex;
    flex-direction: column; /* 纵向排列 */
}

还可以设定元素之间的对齐方式：

.flex-container {
    display: flex;
    justify-content: center; /* 居中 */
}

.flex-container {
    display: flex;
    justify-content: space-between; /* 拉伸 */
}

.flex-container {
    display: flex;
    justify-content: space-around; /* 均匀 */
}

当然，还可以设定纵向的对齐：

.flex-container {
    display: flex;
    align-items: flex-end; /* 底部对齐 */
}

.flex-container {
    display: flex;
    align-items: center; /* 居中对齐 */
}

有了Flex，想要去实现圣杯布局就非常容易了，只需在这个容器的上面和下面分别放一个块级元素即可。

<div class="header"></div>
<div class="flex-container">
    <div class="red-item"></div>
    <div class="green-item"></div>
    <div class="blue-item"></div>
</div>
<div class="footer"></div>

网格布局Grid

「弹性布局」因足够的灵活，给了子元素充分的「活动空间」，所以称之为「弹性布局Flex」。

与之相对的，还有一种将子元素约束在某个准确位置上的布局方案称为「网格布局Grid」，也有翻译为「栅格布局」的。

在「网格布局」的世界里，页面将被划分为若干行和若干列，就好像是一张大的Excel表格，只不过网格线默认是透明的。

想要实现网格布局，同样需要一个网格容器，通过将某个div的display: grid，即可将其变为网格容器，其子元素将自动成为网格项目。

除此之外，还需要明确的定义这个网格有多少行和多少列，并且多高多宽。

.grid-container {
    display: grid;
    grid-template-columns: 120px 120px 60px;
    grid-template-rows: 60px 120px 60px;
}


.grid-item {
    background-color: brown;
    margin: 10px;
}

我们定义一个三行三列的网格，每个格子宽和高也同时进行了设定，并放入9个子元素。为了方便看清子元素，也给它们加上10px的外边距。

<div class="grid-container">
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
</div>

网格容器中的元素将被依次分配进入到网格中的格子，也因此元素的宽高尺寸不再由自己决定，而是由格子的尺寸来决定。

网格布局真正有用的地方在于，它允许子元素跨越多个格，即类似Excel中「合并单元格」的效果。

当然，这需要调整子元素的CSS：

.long-grid-item {
    grid-column: span 3;
}

<div class="grid-container">
    <div class="grid-item long-grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item"></div>
    <div class="grid-item long-grid-item"></div>
</div>

这里用到了一个class的小技巧，将多个class名字之间以空格隔开，即可对元素可以同时设定多个class。

小结

Flex弹性布局和Grid网格布局都是非常好用的现代化布局实现方案，除了文章中提到的属性以外，还有更多样式属性可以帮助实现更复杂的布局需求，你可以到W3C的官网去查询，此处不再赘述。

使用Flex弹性布局或者Grid网格布局，都可以很好的解决综合练习二中的对齐问题。

稍微看一下B站的源码，它是使用Flex方案实现的。而且不但导航栏整体是flex，而且其中每一个部分也都是用flex实现的。

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。

在上节课的最后，我们遗留下来了三个问题，其一便是下图中的这个小红点。

把未读消息标记为小红点已经成为设计中的惯例，我们会在大量的网页或者APP上看到类似的设计。

有些时候还会显示出具体的数字。

还有的时候还会显示出文字，甚至形状也不再是圆的。

这些小红点学名称作徽章Badge，是一种常见的装饰，通常用来提醒用户，图标或者按钮这里有一些特别的东西可以关注。

徽章有时还会出现在另外三个角落上，以应对更丰富的场景。

比如提醒用户换头像：

展示用户的尊贵身份：

游戏中标记人物等级或者状态：

但不论徽章是什么样子，用于什么目的，它都需要重叠在它要装饰的元素上。

我们知道可以用块级元素block实现垂直排列元素，也知道了使用行内块级元素 inline-block进行水平排列，但是如何把元素叠在一起呢？

本节课就让我们来解决这个重叠的问题。

文档流Normal Flow

两个元素叠在一起，说明这两个元素所在的位置发生了重合，所以我们需要重新思考一下，网页上的各个元素为什么会在现在的位置上。

网页中各元素的位置在默认的情况下，都是按照HTML代码里的书写顺序，在不发生遮盖的情况下，尽可能的靠上（块级元素）、靠左（行内元素）显示。

也就是说每个元素的位置取决于上一个元素的位置，而不是自己决定自己的位置。

我们可以通过分别在Word和PowerPoint中插入图片来感受一下两者区别。

在Word中的图片会随着文本内容的变化跟着移动。

而PowerPoint中的图片则不会随着别的内容修改而改变自己的位置。

网页中元素的位置更接近在Word文档中的这种，当前面的内容删除了之后，后面的内容会自动补充过去，就好像是流水一样，哪里低就流向哪里。所以，称作文档流Normal Flow。

绝对定位

元素的样式属性「定位」position，可以告诉浏览器是否将元素从文档流中拿出来单独处理。

设置position: absolute绝对定位，就是一种让元素从文档流中脱离出来的方法。绝对定位的元素将保持在页面某个位置上，出现类似PowerPoint中的效果。

让我们创建一个新文件position.html，然后体验一下。

<div class="absolute">
    <img src="assets/icon.png">
</div>
<div class="greeting">欢迎关注弦五说！！</div>

.absolute {
    position: absolute;
}

因为图片变成了绝对定位的元素，所以它脱离了文档流。原本应在图片下一排显示的文字，不再被图片影响，从而显示在了图片原本的位置，两个元素的位置相同，从而引发了重叠。

绝对定位的元素默认会呆在它原本在文档流中的位置，如何调整它的位置呢？

这需要使用left、right、top、bottom4个样式属性，用来指明元素的位置距离文档的4个边缘多远。

.absolute {
    position: absolute;
    left: 25px;
    top: 40px;
}

通常，我们只需在left和right这一对中选取一个进行设定，没有必要同时设定两个。top和bottom也是类似的情况。

即使我们同时设定了两个，其实也只会有一个生效，具体是哪个生效取决于文档流的方向，在一般情况下 left和top具有更高的优先级。

绝对定位适合用于排版准确度要求比较高，且内容相对明确的页面，比如产品的官网、邀请函等。

但用绝对定位来实现徽章却不太方便：徽章只是用来装饰，我们不能要求被装饰的对象也一起成为绝对定位的元素。如果原本要被装饰的对象依然是在文档流中的，一旦被装饰的对象随着文档流发生变化，徽章就很难跟着同步移动了。

固定定位

还有的时候，我们不是要将元素的位置固定在在页面中的某处，而是要相对于浏览器窗口来定位。

比如，给用户弹出的对话框，无论用户目前阅读到了页面的哪里，都需要在整个浏览器窗口里居中。

这种定位方法叫做固定定位，对应的position: fixed。

​固定定位的元素同样会脱离文档流，也使用left、right、top、bottom4个样式属性，用来标记元素的位置应该距离浏览器窗口的4个边缘多远。

看一下效果。

<div class="fixed">
    <img src="assets/icon.png">
</div>

.fixed {
    position: fixed;
    right: 25px;
    top:40px
}

固定定位因为会跟着浏览器窗口移动，没有办法准确的停在某个元素附近，就更不适合实现徽章了。

相对定位

除了绝对定位和固定定位还有一种相对定位的方法，对应的position: relative

将元素设定为相对定位时，元素将依然存在于文档流中，这时left、right、top、bottom4个样式属性，让元素偏离原本所在的位置。

<div class="greeting">欢迎关注弦五说！！</div>
<div class="greeting">欢迎关注弦五说！！</div>
<div class="greeting">欢迎关注弦五说！！</div>
<div class="relative">
    <img src="assets/icon.png">
</div>
<div class="greeting">欢迎关注弦五说！！</div>
<div class="greeting">欢迎关注弦五说！！</div>
<div class="greeting">欢迎关注弦五说！！</div>

.relative {
    position: relative;
    left: 25px;
    top: 40px;
}

相对定位能实现元素的重叠的同时，还能跟着文档流流动，比较适合实现徽章。

但相对定位也有一个不尽如人意的地方：因为相对定位的元素并没有脱离文档流，尽管它显示的位置发生了偏移，但它依然占据着文档流中原本的位置，这导致原本的位置会显示出一个空白区域。

复合定位

我们可以综合使用绝对定位和相对定位，可以让元素既能在局部发生位移，又能让元素脱离文档流，避免空白区域。

这需要用到绝对定位的一个特性。

当绝对定位的父元素不是默认定位方式，而是绝对定位、固定定位、相对定位中的任何一种时，这个绝对定位的元素仍然会脱离文档流，但位置不再以整个文档的边缘为基准偏移，而是以这个父元素的（外边距）边缘为基准偏移。

<div class="greeting">欢迎关注弦五说！！</div>
<div class="greeting">欢迎关注弦五说！！</div>
<div class="greeting">欢迎关注弦五说！！</div>
<div class="relative">
    <div class="absolute"><img src="assets/icon.png"></div> 
</div>
<div class="greeting">欢迎关注弦五说！！</div>
<div class="greeting">欢迎关注弦五说！！</div>
<div class="greeting">欢迎关注弦五说！！</div>

.absolute {
    position: absolute;
    left: 25px;
    top: 40px;
}

.relative {
    position: relative;
}

这种复合定位的方式，很适合实现徽章的效果。

我们可以把要被装饰的元素和小红点装到同一个父元素里，并把这个父元素设置为相对定位，然后把小红点设置为绝对定位，这时再调整小红点的位置即可。

<div class="badge-father">
    <img src="assets/icon.png">
    <div class="badge"></div>
</div>

.badge-father {
    position: relative;
    width: fit-content;
}
.badge {
    position: absolute;
    top: 0px;
    right: 0px;
    background-color: red;
    width: 12px;
    height: 12px;
    border-radius: 50%;
}

这样小红点以及它所装饰的icon就可以随着父元素一起，随着原本的文档流移动了，从而实现了徽章的效果。

我将本课程所有的代码托管在gitee上了，你可以点击这个链接，或到gitee.com上搜索弦五 网页开发入门，查看和获取本课程的全部代码。