第 5 章 引用类型

引用类型的值（对象）是引用类型的一个实例。对象是使用 new 操作符后跟一个构造函数来创建的。构造函数本身就是一个函数。

1

var person = new Object();

5.1 Object 类型

创建 object 类型的实例有两种方式，一种是 new 操作符后面跟 Object 构造函数，另一种是用对象字面量表示法。例如 var person = {};
一般来说访问对象属性都用点来表示，不过也可以使用方括号表示法来访问对象属性。

1
2
3

var person = { name: "Diamond" };
console.log(person.name); //Diamond
console.log(person["name"]); //Diamond

使用方括号表示的时候可以使用变量。

1
2

var key = "name";
console.log(person[key]); //Diamond

5.2 Array 类型

初始化也有两种，一种是使用 Array 构造函数，或者也可以使用字面量表示。

1
2

var colors = new Array();
var names = [];

访问数组的值，要使用方括号并且提供基于 0 的数字索引。
length 永远为数组的最后一项的索引 +1 。最多包含 4294967295 个项。

1
2
3

let data = [];
data[100] = 10;
console.log(data.length); //101

5.2.1 检测数组

Array.isArray

5.2.2 转换方法

1
2

let data = [1, 2];
console.log(data.toString() === data.join(",")); //true

5.2.3 栈方法

• push 入栈
• pop 出栈

5.2.4 队列方法

• push 入队
• shift 出队

5.2.5 重排序方法

• reverse 反转
• sort 排序

5.2.6 操作方法

• concat 连接
• slice 基于当前数组中的一或多个项创建一个新数组
• splice 删除/插入/替换

5.2.7 位置方法

• indexOf
• lastindexOf

5.2.8 迭代方法

• every 对数组中的每一项运行给定函数,如果该函数对每一项都返回 true,则返回 true。
• filter 对数组中的每一项运行给定函数,返回该函数会返回 true 的项组成的数组。
• forEach 对数组中的每一项运行给定函数。这个方法没有返回值。
• map 对数组中的每一项运行给定函数,返回每次函数调用的结果组成的数组。
• some 对数组中的每一项运行给定函数,如果该函数对任一项返回 true,则返回 true

5.2.9 缩小方法

• reduce
• reduceRight
  上面两个函数都接受四个参数，前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。

5.3 Date 类型

注意

1
2
3

console.log(new Date().getSeconds()); //返回秒数 范围是0~59
console.log(new Date().getDay()); //返回星期几 0 表示星期天
console.log(new Date().getMonth()); //返回几月份 0 表示1月 11表示12月

5.4 RegExp 类型

正则语法如下 var expression = / pattern / flags;
Flag 支持三个标志,可以一个或者多个

• g 表示全局，否则会在第一个匹配后立刻停止
• I 表示不区分大小写
• m 表示多行模式
  -

5.4.1 实例属性

• gobal 布尔值,表示是否设置了 g 标志。
• ignoreCase 布尔值,表示是否设置了 i 标志
• lastIndex 整数,表示开始搜索下一个匹配项的字符位置,从 0 算起。
• multiline 布尔值,表示是否设置了 m 标志。
• source 正则表达式的字符串表示,按照字面量形式而非传入构造函数中的字符串模式返回。

5.4.2 RegExp 实例方法

RegExp 对象的主要方法是 exec ,该方法是专门为捕获组而设计的。exec 接受一个参数,即要应用模式的字符串,然后返回包含第一个匹配项信息的数组;或者在没有匹配项的情况下返回 null.
对于 exec 方法而言,即使在模式中设置了全局标志,它每次也只会返回一个匹配项。在不设置全局标志的情况下,在同一个字符串上多次调用 exec 将始终返回第一个匹配项的信息。而在设置全局标志的情况下,每次调用 exec 则都会在字符串中继续查找新匹配项。
正则表达式的第二个方法是 test ,它接受一个字符串参数。在模式与该参数匹配的情况下返回 true;否则,返回 false。
RegExp 实例继承的 tostring 方法会返回正则表达式的字面量。

5.5 Function 类型

函数可以通过 Function 构造函数来创建。

1

var sum = Function("num1", "num2", "return num1 + num2");

5.5.1 没有重载

相同函数名的函数会相互覆盖

5.5.2 函数声明与函数表达式

解析器在向执行环节加载数据时，会率先去读函数声明，使其在执行任何代码之前可用。而函数表达式，则必须等到解析器执行到它所在的代码行。

5.5.3 作为值的函数

函数除了可以作为值使用，不仅可以把一个函数传递给另一个函数，还可以将一个函数作为另一个函数的结果返回。

5.5.4 函数的内部属性

this 引用的是函数据以执行的环境对象。在严格模式下，全局作用域调用函数时候，this 引用是 window。
函数名字仅仅是一个包含指针的变量，所以把函数赋值给其他对象，调用时候指向的仍然是同一个函数。

严格模式下被废弃或者不推荐的内容

arguments 有一个名叫 callee 的属性，指向拥有这个 arguments 对象的函数。
函数有一个对象属性 caller 保存着调用当前函数的函数的引用。如果在全局调用，则它的值为 null .
严格模式下，全局调用的函数，this 指向的是 undifined

5.5.5 函数属性和方法

每个函数都包含两个属性，length 和 prototype。lenght 属性表示函数希望接收的命名参数的个数。
对于引用类型而言，prototype 是保存它们所有实例方法的真正所在。诸如 toString 和 valueOf 都保存在 prototype 下。
每个函数都包含两个非继承而来的方法 call 和 apply .这两个方法用途都是在特定作用域下调用函数，等于是设置 this 的值。首先，apply 接收两个参数，一个在其中运行函数的作用域，另一个是参数数组。可以是 array 的实例，也可以是 arguments 对象。
call 和 apply 作用相同，只是接收参数的方法不同。call 第一个参数和 apply 相同，其他参数都是直接传递给函数。
bind 方法会创建一个函数的实例，其 this 会被绑定到传给 bind 函数的值。
函数的 toSring 会返回函数的代码。

5.6 基本包装类型

每当读取基本类型值的时候，后台就会创建一个对应的基本包装类型的对象。让我们能够调用一些方法来操作这些属性。

5.6.1 Boolean 类型

建议不要使用。

5.6.2 Number 类型

1

var numberObject = new Number(10); //创建

