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標籤

<script>
    function f1(){
        document.write("上一個函式");
    }
    f1();//這裡呼叫f1()函式輸出:上一個函式
    //下面script標籤裡的f1()函式  並不會對這裡造成影響
</script>
<script>
    f1();//在這裡呼叫f1()輸出的是:下一個函式
    // 與預解析會將函式程式碼發到所在script標籤所在塊內的最上面;然後從上到下一次執行程式碼
    function f1(){
        document.write("下一個函式");
    }

</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]+" ");
 }