JS06 函数及其返回值

1、函数

• 函数的定义
  • 函数也是一个对象
  • 普通对象只能存储东西（封装功能），而函数对象可以执行该功能
  • 函数对象具有所有普通对象具有的功能，但是他比普通对象更加强大
  • 函数可以保存一些代码，在需要的时候调用代码
  • 使用typeof检查一个函数对象时，会返回function
• 创建函数方法1：构造函数
  • 创建一个函数对象
  • 可以将要封装函数的代码以字符串的形式传递给构造函数
    • 在实际开发中很少使用构造函数来创建函数
    • var fun = new Function("console.log('醉爱于炀');");
    • 封装到函数里面的代码不会立即执行，只会在函数调用时执行
    • 调用函数   语法：函数对象()
      • 当调用函数时，函数封装的代码会按照顺序执行

  • //创建函数方法1：构造函数
    //创建一个函数对象
    var fun = new Function("console.log('醉爱于炀');");
    
    //调用函数
    fun.hello="HOG";
    //fun();
    console.log(fun.hello);

• 创建函数方法2：函数声明
  • 使用函数声明来创建一个函数
  • 语法：
    • function 函数名（[形参1，形参2......，形参n]）{语句……}

  • function fun2(){
    	console.log("醉爱于炀");
    	alert("O(∩_∩)O");
    	document.write("┭┮﹏┭┮");
    }
    //调用fun2
    fun2();

• 创建函数方法3：函数表达式
  • 使用函数表达式来创建函数
  • 使用函数表达式创建的函数其实和给声明变量一个意思，不过这里是给匿名函数声明
  • 语法：
    • var 函数名 = function（[形参1，形参2，........，形参n]）{语句......}

  • //创建一个匿名函数(匿名函数本身时无法使用的，要对他进行声明)
    var fun3=function(){
    	console.log("匿名函数");
    };
    fun3();

• 可以在函数中指定一个或多个形参（形式参数）
  • 多个形参之间使用，号隔开  ，声明形参，就相当于在函数内部声明了对应的变量
  • 但是没有赋值
• 可以在调用函数时，在（）号里面定义实参（实际参数）
  • 实参将会赋值给函数对应的形参
  • 调用函数时，不会检查实参的类型
    • 所以要注意，是否有可能，则需要对参数进行类型的检查
    • 函数的实参可以是任意的数据类型
  • 调用函数时，解析器也不会检查实参的数量
    • 多余的实参不会被赋值
    • 如果实参的数量少于形参的数量，则没有对应实参的形参将为undefined

• function HOG(a,b){
  	console.log(a+b);
  }
  HOG(1,2);

• 立即执行函数：
  • 函数定义完了之后，立即被执行
  • 立即执行函数只会执行一次，没有变量去保存它

<script type="text/javascript">
	//函数对象
	(function(){
		alert("我是匿名函数");
	})();

	//赋值
	(function(aa,ba){
		alert(aa);
		alert(ba);
	})(1,2);
</script>

2、函数的返回值

• 在调用函数时，希望它可以存储下来而不是立即调用
  • 可以使用return来设置函数的返回值
  • 语法：return 值;
  • return后的值将会作为函数的执行结果返回。
    • 可以定义一个变量来接收该结果
  • 在return后面的值都不会执行
  • return后面不跟任何值，就会直接返回undefined
    • 如果函数中不写return，则也会返回undefined
  • return后面可以跟任意类型的值

  • function sum(a,b,c,d){
    	var bbb = a+b+c+d;
    	return bbb;
    }
    //定义的result的值就是函数的执行结果
    //函数返回什么，result就是什么
    
    //这里就相当于将结果保存在定义的result中，当想要用的时候在拿出来
    var result=sum(1,2,3,4);
    console.log("result=" + result);//拿出来用了

• 实参可以是任意的数据类型，也可以是一个对象
  • 当我们的参数过多时，我们可以将参数封装到一个对象中，然后通过对象传递
• 实参也可以是函数
  • wo
    • 函数对象
    • 相当于直接使用函数对象
  • wo（）
    • 调用函数
    • 相当于使用函数的返回值

