函数精讲-优快云博客

函数有了参数才有了灵魂，可以实现多次重复使用了。

在调用函数时，可以向其传递值，这些值被称为参数。这些参数可以在函数中使用；可以发送任意多的参数，由逗号隔开。
//函数声明
function fun(形参1，形参2，...){    //把形参看作是没有经过声明的变量就好了。
    //方法体
}

fun（实参1，实参2...）;    //函数调用
核心：把形参看作是没有经过声明的变量就好了。

函数内部是一个封闭的环境，可以通过参数的方式，把外部的值传递给函数内部

带参数的函数调用是一一对应的关系。

形参和实参

形式参数：在声明一个函数的时候，为了函数的功能更加灵活，有些值是固定不了的，对于这些固定不了的值，我们可以给函数设置参数，这个参数没有具体的值，仅仅起到一个占位置的作用，我们通常称之为从事参数，也叫形参。
实际参数：如果函数在声明时，设置了形参，那么在函数调用的时候就需要传入对应的参数，我们把传入的参数叫做实际参数，也叫实参。
function add(a , b){
    console.log(a + b);
}

var x = 5, y = 6;
add( x , y);
//x、y实参，有具体的值，函数执行的时候会把x，y复制一份给函数内部的a和b
//函数内部的值是复制的新值，无法修改外部的x、y
如果我们在函数内部修改形参的值，是否会影响函数外部实参的值？
答案是不会。因为调用函数的时候，是把实参的值复制了一份赋给形参，它们两个各自的改变是没有多大关系的

函数使用案例

求n个数的最大值

类似打擂台的方法，先将第一个定义为最大值，max

function getMax(arr){
    //参数arr是数组
    var max = arr[0];
    for (var i = 1; i < arr.length; i++){
        //将max和数组中的每一个元素进行比较
        if(max < arr[i]){
            max = arr[i];
        }
    }
    console.log(max);

}

var array = [12, 54, 25, 99];
getMax(array);

判断一个数是否是素数

素数又叫质数，只能被1和自身整除的数

function jdugePrimeNumber(number){
    //假设number是质数
    var isPrime = ture;    //和冒泡排序用到的优化一样定义一个布尔变量来判断
    for (var i = 2; i < number; i++){
        //判断是否有能被number整除的数
        if(number % i ===0){
            //如果此处执行了，说明不是质数
            isPrime = false;
            break;
        }
    }
    if (isPrime){
        console.log('质数');
    }else{
        console.log('是一个素数');
    }
}
jdugePrimeNumber(29);

函数的返回值

当函数执行完的时候，并不是所有时候都需要把结果打印出来。如果我们期望函数给我们一些反馈（比如计算的结果返回，用于进行后续的计算），这个时候可以让函数返回一些东西，也就是返回值，函数通过return返回一个返回值。

也可以理解为调用一个函数就是接受这个函数返回的结果，从而我们可以用这个结果来进行后续的操作。

当函数中不写return时，有返回值，为undefined
如果写了return但后面什么都不跟，也有返回值，为undefined。如果后面有值，则为该函数的返回值。
函数使用return语句后，这个函数会在执行完return语句后立即停止并退出，也就是说return后面的所有其他代码都不会再执行。
推荐的做法是：要么让函数始终都返回一个值，要么永远都不要返回值。

返回值案例

阶乘案例

求一个数的阶乘

function getJieCheng(n){
    var result = 1;    //如果n=1的时候则直接返回1
    for (var i = 1; i <= n;i++){
        result *= i;
    
    }
    return result;
}
var num = getJieCheng(5);

求1！+2！+3！...+n！

function getJieCheng(n){
    var result = 1;    //如果n=1的时候则直接返回1
    for (var i = 1; i <= n;i++){
        result *= i;
    
    }
    return result;
}

function getSum(n){
    //求1-n之间每一个数的阶乘的累加
    var sum = 0;
    for (var i = 1; i <= n; i++){
        //累加的是每一个数的阶乘
        sum += gerJieCheng(i);
    }
    return sum;
}

gerSum(6);

判断一个年份是否是闰年

闰年：能被4整除并且不能被100整除，或者能被400整除的数是闰年

function isRun(year){
    //假设不是闰年，布尔值为false
    var result = false;    //去掉布尔值假设，则if后面需要加一个else
    if ((year %4 === 0 && year % 100 !== 0) || (year % 400 === 0)){
    result = ture;
    }
return result;
}
isRun(2020);

输入某年某月某日，判断这一天是这一年的第几天？

function isRun(year){
    //假设不是闰年，布尔值为false
    var result = false;    //去掉布尔值假设，则if后面需要加一个else
    if ((year %4 === 0 && year % 100 !== 0) || (year % 400 === 0)){
    result = ture;
    }
return result;
}

