2018-05-18

第1讲 | 为什么要学习网络协议？

《圣经》中有一个通天塔的故事，大致是说，上帝为了阻止人类联合起来，就让人类说不同的语言。人类没法儿沟通，达不成“协议”，通天塔的计划就失败了。

但是千年以后，有一种叫“程序猿”的物种，敲着一种这个群体通用的语言，连接着全世界所有的人，打造这互联网世界的通天塔。如今的世界，正是因为互联网，才连接在一起。

当 “Hello World!” 从显示器打印出来的时候，还记得你激动的心情吗？

public class HelloWorld {
  public static void main(String[] args){
    System.out.println("Hello World!");
  }
}

如果你是程序员，一定看得懂上面这一段文字。这是每一个程序员向计算机世界说“你好，世界”的方式。但是，你不一定知道，这段文字也是一种协议，是人类和计算机沟通的协议，只有通过这种协议，计算机才知道我们想让它做什么。

协议三要素

当然，这种协议还是更接近人类语言，机器不能直接读懂，需要进行翻译，翻译的工作教给编译器，也就是程序员常说的 compile。这个过程比较复杂，其中的编译原理非常复杂，我在这里不进行详述。

但是可以看得出，计算机语言作为程序员控制一台计算机工作的协议，具备了协议的三要素。

语法，就是这一段内容要符合一定的规则和格式。例如，括号要成对，结束要使用分号等。
语义，就是这一段内容要代表某种意义。例如数字减去数字是有意义的，数字减去文本一般来说就没有意义。
顺序，就是先干啥，后干啥。例如，可以先加上某个数值，然后再减去某个数值。

会了计算机语言，你就能够教给一台计算机完成你的工作了。恭喜你，入门了！

但是，要想打造互联网世界的通天塔，只教给一台机器做什么是不够的，你需要学会教给一大片机器做什么。这就需要网络协议。只有通过网络协议，才能使一大片机器互相协作、共同完成一件事。

这个时候，你可能会问，网络协议长啥样，这么神奇，能干成啥事？我先拿一个简单的例子，让你尝尝鲜，然后再讲一个大事。

当你想要买一个商品，常规的做法就是打开浏览器，输入购物网站的地址。浏览器就会给你显示一个缤纷多彩的页面。

那你有没有深入思考过，浏览器是如何做到这件事情的？它之所以能够显示缤纷多彩的页面，是因为它收到了一段来自 HTTP 协议的“东西”。我拿网易考拉来举例，格式就像下面这样：

HTTP/1.1 200 OK
Date: Tue, 27 Mar 2018 16:50:26 GMT
Content-Type: text/html;charset=UTF-8
Content-Language: zh-CN

<!DOCTYPE html>
<html>
<head>
<base href="https://pages.kaola.com/" />
<meta charset="utf-8"/> <title> 网易考拉 3 周年主会场 </title>

这符合协议的三要素吗？我带你来看一下。

首先，符合语法，也就是说，只有按照上面那个格式来，浏览器才认。例如，上来是状态，然后是首部，然后是内容。

第二，符合语义，就是要按照约定的意思来。例如，状态 200，表述的意思是网页成功返回。如果不成功，就是我们常见的“404”。

第三，符合顺序，你一点浏览器，就是发送出一个 HTTP 请求，然后才有上面那一串 HTTP 返回的东西。

浏览器显然按照协议商定好的做了，最后一个五彩缤纷的页面就出现在你面前了。

我们常用的网络协议有哪些？

接下来揭秘我要说的大事情，“双十一”。这和我们要讲的网络协议有什么关系呢？

在经济学领域，有个伦纳德·里德（Leonard E. Read）创作的《铅笔的故事》。这个故事通过一个铅笔的诞生过程，来讲述复杂的经济学理论。这里，我也用一个下单的过程，看看互联网世界的运行过程中，都使用了哪些网络协议。

你先在浏览器里面输入 https://www.kaola.com ，这是一个URL。浏览器只知道名字是“www.kaola.com”，但是不知道具体的地点，所以不知道应该如何访问。于是，它打开地址簿去查找。可以使用一般的地址簿协议**DNS**去查找，还可以使用另一种更加精准的地址簿查找协议**HTTPDNS**。

无论用哪一种方法查找，最终都会得到这个地址：106.114.138.24。这个是IP地址，是互联网世界的“门牌号”。

知道了目标地址，浏览器就开始打包它的请求。对于普通的浏览请求，往往会使用HTTP协议；但是对于购物的请求，往往需要进行加密传输，因而会使用HTTPS协议。无论是什么协议，里面都会写明“你要买什么和买多少”。

DNS、HTTP、HTTPS 所在的层我们称为应用层。经过应用层封装后，浏览器会将应用层的包交给下一层去完成，通过 socket 编程来实现。下一层是传输层。传输层有两种协议，一种是无连接的协议UDP，一种是面向连接的协议TCP。对于支付来讲，往往使用 TCP 协议。所谓的面向连接就是，TCP 会保证这个包能够到达目的地。如果不能到达，就会重新发送，直至到达。

TCP 协议里面会有两个端口，一个是浏览器监听的端口，一个是电商的服务器监听的端口。操作系统往往通过端口来判断，它得到的包应该给哪个进程。

传输层封装完毕后，浏览器会将包交给操作系统的网络层。网络层的协议是 IP 协议。在 IP 协议里面会有源 IP 地址，即浏览器所在机器的 IP 地址和目标 IP 地址，也即电商网站所在服务器的 IP 地址。

操作系统既然知道了目标 IP 地址，就开始想如何根据这个门牌号找到目标机器。操作系统往往会判断，这个目标 IP 地址是本地人，还是外地人。如果是本地人，从门牌号就能看出来，但是显然电商网站不在本地，而在遥远的地方。

操作系统知道要离开本地去远方。虽然不知道远方在何处，但是可以这样类比一下：如果去国外要去海关，去外地就要去网关。而操作系统启动的时候，就会被 DHCP 协议配置 IP 地址，以及默认的网关的 IP 地址 192.168.1.1。

操作系统如何将 IP 地址发给网关呢？在本地通信基本靠吼，于是操作系统大吼一声，谁是 192.168.1.1 啊？网关会回答它，我就是，我的本地地址在村东头。这个本地地址就是MAC地址，而大吼的那一声是ARP协议。

于是操作系统将 IP 包交给了下一层，也就是MAC 层。网卡再将包发出去。由于这个包里面是有 MAC 地址的，因而它能够到达网关。

网关收到包之后，会根据自己的知识，判断下一步应该怎么走。网关往往是一个路由器，到某个 IP 地址应该怎么走，这个叫作路由表。

路由器有点像玄奘西行路过的一个个国家的一个个城关。每个城关都连着两个国家，每个国家相当于一个局域网，在每个国家内部，都可以使用本地的地址 MAC 进行通信。

一旦跨越城关，就需要拿出 IP 头来，里面写着贫僧来自东土大唐（就是源 IP 地址），欲往西天拜佛求经（指的是目标 IP 地址）。路过宝地，借宿一晚，明日启行，请问接下来该怎么走啊？

城关往往是知道这些“知识”的，因为城关和临近的城关也会经常沟通。到哪里应该怎么走，这种沟通的协议称为路由协议，常用的有OSPF和BGP。

城关与城关之间是一个国家，当网络包知道了下一步去哪个城关，还是要使用国家内部的 MAC 地址，通过下一个城关的 MAC 地址，找到下一个城关，然后再问下一步的路怎么走，一直到走出最后一个城关。

最后一个城关知道这个网络包要去的地方。于是，对着这个国家吼一声，谁是目标 IP 啊？目标服务器就会回复一个 MAC 地址。网络包过关后，通过这个 MAC 地址就能找到目标服务器。

目标服务器发现 MAC 地址对上了，取下 MAC 头来，发送给操作系统的网络层。发现 IP 也对上了，就取下 IP 头。IP 头里会写上一层封装的是 TCP 协议，然后将其交给传输层，即TCP 层。

在这一层里，对于收到的每个包，都会有一个回复的包说明收到了。这个回复的包绝非这次下单请求的结果，例如购物是否成功，扣了多少钱等，而仅仅是 TCP 层的一个说明，即收到之后的回复。当然这个回复，会沿着刚才来的方向走回去，报个平安。

因为一旦出了国门，西行路上千难万险，如果在这个过程中，网络包走丢了，例如进了大沙漠，或者被强盗抢劫杀害怎么办呢？因而到了要报个平安。

如果过一段时间还是没到，发送端的 TCP 层会重新发送这个包，还是上面的过程，直到有一天收到平安到达的回复。这个重试绝非你的浏览器重新将下单这个动作重新请求一次。对于浏览器来讲，就发送了一次下单请求，TCP 层不断自己闷头重试。除非 TCP 这一层出了问题，例如连接断了，才轮到浏览器的应用层重新发送下单请求。

当网络包平安到达 TCP 层之后，TCP 头中有目标端口号，通过这个端口号，可以找到电商网站的进程正在监听这个端口号，假设一个 Tomcat，将这个包发给电商网站。

电商网站的进程得到 HTTP 请求的内容，知道了要买东西，买多少。往往一个电商网站最初接待请求的这个 Tomcat 只是个接待员，负责统筹处理这个请求，而不是所有的事情都自己做。例如，这个接待员要告诉专门管理订单的进程，登记要买某个商品，买多少，要告诉管理库存的进程，库存要减少多少，要告诉支付的进程，应该付多少钱，等等。

如何告诉相关的进程呢？往往通过 RPC 调用，即远程过程调用的方式来实现。远程过程调用就是当告诉管理订单进程的时候，接待员不用关心中间的网络互连问题，会由 RPC 框架统一处理。RPC 框架有很多种，有基于 HTTP 协议放在 HTTP 的报文里面的，有直接封装在 TCP 报文里面的。

