题目1

function a(i) {
  var i;
  alert(i);
};
a(10);

/*
  输出结果是: 10
  分析:
    变数提升是只提升定义，赋值(指定值)部份不会提升。
    alert 输出 10
*/

function ab(x) {
  console.log(x);
  var x;
  console.log(x);
};
ab(3);
// 3
// 3
// 但是, 当函数中声明的变量是被赋了值, 就会顶替掉传进来的参数

function ab(x) {
  console.log(x);
  var x = 4;
  console.log(x);
};
ab(3);
// 3
// 4

function ab(x) {
  console.log(x);
  function x() {
    console.log("我是函数") };
    console.log(x);
};
ab(3);
// fn
// fn 
// 函数声明提升

function foo(b) {
  var b = 2;
  console.log(b);
  console.log(arguments[0]);
}
foo(1); 
// 2
// 2
// 局部变量声明不会覆盖形参，赋值不是改变形参，而是覆盖形参的值 // 同一作用域，重复声明但不赋值，不会对变量有影响

题目2

function a(i) {
  alert(i);
  alert(arguments[0]);
  var i = 2;
  alert(i);
  alert(arguments[0]);
};
a(10);

/*
  输出结果: 10,10,2,2
  分析:
    第一个 alert 把形参 i 的值 10 输出
    第二个 alert 把 arguments[0] 输出，应该也是 i
    接着定义个局部变量 i 并赋值为2，这时候局部变量 i=2
    第三个 alert 就把局部变量 i 的值 2 输出
    第四个alert再次把 arguments[0] 输出
*/

题目3

var i=10;
function a() {
  alert(i);
  var i = 2;
  alert(i);
};
a();

// undefined
// 2

题目4

var i=10;
function a() {
  alert(i);
  function b(){
    var i = 2;
    alert(i);
  }
  b();
};
a();

// 10
// 2

题目5

var scope = "global scope";
function checkscope(){
  var scope = "local scope";
  function f(){
    return scope;
  }
  return f();
}
checkscope();

function checkscope2(){
  var scope = "local scope";
  function f(){
    return scope;
  }
  return f;
}
checkscope2()();

/*
  输出结果: local scope, local scope
  分析:
    checkscope(); 局部变量作用于在函数里面都是通用的，
    checkscope2()(); f() 依旧是绑定 checkscope2(),checkscope2 一样是存在
*/

题目6

// 数据统计1
var uniqueInteger = (function(){
  var counter = 0;
  return function(){
    return counter++;  // 注意 ++ 在后
  }
}());
uniqueInteger();  // 0

// 数据统计2 通过对象
function counter(){
  var n = 0;
  return {
    count:function(){ return n++}, 
    reset:function(){ n=0;}  // 函数没有 return 的时候，就应该是 undefined
  };
}

var c = counter();
var d = counter();
c.count();  // 0
d.count();  // 0
c.reset();  // undefined
c.count();  // 0,但是 c.getCount() 返回 1
d.count();  // 1，但是此时 n 的值为2

/*
  1.两个方法都可以访问私有变量n
  2.每次调用counter()都会创建一个新的作用域链和一个新的私有变量
*/

题目7

function constfunc(v){
  return function(){
    return v;
  };
}
var funcs = [];
for(var i = 0;i<10;i++){
  funcs[i] = constfunc(i);
}
funcs[5]();  // 值是多少？

function constfunc(){
  var funcs = [];
  for(var i = 0;i<10;i++){
    funcs[i] = function(){return i;};
  }return funcs;
}
var funcs = constfunc();
funcs[5]();  // 值是多少？

/*
  结果: 5,10,5
  分析:
    第一个 funcs 中的每个 function 都是 new 新的 constfunc，处于不同的闭包
    第二个 funcs 中的每个 function 处于同一个闭包中,数据共享,都会返回相同的值
    第三个 func 中 for 使用 let 形成块级作用域
*/

注：变量只能声明变量，不能提升值。