var t = 10;
        function test(test){
            var t = ++test;//t text=11
            console.log(t);//11
        }
        test(t);
        console.log(t);//10
        /*
        *函式宣告提前；執行js程式碼前，解析器將當前作用域內宣告的所有變數和函
        *數都會放到作用域的開始處
        *1 function test（t）{}會提前宣告；
        *2 var t=10;
        *3 test(t); 執行函式 test(10);
        *4 function test(t){} 此時實參將10賦值給函式體的形參test 就是區域性變數 var text=10;
        *5 var t = ++test; t=11
        *6 函式體內 console.log(t) t=11;
        *7 外層函式 console.log(t);首先在自己函式域內尋找 發現var t=10; 則全域性變數t=10
         */
      
        var t = 10;
        function test(test){
            t = t + test;
            console.log(t);//20
        }
        test(t);
        console.log(t);//20

        /*
        *函式宣告提前；執行js程式碼前，解析器將當前作用域內宣告的所有變數和函
        *數都會放到作用域的開始處
        *1 function test（t）{}會提前宣告；
        *2 var t=10;
        *3 test(t); 執行函式 test(10);
        *4 function test(t){} 此時實參將10賦值給函式體的形參test 就是區域性變數 var test=10;
        *5 t = t+test; 此時test=10 t在自己本函式作用域尋找，沒找到向上一層尋找，找到全域性
        *               變數 var t=10; 然後t=t+test=20;此時改變的是全域性變數的值 var=20;
        *6 函式體內 console.log(t) t=20;
        *7 外層函式 console.log(t);首先在自己函式域內尋找 發現var t=20(第五步改變的值);
        *                           則全域性變數t=20
        */

    
        var t = 10;
        function test(test){
            t = t + test;
            console.log(t);//undefined+10=NaN
            var t = 3;
        }
        test(t);
        console.log(t);//10
        /*
        *函式宣告提前；執行js程式碼前，解析器將當前作用域內宣告的所有變數和函
        *數都會放到作用域的開始處
        *1 function test（t）{}會提前宣告；
        *2 var t=10;
        *3 test(t); 執行函式 test(10);
        *4 function test(t){} 此時實參將10賦值給函式體的形參test 就是區域性變數 var test=10;
        *5 t = t+test; 此時test=10 此時t會在本身函式作用域內尋找，由於var t=3;宣告會提前到
        *               函式體內的最前面，則var t;宣告但沒有賦值  t找到的時候，發現t 宣告
        *               但沒有賦值 所以t為undefine 則t=undefine+10=NaN    
        *6 函式體內 console.log(t) t=undefined;
        *7 外層函式 console.log(t);首先在自己函式域內尋找 發現var t=10;
        *                           則全域性變數t=10
        */
        
        
         function f(){
         alert(1);
        }
        f();
        function f(){
         alert(10);
        }
        f();
         /*
        *函式宣告提前；執行js程式碼前，解析器將當前作用域內宣告的所有變數和函
        *數都會放到作用域的開始處
        *1 第一個function f（）{}會提前宣告；第二個function f（）{}也會提前宣告
        *   但是發現兩個函式名相同，則發生覆蓋，只保留了第二個function f（）{}
        *2 f();則alert(10)被列印
        
        */