当接待员发现相应的部门都处理完毕，就回复一个 HTTPS 的包，告知下单成功。这个 HTTPS 的包，会像来的时候一样，经过千难万险到达你的个人电脑，最终进入浏览器，显示支付成功。

2018-04-27

Docker入门

2013年发布至今， Docker 一直广受瞩目，被认为可能会改变软件行业。

但是，许多人并不清楚 Docker 到底是什么，要解决什么问题，好处又在哪里？本文就来详细解释，帮助大家理解它，还带有简单易懂的实例，教你如何将它用于日常开发。

一、环境配置的难题

软件开发最大的麻烦事之一，就是环境配置。用户计算机的环境都不相同，你怎么知道自家的软件，能在那些机器跑起来？

用户必须保证两件事：操作系统的设置，各种库和组件的安装。只有它们都正确，软件才能运行。举例来说，安装一个 Python 应用，计算机必须有 Python 引擎，还必须有各种依赖，可能还要配置环境变量。

如果某些老旧的模块与当前环境不兼容，那就麻烦了。开发者常常会说：”它在我的机器可以跑了”（It works on my machine），言下之意就是，其他机器很可能跑不了。

环境配置如此麻烦，换一台机器，就要重来一次，旷日费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。

二、虚拟机

虚拟机（virtual machine）就是带环境安装的一种解决方案。它可以在一种操作系统里面运行另一种操作系统，比如在 Windows 系统里面运行 Linux 系统。应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统来说，虚拟机就是一个普通文件，不需要了就删掉，对其他部分毫无影响。

虽然用户可以通过虚拟机还原软件的原始环境。但是，这个方案有几个缺点。

（1）资源占用多

虚拟机会独占一部分内存和硬盘空间。它运行的时候，其他程序就不能使用这些资源了。哪怕虚拟机里面的应用程序，真正使用的内存只有 1MB，虚拟机依然需要几百 MB 的内存才能运行。

（2）冗余步骤多

虚拟机是完整的操作系统，一些系统级别的操作步骤，往往无法跳过，比如用户登录。

（3）启动慢

启动操作系统需要多久，启动虚拟机就需要多久。可能要等几分钟，应用程序才能真正运行。

三、Linux 容器

由于虚拟机存在这些缺点，Linux 发展出了另一种虚拟化技术：Linux 容器（Linux Containers，缩写为 LXC）。

Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。或者说，在正常进程的外面套了一个保护层。对于容器里面的进程来说，它接触到的各种资源都是虚拟的，从而实现与底层系统的隔离。

由于容器是进程级别的，相比虚拟机有很多优势。

（1）启动快

容器里面的应用，直接就是底层系统的一个进程，而不是虚拟机内部的进程。所以，启动容器相当于启动本机的一个进程，而不是启动一个操作系统，速度就快很多。

（2）资源占用少

容器只占用需要的资源，不占用那些没有用到的资源；虚拟机由于是完整的操作系统，不可避免要占用所有资源。另外，多个容器可以共享资源，虚拟机都是独享资源。

（3）体积小

容器只要包含用到的组件即可，而虚拟机是整个操作系统的打包，所以容器文件比虚拟机文件要小很多。

总之，容器有点像轻量级的虚拟机，能够提供虚拟化的环境，但是成本开销小得多。

四、Docker 是什么？

Docker 属于 Linux 容器的一种封装，提供简单易用的容器使用接口。它是目前最流行的 Linux 容器解决方案。

Docker 将应用程序与该程序的依赖，打包在一个文件里面。运行这个文件，就会生成一个虚拟容器。程序在这个虚拟容器里运行，就好像在真实的物理机上运行一样。有了 Docker，就不用担心环境问题。

总体来说，Docker 的接口相当简单，用户可以方便地创建和使用容器，把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改，就像管理普通的代码一样。

五、Docker 的用途

Docker 的主要用途，目前有三大类。

（1）提供一次性的环境。比如，本地测试他人的软件、持续集成的时候提供单元测试和构建的环境。

（2）提供弹性的云服务。因为 Docker 容器可以随开随关，很适合动态扩容和缩容。

（3）组建微服务架构。通过多个容器，一台机器可以跑多个服务，因此在本机就可以模拟出微服务架构。

六、Docker 的安装

Docker 是一个开源的商业产品，有两个版本：社区版（Community Edition，缩写为 CE）和企业版（Enterprise Edition，缩写为 EE）。企业版包含了一些收费服务，个人开发者一般用不到。下面的介绍都针对社区版。

Docker CE 的安装请参考官方文档。

Mac
Windows
Ubuntu
Debian
CentOS
Fedora
其他 Linux 发行版

安装完成后，运行下面的命令，验证是否安装成功。

1
2
3

$docker version
 # 或者
$docker info

Docker 需要用户具有 sudo 权限，为了避免每次命令都输入sudo，可以把用户加入 Docker 用户组（官方文档）。

1	$sudo usermod -aG docker $USER

Docker 是服务器—-客户端架构。命令行运行docker命令的时候，需要本机有 Docker 服务。如果这项服务没有启动，可以用下面的命令启动（官方文档）。

1 2	# service 命令的用法 $sudo service docker start

1 2	# systemctl 命令的用法 $sudo systemctl start docker

六、image 文件

Docker 把应用程序及其依赖，打包在 image 文件里面。只有通过这个文件，才能生成 Docker 容器。image 文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

image 是二进制文件。实际开发中，一个 image 文件往往通过继承另一个 image 文件，加上一些个性化设置而生成。举例来说，你可以在 Ubuntu 的 image 基础上，往里面加入 Apache 服务器，形成你的 image。

# 列出本机的所有 image 文件。
$docker image ls

# 删除 image 文件
$docker image rm [imageName]

image 文件是通用的，一台机器的 image 文件拷贝到另一台机器，照样可以使用。一般来说，为了节省时间，我们应该尽量使用别人制作好的 image 文件，而不是自己制作。即使要定制，也应该基于别人的 image 文件进行加工，而不是从零开始制作。

为了方便共享，image 文件制作完成后，可以上传到网上的仓库。Docker 的官方仓库 Docker Hub 是最重要、最常用的 image 仓库。此外，出售自己制作的 image 文件也是可以的。

七、实例：hello world

下面，我们通过最简单的 image 文件”hello world”，感受一下 Docker。

首先，运行下面的命令，将 image 文件从仓库抓取到本地。

1	$ docker image pull library/hello-world

上面代码中，docker image pull是抓取 image 文件的命令。library/hello-world是 image 文件在仓库里面的位置，其中library是 image 文件所在的组，hello-world是 image 文件的名字。

由于 Docker 官方提供的 image 文件，都放在library组里面，所以它的是默认组，可以省略。因此，上面的命令可以写成下面这样。

1	$ docker image pull hello-world

抓取成功以后，就可以在本机看到这个 image 文件了。

1	$ docker image ls

现在，运行这个 image 文件。

1	$ docker container run hello-world

docker container run命令会从 image 文件，生成一个正在运行的容器实例。

注意，docker container run命令具有自动抓取 image 文件的功能。如果发现本地没有指定的 image 文件，就会从仓库自动抓取。因此，前面的docker image pull命令并不是必需的步骤。

如果运行成功，你会在屏幕上读到下面的输出。

$ docker container run hello-world

Hello from Docker!
This message shows that your installation appears to be working correctly.

... ...

输出这段提示以后，hello world就会停止运行，容器自动终止。

有些容器不会自动终止，因为提供的是服务。比如，安装运行 Ubuntu 的 image，就可以在命令行体验 Ubuntu 系统。

1	$ docker container run -it ubuntu bash

对于那些不会自动终止的容器，必须使用docker container kill 命令手动终止。

1	$ docker container kill [containID]

八、容器文件

image 文件生成的容器实例，本身也是一个文件，称为容器文件。也就是说，一旦容器生成，就会同时存在两个文件： image 文件和容器文件。而且关闭容器并不会删除容器文件，只是容器停止运行而已。

# 列出本机正在运行的容器
$ docker container ls

# 列出本机所有容器，包括终止运行的容器
$ docker container ls --all

上面命令的输出结果之中，包括容器的 ID。很多地方都需要提供这个 ID，比如上一节终止容器运行的docker container kill命令。

终止运行的容器文件，依然会占据硬盘空间，可以使用docker container rm命令删除。

1	$ docker container rm [containerID]

运行上面的命令之后，再使用docker container ls --all命令，就会发现被删除的容器文件已经消失了。

九、Dockerfile 文件

学会使用 image 文件以后，接下来的问题就是，如何可以生成 image 文件？如果你要推广自己的软件，势必要自己制作 image 文件。

这就需要用到 Dockerfile 文件。它是一个文本文件，用来配置 image。Docker 根据该文件生成二进制的 image 文件。

下面通过一个实例，演示如何编写 Dockerfile 文件。

十、实例：制作自己的 Docker 容器

下面我以 koa-demos 项目为例，介绍怎么写 Dockerfile 文件，实现让用户在 Docker 容器里面运行 Koa 框架。

作为准备工作，请先下载源码。

1 2	$ git clone https://github.com/ruanyf/koa-demos.git $ cd koa-demos

10.1 编写 Dockerfile 文件

首先，在项目的根目录下，新建一个文本文件.dockerignore，写入下面的内容。

1
2
3

.git
node_modules
npm-debug.log

上面代码表示，这三个路径要排除，不要打包进入 image 文件。如果你没有路径要排除，这个文件可以不新建。

然后，在项目的根目录下，新建一个文本文件 Dockerfile，写入下面的内容。

