文章目录

14 - 什么是函数

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>14 - 什么是函数</title>
    <!-- 
        1. 函数的概念
        ============
        在 JS 里面，可能会定义非常多的相同代码或者功能相似的代码，这些代码可能需要大量重复使用。
        虽然 for循环语句也能实现一些简单的重复操作，但是比较具有局限性，此时我们就可以使用 JS 中的函数。
        函数： 就是封装了一段 可被重复调用执行的代码块。 通过此代码块可以实现大量代码的重复使用。
     -->
    <script>
        // 1. 求 1~100的累加和
        var sum = 0;
        for (var i = 1; i <= 100; i++) {
            sum += i;
        }
        console.log(sum); // 5050

        // 2. 求 10~50的累加和
        var sum = 0;
        for (var i = 10; i <= 50; i++) {
            sum += i;
        }
        console.log(sum); // 1230

        // 3. 函数就是封装了一段可以被重复执行调用的代码块 目的： 就是让大量代码重复使用
        function getSum(num1, num2) {
            var sum = 0;
            for (var i = num1; i <= num2; i++) {
                sum += i;
            }
            console.log(sum); 
        }
        getSum(1, 100); // 5050
        getSum(10, 50); // 1230
        getSum(1, 1000); // 500500
    </script>
</head>
<body>

</body>
</html>

15 - 函数的使用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>15 - 函数的使用</title>
    <!-- 
        2. 函数的使用
        ============
        函数在使用时分为两步：声明函数和调用函数。

        2.1 声明函数
        -----------

        ```JavaScript
        // 声明函数
        function 函数名() {
            //函数体代码
        }
        ```

        - function 是声明函数的关键字, 必须小写
        - 由于函数一般是为了实现某个功能才定义的， 所以通常我们将函数名命名为动词，比如 getSum

        2.2 调用函数
        -----------
        
        ```JavaScript
        // 调用函数
        函数名(); // 通过调用函数名来执行函数体代码
        ```

        - 调用的时候千万 不要忘记添加小括号
        - 口诀：函数不调用，自己不执行。
        注意：声明函数本身并不会执行代码，只有调用函数时才会执行函数体代码。

        知识总结
        -------
        - 函数的声明：
            function  函数名(参数1，参数2) {
                封装的代码块  
            }
        - 函数的调用： 函数名( )

     -->
    <script>
        // 函数使用分为两步： 声明函数 和 调用函数
        // 1. 声明函数
        // function 函数名() {
        //     // 函数体
        // }
        function sayHi() {
            console.log('hi~~');

        }
        // (1) function 声明函数的关键字 全部小写
        // (2) 函数是做某件事情，函数名一般是动词 sayHi 
        // (3) 函数不调用自己不执行
        // 2. 调用函数
        // 函数名();
        sayHi(); // hi~~
        // 调用函数的时候千万不要忘记加小括号
    </script>
</head>
<body>

</body>
</html>

