《JavaScript 教程》学习补遗（二）

数据类型

与值相关的全局方法

parseInt 将字符串转为数值

（1）行首有空格的时候，会自动清除；
（2）当第一个字符不能转换成数据值，返回 NaN，后面跟着数值的正（+）、负（-）号除外；

parseInt('abc') // NaN
parseInt('.3') // NaN
parseInt('') // NaN
parseInt('+') // NaN
parseInt('+1') // 1

（3）0x 与 0X开头，当成16进制，0 开头，当成10进制；
（4）注意因科学记数法，导致转换异常的情况；

parseInt(1000000000000000000000.5) // 1
// 等同于
parseInt('1e+21') // 1

parseInt(0.0000008) // 8
// 等同于
parseInt('8e-7') // 8

（5）parseInt方法还可以接受第二个参数（2到36之间，超过这个范围返回 NaN ），如果第二个参数是0、undefined和null，则直接忽略;
（6）JavaScript 不再允许将带有前缀0的数字视为八进制数，而是要求忽略这个0。但是，为了保证兼容性，大部分浏览器并没有部署这一条规定。

parseInt(011, 2) // NaN

// 等同于
parseInt(String(011), 2)

// 等同于
parseInt(String(9), 2)

parseFloat 将字符串转为浮点数

（1）parseFloat会将空字符串转为NaN

parseFloat(true)  // NaN
Number(true) // 1

parseFloat(null) // NaN
Number(null) // 0

parseFloat('') // NaN
Number('') // 0

parseFloat('123.45#') // 123.45
Number('123.45#') // NaN

isNaN 判断一个值是否为NaN

（1）isNaN只对数值有效，如果传入其他值，会被先转成数值，isNaN为true的值，有可能不是NaN，而是一个字符串。

isNaN('Hello') // true
// 相当于
isNaN(Number('Hello')) // true

（2）对于对象和数组，isNaN也返回true。

isNaN({}) // true
// 等同于
isNaN(Number({})) // true

isNaN(['xzy']) // true
// 等同于
isNaN(Number(['xzy'])) // true

（3）对于空数组和只有一个数值成员的数组，isNaN返回false。

isNaN([]) // false
isNaN([123]) // false
isNaN(['123']) // false

isFinite 某个值是否为正常的数值

isFinite(Infinity) // false
isFinite(-Infinity) // false
isFinite(NaN) // false
isFinite(undefined) // false
isFinite(null) // true，注意这个
isFinite(-1) // true 

除了 Infinity、-Infinity、NaN 和 undefined这几个值会返回 false，isFinite对于其他的数值都会返回true。

字符串

（1）用单引号（'）与双引号（"）都可以，也可以互相嵌套；
（2）如果要在单引中用使用单引号（或双引号中使用双引号），可以使用转义字符；
（3）建议使用单引号，用于与html的双引号区分；
（4）一个字符串要写在一行，否则报错。如果要写在多行，每行后面，加一个 \，并且以换行符结束；

var longString = 'Long 
long 
long 
string';

longString
// "Long long long string"

（5）利用多行注释，变向输出多行

(function () { /*
line 1
line 2
line 3
*/}).toString().split('n').slice(1, -1).join('n')
// "line 1
// line 2
// line 3"

（6）特殊的转义字符，如果 \ 使用在非特殊字符中，没任何影响；

• \0 ：null（\u0000）
• \b ：后退键（\u0008）
• \f ：换页符（\u000C）
• \n ：换行符（\u000A）
• \r ：回车键（\u000D）
• \t ：制表符（\u0009）
• \v ：垂直制表符（\u000B）
• \' ：单引号（\u0027）
• \" ：双引号（\u0022）
• \\ ：反斜杠（\u005C）

（7）转义字符三种写法

'251' // "©"，直接3位数字，8进制
'xA9' // "©"，x开头，2位数字，16进制
'u00A9' // "©"，u开头，4位字符（或者叫码点），16进制

'172' === 'z' // true
'x7A' === 'z' // true
'u007A' === 'z' // true

（8）每个字符在 JavaScript 内部都是以16位（即2个字节，U+0000到U+FFFF）的 UTF-16 格式储存。4个字节长度（U+10000到U+10FFFF）时，会当成两个2字节处理，历史原因造成。

（9）Base64 就是一种编码方法，可以将任意ASCII码值转成 0～9、A～Z、a-z、+和/这64个字符组成的可打印字符；

• btoa()：任意值转为 Base64 编码
• atob()：Base64 编码转为原来的值

（10）要将非 ASCII 码字符转为 Base64 编码，必须中间插入一个转码环节

function b64Encode(str) {
  return btoa(encodeURIComponent(str));
}

function b64Decode(str) {
  return decodeURIComponent(atob(str));
}

b64Encode('你好') // "JUU0JUJEJUEwJUU1JUE1JUJE"
b64Decode('JUU0JUJEJUEwJUU1JUE1JUJE') // "你好"