FROM node:8.4
COPY . /app
WORKDIR /app
RUN npm install --registry=https://registry.npm.taobao.org
EXPOSE 3000

上面代码一共五行，含义如下。

FROM node:8.4：该 image 文件继承官方的 node image，冒号表示标签，这里标签是8.4，即8.4版本的 node。
COPY . /app：将当前目录下的所有文件（除了.dockerignore排除的路径），都拷贝进入 image 文件的/app目录。
WORKDIR /app：指定接下来的工作路径为/app。
RUN npm install：在/app目录下，运行npm install命令安装依赖。注意，安装后所有的依赖，都将打包进入 image 文件。
EXPOSE 3000：将容器 3000 端口暴露出来，允许外部连接这个端口。

10.2 创建 image 文件

有了 Dockerfile 文件以后，就可以使用docker image build命令创建 image 文件了。

1
2
3

$ docker image build -t koa-demo .
# 或者
$ docker image build -t koa-demo:0.0.1 .

上面代码中，-t参数用来指定 image 文件的名字，后面还可以用冒号指定标签。如果不指定，默认的标签就是latest。最后的那个点表示 Dockerfile 文件所在的路径，上例是当前路径，所以是一个点。

如果运行成功，就可以看到新生成的 image 文件koa-demo了。

1	$ docker image ls

10.3 生成容器

docker container run命令会从 image 文件生成容器。

1
2
3

$ docker container run -p 8000:3000 -it koa-demo /bin/bash
# 或者
$ docker container run -p 8000:3000 -it koa-demo:0.0.1 /bin/bash

上面命令的各个参数含义如下：

-p参数：容器的 3000 端口映射到本机的 8000 端口。
-it参数：容器的 Shell 映射到当前的 Shell，然后你在本机窗口输入的命令，就会传入容器。
koa-demo:0.0.1：image 文件的名字（如果有标签，还需要提供标签，默认是 latest 标签）。
/bin/bash：容器启动以后，内部第一个执行的命令。这里是启动 Bash，保证用户可以使用 Shell。

如果一切正常，运行上面的命令以后，就会返回一个命令行提示符。

1	root@66d80f4aaf1e:/app#

这表示你已经在容器里面了，返回的提示符就是容器内部的 Shell 提示符。执行下面的命令。

1	root@66d80f4aaf1e:/app# node demos/01.js

这时，Koa 框架已经运行起来了。打开本机的浏览器，访问 http://127.0.0.1:8000，网页显示"Not Found”，这是因为这个 demo没有写路由。

这个例子中，Node 进程运行在 Docker 容器的虚拟环境里面，进程接触到的文件系统和网络接口都是虚拟的，与本机的文件系统和网络接口是隔离的，因此需要定义容器与物理机的端口映射（map）。

现在，在容器的命令行，按下 Ctrl + c 停止 Node 进程，然后按下 Ctrl + d （或者输入 exit）退出容器。此外，也可以用docker container kill终止容器运行。

# 在本机的另一个终端窗口，查出容器的 ID
$ docker container ls

# 停止指定的容器运行
$ docker container kill [containerID]

容器停止运行之后，并不会消失，用下面的命令删除容器文件。

# 查出容器的 ID
$ docker container ls --all

# 删除指定的容器文件
$ docker container rm [containerID]

也可以使用docker container run命令的--rm参数，在容器终止运行后自动删除容器文件。

1	$ docker container run --rm -p 8000:3000 -it koa-demo /bin/bash

10.4 CMD 命令

上一节的例子里面，容器启动以后，需要手动输入命令node demos/01.js。我们可以把这个命令写在 Dockerfile 里面，这样容器启动以后，这个命令就已经执行了，不用再手动输入了。

FROM node:8.4
COPY . /app
WORKDIR /app
RUN npm install --registry=https://registry.npm.taobao.org
EXPOSE 3000
CMD node demos/01.js

上面的 Dockerfile 里面，多了最后一行CMD node demos/01.js，它表示容器启动后自动执行node demos/01.js。

你可能会问，RUN命令与CMD命令的区别在哪里？简单说，RUN命令在 image 文件的构建阶段执行，执行结果都会打包进入 image 文件；CMD命令则是在容器启动后执行。另外，一个 Dockerfile 可以包含多个RUN命令，但是只能有一个CMD命令。

注意，指定了CMD命令以后，docker container run命令就不能附加命令了（比如前面的/bin/bash），否则它会覆盖CMD命令。现在，启动容器可以使用下面的命令。

1	$ docker container run --rm -p 8000:3000 -it koa-demo:0.0.1

10.5 发布 image 文件

容器运行成功后，就确认了 image 文件的有效性。这时，我们就可以考虑把 image 文件分享到网上，让其他人使用。

首先，去 hub.docker.com 或 cloud.docker.com 注册一个账户。然后，用下面的命令登录。

1	$ docker login

接着，为本地的 image 标注用户名和版本。

1
2
3

$ docker image tag [imageName] [username]/[repository]:[tag]
# 实例
$ docker image tag koa-demos:0.0.1 ruanyf/koa-demos:0.0.1

也可以不标注用户名，重新构建一下 image 文件。

1	$ docker image build -t [username]/[repository]:[tag] .

最后，发布 image 文件。

1	$ docker image push [username]/[repository]:[tag]

发布成功以后，登录 hub.docker.com，就可以看到已经发布的 image 文件。

十一、其他有用的命令

docker 的主要用法就是上面这些，此外还有几个命令，也非常有用。

（1）docker container start

前面的docker container run命令是新建容器，每运行一次，就会新建一个容器。同样的命令运行两次，就会生成两个一模一样的容器文件。如果希望重复使用容器，就要使用docker container start命令，它用来启动已经生成、已经停止运行的容器文件。

1	$ docker container start [containerID]

（2）docker container stop

前面的docker container kill命令终止容器运行，相当于向容器里面的主进程发出 SIGKILL 信号。而docker container stop命令也是用来终止容器运行，相当于向容器里面的主进程发出 SIGTERM 信号，然后过一段时间再发出 SIGKILL 信号。

1	$ bash container stop [containerID]

这两个信号的差别是，应用程序收到 SIGTERM 信号以后，可以自行进行收尾清理工作，但也可以不理会这个信号。如果收到 SIGKILL 信号，就会强行立即终止，那些正在进行中的操作会全部丢失。

（3）docker container logs

docker container logs命令用来查看 docker 容器的输出，即容器里面 Shell 的标准输出。如果docker run命令运行容器的时候，没有使用-it参数，就要用这个命令查看输出。

1	$ docker container logs [containerID]

（4）docker container exec

docker container exec命令用于进入一个正在运行的 docker 容器。如果docker run命令运行容器的时候，没有使用-it参数，就要用这个命令进入容器。一旦进入了容器，就可以在容器的 Shell 执行命令了。

1	$ docker container exec -it [containerID] /bin/bash

（5）docker container cp

docker container cp命令用于从正在运行的 Docker 容器里面，将文件拷贝到本机。下面是拷贝到当前目录的写法。

1	$ docker container cp [containID]:[/path/to/file] .

原文

http://www.ruanyifeng.com/blog/2018/02/docker-tutorial.html

2018-04-20

Dockerizing a Node.js web app

The goal of this example is to show you how to get a Node.js application into a Docker container. The guide is intended for development, and not for a production deployment. The guide also assumes you have a working Docker installation and a basic understanding of how a Node.js application is structured.

In the first part of this guide we will create a simple web application in Node.js, then we will build a Docker image for that application, and lastly we will run the image as a container.

Docker allows you to package an application with all of its dependencies into a standardized unit, called a container, for software development. A container is a stripped-to-basics version of a Linux operating system. An image is software you load into a container.

Create the Node.js app

First, create a new directory where all the files would live. In this directory create a package.json file that describes your app and its dependencies:

{
  "name": "docker_web_app",
  "version": "1.0.0",
  "description": "Node.js on Docker",
  "author": "First Last <first.last@example.com>",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.16.1"
  }
}

With your new package.json file, run npm install. If you are using npm version 5 or later, this will generate a package-lock.json file which will be copied to your Docker image.

Then, create a server.js file that defines a web app using the Express.js framework:

'use strict';

const express = require('express');

// Constants
const PORT = 8080;
const HOST = '0.0.0.0';

// App
const app = express();
app.get('/', (req, res) => {
  res.send('Hello world\n');
});

app.listen(PORT, HOST);
console.log(`Running on http://${HOST}:${PORT}`);

In the next steps, we’ll look at how you can run this app inside a Docker container using the official Docker image. First, you’ll need to build a Docker image of your app.

Creating a Dockerfile

Create an empty file called Dockerfile:

1	touch Dockerfile

Open the Dockerfile in your favorite text editor

The first thing we need to do is define from what image we want to build from. Here we will use the latest LTS (long term support) version 8 of node available from the Docker Hub:

1	FROM node:8

Next we create a directory to hold the application code inside the image, this will be the working directory for your application:

1 2	# Create app directory WORKDIR /usr/src/app

This image comes with Node.js and NPM already installed so the next thing we need to do is to install your app dependencies using the npm binary. Please note that if you are using npm version 4 or earlier a package-lock.json file will not be generated.

# Install app dependencies
# A wildcard is used to ensure both package.json AND package-lock.json are copied
# where available (npm@5+)
COPY package*.json ./

RUN npm install
# If you are building your code for production
# RUN npm install --only=production

Note that, rather than copying the entire working directory, we are only copying the package.json file. This allows us to take advantage of cached Docker layers. bitJudo has a good explanation of this here.

To bundle your app’s source code inside the Docker image, use the COPY instruction:

1 2	# Bundle app source COPY . .

Your app binds to port 8080 so you’ll use the EXPOSE instruction to have it mapped by the docker daemon:

1	EXPOSE 8080

