js的函数应用

函数function

作用：
1.简化代码
2.方便维护
3.提高开发效率
4.提高了代码的复用性，减少代码冗余

• 格式：
  function 函数名（参数…）{
  函数执行的代码
  }
  【注意】函数先定义后调用
  分类：

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

示例：
函数的简化示例

       // 输入相同的数据。
        function dw(){
            document.write("八千里路");
            document.write("云和月");
            document.write("三十功名尘与土");
        }
        dw();
        dw();
        dw();

这里只需要输入dw（）；
就可以添加相同代码。

有参数无返回值

参数为
形参 形式上的参数。
实参 实际参数。
示例：

       // 求1-n的和,将结果输出到页面。
        function sum(n) {
            var sum = 0;
            for (var i = 1; i <= n; i++) {
               sum += i;
            }
            document.write(sum);
        }
        sum(100);

这里可以更改n的值进行更改所求的和

计算1到100的和。

无参数有返回值

返回值：对函数执行完成的结果的返回。
return:结束当前函数，并将return后面的值（表达式/变量）作为函数的运行结果返回。
当我们需要对函数的运算结果进行不同的处理时，需要将函数的结果返回。
示例

        // 求1-100的和,将结果输出到页面。
        function sum() {
            var sum = 0;
            for (var i = 1; i <= 100; i++) {
               sum += i;
            }
            return sum;
        }
        // 1.调用，将结果弹出
        var a = sum();
        // 2 调用，将结果输出到页面上
        document.write(a);
        // 3.调用 将结果输出到控制台。
        console.log(a);

这里输出页面一个输出控制台一个。

封装函数

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

示例：

        var arr = ["苏轼", "辛弃疾", "李白"];
        function joint(arr) {
            var str = "";
            for (var i = 0; i <= arr.length - 1; i++) {
                str += arr[i];
                if (i == arr.length - 1) continue
                str += "|";
            }
            return str;
        }
        alert(joint(arr));

实现插入字符串“|”拼接

---

这里让我们练习一下函数的运用

1. 编写一个函数，计算三个数字的大小，按从小到大顺序输出。

       function order(a,b,c) {
            var temp;
            if (a>b) {
                temp = a;
                a = b;
                b = temp;
            }
            if (b>c) {
                temp = b;
                b = c;
                c = temp;
            }
            if (a>b) {
                temp = a;
                a = b;
                b = temp;
            }
            var str = a+"<"+b+"<"+c;
            document.write(str);
        }
        order(5,4,3);

换位进行比较大小。

2. 获取0-1的随机数：
   Math.random()
   获取1-10就Math.random()*10
   示例：
   随机获取数字。

        //获取0——10的随机数
        var a = parseInt(Math.random() * 10);
        alert(a);

• 编写一个可以生成4位数字验证码的函数，将结果输出到页面上。

        function authCode() {
            //四位数要parseInt(Math.random()*10000)。
            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(authCode());

页面刷新一次改变一次随机四位数。

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

        function encryption(num) {
            // 取个位数
            var units = compute(num%10);
            // 十位数
            var tens = compute(parseInt(num/10)%10);
            // 百位
            var hundreds = compute(parseInt(num/100)%10);
            // 千位
            var kilobit = compute(parseInt(num/1000));
            return Number(""+units+tens+hundreds+kilobit);
        }
        function compute(num) {
            return (num+5)%10;
        }
        // isNaN() 可以判断一个变量是否为Not a number NaN
        var num = Number(prompt("请输入四位整数："));
        if (!isNaN(num)&&num>999&&num<10000) {
            var n = encryption(num);
            alert(n);
        }

输入1234进行加5除10求余数是6789，在反转过来结果为9876。

arguments储存实参

arguments是用来存储实参
比如：
示例

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

        sum(12, 5, 8, 10);

argumets 对sun（）里面的数进行取值。

作用域

作用域：变量存在的范围

• 全局变量
  直接写在Script标签中的变量，在页面中的任意位置都可以访问到。
  在页面打开创建，在页面关闭时销毁
• 局部变量
  局部变量是定义在函数内部的变量.这个变量只能在函数内使用.例外,函数中的形参也是局部变量.
  每一次调用时创建，调用结束会销毁。

【注意】
如果局部变量与全局变量重名，则使用局部变量。若函数内部没有找到该变量，则去全局变量中查找。

示例：

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

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

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

        }
        sum();

声明比较。

递归

递归：函数之间可以互相调用，如果函数内部调用了其自身，则我们称其为递归调用。

• 特点：
  1.函数自己调用自己
  2.一般情况下还有参数
  3.一般情况下有返回值
• 方法：
  1.找这一次计算与上一次计算的关系。
  2.调用自身
  3.找到函数结束的条件。
  示例:

       //  求n的阶乘
        function fac(n) {
             if (n==1) {
                 return n;
             }
             return n*fac(n-1);
        }
        alert(fac(10));

递归练习:
兔子繁殖问题：
设有一对新生兔子，从第四个月开始每个月初都会生一对兔子，新生的兔子从第四个月开始也会每个月初生一对兔子，按照这个规律，假设兔子没有死亡，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         

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

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

可以看出9个月有13只兔子。