• toSring 方法传递基数，可以转换进制。
• toFixed 传入位数，返回数值的字符串表示，会四舍五入。IE8 以及之前有 bug
• toExponential 返回指数表示法，参数指定输出结果中的小数位数
• toPrecision ，会根据情况智能判断使用 toFixed 还是 toExponential
  建议不要实例化 Number ，因为 typeof 会显示 object。

5.6.3 String 类型

略 详情见 MDN

5.7 单体内置对象

ECMAScript 实现提供的，不依赖于宿主环境的对象，在 ECMAScript 程序执行前就已经存在了。

5.7.1 Global 对象

兜底对象，不属于其他对象的属性和方法，最终都是它的属性。

1. URI 编码方法

encodeURI 和 encodeURIComponent 都可以对 URL 编码。
encodeURI 主要对 URI 编码，而 encodeURIComponent 则会对任何非标准字符编码。编码对应有两个解码方法 decodeURI , decodeURIComponent。

2. eval 方法

只接受一个参数，就是要执行的 ECMAScript 字符串。被执行代码具有与该环境相同的作用域链。严格模式下，外部无法访问到 eval 中创建的任何变量和函数。

3. Global 对象的属性

所有原生引用类型的构造函数都是 Global 对象的属性。还有 undefined ,NaN 和 Infinity 等。

4.window 对象

在浏览器环境下，全剧作用域中声明的所有变量和函数，都成为了 window 对象的的属性。

5.Math 对象

详情可见 MDN。

5.8 小结

对象在 Javascript 中被称为引用类型的值,而且有一些内置的引用类型可以用来创建特定的对象
现简要总结如下:

• 引用类型与传统面向对象程序设计中的类相似,但实现不同;
• Object 是一个基础类型,其他所有类型都从 Object 继承了基本的行为;
• Array 类型是一组值的有序列表,同时还提供了操作和转换这些值的功能;
• Date 类型提供了有关日期和时间的信息,包括当前日期和时间以及相关的计算功能;
• RegExp 类型是 ECMAScrip t 支持正则表达式的个接口,提供了最基本的和一些高级的正则表达式功能。
  函数实际上是 Function 类型的实例,因此函数也是对象;而这一点正是 Javascript 最有特色的地方。由于函数是对象,所以函数也拥有方法,可以用来增强其行为.因为有了基本包装类型,所以 JavaScript 中的基本类型值可以被当作对象来访问。三种基本包装类型分别是: Boolean、 Number 和 String。以下是它们共同的特征:
• 每个包装类型都映射到同名的基本类型;
• 在读取模式下访问基本类型值时,就会创建对应的基本包装类型的一个对象,从而方便了数据操作;
• 操作基本类型值的语句一经执行完毕,就会立即销毁新创建的包装对象。
  在所有代码执行之前作用域中就已经存在两个内置对象,Global 和 Math 在大多数 ECMAScript 实现中都不能直接访问 Global 对象;不过,web 浏览器实现了承担该角色的 window 对象。全局变量和函数都是 Global 对象的属性。Math 对象提供了很多属性和方法,用于辅助完成复杂的数学计算任务。

第 4 章 变量、作用域和内存问题

4.1 基本类型和引用类型

ECMAScript 变量可能包含两种不同数据类型的：基本类型值和引用类型值。基本类型值指的是简单的数据段,而引用类型值指那些可能由多个值构成的对象。
在将一个值赋绐变量时,解析器必须确定这个值是基本类型值还是引用类型值。基本类型是按值访问的，引用类型是按引用访问的。

4.1.1 动态的属性

对于引用类型的值,我们可以为其添加属性和方法,也可以改变和删除其属性和方法。而我们不能给基本类型的值添加属性，尽管不会导致任何错误。

4.1.2 复制变量值

如果从一个变量向另外一个变量复制基本类型的值，会在变量对象上创建一个新值，然后把该值复制到为新变量分配得位置上。
当从一个变量向另一个变量复制引用类型的值时,同样也会将存储在变量对象中的值复制一份放到为新变量分配的空间中。不同的是,这个值的副本实际上是一个指针,而这个指针指向存储在堆中的一个对象。复制操作结束后,两个变量实际上将引用同一个对象。

4.1.3 传递参数

ECMAScript 中所有函数的参数都是按值传递的。把函数外部的值复制给函数内部的参数,就和把值从一个变量复制到另一个变量一样。在向参数传递引用类型的值时,会把这个值在内存中的地址复制给一个局部变量。所以局部变量的变化会反映在外部。

4.1.4 检测类型

检测一个变量是不是基本数据类型，可以使用 typeof，如果想知道某个值是什么类型的对象，可以使用 instanceof 操作符。
如果变量是给定引用类型的实例，那么 instanceof 操作符会返回 true 。

4.2 执行环境及作用域

每一个执行环境都有与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中。
全局执行环境是最外围的一个执行环境，根据 ECMA 所在的宿主环境不同，执行环境对象也不一样。浏览器中，全局执行环境被认为是 window 对象。
每个函数都有自己的执行环境，当执行流进入一个函数时，函数环境就会被推入环境栈中。函数执行后，栈将其环境退出。把控制器交还给之前的执行环境。
当代码在环境中执行，会创建变量对象的一个作用域链。作用域链的用处是保证对执行环境有权访问的所有变量和函数的有序访问。作用域链的前端，永远都是当前执行代码所在环境的变量对象。
如果这个环境是函数,则将其活动对象作为变量对象。活动对象在最开始时只包含一个变量，即 arguments 对象，作用域链中的下一个变量对象来自包含(外部)环境，而再下一个变量对象则来自下一个包含环境。这样,一直延续到全局执行环境。全局执行环境的变量对象始终都是作用域链中的最后一个对象。

内部环境可以通过作用域链访问所有的外部环境，但是外部环境不能访问内部环境中的任何变量和函数。每个环节都可以向上搜索作用域链，以查询变量和函数名。

4.2.1 延长作用域链

With 不常用，略。
4.2.2 var 没有块级作用域

1
2
3
4

if (true) {
  var color = "blue";
}
console.log(color); //blue

使用 var 声明的变量会添加到最接近的环境中

1
2
3
4

for (var i = 0; i < 10; i++) {
  //doSomething
}
console.log(i); //10

如果在循环中创建变量，在循环结束后依旧会存在于循环的外部执行环境中。