Last but not least, define the command to run your app using CMD which defines your runtime. Here we will use the basic npm start which will run node server.js to start your server:

1	CMD [ "npm", "start" ]

Your Dockerfile should now look like this:

FROM node:8

# Create app directory
WORKDIR /usr/src/app

# Install app dependencies
# A wildcard is used to ensure both package.json AND package-lock.json are copied
# where available (npm@5+)
COPY package*.json ./

RUN npm install
# If you are building your code for production
# RUN npm install --only=production

# Bundle app source
COPY . .

EXPOSE 8080
CMD [ "npm", "start" ]

.dockerignore file

Create a .dockerignore file in the same directory as your Dockerfile with following content:

1 2	node_modules npm-debug.log

This will prevent your local modules and debug logs from being copied onto your Docker image and possibly overwriting modules installed within your image.

Building your image

Go to the directory that has your Dockerfile and run the following command to build the Docker image. The -t flag lets you tag your image so it’s easier to find later using the docker images command:

1	$ docker build -t <your username>/node-web-app .

Your image will now be listed by Docker:

$ docker images

# Example
REPOSITORY                      TAG        ID              CREATED
node                            8          1934b0b038d1    5 days ago
<your username>/node-web-app    latest     d64d3505b0d2    1 minute ago

Run the image

Running your image with -d runs the container in detached mode, leaving the container running in the background. The -p flag redirects a public port to a private port inside the container. Run the image you previously built:

1	$ docker run -p 49160:8080 -d <your username>/node-web-app

Print the output of your app:

# Get container ID
$ docker ps

# Print app output
$ docker logs <container id>

# Example
Running on http://localhost:8080

If you need to go inside the container you can use the exec command:

1 2	# Enter the container $ docker exec -it <container id> /bin/bash

Test

To test your app, get the port of your app that Docker mapped:

$ docker ps

# Example
ID            IMAGE                                COMMAND    ...   PORTS
ecce33b30ebf  <your username>/node-web-app:latest  npm start  ...   49160->8080

In the example above, Docker mapped the 8080 port inside of the container to the port 49160 on your machine.

Now you can call your app using curl (install if needed via: sudo apt-get install curl):

$ curl -i localhost:49160

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: text/html; charset=utf-8
Content-Length: 12
ETag: W/"c-M6tWOb/Y57lesdjQuHeB1P/qTV0"
Date: Mon, 13 Nov 2017 20:53:59 GMT
Connection: keep-alive

Hello world

We hope this tutorial helped you get up and running a simple Node.js application on Docker.

You can find more information about Docker and Node.js on Docker in the following places:

original

https://nodejs.org/en/docs/guides/nodejs-docker-webapp/

2018-03-25

IO—Node源码解析_buffer

在Node、ES2015出现之前，前端工程师只需要进行一些简单的字符串或DOM操作就可以满足业务需要，所以对二进制数据是比较陌生。node出现以后，前端面对的技术场景发生了变化，可以深入到网络传输、文件操作、图片处理等领域，而这些操作都与二进制数据紧密相关。

Node里面的buffer，是一个二进制数据容器，数据结构类似与数组，数组里面的方法在buffer都存在(slice操作的结果不一样)。下面就从源码(v6.0版本)层面分析，揭开buffer操作的面纱。

1. buffer的基本使用

在Node 6.0以前，直接使用new Buffer，但是这种方式存在两个问题:

参数复杂: 内存分配，还是内存分配+内容写入，需要根据参数来确定
安全隐患: 分配到的内存可能还存储着旧数据，这样就存在安全隐患

// 本来只想申请一块内存，但是里面却存在旧数据
const buf1 = new Buffer(10) // <Buffer 90 09 70 6b bf 7f 00 00 50 3a>
// 不小心，旧数据就被读取出来了
buf1.toString()  // '�\tpk�\u0000\u0000P:'

为了解决上述问题，Buffer提供了Buffer.from、Buffer.alloc、Buffer.allocUnsafe、Buffer.allocUnsafeSlow四个方法来申请内存。

// 申请10个字节的内存
const buf2 = Buffer.alloc(10) // <Buffer 00 00 00 00 00 00 00 00 00 00>
// 默认情况下，用0进行填充
buf2.toString() //'\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'

// 上述操作就相当于
const buf1 = new Buffer(10);
buf.fill(0);
buf.toString(); // '\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'

2. buffer的结构

buffer是一个典型的javascript与c++结合的模块，其性能部分用c++实现，非性能部分用javascript来实现。

下面看看buffer模块的内部结构:

exports.Buffer = Buffer;
exports.SlowBuffer = SlowBuffer;
exports.INSPECT_MAX_BYTES = 50;
exports.kMaxLength = binding.kMaxLength;

buffer模块提供了4个接口:

Buffer: 二进制数据容器类，node启动时默认加载
SlowBuffer: 同样也是二进制数据容器类，不过直接进行内存申请
INSPECT_MAX_BYTES: 限制bufObject.inspect()输出的长度
kMaxLength: 一次性内存分配的上限，大小为(2^31 - 1)

其中，由于Buffer经常使用，所以node在启动的时候，就已经加载了Buffer，而其他三个，仍然需要使用require('buffer').***。

关于buffer的内存申请、填充、修改等涉及性能问题的操作，均通过c++里面的node_buffer.cc来实现:

// c++里面的node_buffer
namespace node {
  bool zero_fill_all_buffers = false;
  namespace Buffer {
    ...
  }
}
NODE_MODULE_CONTEXT_AWARE_BUILTIN(buffer, node::Buffer::Initialize)

3. 内存分配的策略

Node中Buffer内存分配太过常见，从系统性能考虑出发，Buffer采用了如下的管理策略。

3.1 Buffer.from

Buffer.from(value, ...)用于申请内存，并将内容写入刚刚申请的内存中，value值是多样的，Buffer是如何处理的呢？让我们一起看看源码:

Buffer.from = function(value, encodingOrOffset, length) {
  if (typeof value === 'number')
    throw new TypeError('"value" argument must not be a number');

  if (value instanceof ArrayBuffer)
    return fromArrayBuffer(value, encodingOrOffset, length);

  if (typeof value === 'string')
    return fromString(value, encodingOrOffset);

  return fromObject(value);
};

value可以分成三类:

ArrayBuffer的实例: ArrayBuffer是ES2015里面引入的，用于在浏览器端直接操作二进制数据，这样Node就与ES2015关联起来，同时，新创建的Buffer与ArrayBuffer内存是共享的
string: 该方法实现了将字符串转变为Buffer
Buffer/TypeArray/Array: 会进行值的copy

3.1.1 ArrayBuffer的实例

Node v6与时俱进，将浏览器、node中对二进制数据的操作关联起来，同时二者会进行内存的共享。

var b = new ArrayBuffer(4);
var v1 = new Uint8Array(b);
var buf = Buffer.from(b)
console.log('first, typeArray: ', v1) // first, typeArray:  Uint8Array [ 0, 0, 0, 0 ]
console.log('first, Buffer: ', buf) // first, Buffer:  <Buffer 00 00 00 00>
v1[0] = 12
console.log('second, typeArray: ', v1) // second, typeArray:  Uint8Array [ 12, 0, 0, 0 ]
console.log('second, Buffer: ', buf) // second, Buffer:  <Buffer 0c 00 00 00>

在上述操作中，对ArrayBuffer的操作，引起Buffer值的修改，说明二者在内存上是同享的，再从源码层面了解下这个过程:

// buffer.js Buffer.from(arrayBuffer, ...)进入的分支:
function fromArrayBuffer(obj, byteOffset, length) {
  byteOffset >>>= 0;

  if (typeof length === 'undefined')
    return binding.createFromArrayBuffer(obj, byteOffset);

  length >>>= 0;
  return binding.createFromArrayBuffer(obj, byteOffset, length);
}
// c++ 模块中的node_buffer:
void CreateFromArrayBuffer(const FunctionCallbackInfo<Value>& args) {
  ...
  Local<ArrayBuffer> ab = args[0].As<ArrayBuffer>();
  ...
  Local<Uint8Array> ui = Uint8Array::New(ab, offset, max_length);
  ...
  args.GetReturnValue().Set(ui);
}

3.1.2 string

可以实现字符串与Buffer之间的转换，同时考虑到操作的性能，采用了一些优化策略避免频繁进行内存分配:

function fromString(string, encoding) {
  ...
  var length = byteLength(string, encoding);
  if (length === 0)
    return Buffer.alloc(0);
  // 当字符所需要的字节数大于4KB时: 直接进行内存分配
  if (length >= (Buffer.poolSize >>> 1))
    return binding.createFromString(string, encoding);
  // 当字符所需字节数小于4KB: 借助allocPool先申请、后分配的策略
  if (length > (poolSize - poolOffset))
    createPool();
  var actual = allocPool.write(string, poolOffset, encoding);
  var b = allocPool.slice(poolOffset, poolOffset + actual);
  poolOffset += actual;
  alignPool();
  return b;
}

a. 直接内存分配

当字符串所需要的字节大于4KB时，如何还从8KB的buffer pool中进行申请，那么就可能存在内存浪费，例如:

poolSize - poolOffset < 4KB: 这样就要重新申请一个8KB的pool，刚才那个pool剩余空间就会被浪费掉

看看c++是如何进行内存分配的:

// c++
void CreateFromString(const FunctionCallbackInfo<Value>& args) {
  ...
  Local<Object> buf;
  if (New(args.GetIsolate(), args[0].As<String>(), enc).ToLocal(&buf))
    args.GetReturnValue().Set(buf);
}

b. 借助于pool管理

用一个pool来管理频繁的行为，在计算机中是非常常见的行为，例如http模块中，关于tcp连接的建立，就设置了一个tcp pool。