• //实参是对象
  function wo(o){
    console.log("我是"+o.name+",我今年"+o.age+",我性别"+o.gender+",我家"+o.address);
  }
  //wo("ll",12,"fsadf","fsdaf");//注意顺序
  //创建一个对象
  var obj={
  	name:"于炀",
  	age:19,
  	gender:"男",
  	address:"HOG总部"
  }; //注意这里是声明，要加；号
  //wo(obj);
  //函数里面的o作为被封装的对象，代表的是定义的obj对象，所以在调用时，使用obj
      //思考：那么可不可以定义更多的对象，然后利用一个函数去引用他们
  
  //实参是函数
  function ni(a){
  	//console.log(a);
  }
  ni(wo(obj));
  //ni(function(){alert("你好");})

•  返回值的类型：
  • break：跳出当前循环
  • continue：跳出当次循环
  • return：会直接退出整个函数

  • function b(){
    	console.log("sdfsadfad");
    	for (var i=0 ; i<5 ; i++){
    		console.log(i);
    		if (i==2){
    			//break;
    			//continue;
    			//return;
    			// alert("sdfsdfdf");直接退出函数，所以不会执行
    		}
    	}
    	alert("sdfsdfdf");
    }
    //b();

• 返回值可以是任意的数据类型
  • 也可以是对象
  • 也可以是函数
  • 返回值为对象

function m(){
	//var obj={name:"sdfsadf"};
   // return obj;
	return {name:"sdfsadf"};
}
var a=m();
console.log(a);

//返回值为函数
function n(){
	//在函数内部再声明一个函数
	function l(){
		alert("我是l");
	}
	//将l函数对象作为返回值返回，所以这个return是在函数n里面的
	//此时n函数的返回值为l函数
	return l;
}
var k= n();  //声明一个变量k，用来调用函数n
console.log(k);  //输出k后得到的就是函数n，调用的是n函数里面的东西
k();  //直接调用l函数
n()();  //直接调用l函数

•  练习1：
  • 定义一个函数，判断一个数字是否是偶数，是为true，否为false

function isOu(num){
	return num%2==0;
/* if (num%2==0){
		return true;
	} else{
		return false;
	}*/
}
var result=isOu(2);
console.log(result);

•  练习2：
  • 定义一个函数，可以根据半径计算一个圆的面积，并返回计算结果

function mianji(r){
	return 3.14*r*r;
}
var a=mianji(10);
console.log(a);

3、函数对象的方法

• call()和apply()
  • 这两个方法都是函数对象的方法，需要通过函数对象来调用
  • 当对函数调用call()和apply()都会调用函数执行
  • 在调用call和apply()可以将一个对象指定第一个参数
    • 此时这个对象将会成为函数执行时的this
  • call() ：可以将实参在对象中依次传递
  • apply() ：需要将实参封装到一个数组里，统一传递

  • function fun(){
    	alert(this.name);
    }
    //fun.call();
    //fun.apply();
    //fun();
    
    var obj={
    	name:"obj",
    	hello:function(){
    		alert(this.name);
    	}
    };
    
    var obj2={name:"obj2"};
    //fun.call(obj);  //指定谁this就是谁，这里指定的是obj，所以this是obj
    //fun();  //this是window
    obj.hello.apply(obj2);
    
    function fun(a,b){
    	console.log("a="+a);
    	console.log("b="+b);
    	//alert(this);
    }
    var obj={
    	name:"obj",
    	hello:function(){
    		alert(this.name);
    	}
    };
    fun.call(obj,2,3);
    fun.apply(obj,[2,3]);
    var obj2={name:"obj2"};

• arguments ：
  • 在调用函数时，浏览器每次都会传递两个隐含的参数
    • 1、函数的上下文对象：this
    • 2、封装实参的对象：arguments
      • arguments是一个类数组对象，它也可以通过索引来操作数据，也可以获取长度
      • 在调用函数时，我们传递的实参都会在arguments中保存
      • arguments.length可以获取实参的长度
      • 即使不定义形参，也可以通过arguments来使用实参
        • arguments[0]  表示第一个实参
        • arguments[1]  表示第二个实参
      • 它里面有一个属性叫做callee
        • 这个属性对应一个函数对象，就是当前正在执行的函数对象
           

function fun(){
	//检查arguments是不是数组
	console.log(arguments instanceof Array);  //false
	console.log(Array.isArray(arguments));  //false
	console.log(arguments.length);
	console.log(arguments[1]);
	console.log(arguments.callee == fun);  //true
}
fun("heeee" , true);