JavaScript核心

计算机科学只有两个难题

缓存失效和命名

任何人都能写出计算机能够理解的代码，但不是人人都能写出人能理解的代码

// bad
const fruit = ['apple', 'banana'];

// ok
const fruitArr = ['apple', 'banana'];

// good
const fruits = ['apple', 'banana'];


// 优秀的代码
function startEditing() {
    if (user.canEdit(currentDocument)) {
        editControl.setEditMode(true);
    }
}

变量的基本类型与引用类型

1、JavaScript变量与其他类型不同，他是松散类型，不会定义变量存储的类型

2、引用类型与基本类型，引用类型保存在内存中。

复制对象时(不是拷贝引用)，操作的实际上是对象的引用而不是实际对象(因此会出现两个复制的对象修改共享)，而基本类型则是值传递，互不影响。

特别注意，这一点在函数的参数传递也是一样(函数的参数被复制为局部变量，如果是引用类型指向堆内存的同一个指针)。就是简单的值传递，不存在引用传递

// 基础类型复制
let num1 = 1;
let mun2 = num1;
num1 = 2;
console.log(num1); // 1
console.log(num2); // 2

// 引用类型复制
let obj1 = { id: 1 };
let obj2 = a;
obj2.id = 2;
console.log(obj1.id); // 2
console.log(obj2.id); // 2

// 基本类型函数参数传递,未改变，还是10
let num = 10;
function add(n) {
    n = n + 1;
    return n;
}
add(num);
console.log(num);

// 引用类型函数参数传递; 输出2，值传递，引用类型共享引用，被修改
let obj = { id: 1 };
function changeId(obj) {
    obj.id = 2;
}
changeId(obj);
console.log(obj.id);

// 函数参数传递是值传递，js中不存在引用传递; 输出2，值传递，引用类型共享引用，被修改。
// 注意这里，首先是变量提升，但提升完声明后为id赋值2；仍然没有修改引用，因此修改的依旧是外部的obj；
// 而obj= {id: 'newId'}这时改变引用，因此这时内部操作的obj都是指向var声明的，不会响应到外部
// 但外部已经修改完成，因此外部的obj.id是2；内部的obj.id是newId
let obj = { id: 1 };
function changeId(obj) {
    obj.id = 2;
    var obj = { id: 'newId' };
    console.log(obj.id)
}
changeId(obj);
console.log(obj.id);

函数的参数可以理解为叫外部变量复制一份的局部变量，内部声明的局部变量创建了新引用，没有响应到外部obj，说明是值传递而不是引用传递(如果是引用传递obj.id就应该被修改为newId)

// 输出1，因为内部声明了一个新的变量指向新的引用，因此内部操作的obj都是var声明的
let obj = { id: 1 };
function changeId(obj) {
	var obj = {};
    obj.id = 2;
    obj = { id: 'newId' };
}
changeId(obj);
console.log(obj.id); 


// 输出2，只做了obj的声明(其实声明不声明都无所谓，因为已经拷贝了外部变量为函数局部obj)，
// 没有修改他的引用，obj.id操作的依然是函数拷贝的外部变量,而obj={}修改了他的引用，
// 局部指向id为newId的引用，外部还是指向原来的引用，id被修改为2
let obj = { id: 1 };
function changeId(obj) {
	var obj;
    obj.id = 2;
    obj = { id: 'newId' };
}
changeId(obj);
console.log(obj.id); 

区别

1、基本类型值在内存中占据固定大小的空间，因此被保存在栈内存中；

2、从一个变量向另一个变量复制基本类型的值，会创建这个值的一个副本；

3、引用类型的值是对象，保存在堆内存中；

4、包含引用类型值的变量实际上包含的并不是对象本身，而是一个指向该对象的指针；

5、从一个变量向另一个变量复制引用类型的值，复制的其实是指针，因此两个变量最终都指向同 一个对象；

6、确定一个值是哪种基本类型可以使用 typeof 操作符，而确定一个值是哪种引用类型可以使用 instanceof 操作符。

instanceof

