JavaScript函数习题

一、作用域，作用域链

 var a = 20;
	   function arr(){
	      var a = 10;
	      var b = 50;
	      function arr2(){
	        var c = 25;
	        console.log(a);//10
	        //这个a是在arr执行后，在作用域里面找，因为arrAO里面有a ，所以 a  = 10
	        console.log(b);//50
	        console.log(c);//25
	        return arr;
	      }
	      arr2();
	      console.log(a);//10
	      //这个a是找的也是arrAO的a ，所以 a  = 10
	   }
	   console.log(a);//20
	   //这个a是直接找作用域GO里面的a;因为此时arr函数未执行,所以 a  = 20
	   arr();
	   // GO{
    //        a : 20
    //        arr : fn...
	   // }
	   // arr AO{
	   // 	  a : 10;
	   // 	  b : 50;
	   // 	  arr2 : fn...;
	   // }
	   // arr2 AO{
	   // 	  c : 25;
	   // }
	   

var name = 'll';
var age = 10;
var sex = '男';
function work(){
	var age = 18;
	console.log(name);//ll
	console.log(age);//18
	console.log(sex);//男
	return work;
	function work2(){
		var sex = '女';
		console.log(name);
		console.log(age);
		console.log(sex);
	}
	work2();
}
work();
console.log(name);//ll
console.log(age);//10
console.log(sex);//男
    // GO{
    // 	name : 11
    // 	age : 18;
    // 	sex : 男;
    // 	work : fn...
    // }
    // work AO{
    // 	age : 10;
    // 	work2 : fn...; 
    // }
    // work2 AO{
    // 	sex : 女;
    // }

+function(){
        console.log(a)// fn....  函数和和变量先执行，
        var a=5;  //原地赋值为5 a = 5
        function a(){}
        console.log(a) //5    
        function b(){}
        b=6 //b赋值为6 , 为全局变量
        console.log(b) //6 
        var c=d=b  // d和b都为全局变量 所以都是6
    }()
    console.log(d) // 6

console.log(pom)  // 变量声明提前 此时为undefined       
var pom=0;
function fn(num1,num2){
　　console.log(pom) // 变量声明提前 此时为undefined       
　　var pom=num1+num2
　　console.log(pom)  // pom= num1 + num2 100+200 =300    
}
fn(100,200) // 运行函数
console.log(pom)  // 0 

二、预编译

function test(a,b){
		//预编译函数和变量的声明提前
		// 所以函数a提起声明
		// 变量提前声明但未赋值
		console.log(a); //fn....
		console.log(b); //undefined
		var  b =10;
		// 函数运行到此处，给b赋值为10
		console.log(b); //10 
		//此处给a声明没有用var关键字声明，所以此处a为全局变量 GO a = 20
		a=20;            
		console.log(a); //20
		function a(){}  
		//此处再次给a声明 并用var关键字声明，b也声明，全局变量 GO b = 30
		var a; 
		b=30; 
		// 此处给b赋值，赋值为一个函数体 A0 b fn....        
		var b = function(){}
		console.log(a); //20
		console.log(b); //fn.... 
}
test(1);

 //预编译函数和变量的声明提前
// 所以函数a，b提起声明
// 变量提前声明但未赋值
console.log(a);//undefined
console.log(b);//undefined
//声明的变量a 和 b 是局部变量 c 是全局变量 b和c都赋值为10
var a ; 
var b = c = 10;
function arr(){
	console.log(c); // 10
	// 因为b没有var关键字声明，所以声明不会提前，此时的b声明为全局变量
    b = function(){};
    //此时a声明成全局变量，赋值为20
     a = 20;
     console.log(a);//20
	 console.log(b);//fn....
	 console.log(c);//10
}
arr();

var x = 1, y = z = 0; 
// x有var关键字提前声明,赋值为1	 
function add(n) {  
      return n = n + 1;  
}  
y = add(x);
   
function add(n) {  
      return n = n + 3;  
}  
z = add(x);
//因为预编译函数会提起声明,下面的函数把上面的函数覆盖
// 将x值代入到add函数中去，此时y值等于返回的x+3    
// 将x值代入到add函数中去，此时z值等于返回的x+3    
console.log(x,y,z)//1，4，4

function test (a,b){
    console.log(a) // 1 
    c = 0;
    var c;
    a = 3;
    b =2;
    console.log(b); // 2
    function b() {}
    function d() {}
    console.log(b)  // 2
 }
 test(1)

三、构造函数

var User = {
　　count: 1,
　　getCount: function () {
　　　　return this.count;
　　}     
};    
console.log(User.getCount());     // 1
var func = User.getCount;
console.log(func());              // undefined

执行过程：
console.log(User.getCount());     // 1
getCount函数被User对象调用，所以this指向的是User。

console.log(func());              // undefined
func变量接收的是一个函数体：

function () {
　　return this.count;  
}
所以， func()执行的时候， this指的是window， 而window中没有count这个属性。 所以，返回的是undefined。