函数及应用例子

函数

作用

1.简化代码
2.方便维护
3.提高开发效率
4.提高了代码的复用性，减少代码冗余
格式：
function 函数名（参数…）{
函数执行的代码（函数体）
}
参数划分：

1. 形参：变量，没有固定值，可以被改变
2. 实参：常量，固定值，不可以被改变
   **【注意】**函数先定义后调用

分类

1.内置函数（官方提供的函数，系统自身拥有函数）
alert();
document.write();
console.log();
parseInt();
parseFloat();
2.自定义函数
根据参数和返回值的不同，可将函数分为四种。
1.无参数无返回值

function sum() {
            var sum = 0;
            for (var i = 1; i <= 100; i++) {
                sum += i;
            }
            document.write(sum);

        }
        sum();

2.有参数无返回值

function sum(n) {
            var sum = 0;
            for (var i = 1; i <= n; i++) {
                sum += i;
            }
            document.write(sum);
        }
        sum(100);

3.无参数有返回值

function sum() {
            var sum = 0;
            for (var i = 1; i <= 100; i++) {
                sum += i;
            }
            return sum;

        }
        var a = sum();
        alert(a);

4.有参数有返回值

function sum(n) {
            var sum = 0;
            for (var i = 1; i <= n; i++) {
                sum += i;
            }
            return sum;
        }
        var a = sum(100);
        alert(a);

封装函数

步骤：
1.确定函数的执行代码：函数体。
2.找出变量（不确定值。），将其设置为形参
3.如果需要对返回结果进行不同的处理，则定义返回值。

三个数比较大小

 		function compare(a, b, c) {
            var temp;
            if (a > b) {
                temp = a;
                a = b;
                b = temp;
            }
            //a与b比较，若a>b，则a与b的值交换，a一定比b小
            if (b > c) {
                temp = c;
                c = b;
                b = temp;
            }
            //b与c比较，若b>c，则b与c的值交换,c一定比b大
            if (a > b) {
                temp = a;
                a = b;
                b = temp;
            }
            //因为a一定比b小 、c一定比b大，那么就已经找到最大值了c,只需要让a与b在比较一次就可以了
            return a + "<" + b + "<" + c;
        }
        alert(compare(4, 8, 1));

如 4,8,1三个数分别为a,b,c，a与b 比较（a一定比b小），a=4、b=8；b与c 比较（c一定比b大），b=1、c=8；a与b 比较（a一定比b小），a=1、b=4，

随机生成四位数的验证码

方法1

   		// Math.random();
        // 获取0-1之间的随机数
        function encryption() {
            var code = parseInt(Math.random() * 10000);
            if (code < 10) {
                code = "000" + code;
            } else if (code < 100) {
                code = "00" + code;
            } else if (code < 1000) {
                code = "0" + code;
            }
            return code;
        }
        document.write(encryption())

方法2

		function encryption() {
            var code = "";
            for (var i = 0; i < 4; i++) {
                code += parseInt(Math.random() * 10);
            }
            return code;
        }
        document.write(encryption())

对密码加密

密码是一个四位整数,需要进行加密.加密算法为:
1.每个数字都加5,然后用除以10的余数替代该数字.
2.再讲数字的各个位数进行反转.,
编写这样一个函数,传入原数据,返回加密数据.
方法1

 		var num = prompt("请输入一个四位数！");
        var a = parseInt(num / 1000);
        var b = parseInt(num % 1000 / 100);
        var c = parseInt(num % 100 / 10);
        var d = num % 10;
        var arr = [a, b, c, d];

        function encryption(arr) {
            for (var i = 0; i < arr.length; i++) {
                arr[i] = (arr[i] + 5) % 10;
            }
            arr.reverse();
            
            var result = arr.join("&nbsp;")
            return result;
            
			//var str = "";
            // for (var i = 0; i < arr.length; i++) {
            //     str += arr[i];
            // }
            // return (str);
        }
        document.write(encryption(arr));
        console.log(typeof(encryption(arr)));

