【学习笔记16】JavaScript函数封装习题

笔记初发

1、书写一个函数, 求任意两个数字的和, 把结果以弹窗的形式展示

1. 书写一个函数
2. 需要参数吗?            -->需要
3. 需要几个参数?         —>两个
4. 函数要做什么?         -->求和
5. 然后弹窗的形式展示    -->alert(弹窗展示的值)

        function fn(num1, num2) {
            var sum = num1 + num2;

            // 向浏览器弹窗
            alert(sum);   // 300
        }
        fn(100, 200);
1
2
3
4
5
6
7

2、书写一个函数, 求任意两个数字的和, 把结果打印在控制台

1. 书写一个函数
2. 需要参数吗?         -->需要
3. 需要几个参数?      -->两个
4. 函数要做什么?      -->求和，打印在控制台

        function fn(a, b) {
            // 相当于钻了JS的漏洞
            var sum = a + b; 
            console.log(sum);
        }

        fn(1, 2)
1
2
3
4
5
6
7

3、书写一个函数, 求任意两个数字的和, 把结果输出在页面上

1. 书写一个函数
2. 需要参数吗?          -->需要
3. 需要几个参数?        -->两个
4. 函数要做什么?        -->求和，打印在页面

        function fn(a, b) {
            // 相当于钻了JS的漏洞
            var sum = a + b ;
            
            document.write(sum);
        }

        fn(1, 2)