1. 声明变量
   使用 var 声明的变量会添加到最接近的环境中，如果初始化变量时候没有声明，则会被添加到全局环境（严格模式会报错）。
2. 查询标识符
   当环境中为了读取或写入而引入一个标识符时，会从作用域链的前端开始，向上逐级查询与给定名字匹配的标识符。如果在局部环境找到该标识符，搜索结果停止。一直追溯到全局环境的变量对象。

4.3 垃圾收集 GC

4.3.1 标记清除

略

4.3.2 引用计数

略

4.4 小结

JavaScript 变量可以保存两种类型的值，基本类型和引用类型。基本类型和引用类型有以下特点。

• 基本类型在内存中占据固定大小的空间，因此被保存在栈内存中；
• 从一个变量向另一个变量复制基本类型的值，会创建这个值的副本；
• 引用类型的值是对象,保存在堆内存中;
• 包含引用类型值的变量实际上包含的并不是对象本身,而是一个指向该对象的指针;
• 从一个变量向另一个变量复制引用类型的值,复制的其实是指针,因此两个变量最终都指向同一个对象;
• 确定一个值是哪种基木类型可以使用 typeof 操作符,而确定一个值是哪种引用类型可以使用 instanceof 操作符。

所有变量(包括基本类型和引用类型)都存在于一个执行环境(也称为作用域)当中,这个执行环境决定了变量的生命周期,以及哪一部分代码可以访问其中的变量。以下是关于执行环境的几点总结

• 执行环境有全局执行环境(也称为全局环境)和函数执行环境之分;
• 每次进入一个新执行环境,都会创建一个用于搜索变量和函数的作用域链;
• 函数的局部环境不仅有权访问函数作用域中的变量,而且有权访问其包含(父)环境,乃至全局环境;
• 全局环境只能访问在全局环境中定义的变量和函数,而不能直接访问局部环境中的任何数据;
• 变量的执行环境有助于确定应该何时释放内存。
  Javascript 是一门具有自动垃圾收集机制的编程语言,开发人员不必关心内存分配和回收问题。可以对 JavaScript 的垃圾收集例程作如下总结。
• 离开作用域的值将被自动标记为可以回收,因此将在垃圾收集期间被删除。
• “标记清除”是目前主流的垃圾收集算法,这种算法的思想是给当前不使用的值加上标记,然后再回收其内存。
• 另一种垃圾收集算法是“引用计数”,这种算法的思想是跟踪记录所有值被引用的次数。 JavaScript 引擎目前都不再使用这种算法;但在 IE 中访问非原生 JavaScript 对象(如 DOM 元素)时,这种算法仍然可能会导致问题。
• 当代码中存在循环引用现象时,“引用计数”算法就会导致问题。
• 解除变量的引用不仅有助于消除循环引用现象,而且对垃圾收集也有好处。为了确保有效地回收内存,应该及时解除不再使用的全局对象、全局对象属性以及循环引用变量的引用。

第 3 章 基本概念

3.1 语法

3.1.1 区分大小写

ECMAScript 中的一切都区分大小写。

3.1.2 标识符

所谓标识符,就是指变量、函数、属性的名字,或者函数的参数。标识符可以是按照下列格式规则组合起来的一或多个字符:

• 第一个字符必须是一个字母、下划线或一个美元符号($);
• 其他字符可以是字母、下划线、美元符号或数字。

3.4 数据类型

ECMAScript 有六种基本类型 Undifined Null Boolean Number String Symbol 和 Object。

3.4.1 typeof 操作符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// Numbers
typeof 37 === "number";
typeof 3.14 === "number";
typeof Math.LN2 === "number";
typeof Infinity === "number";
typeof NaN === "number"; // 尽管NaN是"Not-A-Number"的缩写
typeof Number(1) === "number"; // 但不要使用这种形式!

// Strings
typeof "" === "string";
typeof "bla" === "string";
typeof typeof 1 === "string"; // typeof总是返回一个字符串
typeof String("abc") === "string"; // 但不要使用这种形式!

// Booleans
typeof true === "boolean";
typeof false === "boolean";
typeof Boolean(true) === "boolean"; // 但不要使用这种形式!

// Symbols
typeof Symbol() === "symbol";
typeof Symbol("foo") === "symbol";
typeof Symbol.iterator === "symbol";

// Undefined
typeof undefined === "undefined";
typeof declaredButUndefinedVariable === "undefined";
typeof undeclaredVariable === "undefined";

// Objects
typeof { a: 1 } === "object";

// 使用Array.isArray 或者 Object.prototype.toString.call
// 区分数组,普通对象
typeof [1, 2, 4] === "object";

typeof new Date() === "object";

// 下面的容易令人迷惑，不要使用！
typeof new Boolean(true) === "object";
typeof new Number(1) === "object";
typeof new String("abc") === "object";

// 函数
typeof function() {} === "function";
typeof class C {} === "function";
typeof Math.sin === "function";
typeof new Function() === "function";

注意

1

typeof null === "object";

3.4.5 Number 类型

1.精度

浮点数值的最高精度是 17 位小数,但在进行算术计算时其精确度远远不如整数。例如,0.1 加 0.2 的结果不是 0.3。

2.范围

ECMAScript 正数数值范围最大为 Number.MAX_VALUE 最小的数值为 Number.Min_VALUE,如果超出最大值，则会转换为 Infinity。
判断一个数字是否是有穷的，可以通过 isFinite()函数来判断。

3.NaN

NaN,即非数值(Not a Number)是一个特殊的数值,这个数值用于表示一个本来要返回数值的操 作数未返回数值的情况(这样就不会抛出错误了)。
注意

1

（NaN === NaN) === false;

判断 NaN 需要通过 isNaN 函数。
如果基于对象调用 isNaN ,会先使用 valueOf ，然后返回的值是否能转换为数值，如果不能，再调用 toString() 方法。

4.数值转换

有三个函数可以把非数值转换为数值，Number(),parseInt(),parseFloat。
Number 的转换规则如下

