js函数（上）

函数的作用

任意功能的代码进行“封装”，在需要的时候进行调用。（像一个盒子，盒子里面封装代码，通过盒子名称找到盒子执行里面的代码）——封装代码

盒子封装代码
调用盒子执行代码
封装优点：封装代码，复用代码

函数的语法

// 定义函数

function 函数名(){

封装代码

}

函数名() // 函数调用语句

示例：

//定义一个函数fun
function fun(){
    console.log('这是我的第一个函数')
}
//调用函数fun语句
fun()

1.（封装）求两个数最大值54,67的函数

//定义名为getMax的函数
function getMax(){
     var m = 54
     var n = 67
     var max = m
     if(max < n){
         max = n
     }
    console.log('最大值为'+max);
}

// 调用getMax函数
getMax()

2.（封装）判断闰年的函数

 // 定义函数isLeapYear
function isLeapYear(){
       var year = 2024
            // 计算闰年
       var day = (year % 4 == 0 && year % 100 != 0)||(year % 400 ==0)
       if(day){
           console.log(year+"是闰年");
       }else{
           console.log(year+"不是闰年");
       }
}
isLeapYear()  //调用isLeapYear函数

函数的参数

形参：定义函数时，在函数名括号中定义的变量称为形参
实参：使用函数调用语句时，传入的参数称为实参

function 函数名(m){

函数体

}

函数体(100)
函数参数的个数
1.定义多个参数

function 函数名(m,n){
    函数体
}

函数体(100,200)

2.形参个数多于实参个数（少传的参数将输出undefined）
3.实参个数多于形参个数（多余的参数传值将被抛弃）

函数的返回值（return）

1.有返回结果

语法为：return 表达式;
作用：语句结束函数执行，返回调用函数，而且把表达式的值作为函数的结果
参数默认值：当传入参数时，参数为传入的参数；当没有传参数时，将传入默认值

function fun(m){
    m = m || 10 //函数默认值
    console.log('m', m)
}

// 参数传入100时，m = 100
fun(100)
// 没有传参时，m为函数中的默认值（m = 10）
fun()

示例：（封装）求两个数最大值54,67的函数

//定义名为getMax的函数
function getMax(x, z) {
    // x = 54, z = 67
    var m = x //54
    var n = z //67
    var max = m
    if (n > max) {
        max = n
    }
    return max
}

var m1 = getMax(54, 67)

var m2 = getMax(34, 89)

console.log('m1 ',m1, ' m2 ',m2);

2.无返回结果

无函数结果，语法为：return;

return false:分会错误的处理结果，终止处理。

一般用于取消默认动作。比如你单击一个链接除了触发onclick事件（如果你指定的话）以外还要触发一个默认事件（执行页面跳转）。而想要取消这个默认动作，就可以使用return false语句

首先在js中，我们常用return false来阻止提交表单或者继续执行下面的代码，通俗的来说就是阻止执行默认的行为。

return false 只在当前函数有效，不会影响其他外部函数的执行。

return true：返回正确的处理结果。

函数的定义方式

1.声明式函数
语法：
function 函数名(){

}
2.函数表达式（赋值式）
语法：
var 函数名 = function (){

}

函数类型

1.无参无返回值
语法：
function 函数名(){

}

2.无参有返回值
语法：
function 函数名(){

return 100

}

3.有参无返回值
语法：
function 函数名(m){

}

4.有参有返回值
语法：
function 函数名(m){

return 100

}

预解析

浏览器javascript引擎，解析执行javascript代码
执行javascript代码之前，它扫描通读js代码，如果发现声明式函数和var声明的变量，将其提前。
1.声明式函数提前
2.var声明变量提前

解析声明式函数和var声明变量的过程：

            // 源代码
            fun()
            console.log('111 num :', num)
            var num = 100
            function fun() {
                console.log('fun >>>')
            }
            console.log('222 num ', num)


            // 浏览器解析之后，将变成  
            // function fun() {
            //  console.log('fun >>>')
            // }
            // var num
            // fun()
            // console.log('111 num :', num)
            // num = 100
            // console.log('222 num ', num)

总结：不管声明代码在哪，浏览器都将会预解析

练习

1.程序输出结果是多少? （预解析知识点）
分析：先找到预解析的代码，将其进行提前处理，在从上到下的顺序输出结果。

console.log(num)    //undefined
var num = 10
f()                 // undefined 20
console.log(f2)     // undefined

function f() {
    console.log(n)
    var n = 20
    console.log(n)
}
console.log(num)    // 10

var f2 = function () {
    console.log('我是f2')
}

2.程序代码片段运行结果是? （函数传参）

var data = 'abc'        

fun(data)       

console.log(data)   // 'abc'

function fun(data) {
    data += 'xyz'
}

3.百元买百鸡（试）

/*
   3. 百元买百鸡:用一百元钱买一百只鸡。已知公鸡5元/只,母鸡3元/只,小鸡1元/3只
    分析：假设: 公鸡 x只  母鸡y只 小鸡z只

    x + y + z = 100

    1 + 1 + 98
    1 + 2 + 97
    1 + 3 + 96

    5*x + 3*y + z/3 = 100

    5 + 3 + 98/3
    5 + 3*2 + 97/3 
*/
for (var x = 1; x < 100; x++) {
    for (var y = 1; y < 100; y++) {
        for (var z = 1; z < 100; z++) {
            if (x + y + z == 100 && 5 * x + 3 * y + z / 3 == 100) {
                console.log(' x :', x, ' y :', y, 'z :', z)
                }
            }
        }
    }
}

优化代码：双重for循环

for (var x = 1; x < 100; x++) {
    for (var y = 1; y < 100; y++) {
        z = 100 - x - y
        if (5 * x + 3 * y + z / 3 == 100) {
            console.log(' x :', x, ' y :', y, 'z :', z)
        }
    }
}