我们可以使用typeof来检测基本类型，但对于引用类型，typeof只能检测为object，而不能进一步确定它是对象、数组、null。为此引入instanceof

alert(person instanceof Object); // 变量 person 是 Object 吗？

alert(colors instanceof Array); // 变量 colors 是 Array 吗？

alert(pattern instanceof RegExp); // 变量 pattern 是 RegExp 吗？

instanceof的常用来检测一个对象的原型是否为另一个对象(检测是否为继承关系)，child instanceof parent

执行环境

1、执行环境定义了变量对象，用于保存和搜索变量和函数。

2、全局执行环境是最外围的一个执行环境。根据 ECMAScript 实现所在的宿主环境不同，表示执行环境的对象也不一样。在 Web 浏览器中，全局执环境被认为是 window 对象，因此所有全局变量和函数都是作为 window 对象的属性和方法创建的。

3、每个函数都有自己的执行环境，当执行流进入一个函数时，函数的环境就会被推入一个环境栈中。而在函数执行之后，栈将其环境弹出，把控制权返回给之前的执行环境。ECMAScript 程序中的执行流正是由这个方便的机制控制

4、某个执行环境中的所有代码执行完毕后，该环境被销毁，保存在其中的所有变量和函数定义也随之销毁(全局执行环境直到应用程序退出——例如关闭网页或浏览器时才会被销毁)。

存疑：这里是垃圾回收触发定时清除还是退出环境js主动清除？？？

5、执行环境的类型只有两种——全局和局部(函数)；全局环境只能访问在全局环境中定义的变量和函数，而不能直接访问局部环境中的任何数据；函数的局部环境不仅有权访问函数作用域中的变量，而且有权访问其包含(父)环境，乃至全局环境；

作用域链

1、当代码在一个环境中执行时，会创建变量对象的一个作用域链(scope chain)。

2、作用域链的用途，让变量沿着作用域链一级一级地一层层向上搜索直到全局环境。

3、每多一层作用域查找性能消耗都是巨大的(缓存顶部对象减少查找层数很有必要)

var color = "blue";
function changeColor() {
    var anotherColor = "red";
    function swapColors(){
        var tempColor = anotherColor;
        anotherColor = color;
        color = tempColor;
        // 这里可以访问 color、anotherColor 和 tempColor
    }

    // 这里可以访问 color 和 anotherColor，但不能访问 tempColor
    swapColors();
}
// 这里只能访问 color 
changeColor();

作用域链访问优化

尽可能的少的跨层查找变量

// 现在函数作用域内查找，没有，往上层层查找
function changeColor() {
    document.getElementById("targetCanvas").style.backgroundColor = "red";
}

// 优化，函数作用域内就能找到
function changeColor() {
    let $document = document;
    $document.getElementById("targetCanvas").style.backgroundColor = "red";
}

上述只有一层或一次调用时性能优化不明显，但大量的全局变量被从反复访问，那么重写后的代码性能会显著改善

作用域链变更

虽然执行环境的类型总共只有两种——全局和局部(函数)，但还是有其他办法来延长作用域链。因为有些语句可以在作用域链的前端临时增加一个变量对象，该变量对象会在代码执行后被移除。

1、try-catch 语句

2、with 语句

对with和catch语句而言，会创建一个新的变量对象，把语句内使用到的局部变量放进去，查找其中的变量需要多访问一层的作用域，造成性能问题。因此我们要避免使用with。

而try-catch语句在代码调试和异常处理非常有用，无法完全避免。但为了减少性能问题，我们把try中和catch中的语句抽离成函数(这样就没有局部变量的访问，作用域的延长就不会造成性能问题)

// try-catch优化改造
function tryRun() {
    // 耗时、变量代码
}
function catchRun(e) {
    // 耗时、变量代码及异常处理
}

try {
    tryRun();
} catch(e) {
    catchRun(e)
}

块级作用域

var声明的变量只有函数作用域和全局作用域

而ES6的const与let声明的变量具有块级作用域

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

// 由于ES6块级作用域，报错i未定义
for (let i = 0; i < 10; i++) {
    // dosomething
}
console.log(i);

