var name = ‘the window‘;

var obj = {

　　name:"my obj",

　　getNameFunc:function(){

　　　　return function(){

　　　　　　return this.name;

　　　　}

　　}

};

alert(obj.getNameFunc()());//问输出功效是几多

答案：the window

理解：这里的obj.getNameFunc()返回了一个function,然后再再外面挪用这个function,这时候挪用function的是window东西，，所有输出the window

2.

var name = ‘the window‘;

var obj = {

　　name:"my obj",

　　getNameFunc:function(){

　　　　var that = this;

　　　　return function(){

　　　　　　return that.name;

　　　　}

　　}

};

alert(obj.getNameFunc()());//问输出功效是几多

答案：my obj

理解：返回的这个function是getNameFunc的一个内部函数，而他使用了外部函数界说的变量，所以孕育产生了闭包，再挪用执行return that.name;的时候，可以再闭包中找到这个that变量（即外部函数的this）,所有最终相当于挪用了obj 的name,所以返回my obj

3.

function A(){}

A.prototype.n = 1;

var b = new A();

A.prototype={

　　n:2,

　　m:3

}

var c = new A();

console.log(b.n,b.m,c.n,c.m);//问输出几多

答案：1，undefined，2，3

理解：b 东西的原型__proto__指向的是第一次创建A functon的时候的A的prototype,只是上面多加了一个属性n值为1。当后面转变A的prototype的指向此外一个东西时并不会转变b东西的__proto__的指向，只是转变了后面新创建的c东西的指向。

4.

var F = function (){}

Object.prototype.a = function (){

　　console.log(‘a()‘);

}

Function.prototype.b = function (){

　　console.log(‘b()‘);

}

var f = new F();

f.a();

f.b();

F.a();

F.b();

问依次输出是什么？

答案：a()  报错  a()  b()

理解：首先执行var F = function (){}的时候创建了F，F的__proto__指向Function的prototype，所以再Function的prototype上面加的属性F是可以访谒的，所以F.b();应该输出b()。而Function的prototype是Object的一个东西，这个东西是由Object作为Function孕育产生的，所以这个这个东西的__proto__指向Object的prototype，所以F.a();应该输出a()。

var f = new F();所以f .__proto__指向F 的prototype，而F的的prototype是Object的一个东西，这个东西是由Object作为Function孕育产生的，所以这个这个东西的__proto__指向Object的prototype，所以f.a();应该输出a()。而prototype和Functiono的prototype没有直接联系，所以f.b();应该会报错找不到这个要领。

5.

console.log(‘global begin:‘+i);

var i = 1;

foo(1);

function foo(i){

　　if(i==4){

　　　　return;

　　}

　　console.log(‘foo begin:‘+i);

　　foo(i+1);

　　console.log(‘foo end:‘+i);

}

console.log(‘global end:‘+i);

问：所有的输出功效

答案：global begin:undefined  foo begin:1  foo begin:2  foo begin:3  foo end:3  foo end:2  foo end:1  global end:1

理解：这个对照简单，按代码执行挨次就能知道功效。

6.

function a (){}

var a;

console.log(typeof(a));//问输出什么

答案：function

理解：变量提升先于函数提升，所以先执行变量提升a=undefined，然后再将a赋值给函数。

7.

if(!(b in window))

{

　　var b = 1;

}

cnsole.log(b);//问输出什么

答案：undefined

理解：再es5里面没有块感化域，所以再{var b = 1;}相当于再外面执行var b = 1;，由于变量提升再代码执行前window中就有了b属性只是值为undefined，所以b in window为true，不执行判断语句里面的代码，输出undefined

8.

var c = 1 ;

functiong c(c){

　　console.log(c);

}

c(2);//问输出什么

答案：报错：c不是一个函数

理解：由于函数和变量提升，所以实际的执行挨次是：var c ;   function c(c){console.log(c);};   c = 1;  c(2);

9.

var x = 10;

function fn(){

　　console.log(x);

}

function show(f){

　　var x = 20;

　　f();

}

show(fn);

问：输出功效是什么

答案：10

理解：由于fn是最外层的函数所以没有闭包孕育产生，应该用函数的感化域来解决，函数的感化域是再界说函数的时候就已经孕育产生了，并不是代码执行的时候孕育产生，所以即便把fn作为参数传到了show()函数里面，但是执行代码时使用的感化域是界说函数时候的，fn是在最外层界说的，所以当本身内部找不到x的时候会去window上面找。

10.

var fn = function (){

　　console.log(fn);

}

fn();

var obj = {

　　f2:function(){

　　　　console.log(f2);

　　}

}

obj.f2();

问：输出功效是什么

答案：function (){console.log(fn);}   报错：找不到f2