函数语法

重复代码：让程序难以维护

函数主要用于减少重复代码

创建（定义、声明）函数

function 函数名 () {
    //函数体
}

函数体的代码不会直接运行，必须要手动调用函数，才能运行其中的代码。

调用函数

运行函数体

函数名();

 <script>
    //创建函数
    function printSplitor () {
        console.log("=======================");
    }
    //调用函数
    printSplitor();
</script>

函数提升

通过字面量声明的函数，会提升到脚本块的顶部。

通过字面量声明的函数，会成为全局对象的属性。 window的属性

 <script>

其他特点

通过typeof 函数名，得到的结果是"function"

函数内部声明的变量：

1. 如果不使用var声明，和全局变量一致，表示给全局对象添加属性

<script>
    function test () {
        a = 3;
    }
    test();
    console.log(a);   //3
</script>

2. 如果使用var声明，变量提升到所在函数的顶部，函数外部不可以使用该变量

<script>
    function test() {
        console.log(a)   //undefined
        var a = 3;    //相当于var a; a = 3;
    }
    test();
</script>

函数中声明的变量，仅能在函数中使用，在外部无效

<script>
    function test2 () {
        var a = 3;
        a--;
    }
    var a = 5;
    test2();
    console.log(a);   //5
</script>

参数

参数表示函数运行的未知条件，需要调用者告知的数据

//参数的有效返回在函数体中
function 函数名(参数1, 参数2, ...) {
    
}

函数名(实参)

如果实参没有传递，则对应的形参为undefined

