JavaScript关于函数部分详解、以及几种特殊的函数（回调函数、递归函数）

JavaScript函数

JS中的函数概念非常重要，是我们日常学习中使用最多的东西，所以掌握函数这一概念十分重要。

函数

函数中可以封装一些功能（代码），在需要时可以执行这些功能（代码），函数中可以保存一些代码，在需要的时候调用，函数也是一个对象。

一个函数由以下部分组成：

	    function 函数名([参数])
		{
		   函数体语句;
		}

注意：

• function是一个关键字需要全部小写
• 函数名：是一个标识符 建议使用驼峰命名 做到见名知义
• 函数可以有参数也可以没有参数 可以有多个参数 参数之间用逗号分隔
• { }表示函数的控制范围 不能省略
• 函数体语句可以有多条 建议一个函数只完成一个功能

函数表达式：

            var 函数名 = function([形参]){
				函数体语句;
            }

内聚：模块内部结合的紧密程度
耦合：模块之间结合的紧密程度

调用函数

封装到函数中的代码不会立即执行，函数中的代码会在函数调用的时候执行，通常有两种调用函数的方法：

• 函数名([参数])
• 事件名 = 函数名 ([参数])

        function fun1() {
            console.log('这是我第一个函数')
        }
        fun1()// 调用函数

函数的参数

函数的参数分为形参和实参

• 形参(形式参数)：在定义函数时出现在函数首部的参数，可以看作是不用声明的变量，在定义函数时，形参只是占位符，没有确定的值。
• 实参(实际参数)：函数调用时出现在函数首部的参数，是实际的值。

在调用函数时可以在()中指定实参，实参将会赋值给对应的形参。
注意：

• 当形参的个数比实参的个数多时函数不会报错，多余的形参会是undefined类型。
• 当实参的个数比形参的个数多时，多余的实参会被忽略。
• 调用函数时解析器不会检查实参的类型 实参可以是任意数据类型。
• 实参向形参传递数据是单向的，形参的改变不会影响到实参。

可以以通过下面这个函数清晰的看到函数调用时参数传递的过程

        function swap(a,b){
            console.log("1 形参a和b交换之前："+a+","+b)
            var t = a
            a = b
            b = t
            console.log("2 形参a和b交换之后："+a+","+b)
        }
        var m = 15,n = 25;
        console.log("3 调用用swap之前，实参m和n的值："+m+","+n)
        swap(m,n)// 函数调用
        console.log("4 调用用swap之后，实参m和n的值："+m+","+n)

函数的返回值

函数的处理结果是通过return语句返回，return语句会将函数的运算结果返回给函数的调用者，return后的语句都不执行，如果return语句后面不跟任何值相当于返回一个undefined

        // 定义函数用来计算n!
        function fun(n){
            var s = 1
            for(var i=1;i<=n;i++){
                s = s*i
            }
            return s //变量s中的值就是fun函数运算的结果
        }
        var t = prompt("请输入一个整数：")
        var s1 = fun(t) //函数调用
        console.log(t+"的阶乘"+s1)

这里注意不能直接在控制台上输出s,以内s是在函数内部用var关键字定义的，属于局部变量，函数运行完后变量s被销毁。

闰年练习

        // 定义函数 功能是判断传入年份是否是闰年 调用该函数输出公元1500-2020之间的所有闰年
        // 要求每行输出10个年份
        function fun(n){
            if((n%400==0)||(n%4==0 && n%100!=0)){
                return true;
            }
            return false;
        }        
        // 函数调用
        var count = 0;
        var str = '';
        for(var i=1500;i<=2020;i++){
            if(fun(i)){
                count++;
                str += i+'\t';
            }
            if(count%10==0){
                str += '\n';
            }
        }
        console.log(str)

函数的内置对象arguments

arguments 保存了函数接收的所有实参，arguments是以数组的方式存放所有接收到的实参

        function fn(){
            console.log(arguments);
            console.log(arguments.length);
        }
        fn(23,22);

回调函数

将一个函数A作为参数传递给函数B，在函数B内对函数A进行调用，函数A称为回调函数。

        function fun1(a,b){
            return a+b;
        }// 函数fun1是回调函数
        function cal(m,n,fn){
            return fn(m,n)
        }
        //调用函数
		var s1 = cal(15,16,fun1)
        console.log("s1="+s1)

递归函数

递归函数的主要思想就是自己调用自己

使用递归的前提条件：

• 问题可以分解(即复杂的问题逐步分解成简单的问题)
• 分解得到的新问题的解法和原来老问题的解法是相同的
• 必须有明确的终止条件

递归过程

• 自上而下分解问题
• 自下而上回溯得到问题的解

递归法求n的阶乘

        function fun(n){
            if(n==1){ // 递归结束的条件
                return 1;
            }
            return n*fun(n-1); // 递归调用 函数自己调用自己
        }
        var k = prompt("请输入一个整数：");
        var n = parseInt(k);
        if(isNaN(n)){
            console.log("输入的值不合法");
        }else{
            console.log(n+"的阶乘为"+fun(n));
        }

递归法求斐波拉契数列前20项

        // 使用递归函数输出斐波拉契数列前20项
        // 1 1 2 3 5 8 13...
        function fib(n){
            if(n==1||n==2){
                return 1;
            }
            return fib(n-1)+fib(n-2);
        }
        var str = '';
        for(var i=1;i<=20;i++){
            str += fib(i)+'\n';
        }
        console.log(str);

递归法求1+2+3+…+100

        // 求1+2+3+...+100
        function fun(n){
            if(n==1){
                return 1
            }
            return fun(n-1)+n
        }
        console.log(fun(100))