共计 4914 个字符，预计需要花费 13 分钟才能阅读完成。
数据类型
与值相干的全局办法
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#') // NaNisNaN 判断一个值是否为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']) // falseisFinite 某个值是否为失常的数值
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 // truevar 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