// 输出10次10
for (var i = 0; i < 10; i++) {
    setTimeout(() => console.log(i), 1000)
}

// ES6块级作用域，输出0-9
for (let i = 0; i < 10; i++) {
    setTimeout(() => console.log(i), 1000)
}

对于有块级作用域的语言，i只存在于循环内部；对于 JavaScript 来说，由 for 语句创建的变量 i 即使在 for 循环执行结束后，也依旧会存在 于循环外部的执行环境中，因此不管你是let还是var声明的变量，都存在于外部，返回10

变量查询和提升

从当前作用域逐层向上查找，如果存在一个局部的变量的定义，则搜索会自动停止

var声明的变量会提升到当前作用域的顶部，不是提升到全局。且只有声明提升，赋值不提升。而没有使用var声明的变量默认挂着全局对象window下

对于function a() {}，会将函数整体提升到当前作用域顶部，因此函数只要在同一作用域声明，不管前后都能正确使用。因为函数会整体提升到顶部

// 变量提升到当前作用域顶部
function add(num1, num2) {
    console.log(sum); // undefined
    var sum = num1 + num2;
    return sum;
}
var result = add(10, 20); //30
console.log(sum);

// 只有变量会提升
console.log(typeof(a)); // undefined，a为变量提升
console.log(typeof(b)); // function，b为具名函数，函数整体提升
var a = function() {  }
function b() {  }

由于变量提升，sum会被提升到函数的第一行var sum;因此第一个log为undefined。而外面的sum直到全局作用域也查找不到，因此报错未定义

如果是函数变量提升，相当于var add; add = function...;

console.log(add);
function add() {};

// 打印undefined，相当于
var add;
console.log(add);
add = function() {};

垃圾回收

JavaScript具有自动垃圾回收机制：找出那些不再继续使用的变量，然后释放其占用的内存。为此，垃圾收集器会按照固定的时间间隔(或代码执行中预定的收集时间)，周期性地执行这一操作。

标记清除法

JavaScript 中最常用的垃圾收集方式是标记清除(mark-and-sweep)

垃圾收集器在运行的时候会给存储在内存中的所有变量都加上标记(可以使用任何标记方式如翻转某一位)。然后，它会去掉环境中的变量以及被环境中的变量引用的变量的标记。然后销毁那些带标记的值并回收它们所占用的内存空间

大部分浏览器IE、Firefox、Opera、Chrome 和 Safari 的 JavaScript 实现使用的都是标记清除式的 垃圾收集策略(或类似的策略)，只不过垃圾收集的时间间隔互有不同

引用计数法

另一种不常见的垃圾收集方式是引用引用计数(reference counting)

跟踪记录每个值被引用的次数，当声明了一个变量并将一个引用类型值赋给该变量时，则这个值的引用次数就是 1。如果同一个值又被赋给另一个变量，则该值的引用次数加 1。相反，如果包含对这个值引用的变量又取得了另外一个值，则这个值的引用次数减 1。当垃圾收集器运行时，它就会释放那些引用次数0零的值所占用的内存。

循环引用(最常见的objectA的某个属性指向objectB，而objectB的属性又指向objectA，还有很多其他情况会循环引用，导致内存泄露)，

循环引用，在标记清除法中，不会出现问题(不在环境中就会被释放)，而在引用计数法中这两个对象的引用永远不可能是0。假如包含循环引用的代码被重复使用，将会导致大量的内存无法释放

解决循环引用，手动设置对象为null，置空引用

性能问题

IE 的垃圾收集器是根据内存分配量运行的，具体一点说就是 256 个变量、4096 个对象(或数组)、 64KB 的字符串。达到上述任何一个临界值，垃圾收集器就会运行。

如果一个脚本中很多变量，那么该脚本很可能会在执行时一直触发垃圾收集器，引发严重的性能问题

IE解决频繁除法垃圾回收方案(值得借鉴)，==动态分配临界值==，如果垃圾收集例程回收的内存分配量低于 15%，临界值就会加倍。如果例程回收了 85%的内存分配量，则将各种临界值重置回默认值。