16 - 利用函数封装求1~100的和

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>16 - 利用函数封装求1~100的和</title>
    <!-- 
        2.3 函数的封装
        -------------

        - 函数的封装是把一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口
        - 简单理解：封装类似于将电脑配件整合组装到机箱中 ( 类似快递打包）

        案例：利用函数计算1-100之间的累加和
        --------------------------------

        2.4 提问
        --------
        1. 函数是做什么的（作用）？
        2. 声明函数用什么关键词？ 
        3. 如何调用函数？ 
        4. 封装是什么意思？
     -->
    <script>
        // 1. 声明函数
        function getSum() {
            var sum = 0; // // 准备一个变量，保存数字和
            for (var i = 1; i <= 100; i++) {
                sum += i; // // 把每个数值 都累加 到变量中
            }
            console.log(sum); 

        }
        // 2. 调用函数
        getSum(); // 5050
        getSum(); // 5050
    </script>
</head>
<body>

</body>
</html>

17 - 带参数的函数

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>17 - 带参数的函数</title>
    <!-- 
        3. 函数的参数
        ============

        3.1 形参和实参
        -------------
        在 声明函数时 ，可以在函数名称后面的小括号中添加一些参数，这些参数被称为 形参 ，
        而在 调用该函数时 ，同样也需要传递相应的参数，这些参数被称为 实参 。

        参数                          说明
        形参      形式上的参数 函数定义的时候 传递的参数 当前并不知道是什么
        实参      实际上的参数 函数调用的时候传递的参数 实参是传递给形参的

        参数的作用 : 在 函数内部 某些值不能固定，我们可以通过参数在 调用函数时传递 不同的值进去。

        在 声明函数时 ，可以在函数名称后面的小括号中添加一些参数，这些参数被称为 形参 ，
        而在 调用该函数时 ，同样也需要传递相应的参数，这些参数被称为 实参 。
        
        ```JavaScript
        // 带参数的函数声明
        function 函数名(形参1, 形参2 , 形参3...) { // 可以定义任意多的参数，用逗号分隔
            // 函数体
        }
        // 带参数的函数调用
        函数名(实参1, 实参2, 实参3...);
        ```

        知识总结
        -------
        - 参数的作用：
            - 在函数封装的代码块中，使用参数可以在调用函数时修改指定数据，来完成不同的操作
        - 形参：
            - 在函数定义时，设置用来接收函数调用时传过来的数据
        - 实参：
            - 在函数调用时，用户在小括号中传入的数据，可被形参接收，运用到函数内部的调用中
     -->
    <script>
        // 1. 函数可以重复相同的代码
        // function cook() {
        //     console.log('酸辣土豆丝');
        // }
        // cook(); // 酸辣土豆丝
        // cook(); // 酸辣土豆丝

        // 2. 我们可以利用函数的参数实现函数重复不同的代码
        // function 函数名(形参1,形参2...) { // 在声明函数的小括号里面是 形参 （形式上的参数）
        // 
        // }
        // 函数名(实参1,实参2...); // 在函数调用的小括号里面是实参（实际的参数）

        // 3. 形参和实参的执行过程
        function cook(aru) { // 形参是接受实参的  aru = '酸辣土豆丝' 形参类似于一个变量
            console.log(aru);
        }
        cook('酸辣土豆丝'); // 酸辣土豆丝
        cook('大肘子'); // 大肘子
        // 4. 函数的参数可以有，也可以没有个数不限
    </script>
</head>
<body>

</body>
</html>

18 - 利用函数求任意两个数的和

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>18 - 利用函数求任意两个数的和</title>
    <!-- 
        案例：利用函数求任意两个数的和
        ----------------------------

        3.2 函数参数的传递过程
        ---------------------

        ```JavaScript
        // 声明函数
        function getSum(num1, num2) {
            console.log(num1 + num2);
        }
        // 调用函数
        getSum(1, 3); // 4
        getSum(6, 5); // 11
        ```

        1. 调用的时候实参值是传递给形参的
        2. 形参简单理解为： 不用声明的变量
        3. 实参和形参的多个参数之间用逗号(,)分隔
     -->
    <script>
        // 1. 利用函数求任意两个数的和
        function getSum(num1, num2) {
            console.log(num1 + num2);

        }
        getSum(1, 3); // 4
        getSum(3, 8); // 11
        
        // 2. 利用函数求任意两个数之间的和
        function getSums(start, end) {
            var sum = 0;
            for (var i = start; i <= end; i++) {
                sum += i;
            }
            console.log(sum);

        }
        getSums(1, 100); // 5050
        getSums(1, 10); // 55
        
        // 3. 注意点
        // (1) 多个参数之间用逗号隔开
        // (2) 形参可以看做是不用声明的变量
    </script>
</head>
<body>

</body>
</html>

19 - 函数形参实参个数匹配

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>19 - 函数形参实参个数匹配</title>
    <!-- 
        3.3 函数形参和实参个数不匹配问题
        ------------------------------
            参数个数                说明
        实参个数等于形参个数      输出正确结果
        实参个数多于形参个数      只取到形参的个数
        实参个数小于形参个数      多的形参定义为undefined，结果为NaN

        ```JavaScript
        function sum(num1, num2) {
         console.log(num1 + num2);
        }
        sum(100, 200); // 形参和实参个数相等，输出正确结果
        sum(100, 400, 500, 700); // 实参个数多于形参，只取到形参的个数
        sum(200); // 实参个数少于形参，多的形参定义为undefined，结果为NaN
        ```

        注意：在JavaScript中，形参的默认值是undefined。

        3.4 小结
        --------
        - 函数可以带参数也可以不带参数
        - 声明函数的时候，函数名括号里面的是形参，形参的默认值为 undefined
        - 调用函数的时候，函数名括号里面的是实参
        - 多个参数中间用逗号分隔
        - 形参的个数可以和实参个数不匹配，但是结果不可预计，我们尽量要匹配

		知识总结
        --------
        - 如果实参的个数多余形参，形参如何接收实参？
            - 如果实参的个数多余形参，形参将按照顺序依次接收实参，剩余的实参不被接收值
        - 如果实参的个数少于形参，形参如何接收实参
            - 如果实参的个数少于形参，形参将按照顺序依次接收实参，多余的形参接收不到实参，默认值为undefined
     -->
    <script>
        // 函数形参实参个数匹配
        function getSum(num1, num2) {
            console.log(num1 + num2);

        }
        // 1. 如果实参的个数和形参的个数一致 则正常输出结果
        getSum(1, 2); // 3

        // 2. 如果实参的个数多于形参的个数  会取到形参的个数 
        getSum(1, 2, 3); // 3

        // 3. 如果实参的个数小于形参的个数  多于的形参定义为undefined  最终的结果就是 NaN
        // 形参可以看做是不用声明的变量  num2 是一个变量但是没有接受值  结果就是undefined 
        getSum(1); // NaN
        // 建议 我们尽量让实参的个数和形参相匹配
    </script>
</head>
<body>

</body>
</html>

20 - 函数的返回值

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>20 - 函数的返回值</title>
    <!-- 
        4. 函数的返回值
        ==============

        4.1 return语句
        --------------

        有的时候，我们会希望函数将值返回给调用者，此时通过使用 return 语句就可以实现。
        return 语句的语法格式如下：

        ```JavaScript
        // 声明函数
        function 函数名（）{
            ...
            return 需要返回的值；
        }
        // 调用函数
        函数名(); // 此时调用函数就可以得到函数体内return 后面的值
        ```

        - 在使用 return 语句时，函数会停止执行，并返回指定的值 
        - 如果函数 没有return ，返回的值是 undefined

        有的时候，我们会希望函数将值返回给调用者，此时通过使用 return 语句就可以实现。
        例如，声明了一个sum()函数，该函数的返回值为666，其代码如下：

        ```JavaScript
        // 声明函数
        function sum（）{
            ...
            return 666； 
        }
        // 调用函数
        sum(); // 此时 sum 的值就等于666，因为 return 语句会把自身后面的值返回给调用者
        ```
     -->
    <script>
        // 1.函数是做某件事或者实现某种功能
        // function cook(aru) {
        //     console.log(aru);
        // }
        // cook('大肘子');

        // 2. 函数的返回值格式
        // function 函数名() {
        //     return 需要返回的结果;
        // }
        // 函数名();
        // (1) 我们函数只是实现某种功能，最终的结果需要返回给函数的调用者函数名() 通过return 实现的
        // (2) 只要函数遇到return 就把后面的结果 返回给函数的调用者  函数名() = return后面的结果

        // 3. 代码验证
        function getResult() {
            return 666;
        }
        getResult(); // getResult() = 666
        console.log(getResult()); // 666

        function cook(aru) {
            return aru;
        }
        console.log(cook('大肘子')); // 大肘子

        // 4. 求任意两个数的和
        function getSum(num1, num2) {
            return num1 + num2;
        }
        console.log(getSum(1, 2)); // 3
    </script>
</head>
<body>

</body>
</html>

21 - 求两个数的最大值(函数版)

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>21 - 求两个数的最大值(函数版)</title>
    <!-- 
        案例1：利用函数求任意两个数的最大值
        ---------------------------------
     -->
    <script>
        // 利用函数 求两个数的最大值
        function getMax(num1, num2) {
            // if (num1 > num2) {
            //     return num1;
            // } else {
            //     return num2;
            // }
            return num1 > num2 ? num1 : num2;
        }
        console.log(getMax(1, 3)); // 3
        console.log(getMax(11, 3)); // 11
    </script>
</head>
<body>

</body>
</html>

22 - 求数组中的最大值(函数版)

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>22 - 求数组中的最大值(函数版)</title>
    <!-- 
        案例2：利用函数求任意一个数组中的最大值
        ------------------------------------
        求数组[5,2,99,101,67,77] 中的最大数值。
     -->
    <script>
        // 定义一个获取数组中最大数的函数
        function getArrMax(arr) { // arr 接受一个数组  arr =  [5,2,99,101,67,77]
            var max = arr[0];
            for (var i = 1; i <= arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        }
        // getArrMax([5, 2, 99, 101, 67, 77]); // 实参是一个数组送过去
        // 在我们实际开发里面，我们经常用一个变量来接受 函数的返回结果 使用更简单
        var re1 = getArrMax([5, 2, 99, 101, 67, 77]);
        var re2 = getArrMax([3, 77, 44, 99, 143]);
        console.log('最大值为 ' + re1); // 最大值为 101
        console.log('最大值为 ' + re2); // 最大值为 143
    </script>
</head>
<body>

</body>
</html>

23 - 函数返回值注意事项

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>23 - 函数返回值注意事项</title>
    <!-- 
        4.2 return 终止函数
        ------------------

        return 语句之后的代码不被执行。
        
        ```JavaScript
        function add(num1，num2){
            //函数体
            return num1 + num2; // 注意：return 后的代码不执行
            alert('我不会被执行，因为前面有 return');
        }
        var resNum = add(21,6); // 调用函数，传入两个实参，并通过 resNum 接收函数返回值
        alert(resNum); // 27
        ```

        4.3 return的返回值
        ------------------
        return只能返回一个值。 如果用逗号隔开多个值，以最后一个为准。

        ```JavaScript
        function add(num1，num2){
            //函数体
            return num1，num2;
        }
        var resNum = add(21,6); // 调用函数，传入两个实参，并通过 resNum 接收函数返回值
        alert(resNum); // 6
        ```

        案例：创建一个函数，实现两个数之间的加减乘除运算，并将结果返回
        ---------------------------------------------------------
        ```JavaScript
        var a = parseFloat(prompt('请输入第一个数'));
        var b = parseFloat(prompt('请输入第二个数'));
        function count(a, b) {
            var arr = [a + b, a - b, a * b, a / b];
            return arr;
        }
        var result = count(a, b);
        console.log(result);
        ```

        4.4 函数没有return返回undefined
        ------------------------------
        函数都是有返回值的
        1. 如果有return 则返回 return 后面的值
        2. 如果没有return 则返回 undefined

        4.5 break,continue,return的区别
        -------------------------------
        break ：结束当前的循环体（如 for、while） 
        continue ：跳出本次循环，继续执行下次循环（如 for、while）
        return ：不仅可以退出循环，还能够返回 return 语句中的值，同时还可以结束当前的函数体内的代码

		知识总结
        -------
        函数中如果执行了return语句，即结束当前函数，不再继续向下执行代码
        函数中只能有一个返回值，即使写了多个return，也只能执行第一个return语句
        函数中只能返回一个具体的数据，如果返回了多个数据，则只会返回最后一个数据
        函数中通过return关键词指定函数返回值
        函数中如果没有指定返回值，则函数默认返回值为undefined
     -->
    <script>
        // 函数返回值注意事项
        // 1. return 终止函数
        function getSum(num1, num2) {
            return num1 + num2; // return 后面的代码不会被执行
            // alert('我是不会被执行的哦！');
        }
        console.log(getSum(1, 2)); // 3

        // 2. return 只能返回一个值
        function fn(num1, num2) {
            return num1, num2; // 返回的结果是最后一个值
        }
        console.log(fn(1, 2)); // 2

        // 3.  我们求任意两个数的 加减乘数结果
        function getResult(num1, num2) {
            return [num1 + num2, num1 - num2, num1 * num2, num1 / num2];
        }
        var re = getResult(1, 2); // 返回的是一个数组
        console.log(re); // Array(4) [ 3, -1, 2, 0.5 ]

        // 4. 我们的函数如果有return 则返回的是 return 后面的值，如果函数么有 return 则返回undefined
        function fun1() {
            return 666;
        }
        console.log(fun1()); // 返回 666
        function fun2() {

        }
        console.log(fun2()); // 函数返回的结果是 undefined
    </script>
</head>
<body>

</body>
</html>

作业

<!DOCTYPE html>
<html>
<head>
	<meta charset='utf-8'>
	<title>作业</title>
	<!-- 
		1. 写一个函数，用户输入任意两个数字的任意算术运算（简单的计算器小功能），并能弹出运算后的结果。
		2. 写一个函数，用户输入任意两个数字的最大值，并能出弹运算后的结果。
		3. 写一个函数，用户输入任意三个不同数字的最大值，并能弹出运算后的结果。 
		4. 写一个函数，用户输入一个数判断是否是素数，并返弹出回值(又叫质数，只能被1和自身整数的数)
	-->
	 <script>
     	// 写一个函数,用户输入任意两个数字的任意算术运算,并弹出运算后的结果
	    function getResult(){
	        var sum;
            var num1 = prompt('请输入第一个数：');
            var num2 = prompt('请输入第二个数：');
            var operator = prompt('请输入你想要的运算符：')
            switch (operator) {
                case '+':
                    sum = parseInt(num1) + parseInt(num2); // 接受的是字符型
                    break;
                case '-':
                    sum = num1 - num2;
                    break;
                case '*':
                    sum = num1 * num2;
                    break;
                case '/':
                    sum = num1 / num2;
                    break;
                default:
                	return alert('符号错误');
                    break;
            }
            document.write('计算结果是：' + num1 + operator + num2 + '=' + sum + '<br>');
	    }
	    getResult(); // 不要忘了调用函数

	    // 2. 写一个函数，用户输入任意两个数字的最大值，并能出弹运算后的结果。
	    function getTwoMax() {
            var num1 = parseInt(prompt('请输入第一个数：'));
            var num2 = parseInt(prompt('请输入第二个数：'));
            var max = num1 > num2 ? num1 : num2; // max一定要放num后面定义，不然就是undefined
            document.write('最大值：' + max + '<br>'); // 前面不要return，不然后面的句子输出不了
        }
        getTwoMax();

        // 3. 写一个函数，用户输入任意三个不同数字的最大值，并能弹出运算后的结果。 
        function getThreeMax() {
            var a = parseInt(prompt('请输入第一个数：'));
            var b = parseInt(prompt('请输入第二个数：'));
            var c = parseInt(prompt('请输入第三个数：'));
            var arr = [a, b, c];
            var max = arr[0];
            for (var i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            document.write('最大值是：' + max + '<br>');
        }
        getThreeMax();

        // 4. 写一个函数，用户输入一个数判断是否是素数，并返弹出回值(又叫质数，只能被1和自身整数的数)
        function getPrime() {
            var num = Number(prompt('请输入一个正整数,判断此数是不是素数')); // 要判断的数
		    var flag = true; // 假设变量  值为true 是素数 
		    for( var i = 2 ; i < num ; i++ ){
		        if( num % i == 0 ){ // 满足这个条件  说明有因子了  不是素数
		            flag = false; // 不是素数
		            break;
		        }
		    }
		    // 如果假设成立  
		    if( flag && (num != 1 & num != 0) ){ // 1和0不是素数
		        document.write( num + '是素数' + '<br>');
		    }else{
		        document.write( num + '不是素数' + '<br>' );
		    }
        }
        getPrime();
	 </script>
</head>
<body>

</body>
</html>

JavaScript 09 - 函数

文章目录

14 - 什么是函数

15 - 函数的使用

16 - 利用函数封装求1~100的和

17 - 带参数的函数

18 - 利用函数求任意两个数的和

19 - 函数形参实参个数匹配

20 - 函数的返回值

21 - 求两个数的最大值(函数版)

22 - 求数组中的最大值(函数版)

23 - 函数返回值注意事项

作业

通过榨汁机看透函数

AI模型 Llama 3体验笔记

【面试准备】又一次失败的面试经历，题目离谱～资深软件测试工程师

dotnet 8 版本与银河麒麟V10和UOS系统的 glibc 兼容性

JavaScript基礎第03天【筆記+代碼】

lisa音標

計算機-查找專項練習

JavaScript基礎第02天【筆記+代碼】

corejava_day1（核心Java）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結