function getDays(year, month, day){
    //计算总共有多少天
    var days = day;    //当前月份的天数
    for (var i = 1;i < month; i++){
        switch(i) {
            case 1;
            case 3;
            case 5;
            case 7;
            case 8;
            case 10;
            case 12;
                days += 31;
            case 4;
            case 6;
            case 9;
            case 11;
                days += 30;
                break;
            case 2;
                //判断是平年28天还是闰年29天
                if(isRun(year)){
                    days += 29;
                }else{
                    days += 28;
                }
                break;
        }
    }
}

arguments的使用

JavaScript中，arguments对象是比较特别的一个对象，实际上是当前函数的一个内置属性，也就是说所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参，arguments是一个伪数组，因此可以进行遍历。

如案例求任意个数的最大值
function getMax(){
    var max = arguments[0];
    for (var i = 1; i < arguments.length; i++){   //arguments用于获取函数调用的时候的实参，非常像数组，但又不是数组
        if(max < arguments[i]) {
                
        }
    }
    return max;
}
var max = getMar(15,98,65,41);
arguments也可以理解为当不写形参的时候，我们无从知道具体实参是什么，那么就可以用类似数组的arguments来遍历实参或洞悉实参

函数其他

函数有命名函数，即有方法名的函数如: function fn( ) { };
还有函数表达式，即后半部分为匿名函数。如： var fn = function （）{ }；
还有自调用函数，当函数书写完成之后立即调用
函数也是一种数据类型，function也是一种数据类型
当我们调用函数时，如果没有传递参数，此时形参的值是undefined。
因为函数是一种数据类型，所以函数可以作为另一个函数的参数
因为函数是一种数据类型，所以函数可以作为另一个函数的返回值

匿名函数

指没有名字的函数

那么匿名函数如何使用：

将匿名函数赋值给一个变量，这样就可以通过变量进行调用
匿名函数自调用

自调用函数

匿名函数不能通过直接调用来执行，因此可以通过匿名函数的自调用方式来执行
(function(){
    console.log(3);    //匿名函数是一个没有方法名的函数，这里的大括号相当于一个函数，后面的小括号表没有参数的函数调用
})();

函数是一种数据类型

可通过typeof来检验函数是否是一个数据类型
function fn(){
    console.log(typeof fn);    //输出结果为黑色字体的function，证明函数是一个数据类型
}

代码规范

变量名一般用名词
函数名一般用动词（因为这是动作的执行）
操作符的前后要有一个空格
当行注释斜杠后要有一个空格，逗号分号后要有一个空格

变量和作用域

变量可以起到作用的范围

全局变量：在任何地方都可以访问到的变量就是全局变量，对应全局作用域，通常写在<script>或一个独立的js文件中。全局变量除了写在方法体的外部还可以不使用var来声明的变量也叫全局变量，但不推荐使用
局部变量：只在固定的代码片段可以访问到的变量，最常见的是函数内部，对应局部作用域（函数作用域）
块级作用域，即一对花括号{ }阔起来的代码块，在ECMAScript中没有块级作用域，所以块级里面的变量是可以访问的，在java、c等编程语言中才有块级作用域（即在这之中定义的所有变量在代码块外都是不可见的）
变量退出作用域之后会销毁，全局变量在关闭网页或浏览器才会销毁

作用域链

只有函数可以制造作用域结构，那么只要是代码，就至少有一个作用域，凡是代码中有函数，那么这个函数就构成另一个作用域，如果函数中还有函数，那么在这个作用域中就又可以诞生一个作用域
像这样的所有的作用域列出来，可以有一个结构：函数内指向函数外的链式结构，就称作作用域链。
// num为全局作用域，即0级作用域
var num = 5;
function f1() {
    // f1下的为局部作用域，num=15就是局部作用域，也称1级作用域
    var num = 15;
    function f2() {
        // f2下的也为局部作用域，依次排列到了2级作用域
        console.log(num);
    }
    f2();
}

f1();    // 此刻输出来的num为15，可看似就近原则

预解析

变量提升：把变量的声明提升到当前作用域的最上面，但此时给变量赋的值不予提升
函数提升：把函数的声明提升到当前作用域的最上面，但此时函数的调用不予提升
预解析是从上到下的

// 案例1
console.log(num);
var num = 5;
// 预解析后
var num;
console.log(num);
num = 5;        //所以此时输出num的话，值是undefined

//案例二
var a = 25;
function abc(){
    alert(a);
    var a = 10;
}
abc();        //此刻打印出来的a为undefined

//预解析后
var a;
function abc(){
    //局部作用域的预解析
    var a;
    alert(a);
    a = 10;
}
a = 25;
abc();

//案例三
console.log(a);
function a() {
    console.log('aaa');
}
var a = 1;
console.log(a);    //输出的结果为undefined、1

//预解析的过程中，如果函数名和变量的名字相同，此时函数优先
//预解析后
var a;
function a() {
    console.log('aaa');
}
console.log(a);
a = 1;
console.log(a);