<script>
    //输出一个数是否是奇数
    function isOdd(n) {
        if (n % 2 === 0) {
            console.log(n + "不是奇数");
        } else {
            console.log(n + "是奇数");
        }
    }
    var nums = [234, 3, 4];
    for (var i = 0; i < nums.length; i++) {
        isOdd(nums[i]);   //234不是奇数 3是奇数 4不是奇数
    }
    isOdd(5);   //5是奇数
    isOdd(122); //122不是奇数
    isOdd();    //undefined是奇数

    //输出两个数相加的结果
    function sum (a, b) {
        console.log(`${a}+${b} = ${a+b}`);
    }
    sum(3, 5);  //3+5=8;
    sum(234, 234, 34242, 22323);   //234+234=468;
    sum(123);     //123+undefined=NaN;

    //对一个数组求和
    function sumOfArray(arr) {
        var sum = 0;
        for (var i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        console.log("和为：" + sum);
    }
    sumOfArray([2, 3, 4, 5, 6]); // 和为：20

    //删除数组末尾的指定数量的数据
    function deleteArray (arr, number) {
        arr.splice(-number, number);
    }
    var nums = [1, 2, 3, 4, 5];
    deleteArray(nums, 3);
    console.log(nums);   //[1, 2]
</script>

返回值

函数运行后，得到的结果，调用函数时，调用表达式的值就是函数的返回值

<script>
    function isOdd(n) {
        if (n % 2 === 0) {
            return false;   //返回false
        } else {
            return true;   //返回true
        }
    }

    var nums = [234, 34, 56, 345, 455, 777];
    //输出数组中所有的奇数
    var sum = 0;
    for (var i = 0; i < nums.length; i++) {
        if (isOdd(nums[i])) {
            sum += nums[i];
        }
    }
    console.log(sum);   //1577
</script>

return 会直接结束整个函数的运行

return 后面如果不跟任何数据，返回undefined

如果函数中没有书写return, 则该函数会在末尾自动return undefined。

 <script>
    //对一个数组求和
    function sumOfArray(arr) {
        var sum = 0;
        for (var i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
    var num1 = [233, 455, 34, 33, 546];
    var num2 = [3434, 3545, 55, 66, 77];
    console.log(sumOfArray(num1) + sumOfArray(num2));   //8478

    //判断一个数是不是素数
    function isPrime(n) {
        if (n < 2) {
            return false;
        }
        for (var i = 2; i < n - 1; i++) {
            if (n % i === 0) {
                return false
            }
        }
        return true;
    }
    var nums = [32, 65, 67, 45, 3, 4, 55, 9];
    var sum = 0;
    for (var i = 0; i < nums.length; i++) {
        if (isPrime(nums[i])) {
            sum += nums[i];
        }
    }
    console.log(sum);   //70
</script>

文档注释

/**
 *
 *
*/

 /**
    * nums:一个数字的数组
*/
var nums = [23, 56, 7, 4, 5, 6];

/**
* 两个数求和
* @param {number} a 第一个
* @param {number} b 第二个
*/ 
function sum(a, b) {
    return a + b;
}
sum (1, 3)

通用函数编写

新建一个js文件，编写以下函数

1. 写一个函数，该函数用于判断某个数是不是奇数

函数名参考： isOdd

/**
 * 判断一个数是不是奇数
 * @param {number} n 要判断的数字
 * @param {boolean}
 */
function isOdd(n) {
    // if (n % 2 !== 0) {
    //     return true;
    // } else {
    //     return false;
    // }
    return n % 2 !== 0;
}
console.log(isOdd(3));   // true

2. 写一个函数，该函数用于判断某个数是不是素数

函数名参考：isPrime

/**
 * 判断一个数是不是素数
 * @param {*} n
 */
function isPrime(n) {
    if (n < 2) {
        return false;
    }
    for (var i = 2; i < n; i++) {
        if (n % i === 0) {
            return false;
        }
    }
    return true;
}
console.log(isPrime(2));  //true
console.log(isPrime(10)); //false

3. 写一个函数，该函数用于对数组求和

函数名参考：sumOfArray

/**
 * 对数组进行求和
 * @param {*} arr 
 */
function sumOfArray (arr) {
    var sum = 0;
    for (var i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
    return sum;
}
console.log(sumOfArray([1, 2, 3, 4, 5, 6]));    //21
console.log(sumOfArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])); //55

4. 写一个函数，该函数用于得到数组中最大的值

函数名参考： maxOfArray

/**
 *  得到数组中最大的值
 * @param {*} arr 
 */
function maxOfArray(arr) {
    if (arr.length === 0) {
        return;
    }
    var max = arr[0];
    for (var i = 0; i < arr.length;  i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}
console.log(maxOfArray([2, 3, 4, 5,444]));   //444

5. 写一个函数，该函数用于得到数组中的最小值

函数名参考：minOfArray

/**
 * 得到数组中最小的值
 * @param {*} arr 
 */
function minOfArray(arr) {
    if (arr.length === 0) {
        return;
    }
    var min = arr[0];
    for(var i = 0; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}
console.log(minOfArray([2, 3, 4, 5,444]));   //1

6. 写一个函数，该函数用于判断数组是否是稀松数组

函数名参考：hasEmptyInArray

/**
 * 判断一个数组是不是稀松数组
 * @param {*} arr 
 */
function hasEmptyInArray(arr) {
    //稀松数组特点：下标连续
    for (var i = 0; i < arr.length; i++) {
        if (!(i in arr)) {
            return true;
        }
    }
    return false;
}
console.log(hasEmptyInArray(new Array(3)));   //true

7. 写一个函数，判断该年是否是闰年

函数名参考： isLeap

/**
 * 判断该年是否是闰年
 * @param {*} year 
 */
function isLeap (year) {
    //4年一润，百年不润，400年一润
    // if (year % 4 === 0 && year % 100 === 10 || year % 400 === 0) {
    //     return true;
    // }
    // return false;
    return year % 4 === 0 && year % 100 === 10 || year % 400 === 0;

}
console.log(isLeap(2000));  //true
//输入一个年份，判断是否是闰年
var year = +prompt("请输入一个年份");
if (isLeap(year)) {
    console.log("是闰年");
} else {
    console.log("是平年");
}

8. 写一个函数，得到某年某月的天数

函数名参考：getDays

/**
 * 得到某年某月的天数
 * @param {*} year 
 * @param {*} month 
 */
function getDays (year, month) {
    if (month === 2) {
        return isLeap(year) ? 29 : 28;
    } else if (month < 8 && isOdd(month) || month >= 8 && !isOdd(month)) {
        return 31;
    } else {
        return 30;
    }
} 
console.log(getDays(2000, 2));     //29
console.log(getDays(2004, 2));     //28
console.log(getDays(2000, 8));     //31

9. 写一个函数，得到某个数字数组中出现次数最多的数字和频率

函数名参考：getTopFreqInArray

/**
 * 得到某个数字数组中出现次数最多的数字和频率
 * 返回一个对象
 * @param {*} arr 
 */
function getTopFreqInArray(arr) {
    var records = {};  //记录出现频率
    for (var i = 0; i < arr.length; i++) {
        var n = arr[i];
        if (records[n]) {
            records[n]++
        } else {
            records[n] = 1;
        }
    }
    var result;   //记录最终结果的对象
    for (var prop in records) {
        if (!result || records[prop] > result.frequency) {
            result = {
                number: prop,
                frequency: records[prop]
            };
        }
    }
    return result;
}
console.log(getTopFreqInArray([2, 2, 2, 3, 4, 5, 6, 7])); //{number: "2", frequency: 3}

函数使用

1. 利用上面的某些函数，实现哥德巴赫猜想

任一大于2的偶数都可写成两个质数之和，比如： 8 = 3 + 5

让用户输入一个大于2的整数，输出其等于哪两个素数相加

function begin () {
    var num = +prompt("请输入一个大于2的偶数");
    if (isNaN(num) || num <= 2 || isOdd(num)) {
        console.log("输入有误");
        return ;
    }
    //输入正确
    for (var i = 2; i <= num - 2; i++) {
        var j = num - i;
        //判断两个数字是否都是素数
        if (isPrime(i) && isPrime(j)) {
            console.log(`${num} = ${i} + ${j}`);
            return;
        }
    }
}
begin();

2. 让用户输入一个年份，输出该年每个月的天数

function begin () {
    var year = +prompt("请输入一个年份（1990～2100）");
    if (isNaN(year) || year < 1990 || year > 2100) {
        console.log("输入有误");
        return ;
    }
    //输入正确
    for (var m = 1; m <= 12; m++) {
        console.log(`${year}年${m}月：${getDays(year, m)}`);
    }
}
begin();