• 如果是 Boolean，true 和 false 讲分别转换为 1 和 0
• 如果是数值，则是简单的传入和返回
• 如果是 null 返回 0
• 如果是 undefined 返回 NAN
• 如果是字符串,遵循下列规则 + 如果字符串中只包含数字(包括前面带正号或负号的情况),则将其转换为十进制数值,即 1 会变成 1,"123"会变成 123,而"011"会变成 11 + 如果字符串中包含有效的浮点格式,如 1.1,则将其转换为对应的浮点数值 + 如果字符串中包含有效的十六进制格式,例如"0xf",则将其转换为相同大小的十进制整数值; + 如果字符串是空的(不包含任何字符),则将其转换为 0 + 如果字符串中包含除上述格式之外的字符,则将其转换为 NaN + 如果是对象,则调用对象的 valueof()方法,然后依照前面的规则转换返回的值。如果转换的结果是 NaN,则调用对象的 tostring()方法,然后再次依照前面的规则转换返回的字符串值。

一元加操作符(3.5.1节将介绍)的操作与 number() 函数相同。

parseInt()在转换字符串时,更多的是看其是否符合数值模式。它会忽略字
符串前面的空格,直至找到第一个非空格字符。如果第一个字符不是数字字符或者负号, parseInt()就会返回 NaN;也就是说, parseInt('') //NaN

• 如果第一个字符是数字字符, parseInt()会继续解析第二个字符,直到解析完所有后续字符或者遇到了一个非数字字符。

parseInt 的第二个参数为转换使用的进制，建议无论在任何情况都要穿入第二个参数。

parseFloat 也是从第一个字符(位置 0)开始解析每个字符。而且也是一直解析到字符串末尾, 或者解析到遇见一个无效的浮点数字字符为止。符串中的第一个小数点是有效的,而第二个小数点就是无效的了。

parseFloat() 只解析十进制的数字，如果字符串包含的是个可解析为整数的数，parseFloat 结果会是一个整数。

3.4.6 String 类型

