标签：5.0 lis html 快捷 依赖 des 显示 默认值 整数
# 《JavaScript权威指南》笔记——第1部分
说明：
印刷版：2012年4月第1版 2016年9月第17次印刷。
本书的风格和《Effective Java》很类似，推荐一下。
该笔记逆序记录的。
-----------------------
------<end>------
| node的helloworld程序：
```js
//! program.js
// 通过在命令行输入`node program.js`来运行，然后在浏览器中打开网址`127.0.0.1:8080`来访问
var http = require(‘http‘);
var server = new http.Server();
server.listen(8080);
server.on(‘request‘, function(request, response){
console.log(request.url); //打印请求网址
response.write("Hello World!");
response.end();
});
```
| Rhino，一种用Java编写的JavaScript解释器。在[mozilla/rhino: Rhino is an open-source implementation of JavaScript written entirely in Java](https://github.com/mozilla/rhino)中具体研究。
| JavaScript运行环境（除了Web浏览器之外的两种运行环境）
- [下载 Rhino - Mozilla 产品与私有技术 | MDN](https://developer.mozilla.org/zh-CN/docs/Mozilla/Projects/Rhino/Download_Rhino)
- node: https://nodejs.org
## 第十二章：服务器端JavaScript
| 解构赋值右侧的数组所包含的元素不必和左侧的变量一一对应，左侧多余的变量的赋值为`undefined`，
右侧多于的值则会被忽略。左侧的变量列表可以包含连续的逗号用以跳过右侧对应的值。--p275
```js
let [x, y] = [1]; // x = 1, y = undefined
```
| 通过var声明的变量在函数内都是可用的，
而通过let声明的变量则只属于就近的花括号括起来的语句块。--p272
## 第十一章：JavaScript的子集和扩展
| RegExp方法
- `exec()`：exec()方法对一个指定的字符串执行一个正则表达式。lastIndex属性会在设置了`g`修饰符后起作用。 --p264 --p265
- `test(字符串)`：对字符串进行检测，如果包含有一个匹配，则返回true；
| String支持4种正则表达式用法。--p262
- String.search(/正则/); 如果参数不是正则，则通过RegExp构造正则对象；
- String.replace(/正则/, "待替换的文本"); 如果第一个参数是字符串，则直接搜索该字符串而不是构造成正则表达式。第二个参数可以是函数，该函数能够动态地计算替换字符串；
- String.match(/正则/); 最常用的正则方法；
- String.split(/正则/); 参数可以是字符串也可以是正则；
| 正则表达式修饰符：出现在第二条斜线之外的字符。 --p261
```
i 不区分大小写
g 全局匹配
m 多行模式的匹配
```
| 锚字符：--p261
```
^ 匹配字符串开头
$ 匹配字符串结尾
\b 匹配单词的边界
\B 匹配非单词边界
(?=p) 零宽正向先行断言，要求接下来字符都与p匹配
(?!p) 零宽负向先行断言，要求接下来字符不与p匹配
```
| 非贪婪匹配（尽可能少地匹配）：在匹配的字符后跟随一个问号。--p257
| 重复：--p257
```
{n, m} （至少n次，不能超过m次）
{n, } （匹配前一项n次到多次）
{n} 匹配前一项n次
? 0次或多次
+ 1次或多次
* 0次或多次
```
| 字符类：将直接量字符单独放进方括号`[]`内就组成了字符类。 --p256
| 在正则表达式中，具有特殊含义的标点符号：--p255
```js
^ $ . * + ? = ! : | \ / ( ) [ ] { }
```
| ECMAScript 5 规范做了同ECMAScript 3相反的规定，
同一段代码所表示的正则表达式直接量的每次运算都返回新的对象。--p254
| 创建正则表达式：
- 使用`RegExp()`构造函数来创建；
- 使用正则表达式直接量语法（包含在一对斜杠之间的字符）；
## 第十章：正则表达式
| 模块，导出API：
1. 返回构造函数； --p251
2. 通过new来直接调用模块函数； --p252
3. 框架提供的导出模块API方法； --p252
| 模块化，实现代码的重用。--p248
| 锁定原型对象的一个使用场合：阻止枚举类型`enumeration()`属性的变化（修改和删除）。
在`Object.freeze()`方法调用之前所做的设置都是生效可用的。 --p244
| `Object.freeze()`和`Object.seal`的功能一样，都会把对象的属性设置为只读和不可配置的。--p244
注意：没有反操作；
> Freezing an object is the ultimate form of lock-down. Once an object has been frozen it cannot be unfrozen – nor can it be tampered in any manner. This is the best way to make sure that your objects will stay exactly as you left them, indefinitely
- [Opposite of Object.freeze or Object.seal in JavaScript](http://stackoverflow.com/questions/19293321/opposite-of-object-freeze-or-object-seal-in-javascript)
| `Object.defineProperty()`和`Object.defineProperties()`可以用来创建新特性，也可以用来修改已有属性的特性。 --p242
| ECMAScript 5给对象的扩展性增加了限制（方法支持：setter、getter、可枚举性、可写性、可配置性），其新特性使类更加健壮。 --p239
```js
Object.defineProperty();
Object.defineProperties();
Object.seal();
Object.preventExtensions();
Object.create();
Object.freeze();
Object.getOwnPropertyDescriptor();
```
| `var str = JSON.stringify(o);`将对象转化为json字符串，
`JSON.parse(str)`，将字符串转化为对象，但是该对象不具有和o对象相同的继承结构。 --p222
| 鸭式辨型不能应用于内置类，比如不能通过`quacks(o, Array)`来检测o是否实现了Array中的所有同名方法。
原因是内置类的方法都是不可枚举的（for/in操作无法遍历）。--p217
| 在JavaScript中，类的实现是基于其原型继承机制的。--p201
## 第九章：类和模块
| 需要给`f()`传入一个参数，所以使用`f()`的`call()`方法；
需要给`g()`传入多个参数，所以使用`g()`的`apply()`方法； --p197 --p189
```js
function f(a){console.log("a=" + a)}
function g(){console.log("args:"+arguments.length)}
f.call(this, 3); // => a=3
g.apply(this, [3, 1, 4, 1, 5, 9, 2, 6]); // => args:8
```
| 可以通过`new Function()`构造方法的方式来定义函数
（另外两种定义方式：1.函数定义语句；2. 函数直接量表达式）。
`Function`构造函数创建的是一个匿名函数，不需要指定函数名。--p192
| 书写闭包的时候还需要注意一件事，this是JavaScript的关键字，而不是变量。
| 函数的执行依赖于变量作用域，这个作用域是在函数定义时决定的，而不是函数调用时。 --p182
| 直接调用匿名函数
```js
(function(){console.log("我是匿名函数，我被调用")}());
(function(x){console.log("我是匿名函数，我被调用=>" + x)})(3);
```
注意：`function`之前的左圆括号是必需的，如果不写这个左圆括号，JavaScript解释器会视图将关键字function解析为函数定义表达式。
| 调用函数中的函数：
```js
// 函数中的函数
function a(){
console.log("我是a");
return b;
}
function b(){
console.log("我是b");
return c;
}
function c(){
console.log("我是c");
}
a()()(); // => 我是a /n 我是b /n 我是c
```
| `arguments[]`对象适用场合：函数包含固定个数的命名和必须的参数，以及随后个数不定的可选实参。--p175
| JavaScript针对实参的默认检查行为：省略的实参都是`undefined`，多出的实参会自动省略。--p174
| 标识符`arguments`是指向实参对象的引用，实参对象是一个类数组对象。可以通过下标来访问传入的实参值。
例如：`argeuments[0]`表示第一个参数，`arguments.length()`表示实参数组的长度。--p174
| this是一个关键字，不是变量，也不是属性名。JavaScript的语法不允许给this赋值。--p171
| 任何函数只要作为方法调用实际上都会传入一个隐式的实参——这个实参是个对象，方法调用的母体就是这个对象。--p170
| 函数定义表达式/函数声明语句
- 函数声明语句：ECMAScript规范只是允许它们作为顶级语句。可以出现在全局代码里，或者内嵌在其他函数中，不能出现在循环，条件判断，或者try/catch/finally中。
- 函数定义表达式：可以出现在JavaScript代码的任何地方。 --p168
# 第八章：函数
| 对于字符串`var a = "test"`虽然可以通过`a[0]`的方式获取字符（很类似于数组的获取方式），
但是字符串不是数组：`Array.isArray(a) === false`。
| `Array.indexOf()`和`Array.lastIndexOf()`：
- 参数1：需要搜索的值。
- 参数2：指定数组中的一个索引，从那里开始搜索。（可选的，如果省略则从头开始搜索；如果是负数，则表示相对末尾的偏移量） --p160
| `Array.reduce()`需要两个参数： --p158
- 参数1： 执行化简操作的函数。
- 参数2： 传递给函数的初始值（可选的）。
```js
var a = [1, "a", "b", "c", 3, 3, 88];
a.reduce(function(x, y){return x+y;}, 1); // => "2abc3388"
```
| forEach无法在所有元素都传递给调用的函数之前终止遍历。可以通过抛异常的方式来中断。--p156
| [JavaScript中函数和方法的区别](http://www.cnblogs.com/moltboy/archive/2013/04/24/3040450.html)
函数：是可执行的JavaScript代码块，由JavaScript程序定义或JavaScript实现预定义。
方法：是通过对象调用的JavaScript函数。
（一个方法无非是个保存在一个对象的属性里的JavaScript函数。--p169）
（如果函数挂载在一个对象上，作为对象的一个属性，就称它为对象的一个方法。
当通过这个对象来调用函数时，该对象就是此次调用的上下文，也就是该函数的this值--p165）
方法是用来对this对象进行操作的，this对象是方法的一个重要属性，当this对象出现在方法主体内部，
this值就指向调用该方法的对象。而函数通常是独立的，并不需要经常使用this对象。
| `Array.push(a)`和`Array.pop()`，均修改原数组本身。 --p154
|`Array.splice()`，对元素本身做修改。
- 参数1：指定插入或删除的起始位置；
- 参数2：指定了应该从数组中删除的元素个数。（为0时不删除任何元素）
- 后续参数：要插入的元素；
```js
var a = [1, 2, 3];
a.splice(1, 1, ‘a‘, ‘b‘, ‘c‘) // => [2]
a // => [1, "a", "b", "c", 3]
```
| `Array.concat()`不会递归扁平化数组的数组。`concat()`也不会修改调用的数组。
| `Array.reverse()`操作的是原数组，对原数组进行重新排列。
例如：
```js
var a = [1, 2, 3];
a.reverse().join("-"); // => 3-2-1
a // =>[3, 2, 1]
```
| `Array.join()`，用指定的字符来拼接数组中的元素。
例如：`[1, 2, 3].join(-)`的结果是`1-2-3`；
有另外一种调用方式（基于数组原型的方式）：
```js
Array.prototype.join.call([3, 1, 4, 1, 5, 9, 2, 6], ‘-‘); // => "3-1-4-1-5-9-2-6"
```
| 在数组尾部压入一个元素，与给数组a[a.length]赋值效果是一样的。
```js
var a = [];
a.push("one"); // ["one"]
a[a.length] = "two"; // ["one", "two"]
```
| 在数组直接量中省略值时不会创建稀疏数组。
省略的元素在数组中是存在的，其值为`undefined`。 --p147
```js
var a1 = [,,,]; // 数组是[undefined, undefined, undefined]
var a2 = new Array(3); // 该数组根本没有元素
0 in a1 // => true: a1在索引0处有一个元素——undefined。？？？，在Chrome56.0中，其值为false；而如果a1=[undefined, undefined, undefined]，该结果是true
0 in a2 // => false: a2在索引0处没有元素
```
| 数组最大能容纳`2^32-1=4 294 967 295`个元素。
| 非标准的方法：以两条下划线作前缀，两条下划线做后缀的方法。
例如：`__lookupGetter__()、__lookupSetter__()`。--p138
# 第七章
| 基于兼容性考虑，不推荐使用`__proto__`，IE和Opera尚未实现它。 --p139
| `Object.defineProperty(参数1：对象, 参数2：要创建或修改的属性名称, 参数3：属性描述符对象)`
方法可以用来设置属性的特性、新建属性的某种特性。
属性描述符：`{value: 1, writable: true, enumerable: false, configurable: true}`，
不必包含所有4个特性，例如:`{value:2}`；
对于新创建的属性来说，默认的特性值是`false`或`undefined`。 --p136
| 对象直接量:var a = {x:1, y:2}
对象直接量是一个表达式，每次运算都创建并初始化一个新对象，
如果在一个重复调用的函数中的循环体内使用了对象直接量，它将会创建很多新对象；--p120
http://www.cnblogs.com/jiuyi/p/4226903.html
| 严格模式（"use strict"是ECMAScript 5引入的一条指令）
```js
// c = "dd"; // 在`use strict`之前没有任何表达式
"use strict" // 被当作指令
d = "d1"
```
```js
c = "dd";
"use strict" // 被当作普通的表达式语句对待。
d = "d1";
```
| 严格模式存在的意义：修正了语言的重要缺陷，并提供健壮的查错功能和增强的安全机制。 --p115
| with的用法
```js
// ==> with测试
var o = {x:1};
console.log(o); // => {x:1}
with(o) x = 12;
console.log(o); // => {x: 12}: with语句可以用来修改对象中属性的值。
var o = {};
with(o) x = 13;
console.log(o); // => {}:with提供了一种读取o的属性的快捷方式，但是不能创建o的属性。
console.log(x); // => 13:如果o没有属性x, 则相当于这段代码相当于`x=13`
```
| 在严格模式下是禁止使用`with`语句的，并且在非严格模式下也是不推荐的，
尽量避免使用`with`语句。(难优化，运行的慢) --p113
| 通过`prompt("msg")`的方式，从浏览器客户端获取用户输入。
通过`alert("msg")`的方式弹出消息。
| 如果抛出异常的函数没有处理它的`try/catch/finally`语句，异常将向上传播到调用该函数的代码。
如果没有找到任何异常处理程序，JavaScript将把异常当作程序错误来处理。--p110
| return语句只能在函数体内出现，否则会报语法错误。 --p109
| 函数，可以通过两种方式来定义： --p62, p57，p95
```js
// 方式1--函数定义表达式：
var square = function(x){ return x * x;}
// 方式2--函数声明语句：
function square(x){
return x * x;
}
```
两者的区别是：
- 使用var，只有变量声明提前了--变量的初始化代码仍然在原来的位置。
- 使用函数声明语句的话，函数名称和函数体均提前。
举个例子：
```js
// ==>函数声明提前测试；
// 在函数初始化之前调用
console.log("代码定义之前调用=============");
// f1(); // =>TypeError: f1 is not a function
f2(); // => f2
// 函数定义的地方
var f1 = function(){console.log("f1")}
function f2(){console.log("f2")}
console.log("代码定义之后调用=============");
f1(); // => f1
f2(); // => f2
```
整体被显示地“提前”到了脚本或函数的顶部。
| 函数体内局部变量会声明提前，并且会覆盖同名的全局变量 --p58
> 将函数内的变量声明“提前”至函数体顶部，同时变量初始化留在原来的位置。
| JavaScript中，if,else的匹配规则是，else总是和就近的if语句匹配（最好用花括号来分组，以便阅读和理解）。 --p97
JavaScript中没有块级作用域。 --p93
delete:一些内置核心和客户端属性是不能删除的，用户通过var语句声明的变量不能删除。--p89
三元运算符的使用场合： --87
如果有定义就使用定义过的，如果没有定义则使用默认值。
```js
var greeting = "hello" + (username ? username : "there");
```
为什么会有下面这种用法？p.x的执行依赖于p，如果不使用这种“&&”的方式，那么会抛出类型错误异常。--p80
```js
var p = null;
p && p.x // 通过短路的方式，来决定后面的表达式是否继续运算
```
假值是`false, null, undefined, 0, -0, NaN和""`，所有其他的值包括对象都是真值。 --p79
所有小写的ASCII字母都“大于”大写的ASCII字母。 -- p77
数组也是对象
```js
typeof [] === "object"; // =>true
```
只有在`x`等于`NaN`时，表达式`x!==x`成立。 --p75
true在比较的过程中会转换为1.
```js
1 == true // => true
2 == true // => false
```
NaN和其他任何值都是不相等的（包括它本身）。 --p75
位操作移动的位数的范围是：0-31.
为什么？因为位运算符要求它的操作数是整数，这些整数表示为32位整型而不是64位浮点型； -p73
在JavaScript中，所有的数字都是浮点型的，除法运算的结果也是浮点型的。--p70
如果操作数是NaN，那么操作结果也是NaN。--p70
所有无法转换成数字的操作数在进行算术运算时，都转换成NaN。 --p70
结合性：一元运算符，赋值和三元条件运算符都具有从右至左的结合性。 --p69
注意：当属性名是通过运算得出的值而不是固定的值的时候，使用方括号写法。 --p64
点式的写法更简单（相比较于方括号），但是访问的属性名称必须是合法的标识符，并且需要知道属性的名字。 --p63
对于属性名称中包含空格的情况，可以通过`[]`来表示，例如：
```js
var p = {"ni hao" : "hello"};
p["ni hao"] // => hello
```
对象直接量中的属性名称可以是字符串而不是标识符。--p62
```js
var c = {"a b":1, "d":2}
c["a b"] // => 1: 这种情况要通过方括号的方式引用
c["d"] // => 2
c.d // => 2
```
数组直接量中的列表逗号之间的元素可以省略，省略的空位会填充 `undefined`。
数组直接量的元素 **列表结尾** 可以留下单个逗号，这时并不创建一个新的`undefined`对象。 --p62
在js语句开头添加一行字符串`use strict;`可以开启严格模式；
同名的变量名，局部的会覆盖全局的。注意声明提前的问题。
始终使用`var`来声明变量（不要隐藏var）。 --p56
`new Boolean(false)`是一个对象，而不是原始值。所以以下代码会打印出`1`:
```js
var c = new Boolean(false);
if(c){ // => 1
console.log(1);
} else {
console.log(2);
}
if(c.toString()){ // => 1:注意："false" != false
console.log(1);
} else {
console.log(2);
}
```
依照术语的叫法，对象值都是引用，对象的比较均是引用的比较：
当且仅当他们引用同一个基对象时，他们才相等。--p48
```js
var a = {a:1, b:2};
var b = {a:1, b:2};
a === b // => false
b = a;
a === b // => true
```
JavaScript中的字符串相等`===`：
当且仅当他们的长度相等，且每个索引的字符都相等时. --p47
JavaScript对象是一种复合值：它是属性或已命名值的集合。 --p46
当属性值是一个函数的时候，称其为方法。通过`o.m()`的这样的方式进行调用。
任意JavaScript的值都可以转换成布尔值。所有其他值，包括所有对象（数组）都会转换成true. --p43
```js
undefined
null
0
-0
NaN
"" // 空字符串（注意：如果中间有空格的话就不是哦）
```
在两条斜线之间的文本构成了一个正则表达式直接量。
直接量（正则直接量、对象直接量、数字、字符串……）如果不被赋值给变量，那么就只能使用一次。
舍入误差的解决方案：使用整数“分”而不要使用小数“元”进行基于货币单位的运算。 --p38
(以更精确的单位进行运算)
二进制浮点数表示法并不能精确表示类似0.1这样的简单数字。 --p37
除了作为除数外`0`和`-0`是一模一样的。
```js
var zero = 0;
var negz = -0;
zero === negz; // => true
1/zero === 1/negz; // => false: 正无穷大和负无穷大不一样
```
-- p37
当且仅当x为`NaN`时，表达式`x != x`为`true`；--p37
无穷大值在进行加减乘除运算后，结果还是无穷大。
```js
Infinity / 0 = Infinity;
Infinity / -0 = -Infinity;
Infinity / -1 = -Infinity;
```
JavaScript中的算术运算在溢出、下溢、被零整除时不会报错：--p36
```js
3 / 0 = Infinity;
-3 / 0 = -Infinity;
```
八进制（不推荐使用八进制，在ECMAScript 6的严格模式下 ，8进制是明令禁止的）：
0377是八进制；
0378是十进制；（可以通过console来验证） --p35
浮点数范围（采用IEEE 754标准）：
最大值（无限远离0）：+- 1.7976931348623157 x 10^308
最小值（无限接近0）：+- 5.0 x 10^-324
（注意：这里的最大值最小值是相对于0而言的。）
--p34
数字直接量：一个数字直接出现在JavaScript程序中。
在任何数字直接量前添加`-`符号，可以得到它们的负值。但负号是一元求反运算符，并不是数字直接量语法的组成部分。p34
JavaScript中的所有数字均用浮点数值表示。
不在任何函数内声明的变量称作全局变量，它在JavaScript程序中的任何地方都是可见的。
在函数内声明的变量具有函数作用域，并且只在函数内可见。 --p34
### 可选的分号
在JavaScript中，分割语句的分号是可选的。
JavaScript并不是在所有换行处都填补分号：只有在缺少了分号就无法正确解析代码的情况下，JavaScript才会填补分号；
例外1：注意：在`return`, `break`, `continue`和随后的表达式之间不能换行（会自动添加分号）。
例外2：在涉及`++`, `--`的时候，既可以作为前缀也可以作为后缀。如果作为后缀表达式，则应当放在同一行。
### 数据类型
在编程语言中，能够表示并操作的值的类型称作数据类型。
在技术上讲，只有JavaScript对象才能拥有方法。然而数字，字符串和布尔值也可以拥有自己的方法。
在JavaScript中只有`null`和`undefined`是无法拥有方法的；
--------
------<start>------
### 书中的错误
| p75
结果应该是相等，这条和第四条关于NaN的描述存在矛盾。
> 如果两个值都是null或者都是undefined，则它们不相等。 => 则他们相等
| p77
> 则需要首先将字符串转全部换为小写字母 => 则需要首先将字符串全部转换为小写字母
| p113
> width、debugger和use strict => with、debugger和use strict
| p159
> 为了简单起见，到目前位置 => 到目前为止
| p168
> try/cache/finally => try/catch/finally
| p177
> 数组a中必须为数字、null和undefined的元素都将忽略。 => `、`修改为`,`
| p203
> prototye属性 => prototype属性
| p204
> var r = range(1, 3); => var r = new Range(1, 3);
| p205
> 冠以关键字mew => 冠以关键字new
| p213
> 但我们常常会忽觉原型上的constructor属性。 => 但我们常常会忽略原型上的constructor属性。
| p260
> /\s\Javas/ => /\sJava\s/
| p260
> 带有“(?!”的断言是负向先行断言，用以指定接下来的字符都不必匹配。
=> 带有“(?!”的断言是负向先行断言，用以指定接下来的字符都不匹配。
| p263
> 接下来对exec()方法的讨论中会提到：
=> 接下来对exec()方法的讨论中会提到。（最后的标点符号应该是句号）
JavaScript权威指南笔记——第1部分
标签：5.0 lis html 快捷 依赖 des 显示 默认值 整数
原文地址：http://www.cnblogs.com/lyloou/p/6513967.html