function fromString(string, encoding) {
  ...
  // 当字符所需字节数小于4KB: 借助allocPool先申请、后分配的策略
  // pool的空间不够用，重新分配8kb的内存
  if (length > (poolSize - poolOffset))
    createPool();
  // 在buffer pool中进行分配
  var actual = allocPool.write(string, poolOffset, encoding);
  // 得到一个内存的视图view, 特殊说明: slice不进行copy，仅仅创建view
  var b = allocPool.slice(poolOffset, poolOffset + actual);
  poolOffset += actual;
  // 校验poolOffset是8的整数倍
  alignPool();
  return b;
}

// pool的申请
function createPool() {
  poolSize = Buffer.poolSize;
  allocPool = createBuffer(poolSize, true);
  poolOffset = 0;
}
// node加载的时候，就会创建第一个buffer pool
createPool();
// 校验poolOffset是8的整数倍
function alignPool() {
  // Ensure aligned slices
  if (poolOffset & 0x7) {
    poolOffset |= 0x7;
    poolOffset++;
  }
}

3.1.3 Buffer/TypeArray/Array

可用从一个现有的Buffer、TypeArray或Array中创建Buffer，内存不会共享，仅仅进行值的copy。

var buf1 = new Buffer([1,2,3,4,5]);
var buf2 = new Buffer(buf1);
console.log(buf1); // <Buffer 01 02 03 04 05>
console.log(buf2); // <Buffer 01 02 03 04 05>
buf1[0] = 16
console.log(buf1); // <Buffer 10 02 03 04 05>
console.log(buf2); // <Buffer 01 02 03 04 05>

上述示例就证明了buf1、buf2没有进行内存的共享，仅仅是值的copy，再从源码层面进行分析:

function fromObject(obj) {
  // 当obj为Buffer时
  if (obj instanceof Buffer) {
    ...
    const b = allocate(obj.length);
    obj.copy(b, 0, 0, obj.length);
    return b;
  }
  // 当obj为TypeArray或Array时
  if (obj) {
    if (obj.buffer instanceof ArrayBuffer || 'length' in obj) {
      ...
      return fromArrayLike(obj);
    }
    if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
      return fromArrayLike(obj.data);
    }
  }

  throw new TypeError(kFromErrorMsg);
}
// 数组或类数组，逐个进行值的copy
function fromArrayLike(obj) {
  const length = obj.length;
  const b = allocate(length);
  for (var i = 0; i < length; i++)
    b[i] = obj[i] & 255;
  return b;
}

3.2 Buffer.alloc

Buffer.alloc用于内存的分配，同时会对内存的旧数据进行覆盖，避免安全隐患的产生。

Buffer.alloc = function(size, fill, encoding) {
  ...
  if (size <= 0)
    return createBuffer(size);
  if (fill !== undefined) {
    ...
    return typeof encoding === 'string' ?
        createBuffer(size, true).fill(fill, encoding) :
        createBuffer(size, true).fill(fill);
  }
  return createBuffer(size);
};
function createBuffer(size, noZeroFill) {
  flags[kNoZeroFill] = noZeroFill ? 1 : 0;
  try {
    const ui8 = new Uint8Array(size);
    Object.setPrototypeOf(ui8, Buffer.prototype);
    return ui8;
  } finally {
    flags[kNoZeroFill] = 0;
  }
}

上述代码有几个需要注意的点:

3.2.1 先申请后填充

alloc先通过createBuffer申请一块内存，然后再进行填充，保证申请的内存全部用fill进行填充。

1 2	var buf = Buffer.alloc(10, 11); console.log(buf); // <Buffer 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b>

3.2.2 flags标示

flags用于标识默认的填充值是否为0，该值在javascript中设置，在c++中进行读取。

// js
const binding = process.binding('buffer');
const bindingObj = {};
...
binding.setupBufferJS(Buffer.prototype, bindingObj);
...
const flags = bindingObj.flags;
const kNoZeroFill = 0;

// c++
void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
  ...
  Local<Object> bObj = args[1].As<Object>();
  ...
  bObj->Set(String::NewFromUtf8(env->isolate(), "flags"),
    Uint32Array::New(array_buffer, 0, fields_count));
}

3.2.3 Uint8Array

Uint8Array是ES2015 TypeArray中的一种，可以在浏览器中创建二进制数据，这样就把浏览器、Node连接起来。

3.3 Buffer.allocUnSafe

Buffer.allocUnSafe与Buffer.alloc的区别在于，前者是从采用allocate的策略，尝试从buffer pool中申请内存，而buffer pool是不会进行默认值填充的，所以这种行为是不安全的。

Buffer.allocUnsafe = function(size) {
  assertSize(size);
  return allocate(size);
};

3.4 Buffer.allocUnsafeSlow

Buffer.allocUnsafeSlow有两个大特点: 直接通过c++进行内存分配；不会进行旧值填充。

Buffer.allocUnsafeSlow = function(size) {
  assertSize(size);
  return createBuffer(size, true);
};

4. 结语

字符串与Buffer之间存在较大的差距，同时二者又存在编码关系。通过Node，前端工程师已经深入到网络操作、文件操作等领域，对二进制数据的操作就显得非常重要，因此理解Buffer的诸多细节十分必要。

原文

http://zhenhua-lee.github.io/node/buffer.html

2018-03-07

模块—浅析Node.js的vm模块以及运行不信任代码

在一些系统中，我们希望给用户提供插入自定义逻辑的能力，除了 RPC 和 REST 之外，运行客户提供的代码也是比较常用的方法，好处是可以极大地减少在网络上的耗时。JavaScript 是一种非常流行而且容易上手的语言，因此，让用户用 JavaScript 来写自定义逻辑是一个不错的选择。下面我们介绍 Node.js 提供的 vm 模块以及分析用它来运行不信任代码可能遇到的问题。

vm模块

vm 模块是 Node.js 内置的核心模块，它能让我们编译 JavaScript 代码和在指定的环境中运行。请看下面例子：

const util = require('util');
const vm = require('vm');

// 1. 创建一个 vm.Script 实例, 编译要执行的代码
const script = new vm.Script('globalVar += 1; anotherGlobalVar = 1; ');
// 2. 用于绑定到 context 的对象
const sandbox = {globalVar: 1};
// 3. 创建一个 context, 并且把 sandbox 这个对象绑定到这个环境, 作为全局对象
const contextifiedSandbox = vm.createContext(sandbox);
// 4. 运行上面编译的代码, context 是 contextifiedSandbox
const result = script.runInContext(contextifiedSandbox);

console.log(`sandbox === contextifiedSandbox ? ${sandbox === contextifiedSandbox}`);
// sandbox === contextifiedSandbox ? true
console.log(`sandbox: ${util.inspect(sandbox)}`);
// sandbox: { globalVar: 2, anotherGlobalVar: 1 }
console.log(`result: ${util.inspect(result)}`);
// result: 1

vm.Script 是一个类，用于创建代码实例，后面可以多次运行。

vm.createContext(sandbox) 用于 “contextify” 一个对象，根据 ECMAScript 2015 语言规范，代码的执行需要一个 execution context。这里的 “contextify”，就是把传进去的对象与 V8 的一个新的 context 进行关联。这里所说的关联，我的理解是，这个 “contextified” 对象的属性将会成为那个 context 的全局属性，同时，在 context 下运行代码时产生的全局属性也会成为这个 “contextified” 对象的属性。

script.runInContext(contextifiedSandbox) 就是使代码在 contextifiedSandbox 这个 context 中运行，从上面的输出可以看到，代码运行后，contextifiedSandbox 里面的属性的值已经被改变了，运行结果是最后一个表达式的值。

除了上面几个接口之外，vm 模块还有一些更便捷的接口，例如 vm.runInContext(code, contextifiedSandbox[, options])，vm.runInNewContext(code[, sandbox][, options])等，详细可看文档。

外层如何得到代码运行结果

我们用 vm 运行代码的时候很可能需要得到一些结果，从上面的例子中可以看到，我们可以通过把结果作为最后一个表达式的值传给外层，或者作为context 的属性给外层使用，这在同步代码里没有问题，但是假如结果需要依赖里面的异步操作呢？这时，我们可以通过在 context 里放一个回调函数。下面是例子：

const util = require('util');
const vm = require('vm');

const sandbox = {globalVar: 1, setTimeout: setTimeout, cb: function(result) {
    console.log(result);
}};
vm.createContext(sandbox);
const script = new vm.Script(`
    setTimeout(function(){
        globalVar++;
        cb("async result");
    }, 1000);
`,{});
script.runInContext(sandbox);
console.log(`globalVar: ${sandbox.globalVar}`);
// globalVar: 1
// async result

代码运行时间限制

script.runInContext(contextifiedSandbox[, options]) 方法有一个 timeout 选项可以设定代码的运行时间，如果超过时间就会抛出错误，请看下面例子：　

const util = require('util');
const vm = require('vm');
const sandbox = {};
const contextifiedSandbox = vm.createContext(sandbox);
const script = new vm.Script('while(true){}');
const result = script.runInContext(contextifiedSandbox, {timeout: 1000});
// const result = script.runInContext(contextifiedSandbox, {timeout: 1000});
//                       ^
// Error: Script execution timed out.

再试试异步代码，

const util = require('util');
const vm = require('vm');

const sandbox = {globalVar: 1, setTimeout: setTimeout, cb: function(result) {
    console.log(result);
}};
vm.createContext(sandbox);
const script = new vm.Script(`
    setTimeout(function(){
        globalVar++;
        cb("async result");
    }, 1000);
    globalVar;
`,{});
const result = script.runInContext(sandbox, {timeout: 500});
console.log(`result: ${result}`);
// result: 1
// async result