对象

（1）对象的所有键名都是字符串（ES6 又引入了 Symbol 值也可以作为键名），所以加不加引号都可以
（2）如果键名是数值，会被自动转为字符串

var obj = {
  1: 'a',
  3.2: 'b',
  1e2: true,
  1e-2: true,
  .234: true,
  0xFF: true
};

obj
// Object {
//   1: "a",
//   3.2: "b",
//   100: true,
//   0.01: true,
//   0.234: true,
//   255: true
// }

obj['100'] // true

（3）如果键名不符合标识名的条件（比如第一个字符为数字，或者含有空格或运算符），且也不是数字，则必须加上引号，否则会报错。

// 报错
var obj = {
  1p: 'Hello World'
};

// 不报错
var obj = {
  '1p': 'Hello World',
  'h w': 'Hello World',
  'p+q': 'Hello World'
};

（4）对象的每一个键名又称为“属性”（property），它的“键值”可以是任何数据类型。如果一个属性的值为函数，通常把这个属性称为“方法”，它可以像函数那样调用

var obj = {
  p: function (x) {
    return 2 * x;
  }
};

obj.p(1) // 2

（5）如果属性的值还是一个对象，就形成了链式引用

var o1 = {};
var o2 = { bar: 'hello' };

o1.foo = o2;
o1.foo.bar // "hello"

（6）最后一个属性后面可以加逗号（trailing comma），也可以不加
（7）属性可以动态创建，不必在对象声明时就指定。

var obj = {};
obj.foo = 123;
obj.foo // 123 

（8）无法确定是对象还是代码块，一律解释为代码块。如果要解释为对象，最好在大括号前加上圆括号。

({ foo: 123 }) // 正确
({ console.log(123) }) // 报错

（9）读取属性时，可以用 . 或 []，如果使用 []，属性名必须加引号，否则会被当成变量处理

ar foo = 'bar';

var obj = {
  foo: 1,
  bar: 2
};

obj.foo  // 1
obj[foo]  // 2

（10）方括号运算符内部还可以使用表达式

obj['hello' + ' world']
obj[3 + 3]

（11）数字键可以不加引号，因为会自动转成字符串。

var obj = {
  0.7: 'Hello World'
};

obj['0.7'] // "Hello World"
obj[0.7] // "Hello World"

（12）数值键名不能使用点运算符（因为会被当成小数点），只能使用方括号运算符。

var obj = {
  123: 'hello world'
};

obj.123 // 报错
obj[123] // "hello world"

（13）查看属性

var obj = {
  key1: 1,
  key2: 2
};

Object.keys(obj);
// ['key1', 'key2']

（14）删除属性

var obj = { p: 1 };
Object.keys(obj) // ["p"]

delete obj.p // true
obj.p // undefined
Object.keys(obj) // []

（15）删除一个不存在的属性，delete不报错，而且返回true。

var obj = {};
delete obj.p // true

（16）该属性存在，且不得删除时，返回 false

var obj = Object.defineProperty({}, 'p', {
  value: 123,
  configurable: false
});

obj.p // 123
delete obj.p // false

（17）delete命令只能删除对象本身的属性，无法删除继承的属性，即使delete返回true，该属性依然可能读取到值。

var obj = {};
delete obj.toString // true
obj.toString // function toString() { [native code] }

（18）属性是否存在 in，但不能识别哪些属性是对象自身的，哪些属性是继承的，可以使用hasOwnProperty

var obj = { p: 1 };
'p' in obj // true
'toString' in obj // true

var obj = {};
if ('toString' in obj) {
  console.log(obj.hasOwnProperty('toString')) // false
}

（19）属性的遍历：for...in 循环

• 它遍历的是对象所有可遍历（enumerable）的属性，会跳过不可遍历的属性。
• 它不仅遍历对象自身的属性，还遍历继承的属性。

var obj = {};

// toString 属性是存在的，但不是可遍历的
obj.toString // toString() { [native code] }

for (var p in obj) {
  console.log(p);
} // 没有任何输出

（20）通过 hasOwnProperty 只遍历自己的属性

var person = { name: '老张' };

for (var key in person) {
  if (person.hasOwnProperty(key)) {
    console.log(key);
  }
}
// name

（21）with 语句

// 例一
var obj = {
  p1: 1,
  p2: 2,
};
with (obj) {
  p1 = 4;
  p2 = 5;
}
// 等同于
obj.p1 = 4;
obj.p2 = 5;

// 例二
with (document.links[0]){
  console.log(href);
  console.log(title);
  console.log(style);
}
// 等同于
console.log(document.links[0].href);
console.log(document.links[0].title);
console.log(document.links[0].style);

（22）如果with区块内部有变量的赋值操作，必须是当前对象已经存在的属性，否则会创造一个当前作用域的全局变量。不推荐使用

var obj = {};
with (obj) {
  p1 = 4;
  p2 = 5;
}

obj.p1 // undefined
p1 // 4