介绍JavaScript编程语言中的函数

·  阅读 380
介绍JavaScript编程语言中的函数

函数

函数就是封装了一段可以被重复执行调用的代码块 目的: 就是让大量代码重复使用 (提高复用性)

比如求1-100之间的和

        function getSum(num1, num2) {
            var sum = 0;
            //num1=1,num2=100 相当于 for(i=1;i<=100;i++)
            for (var i = num1; i <= num2; i++) {
                sum += i;
            }
            console.log(sum);
        }
        getSum(1, 100);
        //求1-1000的和
        getSum(1, 1000);
复制代码

声明函数


// 声明函数
function 函数名() {
//函数体代码
}
复制代码
  • function 是声明函数的关键字,必须小写
  • 由于函数一般是为了实现某个功能才定义的, 所以通常我们将函数名命名为动词,比如 getSum

函数的使用

函数在使用时分为两步:声明函数调用函数。


// 调用函数
函数名(); // 通过调用函数名来执行函数体代码
复制代码
  • 调用的时候千万不要忘记添加小括号
  • 口诀:函数不调用,自己不执行。
  • *注意:*声明函数本身并不会执行代码,只有调用函数时才会执行函数体代码。

函数的封装

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

函数的参数

形参和实参

  • 形参是接受实参的

  • 在声明函数的小括号里面是 形参 (形式上的参数)

  • 在函数调用的小括号里面是实参(实际的参数)

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

  • 注意:

    • 形参和实参是按照顺序依次赋值
    • 如果形参大于实参,多余的形参为undefined
    • 如果实参大于形参,多余的实参忽略不计
    • 如果形参重名,传递过来的实参,后者覆盖前者
        function 函数名(形参1,形参2...) { // 在声明函数的小括号里面是 形参 (形式上的参数)
​
        }
        函数名(实参1,实参2...); // 在函数调用的小括号里面是实参(实际的参数)
​
​
        function cook(aru) { // 形参是接受实参的  aru = '酸辣土豆丝' 形参类似于一个变量
            console.log(aru);
​
        }
        cook('酸辣土豆丝');
复制代码

函数的返回值

return 语句

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

  • 我们函数只是实现某种功能,最终的结果需要返回给函数的调用者函数名() 通过return 实现的
  • 只要函数遇到return 就把后面的结果 返回给函数的调用者 函数名() = return后面的结果
  • 在使用 return 语句时,函数会停止执行,并返回指定的值
  • 如果函数没有 return ,返回的值是 undefined
  • 函数内部不应该有返回语句
  • 一个函数可以有return,也可以没有,如果单纯打印不需要return
  • 我们的函数如果有return 则返回的是 return 后面的值,如果函数没有 return 则返回undefined
  • return 和函数是一个共同体, 想利用函数返回一个结果 那么必须要加return 不加return 默认返回的是undefined
  • return 后面的代码不会被执行,且return只能返回一个值,多个参数后面的会覆盖前面的

return 语句的语法格式如下:


// 声明函数
function 函数名(){
...
return 需要返回的值;
}
// 调用函数
函数名(); // 此时调用函数就可以得到函数体内return 后面的值
​
​
        function 函数名() {
            return 需要返回的结果;
        }
        函数名();
        // (1) 我们函数只是实现某种功能,最终的结果需要返回给函数的调用者函数名() 通过return 实现的
        // (2) 只要函数遇到return 就把后面的结果 返回给函数的调用者  函数名() = return后面的结果
        // 3. 代码验证
        function getResult() {
            return 666;
        }
        getResult(); // getResult()   = 666
        console.log(getResult());
复制代码

求两数和及利用函数实现两个数的最大值,再用最大值加10:


    // 求两数和
    function getSum(num1, num2) {
        return num1 + num2;
    }
    console.log(getSum(1, 2));//3
复制代码

    // 利用函数实现两个数的最大值,再用最大值加10
    function fn(a, b) {
        if (a > b) {
            return a
        } else {
            return b
        }
        //可以用三元表达式
        //return a > b ? a : b
    }
    //fn(5, 56)就相当于最大值a=5555+10=66
    console.log(fn(5, 56) + 10);//66
复制代码

求数组中的最大值:


        // 利用函数求数组 [5,2,99,101,67,77] 中的最大数值。
        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 re = getArrMax([5, 2, 99, 101, 67, 77]);
        var re = getArrMax([3, 77, 44, 99, 143]);
        console.log(re);//143
