Js中arguments的使用、函数自调用、变量作用域、函数作为参数传入、函数作为返回值

1，arguments是一个比较特别的对象，每个函数中都有一个arguments，它接收函数传入的参数，以数组的形式存放在 arguments，可遍历

//1,需求:求任意数的最大值
 function getMax(){
     var Max = arguments[0];         //arguments接收传进来的参数,通过下标可以索引
     for (i = 1;i< arguments.length; i
         if(Max < arguments[i]){
             Max = arguments[i];
         }
     }
     return Max;
 }
 document.write(getMax(4,6,5,8,3));//传入四个参数

2,return可以返回一个数组

//需求:将数组进行转置
function reversal(arr){
    // var temp;
    for(var i = 0;i < arr.length/2; i++){
        var temp = arr[i] ;
        arr[i] =  arr[arr.length - 1 -i];
        arr[arr.length - 1 -i] = temp;
     }
     return arr; //将转置后的数组作为返回值返回
}
//测试:
arr1 = [1,2,3,4,5,6,7] ;
var arr = reversal(arr1);//arr变量接收返回的数组
for(var i = 0; i < arr.length; i++){
    document.write(arr[i]+" ")
}

3, 函数的自调用:

函数有三种什么方法:1,通过function 函数名(参数){代码块}  进行定义,

2,var fn = function(参数){代码块};

3,匿名法定义函数  function(){代码块};  

匿名法定义的函数无法调用,只能通过自调用来执行函数;在定义的同时直接调用函数,只能调用一次,因此他有被称为一次性函数

(function(){alert("我是hongbo")})()

4,变量的作用域

变量分为全局变量和局部变量,全局变量可以在任何地方访问到,局部变量只能在固定的代码段才能访问到.

任何一对花括号({})中的语句都属于块,在这个块中定义的变量,块外是不可见的,但js中并没有块级作用域,只有函数块中的作用域,在函数块中用var声明的变量,函数的外部是不可见的,但是没有用var声明的变量,属于隐式全局变量,在函数被调用后,函数中的隐式全局变量才会生效.

js中语法作用域的规制:  函数可以访问函数外部的数据、整个代码结构中可以限定作用域、作用域首先使用提升规则分析（即js的域解析原理）、如果当前作用规则中有名字了，就不考虑外面的名字（屏蔽效应）

function f1() {
    var num = 456;
    function f2() {
        var num = 123;
        console.log( num );
    }
    f2();   //在函数f1()中调用了f2
}
var num = 789;//全局变量num和f1()函数中的变量num的值相同?
f1();  //输出结果为 123;
//证明f1()中的num屏蔽了全局变量num;而f2()中的num又屏蔽了f1中的num,因此输出的是f2()中的num变量

5，js中的预解析原理

JavaScript代码的执行是由浏览器中的JavaScript解析器来执行的。
JavaScript解析器执行JavaScript代码的时候，分为两个过程：预解析过程和代码执行过程

预解析过程：1、把变量的声明提升到当前作用域的最前面，值会提升不会对变量进行赋值  2、把函数的声明提升到当前作用域最前面，只提升，不会对函数进行调用，3、先提升var 再提升function（当var和函数名相同时，函数优先）

var a = 25;
function abc (){
    alert(a);//undefined,为什么是undefined;首先内部变量a被提升到函数abc作用域的最前面,但没有被赋值,
            // 外部的a变量被屏蔽!
            //调用方法alert(a),此时a没有被赋值,因此对话框弹出undefined
    var a = 10;
}
abc();//调用

下面几个案例：关于代码的预解析

//案列一:
    var num = 10;
     fun(); //输出的值为undefined : 函数被提升到最前面,函数中的变量num被提升到函数块中的最前面(num被没有),
           // num将外部的全局变量num屏蔽,所有当调用函数执行console.log(num)时num只有定义没有赋值,为undefined
     function fun(){
         console.log(num);
         var num = 20;
     }


    //案列二:
     var a = 18;
     f1(); //输出undefined 和 9  理由同案例一,正常输出9
     function f1() {
         var b = 9;
         console.log(a);
         console.log(b);
         var a = '123';
     }

    //案列三:
    f1();
     console.log(c); //9
     console.log(b); //9
     console.log(a); // a is not defined  //a,b,c  只会提升到函数块的最前端,但不能出函数
     function f1(){
         var a = b = c = 9;  //a为全局变量, b c为隐式全局变量
        console.log(a);//9
         console.log(b);//9
         console.log(c);//9
     }

关于两个script标签中预解析 :预解析,只会将函数提升到它所在的script标签的最上面,不会越出script标签

6,函数的返回值

函数的返回值可以是一个数组

//3,需求:对数组排序，从小到大
 function sortArr(arr){
     var i = arr.length - 1;
     var temp;
     var lastExchangeIndex;
     while(i > 0){
        var lastExchangeIndex = 0;
        for(var j = 0; j < i; j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                lastExchangeIndex = j;
            }//if
        }//for
         i = lastExchangeIndex;
     }//while
     return arr;
 }
// 测试:
 arr1 = [5,4,3,2,1];
 arr = sortArr(arr1);
 for(var i = 0; i < arr.length; i++){
     document.write(arr[i]+" ");
 }