2018-09-25js参数

1.函数(方法)

实现了某一个功能的操作的集合。
函数的原则：功能单一。

2.函数的定义(申明)

函数的定义并不会执行函数，函数生效的在调用的地方。

2.1使用函数的关键字function申明。

• 格式：
  function name(){

}
eg：

<script>
    var say = function(){
        alert(1);
    }
    ss();
</script>

2.2使用函数表达式申明。一般使用的是匿名函数。

• 格式：
  var fun = function(){

};
Odiv.onclick = function {

};
eg:

<script>
var say = function ss(){
        alert(1);
};
</script>

2.3对象申明法

eg：
var func = new function(a,b,'return a+b;')
var func = function(a,b,c){
return a+b;
}

3.函数的重复申明

函数的重复申明类似于变量的重复申明所生效的永远是后面的。
eg1:

<script>
            function fun(){
                alert(1);
            }
            function fun(){
                alert(2);
            }
            fun();  //2
</script>

eg2：

    <script>
            fun();
            function fun(){
                alert(1);
            }
            function fun(){
                alert(2);
            }   //2

    </script>

4.函数的提升

函数的提升类似于变量的提升，在js里面所以的变量申明以及函数申明都会在执行代码之前运行。

• (在定义一个变量或者函数时两个不能同名，否则系统会自动将后面的函数当成变量不执行。函数里面的变量 不能提到函数外面去。
  )
  函数内部的变量申明，也会出现变量的提升，但是这个提升只能提升到函数的最前面，不能提升到函数的外部。

5.()

申明的时候。括号里面是放置参数的，不能省略，即使没有参数也要有。
调用的时候，括号里面传入的是实际的数据，表示函数的执行。

6.函数的参数

js参数的意义能够获取外面的“值”，但是里面的修改不会影响外面。

• 形参：形式参数，函数定义的括号里面的，只能是一个变量。相当于一个占位符，没有实际的意义，只是方便函数里面去获取外面的数据。相当于给函数的内部申明了一个变量，不过这个变量可以获取外面的数据。
• 实参：实际参数，函数调用的时候传入函数内部的数据。必须是具体的值或者变量。

7.作用域

• 全局作用域：函数外面的叫做全局作用域。
• 局部作用域：函数内部的作用域叫做局部作用域。(局部变量不能在外部执行。)

<script>
var a = 1;
function ss(){
    var b = 2;

}
ss();
    console.log(a);   //1
    console.log(b);   //2
</script>

• 结论：全局作用域的变量能够在任何地方使用，局部作用域的变量只能在函数的内部使用，不能再函数的外部使用。

• 作用域链：
  js所特有的。一个变量在函数内部找不到的时候，回去函数外部查找，如果一直到最外部(window)没有找到那么就会产生not defind错误，但是有时候并不是单纯的内部与外部，而是很多层。这个时候内部查找的时候就要一层一层向外查找，直到找到为止，这就是函数作用域。

eg：

<script>
        var a = 10;
window.onload=function(){
    function s(){
        console.log(a)
    }
    m();
}s();
</script>

8.返回值。

一个函数是实现某个功能的，实现了没有怎么判断？
eg：
计算1-100之间所有的数字的和。
function sum(){
var sum = 0;
for(var i=1;i<101;i++){
sum+=1;}
}
sum();

• 函数执行完成之后，内部的结果想要告诉函数的调用者。那么就要使用函数的返回值，函数的返回值只能有一个。
  语法是在所有的函数内部的语句之后添加一条return语句。想要返回什么就在return后面写什么。
  任何调用这个函数的地方都可以回到这个返回值。
  eg:
  计算从什么-什么之间所有的数字的和。

    <!-- <script>
        function sum(n){
        var sum = 0;
        for(var i= 1;i<n+1;i++){
         sum+=i;     //(sum= sum + 1;)
        }
        return sum;
    }
    console.log(sum(20))
    </script> -->

eg：

    <script>
        function open (){
            if(status){
                returm true;
            }return false;
        }

        if(open()){
            console.log('打开了');
        }else{
            console.log('没打开');
        }
    </script>

9.函数申明的优先级

如果一个表达式申明的函数与一个使用function()关键字申明的函数具有相同的调用方式。那么最终生效的永远是表达式申明的函数，也就是说表达式申明的函数优先级高。
eg：

<script>
function a(){
    console.log(2);
 }
 var a = function(){
    console.log(1);
 };
 a();
</script>

10.不要在if以及所有判断里面申明函数。

eg:

<script>
var i =1;
if(i){
    function a(){
        console.log(1);
    }
}else{
    function b(){
        console.log(2);
    }
}
</script>

11.函数的属性及方法。

面向对象。函数也是一个对象，对象就是具有方法以及属性是一个个头。

• name属性：函数名。
• length属性：形参参数的个数。
• toString()：函数字符串。
  eg：

<script>
function s (){
        //此处this表达的是函数的者
        console.log(this.name);
}
s();      //表达的意思是调用一个函数
</script>

真确的表达式：

<script>
function s (){
}
onsole.log(s.name);     //表达的意思是调用一个函数
</script>

eg2：

