函数-理论

函数

可重复使用的一段代码；把所需的东西封装在一个函数里（代码块），随时调用。

函数声明

函数声明时，会产生一个作用域，在函数内部声明时，叫局部变量；只有当前函数内部可调用.

函数和用var声明变量一样，也存在变量提升。（var:会有变量提升，到当前代码块顶部； let：不会有变量提升；）

console.log(add)
function add(a,b){
        return a+b;
}

注意：

嵌套函数的声明
函数和变量名相同时，会被覆盖

嵌套：

function add(){ function add2(){

    }   
}
console.log(typeof addnum);    // 控制台输出 → function
console.log(typeof add)        // 控制台输出 → undefined
 

覆盖：

let add=1;
function add(){
    //语句
}
console.log(typeof add)   // 控制台输出 → number

function

function add(){
      代码；   
}

形参函数声明时()内是形参。

求1+...+100,和
function add(){     //add()没有值
    let sum=0;
    for(let i=0;i<=100;i++){
        sum +=i;
    }
    console.log(sum);
}
add();

函数调用

add（）

实参调用函数，实际传入的参数

求1+...+100,和
function add(start,end){     
    let sum=0;
    for(let i=start;i<=end;i++){
        sum +=i;
    }
    console.log(sum);
}
add(1,100);  //1，100：传入的参数


案列：
求： 100——200偶数和
function add1(start,end){
    let sum=0;
    for(let n=start;n<=end;n++){
       if(n%2==0){
          sum+=n;
       }
    }
    console.log(sum);
}
add1(100,200);

return

返回值，输出运算结果；终止后续代码运行(后有console不会输出).
返回值，return是否需要我们函数运算的结果，进行下一次计算或函数调用的参数.

求1+...+100,和
function add(start,end){     
    let sum=0;
    for(let i=start;i<=end;i++){
        sum +=i;
    }
    return sum;   // 返回值
    //  console.log(sum);不会输出.
}
add(1,100);  //1，100：传入的参数

函数特征

1，有函数申明的关键字 function

2，函数标识符addnum（函数名）

3，形式参数(a,b)

4，函数体 a+b

5，返回值(return a+b);

函数作用域

函数调用的时候，会产生一个作用域。在函数内部申明的变量，叫局部变量.只有当前函数内部可以使用

返回值

函数运算结束后，返回的一个运算结果。就是返回值 return 数据

返回值 return 是否需要我们函数运算的结果，进行下一次计算或函数调用的参数。

参数

函数内部使用参数和函数形参保持一致

当函数内部需要使用外部的一个值，进行函数运算的时候，我们就为该函数进行传参。如果函数内部不需要参数就可以运算，就可以不传参

函数在进行计算时候，需要的条件值，就是参数。

参数分实参和形参。

实参就是实际传入的参数（调用），形参是申明函数时传入的参数，亦可作为函数的局部变量使用。

let add=function(num,num1){   //形参
     console.log(num);
}
add();             // 控制台输出 undefined
add(1,2,3,4,5);    // 控制台输出 1,2；

例：
      function add(a,b){
        console.log(a);
        console.log(b);
    }
    在上个申明的函数中，a和b代表的就是形参，
    add(1,2)//结果为：1，2
    add(1,2，3)//结果为：1，2
    add(1)//结果为：1，undedined;
    在调用函数的是传入的1,2为实参；定义未赋值undedined;所以说可以当局部变量

值传递

参数基本类型（number,boolean,string)；

var a=100;
function test(a){
    a++;
    console.log(a);
}
test(a);
console.log(a);

如果参数是复杂数据类型，那么会引起作用的反射；

例：
let arr=[1,2,3];
function add(obj){
    for(let i=0;i<obj.length;i++){
        obj[i]=obj[i]+1;
    }
    return obj;
}
console.log(add(arr));
console.log(arr);

基本数据类型，传入的是一个值，而我们复杂数据类型，传入的是一个地址
实参和形参的数量

arguments对象

arguments对象是和函数紧密结合在一起的，可以算是函数的一个属性argument，为当前执行的函数对象返回一个arguments对象;是一个伪数组。拥有一些数组的特性，比如有length属性，还可以通过下标去获取里面的参数值，也可以通过for来遍历，但它没有数组的方法。aguments对象，是一个假的数组。它并不能使用数组的方法。

 function add(){
     console.log(arguments);
 }
 add(1,2,3,4,5);   // 输出：['0':1,'1':2,'2':3, ... 5]



function add(){
     for(let i=0;i<arguments.length;i++){

         console.log(arguments[i]);
    } 
 }
 add(1,2,3,4,5);   // 输出 1,2,3,4,5

rest 不定参数/剩余参数

自定义一个标识符，在前面加上三个点(...)
把参数转化成真的数组。既然是真的数组，那么数组的方法，它都可以使用。

function add(a,b...rest){
     console.log(rest);
 }
 add(1,2,3,4,5,6,7,8);   // 输出：  3,4,5,6,7,8



function add(a,b...rest){
     rest.splice(0,3);
     console.log(rest);
 }
 add(1,2,3,4,5,6,7,8);   // 输出：  6,7,8

name ,length

function add(a,b,c,d,e){

}
add(1,2,3,4,5,6,7,8); 
console.log(add.name);      // 输出： add
console.log(add.length);    // 输出： 5

作用域

作用域（scope）指的是变量存在的范围。
这个作用域的范围确定，主要是我们的函数
申明函数后，在函数内部，进行的变量申明和函数，在函数外面是找不到的，我们称之为局部变量；比如我们的小名，在家里人，都知道，但是在外面。是不是就不知道。与之相反，就是在函数外面进行申明，这个就是全局变量。不使用var声明，会产生全局变量

var a=1;   //全局变量
let add=function(){   //作用域     let 不会提升；
    var b=2;                      var 会有变量提升，到当前代码块顶部.
}                             
console.log(b);



if(true){
    let c=3;             // let 产生块级作用域，在循环内有用
    console.log( c );    
}

例：
let scope="global";  
function fn(){
    let scope='local'；
    console.log(scope);
}
fn();
console.log(scope);

let scope="global";  
function fn(){
    console.log(scope);
    var scope='local'；
    console.log(scope);
}
fn();
console.log(scope);