多重條件語句

1、 語法三：

    if(條件表達式){
        語句...
    }else if(條件表達式){
        語句...
    }else if(條件表達式){
        語句...
    }else{
        語句...
    }

if...else if...else當該語句執行時，會從上到下依次對條件表達式進行求值判斷

如果值為true，則執行當前語句。
如果值為false，則繼續向下判斷。
如果所有的條件都不滿足，則執行最后一個else后的語句
該語句中，只會有一個代碼塊被執行，一旦代碼塊執行了，則直接結束語

2、 條件分支語句也叫switch語句
語法：

        switch(條件表達式){
            case 表達式:
                語句...
                break;
            case 表達式:
                語句...
                break;
            default:
                語句...
                break;
        }

執行流程：switch...case..語句
在執行時會依次將case后的表達式的值和switch后的條件表達式的值進行全等比較，如果比較結果為true，則從當前case處開始執行代碼。
當前case后的所有的代碼都會執行，我們可以在case的后邊跟著一個break關鍵字，這樣可以確保只會執行當前case后的語句，而不會執行其他的case
如果比較結果為false，則繼續向下比較
如果所有的比較結果都為false，則只執行default后的語句
switch語句和if語句的功能實際上有重復的，使用switch可以實現if的功能，同樣使用if也可以實現switch的功能，所以我們使用時，可以根據自己的習慣選擇。

數組

1、創建數組

面向對象的方式創建
var aRr01 = new Array(1,2,3,'abc');

直接創建
var aRr02 = [1,2,3,'def'];//推薦使用，性能更高

獲取數組的成員數量（長度）
alert(aRr02.length);//彈出4
alert(aRr02[3]);//彈出cdf

var aRr03 = [[1,2,3],['a','b','c','d'],[true,false]];
alert(aRr03.length);//彈出3
alert(aRr03[1].length);//彈出3
alert(aRr03[1][2]);//彈出c

2、 數組常用方法
var aRr = [1,2,3,4];
用-連接數組元素并轉為字符串
var sTr = aRr.join("-");//用-連接數組元素并轉為字符串，彈出1-2-3-4

var sTr = aRr.join('');//用空串連接
alert(sTr);//彈出1234

向數組最后追加元素
aRr.push(5);
alert(aRr);//1,2,3,4,5

刪除末尾元素
aRr.pop();
alert(aRr);//1,2,3

向最前面插入元素0
aRr.unshift(0);
alert(aRr);//0,1,2,3,4

刪除第一個（索引為0的）元素
aRr.shift();
alert(aRr);//2,3,4

反轉
aRr.reverse();
alert(aRr);//4,3,2,1

查找字母'b'第一次出現的索引
var aRr2 = ['a','b','c','d','a','b','c','d'];
var num = aRr2.indexOf('b');
alert(num);//1

從第2索引元素開始，刪除1個元素
aRr2.splice(2,1);//刪除c
alert(aRr2);//a,b,d,a,b,c,d

從第2索引元素開始，刪除1個元素，再插入e
aRr2.splice(2,1,'e');//把c替換成e
alert(aRr2);//a,b,e,d,a,b,c,d

刪除后面的abcd，改為fghi
aRr2.splice(4,4,'f','g','h','i');
alert(aRr2);//a,b,c,d,f,g,h,i