没有错误抛出，也就是说，这个选项并不能限制异步代码的运行时间，那应该怎么去限制所有代码的执行时间呢，目前好像没有接口终止 vm 代码的运行，如果有异步代码长时间不结束，很容易造成内存泄露，目前可行的方案是使用子进程去运行代码，如果超过限定时间还没有结果，就杀掉该子进程，另外，使用子进程还可以更方便地对内存等资源进行限制。

定制 context 与安全问题

在一个全新的 V8 context 里运行代码，里面包含了语言规范规定的内置的一些函数和对象，如果我们想要一些语言规范之外的功能或者模块，我们需要把相应对象放到与这个 context 关联的对象里，例如在上面例子中的这句代码：

1
2
3

const sandbox = {globalVar: 1, setTimeout: setTimeout, cb: function(result) {
    console.log(result);
}};

setTimeout 不是语言规范规定的内置函数， context 本身不提供，所以我们需要通过关联的对象传进去。

然而，当我们把一些模块功能提供给 context 的时候，也同时带入了更多的安全隐患，请看下面来自例子：

const util = require('util');
const vm = require('vm');

const sandbox = {};
vm.createContext(sandbox);
const script = new vm.Script(`
    // sandbox 的 constructor 是外层的 Object 类
    // Object 类的 constructor 是外层的 Function 类
    const OutFunction = this.constructor.constructor;
    // 于是, 利用外层的 Function 构造一个函数就可以得到外层的全局 this
    const OutThis = (OutFunction('return this;'))();
    // 得到 require
    const require = OutThis.process.mainModule.require;
    // 试试
    require('fs');
`,{});
const result = script.runInContext(sandbox);
console.log(result === require('fs'));
// true

显然，定制 context 的时候，任何一个传进去的对象或者函数都可能带来上面的问题，安全问题真的有很多工作需要做。

Github 上有一些开源的模块用于运行不信任代码，例如 sandbox，vm2，jailed等。查看这些项目的 issue 可以发现，sandbox 和 jailed 都可以用类似上面的方法突破限制，而 vm2 对这方面做了防护，其它方面也做了更多的安全工作，相对安全些。

生产中可以考虑在子进程中运行 vm2，然后增加更低层的安全限制，例如限制进程的权限和使用 cgroups 进行 IO，内存等资源限制，这里不详细讨论。

总结

本文通过几个例子介绍了 Node.js 的 vm 模块以及使用 vm 模块运行不信任代码可能遇到的问题，并且对安全问题给出了一些建议。

原文

https://segmentfault.com/a/1190000008284054

2018-02-25

IO—console模块解读之实现一个console.log

console是同步的还是异步的?

console.log既不是总是同步的，也不总是异步的。是否为同步取决于链接的是什么流以及操作系统是Windows还是POSIX:

注意: 同步写将会阻塞事件循环直到写完成。有时可能一瞬间就能写到一个文件，但当系统处于高负载时，管道的接收端可能不会被读取、缓慢的终端或文件系统，因为事件循环被阻塞的足够频繁且足够长的时间，这些可能会给系统性能带来消极的影响。当你向一个交互终端会话写时这可能不是个问题，但当生产日志到进程的输出流时要特别留心。

文件(Files): Windows和POSIX平台下都是同步
终端(TTYs): 在Windows平台下同步，在POSIX平台下异步
管道(Pipes): 在Windows平台下同步，在POSIX平台下异步

实现一个console.log

实现console.log在控制台打印，利用process.stdout将输入流数据输出到输出流(即输出到终端)，一个简单的例子输出hello world ， process.stdout.write(‘hello world!’ + ‘\n’); ，以下例子是对console源码解读实现，将Console取名为Logger。

实现步骤

初始化Logger对象
对参数进行检验，当前对象是否为Logger实例，是否为一个可写流实例
为Logger对象定义_stdout，_stderr等属性
将原型方法上的属性绑定到Logger实例上
实现log、error、warning、trace、clear等方法

创建logger.js文件

const util = require('util');

/**
 * 初始化Logger对象
 * @param {*} stdout 
 * @param {*} stderr 
 */
function Logger(stdout, stderr){
    // step1 检查当前对象是否为Logger实例
    if(!(this instanceof Logger)){
        return new Logger(stdout, stderr);
    }

    //检查是否是一个可写流实例
    if(!stdout || !(stdout.write instanceof Function)){
        throw new Error('Logger expects a writable stream instance');
    }

    // 如果stderr未指定，使用stdout
    if(!stderr){
        stderr = stdout;
    }

    //设置js Object的属性
    let props = {
        writable: true, // 对象属性是否可修改,flase为不可修改，默认值为true
        enumerable: false, // 对象属性是否可通过for-in循环，flase为不可循环，默认值为true
        configurable: false, // 能否使用delete、能否需改属性特性、或能否修改访问器属性、，false为不可重新定义，默认值为true
    }

    // Logger对象定义_stdout属性
    Object.defineProperty(this, '_stdout', Object.assign(props, {
        value: stdout,
    }));

    // Logger对象定义_stderr属性
    Object.defineProperty(this, '_stderr', Object.assign(props, {
        value: stderr,
    }));

    // Logger对象定义_times属性
    Object.defineProperty(this, '_times', Object.assign(props, {
        value: new Map(),
    }));

    // 将原型方法上的属性绑定到Logger实例上
    const keys = Object.keys(Logger.prototype);

    for(let k in keys){
        this[keys[k]] = this[keys[k]].bind(this);
    }
}

//定义原型Logger的log方法
Logger.prototype.log = function(){
    this._stdout.write(util.format.apply(this, arguments) + '\n');
}

Logger.prototype.info = Logger.prototype.log;

// 定义原型Logger的warn方法
Logger.prototype.warn = function(){
    this._stderr.write(util.format.apply(this, arguments) + `\n`);
}

Logger.prototype.error = Logger.prototype.warn;

// 返回当前调用堆栈信息
Logger.prototype.trace = function trace(...args){
    const err = {
        name: 'Trace',
        message: util.format.apply(null, args)
    }

    // 源自V8引擎的Stack Trace API https://github.com/v8/v8/wiki/Stack-Trace-API
    Error.captureStackTrace(err, trace);

    this.error(err.stack);
}

// 清除控制台信息
Logger.prototype.clear = function(){
    
    // 如果stdout输出是一个控制台，进行clear 否则不进行处理
    if(this._stdout.isTTY){
        const { cursorTo, clearScreenDown } = require('readline');
        cursorTo(this._stdout, 0, 0); // 移动光标到给定的 TTY stream 中指定的位置。
        clearScreenDown(this._stdout); // 方法会从光标的当前位置向下清除给定的 TTY 流
    }
}

//直接输出某个对象
Logger.prototype.dir = function(object, options){
    options = Object.assign({ customInspect: false }, options);

    /**
     * util.inspect(object,[showHidden],[depth],[colors])是一个将任意对象转换为字符串的方法，通常用于调试和错误的输出。
     * showhidden - 是一个可选参数，如果值为true，将会输出更多隐藏信息。
     * depth - 表示最大递归的层数。如果对象很复杂，可以指定层数控制输出信息的多少。
     * 如果不指定depth,默认会递归3层，指定为null表示不限递归层数完整遍历对象。
     * 如果color = true，输出格式将会以ansi颜色编码，通常用于在终端显示更漂亮的效果。
     */
    this._stdout.write(util.inspect(object, options) + '\n');
}

// 计时器开始时间
Logger.prototype.time = function(label){

    // process.hrtime()方法返回当前时间以[seconds, nanoseconds] tuple Array表示的高精度解析值， nanoseconds是当前时间无法使用秒的精度表示的剩余部分。
    this._times.set(label, process.hrtime())
}

// 计时器结束时间
Logger.prototype.timeEnd = function(label){
    const time = this._times.get(label);

    if (!time) {
        process.emitWarning(`No such label '${label}' for console.timeEnd()`);
        return;
    }

    const duration = process.hrtime(time);
    const ms = duration[0] * 1000 + duration[1] / 1e6; // 1e6 = 1000000.0 1e6表示1*10^6
    this.log('%s: %sms', label, ms.toFixed(3));
    this._times.delete(label);
}

module.exports = new Logger(process.stdout, process.stderr);

module.exports.Logger = Logger;

使用说明

基础例子

无特殊说明，日志都是默认打印到控制台

const logger = reuqire('logger');

logger.log('hello world')   // 普通日志打印
logger.info('hello world')  // 等同于logger.log
logger.error('hello world') // 错误日志打印
logger.warn('hello world')  // 等同于logger.error
logger.clear()              // 清除控制台信息

将调试信息打印到本地指定文件，这里要注意版本问题，以下代码示例在nodev10.x以下版本可以，具体原因参考 TypeError: Console expects a writable stream instance

const fs = require('fs');
const output = fs.createWriteStream('./stdout.txt');
const errorOutput = fs.createWriteStream('./stderr.txt');
const { Logger } = require('./logger');

const logger = Logger(output, errorOutput);

logger.info('hello world!'); // 内容输出到stdout.txt文件
logger.error('错误日志记录'); // 内容输出到stderr.txt文件

trace打印错误堆栈

1	logger.trace('测试错误');

Trace: 测试错误
    at Object.<anonymous> (/Users/qufei/Documents/mycode/Summarize/test/console-test.js:7:8)
    at Module._compile (module.js:624:30)
    at Object.Module._extensions..js (module.js:635:10)
    at Module.load (module.js:545:32)
    at tryModuleLoad (module.js:508:12)
    at Function.Module._load (module.js:500:3)
    at Function.Module.runMain (module.js:665:10)
    at startup (bootstrap_node.js:201:16)
    at bootstrap_node.js:626:3