我们可以手动的触发浏览器的垃圾回收(不同浏览器调用方式不同)，但不推荐手动触发(因为垃圾回收是阻塞性的，会停止响应其他操作)

内存管理

分配给Web浏览器的可用内存数量通常要比分配给桌面应用程序的少。这样做的目的主要是出于安全方面的考虑， 目的是防止运行 JavaScript 的网页耗尽全部系统内存而导致系统崩溃。内存限制问题不仅会影响变量 分配内存，同时还会影响调用栈以及在一个线程中能够同时执行的语句数量。确保占用最少的内存可以让页面获得更好的性能。

优化内存占用的最佳方式是，一旦数据不再有用，最好通过将其值设置为 null 来释放其引用——这个做法叫做解除引用(dereferencing)这一做法适用于大多数全局变量和全局对象的属性。局部变量会在它们离开执行环境时自动被解除引用

不过，解除一个值的引用并不意味着自动回收该值所占用的内存。解除引用的真正作用是让值脱离 执行环境，以便垃圾收集器下次运行时将其回收。

内存泄露及优化

1、全局变量引起的内存泄露

置null解除引用，尽量少使用全局变量。

意外的全局变量(没有var和let等声明，默认挂在全局对象上，相当于意外声明的全局变量)，添加严格模式限制，防止意外的全局变量

2、闭包

闭包可能保存着函数内部变量的引用，且闭包在外部环境，就会导致函数内部的变量不能够销毁。慎用闭包

3、DOM清除时，相关的事件未清除(手动addEventListener绑定的事件,onclick这些不需要)

removeEvent移除相关手动添加的事件，尽量在html中去绑定事件

4、循环引用

对象使用结束后，obj置为null解除引用，在gc触发时回收

5、封装通用模块对象，实现对象的复用

js中开辟空间的操作有new(), [ ], { }, function (){..}。最大限度的实现对象的重用

6、组件中使用了setInterval，里面使用的对象将不会被释放(除非定时器停止)，所以需要及时清除定时器

垃圾回收缺陷的优化

GC时，停止响应其他操作，这是为了安全考虑。而Javascript的GC在100ms甚至以上，对一般的应用还好，但对于JS游戏，动画对连贯性要求比较高的应用，就麻烦了。这就是新引擎需要优化的点：避免GC造成的长时间停止响应。

1、分代回收(Generation GC)：通过区分“临时”与“持久”对象；多回收“临时对象”区(young generation)，少回收“持久对象”区(tenured generation)，减少每次需遍历的对象，从而减少每次GC的耗时。

2、增量GC：这个方案的思想很简单，就是“每次处理一点，下次再处理一点，如此类推。

Object

1、对象的创建：构造函数或对象字面量

// new + 构造函数
let p = new Object();
p.name = 'Bob';

// 字面量(推荐)
let p = {
    name: 'Bob'
}

2、属性访问

let p = {
    name: 'Bob'
}

// 通过.访问(推荐)
p.name

// 通过[]，可以使用变量
let prop = 'name';
p[prop];

Array

values = [1,2,]; 在IE会被解析为1,2,undefined三项的数组，其他则是1,2两项

数组的 length 属性很有特点——它不是只读的。因此，通过设置这个属性，可以从数组的末尾移除项或向数组中添加新项。我们可以通过len来指定最后一项

检测数组

// 1、instanceof
if (arr instanceof Array) ...

// 2、Array.isArray
if (Array.isArray(arr)) ...

转换：调用数组['red', 'blue', 'yellow'].toString()将返回数组的字符串标识，以逗号分隔，red,blue,yellow

split与join

将字符串分割为数组以及组合回去，注意在split的时候，一定要先判断数据存在，像从后台拿到数据可能是null，调用split将会报错 str && str.split(',')

pop与push

push可以==新增多项==arr.push('red', 'green'); // ['red', 'green']，pop只能删除一项

数组的pop与push提供了类似栈(Last-In-First-Out后进先出)的操作方法。从尾部添加或删除

