JavaScript脚本语言 - 函数（细节统计）

函数（Java中方法）

声明函数

fuction 函数名(){
	//函数体
}

举例

    <script>
        function getSum(start,end){
            var sum = 0;
            for (var i = start; i <= end; i++){
                sum+= i;
            }
            console.log(sum);
        }
        getSum(1,100);
        
    </script>

细节(实参个数不同)

• 函数名一般为动词，遵循Java驼峰法命名

• 函数的参数可以有，也可以没有、个数不限

• 声明函数的时候，函数名括号里面的是形参，形参的默认值为undefined

形参和实参个数不匹配问题(注意)

参数个数	说明
实参个数等于形参个数	输出正确结果
实参个数多于形参个数	只取到形参的个数
实参个数小于形参个数	多的形参定义为undefined，结果为NaN

    <script>
        function getSum(start,end){
            var sum = start + end;
            console.log(sum);
        }
        //1.实参个数一致情况
        getSum(1,2);      //3
        //2.实参的个数多余形参的个数
        getSum(1,2,3);      //3
        //3.实参的个数小于形参的个数
		//形参可以看作是不用声明的变量，end 是一个变量但是没有接受值，结果就是undefined
		//1 + undefined = NaN
        getSum(1);          //NaN
        
    </script>

函数的返回值（同java，需要注意语法）

function 函数名(){
	return 需要返回的结果；
}

• 只要函数遇到return，就把后面的结果返回给函数的调用者，函数名（） = return后面的结果

function getResult(){
	return 666;
}
console.log(getResult());	//666

案例

求数组最大值

    <script>
        var arr = [1,2,4,3,5];
        function getMax(arr){
            var Max = arr[0];
            for (var i = 1; i < arr.length;i++){
                if(Max < arr[i]){
                    Max = arr[i];
                }
            }
            return Max;
        }
        console.log(getMax(arr));
        
    </script>

细节(return)

function fn(num1,num2){
	return num1,num2;	//返回最后一个值
}
console.log(fn(1,2));	//2

数组接收（return）

    <script>
        function getResult(num1,num2){
            return [num1 + num2, num1 - num2, num1 * num2, num1 /num2];
        }
        var re = getResult(1, 2);
        console.log(re);	//(4) [3, -1, 2, 0.5]
        
    </script>

• 我们的函数如果有return 则返回的是 return 后面的值，如果函数么有 return 则返回undefined

function fun1(){
	return 666;
}
console.log(fun1());	//666

function fun2(){

}
console.log(fun2());	//undefined

arguments的使用

当我们不确定有多少个参数传递的时候，可以用arguments来获取。在JavaScript中,arguments实际上它是当前函数的一个内置对象。所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参。

举例

function fn(){
	console.log(arguments);
}
fn(1,2,3);

1. Arguments(3) [1, 2, 3, callee: *ƒ, Symbol(Symbol.iterator): *ƒ*]*

2. 1. 0: 1
   2. 1: 2
   3. 2: 3
   4. callee: ƒ fn()
   5. length: 3
   6. Symbol(Symbol.iterator): ƒ values()
   7. [[Prototype]]: Object

arguments展示形式是一个伪数组，因此可以进行遍历。伪数组具有以下特点：

• 具有length属性
• 按索引方式存储数据
• 不具有数组的push，pop等方法

伪数组

1. 具有数组的length属性
2. 按照索引的方式进行存储的
3. 他没有真正数组的一些方法 pop（） push（）等等
4. 只有函数才有arguments对象，而且是每个函数都内置好了这个arguments

arguments函数举例

     <script>
        function getMax(){
            var max = arguments[0];
            for (var i = 1; i <arguments.length;i++){
                if(arguments[i] > max){
                    max = arguments[i];
                }
            }
            return max;
        }
        console.log(getMax(1,2,3,4,5)); //5 
        console.log(getMax(1,2,3,7,5)); //7
    </script>

函数调用函数

    <script>
        function fn1(){
            console.log(1);
            fn2();
        }
        fn1();
        function fn2(){
            console.log(2);
            fn1();
        }
    
    </script>

判断闰年函数

    <script>
        var getYear = prompt('请输入年份');
        
        function getDays(year){
            if (year % 400 == 0 || year % 100 != 0 && year % 4 == 0){
                var day = 29;
            }else{
                var day = 28;
            }
            return day;
        }
        
        alert(getDays(getYear));

    </script>

判断闰年函数（修正版）

    <script>
        backDay();
        function backDay(){
            var year = prompt('请输入年份');
            if (getDays(year)){
                alert('闰年，29天');
            }else {
                alert('平年，28天');
            }
        }

        function getDays(year){
            var flag = true;
            if (year % 400 == 0 || year % 100 != 0 && year % 4 == 0){
                return flag;
            }else{
                flag = false;
                return flag;
            }
        }
    </script>

函数的两种命名方式

1.利用函数关键字自定义函数（命名函数）

function fn(){
	
}
fn();

2.函数表达式(匿名函数)

• var 变量名 = function(){};

var fun = function(){
	console.log('我是函数表达式');
}
fun();

1. fun是变量名 ，不是函数名
2. 函数表达式声明方式跟声明变量差不多，只不过变量里面存的是值，而函数表达式里面存的是函数
3. 函数表达式也可以进行传递参数