Sunny

# 例子

写一个函数 告知你所选定的小动物的叫声

function scream(animal) {
        switch (animal) {
            case "dog":
                document.write('wang!');
            case "cat":
                document.write('miao!');
            case "fish":
                document.write('ovo~');
                return;
        }
    }
1
2
3
4
5
6
7
8
9
10
11

# 例子

写一个函数 实现加法计数器

function sum() {
        var result = 0;
        for (var i = 0; i < arguments.length; i++) {
            result += arguments[i];
        }
        console.log(result);
    }
     //arguments [1,2,3,4,5,6,7,8,9];
    sum(1, 2, 3, 4, 5, 6, 7, 8, 9);
1
2
3
4
5
6
7
8
9

# 求阶乘（递归法）

function jc(n) {
        if (n == 1) {
            return 1; //出口
        }
        return n * jc(n - 1);//规律
    }
1
2
3
4
5
6

阶乘规律 mul(5);

mul(5) ===> 5 * mul (4);

mul(4) ===> 5 * mul (3);

mul(3) ===> 5 * mul (2);

mul(2) ===> 5 * mul (1);

递归

递归就是return规律

1.找规律 2.找出口

特点 递归唯一的好处只能简化代码

递归的规律就是 先执行的 最后才访问完 比如求mul(5)他会先求mul(1)然后2最后直到5才返回(影响效率)

# 斐波那契数列

规律：

fb(5) == > fb(4) + fb(3);

fb(4) == > fb(3) + fb(2);

fb(3) == > fb(2) + fb(1);

通式：fb (n) == fb(n - 1) + fb(n - 2);

function fb(n) {
        if (n == 1 || n == 2) {
            return 1;            //出口
        }
        return fb(n - 1) + fb(n - 2);   //规律
    }
1
2
3
4
5
6

# 判断一个数是不是奇数

function isPrime(n) {
        if (n < 2) {
            return false;
}
        for (var i = 2; i < n; i++) {
            if (n % i === 0) {
                return false;
            }
        }
        return true;
    }
    console.log(isPrime(2));
1
2
3
4
5
6
7
8
9
10
11
12

# 数组的求和

function sumOfArray(arr) {
        var sum = 0;
        for (var i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
    console.log(sumOfArray([1, 2, 3, 4, 5, 6, 7, 8, 9]));
1
2
3
4
5
6
7
8

# 求一个数组中最大的值

得到数组中的最大值，如果数组长度为0，则返回undefined

function maxOfArray(arr) {
        if (arr.length === 0) {
            return;
        }
var max = arr[0];
        for (var i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
    }
    return max;
    console.log(maxOfArray([34, 6, 76, 22, 1, 222]));
1
2
3
4
5
6
7
8
9
10
11
12
13

# 求一个数组中最小的值

得到数组中的最大值，如果数组长度为0，则返回undefined

function minOfArray(arr) {
        if (arr.length === 0) {
            return;
        }
var min = arr[0];
        for (var i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
    }
            return min;
    console.log(minOfArray([34, 6, 76, 22, 1, 222]));
1
2
3
4
5
6
7
8
9
10
11
12
13

# 判断该年是不是闰年

4年一闰，百年不闰；400年一闰

function isLeep(year) {
        return (year % 4 === 0 && year % 100 !=== 0 || year % 400 === 0);
    }
    console.log(isleep(2000));
1
2
3
4

# 函数作用域

var a = 123;
//此时的 a 为全局变量
function test() {
var b = 123;
//此时的 b 为局部变量
docoment.write(a);
//在里面可以访问外面的a  但是在外面的a不可以访问里面的b
}
1
2
3
4
5
6
7
8

← 作用域 →