1
2
3
4
5
6
7
8

        function fn(n) {

            // 计数器, 记录一下 if 是否执行
            var sum = 100;  
            for (var i = 2; i < n; i++) {   
                if (n % i == 0) { 
                    sum = 99 
                }
            }

            // 根据参数n是否为质数, 决定返回true还是false
            if (sum == 100) {
                // 如果sum == 100成立说明, for循环内部的if没有执行, 那么证明这个参数n 是质数
                return true
            } else if (sum == 99) {
                // 如果sum == 99成立说明, for循环内部的if执行了!!! 那么证明这个参数n不是质数
                return false
            }
        }
        var myFn = fn(7)    // true
        console.log(myFn)
        var myFn1 = fn(8)   //  false
        console.log(myFn1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4、判断一个数字是否为质数

    1. 书写一个函数
    2. 需要参数吗?      ---> 需要
    3. 需要几个参数?    ---> 1个
    4. 需要返回值吗?    ---> 需要, 最好是返回布尔值!    是质数返回 true    不是返回 false

    质数的概念
        一个数, 除了1和它本身之外, 没有任何数能被他整除  ---> 这样的数字就是质数
        一个数, 能给被除了1和它本身之外的某个数整除,     ---> 这样的数字不是质数
         7   /  2 3 4 5 6    --->    7 是质数
         8   /  2 3 4 5 6 7  --->    8 不是质数
         9   /  2 3 4 5 6 7 8    --->  9 不是质数
1
2
3
4
5
6
7
8
9
10
11

        // 循坏遍历 获取1~25的数字
        for (var n = 1; n <= 25; n++) {  
            // 计数器
            var sum = 0 

            for (var k = 2; k < n; k++) {
                if (n % k == 0) {
                    sum = 100
                }
            }

            if (sum !== 0) {
                // console.log(n, '不是质数')
            } else {
                console.log(n, '是质数')
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

        function fn(n) {

            // 计数器, 记录一下 if 是否执行
            var sum = 100;  
            for (var i = 2; i < n; i++) {   
                if (n % i == 0) { 
                    sum = 99 
                }
            }

            // 根据参数n是否为质数, 决定返回true还是false
            if (sum == 100) {
                // 如果sum == 100成立说明, for循环内部的if没有执行, 那么证明这个参数n是质数
                return true
            } else if (sum == 99) {
                // 如果sum == 99成立说明, for循环内部的if执行了!!! 那么证明 这个参数n不是质数
                return false
            }
        }
        var myFn = fn(7)    // true
        console.log(myFn)
        var myFn1 = fn(8)   //  false
        console.log(myFn1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5、封装一个函数, 判断一个数字是否为 水仙花数

1. 写个函数
2. 需要参数?      —> 需要
3. 需要几个?      —> 一个
4. 需要返回值?    —> 需要
5. 返回什么?      —> 布尔值

        function fn () { }
        var fn = function (n) {
            // 拿到各个位置上的数字
            var baiW = parseInt(n / 100)
            var shiW = parseInt(n / 10 % 10)
            var geW = n % 10

            // 求各个位置上的数字的三次方  三个位置上三次方的和
            var sum = baiW ** 3 + shiW ** 3 + geW ** 3

            // 判断和是否等于它自身 
            // 根据参数n是否为水仙花数, 决定返回的布尔值, 是的话返回true, 不是返回false
            if (sum == n) {
                // 是水仙花数
                return true
            } else {
                // 不是水仙花数
                return false
            }
        }

        var a = fn(154)
        console.log(a)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6、封装一个函数, 对一个四位数字加密

    加密规则:
            1. 每一位上的数字+5    然后使用10的余数替代
            2. 一三交换位置, 二四交换位置
    举例:
        输入1234
        1. 每一位上的数字+5     ===> 6789
        2. 使用10的余数代替     ===> 6789
        3. 一三和二四交换位置   ===> 8967

        输入 5655
        1. 每一位上的数字 +5     ===> 0100
        2. 使用10的余数代替      ===> 0100
        3. 一三和二四  交换位置  ===> 0001   (这里需要打印0001, 不能打印1)
1
2
3
4
5
6
7
8
9
10
11
12
13

1. 写一个函数
2. 需要参数         —> 需要
3. 需要几个参数?    —> 1个
4. 需要返回值?      —> 需要
5. 返回的是?        —> 加密后的数据

        function fn(n) {
            var qianW = (parseInt(n / 1000) + 5) % 10;
            var baiW = (parseInt(n / 100 % 10) + 5) % 10;
            var shiW = (parseInt(n / 10 % 10) + 5) % 10;
            var geW = (n % 10 + 5) % 10;

            return ('' + shiW + geW + qianW + baiW - 0);
        }
        var sum = fn(1234);
        console.log(1234, '加密后: ', sum);
1
2
3
4
5
6
7
8
9
10

7、封装一个函数, 求两个数字的最大公约数

1. 写一个函数
2. 需要参数吗?     —> 需要
3. 需要几个?       —> 2个
4. 需要返回值?     —> 需要
5. 返回什么?       —> 最大公约数

        function fn(a, b) {
            /**
             *  最大公约数
             *    两个数的所有约数中, 相同的, 称之为两个数的公约数,  其中最大的哪一个为最大公约数
             *
             *  什么是约数
             *      整数x除以整数y(y != 0) 除得的商正好是整数而没有余数，我们就说x能被y整除，或 y能整除x。
             *      x 称为y的倍数，y称为x的约数
            */
            for (var i = a; i >= 1; i--) {
                if (a % i == 0 && b % i == 0) {
                    return i;
                }
            }
        }
        var num = fn(8, 12);
        console.log(num);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

8、封装一个函数, 求两个数字的最小公倍数

        // 封装一个函数, 求两个数字的最大公约数
        function fn(a, b) {
            /**
             *  最大公约数
             *      两个数的所有约数中, 相同的, 称之为两个数的公约数,  其中最大的哪一个为最大公约数
             *
             *  什么是约数
             *      整数x除以整数y(y != 0) 除得的商正好是整数而没有余数，我们就说x能被y整除，或 y能整除x。
             *      x称为y的倍数，y称为x的约数
            */
            for (var i = a; i >= 1; i--) {
                if (a % i == 0 && b % i == 0) {
                    return i;
                }
            }
        }
        var num = fn(8, 12);
        console.log(num);

        // 封装一个函数, 求两个数字的最小公倍数
        function fn1(a, b) {
            /**
             *  数学概念:
             *      a * b == 最大公约数 * 最小公倍数
             *      8 * 12 == 4 * 24
             *          96 == 96
             *
             *  根据数学概念 转换等式
             *      a * b == 最大公约数 *  最小公倍数
             *      a * b /  最大公约数 == 最大公约数 * 最小公倍数 / 最大公约数
             *      a * b /  最大公约数 == 最小公倍数
            */
            return a * b / fn(a, b);
        }
        var myFn1 = fn1(8, 12)
        console.log(myFn1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36