JavaScript函数_js sum

函数： 就是把一坨重复的代码封装，在需要的时候直接引入调用
函数的作用： 让代码可以重复使用

一、函数的定义

语法：

function 函数名(){
    函数体(一段重复的代码);
}

二、函数的调用

语法：

函数名();

// 函数的定义
function cook() {
    console.log("切菜");
    console.log("放油");
    console.log("炒菜");
    console.log("放盐");
    console.log("装盘");
}
// 函数的调用
console.log("早上===");
cook();
console.log("中午===");
cook();
console.log("晚上===");
cook();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、练习

1.求两个数字的和

function consoleSum() {//函数定义
	var num1 = 100;
	var num2 = 200;
	var sum = num1 + num2;
	console.log(sum);
}
//调用
consoleSum();
1
2
3
4
5
6
7
8

2.求三个数字的和

function consoleSum2() {
  var num1 = 10;
  var num2 = 20;
  var num3 = 30;
  var sum = num1 + num2 + num3;
  console.log(sum);
}
consoleSum2();
1
2
3
4
5
6
7
8

3.求两个数字的最大值

function consoleMax() {
  var x = 10;
  var y = 20;
  console.log(x > y ? x : y);
}
consoleMax();
1
2
3
4
5
6

4.求三个数字的最大值

function consoleMax2() {
  var x = 10;
  var y = 20;
  var z = 30;
  var max = x > y ? (x > z ? x : z) : (y > z ? y : z);//嵌套的三元表达式
  console.log(max);
}

consoleMax2();
1
2
3
4
5
6
7
8
9

5.求1~100之间所有数字的和

function everySum() {
  var sum=0;
  for(var i=1;i<=100;i++){
    sum+=i;
  }
  console.log(sum);
}
everySum();
1
2
3
4
5
6
7
8

6.求一个数组的和

function consoleArraySum() {
  var sum=0;
  var arr=[10,20,30,40,50];
  for(var i=0;i<arr.length;i++){
    sum+=arr[i];
  }
  console.log(sum);
}
consoleArraySum();
1
2
3
4
5
6
7
8
9

总结：
1.函数需要先定义，然后才能开始使用
2.函数名字，要遵循驼峰命名法
3.函数名不能重名，一旦重名，后面的会把前面的覆盖
4.一个函数最好只实现一个功能（以上练习只供学习练习，不推荐在代码中使用）

四、函数的参数

1.在函数定义的时候，函数名字的小括号里的变量就是参数，目的是在函数调用的时候，用-用户传进来的值操作

//函数定义
function consoleSum(x, y) {
  var sum = x + y;//计算和----功能
  console.log(sum);//输出和---第二个功能
}
//函数的调用
consoleSum(100,200);//300
1
2
3
4
5
6
7

2.函数定义的时候，后面的小括号里的变量叫参数；写了两个变量，就有两个参数。在函数调用的时候，按照提示的方式，给变量赋值（即传值），把这个值传到变量（参数）中

//函数定义
function consoleSum(x, y) {
  var sum = x + y;//计算和----功能
  console.log(sum);//输出和---第二个功能
}
//函数调用
var num1=10;
var num2=20;
consoleSum(num1, num2);//30
1
2
3
4
5
6
7
8
9

3.形参和实参
形参：形式参数，是函数定义在小括号里的变量
实参：实际参数，是函数在调用的时候小括号里传入的值，实参可以是变量也可以是值

五、函数的返回值

1.返回值： 在函数内部有return关键字，并且在关键字后面有内容，这个内容被返回（即最后暑促的内容）；当函数调用之后，需要这个返回值，那么就定义变量即可。
个人理解： 返回值就是，定义的这个函数最终需要输出什么，返回的就是什么，最后调用这个函数输出的也是返回值。

function getSum(x, y) {
    var sum = x + y;
    return sum; //把和返回
}
//函数调用
var result = getSum(10, 20);
console.log(result);//30
1
2
3
4
5
6
7

2.函数定义： 有参数有返回值的函数

// 函数定义: 有参数有返回值的函数
function getSum(x, y) {
    return x + y; //把和返回
}
//函数调用
var result = getSum(10, 20);
console.log(result);//30
1
2
3
4
5
6
7