特别注意，pop与push会修改原数组，pop返回的是==删除==的那一项，push返回的是==新增==数组的长度。

// 错误操作：将push后的返回复制给原数组。
let arr = [1, 2, 3];
arr = arr.push(4);

// 正确操作: push改变原数组，直接push就ok
arr.push(4)

shift与unshift

unshift添加可以接受==新增多项==arr.unshift('red', 'green'); // ['red', 'green']，shift只是删除一项

数组的shift与unshfit提供了类似队列(First-In-First-Out先进先出)的操作方法。从头部添加或删除

特别注意，shift与unshfit会修改原数组，shift返回的是==删除==的那一项，unshift返回的是==新增==后数组的长度。

// unshift是向头部加所有
var colors = new Array(); //创建一个数组
var count = colors.unshift('red', 'green'); // ['red', 'green']

排序方法

arr.reverse()将数组倒序，而sort则支持一个自定义的排序方法。两者均会改变原数组

对象数组按序号order排序

let users = [    { order: '1', name: 'lzb' },    { order: '3', name: 'xby' },    { order: '2', name: 'zn' },];

users.sort(function(a, b) {
    return a.order - b.order;
});

操作方法

concat合并数组，arr = arr.concat(arr2) 不影响原数组，生成新数组

slice截取开始到结束下标(不包含)的数组项。如果只有一个参数，默认截取到末尾的所有项。不影响原数组，生成新数组

万能方法splice(index, len, newItem1, ...)删除指定下标开始的len项，同时新增任意项。返回删除的那些项，相当于slice截取的效果

位置方法

arr.indexOf(item)返回指定字符第一次出现的位置，找不到则返回-1

arr.lastIndexOf(item)则返回最后一次出现的位置，找不到则返回-1

遍历方法

every、some、filter、map、forEach

检查是否满足条件

every每一项满足条件才返回true；some则是任一项满足返回true。filter则是过滤出所有满足条件的项(找不到返回空)

// 检验数组所有数都是偶数，都是偶数返回true，否则返回false
let arr = [2, 4, 6, 8, 9];

// 使用自带方法some
let flag = !arr.some(item => item % 2 !== 0);

// 使用自带方法every
let flag = arr.every(item => item % 2 === 0);

// 使用for
let flag = true;
for (let i = 0, len = arr.length; i < len; i++) {
    if (arr[i] % 2 !== 0) {
        flag = false;
        break
    }
}

map

对每一项进行处理，返回派生的数组，如给对象数组的每一项添加属性selected，默认设置为false

map函数支持传入一个处理函数function deal() {...}; userList.map(deal);

forEach

遍历数组，特别注意，不能return

归并方法

reduce() 和 reduceRight()迭代数组的所有项，然后构建一个最终返回的值。reduce() 方法从数组的第一项开始，逐个遍历到最后。而 reduceRight() 则从数组的最后一项开始，向前遍历到第一项。

他们都接收 4 个参数：前一个值、当前值、项的索引和数组对象

常用来做数组项累加，数组降维度，数组去重，统计出现次数

// 累加
let arr = [1, 2, 3, 4, 5];
let sum = arr.reduce((pre, cur) => {
    return pre + cur;
}, 0);

归并的初始值为0，每一项累加最后返回结果15

let arr = [[1, [2, 4]], 3];

// 数组降维:reduce
function flattenDeep(arr) {
    return arr.reduce((pre, cur) => Array.isArray(cur) ? pre.concat(flattenDeep(cur)) : pre.concat(cur), []);
}

let result = flattenDeep(arr);

// 自带的降维，flat接收一个参数，代表降维几次，默认降1次，传入Infinity代表降维成1维数组(任意无穷维可降)
arr.flat(); // [1, [2, 4], 3]
arr.flat(Infinity); // [1,2,4,3]

Date

Date类型使用自 UTC(Coordinated Universal Time，国际协调时间)1970 年 1 月 1 日午夜(零时)开始经过的毫秒数来保存日期。

创建

