function函数封装的各种案例分析

1. 利用函数封装[求数组的和]的 案例分析

<script>
        // 求数组的和函数
        // 要求:
        // 1. 封装一个函数名为 getSum 的函数
        // 2. 功能: 根据传入的**数组**，使得函数的返回值为从**数组中各项数字的和**
        // 3. 测试: 分别以document.write、console.log两种方式来输出函数返回的值

        //第一种办法
        //当利用了伪数组arguments,此时括号可以不填写内容
        function getSum() {

            let sum = 0
            //利用arguments去创建一个伪数组,当用户输入一些数字的时候,可以伪装成数组来求和即可
            for (let i = 0; i < arguments.length; i++) {
                sum += arguments[i] // 表示遍历数组里的每一个元素
            }
            return sum
        }
        let res = getSum(1, 2, 3, 4, 5) //注意这里输入的是个数而不是数组的形式
        document.write(res)


        // 第二种方法  正常利用数组方式去求和
        function getSum(a) {
            let sum = 0
            for (let i = 0; i < a.length; i++) {
                sum += a[i]
            }
            return sum
        }
        let res = getSum([1, 2, 3, 4, 5])
        console.log(res);
        document.write(res)
</script>

2. 用函数封装 [求若干参数的和及平均值] 的案例分析

<script>
        // 求若干参数的和 和 平均值的函数

        // 要求:

        // 1. 封装一个函数名为 getData 的函数
        // 2. 功能: 用户可以传入**任意数量的参数**，使得函数的返回值为**用户输入的若干参数的和**  和 **平均值**
        // 3. 测试: 分别以document.write、console.log两种方式来输出函数返回的值



        function getData(a) {
            // 凡是需要计算总和的  都要先创建一个箩筐去装  所以先创建 sum和avg 
            let sum = 0
            let average = 0
            for (let i = 0; i <= a.length; i++) { //因为是访问若干参数的和,所以用遍历数组来做
                sum += i
            }
            average = sum / a.length //平均值等于总和 / 数组长度的个数

            return [sum, average]  // 结果需要返回值给调用者 getData () 让用户自己决定用哪种方式输出
        }
        let res = getData([1, 2, 3, 4, 5])  //需要用一个res去装 getData的值 
        console.log(`和为${res[0]} ,平均值为 ${res[1]} `);
        document.write(`和为${res[0]} ,平均值为 ${res[1]} `)
</script>

3. 求圆的半径

 <script>
        // 求圆的面积函数

        // 要求:

        // 1. 封装一个函数名为 getArea 的函数
        // 2. 功能: 用户可以传入**一个半径值作为参数**，使得函数的返回值为 **圆形的面积（圆的面积=3.14\*r\*r）**
        // 3. 测试: 分别以document.write、console.log两种方式来输出函数返回的值
        let r = prompt('请输入一个圆的半径')
        function getArea(r) {
            return 3.14 * r * r
        }

        let res = getArea(r)
        console.log(res);
        document.write(res)
 </script>

4. 用函数封装冒泡排序

 <script>
        // 封装冒泡排序函数

        // 要求:

        // 1. 封装一个函数名为 getArr 的函数

        // 2. 功能: 用户可以传入**数组**，从小到大排序后返回新数组

        // 3. 调用2次函数并传入不同的数组，通过log的方式输出排序后的数组查看函数是否封装正确

        function getArr(arr) {
            //数组的下标是要从0开始的,由于i=1,所以在后面需要-1
            for (let i = 1; i <= arr.length - 1; i++) { //一定要<= 不然就只执行一次就结束了
                document.write(`这是轮了第${i}次`)

                for (let j = 1; j <= arr.length - i; j++) { //-i的意思是每一趟每换一次就减少1次长度
                    if (arr[j - 1] > arr[j]) {
                        let stmp = arr[j - 1]
                        arr[j - 1] = arr[j]
                        arr[j] = stmp
                    }
                }
            }
            return arr
        }
        let res = getArr([55, 11, 3, 66, 4])
        console.log(res);
        document.write(res)
 </script>

5.用户输入的秒数 转换为时分秒 不足两位补0 的案例分析

<script>
        /*
            小时：  h = parseInt(总秒数 / 60 / 60 % 24)
            分钟：  m = parseInt(总秒数 / 60 % 60 )
            秒数：  s = parseInt(总秒数 % 60)
        */

        // 用户输入的秒数 转换为时分秒 不足两位补0
        let times = +prompt('请您输入秒数')


        function getTime(time) {
            let h = parseInt(time / 60 / 60 % 24)
            let m = parseInt(time / 60 % 60)
            let s = parseInt(time % 60)

            // 补0的操作  ctrl+d 快速选中相同的内容
            h = h < 10 ? '0' + h : String(h)
            m = m < 10 ? '0' + m : String(m)
            s = s < 10 ? '0' + s : String(s)
            // s = s < 10 ? '0' + s : s.toString()

            // 不做任何处理 直接返回三个值
            return [h, m, s]
        }

        let res = getTime(times)
        console.log(res);
        document.write(`您输入的秒数为${time},转换的时间为：${res[0]}:${res[1]}:${res[2]}`)
    </script>