JavaScript数据类型和语法

第一章 类型

1.2 内置类型

使用 typeof 检测对象类型并非很是安全的行为：

// 安全的
typeof undefined    // 'undefined'
typeof true         // 'boolean'
typeof 42           // 'number'
typeof '42'         // 'string'
typeof {}           // 'object'
typeof Symbol()     // 'symbol'
typeof (function(){}) // 'function'
// 不安全的
typeof null         // 'object'
typeof []           // 'object'

函数对象能够拥有属性。函数的length属性为其声明的参数个数。

⚠️

• null 是基本类型中惟一一个“假值”！！！
• function（函数）也是JavaScript 的一个内置类型。然而查阅规范就会知道， 它其实是 object 的一个“子类型”。具体来讲，函数是“可调用对象”，它有一个内部属 性 [[Call]]，该属性使其能够被调用（函数不只是对象，还能够拥有属性）

1.3 值和类型

JavaScript 中的变量是没有类型的，只有值才有。变量能够随时持有任何类型的值

1.3.1 undefined和undeclared

声明但尚未赋值的变量是undefined。 尚未在做用域声明过的变量是undeclared（【严格模式】下访问会抛出ReferenceError）。

对于 undeclared（或者 not defined）变量，typeof 照样返回 "undefined"，而且不会报错，返回'undefined'。

或者当其为全局变量的时候，用window的点操做符去访问，也不会报错。

第二章 值

2.1 数组

在稀疏数组中，中间未赋值的内容会初始化为undefined

var a = [];
a[0] = 1;
a[2] = 3;

a[1]; // undefined
a.length; // 3

⚠️也能够用键访问（输入不能转换为数字的字符串）去设置数组的属性，但他们不会归入数组的值和length，而是做为独立的属性存在。

var arr = [];
  arr[0] = 1;
  arr["2"] = 2;
  arr["obb"] = 3;
  arr.length; // 3
  arr[2]; // 2, “2”字符串键值 被强制转换为十进制数字
  arr.obb; arr["obb"]; // 3

类数组（Array Like）（一组经过数字索引的值）

如：DOM查询返回的DOM元素列表；arguments（es6废除）

• 对象表示其类型相似于数组，可是原型链上没有Array对象，天然也没法直接使用Array的原型方法。

• 转换类数组使用ES5的Array.prototype.slice.call(arrayLikeObj)，slice() 返回参数列表（上例中是一个类数组）的一个数组复本。或者ES6的Array.from(arrayLikeObj)。

  function foo() {
  var arr = Array.prototype.slice.call( arguments );
  或 var arr = Array.from( arguments );
  arr.push( "bam" );
  console.log( arr );
  }
  foo( "bar", "baz" ); // ["bar","baz","bam"]

2.2 字符串

和数组类似，都有 length 属性以及 indexOf(..)，和 concat(..) 方法

能够经过“借用”数组的非变动方法来处理字符串：字符串没有join、map方法

a.join;         // undefined 
a.map;          // undefined 
var c = Array.prototype.join.call( a, "-" ); 
var d = Array.prototype.map.call( a, function(v){     
    return v.toUpperCase() + "."; 
} ).join( "" );

JS中字符串的单个字符不可变，不能用键访问去改变字符串的某个字符。 字符串也能够借用数组的一些原型方法来进行处理。一个经常使用场景是字符串的倒置：

var c = a
        // 先转为Array
        .split('')
        // 再倒置Array
        .reverse()
        // 最后转回字符串
        .join('');

2.3 数字

直接对数字字面量调用原型方法，有时候须要两个点（.），这是由于第一个点会被理解为小数点。 Number.prototype上有这些方法：

• toExponential()，转为指数格式，特别大或小的数字默认用指数格式显示
• toFixed()，指定小数位数
• toPrecision()，指定有效位数的显示位数
  // 无效语法：
  42.toFixed( 3 ); // SyntaxError ，由于 . 被视为常量 42. 的一部分
  // 下面的语法都有效：
  (42).toFixed( 3 ); // "42.000"
  0.42.toFixed( 3 ); // "0.420"
  42..toFixed( 3 ); // "42.000"
  其余进制的问题：
• 0xf3，16进制
• 0b11110011，2进制
• 0o363，8进制

2.3.2 较小的数值

0.1 + 0.2 === 0.3; // false，二进制浮点数中的 0.1 和 0.2 并非十分精确，相加的结果0.30000000000000004

解决方法：偏差范围值，即机器精度（machine epsilon）。 使用机器精度，能够判断两个浮点值的运算结果是否等于另外一个数字。Math.abs(n1 - n2) < Number.EPSILON