var cur = new Date(); // 当前时间
var date1 = new Date(1620269389455); // 传入时间戳
var date2 = new Date('2021-12-05'); // 传入字符串，可以是/或-分割
var date2 = new Date('2020', '12', '04', '12', '15', '30', '10') // 传入年月日时分秒毫秒

时间戳

Date.now(); // 返回毫秒数
new Date().getTime(); // 返回毫秒数

比较

Date类型的valueof()重写，不返回字符串，而是返回日期的毫秒表示，为时间比较提供了很大的方便

new Date('2020-12-02') > new Date('2020-11-20') // true

// 自定义sort方法，按时间排序
arr.sort((a, b) => {
    return new Date(a) - new Date(b)
})

自带方法

方法	说明
getTime/setTime	按毫秒数获取/设置日期，与valueof相同
getFullYear/setFullYear	获取/设置4位数的年份，如2021
getMonth/setMonth	获取/设置4位数的月份，0-11对应1-12月
getDate/setDate	获取/设置天数，1-31
getDay/setDay	获取/设置星期数，0代表星期天，1-6对应相应星期
getHours/setHours	获取/设置小时数，0-23
getMinutes/setMinutes	获取/设置分钟数，0-59
getSeconds/setSeconds	获取/设置秒数，0-59
getMillSeconds/setMillSeconds	获取/设置毫秒数，0-59

注意，上述操作方法，如果出现越界会进位到上一级，如设置月数，setMonth(13)会进位年份，由此可以用来做时间运算

// 1天后的日期：由此可以获取n天前、n天后的日期
var date = new Date('2021-02-28');
date.setDate(date.getDate() + 1); // 2月28日后一天为3月1日

// 2小时后
var date = new Date('2021-02-28 23:59:59');
date.setHours(date.getHours() + 2); // 2小时后为3月1日的1点59分59秒

// 同理可以计算n秒前后，n分前后，n年前后等等等等

// 使用场景：最近15天数据展示、最近一周、最近一个月

正则

要么匹配字符，要么匹配位置

函数

每个函数都是Function的实例，函数实际上是Object，与其他引用类型一样可以有属性和方法

函数声明

1、函数声明语法

function test(num1, num2) {
  return num1 + num2;
}

2、变量声明法

var test = function() {};

3、构造函数形式

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

最后一个参数为函数执行体，不推荐这样声明(需要二次解析，解析js代码与eval字符串导致性能问题)。 但是这种声明表明函数是对象，函数名是指针(因此函数名可以被重置，如重置系统的alert方法，alert = null)

没有重载

js中的函数没有重载，因为函数名是一个指针，只会出现后面的函数覆盖前面的函数

函数提升(函数声明与函数表达式)

对于函数声明提升，而函数表达式相当于变量提升

// 由于函数声明提升，2
sum(1)
function sum(num) {
  return num + 1;
}

// 表达式写法，相当于变量，提升变量声明; sum是一个undefined，执行sum(1)报错sum is not a function
sum(1)
var sum = function(num) {}

函数作为参数传递，必须去掉()，不然将会自执行，这一点在callback时很有用

函数的arguments属性

arguments类似数组的对象，包含传入函数中的所有参数，它有一个callee的属性，用来执行函数本身。 我们可以利用arguments.callee来消除阶乘函数中的耦合(不在依然函数名称)

// 普通阶乘，依赖于函数名，且函数名不能改变
function factorial(num) {
  if (num <= 1) {
    return num;
  } else {
    return num * factorial(num - 1)
  }
}

// 消除耦合
function factorial(num) {
    if (num <= 1) {
    return num;
  } else {
    return num * arguments.callee(num - 1)
  }
}

函数的this

this指向函数的执行环境对象(当在网页的全局作用域中调用函数时,this对象引用的就是window)

window.color = "red";
var o = { color: " blue" };
function sayColor() {
  var color = "123";
  alert(this.color);
}
sayColor(); //"red"
o.sayColor = sayColor;
o.sayColor(); //"blue"

this指向函数的执行环境对象，sayColor在全局作用域中执行，所以this.color为window.color 而o.sayColor，this执行o对象，因此this.color指向o.color