3.注意：
（1）如果一个函数中有return,那么这个函数就有返回值；如果一个函数中没有return,那么这个函数就没有返回值
（2）如果一个函数有参数，就是有参数的函数；如果一个函数没有参数，就是没有参数的函数

//有参数,有返回值的函数
function f1(x, y) {
    return x + y;
}
//有参数,无返回值的函数
function f2(x) {
    console.log(x);
}
//无参数,有返回值的函数
function f3() {
    return 100;
}
//无参数无返回值的函数
function f4() {
    console.log("无参数无返回值");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

（3）如果一个函数中没有明确的返回值，那么结果就是undefined（没有明确返回值的两种情况：1.函数中没有return；2.函数中有return，但是return后面没有内容）

function f1(x, y) {
    var sum = x + y;
    return;
}
var sum = f1(10);
console.log(sum); //NaN
1
2
3
4
5
6

（4）形参的个数可以和实参不一样

function f1(x, y) {
    return x + y;
}
var sum = f1(10);
console.log(sum);//NaN
1
2
3
4
5

（5）return下面的代码是不会执行的，所以return要写在函数的最后面。

function f1(x, y) {
    var sum = x + y;
    return sum;
    console.log("不会被执行");
    return 100;
}
var result = f1(10, 20);
console.log(result);//30
1
2
3
4
5
6
7
8

六、例题

1.求两个数字的和（即获取任意两个数的和）

function getSum(x, y) {
  return x + y;
}
console.log(getSum(10, 20));//30
1
2
3
4

2.求1-100之间所有数字的和

function geteverySum() {
    var sum = 0;
    for (var i = 1; i <= 100; i++) {
        sum += i;
    }
    return sum;
}
console.log(geteverySum());
1
2
3
4
5
6
7
8

3.求1-n之间所有数字的和

function geteverySum(n) {
  var sum = 0;
  for (var i = 1; i <= n; i++) {
    sum += i;
  }
  return sum;
}
console.log(geteverySum(10));//在这里传入n
1
2
3
4
5
6
7
8

4.求n-m之间所有数字的和

function geteverySum2(n, m) {
  var sum = 0;
  for (var i = n; i <= m; i++) {
    sum += i;
  }
  return sum;
}
console.log(geteverySum2(1, 100));
1
2
3
4
5
6
7
8

5.求圆的面积

function getS(r) {
//Math.PI为已经被定义好的对象，它的值为3.1415926……
  return Math.PI * r * r;
}
console.log(getS(5));
1
2
3
4
5

6.求两个数字中的最大值

function getMax(num1, num2) {
    return num1 > num2 ? num1 : num2;
}
console.log(getMax(10, 20)); //20
1
2
3
4

7.判断一个数是否是素数（即质数）

// 质数是指，只能被1和自己本身整除的数
function isPrimeNumber(num) {
    for (var i = 2; i < num; i++) {
        if (num % i == 0) {
            // 说明如果有一个数能被整除，就没有必要向后继续除了，已经验证出这个数不是质数
            return false;
        }
    }
    return true;
}

var result=isPrimeNumber(7);
if(result){
    // 如果返回true
    console.log("这个数是质数");
}else{
    console.log("这个数不是质数");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

8.求一组数中的最大值、最小值还有和

function getArrayMaxMinMndSun(array) {
   // 新建一个变量存储最小值，将数组的第一个数赋值给这个变量
   var min = array[0];
   // 新建一个变量存储最大值，将数组的第一个数赋值给这个变量
   var max = array[0];
   // 新建一个变量存储数组的和
   var sum = 0;
   // i指数组的下标
   for (var i = 0; i < array.length; i++) {
       // 计算所有数组中所有数的和
       sum = sum + array[i];

       // 最大值
       // 当遍历到比max大的值，就把这个值赋值给max
       if (max < array[i]) {
           max = array[i];
       }

       // 最小值
       // 当遍历到比min小的值，就把这个值赋值给min
       if (min > array[i]) {
           min = array[i];
       }
   }
   // 将最大值，最小值，和装到一个数组中
   var arr = [max, min, sum];
   return arr; //返回这个数组
}
var resultArray = getArrayMaxMinMndSun([1, 3, 4, 6, 8, 0]);
console.log("最大值" + resultArray[0]); //8
console.log("最小值" + resultArray[1]); //0
console.log("总和" + resultArray[2]); //22
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

9.数组实现冒泡排序

function sortArray(arr) { // 控制比较轮数
    for (var i = 0; i < arr.length; i++) {
        // 控制每一轮的比较次数
        for (var j = 0; j < arr.length - 1 - i; i++) {
            if (arr[j] > arr[j + 1]) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
console.log(sortArray([0, 19, 29, 38, 100, 3]));
1
2
3
4
5
6
7
8
9
10
11
12
13
14

10.输入年月日，获取这个日期是这一年的第几天

function getDay(year, month, day) {
    // 定义变量存储对应的天数；
    var days = day;
    // 如果用户输入的是一月份，没必要向后算天数，直接返回天数
    if (month == 1) {
        return days;
    }
    // 代码执行到这说明用户输入的不是一月
    // 定义一个数组存储每个月的天数
    var months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    // i为月份数组的下标，输入月份只算到这一个月的前一个月，因为输入的这个月还没过完
    for (var i = 0; i < month - 1; i++) {
        days += months[i];
    }
    // 判断这个年份是不是闰年
    if (isLeapYear(year) && month > 2) {
        days++;
    }
    return days;
}
// 定义一个函数返回闰年的月份
function isLeapYear(year) {
    return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}
console.log(getDay(2021, 10, 1)); //274
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

七、argument对象

//定义
function f1() {
    //获取的是函数在调用的时候,传入了几个参数
    console.log(arguments.length);
    //使用arguments对象可以获取传入的每个参数的值
    console.log(arguments);
}

f1(10, 20, 30, 40, 100, 200); //调用
1
2
3
4
5
6
7
8
9

计算n个数字的和
定义一个函数，如果不确定用户是否传入了参数，或者说不知道用户传了几个参数的情况下，没办法计算，但是如果在函数中知道了参数的个数，也知道了，每个参数的值——就能进行计算

function f1() {
   //arguments----->数组使用------伪数组
   var sum=0;
   for(var i=0;i<arguments.length;i++){
     sum+=arguments[i];
   }
   return sum;
}
1
2
3
4
5
6
7
8

八、函数的其他定义方式

1.命名函数

函数如果有名字，就是命名函数

function f1() {
    console.log("哈哈");
}
f1(); //函数调用
1
2
3
4

2.匿名函数

函数如果没有名字，就是匿名函数

//报错
function () {
    console.log("哈哈");
}
f1(); //函数调用
1
2
3
4
5

3.函数表达式

// 匿名函数不能直接调用，所以将他赋值给一个叫f1的变量
// 这种方式叫函数表达式
var f1 = function() {
    console.log("阿涅哈斯诶呦");
};
f1();
1
2
3
4
5
6

把一个函数给一个变量此时形成了函数表达式

var 变量=匿名函数；
例子：
var f1=function(){
};
如果是函数表达式，那么此时前面的变量中存储的就是一个函数，而这个变量就相当于是一个函数，直接加小括号调用 f1();
注意：函数表达式后面赋值结束后要加分号。

4.函数表达式和匿名函数的区别

5.函数的自调用

没有名字调用→声明的同时，直接调用

这是一次性的（只能使用一次）
匿名函数的优点：没有名字永远不会冲突
1)函数也是一种数据类型——function类型
        利用输出数据类型的typeof输出函数，发现function也是一种数据类型

function f1() {
  console.log("我是函数");
}
//如何获取某个变量的类型? typeof
console.log(typeof f1);
1
2
3
4
5

2)函数可以作为参数使用——回调函数
        函数可以作为参数使用，如果一个函数作为参数，那么我们说这个参数(函数)可以叫回调函数（即，只要看到一个函数作为参数使用了，那么就是回调函数）

function sayHi(fn) {
   console.log("第一个函数");
   fn();//fn此时应该是一个函数
 }
 function suSay() {
   console.log("第二个函数");
 }
 sayHi(suSay);
 //结果
 //第一个函数
 //第二个函数
1
2
3
4
5
6
7
8
9
10
11

3）函数可以作为返回值使用

function f1() {
  console.log("f1函数调用了");
  return function () {
    console.log("这是一个函数");
  };
}

var ff=f1();//调用
//ff就是一个函数了
ff();
//结果
//f1函数调用了
//返回值函数
1
2
3
4
5
6
7
8
9
10
11
12
13