3、數組去重
var aRr = [1,3,4,1,6,9,1,2,5,3,1,6,5,4,4];
var aRr2 = [];
for(var i=0; i<aRr.length; i++){
判斷元素第一次出現的位置，恰好是當前索引時，就將元素放入新數組
if(aRr.indexOf(aRr[i]) == i){
aRr2.push(aRr[i])

通過標簽獲取元素

1、window.onload = function(){
獲取頁面上所有的li
var aLi = document.getElementsByTagName('li');

        //獲取id為list01的ul
        var oList = document.getElementById('list01');
        //再獲取這個ul下的所有li
        var aLi = oList.getElementsByTagName('li');
        alert(aLi.length);//8
        // aLi.pop();//錯誤用法，aLi是一個類似數組的選擇集，沒有數組通用的一些方法

        aLi[0].style.backgroundColor = 'gold';
        aLi[1].style.backgroundColor = 'gold';

循環語句

循環語句：通過循環語句可以反復的執行一段代碼多次

1、 while循環
語法：

while(條件表達式){
    語句...
}

• while語句在執行時，先對條件表達式進行求值判斷，如果值為true，則執行循環體，循環體執行完畢以后，繼續對表達式進行判斷
  如果為true，則繼續執行循環體，以此類推
  如果值為false，則終止循環

2、 do...while循環
語法：

do{
    語句...
}while(條件表達式)

• 執行流程：
  do...while語句在執行時，會先執行循環體，循環體執行完畢以后，在對while后的條件表達式進行判斷，
  如果結果為true，則繼續執行循環體，執行完畢繼續判斷以此類推
  如果結果為false，則終止循環

實際上這兩個語句功能類似，不同的是while是先判斷后執行，而do...while會先執行后判斷，do...while可以保證循環體至少執行一次，而while不能

3、 for語句，也是一個循環語句，也稱為for循環

在for循環中，為我們提供了專門的位置用來放三個表達式：
1.初始化表達式
2.條件表達式
3.更新表達式

for循環的語法：

for(①初始化表達式;②條件表達式;④更新表達式){
        ③語句...
}

for循環的執行流程：
①執行初始化表達式，初始化變量（初始化表達式只會執行一次）
②執行條件表達式，判斷是否執行循環。
如果為true，則執行循環
③如果為false，終止循環
④執行更新表達式，更新表達式執行完畢繼續重復，任意一種循環都可以互相嵌套

創建一個循環，往往需要三個步驟
1.創初始化一個變量
var j = 0;
2.在循環中設置一個條件表達式
while(j < aLi.length){
aLi[j].style.background = 'gold';
3.定義一個更新表達式，每次更新初始化變量j++;

像這種將條件表達式寫死為true的循環，叫做死循環
該循環不會停止，除非瀏覽器關閉，死循環在開發中慎用
可以使用break，來終止循環

break關鍵字可以用來退出switch或循環語句
不能在if語句中使用break和continue
break關鍵字，會立即終止離他最近的那個循環語句
continue關鍵字可以用來跳過當次循環
同樣continue也是默認只會對離他最近的循環循環起作用

可以為循環語句創建一個label，來標識當前的循環
label:循環語句
使用break語句時，可以在break后跟著一個label，這樣break將會結束指定的循環，而不是最近的

字符串

1、字符串的處理方法

字符串切斷轉成數組
var sTr = '2018-06-20';
var aRr = sTr.split('-');
alert(aRr);//2018,06,20
console.log(aRr);

var aRr2 = sTr.split('');
console.log(aRr2);
實際上就是修改了<title>標簽的內容
document.title = aRr2;

var sTr2 = '#div1';
var sTr3 = '.div1';

獲取指定索引的字符
var sTr4 = sTr2.charAt(0);
if(sTr4 == '#'){
alert('id選擇器');
}

查看子串第一次出現的位置
var sTr5 = 'Microsoft Yahei';
var num = sTr5.indexOf('Yahei');
alert(num);//10

var num2 = sTr5.indexOf('xihei');
alert(num2);//沒有找到就彈出-1

substring截取子串
從10開始，截到15（包括開始位置，不包括結束位置）
var sTr6 = sTr5.substring(10,15);//Yahei
從10開始截取到末尾
var sTr6 = sTr5.substring(10);//Yahei
alert(sTr6);

全部轉為大寫字母
alert(sTr6.toUpperCase());//YAHEI
全部轉為小寫字母
alert(sTr6.toLowerCase());//yahei

2、 字符串反轉
var sTr = "123asdf79888asdfe21";
1、split字符串轉成數組
2、reverse數組反轉
3、join數組轉成字符串
var sTr2 = sTr.split('').reverse().join('');
alert(sTr2);//12efdsa88897fdsa321

定時器

1、定時器彈框

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>定時器彈框</title>
    <style type="text/css">
        .pop{
            width: 400px;
            height: 300px;
            background-color: #fff;
            border: 1px solid #000;
            /*固定定位*/
            position: fixed;
            /*左上角位于頁面中心*/
            left: 50%;
            top: 50%;
            /*讓div向左偏移半個寬度、向上偏移半個高度，使div位于頁面中心*/
            margin-left: -200px;
            margin-top: -150px;
            /*彈窗在最上面*/
            z-index: 9999;
        }
        /*遮罩樣式*/
        .mask{
            position: fixed;
            width: 100%;
            height: 100%;
            background-color: #000;
            left: 0;
            top: 0;
            /*設置透明度30%*/
            opacity: 0.3;
            filter: alpha(opacity=30);/*兼容IE6、7、8*/
            /*遮罩在彈窗的下面，在網頁所有內容的上面*/
            z-index: 9990;
        }
        .pop_con{
            display: none;/*默認不顯示，用定時器顯示*/
        }
    </style>
    <script type="text/javascript">
        /*
        setTimeout      只執行一次的定時器
        clearTimeout    關閉只執行一次的定時器
        setInterval     反復執行的定時器
        clearInterval   關閉反復執行的定時器
        */

        window.onload = function(){
            var oPop = document.getElementById('pop');
            var oShut = document.getElementById('shutOff');

            /*setTimeout(showPop, 3000);//開啟定時器，3秒后調用函數showPop()彈框

            function showPop(){
                oPop.style.display = 'block';//顯示彈框和遮罩
            }*/
            //開啟定時器的簡寫方式：調用匿名函數
            setTimeout(function(){
                oPop.style.display = 'block';
            }, 3000);

            oShut.onclick = function(){
                oPop.style.display = 'none';//關閉彈框和遮罩
            }
        }
    </script>
</head>
<body>
    <h1>首頁標題</h1>
    <p>頁面內容</p>
    <a >百度網</a>


    <div class="pop_con" id="pop">
        <div class="pop">
            <h3>提示信息！</h3>
            <a href="#" id="shutOff">關閉</a>
        </div>
        <div class="mask"></div>
    </div>
</body>
</html>

2、 定時器基本用法
單次定時器
var timer = setTimeout(function(){
alert('hello!');
}, 3000);

清除單次定時器
clearTimeout(timer);

反復循環定時器
var timer2 = setInterval(function(){
alert('hi~~~');
}, 2000);

清除反復循環定時器
clearInterval(timer2);

3、定時器動畫

<style type="text/css">
        .box{
            width: 100px;
            height: 100px;
            background-color: gold;
            position: fixed;
            left: 20px;
            top: 20px;
        }
    </style>
    <script type="text/javascript">
        window.onload = function(){
            var oBox = document.getElementById('box');

            var left = 20;
            //反復循環定時器，每30毫秒修改一次盒子的left值
            var timer = setInterval(function(){
                left += 2;
                oBox.style.left = left + 'px';

                //當left值大于700時停止動畫（清除定時器）
                if(left > 700){
                    clearInterval(timer);
                }
            },30);
        }
    </script>

4、 時鐘

<script type="text/javascript">
        window.onload = function(){
            var oBox = document.getElementById('box');

            function timeGo(){
                var now = new Date();
                // alert(now);//彈出美式時間：Wed Jun 20 2018 15:27:13 GMT+0800 (中國標準時間)
                var year = now.getFullYear();//2018年
                var month = now.getMonth() + 1;//6月彈出5//范圍0-11
                var date = now.getDate();//20號
                var week = now.getDay();//3//星期幾，西半球時間，范圍0-6，星期日為一周的第一天，為0

                var hour = now.getHours();
                var minute = now.getMinutes();
                var second = now.getSeconds();

                // alert(hour + ":" + minute + ":" + second);//15:33:9

                oBox.innerHTML = '當前時間是：' + year + '年' + toDouble(month) + '月' + toDouble(date) + '日 ' + toWeek(week) + ' ' + toDouble(hour) + ":" + toDouble(minute) + ":" + toDouble(second);
            }

            timeGo();
            setInterval(timeGo, 1000);
        }

        //此函數將星期的數字轉為漢字表示
        function toWeek(num){
            switch(num){
                case 0:
                    return '星期天'; 
                    break;
                case 1:
                    return '星期一'; 
                    break;
                case 2:
                    return '星期二'; 
                    break;
                case 3:
                    return '星期三'; 
                    break;
                case 4:
                    return '星期四'; 
                    break;
                case 5:
                    return '星期五'; 
                    break;
                case 6:
                    return '星期六'; 
                    break;
            }
        }

        //此函數將不足兩位的數字前面補0
        function toDouble(num){
            if(num < 10){
                return '0' + num;
            }else{
                return num;
            }
        }
    </script>

5、 倒計時

<script type="text/javascript">
        window.onload = function(){
            //活動第二天要將頁面下線，直接跳轉到其它頁面，不會走后面的代碼了
            // window.location.;

            var oDiv = document.getElementById('div1');

            function timeLeft(){
                //實際開發中此時間從服務器獲取，避免客戶端調整時間
                var now = new Date();
                var future = new Date(2018,5,20,16,30,20);

                // alert(future - now);//彈出與當前時間相差的毫秒數：12469935436
                var milli = parseInt((future - now)/1000);

                //活動當天頁面下線，避免倒計時到點后繼續計負時
                // if(milli <= 0){
                //  //頁面跳轉，不執行下面的代碼了
                //  window.location.;
                // }

                var day = parseInt(milli / 86400);
                var hour = parseInt(milli % 86400 / 3600);
                var minute = parseInt(((milli % 86400) % 3600) / 60);
                var second = milli % 60;

                oDiv.innerHTML = '距離2018年11月12日00時00分00秒還有' + day + '天' + toDouble(hour) + '時' + toDouble(minute) + '分' + toDouble(second) + '秒';
            }
            
            timeLeft();
            setInterval(timeLeft, 1000);
        }

        function toDouble(num){
            if(num < 10){
                return '0' + num;
            }else{
                return num;
            }
        }
    </script>

變量的作用域

全局變量：函數外部定義的變量，函數內部和外部都可以訪問，它的值可以共享

局部變量：函數內部定義的變量，函數內部可以訪問，外部無法訪問。函數內部訪問變量時，先在內部查找是否有此變量，如果有，就使用內部變量，如果沒有，就去外部查找

函數內部如果不用'var'關鍵字定義變量，變量可能會變成全局變量，如果用嚴格模式解析會報錯

封閉函數

1、 封閉函數

<script type="text/javascript">
        /*原來的寫法
        function myAlert(){
            var str = '歡迎訪問我的主頁';
            alert(str);
        }

        myAlert();*/

        var str = function(){
            alert('test');
        }
//封閉函數其他的寫法：在匿名函數前加“！”或者“~”，之后加“()”
        ~function(){
            var str = '歡迎訪問我的主頁';
            alert(str);
        }();

封閉函數的一般寫法
封閉函數定義：(function(){……})()
;;(function(){
var str = '歡迎訪問我的主頁';
alert(str);
})();//最后的()表示馬上執行

2、 用變量的方式定義函數
原來的寫法：可以提前myAlert();
function myAlert(){
alert('hello!');
}

函數用變量方式定義：先定義再使用myalert();
提前會報錯
var myAlert = function(){
alert('hello!');
}
myAlert();//放在下面可以執行

3、閉包
閉包的本質就是函數嵌套，就是在函數里面定義函數，內部函數可以引用外部函數的參數和變量
參數和變量不會被垃圾回收機制給回收
閉包的用途：可以存循環的索引值、做私有變量計數器
閉包的一般寫法
function aa(b){
var a = 12;

function bb(){
alert(a);
alert(b);
}

return bb;
}

var cc = aa(24);

閉包的封閉函數寫法
var cc = (function(b){
var a = 12;
function bb(){
alert(a);
alert(b);
}
return bb;})(24);cc();

只能調用一次的閉包
(function(b){
var a = 12;
function bb(){
alert(a);
alert(b);
}
return bb;})(24)();