2.3.3 整数安全范围

安全的最大整数是2^53 - 1，即9007199254740991，ES6中为Number.MAX_SAFE_INTEGER。同理，最小整数为其负数-(2^53 - 1)，ES6中为Number.MIN_SAFE_INTEGER。

2.3.4 整数检测

• Number.isInteger，检测是否为整数
• Number.isSafeInteger，检测是否为安全的整数

2.3.5 32位有符号整数

数位运算符只适用于32位的整数，其余数位将会被忽略。

2.4 特殊数值

2.4.1 不是值的值

空值：

• null，指空值，曾经赋值，如今没有值empty value
• undefined，指没有值，从未被赋值，missing value

null 是一个特殊关键字，不是标识符，咱们不能将其看成变量来使用和赋值。然而 undefined 倒是一个标识符，能够被看成变量来使用和赋值。

2.4.2 undefined

经过void运算符能够返回undefined。

var a = 42; 
console.log( void a, a ); // undefined 4，void 并不改变表达式的结果， 只是让表达式不返回值：

2.4.3 特殊的数字

• NaN是一个警惕值，表示数学运算没有成功，失败后返回的结果。
  NaN 是一个特殊值，它和自身不相等，是惟一一个非自反 NaN != NaN 为 true
  ES6 判断是否为NaN：Number.isNaN(a)

• Infinity表示无穷数，数学运算结果溢出
  var a = 1 / 0; // Infinity
  var b = -1 / 0; // -Infinity

  规范规定，若是数学运算（如加法）的结果超出处理范围，则由 IEEE 754 规范中的“就 近取整”（round-to-nearest）模式来决定最后的结果。
  计算结果一旦溢出为无穷数（infinity）就没法再获得有穷数

• -0表示第一位正负位为负，保留了该信息，后续处理的时候会携带它。
  对负零进行字符串化会返回 "0"; 若是反过来将其从字符串转换为数字，获得的结果是准确的
  -0 == 0; // true
  -0 === 0; // true

  ⚠️为何须要负0：保留0的符号位，来获取方向信息。

2.4.4 特殊等式

ES6：Object.is（..）:来判断两个值是否绝对相等(用来处理特殊比较，不然使用==或===解)

• Object.is(NaN, NaN) === true
• Object.is(+0, -0) === false

2.5 值和引用

简单值（即基本类型值），经过值复制的方式来赋值/传递。 复合值（对象、数组和函数），老是经过引用复制的方式来赋值/传递。 减小引用复制反作用的方法是，传递时候采用复本建立的方式，好比a.slice()。

slice(..) 不带参数会返回当前数组的一个浅复本

⚠️标量基本类型值是不可更改的（字符串和布尔也是如此）。

function foo(x) {    
    x = x + 1;    
    x; // 3  
} 
var a = 2; 
var b = new Number( a ); // Object(a)也同样 
foo( b ); 
console.log( b ); // 是2，不是 3

.......待补充！！

第四章 强制类型转换

4.1 值类型转换

显式值类型转换称为类型转换，发生在静态语言的编译阶段。隐式的状况称为强制类型转换，发生在动态语言的运行时。 JS中只存在强制类型转换（运行时中转换），只会返回标量基本类型值，好比字符串、数字和布尔值，不会返回对象或函数。

4.2 抽象值操做

4.2.1 toString

• null -> 'null'
• undefined -> 'undefined'
• true/false -> 'true'/'false'
• 极大数，极小数 -> 指数形式表达
• Array -> arr.join(',')
• Object -> obj.toPrimitive

对于JSON安全：包含undefined、function、symbol和循环引用的对象不符合JSON的结构标准，它们在stringify操做中会被忽略，数组中转为null。 当一个对象JSON不安全时，能够定义其toJSON()方法来返回一个JSON安全的对象，它在JSON.stringify的时候会隐式调用。 JSON.stringify(target, replacer?, space?)的replacer能够是一个字符串数组或函数，用于指定哪些属性须要归入处理。space指定缩进格式。

4.2.2 ToNumber

• true/false -> 1/0
• undefined -> NaN
• null -> 0
• 对象：调用toPrimitive，首先检查该值有没有valueOf()方法，若有则执行，如没有就使用toString()方法，对最终结果进行强制类型转换。若是二者均不返回基本类型值，抛出TypeError错误。

4.2.3 toBoolean

JS中的假值一般为基本类型：

• undefined
• null
• false
• +0, -0, NaN
• ''（空字符串）

4.3 显式强制类型转换

4.3.1 字符串和数字之间的显式转换

Number转String：

• String(a)
• a.toString()

String转Number：