注意：o.sayColor与sayColor都是指向函数的指针，即使执行环境不同，他们调用的也是一个函数

函数的caller

函数的caller属性指向调用本函数的浮函数，用于区分arguments.caller，但存在一定的兼容性问题，使用时需要注意，特别是严格模式

函数的length与prototype

函数的length代表函数预期的参数长度(注意是形参而不是实参)

function sayName(name){
  alert(name);
}
function sum(num1, num2){
  return num1 + num2;
}
function sayHi(){
  alert("hi");
}
alert(sayName.length); //1
alert(sum.length); //2
alert(sayHi.length); //0

对于引用类型，prototype是保存所有实例方法的真正所在，诸如toString、valueOf等方法都保存在prototype下， 只是通过各自的实例来调用而已，在new和继承非常有用。prototype的属性无法被枚举，因此不能被for-in循环遍历

函数的apply与call

fn.apply($this, arguments)
fn.call($this, p1, p2, ...)

用于修正this的指向，两者的区别在于apply接受一个参数数组，而call则是顺序参数

bind也用来修正this，bind会返回一个函数实例，这个函数实例中的this指向bind修正的环境对象，而不是运行时

window.color = "red";
var o = { color: "blue" };
function sayColor(){
  alert(this.color);
}
var objectSayColor = sayColor.bind(o);
objectSayColor(); //blue

即使函数实例运行在全局，而能正确返回o.color 这样的优点在于？？

基础包装类型

number类型对应的Number对象、string类型对应的String对象、布尔类型对应的Boolean对象

str.charAt(1)返回指定位置的字符，也可以通过下标获取str[1]

str.concat(str1)字符串拼接

创建新字符串，不会修改原字符串：

str.slice(sIndex, eIndex)返回指定下标区间的字符，不包含结束

str.substring(sIndex, eIndex)一般同slice，但在处理负区间时不同

str.sub(sIndex, length)返回指定下标开始length个字符

str.lastIndexOf(char)从尾部查找

str.indexOf(char)从头部查找出现的位置

str.trim()去除两端空格

str.toLowerCase与str.toUpperCase转大小写

Global对象

不管任何对象的属性和方法，最终都是Global的属性和方法(其实不存在全局方法，所有的全局方法都是Global对象的方法)

编码与解码

encodeURI()与encodeURIComponent()对url进行编码；decodeURI与decodeUrICompoent解码

encodeURI不会对属于URL本身的特殊字符编码，如冒号，#号，正斜杠，问号。但会对所有url的空格、中文编码

encodeURIComponent则会把所有的特殊字符都编码

实际中我们一般用来给url传递参数时编码，因此我们一般使用encodeURIComponent对参数部分编码，而不是对整个url编码

eval

eval是js中最强大的一个方法，它就像一个完整的ECMAScript解析器，它会把字符串按照 ECMAScript 语句解析并计算

// 相当于直接调用alert
var msg = "hello world";
eval("alert(msg)"); //"hello world"

// 相当于函数声明
eval("function sayHi() { alert('hi'); }");

注意：eval中的所有变量声明与函数声明都不会提升

Math

常用属性：Math.PI、Math.e、Math.LOG2等等

最大最小

Math.min(a, b, c, ...)与Math.max(a, b, c, ...)比较一系列的数值(仅数值，毕竟Math)的最大与最小

可以延伸处理获取数值数组的最大与最小[1, 3, 5, 7, 9]

let numberArr = [1, 3, 5, 7, 9];
// 拓展运算符
Math.max(...numberArr);

// apply形式
Math.max.apply(Math, numberArr)

// call形式
Math.max.call(Math, ...numberArr)

常用方法

Math.ceil()天花板向上、 Math.floor()地板向下取整、Math.round()

Math.random()返回随机的0-1之间的数，常用来随机展示项。Math.floor(Math.random() * 10);随机0-9

Math.abs(num)返回绝对值

Math.pow(2, n)返回2的n次方

Math.sqrt(num)开根号

以及一些三角相关，正切tan等