JavaScript函数

---

前言

函数是一个把一些需要重复使用的代码封装起来，便于我们重复调用，分块及简化代码的对象

---

一.创建一个函数对象

方法一：
将要封装的代码以字符串的形式传递给构造函数（不推荐）

  		var fun=new Function("console.log('Hello World');");
  		 //封装到函数中的代码不会立即执行，函数中的代码会在函数调用时再执行
        fun();//Hello World

函数对象具有所有普通对象所具有的功能

  		var fun=new Function("console.log('Hello World');");
        fun();//Hello World
        fun.hello="你好";
        console.log(fun.hello);//你好
        console.log(typeof fun);//function
        console.log(typeof fun());//Hello World  
        						  //undefined
        console.log(fun instanceof Function);//true

方法二：
使用函数声明来创建一个函数

语法：
	function 函数名 ( [形参1，形参2，形参3，···，形参n] ) {
							语句···
							}

注：[ ]中的内容表示可选，即函数中的参数可以有多个，也可以没有
eg：

  		function fun(){
            console.log("这是函数声明创建的函数");
        }
        fun();//这是函数声明创建的函数

方法三：
使用函数表达式来创建一个函数（匿名函数）

语法:
	var 变量 = function ( [ 形参1，形参2，···，形参n ] ) {
			语句···
			}

eg：

		var fun = function(){
            console.log("我是匿名函数中封装的代码");
        }
        fun();//我是匿名函数中封装的代码

二.函数的参数

可以在函数的（）中指定一个或多个形参（形式参数），多个形参之间使用 ，隔开，声明形参就相当于在函数内部声明了对应的变量，但是并不赋值

eg：

   		function sum(a,b){
            console.log(a+b);
        }
        //在调用函数时，可以在（）中指定实参（实际参数），实参将会赋值给函数中对应的形参
        sum(1,2);//3

调用函数时解析器不会检查实参的类型，所以要注意，是否有可能会接收到非法的参数，如果有可能，则需要对参数进行类型的检查
eg：

   		function sum(a,b){
            console.log(a+b);
        }
        //string类型与number类型作加法，会先将number——>string,然后再和字符串拼串
        sum(123,"hello");//123hello
        //boolean——>number true=1,false=0
        sum(true,false);//1

在调用函数时，解析器也不会检查实参的数量，多余的实参将不会被赋值，如果实参数量少于形参数量，则没有对应实参的形参将是undefined
eg：

   function sum(a,b){
            console.log(a+b);
        }
        sum(123,456,"hello",true,null);//579
        sum(123);//NaN   123+undefined=NaN

函数的实参可以是任意的数据类型（包括对象）

三.函数的返回值

可以使用return来设置函数的返回值

语法：return 值

eg：

	function sum(a,b,c){
            var d=a+b+c;
            return d;
        }

return后的值将会作为函数的执行结果返回，可以定义一个变量，来接收该结果

eg：

		function sum(a,b,c){
            var d=a+b+c;
            return d;
        }
		//变量result的值就是函数的执行结果，函数返回什么result的值就是什么
		var result=sum(4,7,8);

在函数中return后的语句都不会执行

        function sum1(a, b, c) {
            var d = a + b + c;
            return d;
            d=d+1;//这条语句不执行
        }
        console.log(sum1(1, 2, 3)); //6

        function sum2(a, b, c) {
            var d = a + b + c;
            var d=1;//这条语句会执行
            return d;
        }
        console.log(sum2(1, 2, 3)); //1

如果return语句后不跟任何值（即：return; ），就相当于返回一个undefined

 		function sum3(a, b, c) {
            var d = a + b + c;
            return;
        }
        console.log(sum3(1, 2, 3)); //undefined

如果函数中不写return，则也会返回undefined

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

return后可以跟任意类型的值（即：返回值可以是任意的数据类型，可以是一个对象，是一个函数）

  		var result = alert("hello");
        console.log(result);//undefined

实参可以是一个对象，也可以是一个函数

  		function fun(a){
            console.log("a="+a);
        }
        function area(r){
            return 3.14*r*r;
        }
        fun(area);//a=function area(r){
                 //       return 3.14*r*r;
                //    }
        fun(area(10));//314

立即执行函数
函数定义完，立即被调用，立即执行函数只会执行一次
eg：

//方式一：
  		(function(a,b){
            console.log(a+b);
        })(123,456);//579
//方式二：
		 (function(a,b){
            console.log(a+b);
        }(123,456));//579

四.方法

对象的属性可以是任何的数据类型，也可以是个函数，如果一个函数作为一个对象的属性保存，那么我们称这个函数为这个对象的方法，调用这个函数就说调用对象的方法。
eg：

//使用new关键字创建对象
		var obj=new Object();
        obj.name="孙悟空";
        obj.age=18;
        obj.sayName=function(){
            console.log(obj.name);
        };
        obj.sayName();//孙悟空
//使用字面量创建对象
   		var obj2={
            name:"猪八戒",
            age:20,
            sayName:function(){
                console.log(obj2.name);
            }
        };
        obj2.sayName();//猪八戒

五.函数的声明提前

使用函数声明形式创建的函数，即

function 函数名 (){
	语句···
}

它会在所有的代码执行之前就被创建，所以我们可以在函数声明之前来调用函数

使用函数表达式所创建的函数

var fun=function(){
	语句···
};

不会被声明提前，不能再声明前调用

        fun();//undefined
        var a=123;
        function fun(a){
           console.log(a);
            a=456;
        }
        fun();undefined
        console.log(a);//123

上面这个例子中，函数fun定义了形参，这就相当于在函数作用域中定义了变量a，在输出a时，此时并未给a赋值，于是输出了undefined，而最后一条语句输出123，是因为全局作用域中的变量无法访问函数作用域中的变量