复制代码

利用函数实现数组的动态赋值


    // 动态赋值
    function fn(arr) {
        var arr1 = []
        for (i = 0; i < arr.length; i++) {
            arr1[arr1.length] = arr[i]
        }
        return arr1
    }
    var re = fn([5, 4, 3, 2, 1])
    console.log(re);//(5) [5, 4, 3, 2, 1]
复制代码

利用数组求两个数的加减乘除


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

break ,continue ,return 的区别

  • break : 结束当前的循环体(如 for、while)
  • continue : 跳出本次循环,继续执行下次循环(如 for、while)
  • return : 不仅可以退出循环,还能够返回 return 语句中的值,同时还可以结束当前的函数体内的代码

arguments的使用

当我们不确定有多少个参数传递的时候,可以用 arguments 来获取。在 JavaScript 中,arguments 实际上 它是当前函数的一个内置对象。所有函数都内置了一个 arguments 对象,arguments 对象中存储了传递的 所有实参。 (重要)

  • arguments 对象中存储了传递的所有实参(和形参没关系)可以不用写形参

  • arguments是一个伪数组,具有数组的length属性

  • arguments可以直接修改传递过来的实参

    • 
          function fn() {
              arguments[0] = 33
              console.log(arguments);//33 22
          }
          fn(11, 22)
      复制代码
  • 求和

    • 
          function fn() {
              var sum = 0
              for (i = 0; i < arguments.length; i++) {
                  sum += arguments[i]
              }
              return sum
          }
          var re = fn(1, 2, 3)
          console.log(re);//6
      复制代码
  • 利用arguments求最大值

    • 
          // 利用arguments求最大值
          function fn() {
              var max = arguments[0]
              for (i = 1; i < arguments.length; i++) {
                  if (arguments[i] > max) {
                      max = arguments[i]
                  }
              }
              return max
          }
          console.log(fn(2, 33, 44, 77)); //77
      复制代码

伪数组

  • 伪数组 并不是真正意义上的数组
  • 具有数组的 length 属性
  • 按照索引的方式进行存储的
  • 它没有真正数组的一些方法 pop() push() 等等

arguments展示形式是一个伪数组,因此可以进行遍历。伪数组具有以下特点:


        // arguments 的使用  只有函数才有 arguments对象  而且是每个函数都内置好了这个arguments
        function fn() {
            // console.log(arguments); // 里面存储了所有传递过来的实参  arguments = [1,2,3]
            // console.log(arguments.length);//3
            // console.log(arguments[2]);//3
            // 我们可以按照数组的方式遍历arguments
            for (var i = 0; i < arguments.length; i++) {
                console.log(arguments[i]);//123
​
            }
        }
        fn(1, 2, 3);
        fn(1, 2, 3, 4, 5);
        // 伪数组 并不是真正意义上的数组
        // 1. 具有数组的 length 属性
        // 2. 按照索引的方式进行存储的
        // 3. 它没有真正数组的一些方法 pop()  push() 等等
复制代码

利用函数判断闰年


        // 用户输入年份,输出当前年份2月份的天数
        function backDay() {
            var year = prompt('请您输入年份:');
            // NaN  false 0 null undefined ''
            if (isRunYear(year)) { // 调用函数需要加小括号
                alert('当前年份是闰年2月份有29天');
            } else {
                alert('当前年份是平年2月份有28天');
            }
        }
        backDay();
        // 判断是否为闰年的函数
        function isRunYear(year) {
            // 如果是闰年我们返回 true  否则 返回 false 
            var flag = false;
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                flag = true;
            }
            return flag;
        }
复制代码

函数的两种声明方式

  • 
    //可以在任何地方调用函数
          // 1. 利用函数关键字自定义函数(命名函数)
          function fn() {
      
          }
          fn();
    复制代码
  //必须先声明在调用
  // 2. 函数表达式(匿名函数) 
          // var 变量名 = function() {};
          var fun = function(aru) {
              console.log('我是函数表达式');
              console.log(aru);
  
          }
          fun('pink');
          // (1) fun是变量名 不是函数名  
          // (2) 函数表达式声明方式跟声明变量差不多,只不过变量里面存的是值 而 函数表达式里面存的是函数
          // (3) 函数表达式也可以进行传递参数
复制代码
  • 注意:

    • var fn =function fn1(){} 此时fn1是无效的
      复制代码
分类:
前端
标签:
收藏成功!
已添加到「」, 点击更改