1、两个不同的函数各自申明了同一个变量，那么该变量只在各自的函数体内起作用。
2、由于JavaScript的函数可以嵌套，此时，内部函数可以访问外部函数定义的变量，反过来则不行。
3、变量提升，
4、全局作用域（ window ）
5、局部作用域：for if else 不能创造作用域
eg：for循环中用var定义的i，在for循环外部，依旧能够访问到；相反，用 let 可以实现块级作用域。
6、ES6中，表示常量的const也有块级作用域
7、ES6解构：一个对象中取出若干属性，一个数组中取出若干到元素
8、map()：给数组的每一项进行相同的操作，得到一个新数组，是操作后得到的数组
把Array的所有数字转为字符串：
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(String); // ['1', '2', '3', '4', '5', '6', '7', '8', '9']
·
字符串转成数字为什么不行？
var arr = ['1', '2', '3'];
arr.map(parseInt); // 1,NaN,NaN
正确解析：
由于map()接收的回调函数可以有3个参数：callback(currentValue, index, array)，通常我们仅需要第一个参数，而忽略了传入的后面两个参数。不幸的是，parseInt(string, radix)没有忽略第二个参数，导致实际执行的函数分别是：
parseInt('0', 0); // 0, 按十进制转换
parseInt('1', 1); // NaN, 没有一进制
parseInt('2', 2); // NaN, 按二进制转换不允许出现2
可以改为：
arr.map(Number);
因为Number(value)函数仅接收一个参数。
9、reduce() : 把一个函数作用在一个Array的 [ x1, x2, x3... ] 上，这个函数必须接收两个参数，reduce()把结果继续和序列的下一个元素做累积计算
a ） 对一个Array求和，就可以用reduce实现：
var arr = [1, 3, 5, 7, 9];
arr.reduce(function (x, y) {
return x + y;
}); // 25
b） 要把[1, 3, 5, 7, 9]变换成整数13579，reduce()也能派上用场：
var arr = [1, 3, 5, 7, 9];
arr.reduce(function (x, y) {
return x * 10 + y;
}); // 13579
10、filter() : 从数组中，筛选出想要的数据，返回组成新的数组
a) 数组去重
arr.filter( function(element,index,self){
return self.indexOf(element) === index
} )
11、sort()：默认转成字符串后，再进行比较。导致 [1,2,10,20] 的排序结果为【1，10，2，20】，解决如下：
arr.sort(function(x,y){
if(x>y){
return 1;
} else if(x==y){
return 0;
} else{
return -1;
}
})
并且，sort() 会改变原数组
12、闭包实例1：
function outter(){
var sky="blue";
function inner(){
console.log(sky);
}
return inner;
}
var result=outter();
result(); //"blue"
闭包：
闭包是指有权访问另一个函数作用域中变量的函数，创建闭包的最常见的方式就是在一个函数内创建另一个函数，通过另一个函数访问这个函数的局部变量,利用闭包可以突破作用链域，将函数内部的变量和方法传递到外部。
闭包的特性：
1.函数内再嵌套函数
2.内部函数可以引用外层的参数和变量
3.参数和变量不会被垃圾回收机制回收
上面代码就包含一个简单的闭包：outter函数的返回值是一个函数，即inner。inner在outter内部，理所当然能访问到局部变量sky，但当inner作为outter的返回值赋给outter外的全局变量时，神奇的事情发生了：在全局作用域中访问到了sky，这就是闭包。
原理：
每个函数都有自己的执行环境，当一个函数被执行时，它的执行环境就会被推入环境栈，其活动对象(存储环境中定义的变量及函数)加入作用域链中，一旦函数执行完，栈将其环境弹出，活动对象被销毁。·
对于上面的例子来说，outter执行完之后将返回inner给了result，outter的执行环境从环境栈弹出，控制权交给全局环境，outter的活动对象理应被销毁。但此时inner已经存储在全局活动对象中了，同时inner需要访问sky，所以outter的活动对象没有被销毁，即使result执行完毕，outter的活动对象依然存在于作用域链中，只有当result被销毁
闭包优点：
能在一个函数外访问函数中的局部变量，把这些变量用闭包的形式放在函数中便能避免全局作用域污染。
闭包缺点：
- 闭包将函数的活动对象维持在内存中，过度使用闭包会导致内存占用过多；
- 闭包只能取得外部函数中任何变量的最后一个值，在使用循环且返回的函数中带有循环变量时会得到错误结果；
- 当返回的函数为匿名函数时，注意匿名函数中的this指的是window对象。
function counter () {
var n = 0;
return {
count:function(){return n++;},
reset:function(){n = 0;}
}
}
var c = counter();
var d = counter(); // 每创建一个实例，他们的n都互不影响
c.count() //0
d.count() //0
c.reset() //reset()和count()共享
d.count() //1
c.count() //0
<script>
function A(){
var x = 1;
return function(){
x++;
console.log(x);
}
}
var m1 = A();//第一次执行A函数
m1();//2
m1();//3
var m2 = A();//第二次执行A函数
m2();//2
m1();//4
</script>
常见的内存泄漏方式：
1、意外的全局变量
a）函数里未用var／let来声明变量
b）在函数中通过this赋予变量，在函数中，this指向window
2、定时器setTimeout setInterval以及回调函数
当不需要setInterval或者setTimeout时，定时器没有被clear，定时器的回调函数以及内部依赖的变量都不能被回收，造成内存泄漏。
比如：vue使用了定时器，需要在beforeDestroy 中做对应销毁处理。js也是一样的。