String 类型用于表示由零或多个 16 位 Unicode 字符组成的字符序列,即字符串。字符串可以由单引号(')或双引号")表示。

1

"\u03a3".length === 1; //true

2. 字符串的特点
   ECMAScript 中的字符串是不可变的。一旦创建，它们的值就不能改变。要改变变量创建的字符串，首先要销毁原来的字符串。
3. 转换为字符串
   要把值转换为字符串，有两种方式。第一种是使用几乎每个值都有的 toString 方法。多数情况下,调用 tostring 方法不必传递参数。但是,在调用数值的 tostring()方法时,可以传递一个参数：输出数值的基数。默认情况下，基数为 10。

1
2

var num = 10;
console.log(num.toString(8)); // "12"

如果不确定值是否为 null 或者 undefined 可以使用函数 String 来转换。

1
2

String(null); // "null"
String(undefined); // "undefined"

3.4.7 Object 类型

对象可以通过执行 new 操作符后跟要创建的对象类型的名称来创建。

3.5 操作符

3.5.1 一元操作符

1. 递增和递减操作符 ++,--

1
2
3
4

let a = 1;
console.log(++a); //2
console.log(a++); //2
console.log(a); //3

2. 一元加和减操作符
   加放在数值面前，对数值不会产生任何影响，如果是对非数值应用一元加操作符，会先把这个值转换成数值。

3.5.2 位运算

• 非 ~
• 与 &
• 或 |
• 异或 ^
• 左移 <<
• 有符号右移 >>
• 无符号右移 >>>

3.5.3 布尔操作符

1. 逻辑非 !
   可以把任何数据类型都转换为布尔值。

1
2
3
4
5

![]; //false
!{}; //false
!123; //false
!0; //true
!NaN; //true

可以同时使用两个 !,结果与 Boolean 函数相同

2. 逻辑与&&
   除了用在布尔值上，也可以用在对象上。

• 如果第一个操作数是对象,则返回第二个操作数;
• 如果第二个操作数是对象,则只有在第一个操作数的求值结果为 true 的情况下才会返回该对象;
• 如果两个操作数都是对象,则返回第二个操作数;
• 如果有一个操作数是 null,则返回 null;
• 如果有一个操作数是 NaN,则返回 NaN;
• 如果有一个操作数是 undefined , 则返回 undefined

3. 逻辑或 ||
   同上，也可以用在对象上。

• 如果第一个操作数是对象,则返回第一个操作数;
• 如果第一个操作数的求值结果为 false,则返回第二个操作数;
• 如果两个操作数都是对象,则返回第一个操作数;
• 如果两个操作数都是 null,则返回 null;
• 如果两个操作数都是 NaN,则返回 NaN;
• 如果两个操作数都是 undefined,则返回 undefined

3.5.4 乘性操作符

* /

3.5.5 加性操作符

+ -

3.5.6 关系操作符

< > <= >=

• 如果两个操作数都是数值,则执行数值比较。
• 如果两个操作数都是字符串,则比较两个字符串对应的字符编码值。
• 如果一个操作数是数值,则将另一个操作数转换为一个数值,然后执行数值比较。
• 如果一个操作数是对象,则调用这个对象的 valueOf 方法,用得到的结果按照前面的规则执行比较。如果对象没有 valueOf 方法,则调用 toString 方法,并用得到的结果根据前面的规则执行比较。
• 如果一个操作数是布尔值,则先将其转换为数值,然后再执行比较。

因为大写字符的字符编码全部小于小写字母的字符编码，所以就会看到如下的现象。

1
2
3

var result = "Brick" < "alphabet"; //true
var result = "23" < "3"; //true;
var result = "23 " < 3; // false

3.5.7 相等操作符

== === != !==

1. 相等和不相等
   如果两个操作数不相等，会执行强制转型，再比较相等性

• 如果有一个操作数是布尔值,则在比较相等性之前先将其转换为数值 fase 转换为 0,而 true 转换为 1;
• 如果一个操作数是字符串,另一个操作数是数值,在比较相等性之前先将字符串转换为数值;
• 如果一个操作数是对象,另一个操作数不是,则调用对象的 valueOf()方法,用得到的基本类型值进行比较。

1
2

null == undefined; //true
NaN != NaN; //true

2. 全等和不全等
   如果类型不相等，则返回 false

3.5.8 条件操作符 ?:

1

variable = boolean_expression ? true_value : false_value;

3.5.9 赋值操作符 =

在等号前面加乘性操作符、加性操作符或位操作符,可以完成复合操作。

1
2
3
4
5

var num = 10;
num = num + 10;
//等价于下面的
var num = 10;
num += 10;

3.5.10 逗号操作符

逗号操作符可以在一行语句中执行多个操作.

1
2

var num = 1,
  num2 = 2;

3.6 语句

3.6.1 if 语句

推荐任何时候都用代码块包起来。

3.6.2 do-while 语句

略

3.6.3 while 语句

略

3.6.4 for 语句

1
2
3

for (;;) {
  console.log(1);
} // 无限循环

3.5.5 for-in 语句

用来枚举对象的属性，或者枚举数组的索引

3.6.6 label 语句

略 几乎不使用

3.6.7 break 和 continue 语句

略

3.6.8 with 语句

略

3.6.9 switch 语句

不要忘记加 break

3.7 函数

通过 return 来表示返回值，函数会在 return 之后立刻退出，任何 return 后的语句都不会执行。finally 除外。

1
2
3
4
5
6
7
8
9

function tt() {
  try {
    return 2;
  } catch {
  } finally {
    return 1;
  }
}
tt(); // 1

如果 return 后不带任何返回值，则相当于返回 undefined 。

推荐的做法是要么让函数始终都返回一个值,要么永远都不要返回值。否则,如果函教有时候返回值,有时候有不返回值,会给调试代码带来不便。

3.7.1 理解参数

函数内可以通过 arguments 来访问参数，arguments 不是 Array 的实例，虽然有 length 来表示参数的个数。但是没有 Array 的一些方法。

3.7.2 没有重载

定于两个名字相同的函数，则名字属于后定义的函数，可以通过检查传入参数的类型和数量，模拟重载。

3.8 小结

JavaScript 的核心语言特性在 ECMA-262 中是以名为 ECMAScrip t 的伪语言的形式来定义的。ECMAScript 中包含了所有基本的语法、操作符、数据类型以及完成基本的计算任务所必需的对象,但没有对取得输入和产生输出的机制作出规定。理解 ECMAScript 及其纷繁复杂的各种细节,是理解其在 Web 浏览器中的实现 ————JavaScript 的关键。

• ECMAScript 中的基本数据类型包括 Undefined、Null、 Boolean、Number、String 和 Symbol
• 与其他语言不同, ECMScript 没有为整数和浮点数值分别定义不同的数据类型, Number 类型可用于表示所有数值。
• ECMAScript 中也有一种复杂的数据类型,即 Object 类型,该类型是这门语言中所有对象的基础类型。
• 严格模式为这门语言中容易出错的地方施加了限制。
• ECMAScript 提供了很多与 C 及其他类 C 语言中相同的基本操作符,包括算术操作符、布尔操作符、关系操作符、相等操作符及赋值操作符等。
• ECMAScript 从其他语言中借鉴了很多流控制语句,例如 if 语句、for 语句和 switch 语句等。
  ECMAScript 中的函数与其他语言中的函数有诸多不同之处。
• 无须指定函数的返回值,因为任何 ECMAScript 函数都可以在任何时候返回任何值。
• 实际上,未指定返回值的函数返回的是一个特殊的 undefined 值。
• ECMAScript 中也没有函数签名的概念,因为其函数参数是以一个包含零或多个值的数组的形式传递的。
• 可以向 ECMAScript 函数传递任意数量的参数,并且可以通过 arguments 对象来访向这些参数。
• 由于不存在函数签名的特性, ECMAScript 函数不能重载。

第 2 章 在 HTML 中使用 JavaScript

2.1 <script> 元素

在页面插入 JavaScript 主要方法，就是使用 <script> 元素。 <script> 常用有下面几个属性:

• async(html5) 该布尔属性指示浏览器是否在允许的情况下异步执行该脚本。该属性对于内联脚本无作用 (即没有 src 属性的脚本）。
• defer 这个布尔属性被设定用来通知浏览器该脚本将在文档完成解析后，触发 DOMContentLoaded 事件前执行。如果缺少 src 属性（即内嵌脚本），该属性不应被使用，因为这种情况下它不起作用。对动态嵌入的脚本使用 async=false 来达到类似的效果。
• src 这个属性定义引用外部脚本的 URI，这可以用来代替直接在文档中嵌入脚本。指定了 src 属性的 script 元素标签内不应该再有嵌入的脚本
• type 该属性定义 script 元素包含或 src 引用的脚本语言。属性的值为 MIME 类型; 支持的 MIME 类型包括text/javascript, text/ecmascript, application/javascript, 和application/ecmascript。如果没有定义这个属性，脚本会被视作 JavaScript。如果 type 属性为 module，代码会被当作 JavaScript 模块 。请参见 ES6 In Depth: Modules

代码出现 </script> 会导致错误。

1
2
3
4
5

<script type="text/javascript*>
	function sayScript (){
		alert("</script>")
	}
</script>

因为按照解析嵌入式代码的规则,当浏览器遇到字符串</script>时,就会认为那是结束的 <script>标签。可以通过把这个字符串分隔为两部分可以解决这个问题。

1
2
3
4
5

<script type="text/javascript*>
	function sayScript (){
		alert("<\/script>")
	}
</script>

无论如何包含代码,只要不存在 defer 和 async 属性,浏览器都会按照<script>元素在页面中 出现的先后顺序对它们依次进行解析。换句话说,在第一个 <script>元素包含的代码解析完成后,第 二个 <script>包含的代码才会被解析,然后才是第三个、第四个…..

2.1.1 标签的位置

如果把 <script> 标签放在 <head> 中，则必须等全部的 JavaScript 代码执行完成以后，才能呈现页面的内容。此时浏览器窗口将是一片空白。所以现代应用程序一般把 JavaScript 引用放在 <body> 元素中页面内容的后面。如下显示:

1
2
3
4
5
6
7
8
9
10

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
</head>
<body>
    <!-- 这里放内容 -->
	<script src="example1.js"></script>
</body>
</html>

2.1.2 延迟脚本 defer

如果 <script> 标签添加了 defer 属性，那么脚本会延迟到整个页面都解析完毕再运行。相当于告诉浏览器立刻下载，但是延迟执行。

1
2

<script defer="defer" src="example1.js">
<script defer="defer" src="example2.js">

在上面的例子中，脚本将延迟到浏览器遇到 </html> 标签后再按照它们出现的顺序依次执行。这两个脚本会先于 DOMContentLoaded 事件触发前执行。
注意 defer 只适用于外部脚本。

2.1.3 异步脚本

HTML5 之中为 <script> 元素定义了 async 属性。和 defer 属性类似，async 同样只适用于外部脚本。但是和 defer 不同的是标记为 async 的脚本不保证先后顺序执行。
就拿下面的例子来说，脚本 2 可能在脚本 1 之前执行。

1
2

<script async src="example1.js">
<script async src="example2.js">

异步脚本一定会在页面的 load 事件之前执行，但是可能在 DOMContentLoaded 事件触发之前或触发之后执行。

2.4 <noscript> 元素

包含在< noscript>元素中的内容只有在下列情况下才会显示出来

• 浏览器不支持脚本;
• 浏览器支持脚本,但脚本被禁用。

1
2
3
4
5
6
7
8
9
10
11

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
</head>
<body>
	<noscript>
		<p>本页面需要浏览器支持(启用) JavaScript</p>
	</noscript>
</body>
</html>

就像上面那个例子。这个页面会在脚本无效的情况下向用户展示一条消息。

2.5 小结

把 JavaScript 插入到 HTML 页面中要使用 <script> 元素。使用这个元素可以把 JavaScript 嵌入到 HTML 页面中,让脚本与标记混合在一起;也可以包含外部的 JavaScript 文件。而我们需要注意的地方有:

• 在包含外部 JavaScript 文件时,必须将 src 属性设置为指向相应文件的 URL。而这个文件既可 以是与包含它的页面位于同一个服务器上的文件,也可以是其他任何域中的文件。
• 所有 <script> 元素都会按照它们在页面中出现的先后顺序依次被解析。在不使用 defer 和 async 属性的情况下,只有在解析完前面 <script>元素中的代码之后,才会开始解析后面 <script> 元素中的代码
• 由于浏览器会先解析完不使用 defer 属性的 <script>元素中的代码,然后再解析后面的内容, 所以一般应该把 <script> 元素放在页面最后,即主要内容后面,</body>标签前面。
• 使用 defer 属性可以让脚本在文档完全呈现之后再执行延迟脚本总是按照指定它们的顺序执行。
• 使用 async 属性可以表示当前脚本不必等待其他脚本,也不必阻塞文档呈现。不能保证异步脚本按照它们在页面中出现的顺序执行。
  另外,使用< noscrip>元素可以指定在不支持脚本的浏览器中显示的替代内容。但在启用了脚本的情况下,浏览器不会显示< noscript>元素中的任何内容。

第 1 章 JavaScript 简介

完整的 Javascript 实现应该由三部分组成 ECMAScript DOM BOM。

1.2.1 ECMAScript

ECMAScript 和浏览器没有依赖关系，浏览器只是 ECMAScript 可能的宿主环境之一。宿主环境不仅提供基本的 ECMAScript 实现，同时也会提供该语言的扩展,以便语言与环境之间对接交互。而这些扩展——如 DOM，则利用 ECMAScript 的核心类型和语法提供更多具体功能。
ECMAScript 则大致规定了这门语言的下列组成部分。

• 语法
• 类型
• 语句
• 关键字
• 保留字
• 操作符
• 对象

1.2.2 文档对象模型 (DOM)

1.2.2 文档对象模型(DOM)
文档对象模型(DOM, Document Object Model )是针对 XML 但经过扩展用于 HTML 的 API。
利用 DOM API，开发人员就可以轻松自如地删除、添加、替换或修改任何节点。

1.2.3 浏览器对象模型(BOM)

BOM 是支持访问和操作浏览器窗口的浏览器对象模型(BOM, Browser Object Model) 的 API,开发人员使用 BOM 可以控制浏览器显示的页面以外的部分。但人们习惯上也把所有针对浏览器的 JavaScript 扩展算作 BOM 的一部分。

1.3 JavaScript 版本

不同的浏览器支持不同的 JavaScript，有一些高级的 API 就无法在古老的浏览器中使用。

1.4 小结

JavaScript 是一种专为与网页交互而设计的脚本语言,由下列三个不同的部分组成

• ECMAScript,由 ECMA-262 定义,提供核心语言功能;
• 文档对象模型(DOM),提供访问和操作网页内容的方法和接口;
• 浏览器对象模型(BOM),提供与浏览器交互的方法和接口。

Leetcode 215 数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，它是数组有序排列后的第 k 个最大元素，而不是第 k 个不同元素。

例如，
给出 [3,2,1,5,6,4] 和 k = 2，返回 5。

注意事项:

你可以假设 k 总是有效的，1 ≤ k ≤ 数组的长度。

思路 1 堆

可以先取k个元素，放到一个数组中，然后把数组转换成最小堆。之后遍历剩下的全部元素，和最小堆的根进行比较。如果比根要大，则替换根，之后把数组重新转换成最小堆。遍历完成后，最小堆堆根即为第 k 大的元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

class Solution {

   public static int findKthLargest(int[] nums, int k) {
    int[] heap = new int[k];
    //首先取k个元素
    System.arraycopy(nums, 0, heap, 0, k);
    //从倒数k个节点开始 调整数组成为最小堆
    for (int i = k / 2 - 1; i >= 0; i--) {
      adjest(heap, i);
    }
    //如果元素小于最小堆 跳过。
    //如果元素大于最小堆 把元素放在堆顶 然后调整堆
    for (int i = k; i < nums.length; i++) {
      if (heap[0] < nums[i]) {
        heap[0] = nums[i];
        adjest(heap, 0);
      }
    }
    //返回堆顶堆元素
    return heap[0];
  }


  /**
   * 调整最小堆
   * @param heap 堆
   * @param i 从哪个 index 开始
   */
  private static void adjest(int[] heap, int i) {
    int temp = heap[i];
    int length = heap.length;
    for (int k = i * 2 + 1; k < length; k = 2 * k + 1) {
      if (k + 1 < length && heap[k + 1] < heap[k]) {
        k++;
      }
      if (temp <= heap[k]) {
        break;
      } else {
        heap[i] = heap[k];
        i = k;
      }
    }
    heap[i] = temp;
  }
}

题目链接

Leetcode-cn
Leetcode

本文基于版本 6.1.1

Elasticsearch 是基于 Lucene 的开源搜索引擎。封装了底层 Lucene 的接口并且提供了 REST API 的接口。开箱即用。

使用 docker 安装

用 docker-compose 部署最为方便。把下面的内容保存到 docker-compose.yaml 中，然后执行 docker-compose up -d 就可以启动容器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

version: '2'
services:
  elasticsearch:
    image: registry.cn-hongkong.aliyuncs.com/yfd-ci/es-docker-image:v2018037
    container_name: elasticsearch
    hostname: elasticsearch
    restart: always
    networks:
      - elk
    environment:
      - cluster.name=docker-cluster
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms1024m -Xmx1024m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata1:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
      - 9300:9300
  kibana:
    image: registry.cn-hongkong.aliyuncs.com/yfd-ci/kibana-docker-image:v20180327-2
    container_name: kibana
    networks:
      - elk
    depends_on:
      - elasticsearch
    environment:
      SERVER_NAME: kibana
      ELASTICSEARCH_URL: http://elasticsearch:9200
    ports:
      - 5601:5601
volumes:
  esdata1:
    driver: local
networks:
  elk:
    driver: bridge

构建镜像的 Dockerfile 分别 如下

1

FROM docker.elastic.co/kibana/kibana-oss:6.1.1

1
2
3
4
5
6

FROM docker.elastic.co/elasticsearch/elasticsearch-oss:6.1.1

RUN cd /usr/share/elasticsearch/ && \
    ./bin/elasticsearch-plugin install  https://github.com/medcl/elasticsearch-analysis-pinyin/releases/download/v6.1.1/elasticsearch-analysis-pinyin-6.1.1.zip && \
    ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.1.1/elasticsearch-analysis-ik-6.1.1.zip \
    && mv /usr/share/elasticsearch/plugins/analysis-ik/ /usr/share/elasticsearch/plugins/ik/

如果运行成功，那么 es 会在本地的9200端口运行。用 curl 请求9200端口，可以获取当前集群的名称，版本等信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

curl localhost:9200
{
  "name" : "OFyyM08",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "tEBFzeLWT5uuCas17Z0Waw",
  "version" : {
    "number" : "6.1.1",
    "build_hash" : "bd92e7f",
    "build_date" : "2017-12-17T20:23:25.338Z",
    "build_snapshot" : false,
    "lucene_version" : "7.1.0",
    "minimum_wire_compatibility_version" : "5.6.0",
    "minimum_index_compatibility_version" : "5.0.0"
  },
  "tagline" : "You Know, for Search"
}

访问 localhost:5601 就可以看到 Kibana 的页面了

注意点

max virtual memory areas vm.maxmapcount [65530] is too low

如果执行失败 出现 max virtual memory areas vm.max*map*count [65530] is too low 的错误。需要执行下面的命令。

1

sudo sysctl -w vm.max_map_count=262144

Java Object 方法简析

Object 类位于java.lang ，我们可以看到源码中写到 Every class has {@code Object} as a superclass. All objects 即 Object 类是所有类的父类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public final native Class<?> getClass();

  public native int hashCode();
  public boolean equals(Object obj);

  protected native Object clone() throws CloneNotSupportedException;

  public String toString();

  public final native void notify();
  public final native void notifyAll();
  public final native void wait(long timeout) throws InterruptedException;
  public final void wait(long timeout, int nanos) throws InterruptedException;
  public final void wait() throws InterruptedException;

  protected void finalize() throws Throwable { }

getClass方法

1
2
3

 * @return The {@code Class} object that represents the runtime
 *         class of this object.
public final native Class<?> getClass();

从源码中可以看到 getClass 是 final 方法，无法被继承。同时是 native 方法。即其他语言例如 C 与 C++ 实现的方法。结果为对象的运行时 Class 对象。

举个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package im.yfd.demo;
class A {
}

class B extends A {
}

class Test{
  public static void main(String[] args) {
    A a = new A();
    A b = new B();
    System.out.println(a.getClass());
    System.out.println(b.getClass());
    a = b;
    System.out.println(a.getClass());
  }
}

返回结果

1
2
3

class im.yfd.demo.A
class im.yfd.demo.B
class im.yfd.demo.B

hashCode 方法与 equals 方法

equals

equals主要用于判断两个对象是否相等。约定 equals 有下列几个性质。

当object object1 object2 均为非空时。

• 自反性：object.equals(object) 永远为 true
• 对称性：object1.equals(object) == object.equals(object1) 永远为 true
• 传递性：object.equals(object1) 为 true且object1.equals(object2) 为 true 时,object.equals(object2) 为 true。
• 一致性：当 object 与 object1 均未修改时候。object.equals(object1) 结果永远保持不变。
• 对于非空对象 object。那个 object.equals(null) 永远返回 false。

Object类中的默认实现为比较两个地址是否相同。等价于 ==

1
2
3

public boolean equals(Object obj) {
        return (this == obj);
}

hashCode

hashCode也是一个native方法。该方法返回对象的哈希码，通常用在哈希表中。例如常用的 HashMap。

对于hashCode，我们 应该 遵循如下规则：

• 在一个应用程序执行期间，任何时间对同一个对象调用 hashCode 方法。都必须返回用一个整数。这个整数在两次对同一个应用程序的执行在不需要保持一致。
• 如果两个对象通过 equals 比较相等，那么 hashCode 方法必须产生同样的结果。

• 如果两个对象通过 equals 比较不相等，那么 hashCode 方法产生的结果 不需要 向灯。但是如果不同对象产生不同的结果。那么有助于提高哈希表的效率

当重写 equals 时候 必须也要重写 hashcode 。否则在 HashMap 中就会出错。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class Person {
  Person(String name) {
    this.name = name;
  }
  private String name;
  @Override
  public boolean equals(Object object) {
    if (this == object) {
      return false;
    }
    if (object == null || object.getClass() != this.getClass()) {
      return false;
    }
    Person p = (Person) object;
    if (p.name == null) {
      return this.name == null;
    }
    return p.name.equals(this.name);
  }
}


class Test {
  public static void main(String[] args) throws CloneNotSupportedException {
    Person a = new Person("name");
    Person b = new Person("name");
    Map<Person, String> map = new HashMap<>();
    map.put(a, "a");
    System.out.println(a.equals(b));
    System.out.println(map.get(a));
    System.out.println(map.get(b));
  }
}

例如上面的代码的返回结果就是

1
2
3

true
a
null

因为 HashMap 会先根据 hashcode 来决定对象在哪个桶中。再在同一个桶中根据 equals 判断 key 是否相同。

clone方法

clone 会返回对象的拷贝。如果直接调用

1
2
3
4
5
6

class Test {
  public static void main(String[] args) throws CloneNotSupportedException {
    Test test = new Test();
    Test testClone = (Test) test.clone();
  }
}

会报错 Exception in thread "main" java.lang.CloneNotSupportedException。

finalize方法

finalize 方法会在对象被回收时候调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Test {

  String name;

  @Override
  public void finalize() {
    System.out.println("GC: " + name);
  }

  public static void main(String[] args) throws CloneNotSupportedException {
    Test test = new Test();
    test.name = "1";
    System.out.println("test 1");
    System.gc();
    test = new Test();
    System.gc();
    System.out.println("test 2");
  }
}

例如上面的代码返回结果

1
2
3

test 1
test 2
GC: 1

起源

博客挂在Github上不要钱，但是总感觉访问有些慢。而且有时候会想跑一些脚本和服务，就一直考虑过买一台服务器。在大学里对Linux用的不多，唯一一次就是在阿里云上买了一个学生主机，玩了几天以后感觉没什么用不会玩，就没有再续费了。前几天逛阿里云的时候，居然看到了一个叫云上浙江的活动。西湖区的公司，没用过阿里云的话可以免费领2000无任何限制的代金券。简直是天上掉了馅饼。因为我刚好有一个杭州的公司，所以就新注册了一个账户。中间虽然有一些小波折，但是最终还是成功领到了钱。千挑万选之下选了ECS香港 2核4G 1M 带宽 100G 硬盘。虽然带宽1M有点小，不过只需要1980就能买这个配置的服务器三年。还是非常划算的。更何况也不需要我自己出钱。

SSH相关设定

为了不用输入密码和安全考虑，肯定是要用SHH key登录，阿里云控制面板的云服务器 ECS-绑定密钥对-创建密钥,输入名字例如test就可以直接生成密钥对,生成完成以后会自动下载一个test.pem的私钥,然后选择之前已经买好的ECS。绑定之后不需要重启就可以利用这个私钥登录了。用阿里云的服务生成和绑定只要是和自己写的项目FastAirport 有关。

安装docker

假如我们服务的IP是aaa.bbb.ccc.ddd SSH的接口是1234

1

ssh root@aaa.bbb.ccc.ddd -i test.pem -p 1234

部署hexo

原先的博客是放在Github pages上的。分成了blog和GeorgeYuen.github.io,虽然这样不要钱，也比较方便,不过既然搬家到了自己的服务器上，那肯定是要折腾一下的。后来用 Daocloud 做了持续部署。

其他放在另外的文章里面说吧，一下子也说不完。

搭建了一个个人的电子书网站

作为一个松鼠党，从高中逛E-INK开始就收集各类电子书，这么多年下来也积攒了一大笔积蓄。下书入流水，看书如抽丝。那么这些书的管理就成了一个问题。最后选了半天还是决定用calibre来管理自己的电子书。

calibre虽然速度有些慢，不过应该是目前为止能找到的最好的电子书管理工具了。和kindle的结合也很好。考虑数据的备份，除了在自己的Mac上存放了书库以外，还利用Resilio Sync把书库存到了群晖上。这样就算是电脑被偷数据也不会丢了。不过calibre的数据库有一个缺点，他在电脑上储存文件的目录结构是/calibre/author/books

而且会把全部的汉字转换成拼音。直接用Mac上的calibre看的话挺方便的，但是远程用手机访问群晖的话看到的都是类似于拼音文件。找书很不方便。所以就想找一下有没有calibre的web版本。

搜了一下果然有人已经早好轮子了calibre-web 一个用Python写的一个Web app。

官方介绍是这样的：Calibre Web is a web app providing a clean interface for browsing, reading and downloading eBooks using an existing Calibre database.

直接利用calibre的数据库，然后支持下载，上传，在线阅读，数据修改，发送到kindle。而且手机端和web端都支持，真是完美符合我的需求。不过要吐槽一点，这个源码居然不打tag，程序更新完全是靠git拉取来更新。真的是大开眼界。

既然调研好了，那么就开始搭建吧。

网站搭建

背景说明

• 群晖216+Ⅱ
• Calibre
• Resilio
• docker

其实上面啥都不需要，只需要一台能运行docker的设备就可以了。内存大约100m 不知道树莓派能不能撑得住。 Python的效率真低呀。

首先先是电脑上安装calibre，然后同步自己的书库到群晖。这一步网上教程太多，就不详细介绍了。

同步完之后，我们的群晖上就有了数据库。例如我的目录是 /Backup/书库 里面有一个数据库文件 metadata.db

数据库有了，就开始安装程序。程序安装很简单，只需要一个python环境就可以了。

1
2
3
4
5
6

# 1.下载源码
git clone https://github.com/janeczku/calibre-web/
# 2.利用pip安装依赖
pip install --target vendor -r requirements.txt
# 3.运行程序
python cps.py

执行命令以后你就把网站搭好了，访问http://localhost:8083就可以看到自己搭建的网站了。

不过妈妈说了，能用docker解决的问题都用docker解决。

Dockerfile如下。

1
2
3
4
5
6
7
8
9
10
11

FROM python:2.7.13
MAINTAINER FandiYuan  <georgeyuan@diamondyuan.com>

RUN git clone https://github.com/janeczku/calibre-web/  && \
    cd calibre-web  && \
    pip install --target vendor -r requirements.txt

EXPOSE 8083

CMD ["python","/calibre-web/cps.py"]

项目的主页有一个镜像了，但是我个人有点没看懂，而且镜像里面是不带项目本身的，在第一次启动镜像的时候会从git上面拉取最新的源码，然后重启。其实挺符合这个开源项目的风格的，利用git进行版本更新。写得其实比我好。有需要的小伙伴可以自己研究安装。

安装说明

说了半天废话，那么图文教大家如何安装吧。

• 首先安装群晖的docker 点开注册表 双击选择阿里云。

  

  搜索calibre,找到我写好的的镜像后双击下载。因为在国内，所以挺快的。感谢阿里爸爸。

  

  ​

安装完双击启动容器

配置一下本地目录和装载目录。本地目录就是你电子说所在的位置。

如果你需要电子书编辑的功能，那么不要勾选只读。英文我只想浏览和下载，所以选择了只读。

设置完成以后点击确认 应用。你的个人服务器就布置好了。
举个例子
例如我群晖的路由访问页面是192.168.3.101:6001，那么192.168.3.101:8083就可以看到自己部署的网站了。