方法2

		function encryption(num) {
            var authCode = compute(parseInt(num / 1000));
            var hunderse = compute(parseInt(num % 1000 / 100));
            var tens = compute(parseInt(num % 100 / 10));
            var unit = compute(num % 10);
        }

        function compute(num) {
            return (num + 5) % 10;
        }
        var num = prompt("请输入一个四位数！");
        if (num < 10) {
            num = "000" + num;
        } else if (num < 100) {
            num = "00" + num;
        } else if (num < 1000) {
            num = "0" + num;
        }
        var result = encryption(num);

arguments

arguments：特殊的类数组对象，该对象按参数，索引包含的所有参数。
定义一个函数，参数的数量不固定
arguments是用来存储实参。
当调用函数时，函数内的实参就会存放在arguments中。
例子
利用arguments求和

 		function sum() {
            var num = 0;
            for (var i = 0; i < arguments.length; i++) {
                num += arguments[i];
            }
            return num;

        }
       var result = sum(1, 5, 6, 7, 8);
       alert(result);

作用域

作用域：变量存在的范围
全局变量
直接写在Script标签中的变量，在页面中的任意位置都可以访问到。
在页面打开创建，在页面关闭时销毁。
局部变量
局部变量是定义在函数内部的变量.这个变量只能在函数内使用.例外,函数中的形参也是局部变量.
每一次调用时创建，调用结束会销毁。
【注意】
如果局部变量与全局变量重名，则使用局部变量。若函数内部没有找到该变量，则去全局变量中查找。

		var a = 10;
        function sum() {
            console.log(a);
        }
        sum();

变量a是全局变量，在函数sum（）可以调用；

		var a = 10;
        function sum() {
            console.log(a);
            var a = 5;

        }
        sum();

函数体内的变量a是局部变量，在sum（）调用时会首先找函数体内的局部变量，有就会调用局部变量，函数体内的a虽然写在调用后面，但是在函数体内的变量声明，有一个工能，声明提升：变量声明无论是在函数体内的那个位置定义的，声明都会放在函数体最前面；

        function sum1() {
            console.log(a);
            var a = 5;
        }
         function sum2() {
        	var a;
            console.log(a);
            a = 5;
        }
        //sum12函数体内的代码相当于与sum2函数体内的代码，这就是函数体内的声明提升

		var a = 10;

        function sum(a) {
            console.log(a);
        }
        sum();

这时函数体内调用的a是函数sum(a)内的形参a,所以结果为undefined。

		var a = 10;
		var b = 10;
        function sum() {
            console.log(a);
            var b = 5;
        }
        console.log(b);
        sum();

递归

递归：函数之间可以互相调用，如果函数内部调用了其自身，则我们称其为递归调用。
特点：
1.函数自己调用自己
2.一般情况下还有参数
3.一般情况下有返回值.
方法：
1.找这一次计算与上一次计算的关系。
2.调用自身
3.找到函数结束的条件。
兔子繁殖问题
设有一对新生兔子，从第四个月开始每个月初都会生一对兔子，新生的兔子从第四个月开始也会每个月初生一对兔子，按照这个规律，假设兔子没有死亡，n（n<=20）个月月末后共有多少对兔子。

                    一月兔   二月兔  	三月兔   成熟兔       总数

第一个月 1 0 0 0 1
第二个月 0 1 0 0 1
第三个月 0 0 1 0 1
第四个月 1 0 0 1 2
第五个月 1 1 0 1 3
第六个月 1 1 1 1 4
第七个月 2 1 1 2 6
第8个月 3 2 1 3 9
第9个月 4 3 2 4 13
第10个月 6 4 3 6 19

本月成熟兔：上个月的成熟兔+上上上个月的成熟兔

function rabbit(n) {
             if (n<4) {
                 return 1;
             }
             return rabbit(n-1)+rabbit(n-3);
         }
         alert(rabbit(9));

解释
rabbit(n-1)+rabbit(n-3)会调用函数rabbit（n），rabbit(n-1)此时的n-1就是**rabbit（n）中的n、rabbit(n-3))此时的n-3就是rabbit（n）**中的n，如n为9；return rabbit(8)+rabbit(6)；，