• Number(b)
• Number.parseInt(b) / Number.parseFloat(b)
• +b：注意不要两个+号连用变成自增，必要时中间加空格。

其余应用：

• 日期转数字（毫秒级时间戳）：var d = new Date(); +d;，可是更建议使用其getTime()方法。
• ~：JS中的取反操做相似于转换为数字，而后取-(x+1)，经常使用于将-1转为0
• |：后面跟一个toInt32后为0的值（0，NaN等），能够起到ToNumber的做用。

4.3.2 显式解析数字字符串

Number.parseInt()和Number.parseFloat()方法容许字符串中含有非数字字符，遇到非数字字符就中止解析，返回结果。 对于非字符串，会隐式调用其toString()方法。

// 获得Infinity，解析为'Infinity',第一个字符I的ASCII码为18，因此返回结果是18
// 十进制下返回NaN
Number.parseInt(Infinity, 19);

// toString()解析成了8e-7，返回8
Number.parseInt(0.0000008)

4.3.3 显式转换为布尔值

Boolean()能够显式转换为布尔值，另外一种方法是用!和!!。 if(...) {}的判断语句中，若是没有特别声明布尔值，就会调用toBoolean()方法。

4.4 隐式强制类型转换

4.4.2 字符串和数字之间的隐式强制类型转换

+运算符能用于数字加法，也能用于字符串拼接。它一旦遇到两边有一者不是Number的状况，就会对双方调用toPrimitive()或toString()方法，而后进行字符串拼接。 -运算符仅用于数字减法，一旦遇到两边有一者表示Number的状况，就会对双方调用ToNumber()行为，而后计算减法。

4.4.5 ||和&&

它们的返回值是两个操做数中的一个。

||：

• 若是前者判断为true，就返回前者，不然返回后者。
• 相似于a? a:b。
• 经常使用做空值合并运算符。

&&：

• 若是前者判断为true，就返回后者，不然返回前者。
• 相似于a? b:a。
• 经常使用做守护运算符，前面的表达式为后面把关。好比if(a){ foo(); }能够改为a && foo();。

4.4.6 Symbol的强制类型转换

Symbol只支持显式强制类型转换。

var s1 = new Symbol('cool');
String(s1); // 'Symbol(cool)'

s1+ ''; // TypeError

4.5 宽松相等和严格相等

4.5.2 抽象相等

==容许再相等比较中进行强制类型转换，===不容许。 特别注意，如下状况用Object.is()修复：

1. NaN不等于NaN。
2. +0等于-0

ES5规范11.9.3.4-5定义：

1. 若是Type(x)是数字，Type(y)是字符串，则返回 x == ToNumber(y) 的结果。
2. 若是Type(x)是字符串，Type(y)是数字，则返回 ToNumber(x) == y 的结果。

ES5规范11.9.3.6-7定义：

1. 若是Type(x)是布尔类型，则返回 ToNumber(x) == y 的结果。
2. 若是Type(y)是布尔类型，则返回 x == ToNumber(y) 的结果。

可使用a == null来替代a === undefined || a === null。 ES5规范11.9.3.2-3定义：

1. 若是x为null，y为undefined，返回true。
2. 若是x为undefined，y为null，返回true。

ES5规范11.9.3.8-9定义：

1. 若是Type(x)是字符串或数字，Type(y)是对象，则返回 x == ToPrimitive(y)的结果。
2. 若是Type(x)是对象，Type(y)是字符串或数字，则返回 ToPrimitive(x) == y的结果。

特殊状况说明：

'0' == false; // true, Number('0') == Number(false)
false == 0;   // true, Number(false) == 0
false == '';  // true, Number(false) == Number('')
false == [];  // true, Number(false) == ToPrimitive([])
'' == 0;      // true, Number('') == 0
'' == [];     // true, Number('') == ToPrimitive([])
0 == [];      // true, 0 == ToPrimitive([])

4.6 抽象关系比较

比较双方首先调用ToPrimitive，若是出现非字符串，就根据ToNumber规则将双方转换为数字来比较。若是比较双方都是字符串，就按字母顺序来逐位比较。 须要注意的是，a <= b在JS中被处理成!(b < a)。

第五章 语法

5.1 语句和表达式

JS中，表达式能够返回一个结果值。

5.1.1 语句的结果值

语句都有一个结果值（undefined也算）。 对于代码块，其结果值就如同一个隐式的返回，即返回最后一个语句的结果值。

5.1.2 表达式的反作用

语句系列逗号运算符：在()中写入多个语句，用逗号','分隔，返回最后一个语句的结果值。 好比b = (a++, a);能够返回a++以后的a。

5.2 运算符优先级

&&高于||。