dir显示一个对象的所有属性和方法

depth - 表示最大递归的层数。如果对象很复杂，可以指定层数控制输出信息的多少。

const family = {
    name: 'Jack',
    brother: {
        hobby: ['篮球', '足球']
    }
}

logger.dir(family, {depth: 3});

// { name: 'Jack', brother: { hobby: [ '篮球', '足球' ] } }

time和timeEnd计算程序执行消耗时间

logger.time 和 logger.timeEnd用来测量一个javascript脚本程序执行消耗的时间，单位是毫秒

// 启动计时器
logger.time('计时器');

// 中间写一些测试代码
for(let i=0; i < 1000000000; i++){}

// 停止计时器
logger.timeEnd('计时器');

// 计时器: 718.034ms

原文

https://github.com/Q-Angelo/summarize/blob/master/node/console.md

2018-01-25

事件—事件循环机制-实例

在node服务器端运行以下代码会出现什么输出结果？

setTimeout(function(){
    console.log('setTimeout');
    process.nextTick(function(){
        console.log('nextTick1');
    });
})

console.log('main1');

function say(){
    console.log('hello! ');
    process.nextTick(function(){
        console.log('nextTick2');
    })
}

new Promise(function(resolve){
    process.nextTick(function(){
        console.log('nextTick3');
    })
    console.log('promise 1');
    resolve('promise then')
}).then(function(data){
    console.log(data);
})

console.log('main2');

process.nextTick(function(){
    console.log('nextTick4');
});

say();

下面就结合这个原理图，根据问题，来一步一步分析：

也可参考下图：

我们经常会听到引擎和runtime，它们的区别是什么呢？

引擎：解释并编译代码，让它变成能交给机器运行的代码（runnable commands）。
runtime：就是运行环境，它提供一些对外接口供Js调用，以跟外界打交道。不同的runtime，会提供不同的接口，比如，在 Node.js 环境中，我们可以通过 require 来引入模块；而在浏览器中，我们有 window、 DOM。

Js引擎是单线程的，如上图中，它负责维护任务队列，并通过 Event Loop 的机制，按顺序把任务放入栈中执行。而图中的异步处理模块，就是 runtime 提供的，拥有和Js引擎互不干扰的线程。

任务队列

Js 中，有两类任务队列：宏任务队列（macro tasks）和微任务队列（micro tasks）。宏任务队列可以有多个，微任务队列只有一个。那么什么任务，会分到哪个队列呢？

宏任务：script（全局任务）, setTimeout, setInterval, setImmediate, I/O, UI rendering.
微任务：process.nextTick, Promise, Object.observer, MutationObserver.

我们上面讲到，当stack空的时候，就会从任务队列中，取任务来执行。共分3步：

取一个宏任务来执行。执行完毕后，下一步。
取一个微任务来执行，执行完毕后，再取一个微任务来执行。直到微任务队列为空，执行下一步。

从执行步骤来看，我们发现微任务，受到了特殊待遇！我们代码开始执行都是从script（全局任务）开始，所以，一旦我们的全局任务（属于宏任务）执行完，就马上执行完整个微任务队列。

我们代码的开始执行都是从script（全局任务）开始，这个全局任务属于宏任务；代码由上向下执行；

第1行，遇到了一个timer异步任务，属于宏任务，放入宏任务队列；

第8行，遇到log,内部没有其它函数，直接输出main1;

第10行，函数的定义，不执行；

第17行，遇到new Promise()，进入回调函数内部:
1）遇到promise.nextTick,属于微任务，放入微任务队列nextTick3;
2）遇到log,内部没有其它函数，直接输出promise 1;
3）遇到resolve回调，属于微任务，放入微任务队列promise then;

第27行，遇到log,内部没有其它函数，直接输出main2;

第29行，遇到promise.nextTick,属于微任务，放入微任务队列nextTick4;

第33行，执行say()：
1）遇到log,内部没有其它函数，直接输出hello;
2）遇到promise.nextTick,属于微任务，放入微任务队列nextTick2;
到此为止，我们已经做了如下事情：
1）宏任务队列中放入了一个timer函数；
2）输出了main1，promise 1，main2，hello1；
3）微任务队列中已经放入了promise then,nextTick3,nextTick4,nextTick2;

此时，我们的全局任务已执行完成了，就要马上执行完整个微任务队列。但是在微任务中，process.nextTick 是一个特殊的任务，它会被直接插入到微任务的队首（当然了，多个process.nextTick 之间也是先入先出的），优先级最高。所以，依次输出nextTick3,nextTick4,nextTick2,promise then

这时，执行栈为空了，可是别忘了，我们的宏任务队列还放者一个timer函数待执行，进入timer函数：
1）遇到log,内部没有其它函数，直接输出setTimeout;
2）遇到promise.nextTick,属于微任务，放入微任务队列nextTick1;

这个timer宏任务也执行完了，就马上执行完整个微任务队列，微任务队列目前只有一个任务，直接输出nextTick1；

这时，执行栈又为空了，还有其它任务吗? 没有了，大功告成；

以上的这种当函数执行栈为空，从任务队列中去一个任务来执行。再次为空，再取一个任务来执行，如此循环，这就是Event Loop，事件循环机制；

参考：

https://juejin.im/post/5a63470bf265da3e2c383068

https://segmentfault.com/a/1190000011198232

2017-12-15

10. switch 语句

switch 是一个条件语句，用于将表达式的值与可能匹配的选项列表进行比较，并根据匹配情况执行相应的代码块。它可以被认为是替代多个 if else 子句的常用方式。

看代码比文字更容易理解。让我们从一个简单的例子开始，它将把一个手指的编号作为输入，然后输出该手指对应的名字。比如 0 是拇指，1 是食指等等。

package main

import (
    "fmt"
)

func main() {
    finger := 4
    switch finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 5:
        fmt.Println("Pinky")

    }
}

在线运行程序

在上述程序中，switch finger 将 finger 的值与每个 case 语句进行比较。通过从上到下对每一个值进行对比，并执行与选项值匹配的第一个逻辑。在上述样例中， finger 值为 4，因此打印的结果是 Ring 。

在选项列表中，case 不允许出现重复项。如果您尝试运行下面的程序，编译器会报这样的错误: main.go：18：2：在tmp / sandbox887814166 / main.go：16：7

package main

import (
    "fmt"
)

func main() {
    finger := 4
    switch finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 4://重复项
        fmt.Println("Another Ring")
    case 5:
        fmt.Println("Pinky")

    }
}

在线运行程序

默认情况（Default Case）

我们每个人一只手只有 5 个手指。如果我们输入了不正确的手指编号会发生什么？这个时候就应该是属于默认情况。当其他情况都不匹配时，将运行默认情况。

package main

import (
    "fmt"
)

func main() {
    switch finger := 8; finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 5:
        fmt.Println("Pinky")
    default: // 默认情况
        fmt.Println("incorrect finger number")
    }
}

在线运行程序

在上述程序中 finger 的值是 8，它不符合其中任何情况，因此会打印 incorrect finger number。default 不一定只能出现在 switch 语句的最后，它可以放在 switch 语句的任何地方。

您可能也注意到我们稍微改变了 finger 变量的声明方式。finger 声明在了 switch 语句内。在表达式求值之前，switch 可以选择先执行一个语句。在这行 switch finger：= 8; finger 中，先声明了finger 变量，随即在表达式中使用了它。在这里，finger 变量的作用域仅限于这个 switch 内。

多表达式判断

通过用逗号分隔，可以在一个 case 中包含多个表达式。

package main

import (
    "fmt"
)

func main() {
    letter := "i"
    switch letter {
    case "a", "e", "i", "o", "u": // 一个选项多个表达式
        fmt.Println("vowel")
    default:
        fmt.Println("not a vowel")
    }
}

在线运行程序

在 case "a","e","i","o","u": 这一行中，列举了所有的元音。只要匹配该项，则将输出 vowel。

无表达式的 switch

在 switch 语句中，表达式是可选的，可以被省略。如果省略表达式，则表示这个 switch 语句等同于 switch true，并且每个 case表达式都被认定为有效，相应的代码块也会被执行。

package main

import (
    "fmt"
)

func main() {
    num := 75
    switch { // 表达式被省略了
    case num >= 0 && num <= 50:
        fmt.Println("num is greater than 0 and less than 50")
    case num >= 51 && num <= 100:
        fmt.Println("num is greater than 51 and less than 100")
    case num >= 101:
        fmt.Println("num is greater than 100")
    }

}

在线运行程序

在上述代码中，switch 中缺少表达式，因此默认它为 true，true 值会和每一个 case 的求值结果进行匹配。case num >= 51 && <= 100: 为 true，所以程序输出 num is greater than 51 and less than 100。这种类型的 switch 语句可以替代多个 if else 子句。

Fallthrough 语句

在 Go 中，每执行完一个 case 后，会从 switch 语句中跳出来，不再做后续 case 的判断和执行。使用 fallthrough 语句可以在已经执行完成的 case 之后，把控制权转移到下一个 case 的执行代码中。

让我们写一个程序来理解 fallthrough。我们的程序将检查输入的数字是否小于 50、100 或 200。例如我们输入 75，程序将输出75 is lesser than 100 和 75 is lesser than 200。我们用 fallthrough 来实现了这个功能。

package main

import (
    "fmt"
)

func number() int {
    num := 15 * 5 
    return num
}

func main() {

    switch num := number(); { // num is not a constant
    case num < 50:
        fmt.Printf("%d is lesser than 50\n", num)
        fallthrough
    case num < 100:
        fmt.Printf("%d is lesser than 100\n", num)
        fallthrough
    case num < 200:
        fmt.Printf("%d is lesser than 200", num)
    }

}

在线运行程序

