資訊專欄INFORMATION COLUMN
摘要：如圖意義位用來表示符號位位用來表示指數(shù)位表示尾數(shù)浮點數(shù)，比如無限循環(huán)無限循環(huán)此時只能模仿十進(jìn)制進(jìn)行四舍五入了，但是二進(jìn)制只有和兩個，于是變?yōu)樯崛搿＿@即是計算機中部分浮點數(shù)運算時出現(xiàn)誤差，丟失精度的根本原因。
前言
最近一直有小伙伴跟我說JS有很多知識點經(jīng)常不用，已經(jīng)忘記的差不多了。平時找一個小問題都要在網(wǎng)上找半天，希望能有一套比較全面的筆記或者文章。但是網(wǎng)上的文章太過于分散，學(xué)習(xí)起來不是很方便。恰巧最近比較閑，所以為大家整理出來了一套比較全面的JS基礎(chǔ)階段的文章，對于初學(xué)者還是很有幫助的，如果你是一名熟練掌握JS的攻城獅，你可能會覺得文章寫得太過于啰嗦，但是為了照顧大家，啰嗦一點還是有必要的。
這篇文章主要講的是關(guān)于JS基礎(chǔ)的知識點，后面會陸續(xù)更新DOM、JS高階、Ajax、H5C3、JQ，包括一些主流的框架，但是本人時間有限，不可能專門去花費時間來寫，而且工作量也是非常大的，所以喜歡的小伙伴可以點一波關(guān)注，后續(xù)會陸續(xù)更新。
由于是自己所寫，所以里面有些語言可能表達(dá)的有些不明確，不明白的可以給我留言。
1. 初識JS 1.1 什么是JS語言javascript是一種運行在客戶端 的腳本語言
客戶端： 即接受服務(wù)的一端，與服務(wù)端相對應(yīng)，在前端開發(fā)中，通?？蛻舳酥傅木褪?b>瀏覽器。
腳本語言： 也叫解釋型語言，特點是執(zhí)行一行，解釋一行，如果發(fā)現(xiàn)報錯，代碼就停止執(zhí)行。
1.2 JS的三個組成部分javascript的三個組成部分：ECMAScript、BOM、DOM
ECMAScript： 定義了javascript的語法規(guī)范。
BOM： 一套操作瀏覽器功能的API。
DOM： 一套操作頁面元素的API。
1.3 script 標(biāo)簽1、script標(biāo)簽的書寫方式
書寫Javascript代碼有兩種方式，第一種是直接在script標(biāo)簽中書寫，第二種是將代碼寫在js文件中，通過script的src屬性進(jìn)行引入。
直接在script中書寫javascript代碼：
通過script標(biāo)簽引入一個JS文件，需要指定src屬性:
如果script標(biāo)簽指定了src屬性，說明是想要引入一個js文件，這個時候不能繼續(xù)在script標(biāo)簽中寫js代碼，即便寫了，也不會執(zhí)行。
2、script標(biāo)簽的書寫位置
script標(biāo)簽的書寫位置，原則上來說，可以在頁面中的任意位置書寫。
寫在head標(biāo)簽中，style標(biāo)簽之后：
Document
瀏覽器有一個特性，就是在遇到標(biāo)簽時才開始呈現(xiàn)內(nèi)容。如果在head里面引用js文件的話，意味著必須要等到全部的javascript代碼都被下載、解析和執(zhí)行完成之后，才能開始呈現(xiàn)頁面的內(nèi)容。如果文件數(shù)量一旦過多，將會影響頁面加載速度，此時頁面有可能會在加載完成前一片空白。
寫在標(biāo)簽的前面：
Document
在解析javascript代碼之前，頁面的內(nèi)容已經(jīng)完全呈現(xiàn)在瀏覽器當(dāng)中了，用戶會明顯感覺頁面加載變快了。
1.4 js中輸入輸出語句console.log 控制臺輸出日志
console.dir 對象的形式打印一個對象
document.write 往頁面中寫入內(nèi)容
alert 彈框警告
confirm 確認(rèn)框
prompt 輸入框
1.5 注釋不被程序執(zhí)行的代碼。用于程序員標(biāo)記代碼，在后期的修改，以及他人的學(xué)習(xí)時有所幫助，在JS中，分為單行注釋和多行注釋以及文檔注釋。
單行注釋
//這是單行注釋，只能注釋一行
多行注釋
/*
這是多行注釋，不能嵌套
*/
文檔注釋
/**
* 求圓的面積
* @param r {number} 圓的半徑
* @returns {number} 圓的面積
* 這是文檔注釋
*/
function getArea (r) {
return Math.PI * r * r;
}
注釋的作用
模塊劃分，方便代碼查找和維護(hù)
用于解釋復(fù)雜代碼的邏輯，方便維護(hù)和后期開發(fā)。
2. 變量變量，可以變化的量，變量是在計算機中存儲數(shù)據(jù)的一個標(biāo)識符。可以把變量看成存儲數(shù)據(jù)的容器。
變量與字面量：
字面量：10、20、“abc”、true這種從字面上就能看出來類型和值的量叫做字面量。
變量：可以變化的量。
2.1 變量的聲明與賦值// 1- 同時聲明并且賦值
var num = 100;
console.log(num); // 100
// 2- 先聲明了一個變量，再賦值
var num1;
num1 = 100;
console.log(num1); // 100
// 3- 沒有聲明變量，直接賦值（可以，但是不推薦）
num2 = 200;
console.log(num2); // 200
// 4- 有變量聲明，但是沒有賦值（可以，沒有賦值，變量的值默認(rèn)是個undefined）
var num9;
console.log(num9); // undefined
// 5- 既沒有聲明，也沒有賦值，直接用。
console.log(num3); //報錯 num3
// 6- 一個 var，逗號分隔 可以同時聲明多個變量
var name = "Levi丶",
age = 18,
gender = "男";
2.2 變量的命名規(guī)則與規(guī)范
命名規(guī)則（必須遵守）：
由字母、數(shù)字、下劃線、$符號組成，開頭不能是數(shù)字。
不能使用關(guān)鍵字和保留字
區(qū)分大小寫
命名規(guī)范（建議遵守）：
命名要有意義
遵守駝峰命名法。首字母小寫，后面單詞的首字母需要大寫。
2.3 交換兩個變量的值方法一: 聲明一個新的變量
// 交換 num1 和 num2的值 var num1 = 11; var num2 = 22; var temp; temp = num1; // num1=11 temp=11 num1 = num2; // num1=22 num2=22 num2 = temp; // temp=11 num2=11
方法二: 不通過聲明變量的方式
// 不使用臨時變量 var num1 = 11; var num2 = 22; // num1 = 11 + 22 num1 = num1 + num2; // num1=33 // num2 = 33 - 22 num2 = num1 - num2; // num2=11 // num1 = 33 - 11 num1 = num1 - num2; // num1=223. 數(shù)據(jù)類型
基本數(shù)據(jù)類型包括了：number、string、boolean、undefined、null3.1 如何查看數(shù)據(jù)類型
使用typeof關(guān)鍵字查看數(shù)據(jù)類型
typeof(name); // 括號可以省略 typeof name;3.2 Number 類型
進(jìn)制
十進(jìn)制，我們平時使用的就是十進(jìn)制，進(jìn)行運算時，八進(jìn)制和十六進(jìn)制的值最終都會轉(zhuǎn)換成十進(jìn)制。
二進(jìn)制，計算機當(dāng)中用的最多的計算方式，數(shù)值序列只有0和1
八進(jìn)制，0開頭的數(shù)值，數(shù)值序列：0-7
十六進(jìn)制，0x開頭的數(shù)值，數(shù)值序列：0-9、A-F、a-f
浮點數(shù)
所謂浮點數(shù)，就是該數(shù)當(dāng)中必須包含一個小數(shù)點，并且小數(shù)點后面至少有一位數(shù)字。
科學(xué)計數(shù)法：
//如何表示0.003和20000？ var num = 3e-3; // 0.003 var num2 = 2e+4; // 20000
浮點數(shù)的精度問題：
0.1 + 0.2 = ? // 0.30000000000000004 0.07 * 100 = ? // 7.000000000000001
浮點數(shù)在運算的時候會出現(xiàn)精度丟失的問題，因此在做比較運算的時候，盡量不要用小數(shù)進(jìn)行比較。在第五章的時候會著重講解這個問題
數(shù)值范圍
javascript不能表示世界上所有的數(shù)，因此在javascript中，數(shù)值大小是有一定限制的。
Number.MIN_VALUE:5e-324 (js里面能表示最小的數(shù))
Number.MAX_VALUE:1.7976931348623157e+308 (js里面能表示最大的數(shù))
Infinity:正無窮 (如果超出js里面最大的數(shù)，將會顯示infinity)
-Infinity:負(fù)無窮 (如果超出js里面最小的數(shù)，將會顯示-infinity)
數(shù)值判斷
NaN: 表示一個非數(shù)值，當(dāng)無法運算或者運算錯誤的時候，會得到一個NaN，NaN是number類型，表示一個非數(shù)值。
NaN與任何值都不想等，包括它本身
isNaN: 用來判斷是否是一個數(shù)字，當(dāng)返回true的時候說明是NaN，表示的不是一個數(shù)字，返回false，說明不是NaN，表示的是一個數(shù)字。
示例代碼：
var str = "abc"; console.log(isNaN(str)); // true 說明不是一個數(shù)字3.3 String 類型
字面量
字符串的字面量：“abc” 、 ‘a(chǎn)bc’ 字符串可以是雙引號，也可以是單引號引起來。
不管是雙引號，還是單引號，都是成對出現(xiàn)的，假如打印的字符串里有引號怎么辦呢？
這里就要活學(xué)活用，如果只有一處有引號，就可以用單雙引號混合使用：
console.log("我是"帥哥""); // ==> 我是"帥哥"
假如引號非常多的時候怎么辦呢？ 用轉(zhuǎn)義字符:“”：
console.log("我是"帥哥","哈哈哈""); // ==> 我是"帥哥","哈哈哈"
字符串拼接
拼接字符串使用+號
示例代碼：
console.log(11 + 11); // 22
console.log("hello" + " world"); // "hello world"
console.log("100" + "100"); // "100100"
console.log("11" + 11); // "1111"
總結(jié)：
兩邊只要有一個是字符串，那么+就是字符串拼接功能
兩邊如果都是數(shù)字，那么就是算術(shù)功能。
字符串長度
length屬性用來獲取字符串的長度
var str = "abcdefghij"; str.length;// 字符串的長度 103.4. boolean 類型
boolean類型只有兩個字面量，true和false，區(qū)分大小寫(True，F(xiàn)alse不是布爾類型，只是標(biāo)識符)。
所有類型的值都可以轉(zhuǎn)化成true或者false
NaN、""、undefined、null、alse、0 這6個值可以轉(zhuǎn)換成false，其余的都是true。
3.5 undefined類型與null類型undefined表示一個聲明了沒有賦值的變量
var name ; console.log(name); // undefined
null表示一個空的對象
var name = null; console.log(typeof name); // Object
如果定義的變量，將來是準(zhǔn)備用于保存對象的話，最好將變量初始化為null
var name = null;
undefined 與 null 的關(guān)系
undefined == null; // true undefined === null; // false
實際上，undefiner值是派生自null值的，所以判斷相等時為true，但是兩種用途是完全不一樣的。
4. 簡單數(shù)據(jù)類型轉(zhuǎn)換如何使用谷歌瀏覽器，快速的查看數(shù)據(jù)類型？
字符串的顏色是黑色的
數(shù)值類型是藍(lán)色的
布爾類型也是藍(lán)色的
undefined和null是灰色的
這個在調(diào)試過程中時非常有用的。
4.1 轉(zhuǎn)字符串類型1、String()函數(shù)轉(zhuǎn)換
var num = 123; console.log(String(num)); // "123"
2、toString() 轉(zhuǎn)換不了undefined 和 null
var num = 123; console.log(num.toString()); // "123" console.log(undefined.toString()); // 報錯 console.log(null.toString()); // 報錯
3、+ "" 加引號
var num = 123; console.log(num + ""); // "123"4.2 轉(zhuǎn)數(shù)值類型
1、Number
如果轉(zhuǎn)換的是空字符串，返回的是0；
如果是數(shù)字字符串，轉(zhuǎn)換后保留原數(shù)據(jù)；
非數(shù)字字符串，轉(zhuǎn)換之后為NaN；
console.log(Number("-123")); // -123
console.log(Number("")); // 0
console.log(Number("123abc")); // NaN
2、parseInt(取整)
小數(shù)數(shù)字字符串，轉(zhuǎn)換之后，保留整數(shù)部分(取整)；
數(shù)字開頭非純數(shù)字字符串，轉(zhuǎn)換之后保留整數(shù)部分；
非數(shù)字字符串，轉(zhuǎn)換之后為NaN；
console.log(parseInt("123.123")); // 123
console.log(parseInt("123.123abc")); // 123
console.log(parseInt("abc123.123")); // NaN
console.log(parseInt("")); // NaN
console.log(parseInt("abc")); // NaN
3、parseFloat(取數(shù))
數(shù)字字符串，轉(zhuǎn)換之后保留原數(shù)據(jù)；
數(shù)字開頭的非純數(shù)字字符串，轉(zhuǎn)換之后保留數(shù)字部分(包括小數(shù))；
非數(shù)字字符串轉(zhuǎn)換之后為NaN；
console.log(parseFloat("123.123")); // 123.123
console.log(parseFloat("123.123abc")); // 123.123
console.log(parseFloat("abc123.123")); // NaN
console.log(parseFloat("")); // NaN
console.log(parseFloat("abc")); // NaN
4、參與運算==> "+" or "-0"
var str = "-123"; console.log(+str); // -123 console.log(str-0); // -1234.3 轉(zhuǎn)布爾類型
布爾類型只有true和false，但是所有類型的值都可以轉(zhuǎn)換成布爾類型
1、能夠轉(zhuǎn)換成false的只有6種：
""
0
NaN
undefined
null
false
其余的都是true
2、! 轉(zhuǎn)換
var str = ""; // Boolean() 判斷這個參數(shù)的布爾類型 console.log(Boolean(str)); // false console.log(!str); // true5. JS小數(shù)運算精度丟失 5.1 JS數(shù)字精度丟失的一些典型問題
js在使用小數(shù)進(jìn)行計算的時候，會出現(xiàn)精度丟失的問題。不要用來跟其他的小數(shù)做比較。
0.1 + 0.2 != 0.3 //true 0.30000000000000004 // 16位數(shù) 和 17位數(shù)相等 9999999999999999 == 10000000000000001 // true 9007199254740992 + 1 == 9007199254740992 // true5.2 JS數(shù)字丟失精度的原因
計算機的二進(jìn)制實現(xiàn)和位數(shù)限制有些數(shù)無法有限表示。就像一些無理數(shù)不能有限表示，如 圓周率 3.1415926...，1.3333... 等。JS 遵循 IEEE 754 規(guī)范，采用 雙精度存儲（double precision） ，占用 64 bit。如圖
意義：
1位用來表示符號位
11位用來表示指數(shù)
52位表示尾數(shù)
浮點數(shù)，比如：
0.1 >> 0.0001 1001 1001 1001…（1001無限循環(huán)） 0.2 >> 0.0011 0011 0011 0011…（0011無限循環(huán)）
此時只能模仿十進(jìn)制進(jìn)行四舍五入了，但是二進(jìn)制只有0和1兩個，于是變?yōu)?b>0舍1入。這即是計算機中部分浮點數(shù)運算時出現(xiàn)誤差，丟失精度的根本原因。
大整數(shù)的精度丟失和浮點數(shù)本質(zhì)上是一樣的，尾數(shù)位最大是 52 位，因此 JS 中能精準(zhǔn)表示的最大整數(shù)是 Math.pow(2, 53)，十進(jìn)制即 9007199254740992。
大于 9007199254740992 的可能會丟失精度：
9007199254740992 >> 10000000000000...000 // 共計 53 個 0 9007199254740992 + 1 >> 10000000000000...001 // 中間 52 個 0 9007199254740992 + 2 >> 10000000000000...010 // 中間 51 個 0
實際上：
9007199254740992 + 1 // 丟失 9007199254740992 + 2 // 未丟失 9007199254740992 + 3 // 丟失 9007199254740992 + 4 // 未丟失
結(jié)果如圖：
以上，可以知道看似有窮的數(shù)字,在計算機的二進(jìn)制表示里卻是無窮的，由于存儲位數(shù)限制因此存在“舍去”，精度丟失就發(fā)生了。
5.3 JS數(shù)字丟失精度的解決方案對于整數(shù)，前端出現(xiàn)問題的幾率可能比較低，畢竟很少有業(yè)務(wù)需要需要用到超大整數(shù)，只要運算結(jié)果不超過 Math.pow(2, 53) 就不會丟失精度。
對于小數(shù)，前端出現(xiàn)問題的幾率還是很多的，尤其在一些電商網(wǎng)站涉及到金額等數(shù)據(jù)。解決方式：把小數(shù)放到位整數(shù)（乘倍數(shù)），再縮小回原來倍數(shù)（除倍數(shù)）
// 0.1 + 0.2 (0.1*10 + 0.2*10) / 10 == 0.3 // true6. 運算符 6.1 一元運算符
一元運算符有1個操作數(shù)。例如，遞增運算符"++",或者遞減運算符"--"就是一元運算符。
二元運算符有2個操作數(shù)。例如，除法運算符"/"有2個操作數(shù)。
三元運算符有3個操作數(shù)。例如，條件運算符"?:"具有3個操作數(shù)。
遞增 "++" 和 遞減 "--" 還分為前自增或后自增，前自減或后自減,兩種自增自減的運算結(jié)果是不一樣的;
++num 前自增 --num 前自減 先+1或-1，再返回值
num++ 后自增 num-- 后自減 先返回值，再+1或-1
舉個例子，看代碼：
var num = 5; console.log(num++); // 5 console.log(++num); // 7 (因為剛剛num自增了一次，這里打印的話就等于在6的基礎(chǔ)上前自增了,在計算機科學(xué)中，被稱為副效應(yīng)) console.log(num--); // 7 (這里是后自減，所以先返回值，返回7，再運算--，此時的num實際是等于6了) console.log(--num); // 56.2 邏輯運算符
&&(與運算):只要有一個值為假，結(jié)果就是假。找假值 找到假值就返回，如果都是真，返回最后一個
||(或運算):只要有一個值為真，結(jié)果就是真。找真值 找到真值就返回，如果都是假，返回最后一個
!(非運算):取反
示例代碼：
/*細(xì)讀上面三句話，就能理解為什么會是這個打印結(jié)果了*/
console.log(true && true); //true
console.log(false || false); //false
console.log(null && undefined); //null
console.log(null || undefined); //undefined
console.log("abc" && undefined); //undefined
console.log("abc" || undefined); //abc
console.log(null || false || 0 || 1 || null); //1
console.log("abc" && "bcd" && "def"); //def
6.3 運算符的優(yōu)先級
1、() 優(yōu)先級最高
2、一元運算符 ++ -- !
3、算數(shù)運算符 先* / % 后 + -
4、關(guān)系運算符 > >= < <=
5、相等運算符 == != === !==
6、邏輯運算符 先&& 后||
示例代碼：
// 第一題 true && true
console.log(((4 >= 6) || ("人" != "狗")) && !(((12 * 2) == 144) && true)); // true
// 第二題
var num = 10;
// true && true
if(5 == num / 2 && (2 + 2 * num).toString() === "22") {
console.log(true); // true
}else{
console.log(false);
}
7. 選擇語句
7.1 if..else語句
語法：
只有一個判斷條件的時候 if..else：
if(判斷條件){ // 當(dāng)判斷條件為true的時候執(zhí)行代碼1，為false的時候執(zhí)行代碼2
代碼1;
}else{
代碼2;
}
當(dāng)不止一個判斷條件的時候 else用else if 代替：
if(判斷條件1){ // 判斷條件 1 為 true 的時候執(zhí)行 代碼 1
代碼1;
}else if(判斷條件2){ // 判斷條件 2 為 true 的時候執(zhí)行 代碼 2
代碼2;
}else{ // 兩個條件都不滿足的時候執(zhí)行代碼 3
代碼3;
}
思考1：
如果滿18，告訴他可以看電影
如果滿了16，告訴他可以在家長的陪同下觀看
如果不夠16，告訴他不準(zhǔn)看
var age = 20;
if(age >= 18){
console.log("沒時間解釋了，趕緊上車吧"); // 打印這條
}else if(age >= 16){
console.log("請在家長的陪同下觀看");
}else {
console.log("回家學(xué)習(xí)吧");
}
思考2：
根據(jù)new Date().getDay()獲取今天是星期幾
由于獲取到的是純數(shù)字，現(xiàn)在需要根據(jù)這個數(shù)字輸出"今天是周*"的字符串
var date = new Date(); // 獲取當(dāng)前的時間
var week = date.getDay(); // 獲得 0-6 表示周幾 0:星期日
if(week == 0){
console.log("今天是星期天");
}else if(week == 1){
console.log("今天是星期一");
}else if(week == 2){
console.log("今天是星期二");
}else if(week == 3){
console.log("今天是星期三");
}else if(week == 4){
console.log("今天是星期四");
}else if(week == 5){
console.log("今天是星期五");
}else if(week == 6){
console.log("今天是星期六");
}else{
console.log("你火星的來的吧");
}
7.2 switch..case
語法：
// switch: 開關(guān); case: 案列;
switch(變量){ // 判斷變量是否全等于case的值1，或者值2，
case 值1:
執(zhí)行代碼1; // 全等于的時候執(zhí)行代碼1
break; // 然后break；代碼跳出switch語句， 不加break，會繼續(xù)執(zhí)行下面的代碼
case 值2:
執(zhí)行代碼2;
break;
default:
執(zhí)行代碼3; // 當(dāng)都不滿足條件的時候，會執(zhí)行默認(rèn)里的執(zhí)行代碼3
}
思考：素質(zhì)教育（把分?jǐn)?shù)變成ABCDE）
// 90-100 : A
// 80-89: B
// 70-79: C
// 60-69: D
// 0-59 : E
// 這里的等級是根據(jù)一個范圍的分?jǐn)?shù)劃定的，用if..else很容易實現(xiàn)，但是switch..case是一個具體的條件，怎么辦呢？
// 方法：將分?jǐn)?shù)除以10再用parseInt屬性取整
var score = 85;
score = parseInt(score/10); // 8
switch (score) {
// score = 10 或者 9 的時候 返回 A
case 10:
case 9:
console.log("A");
break;
// score = 8 的時候 返回 B
case 8:
console.log("B");
break;
case 7:
console.log("C");
break;
case 6:
console.log("D");
break;
default:
console.log("E");
}
7.3 三元運算符
這個運算符可以用來代替if..else條件判斷。但是為什么有這個運算符呢？這里的原因是if..else使用兩個代碼塊，卻只有一個會執(zhí)行，在講究的程序員看來是一種浪費。所以使用三元運算符，用一條語句就可以完成功能。
語法：
判斷語句?表達(dá)式1:表達(dá)式2; 根據(jù)判斷語句返回的布爾值，true的話，返回表達(dá)式1，false的話返回表達(dá)式2
舉個例子，看代碼：
var sex = 1; sex == 1 ? "男":"女"; // 判斷sex是否等于1，如果true，返回第一個表達(dá)式:"男"
例題：判斷兩個數(shù)的大小
// 用if..else語句解決
// 這里使用了兩個代碼塊，有點浪費
var num1 = 18;
var num2 = 39;
var max;
if(num1>num2){
max = num1;
}else{
max = num2;
}
console.log(max);
// 用三元運算符
var num3 = 28;
var num4 = 49;
var max1 = num3>num4? num3:num4;
console.log(max1);
注意(容易出錯的地方)：
下面這個語句判斷如果是會員，費用為2美元，非會員，為10美元?，F(xiàn)在設(shè)置了非會員，卻打印出了2美元，顯然出錯了。
var isMember = false;
console.log("當(dāng)前費用" + isMember ? "$2.00" : "$10.00"); // "$2.00"
出錯的原因是？號的優(yōu)先級比＋號低，所以實際運行的語句是
// true
console.log("當(dāng)前費用false" ? "$2.00" : "$10.00"); // "$2.00"
8.循環(huán)語句
8.1 while 循環(huán)
語法：
1、如果循環(huán)條件的結(jié)果是true的時候，就會執(zhí)行循環(huán)體
2、如果循環(huán)條件的結(jié)果是false的時候，結(jié)束循環(huán)。
// 1. 如果循環(huán)條件的結(jié)果是true的時候，就會執(zhí)行循環(huán)體
// 2. 如果循環(huán)條件的結(jié)果是false的時候，結(jié)束循環(huán)。
while(循環(huán)條件){
循環(huán)的代碼; // 循環(huán)體
自增或者自減; // 一定不要忘記自增或自減，否則就會死循環(huán)
}
例如，求0~100的和：
var num = 0;
var sum = 0;
while(num <= 100){
sum += num;
num++;
}
console.log(sum); // 5050
8.2 do..while 循環(huán)
語法：
do..while循環(huán)和while循環(huán)非常像，二者經(jīng)?？梢韵嗷ヌ娲?/p>
但是do..while的特點是不管條件成不成立，都會執(zhí)行1次。
do{
循環(huán)的代碼; // 循環(huán)體
自增或者自減; // 一定不要忘記自增或自減，否則就會死循環(huán)
}while(循環(huán)條件);
例如，求0~100的和：
var num = 0;
var sum = 0;
do{
sum += num;
num++；
}while(num<=100);
console.log(sum); // 5050
8.3 for 循環(huán)
寫while循環(huán)的經(jīng)常會忘記自增，for循環(huán)其實是while循環(huán)演化過來的，語法更加的簡潔明了，使用非常的廣泛。
語法：
初始化表達(dá)式
判斷表達(dá)式
自增表達(dá)式
循環(huán)體
//主要for循環(huán)的表達(dá)式之間用的是;號分隔的，千萬不要寫成,號
for(初始化表達(dá)式;判斷表達(dá)式;自增表達(dá)式){
//循環(huán)體
}
例如：求0~100的和：
var sum = 0;
for(var num = 0; num <= 100; num++){
sum += num;
}
console.log(sum); // 5050
8.4 break 和 continue
break:立即跳出整個循環(huán)，即循環(huán)結(jié)束，開始執(zhí)行循環(huán)后面的內(nèi)容（直接跳到大括號）continue:立即跳出當(dāng)前循環(huán)，繼續(xù)下一次循環(huán)（跳到i++的地方）
1、continue 示例代碼：
for(var i = 1; i <= 10; i++) {
if(i == 5) {
continue;
}
console.log(i); // 1,2,3,4,6,7,8,9,10
}
2、break 示例代碼：
for(var i = 1; i <= 10; i++) {
if(i == 5) {
break;
}
console.log(i); // 1,2,3,4
}
8.5 循環(huán)語句練習(xí)
1、計算一個數(shù)的位數(shù)
當(dāng)不知道循環(huán)次數(shù)的時候，用while循環(huán)：
var num = 1234567;
//因為不知道循環(huán)次數(shù)，所以推薦使用while循環(huán)
var count = 0; // count記錄位數(shù)
while(num != 0){ // 循環(huán)條件
num = parseInt(num/10);// 讓num縮小10倍
count++; // ，每縮小10倍就計算一次位數(shù)了
}
console.log(count); // 7
2、翻轉(zhuǎn)一個數(shù)
var num = 12345678;
//因為不知道循環(huán)次數(shù)，所以推薦使用while循環(huán)
var str = "";
while(num != 0){
str += num%10; // 將每一位取余
num = parseInt(num/10);//讓num縮小10倍
}
// str 是一個字符串，所以 +str將它轉(zhuǎn)回Number類型
console.log(+str); //
3、總結(jié)：
循環(huán)有很多種，但是以后用得最多的是for循環(huán)
當(dāng)不明確循環(huán)次數(shù)的時候，可以使用while循環(huán)
當(dāng)無論如何都要執(zhí)行一次代碼的時候，可以使用do..while循環(huán)。
循環(huán)可以相互替代。
9. 數(shù)組所謂數(shù)組，就是將多個元素(通常是同一類型的)，按一定順序排列放到一個集合中，那么這個集合就稱之為數(shù)組
在javascript中，數(shù)組是一個有序的列表，可以在數(shù)組中存放任意的數(shù)據(jù)，并且數(shù)組的長度可以動態(tài)的調(diào)整
9.1 創(chuàng)建數(shù)組1、通過構(gòu)造函數(shù)創(chuàng)建數(shù)組：
var arr = new Array(); 創(chuàng)建了一個空數(shù)組；
var arr = new Array("aa","bb","cc"); 創(chuàng)建了一個數(shù)組，里面存放了三個字符串
var arr = new Array(11,22,33) 創(chuàng)建了一個數(shù)組，里面存放了三個數(shù)字
2、通過數(shù)組子面量創(chuàng)建數(shù)組：
var arr = []; 創(chuàng)建了一個空數(shù)組
var arr = [11,22,33]; 創(chuàng)建了一個數(shù)組，里面存放了三個數(shù)字
var arr = ["aa","bb","cc"]; 創(chuàng)建了一個數(shù)組，里面存放了三個字符串
9.2 數(shù)組的下標(biāo)與長度數(shù)組的下標(biāo)：
數(shù)組是有序的，數(shù)組中的每一個元素都對應(yīng)了一個下標(biāo),下標(biāo)是從0開始的
var arr = ["aa","bb","cc"]; arr[0]; // 下標(biāo)是0，對應(yīng)的值是"aa" arr[2]; // 下標(biāo)是2，對應(yīng)的值是"cc"
數(shù)組的長度：
跟字符串一樣，數(shù)組也有一個length的屬性，指數(shù)組中存放的元素的個數(shù)
var arr = ["aa","bb","cc"]; arr.length; // 數(shù)組的長度為3
空數(shù)組的長度為0
數(shù)組的長度與下標(biāo)的關(guān)系：
數(shù)組的最大下標(biāo) = 數(shù)組的長度 - 1
9.3 數(shù)組的賦值與取值數(shù)組的取值：
格式：數(shù)組名[下標(biāo)]
功能：獲取數(shù)組對應(yīng)下標(biāo)的那個值，如果下標(biāo)不存在，返回undefined
var arr = ["red","blue","green"]; arr[0]; // red arr[2]; // green arr[3]; // 返回undefined，因為數(shù)組最大的下標(biāo)為2
數(shù)組的賦值：
格式：數(shù)組名[下標(biāo)] = 值;
功能：為數(shù)組新增值，如果下標(biāo)有對應(yīng)的值，會把原來的覆蓋，如果下標(biāo)不存在，會給數(shù)組新增一個元素
注意：如果一個數(shù)組的最大長度是3，可是卻給數(shù)組下標(biāo)為5賦了一個值，則下標(biāo)為3、4的值為empty(空)
var arr = ["red", "green", "blue"]; arr[0] = "yellow"; // 把red替換成了yellow arr[3] = "pink"; // 給數(shù)組新增加了一個pink的值 arr[5] = "black"; // 數(shù)組輸出為["red", "green", "blue",empty,empty,"black"]9.4 數(shù)組的遍歷
遍歷: 對數(shù)組的每一個元素都訪問一次，叫做遍歷
數(shù)組遍歷的基本語法：
var arr = [1,2,3,4,5,6,7,8,9];
for(var i = 0; i < arr.length; i++){
console.log(arr[i]); // 1 2 3 4 5 6 7 8 9
}
數(shù)組遍歷的逆向遍歷語法：
// i= arr.length-1 ==> 表示初始化表達(dá)式 從數(shù)組最后一位開始遍歷
// i>=0 表示判斷條件，下標(biāo)要滿足大于等于0
// i--，表示每次遍歷 初始值都是自減的
var arr = [1,2,3,4,5,6,7,8,9];
for(var i = arr.length-1; i >= 0; i--){
console.log(arr[i]); // 9 8 7 6 5 4 3 2 1
}
9.5 數(shù)組綜合練習(xí)
1、求一個數(shù)組中的最大值、最小值以及對應(yīng)的下標(biāo)
var arr = [298, 1, 3, 4, 6, 2, 23, -88,77,44];
var max = arr[0]; // 隨機取數(shù)組中的一個值與其他值比較
var maxIndex = 0; // 初始化最大值的下標(biāo)
var min = arr[0];
var minIndex = 0;
for(var i = 0; i< arr.length; i++){
if(max < arr[i]){ // 用一開始選擇的值，與遍歷后的值進(jìn)行比較
max = arr[i]; // 當(dāng)后面的值比初始值大，就將后面的這個值賦值給初始值，再用這個全新的值再v 去與后面的比較
maxIndex = i; // 比較結(jié)束后，此時的索引就是最大值的索引
}
if(min > arr[i]){
min = arr[i];
minIndex = i;
}
}
console.log("最大的值是：" + max);
console.log("最大值的下標(biāo)是：" + maxIndex);
console.log("最小的值是：" + min);
console.log("最小值的下標(biāo)是：" + minIndex);
2、讓數(shù)組倒序保存到一個新的數(shù)組中
需要了解數(shù)組的一個方法 push,在數(shù)組的最后面添加
var arr = ["大喬", "小喬", "甄姬", "不知火舞"];
var newArr = [];
for (var i = arr.length - 1; i >= 0; i--) {
newArr.push(arr[i]);
}
console.log(newArr); // ["不知火舞", "甄姬", "小喬", "大喬"]
3、將字符串?dāng)?shù)組用"|"或其他符號拼成一個字符串