<script>
function s (a,b,c,d){
}
s(c);      //表达的意思是调用s中其中一个。
console.log(s.length);
</script>

12.参数

参数的默认值。有的时候参数并不是必须要传递的，没有传递的时候可以设置一个默许的来执行。这个时候就可以使用默认值语法。

• 一般来说函数的在调用的时候传递的参数的个数要和函数申明的时候申明的参数一致。如果某一个参数没有传递，那么实参和形参的等对应关系应从前到后，也就是说后面的参数被总是先省略。

<script>
function  s(a,b){
    console.log(a);
    console.log(b);

}
s(3);   //=3
</script>

• 参数的传递方式
  值传递：对于简单数据类型的的参数传递的使用就是值传递。(数字，字符串，布尔值)
  var a = 10;
  b = a;
  b = 11;
  eg:

<script>
var a = 100;
function s(){
    console.log(m);    //=100
    console.log(a);    //=100
    m =0;   //=0
    console.log(a);    //=100
    console.log(m);    //=100

}
s(a);    //=undefind
console.log(a);    //=undefind
console.log(m);    //=undefind

</script>

应用传递(地址传递)：
eg2:

  <script>
        var zhangsan = {};  //对象
        zhangsan.age = 18;
        zhangsan.height = 180;
        zhangsan.weight =180;
        function s(&b){
            b.age = 22;
        }
    s(zhangsan);
    conso.log(zhangsan);
  </script>

14.arguments对象

参数对象，能够在函数的内部获取到所有传入的参数的集合。是一个类数组对象。
出现原因：
(1).如果传入的参数的个数是不确定的。例如：返回传入n个参数的最大值。
(2).申明函数的时候参数的个数比调用的时候传入的参数的个数少。

eg1：

<script>
function s(){
    console.log(a);
    console.log(b);
}
s(3,4,5);
</script>

<script>
function s(){
    console.log(arguments);
}
s(3,1,4,5,6,8,7,8);
console.log(Math.max(3,1,4,5,6,2,7,8));  //返回出最大值8
console.log(Math.min(3,1,4,5,6,2,7,8));  //返回出最小值1
</script>

eg2：

15.函数分类

系统函数，js自己定义好的函数。

• 自定义函数，用户自己定义的函数。
• 匿名函数：没(有名称的函数
• 立即函数(自执行函数)：就是函数在定义的时候自动调用一次。不能使用在函数关键字申明的函数后面直接加上小括号不表示执行，因为JS的解析器认为function开始的语句就是函数定义。
  eg：
  立即函数

<script>
function s(){
    console.log(1);
}();
</script>   //格式是错误的

• 表达式申明：可以使用表达式申明的函数后面加上小括号表示执行。其实对于js解析器来说只要不是function开始都可以实现自执行。
  (function s (){}());
  (function(){})();
  利用上面的这个执行的特点，可以实现用户的一个局部作用域空间，这样可以防止变量的污染。
  其实对于js解析器来说只要不是function开始申明的函数可以加上小括号表示自执行的。
• ！function s (){}();
• ~function(){}();
• +function(){}();
• -function(){}();

eg:

<script>
(function s(){
    console.log(1);
}());
</script>

eg2:

<script>
(function s(){
    var a= 2;
    console.log(2);
})();     //此时里面的console.log
console.log(2);
</script>

16.回调函数

在某一个地方的内部(函数内部)根据某一个条件去调用其他函数。

• 开放，在不修改原代码的基础上实现新的功能。对修改封闭，对扩展开放。开放封闭的原则。
  eg1(方法1）:

<script>
function jisuan(a,b,fuhao){
    swidth(fuhao){
        case'+':
        return a+b;
        break;
        case'-':
        return a-b;
        break;
        case'*':
        return a*b;
        break;
        case'/':
        return a/b;
        break;
    }
}
var jieguo =jisuan(1,2'-');
console.log(jieguo);
</script>

eg2(方法2）:

<script>
function jisuan(a,b,yunsuan){
    return yunsuan(a,b);
}
function jia(a,b){
    return a+b;
}
function jian(a,b){
    return a-b;
}
function chen(a,b){
    return a*b;
}
function chu(a,b){
    return a/b;
}
function quyu(a,b){
    return a%b;
}
var jieguo = jisuan(2,3,quyu);
console.log(jieguo);
</script>   //此处是调用quyu，用2除以3后得到它的余数

17.递归函数

在函数的内部自己调用自己实现某一个操作。
递归函数的一定具有结束条件的

eg：

<script>
function a(){
    console.log(1);
    a();
}
a();   //如果没有对递归函数进行结束，那么他会进行死循环。
</script>

<script>
100
function a(num){
    console.log(num);
    if(num==1){
        return false;
    }
    a(num-1);
}
a(78);
</script>

eg:计算任意数字以内所有正数的和。100+99+98+……+1
<script>
function sum(num){
if(num==1){
return 1;
}
return num+sum(num-1);
}
console.log(sun(100)); //=5050
</script>
eg:计算任意数字以内的阶乘
7！=7654321

<script>
function sum(num){
    if(num==1){
        return 1;
    }
    return num*sum(num-1);
}
console.log(sum(10));
</script>