switch 和 case 的表达式不一定是常量。它们也可以在运行过程中通过计算得到。在上面的程序中，num 被初始化为函数 number() 的返回值。程序运行到 switch 中时，会计算出 case 的值。case num < 100： 的结果为 true，所以程序输出 75 is lesser than 100。当执行到下一句 fallthrough 时，程序控制直接跳转到下一个 case 的第一个执行逻辑中，所以打印出 75 is lesser than 200。最后这个程序的输出会是

1 2	75 is lesser than 100 75 is lesser than 200

fallthrough 语句应该是 case 子句的最后一个语句。如果它出现在了 case 语句的中间，编译器将会报错：fallthrough statement out of place

这也是我们本教程的最后内容。还有一种 switch 类型称为 type switch 。我们会在学习接口的时候再研究这个。

2017-12-12

9. 循环

循环语句是用来重复执行某一段代码。

for 是 Go 语言唯一的循环语句。Go 语言中并没有其他语言比如 C 语言中的 while 和 do while 循环。

for 循环语法

1 2	for initialisation; condition; post { }

初始化语句只执行一次。循环初始化后，将检查循环条件。如果条件的计算结果为 true ，则 {} 内的循环体将执行，接着执行 post 语句。post 语句将在每次成功循环迭代后执行。在执行 post 语句后，条件将被再次检查。如果为 true, 则循环将继续执行，否则 for 循环将终止。（译注：这是典型的 for 循环三个表达式，第一个为初始化表达式或赋值语句；第二个为循环条件判定表达式；第三个为循环变量修正表达式，即此处的 post ）

这三个组成部分，即初始化，条件和 post 都是可选的。让我们看一个例子来更好地理解循环。

例子

让我们用 for 循环写一个打印出从 1 到 10 的程序。

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        fmt.Printf(" %d",i)
    }
}

Run in playground

在上面的程序中，i 变量被初始化为 1。条件语句会检查 i 是否小于 10。如果条件成立，i 就会被打印出来，否则循环就会终止。循环语句会在每一次循环完成后自增 1。一旦 i 变得比 10 要大，循环中止。

上面的程序会打印出 1 2 3 4 5 6 7 8 9 10 。

在 for 循环中声明的变量只能在循环体内访问，因此 i 不能够在循环体外访问。

break

break 语句用于在完成正常执行之前突然终止 for 循环，之后程序将会在 for 循环下一行代码开始执行。

让我们写一个从 1 打印到 5 并且使用 break 跳出循环的程序。

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        if i > 5 {
            break //loop is terminated if i > 5
        }
        fmt.Printf("%d ", i)
    }
    fmt.Printf("\nline after for loop")
}

Run in playground

在上面的程序中，在循环过程中 i 的值会被判断。如果 i 的值大于 5 然后 break 语句就会执行，循环就会被终止。打印语句会在 for循环结束后执行，上面程序会输出为

1 2	1 2 3 4 5 line after for loop

continue

continue 语句用来跳出 for 循环中当前循环。在 continue 语句后的所有的 for 循环语句都不会在本次循环中执行。循环体会在一下次循环中继续执行。

让我们写一个打印出 1 到 10 并且使用 continue 的程序。

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Printf("%d ", i)
    }
}

Run in playground

在上面的程序中，这行代码 if i%2==0 会判断 i 除以 2 的余数是不是 0，如果是 0，这个数字就是偶数然后执行 continue 语句，从而控制程序进入下一个循环。因此在 continue 后面的打印语句不会被调用而程序会进入一下个循环。上面程序会输出 1 3 5 7 9。

无限循环

无限循环的语法是：

1
2

for {  
}

下一个程序就会一直打印Hello World不会停止。

package main

import "fmt"

func main() {  
    for {
        fmt.Println("Hello World")
    }
}

如果你打算在 go playground 里尝试上面的程序，你会得到一个“过程耗时太长”的错误。请尝试在你本地系统上运行，来无限的打印 “Hello World” 。

这里还有一个 range 结构，它可以被用来在 for 循环中操作数组对象。当我们学习数组时我们会补充这方面内容。

这就是 for 循环的全部内容。

2017-12-11

8. if-else 语句

if 是条件语句。if 语句的语法是

1 2	if condition { }

如果 condition 为真，则执行 { 和 } 之间的代码。

不同于其他语言，例如 C 语言，Go 语言里的 { } 是必要的，即使在 { } 之间只有一条语句。

if 语句还有可选的 else if 和 else 部分。

if condition {  
} else if condition {
} else {
}

if-else 语句之间可以有任意数量的 else if。条件判断顺序是从上到下。如果 if 或 else if 条件判断的结果为真，则执行相应的代码块。如果没有条件为真，则 else 代码块被执行。

让我们编写一个简单的程序来检测一个数字是奇数还是偶数。

package main

import (  
    "fmt"
)

func main() {  
    num := 10
    if num % 2 == 0 { //checks if number is even
        fmt.Println("the number is even") 
    }  else {
        fmt.Println("the number is odd")
    }
}

在线运行程序

if num％2 == 0 语句检测 num 取 2 的余数是否为零。如果是为零则打印输出 “the number is even”，如果不为零则打印输出 “the number is odd”。在上面的这个程序中，打印输出的是 the number is even。

if 还有另外一种形式，它包含一个 statement 可选语句部分，该组件在条件判断之前运行。它的语法是

1 2	if statement; condition { }

让我们重写程序，使用上面的语法来查找数字是偶数还是奇数。

package main

import (  
    "fmt"
)

func main() {  
    if num := 10; num % 2 == 0 { //checks if number is even
        fmt.Println(num,"is even") 
    }  else {
        fmt.Println(num,"is odd")
    }
}

在线运行程序

在上面的程序中，num 在 if 语句中进行初始化，num 只能从 if 和 else 中访问。也就是说 num 的范围仅限于 if else 代码块。如果我们试图从其他外部的 if 或者 else 访问 num,编译器会不通过。

让我们再写一个使用 else if 的程序。

package main

import (  
    "fmt"
)

func main() {  
    num := 99
    if num <= 50 {
        fmt.Println("number is less than or equal to 50")
    } else if num >= 51 && num <= 100 {
        fmt.Println("number is between 51 and 100")
    } else {
        fmt.Println("number is greater than 100")
    }

}

在线运行程序

在上面的程序中，如果 else if num >= 51 && num <= 100 为真，程序将输出 number is between 51 and 100。

获取免费的 Golang 工具

一个注意点

else 语句应该在 if 语句的大括号 } 之后的同一行中。如果不是，编译器会不通过。

让我们通过以下程序来理解它。

package main

import (  
    "fmt"
)

func main() {  
    num := 10
    if num % 2 == 0 { //checks if number is even
        fmt.Println("the number is even") 
    }  
    else {
        fmt.Println("the number is odd")
    }
}

在线运行程序

在上面的程序中，else 语句不是从 if 语句结束后的 } 同一行开始。而是从下一行开始。这是不允许的。如果运行这个程序，编译器会输出错误，

1	main.go:12:5: syntax error: unexpected else, expecting }

出错的原因是 Go 语言的分号是自动插入。你可以在这里阅读分号插入规则 https://golang.org/ref/spec#Semicolons。

在 Go 语言规则中，它指定在 } 之后插入一个分号，如果这是该行的最终标记。因此，在if语句后面的 } 会自动插入一个分号。

实际上我们的程序变成了

if num%2 == 0 {  
      fmt.Println("the number is even") 
};  //semicolon inserted by Go
else {  
      fmt.Println("the number is odd")
}

分号插入之后。从上面代码片段可以看出第三行插入了分号。

由于 if{…} else {…} 是一个单独的语句，它的中间不应该出现分号。因此，需要将 else 语句放置在 } 之后处于同一行中。

我已经重写了程序，将 else 语句移动到 if 语句结束后 } 的后面，以防止分号的自动插入。

package main

import (  
    "fmt"
)

func main() {  
    num := 10
    if num%2 == 0 { //checks if number is even
        fmt.Println("the number is even") 
    } else {
        fmt.Println("the number is odd")
    }
}

在线运行程序

现在编译器会很开心，我们也一样 ?

协议三要素

我们常用的网络协议有哪些？

一、环境配置的难题

二、虚拟机

三、Linux 容器

四、Docker 是什么？

五、Docker 的用途

六、Docker 的安装

六、image 文件

七、实例：hello world

八、容器文件

九、Dockerfile 文件

十、实例：制作自己的 Docker 容器

10.1 编写 Dockerfile 文件

10.2 创建 image 文件

10.3 生成容器

10.4 CMD 命令

10.5 发布 image 文件

十一、其他有用的命令

原文

Create the Node.js app

Creating a Dockerfile

.dockerignore file

Building your image

Run the image

Test

original

1. buffer的基本使用

2. buffer的结构

3. 内存分配的策略

3.1 Buffer.from

3.1.1 ArrayBuffer的实例

3.1.2 string

3.1.3 Buffer/TypeArray/Array

3.2 Buffer.alloc

3.2.1 先申请后填充

3.2.2 flags标示

3.2.3 Uint8Array

3.3 Buffer.allocUnSafe

3.4 Buffer.allocUnsafeSlow

4. 结语

原文

vm模块

外层如何得到代码运行结果

代码运行时间限制

定制 context 与安全问题

总结

原文

console是同步的还是异步的?

实现一个console.log

实现步骤

创建logger.js文件

使用说明

基础例子

trace打印错误堆栈

dir显示一个对象的所有属性和方法

time和timeEnd计算程序执行消耗时间

原文

任务队列

默认情况（Default Case）

多表达式判断

无表达式的 switch

Fallthrough 语句

for 循环语法

例子

break

continue

更多例子

无限循环

一个注意点