javascript . 03 函数定义、函数参数（形参、实参）、函数的返回值、冒泡函数、函数的加载、局部变量与全局变量、隐式全局变量、JS预解析、是否是质数、斐波那契数列

1.1 知识点

1. 函数：就是可以重复执行的代码块
2. 2.  组成：参数，功能，返回值
3. 为什么要用函数，因为一部分代码使用次数会很多，所以封装起来， 需要的时候调用
4. 函数不调用，自己不会执行
5. 同名函数会覆盖，后面的覆盖前面的
6. 函数名等于整个函数，打印函数名，就等于打印整个函数的代码
7. 7.  加载函数的时候只加载函数名，不加载函数体
8. 参数相当于局部变量
9. 两个平级的函数中变量不会相互影响
10. 10.     预解析：函数在解释文档的时候会被整体提到文档的最前面，和加载不一样
    1. 第一种：解析的时候会被提前，可在任何地方使用和定义

1.2 函数的定义

1. 第一种：解析的时候会被提前，可在任何地方使用和定义

1. function fun ( a , b ) { 函数体；return ;  }

1. 第二种：函数不会被提前，使用必须在定义之后

2. var fn2 = function ( )｛函数体；｝

3. //函数名可有可无，无名叫匿名函数

1. 第三种：函数不会被提前，使用必须在定义之后，如果函数体不加引号，不调用也会执行

1. var fn3 = new Function（“函数体；”）；

1.3 函数的参数

• 设置参数可解决修改值不修改规则这个问题。
• 增强函数的功能性，和程序员的交互性，和函数的可拓展性
• JS没有方法重载
• 规则中有几个变化的数（操作数），就定义几个参数
• 函数可嵌套
• 开闭原则
• Math.sqrt( ); 开平方

形参

1. 形式上参与运算的值，作用是为实参占位置
2. 实际上参与运算的值
3. 实参要进行运算，必须要有形参占位置
4. 相等，正常执行
5. 实参个数大于形参，正常执行，多去的舍弃不用
6. 形参大于实参，看程序是否出错

实参

形参的个数和实参的个数不一样

a)  计算会得到NaN

b)  实参值是undefined  为给定实参的形参是undefined

c)  任何值和undefined计算都的NaN

1.4返回值

1. 执行函数完毕之后，返回的数据
2. 函数程序运行后的结果外边需要使用的时候，我们不能直接给予，需要通过return返回
3. 作用：函数执行完成以后，结果就是返回值
4. 有return的函数就有返回值，反之则没有
5. 把函数内部的值赋值给外部
6. 6.  如果没有return或者只有return没有值，函数默认返回undefined
7. 函数执行完return后会立即结束，return后面的代码不会执行
8. 函数的返回值必须要执行才可以得到
9. 外部要用那个值，我们就返回哪个值
10. return可以截断循环
11. Math.round（）四舍五入
12. Math.pow( a , n); a的n次幂
13. Math.floor();地板函数
14. var s  =  Math.floor( Math.randow() * (max-min+1) + min ); //生成min-max之间的随机数
15. 函数内用的必须是形参的数组
16. bubble  冒泡
17. 冒泡排序极限后会出现问题

     var arr = [4,435,234,1223,645,341,123,124,562];
     function bubble(arr) {
         for(var i=0;i<arr.length-1;i++){
              var flag = true;
             for(var j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                  var temp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = temp;
                    flag = false;
                }
             }
             if(flag){
                 break;
                 // 此处若直接使用return（arr） ，则不能返回正确的值，个人理解为，此处为局部变量，不能正确返回
             }
         }
         return(arr);
     }
 //    console.log(bubble(arr))

18.函数通过运算来的数一般都是半成品，需要二次加工

1.5 函数名、函数体和函数加载问题

1. 打印函数名，等于打印了整个函数的代码
2. 打印执行函数，等于打印函数的返回值

a)  函数包函数先执行内部函数

　　3. JS加载的时候，只加载函数名，不加载函数体

1.6 变量作用域

局部变量

1. 只有局部能够访问的变量
2. 函数内部用var定义的变量
3. 函数执行完毕后，局部变量被回收

全局变量（成员变量）

1. 在哪里都可以访问的变量
2. 在函数内部，直接定义变量，不加var为全局变量，函数必须得执行后才可以使用

1.7 隐式全局变量（不要不这样写）

1. 一般存在函数之中

a)  var a = b = c = 1; //这种情况，b和c都是隐式全局变量

b)  var a = 1; b = 2; c = 1; //这种情况，b和c都是隐式全集变量，分号相当于换行

c)  var a = 1, b = 2,  c = 1; //这种情况，b和c不是隐式全局变量

1.8 预解析：JS解析器

1. 查看语法错误
2. 变量声明提升（只提升变量名，不提升变量值），
3. 把内容加载到内存中

a)  对象加载到堆中

b)  简单类型加载到栈中

1. 用function定义的函数整体提升

a)  函数内照样适用

b)  就近原则，

　　5.  预解析（整体提升函数）和函数加载（只加载函数名）的区别

　　6.  预解析:检查script标签内的语法，提升函数声明

　　7.  函数加载:把函数加载到内存中

　　8.  解析完再加载

　　　　　　// 测试是否是质数
1         function isPrime(n){
             for(i=2;i<n/2;i++){
              if (n%i == 0 ){
                  return false;
              }
             }
             return true;
         }
          confirm (isPrime(7));

斐波那契数列

         function fibonacci(n){
             if (n<3){
                 n=1;
                 return n;
             }else {
                 var k = 1, j = 1;
                 for (i = 3; i <= n; i++) {
                     j = j + k;
                     k = j - k;
                 }
                 return j;
             }
         }

获取输入年月日，确定是今年的第几天

    console.log(getDay(2016,3,1));
    function getDay(year,month,day){
        var arr = [31,28,31,30,31,30,31,31,30,31,30,31];
        var sum = day;
        if(year%4==0 && year%100!==0 || year%400==0){
            arr[1]=29;
        }
        for(var i=0;i<month-1;i++){
            sum += arr[i];
        }
        return sum ;
    }