|
day01
am:
前端三大基礎(chǔ)知識(shí)：
HTML：專門編寫網(wǎng)頁內(nèi)容
CSS：專門設(shè)計(jì)網(wǎng)頁樣式
JavaScript：專門設(shè)計(jì)網(wǎng)頁交互的語言
交互：輸入數(shù)據(jù)，程序處理數(shù)據(jù)，返回結(jié)果
什么是JavaScript：
1、專門設(shè)計(jì)網(wǎng)頁交互的語言
2、運(yùn)行在JavaScript解釋器中
3、“解釋”執(zhí)行——像讀書一樣
4、互聯(lián)網(wǎng)第一大語言：JSer
布蘭登艾奇：4門語言拼湊出——JavaScript
ECMAScript標(biāo)準(zhǔn)：JavaScript核心語法
微軟：JScript
ECMAScript標(biāo)準(zhǔn)：一紙空文
JavaScript和JScript都號稱完全實(shí)現(xiàn)了ECMAScript標(biāo)準(zhǔn)
W3C：DOM標(biāo)準(zhǔn)：專門操作HTML元素，CSS樣式，事件的統(tǒng)一標(biāo)準(zhǔn)！
BOM：專門操作瀏覽器窗口的工具。
沒標(biāo)準(zhǔn)，由瀏覽器廠商自行實(shí)現(xiàn)
JavaScript=ECMAScript+DOM+BOM
Mozilla基金會(huì)——>Firefox
JSer最大挑戰(zhàn)：瀏覽器兼容性問題
JavaScript典型用途：
1、客戶端數(shù)據(jù)計(jì)算
2、客戶端表單驗(yàn)證
3、動(dòng)畫
JavaScript特點(diǎn)：純文本；解釋執(zhí)行；弱類型；基于對象
如何讓使用：
1、使用瀏覽器自帶的js解釋器：
F12——>控制臺(tái)
光標(biāo)處寫腳本代碼，回車執(zhí)行。
console：指代控制臺(tái)：專門調(diào)式程序輸出結(jié)果的窗口。
log：控制臺(tái)console提供的一個(gè)功能：向控制臺(tái)輸出一行日志。
多行：shift+enter——>換行
**JavaScript中區(qū)分大小寫！**
**字符串單雙引號都行**
2、單獨(dú)安裝專門的解釋器軟件：node.js Chrome V8
win+R——>cmd——>node
退出：兩次Ctrl+c
執(zhí)行.js文件：1、先cd到.js文件所在路徑
2、node 文件名 回車
3、隨網(wǎng)頁一同運(yùn)行：
瀏覽器 包含兩種工具：
排版引擎：專門加載HTML內(nèi)容和CSS樣式
解釋引擎：專門運(yùn)行js腳本
<script>元素：專門包含js腳本塊的元素
<script>中腳本塊何時(shí)運(yùn)行？隨網(wǎng)頁加載，解釋執(zhí)行
<script>中都要使用js語法！
html元素的事件“屬性”中：
什么是事件？元素可以根據(jù)鼠標(biāo)或鍵盤的不同操作相應(yīng)不同的交互行為。
charset必須和文件的存儲(chǔ)編碼一致
<script>解釋執(zhí)行，讀到執(zhí)行。先讀先執(zhí)行?！?lt;script>放置的先后順序影響程序結(jié)
果。
優(yōu)化：放在body的最后
一次定義處處使用，一次修改處處生效！
解決：凡是重復(fù)編寫的代碼塊，都要封裝為一個(gè)方法
方法：執(zhí)行一個(gè)專門功能的一組代碼的序列。
一般定義在<head>下的<script>中
語法：function 方法名(){重用的代碼塊}
*不調(diào)不執(zhí)行*
調(diào)試：bug? debug：解決問題，排除錯(cuò)誤
只要沒反應(yīng)或效果沒出來就是出錯(cuò)！——>F12
查看錯(cuò)誤原因——>定位錯(cuò)誤位置！
<script>腳本塊中的錯(cuò)誤，僅影響“當(dāng)前腳本塊”中出錯(cuò)“位置之后”的腳本執(zhí)行。
不影響<script>之外的其他元素加載或腳本執(zhí)行。
function中的錯(cuò)誤：只有調(diào)用方法是才觸發(fā)！
頁面內(nèi)部腳本塊問題：僅當(dāng)前頁面可用！
解決：外部.js文件！
什么是.js文件：專門保存js腳本源代碼的文件。
源代碼都要放到j(luò)s解釋器才能執(zhí)行。
如何使用.js文件？2步：1、創(chuàng)建.js文件，編寫源代碼 2、在頁面引入外部.js文件
內(nèi)外部同名方法，解釋執(zhí)行！
pm:
JavaScript=ECMAScript（核心語法）+DOM（操作網(wǎng)頁內(nèi)容）+BOM（操作瀏覽器
窗口）
ECMAScript（核心語法）
*區(qū)分大小寫*
*字符串必須用引號（單雙都行）包裹*
*每條語句結(jié)尾都建議有分號*
語句：讓程序可以做一件事的一行命令
腳本塊：多行語句的序列
程序：讓計(jì)算機(jī)可以模擬執(zhí)行人類的想法！
注釋：不會(huì)被解釋執(zhí)行或顯示的代碼說明——給程序員看的
注釋也占網(wǎng)頁流量！生產(chǎn)環(huán)境必須去掉！
HTML注釋：<!---->
CSS注釋：/**/
JS注釋：//單行注釋 /*多行注釋*/
*變量*
什么是變量？內(nèi)存中專門存儲(chǔ)數(shù)據(jù)的空間
程序都是在內(nèi)存中運(yùn)行
任何程序：IPO：Input Process Output
數(shù)據(jù) 數(shù)據(jù) 數(shù)據(jù)
何時(shí)使用變量？只要在程序中臨時(shí)存儲(chǔ)數(shù)據(jù)，都要放在變量中
怎么使用變量？聲明，命名，初始化和使用
聲明：在內(nèi)存中開辟一個(gè)存儲(chǔ)空間，并且起一個(gè)名字
怎么聲明？var 變量名;
賦值：將等號右邊的數(shù)據(jù)，裝入等號左邊的變量中！
如果未賦值：js默認(rèn)賦值為undefined
命名規(guī)則：見名知意
保留字、關(guān)鍵字不能當(dāng)變量名
保留字：js中已經(jīng)占用的特殊意義的關(guān)鍵字
使用：使用變量名等于直接使用變量中存儲(chǔ)的數(shù)據(jù)
+：拼接多段文字為一句話！
常量：一旦創(chuàng)建，值不可改變的特殊變量
如何使用常量：const 常量名=常量值;
強(qiáng)調(diào)：只有等號可以向變量中存入新值。普通運(yùn)算不會(huì)改變變量的值。只是使用變量的
值。
只要帶var就是聲明，只要聲明就會(huì)開辟內(nèi)存空間、
js中新同名變量的空間會(huì)替換舊的空間。
有幾個(gè)var，就會(huì)創(chuàng)建幾個(gè)存儲(chǔ)空間。
數(shù)據(jù)類型：變量中存儲(chǔ)的數(shù)據(jù)類型。
js是弱類型：變量本身沒有類型。只有變量中的值才有類型。
一個(gè)變量，可以反復(fù)保存不同類型的數(shù)據(jù)。
為什么要有數(shù)據(jù)類型：現(xiàn)實(shí)中所有數(shù)據(jù)根據(jù)用途不同，都分為不同數(shù)據(jù)類型。
原始類型：數(shù)據(jù)保存在變量本地！
number類型：表示一切用于比較或數(shù)學(xué)計(jì)算的數(shù)字
程序中數(shù)字分整數(shù)、浮點(diǎn)數(shù)（現(xiàn)實(shí)中的小數(shù)）
js中一切數(shù)字都用number保存，不分整數(shù)類型和小數(shù)類型
如何定義number類型？不帶引號的數(shù)字字面量
程序中數(shù)字類型的舍入誤差：程序中不能準(zhǔn)確表示1/10，就好像現(xiàn)實(shí)中不能準(zhǔn)確表示
1/3一樣！
如何修正：按指定位數(shù)四舍五入：數(shù)字.toFixed（小數(shù)位數(shù)）
今后計(jì)算結(jié)果小數(shù)位數(shù)超長，說明碰到舍入誤差。按位四舍五入。
精度計(jì)算不要用JavaScript
string類型：一串字符的序列！
Unicode：對所有語言文字中的字符編號
Why“因?yàn)橛?jì)算機(jī)只處理數(shù)字，無法處理文字。
計(jì)算機(jī)處理unicode編號，就等效于處理編號對應(yīng)的文字。
轉(zhuǎn)義字符：專門表示非打印字符以及特殊符號
如何使用轉(zhuǎn)義字符：\特殊符號 比如：\n 換行 、\t tab鍵
如果字符串中包含與語法相沖突的特殊字符，要用\轉(zhuǎn)為原文
*字符串變量的內(nèi)容一旦創(chuàng)建補(bǔ)課費(fèi)改變！如果改變，只能創(chuàng)建新字符串，拋棄舊字符串
。*
鄙視題！
var str = "Hello";
str = str + “Word”;
3個(gè)！
boolean類型：僅有兩個(gè)值的特殊數(shù)據(jù)類型：true,false
何時(shí)使用boolean?只要一個(gè)值只有真假兩種情況，就用boolean類型
undefined類型：表示一個(gè)變量僅聲明過，但從未賦值。所有未賦值的變量，默認(rèn)值都
是undefined。
undefined類型的值還是undefined！
原始類型的大小:
number：整數(shù)4字節(jié)，浮點(diǎn)8字節(jié)
string：每個(gè)字符兩字節(jié)
day02
回顧：
JavaScript：ECMAScript（核心語法）
DOM（操作網(wǎng)頁內(nèi)容）
BOM（操作瀏覽器窗口）
ECMAScript：標(biāo)準(zhǔn)
Netscapt：javaScript Microsoft:JScript
變量：內(nèi)存中存儲(chǔ)數(shù)據(jù)的一塊空間
一切數(shù)據(jù)必須存在變量中
聲明：var 變量名——>在內(nèi)存中開辟一塊空間
賦值：變量名=值——>將值保存到左邊的變量空間中備用
使用：使用變量名，就等效于直接使用變量中的數(shù)據(jù)
數(shù)據(jù)類型：
why：存儲(chǔ)空間的大小，用途
原始類型：數(shù)據(jù)保存在變量本地
number string boolean undefined null
string：字符串內(nèi)容一旦創(chuàng)建不能改變
var str = "Hello";
str = str + "World";
3個(gè)！
正課：
數(shù)據(jù)類型間的轉(zhuǎn)換：
隱式轉(zhuǎn)換：程序自動(dòng)轉(zhuǎn)換數(shù)據(jù)類型（坑）
弱類型：1、變量聲明是不必限定數(shù)據(jù)類型，今后可能保存任何數(shù)據(jù)類型
2、數(shù)據(jù)類型間可以自動(dòng)類型轉(zhuǎn)換
僅考慮+：只要有字符串參與，一切類型都加""變?yōu)樽址?br> 如果沒有字符串，都轉(zhuǎn)換為數(shù)字計(jì)算：其中true——>1 false——>0
強(qiáng)制轉(zhuǎn)換：程序員通過調(diào)用專門函數(shù)，手動(dòng)轉(zhuǎn)換類型
2 string：x.toString();——>將x轉(zhuǎn)為字符串類型
2 number：Number(x);——>將任意類型轉(zhuǎn)為number類型
string——>number:
轉(zhuǎn)為整數(shù)：var num = parseInt("str");
讀取字符串中的整數(shù)部分
1、從第一個(gè)字符向后讀。
2、如果碰到第一個(gè)數(shù)字字符，開始獲取數(shù)字，再次碰到不是數(shù)字的字符，停
止讀取
3、如果開頭碰到空格，忽略
4、如果碰到的第一個(gè)非空格字符，不是數(shù)字，說明不能轉(zhuǎn)——>NaN: Not
a Number
什么是NaN：不是數(shù)字（內(nèi)容）的數(shù)字（類型）
轉(zhuǎn)為浮點(diǎn)數(shù)：var num = parseFloat("str");
用法和parseInt全完相同
唯一差別：parseFloat認(rèn)識(shí)小數(shù)點(diǎn)
prompt("提示信息")：專門用于請求用戶輸入數(shù)據(jù)，收集數(shù)據(jù)的對話框！
var str = prompt("提示信息");
*凡是從頁面上獲得的數(shù)據(jù)，都是字符串！必須先轉(zhuǎn)換再計(jì)算*
什么是運(yùn)算符：程序模擬人類運(yùn)算的特殊符號
算數(shù)運(yùn)算：-任意類型做-，都會(huì)被轉(zhuǎn)為數(shù)據(jù)類型
如果有參數(shù)，不能自動(dòng)轉(zhuǎn)換為數(shù)字，則返回NaN
如果除數(shù)為0：Infinity——>無窮大
typeof(x)：判斷任意數(shù)據(jù)的類型
被除數(shù)%除數(shù)——模運(yùn)算：被除數(shù)/除數(shù)，取除不盡的余數(shù)
何時(shí)用：限制一個(gè)數(shù)不能超過某個(gè)最大范圍時(shí)
遞增/遞減運(yùn)算：i++ ==> i = i +1;
i++單獨(dú)用：++放前放后，效果一樣：i++ ==> ++i；
i++出現(xiàn)在表達(dá)式內(nèi)部：
前++，前+1，再參與表達(dá)式
后++，先用舊值參與表達(dá)式。表達(dá)式之后再+1
關(guān)系運(yùn)算：判斷大小！條件判斷中使用
結(jié)果：成立：true，不成立：false
*自帶隱式類型轉(zhuǎn)換*
字符串參與運(yùn)算：從第一個(gè)字符開始，取出每個(gè)字符 PK unicode編號
"Hello" H e(101)
"Hi" H i(105)
關(guān)系運(yùn)算中：任何類型和數(shù)字比較，都轉(zhuǎn)為數(shù)字，再比較
布爾類型參與關(guān)系運(yùn)算，始終轉(zhuǎn)為數(shù)字比較
PM：
關(guān)系運(yùn)算：現(xiàn)將參與判斷的數(shù)據(jù)，強(qiáng)轉(zhuǎn)為相同類型，再比較
字符串比較：
undefined做==比較：
undefined類型，從null類型繼承來的
undefined值被自動(dòng)轉(zhuǎn)換為null!
undefined == null ——>true
===嚴(yán)格相等：不帶自動(dòng)類型轉(zhuǎn)換的相等比較！
類型和值必須都相等！才返回true。
嚴(yán)格相等最初就是為undefined和null設(shè)計(jì)的
只要不確定比較的類型，又不希望自動(dòng)類型轉(zhuǎn)換時(shí)，就用===
NaN做==：
isNaN(x)：專門用來判斷一個(gè)數(shù)據(jù)是不是NaN
如果是NaN返回true；如果不是NaN返回false
是
只要不能轉(zhuǎn)換為數(shù)字的，都返回true
只要能自動(dòng)轉(zhuǎn)換為數(shù)字的，都返回false
關(guān)系運(yùn)算中""，可以自動(dòng)轉(zhuǎn)換為false或0
總結(jié)：1、普通數(shù)據(jù)，先轉(zhuǎn)換為相同類型，再比較
2、undefined，就用===
3、NaN，就用isNaN(x)
邏輯運(yùn)算：基于多組關(guān)系運(yùn)算，得出一個(gè)結(jié)論
&&：而且
||：或者
?。悍牵嵉箃rue和false，今后只要顛倒判斷結(jié)果，就用！
短路邏輯：只要前一個(gè)判斷足以得出最終結(jié)論，則后續(xù)條件不執(zhí)行！
驗(yàn)證是不是漢字：>="\u4E00" && <="\u9FA5"
閏年的判斷公式：(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
位移：n << m ——>n*(2的m次方)
n >> m ——>n/(2的m次方)
賦值運(yùn)算：賦值運(yùn)算結(jié)果就是等號右邊表達(dá)式的結(jié)果
擴(kuò)展的賦值表達(dá)式：對已有的數(shù)據(jù)計(jì)算的同時(shí)，將結(jié)果再存回變量
何時(shí)使用：修改原變量值
三目運(yùn)算：根據(jù)不同條件，動(dòng)態(tài)返回不同結(jié)果！
三目：至少需要3個(gè)表達(dá)式。
語法：
一個(gè)條件，二選一：條件？當(dāng)條件滿足時(shí)返回的值：當(dāng)條件不滿足時(shí)返回的值
多個(gè)條件，多選一：
條件1？條件1滿足時(shí)的值：
條件2？條件2滿足時(shí)的值：
條件n？條件n滿足時(shí)的值：
默認(rèn)值;
需求1：2個(gè)數(shù)中取最大的
var score1 = 100;
var score2 = 80;
var result = score1 > score2 ? score1 : score2;
注意：后一個(gè)條件中不用包含否定前一個(gè)條件的關(guān)系判斷。
因?yàn)?，進(jìn)入后一個(gè)條件隱含的條件就是前一個(gè)條件不滿足。
day03
NaN == NaN? false NaN和任何數(shù)據(jù)比較，永遠(yuǎn)返回false
今后只要可能判斷NaN時(shí)，用isNaN(x)
var str = "Hello";
str > 10? str > 10000? false
NaN NaN
關(guān)系運(yùn)算中，字符串比數(shù)字，字符串轉(zhuǎn)為數(shù)字！
注意：邏輯運(yùn)算中，不要急于將第一個(gè)條件之后的++/--提取出來
使用變量錯(cuò)誤的情況：*沒聲明的變量，只要使用就出錯(cuò)！*
var name;
console.log(Name);//程序運(yùn)行錯(cuò)誤錯(cuò)誤！會(huì)導(dǎo)致程序停止
console.log(name);//undefined1
函數(shù)（方法）：封裝執(zhí)行一項(xiàng)專門任務(wù)的步驟的代碼序列
何時(shí)定義方法？只要發(fā)現(xiàn)一段代碼重復(fù)使用，就封裝為方法
語法：聲明
function 方法名（參數(shù)列表）{
方法體：步驟清單
return 返回值；
}
調(diào)用：方法名(參數(shù)值列表);
參數(shù)：方法內(nèi)獨(dú)有的變量。接收傳入數(shù)據(jù)，在方法內(nèi)處理。參數(shù)讓方法變靈活！
如何聲明方法參數(shù)：不用var!
參數(shù)何時(shí)被創(chuàng)建？只有方法被調(diào)用時(shí)才自動(dòng)創(chuàng)建
返回值：方法執(zhí)行完成后，由方法返回的數(shù)據(jù)
定義返回值：不用再聲明變量，直接用return值！
為什么定義返回值：因?yàn)檎{(diào)用方法的人需要明確的返回結(jié)果。
返回值主要給調(diào)用者使用。
return：本意退出方法！
退出同時(shí)，可返回?cái)?shù)據(jù)！
可以再任何需要的地方，調(diào)用方法執(zhí)行返回值；
帶返回值的方法，使用時(shí)，等效于直接使用返回值數(shù)據(jù)。
作用域：一個(gè)變量的可用范圍！
全局作用域：直接放在全局作用域中的變量，叫全局變量
只要希望所有作用域公用的變量都要聲明在全局作用域
window
局部（函數(shù)）作用域：聲明在方法內(nèi)部的變量或方法參數(shù)的變量都叫局部變量
值傳遞：將一個(gè)變量的值賦值給另一個(gè)變量，其實(shí)將原變量中的值，復(fù)制一份給新變量
。
js中一切賦值都是值傳遞！
對未聲明的變量賦值：js會(huì)自動(dòng)在全局創(chuàng)建該變量！
函數(shù)作用域和變量作用域完全一樣
函數(shù)作用域在調(diào)用方法時(shí)創(chuàng)建，方法執(zhí)行完立刻銷毀！
PM
問題：
方法參數(shù)：依據(jù)方法內(nèi)部的處理邏輯至少需要幾個(gè)數(shù)據(jù)才能正常執(zhí)行。
方法參數(shù)和外部定義了了那些變量沒有任何關(guān)系。
方法參數(shù)作用：1、接收外部傳入數(shù)據(jù)，在方法內(nèi)處理
2、規(guī)定調(diào)用方法的人必須提供哪些參數(shù)！
方法的返回值：根據(jù)方法調(diào)用者的需要! 如果方法調(diào)用者需要明確返回一個(gè)結(jié)果，就定
義返回值！否則，可以不定義返回值！
何時(shí)必須使用變量接住？方法的返回值，后續(xù)程序可能反復(fù)使用!
鄙視題：
var num = 0;
function f1(num){
var num = 100;
console.log(num);
}
f1();
console.log(num);
//100 0
正課：
自定義函數(shù)：
全局函數(shù)：ECMAScript定義了標(biāo)準(zhǔn)，由個(gè)瀏覽器廠商已經(jīng)實(shí)現(xiàn)的函數(shù)。我們直接調(diào)用
！
isNaN(x) parseInt/Float(x)
encodeURI( kword ):將url中的非法字符轉(zhuǎn)為單字節(jié)符號——編碼
decodeURI( kword ):將encodeURI轉(zhuǎn)后的字符串，轉(zhuǎn)換為原文——解碼
unicode編碼：每個(gè)字符2字節(jié)
utf-8：字母、數(shù)字單字節(jié)，漢字3字節(jié)
url規(guī)定參數(shù)值中，再次出現(xiàn)保留字，就是非法：
保留字：/ ? $ : 等
encodeURIComponent( kword );既能對多字節(jié)非法字符編碼，又能對單字節(jié)非法字符
編碼——今后只使用component就夠了
何時(shí)使用？將數(shù)據(jù)通過url發(fā)送時(shí)，都要先編碼再發(fā)送
decodeURIComponent( kword );對encodeURIComponent()編碼的字符串解碼。收
到編碼后的字符串后，都要先解碼，再處理。
eval()：專門執(zhí)行字符串格式代碼
程序結(jié)構(gòu)：3種：順序；分支；循環(huán)
程序：IPO
需求：找名詞——>程序中的數(shù)據(jù)
兩類：輸入數(shù)據(jù)
輸出數(shù)據(jù)
分析處理流程：
分支結(jié)構(gòu)：程序運(yùn)行過程中，可以根據(jù)不同的條件，執(zhí)行不同的任務(wù)。
分支結(jié)構(gòu)：if...結(jié)構(gòu)：1件事，要么做，要么不做
if...else...結(jié)構(gòu)：2件事，二選一執(zhí)行
else if結(jié)構(gòu)：多件事，多選一執(zhí)行
day04
回顧：
方法參數(shù)：方法內(nèi)處理邏輯必須的數(shù)據(jù)
參數(shù)僅限方法內(nèi)部使用！方法外無法訪問方法的參數(shù)變量
參數(shù)名稱自定義！
返回值：調(diào)用者是否需要獲得方法的執(zhí)行結(jié)果
分支：if結(jié)構(gòu) 1件事 可做可不做
if...else... 2件事 必須二選一
if...else if...[else...] 多件事 多選一執(zhí)行
正課：
switch...case...多條分支，根據(jù)條件判斷，選擇執(zhí)行
switch...case...用的是嚴(yán)格相等，不帶自動(dòng)類型轉(zhuǎn)換
語法：swith(表達(dá)式){
case 表達(dá)式1：//如果表達(dá)式的值===表達(dá)式1的值
代碼段1;
case 表達(dá)式n:
代碼段n;
default://如果表達(dá)式的值和都有的case都不相等
默認(rèn)代碼段;
}
運(yùn)行機(jī)制：如果找到與表達(dá)式匹配的case，不但執(zhí)行當(dāng)前case下的代碼，而且之后所有
代碼都被觸發(fā)！
switch(true){
case socre >= 90: console.log("A");
case score >= 80: console.log("B");
case score >= 60: console.log("C");
default: console.log("D");
}
break：退出當(dāng)前結(jié)構(gòu)；
多條件公用同一套執(zhí)行邏輯是，不加break。
switch(true){
case socre >= 90: console.log("A");break;
case score >= 80: console.log("B");break;
case score >= 60: console.log("C");break;
default: console.log("D");
}
循環(huán)結(jié)構(gòu)：程序反復(fù)執(zhí)行同一套代碼段。遇到結(jié)束條件，會(huì)結(jié)束執(zhí)行。
沒有循環(huán)結(jié)束條件，永遠(yuǎn)循環(huán)呢執(zhí)行——死循環(huán)
循環(huán)三要輸：
1、循環(huán)條件：循環(huán)繼續(xù)執(zhí)行的條件。一旦循環(huán)條件不滿足，循環(huán)立刻退出！
2、循環(huán)變量：用于循環(huán)條件中做判斷的變量。循環(huán)變量都會(huì)向著循環(huán)退出的趨勢變化
（不滿足循環(huán)條件的趨勢）——循環(huán)計(jì)數(shù)器
3、循環(huán)體：每次循環(huán)要做的事情
while循環(huán)：當(dāng)滿足條件時(shí)，就繼續(xù)循環(huán)做...事
語法：
var 循環(huán)變量;
while(循環(huán)條件){
循環(huán)體;
迭代變化循環(huán)變量;
}
break：退出當(dāng)前結(jié)構(gòu)
while中何時(shí)用break：循環(huán)條件不滿足之前，希望強(qiáng)行退出循環(huán)。
如何使用break？可以放在任何需要退出循環(huán)的位置。
隨機(jī)數(shù)：Math.random();0<=n<1
任意min——max之間取隨機(jī)數(shù)
公式：parseInt(Math.random()*(max-min-1)+min)
do-while循環(huán)：先執(zhí)行一次循環(huán)體，再判斷是否繼續(xù)！
如果循環(huán)條件不滿足，循環(huán)體至少可以執(zhí)行一次！
var 循環(huán)變量;
do{
循環(huán)體;
迭代變化循環(huán)變量;
}while(循環(huán)條件);
*變量聲明提前*：“相同作用域內(nèi)”，var...不論出現(xiàn)在什么位置，解析時(shí)，優(yōu)先提取到
js開始位置“聲明”！
for：完全等效于while循環(huán)。
循環(huán)變量變化規(guī)律固定，循環(huán)次數(shù)已知、固定
for(聲明并初始化循環(huán)變量;循環(huán)條件；迭代變化循環(huán)變量){
循環(huán)體
}
continue:跳過本輪循環(huán)，繼續(xù)執(zhí)行下一輪循環(huán)
遇到復(fù)雜問題：
先用簡單辦法做最簡單的事情。
從簡單辦法中找規(guī)律！
day05
程序 = 數(shù)據(jù)結(jié)構(gòu) + 算法
良好的數(shù)據(jù)結(jié)構(gòu)，可以極大提高程序的執(zhí)行效率！
數(shù)組：存儲(chǔ)：連續(xù)存儲(chǔ)多個(gè)數(shù)據(jù)的存儲(chǔ)空間
使用：相當(dāng)于多個(gè)變量的集合
why？現(xiàn)實(shí)中數(shù)據(jù)都是批量分類管理
何時(shí)使用：只要批量管理多個(gè)數(shù)據(jù)，就要用數(shù)組保存
如何使用：創(chuàng)建，初始化，訪問數(shù)組中的數(shù)據(jù)
創(chuàng)建：數(shù)組都是用[]創(chuàng)建出來的。
var arr = [];——>創(chuàng)建了一個(gè)數(shù)組對象，數(shù)組中包含0個(gè)元素
var arr = [90, 34, 23];——>創(chuàng)建了一個(gè)數(shù)組對象，數(shù)組中連續(xù)存儲(chǔ)3個(gè)元素
2個(gè)不限制：1、不限制元素的個(gè)數(shù)！ 2、不限制元素?cái)?shù)據(jù)類型
*數(shù)組是引用類型的對象*
原始類型：數(shù)據(jù)保存在變量本地
引用類型：數(shù)據(jù)不保存在變量本地！保存在“堆”中。
由地址指向?qū)嶋H數(shù)據(jù)
引用類型特點(diǎn)：可以保存多個(gè)數(shù)據(jù)，而且數(shù)據(jù)個(gè)數(shù)隨時(shí)變化
why？原始類型中只能保存1個(gè)值
1個(gè)值無法精確描述一個(gè)東西
現(xiàn)實(shí)中，都是用多個(gè)屬性共同描述一樣?xùn)|西
對象：凡是存儲(chǔ)在堆中的，都是對象！
使用引用類型的對象：使用變量，等效使用對象的地址
使用對象地址，等效于使用對象本身
數(shù)組對象支持直接輸出數(shù)組內(nèi)容
其他數(shù)組創(chuàng)建語法：var arr = new Array(num);
new：要在堆中開辟空間！
Array：ECMAScript標(biāo)準(zhǔn)的內(nèi)置類型
new Array：在堆中創(chuàng)建一個(gè)數(shù)組類型的存儲(chǔ)區(qū)域
(num)：初始創(chuàng)建num個(gè)元素
var arr = new Array(7);
//[undefined, undefined, undefined, undefined, undefined, undefined, undefined]
undefined輸出時(shí)，變?yōu)橐粋€(gè)空字符
var arr = new Array(元素1， 元素2，...， 元素n);
null：一個(gè)變量沒有指向任何對象
何時(shí)使用null：主動(dòng)釋放對象！主動(dòng)釋放的對象不能被找回
null vs undefined：
null專用于主動(dòng)釋放對象！
undefined：專用于自動(dòng)初始化任何未賦值的變量
垃圾回收：js引擎自動(dòng)銷毀不再被引用的對象！
垃圾回收程序：隨js程序運(yùn)行而后臺(tái)同時(shí)運(yùn)行
只要對象還有變量引用，就不回收。
訪問數(shù)組：數(shù)組一組變量的集合。
如何獲得其中一個(gè)變量/數(shù)據(jù)：下標(biāo)，數(shù)組中唯一標(biāo)識(shí)一個(gè)元素的序號。從0開始。最后
一個(gè)元素的下標(biāo)是“元素個(gè)數(shù)-1”
js內(nèi)置對象不但封裝存儲(chǔ)，而且封裝常用API
API：已經(jīng)實(shí)現(xiàn)的方法！可以直接調(diào)用！
Array API：
1、arr.length屬性：數(shù)組中元素的個(gè)數(shù)
訪問任意數(shù)組的最后一個(gè)元素：arr[arr.length - 1]
length屬性值，隨數(shù)組長度變化而自動(dòng)變化！
js中數(shù)組可根據(jù)程序需要，“自動(dòng)擴(kuò)容”，保證程序正常執(zhí)行
數(shù)組擴(kuò)容和縮容：都是設(shè)置length屬性的值
如果length屬性值>舊值，會(huì)擴(kuò)容；反之，縮容（截?cái)啵?br>被截?cái)嗟脑兀荒鼙徽业?，不?huì)被回收。只能隨數(shù)組對象一起回收。
固定用法：在任意數(shù)組結(jié)尾追加一個(gè)新元素：arr[arr.length] = 新值;
下午：
棧中的變量 生命周期：和堆完全不同
var a = 5;//全局變量隨網(wǎng)頁生命周期
function fun(){
var b = 10;
}
fun();//作用域環(huán)境棧
/*fun的作用域環(huán)境棧 出棧 fun中局部變量，一同消失*/
console.log(b);//refError
結(jié)論：局部變量的聲明周期和所在方法的作用域環(huán)境棧有關(guān)
作用域創(chuàng)建，局部變量一同創(chuàng)建
作用域結(jié)束，局部變量一同消失
什么是數(shù)組遍歷：對數(shù)組中每個(gè)元素執(zhí)行相同的操作
for(var i = 0; i < arr.length; i++){
arr[i]——>當(dāng)前元素
}
關(guān)聯(lián)數(shù)組：數(shù)組下標(biāo)可以自定義名稱！Key/value對
何時(shí)使用關(guān)聯(lián)數(shù)組：數(shù)組元素的內(nèi)容無法描述自己的意義時(shí)，使用關(guān)聯(lián)數(shù)組為每個(gè)元素
起名
關(guān)聯(lián)數(shù)組的length屬性作廢了！
for in：專門遍歷關(guān)聯(lián)數(shù)組用的！
for(var key in arr){
//從第一個(gè)元素開始，將元素的key賦值給臨時(shí)變量key
arr[key]——>當(dāng)前正在遍歷的元素的值(value)
}
關(guān)聯(lián)數(shù)組直接量定義方式：強(qiáng)調(diào)：大括號
{"key1":"value1", "key2":"value2", ...}
冒泡排序：[3， 5， 3，。。]：見array.html
數(shù)組常用方法：
x.toString()方法：任何對象都有toString方法
默認(rèn)用,分割每個(gè)元素
將任何對象轉(zhuǎn)為字符串
一般不主動(dòng)調(diào)用，js在需要時(shí)自動(dòng)調(diào)用
x.valueOf()方法：同toStrin()
var str = arr.join("分隔符")：將數(shù)組轉(zhuǎn)為字符串。但是可自定義分隔符！
用法，將字符拼接為單詞或句子 chars.join("");
var newArr = arr.concat(1個(gè)元素值, [數(shù)組], ...)：將參數(shù)拆散成單個(gè)元素，追加到數(shù)組
中。
*不會(huì)修改原數(shù)組，只能返回新數(shù)組對象*
var subArr = arr.slice(start, end + 1);截取數(shù)組下標(biāo)從start開始，到end位置的元素，
生成子數(shù)組對象。*含頭不含尾*
arr.splice：刪除！插入！替換！
刪除元素：arr.splice(start, count);
替換元素：arr.splice(start, count, 值1, 值2, ...);
插入元素：arr.splice(start, 0, 值1, 值2, ...)
返回每次刪除元素組成的新數(shù)組
arr.reverse();顛倒所有數(shù)組元素
arr.sort();默認(rèn)升序排序。默認(rèn)都轉(zhuǎn)為字符串排序！
day06
手冊：JavaScript——>js對象——>js數(shù)組——>Array對象參考手冊
回顧：
轉(zhuǎn)為字符串：x.toString()——>任何對象都有toString方法
var str = arr.join("分隔符")——>自定義元素分隔符
固定用法：arr.join("");——>將數(shù)組中的字符串無縫拼接為單詞或字符串
拼接和截?。簐ar newArr = arr.concat(otherArr, 值1, ...)
var subArr = arr.slice(start, end + 1);
復(fù)制原始數(shù)組中的部分元素，原數(shù)組不變
含頭不含尾
splice：*直接修改原數(shù)組！*返回被刪除 的元素
刪除：[var removed =] arr.splice(start, count);
替換：[var rrmoved =] arr.splice(start, count, 值1, 值2, ...);
自動(dòng)調(diào)整數(shù)組容量，容納所有修改的新值
插入：[var rrmoved =] arr.splice(start, 0, 值1, 值2, ...);
正課：
排序：arr.sort();默認(rèn)按字符串升序排列
自定義排序：2步：Step1：定義比較器函數(shù)！
什么是比較器函數(shù)？定義任意兩值比較策略的方法
比如：num1 - num2 > 0 ——> num1 > num2
num1 - num2 < 0 ——> num1 < num2
function compare(a, b){
return a - b;
}//如果返回>0數(shù)，a > b; 如果返回<0數(shù)，a < b; 如果返回=0數(shù)，a = b;
Step2：將比較器函數(shù)傳遞給sort方法！
***如何將方法做參數(shù)傳遞？***
js中方法也是一個(gè)對象！方法名就是指向?qū)ο蟮淖兞棵?br> function compare(a, b){return a - b;}
//可以定義在使用前后的任何位置
//原因：var聲明和function聲明自動(dòng)提前！
相當(dāng)于：var compare = new Function("a", "b", "return a - b;");
//必須定義在使用之前！原因：僅聲明提前，賦值不能提前！
arr.sort(compare);注意！將方法作為對象傳遞是，僅使用方法名，后不加圓
括號。
降序：顛倒比較結(jié)果，可以導(dǎo)致升序變降序
升序：function compareASC(a, b){return a - b;}
顛倒（*-1）：function compareDESC(a, b){return b -a;}
棧和隊(duì)列：
什么是棧？后進(jìn)先出!（LIFO）棧其實(shí)就是數(shù)組，只不過用一對方法模擬了棧的操作!
棧：只能從數(shù)組一端出棧，入棧。另外一端封閉！
操作棧：
結(jié)尾入棧出棧：元素下標(biāo)始終不變，最后一個(gè)元素始終最新
入棧：arr.push(值1, ...);
出棧：var last = arr.pop();
開頭入棧出棧：所有元素下標(biāo)隨入棧出棧操作而變化
入棧：arr.unshift(值1, ...);
出棧：var first = arr.shift();
隊(duì)列：FIFFO
入隊(duì)列：arr.push(值1, ...);
出隊(duì)列：var first = arr.shift();
二位數(shù)組：數(shù)組的元素又是另一個(gè)數(shù)組對象！
創(chuàng)建二位數(shù)組：創(chuàng)建普通數(shù)組，完全一樣！
只不過將普通元素，換為一個(gè)數(shù)組對象而已
var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
arr[3] = [10, 11, 12];
如何訪問二位數(shù)組中的任意元素：arr[父數(shù)組中的下標(biāo)][子數(shù)組中的下標(biāo)]
何時(shí)使用二位數(shù)組：數(shù)據(jù)包含明顯上下級關(guān)系
內(nèi)置對象
什么是內(nèi)置對象？內(nèi)置對象就是ECMAScript標(biāo)準(zhǔn)中已經(jīng)定義好的，由瀏覽器廠商已經(jīng)
實(shí)現(xiàn)的標(biāo)準(zhǔn)對象！
內(nèi)置對象中封裝了專門的數(shù)據(jù)和操作數(shù)據(jù)常用的API。
JavaScript中內(nèi)置對象：
String,Boolean,Number,Array,Date,Math,Error,Function,Object,Global
包裝類型
什么是包裝類型？專門封裝原始類型的數(shù)據(jù)，并提供對數(shù)據(jù)常用操作的內(nèi)置類型。
為什么要用包裝類型？讓原始類型的數(shù)據(jù)也可以像引用類型一樣，擁有方法和屬性。
JavaScript中的包裝類型有三個(gè)：
String類型，Number類型，Boolean類型
何時(shí)使用包裝類型？只要用原始類型的數(shù)據(jù)調(diào)用方法或訪問屬性，js引擎都會(huì)自動(dòng)創(chuàng)建
對應(yīng)的包裝類型對象。
方法調(diào)用完，包裝類型對象自動(dòng)釋放。
var str = "Hello";
//var strObject = new String(str);
str += "world";
//strObject = null;
String包裝類型：*字符串內(nèi)容，一旦創(chuàng)建，不可改變*
創(chuàng)建原始類型字符串變量：
直接量：var stuName = "Smith";
類型轉(zhuǎn)換：var priceString = String(190.3);
創(chuàng)建引用類型字符串對象：
var carType = new String("BMW528Li");
str.length：返回str字符串中的字符個(gè)數(shù)
大小寫轉(zhuǎn)換：都轉(zhuǎn)小寫：str = str.toLowerCase();
都轉(zhuǎn)大寫：str = str.toUpperCase();
何時(shí)使用：希望大小寫一視同仁時(shí)，就要先轉(zhuǎn)換，在處理
day07
內(nèi)置對象：見PPT
包裝類型：見PPT
var num = 5.678;//原始類型
//num = new Number(num);//包裝類型
console.log(num.toFixed(2));
//num = null;//釋放包裝類型對象！
創(chuàng)建字符串：原始類型還是包裝類型？是否new
var str = "...";//原始類型
var str = String("...");//原始類型，類型轉(zhuǎn)換
**********************************************
var strObj = new String("...");//包裝類型對象
轉(zhuǎn)義字符：代替字符串中的非打印字符：\n \t
如果字符串內(nèi)容中包含和語法沖突的特殊字符，可用\轉(zhuǎn)為普通字符
比如：console.log("\tjs是互聯(lián)網(wǎng)\"第一大語言\"");
字符串內(nèi)容一旦創(chuàng)建不能改變！
如果修改，都要?jiǎng)?chuàng)建新字符串，保存新結(jié)果，替換舊字符串
var str = "Hello";
var strObj = new String(str);
str = str.toUpperCase();
//strObj = null;
console.log(str);
*規(guī)律：所有字符串API，都需要變量接收返回值！*
字符串的字符個(gè)數(shù)：str.length屬性
*字符串類型底層其實(shí)都是用字符數(shù)組實(shí)現(xiàn)的*
比如：str[i]
大小寫轉(zhuǎn)換：大小寫字母一視同仁時(shí)，先轉(zhuǎn)化，再處理
比如：重名驗(yàn)證，重復(fù)郵箱，驗(yàn)證碼
獲取指定位置的字符：var char = str.charAt(index);
獲取指定位置字符的unicode編碼：var num = str.charCodeAt(index);
優(yōu)化：*頻繁對字符串+=，要用數(shù)組代替！不會(huì)產(chǎn)生中間對象*
Step1：每個(gè)字符串放入數(shù)組
Step2：join("")拼接字符元素
今天后要把任何類型變?yōu)镾tring，不要用toString，而用+""，效率更高。
字符串三大操作：1.查找關(guān)鍵字！ 2.替換關(guān)鍵字 3.獲取子字符串
查找關(guān)鍵字：var index = str.indexOf("關(guān)鍵字");
返回關(guān)鍵字所在位置！*如果沒找到，返回-1！*
indexOf：懶：只找第一個(gè)關(guān)鍵字位置！
蠢：默認(rèn)只能從位置0開始！
var index = str.indexOf("關(guān)鍵字", from);
from：開始查找的位置，從from開始向后查找
一句話辦幾件事時(shí)，可以把表達(dá)式當(dāng)值用！
var str = "女神說要來，我草草的收拾了房間。結(jié)果她又說不來了。我說：我草";
var index = -1;
while((index = str.indexOf("我草", index + 1)) != -1){
console.log("位置" + index + "發(fā)現(xiàn)關(guān)鍵字");
}
從最后一個(gè)字符，向前找：只要關(guān)鍵字離結(jié)尾近，就用last
var index = str.lastIndexOf("關(guān)鍵字", from);
from：開始查找的位置，從from開始向前查找
*返回的index完全相同！字符在數(shù)組中的下標(biāo)是固定的！*
2處修改：index從str.length開始；每次index要-1
2.獲取子字符串：以下三個(gè)方法省略第二個(gè)參數(shù)，默認(rèn)都是取到結(jié)尾！
var subStr = str.slice(start, end + 1);
start,end支持正負(fù)
var subStr = str.substring(start, end + 1);
用法同slice!唯一差別：不支持負(fù)值作為參數(shù)!
var subStr = str.substr(start, *count*);
JavaScript——>js字符串——>
下午：
按規(guī)律分割字符串：var subs = str.split("分隔符"[, count]);
鄙視題：var str = "no zuo no die";
課堂練習(xí)：判斷字符的種類：unicode范圍：
48-57：0-9 數(shù)字字符
65-90：A-Z 大寫字母
97-122： a-z 小寫字母
19968-40869：漢字
什么是模式匹配：可以設(shè)置查找或替換的規(guī)則！
何時(shí)使用模式匹配：要查找的關(guān)鍵字可能發(fā)生有規(guī)律的變化。
如何使用模式匹配：1.先定義模式：/關(guān)鍵字/模式
比如：var reg = /no/ig; no是要查找的關(guān)鍵字原文，不加""
i表示忽略大小寫！ g表示全局查找和替換！
String類型中，提供了專門支持模式匹配的API！
按模式*替換*關(guān)鍵字：str = str.replace(reg, "新值");
默認(rèn)replace僅替換第一個(gè)關(guān)鍵字！
要想全局替換，要在模式中定義“g”
獲得*所有*關(guān)鍵字的*內(nèi)容：var kwords = str.match(reg);
只能取得關(guān)鍵字的內(nèi)容，無法確定每個(gè)關(guān)鍵字的位置！
kwords.length：找到的關(guān)鍵字個(gè)數(shù)！
*如果未找到，返回null！*
只要有可能返回null！都要先判斷 !=null，再處理！
SetupRegexBuddy.exe 全部默認(rèn)安裝
var index = str.search(reg); 和indexOf完全相同！
indexOf不支持模式查找！search其實(shí)是indexOf的模式查找版
今后在網(wǎng)頁中只要處理字符串的格式，就要用正則表達(dá)式
*正則表達(dá)式*
什么是正則達(dá)表示：字符串中字符出現(xiàn)的規(guī)律
何時(shí)使用正則表達(dá)式？驗(yàn)證字符串格式，查找關(guān)鍵字，替換關(guān)鍵字
比如：銀行卡查詢密碼：6位數(shù)字
用戶名：字母，數(shù)字，_的組合
正則表達(dá)式：
選擇符號：[所有備選字符]：[去草]，必須多選一使用
一個(gè)[]，只能代表一位字符的規(guī)則
[^xxxx]：表示出了xxxx都行！反義。注意必須放在[]中的第一個(gè)位置，否則變?yōu)槠胀ㄗ?
符匹配。
-符號：字符的范圍：備選字符是連續(xù)的范圍！
比如：[0-9] [a-z] [A-Z] [a-zA-Z]//-可以局部使用
漢字范圍：[\u4e00-\u9fa5]
預(yù)定義字符集：使用簡化的符號，定義常用字符集
比如：[0-9] ——> \d [a-zA-Z0-9_] ——> \w 空字符 ——> \s
如果規(guī)則正文中出現(xiàn)特殊符號，用\轉(zhuǎn)為原文
.一個(gè)人一字符！
數(shù)量詞：規(guī)定前邊一個(gè)字符出現(xiàn)次數(shù)的兩次
語法：{min,max}
{num}：固定長度
{min,}：至少min個(gè)，多了不限
手機(jī)號：\+86\s1[3578]\d{9}
用戶名：\w{6,8}
day08
回復(fù)：
[]：備選字符集，只能多選一。一個(gè)[]只能匹配一位字符
比如：我[去草]：我去 我草
[]內(nèi)：開頭^：除了xx都行：[01235689] ——> [^47]
-：表示備選字符的范圍 ：[a-z] [0-9] [A-Z]
預(yù)定義字符集：
[0-9] ——> \d
[a-zA-Z_] ——> \w
\s：空字符： \n \t 空格
量詞：修飾前一位字符出現(xiàn)的次數(shù)
{min,max}：最少min個(gè)，最多max個(gè)
{min,}：最少min個(gè)，最多不限制
{num}：固定num個(gè)
比如：驗(yàn)證座機(jī)號碼：\d{3,4}-\d{7,8}
正課：
特殊數(shù)量詞：+ * ?
？：可有可無，對多只能出現(xiàn)一次
比如：我了？去： 我去 我了去 我了個(gè)去X 我了了去X
*：可有可無，不限制出現(xiàn)次數(shù)
比如：點(diǎn)亮我生命的火*：
點(diǎn)亮我生命的
點(diǎn)亮我生命的火
點(diǎn)亮我生命的火火火
+：至少出現(xiàn)一次！不限制出現(xiàn)次數(shù)
比如：點(diǎn)亮我生命的火+：
點(diǎn)亮我生命的火
點(diǎn)亮我生命的火火火
如果正文中出現(xiàn)+?*，都要用\轉(zhuǎn)義
()：分組：改變模式的匹配順序
比如：驗(yàn)證身份證號：\d{15}(\d{2}[0-9xX])?
驗(yàn)證手機(jī)號：(\+86)?\s+1[3578]\d{9}
^：整個(gè)正則表達(dá)式的開頭，表示以xxx開始
$：整個(gè)正則表達(dá)式的結(jié)尾，表示以xxx結(jié)束
?= 預(yù)判，前一個(gè)字符之后，必須緊跟xxx
?! 預(yù)判，前一個(gè)字符之后，必須不能跟xxx
課堂練習(xí)：中文姓名：[\u4e00-\u9fa5]{2,6}
電子郵件：\w+@\w+([-]\w+)*(\.\w+)+
其中：\w+([-]\w+)* —— 匹配域名
一個(gè)以上的字母，后可跟“-字母”，可有可無
(\.\w+)+
“.字母”組合至少出現(xiàn)1次
RegExp對象：專門封裝一條正則表達(dá)式，提供使用正則表達(dá)式的常用API
如何使用RegExp對象：1.創(chuàng)建 2.調(diào)用API
v如何創(chuàng)建正則表達(dá)式對象：ar regExp = /正則表達(dá)式/ig;
API：
驗(yàn)證：var boolean = regExp.test("被檢查的字符串");
如果驗(yàn)證通過：返回true；否則返回false
驗(yàn)證 vs 查找：
驗(yàn)證要求完整匹配！查找要求部分匹配！
**test方法默認(rèn)：只要找到就返回true！**
正則表達(dá)式前加^，后加$
查找：exec：查找關(guān)鍵字的位置，又能找到關(guān)鍵字的內(nèi)容
indexOf不支持正則，search支持正則，每次只能找1個(gè)
match所有內(nèi)容，但得不到位置！
var arr = regExp.exec("被查找的內(nèi)容");
arr[0]：找到的關(guān)鍵字內(nèi)容
arr.index屬性：找到的關(guān)鍵字的位置
exec方法每次只能找1個(gè)，但是每次自動(dòng)修改regExp對象的lastIndex屬性！
regExp對象的lastIndex屬性：表示下次開始匹配的位置！
查找：僅判斷有沒有，或者僅查找位置：str.indexOf()
支持正則表達(dá)式：str.search()
僅所有關(guān)鍵字的內(nèi)容：str.match()
即找位置，又找內(nèi)容：regExp.exec()
/正則表達(dá)式/
var regExp = new RegExp("\\d{6}", "ig"); 動(dòng)態(tài)創(chuàng)建正則表達(dá)式
強(qiáng)調(diào)：所有\(zhòng)都要改為\\
貪婪模式： .+ .*，默認(rèn)先匹配整個(gè)字符串，再縮小范圍！
懶惰模式： (.+?) (.*?)，從第一個(gè)字符開始，向后擴(kuò)展范圍
下午：
從正則表達(dá)式匹配的內(nèi)容中，取一部分：RegExp.$n
n：正則表達(dá)式中第n個(gè)分組，其實(shí)就是第n個(gè)圓括號
強(qiáng)調(diào)：分組從1開始
必須通過RegExp類型，直接調(diào)用$n，不能使用對象！
String對象與正則表達(dá)式
str = str.replace(/正則表達(dá)式/ig, "替換值");
var arr = str.match(/正則表達(dá)式/ig); str.search()
str.split(/正則表達(dá)式/);
trim功能：去除字符串開始和結(jié)尾的空格。中間空格不去除！
對輸入字符串的處理，多數(shù)要先清除開頭結(jié)尾空格，再處理
IE8不支持trim()方法！
自定義trim()方法：
function trim(str){
var regExp = /(^\s+)\(\s+$)/g;
str = str.replace(regExp, "");
return str;
}
String總結(jié)：所有的API都無法修改原字符串，都會(huì)返回新的字符串
所有StringAPI都需要用變量保存結(jié)果！
str.length 字符個(gè)數(shù)
str = str.toUpperCase()/toLowerCase()
查找關(guān)鍵字：var index = str.indexOf("關(guān)鍵字"[, from])
var arr = str.match(/正則表達(dá)式/g);
獲得子字符串：var substr = str.slice(start, end + 1);
str.substring(start, end + 1);
str.substr(start, count);
替換：str = str.replace(/正則表達(dá)式/g, "替換值");
獲得指定位置的字符：var char = str.charAt(index);
str[index];
字符編碼轉(zhuǎn)碼：var code = str.charCodeAt(index);
var char = String.fromCharCode(code);
RegExp對象總結(jié)：
var reg = /正則表達(dá)式/ig;
var reg = new RegExp("正則表達(dá)式", "ig");
*其中所有的\都要改為\\！*
驗(yàn)證str中時(shí)候包含reg匹配的關(guān)鍵字：
var boolean = reg.test(str);
*強(qiáng)調(diào)：完整驗(yàn)證，都需要在正則表達(dá)式前加^后加$*
同時(shí)查詢所有關(guān)鍵字的內(nèi)容和位置
while((arr= reg.exec(str)) != null){
arr[0] ——> 找到的一個(gè)關(guān)鍵
arr.index ——> 當(dāng)前關(guān)鍵字的位置
}
RegExp.$n：
獲得正則表達(dá)式中第n個(gè)分組（圓括號）匹配的子字符串
Math類型：封裝了所有數(shù)學(xué)計(jì)算有關(guān)的API
不能new！
Math.PI
Math.round(num) ——> 四合五入取整
Math.ceil(num) ——> 向上取整
Math.floor(num) ——> 向下取整
Math.pow(底數(shù), 冪);
Math.sqrt(num);//平方根！
絕對值：Math.abs(num);
Math.max/min(值1, 值2, 值3, ...);
取數(shù)組中的最大值：var max = Math.max.apply(Math, arr);
隨機(jī)數(shù)：Math.random(); 0<=r<1
任意min-max：
Math.floor(Math.random() * (max - min +1) + min);
/*隨機(jī)生成四位驗(yàn)證碼*/
//Step1:數(shù)組：所有字母、數(shù)字
var codes = [];
for(var i = 48; i <= 57; codes.push(i), i++);
for(var i = 65; i <= 90; codes.push(i), i++);
for(var i = 97; i <= 122; codes.push(i), i++);
function getCode(){
var arr = [];
for(var i = 0; i < 4; i++){//0-61之間取隨機(jī)數(shù)
var index = Math.floor(Math.random()*(60-0+1) + 0);
var char = String.fromCharCode(codes[index]);
arr.push(char);
}
return arr.join("");
}
while(true){
var code = getCode();
var input = prompt("輸入驗(yàn)證碼：" + code);
var reg = /^[a-zA-Z0-9]{4}$/;
if(reg.test(input)){
if(code.toLowerCase() == input.toLowerCase()){
document.write("登錄成功");
break;
}else{
alert("驗(yàn)證碼輸入錯(cuò)誤！");
}
}
}
Date對象：封裝一個(gè)時(shí)間點(diǎn)數(shù)據(jù)，提供對時(shí)間、日期的常用API
創(chuàng)建：var date = new Date();
1.創(chuàng)建Date類型對象； 2.自動(dòng)獲得瀏覽器當(dāng)前時(shí)間點(diǎn)！
自定義時(shí)間：var date = new Date("2015-6-9 16:47");
1.創(chuàng)建Date類型對象； 2.自定義一個(gè)具體時(shí)間點(diǎn)
*Date對象中，
保存的是從1970年1月1日 0:00:00到現(xiàn)在的毫秒數(shù)
var date = new Date();
API:
1.每個(gè)分量都有一對get/set方法，獲取/設(shè)置該分量的值！
2.命名：年/月/日 沒有s，時(shí)，分，秒 有s
3.取值、賦值：除了每月中的日之外，其余都是從0開始，到-1結(jié)束
每月中的日，從1開始，帶31結(jié)束
月：取值時(shí)，要+1修正；賦值是，-1修正
星期：//日 一 ............ 六
//0 1 6
日期計(jì)算：兩日期對象相減，得到毫秒數(shù)
時(shí)間做+：var nowMs = date.getTime(); 返回時(shí)間毫秒數(shù)
var nextMs = nowMs + 5*60*1000;
var next = new Date(nextMs);
使用毫秒做計(jì)算，不改變原時(shí)間對象！需要重新封裝時(shí)間對象
最大僅能算到“天數(shù)”。再算“月數(shù)”，無法確定每月天數(shù)。
day09
回顧：
Date對象：內(nèi)部封裝了一個(gè)毫秒數(shù)
創(chuàng)建日期對象：
var date = new Date("2016/7/4");PPT上 new Date("2016-7-4");僅兼容chrome
API
1.每個(gè)分量都有一對get/set方法
2.命名：年月日星期 不帶s；時(shí)分秒帶s
3.值范圍：月中的日：1-31；其他：0-減1
計(jì)算：1.兩日期相減，得到毫秒數(shù)
2.日期+/- 天小時(shí)分秒：用毫秒
3部：1.var ms = date.getTime();
2.ms = ms +/- 毫秒數(shù)
3.var newDate = new Date(ms);
正課：
3.任意分量的計(jì)算：
先取出分量值，做計(jì)算，再set回去！
var now = new Date();
var day = now.getDate();//4
day -= 10;//-6
now.setDate(day);
document.write(now);
date.setXXX()；1.自動(dòng)調(diào)整進(jìn)制
2.*直接修改原日期對象*
如何保留原日期對象？先new出新Date對象，再set
var newDate = new Date(oldDate.getTime());
日期格式轉(zhuǎn)換：
date.toLocaleString();//獲得日期和時(shí)間的本地格式
date.toLocaleDateString();//僅獲得日期部分的本地格式
date.toLocaleTimeString();//僅獲得時(shí)間部分的本地格式
日期格式轉(zhuǎn)換：都要自定義format(date)方法！
function format(date){
var week = ["日", "一", "二", "三", "四", "五", "六"];
var y = date.getFullYear() + "年";
var m = date.getMonth() + 1 + "月";
var d = date.getDate() + "日";
var w = " 星期" + week[date.getDay()];
var h = date.getHours();
var am = h >= 12 ? " 上午 " : " 下午 ";
h = h > 12 ? h - 12 : h;
h = h < 10 ? "0" + h : "" + h;
var mi = date.getMinutes();
mi = mi < 10 ? "0" + mi : "" + mi;
var s = date.getSeconds();
s = s < 10 ? "0" + s : "" + s;
var str = y + m + d + w + am + h + ":" + mi + ":" + s;
return str;
}
Number類型 API:
num.toFixed(n); 按n位小數(shù)四舍五入，*返回一個(gè)字符串*！
何時(shí)使用：在計(jì)算之后，顯示結(jié)果是，*最后調(diào)用toFixed方法*
vs Math.round(num)：只能取整 返回一個(gè)數(shù)Number
num.toString(n)：按n進(jìn)制輸出數(shù)字的字符串格式
錯(cuò)誤處理：
什么是錯(cuò)誤處理：導(dǎo)致程序運(yùn)行停止的運(yùn)行時(shí)異常狀態(tài)
什么是錯(cuò)誤處理：在出現(xiàn)異常狀態(tài)是，保證程序不停止的機(jī)制
如何錯(cuò)誤處理：
錯(cuò)誤類型：Error類型：所有錯(cuò)誤對象的父類型
6種子類型：EvalError,
RangeError：參數(shù)超出范圍
比如：num.toFixed(n) n<0 拋出RangeError
ReferenceError：引用錯(cuò)誤：找不到對象
比如：只要使用未聲明的變量時(shí)，都要拋出ReferenceError
SyntaxError：語法錯(cuò)誤！修改源代碼就可以解決！
TypeError：錯(cuò)誤的使用了類型和類型的方法！
URIError：URI錯(cuò)誤
如何處理錯(cuò)誤：
try{
可能出錯(cuò)的代碼
}catch(err){只要拋出錯(cuò)誤，都要?jiǎng)?chuàng)建一個(gè)Error對象
錯(cuò)誤處理的代碼
1.獲得錯(cuò)誤信息：err.name 類型
2.根據(jù)錯(cuò)誤的類型，執(zhí)行不同的處理
}[finally{可有可無
//程序中使用了大對象！一樣要在finally中主動(dòng)釋放
無論是否出錯(cuò)，都必須執(zhí)行的代碼
}]
能用if...else解決的問題，就不用try...catch！
何時(shí)使用try...catch？try...catch處理的是無法預(yù)料的問題！
主動(dòng)拋出異常：如何告知方法調(diào)用者出錯(cuò)？
thow new Error("自定義的錯(cuò)誤信息");
下午：
Function對象：
1.以聲明方式定義方法：放前放后無所謂
function 方法名(參數(shù)列表){方法體；return 返回值}
2.以創(chuàng)建對象方式定義方法：必須定義在使用之前！
var 方法名 = new Function("參數(shù)1", ..., "方法體；return 返回值");
只有聲明方式的方法定義才被提前解析！——方法聲明提前
重載：方法，根據(jù)傳入的參數(shù)列表不同，執(zhí)行不同的任務(wù)
js支不支持重載：語法不支持，但是可以通過 arguments對象 模擬重載效果
arguments對象：方法對象中保存所有參數(shù)的類數(shù)組對象
類數(shù)組對象（object like array）：長的像數(shù)組的對象
*方法內(nèi)，自動(dòng)創(chuàng)建！直接使用！*
arguments.length：保存變量的個(gè)數(shù)
arguments[i]：訪問傳入的第i + 1個(gè)變量
3.使用匿名函數(shù)賦值的方式定義方法：
匿名函數(shù)：沒有方法名的函數(shù)定義！
var compare = function(a, b){return a-b;}
鄙視題：js中方法定義的方式有幾種：3種！
A.function compare(a, b){return a - b}
**************************************************************************
B.var compare = function(a, b){return a - b;}
C.var compare = new Function("a", "b", "return a- b;");
D.var compare = new Function(a, b, return a- b;); X
function isEmpty(str){
if(str === undefined){
return true;
}else if(str == null){
return true;
}else{
var reg = /^\s*$/;
return reg.test(str);
}
}
var ltrim = function(str){
var reg = /^\s+/;
return str.replace(reg, "");
}
var rtrim = function(str){
var reg = /\s+$/;
return str.replace(reg, "");
}
匿名函數(shù)2個(gè)用途：
1、回調(diào)函數(shù)：函數(shù)何時(shí)執(zhí)行，程序員不需要控制！
由所在環(huán)境執(zhí)行！
比較器！
//var compare = function(a, b){return a - b;} arr.sort(compare);
arr.sort(function(a, b){return a - b;})
事件處理函數(shù)：onclick = "calc(12)";
2、自調(diào)函數(shù)：匿名函數(shù)自己調(diào)用自己！
當(dāng)函數(shù)不需要重復(fù)使用時(shí)，使用匿名函數(shù)自調(diào)。
語法：
(function(參數(shù)...){
方法體；
})(參數(shù)值...);
在函數(shù)定義的位置立即執(zhí)行！
閉包：函數(shù)外使用了不屬于自己的局部變量
何時(shí)使用閉包？保護(hù)局部變量
day10
回顧
1. 閉包
判斷閉包3特點(diǎn)：
1. 嵌套函數(shù)
2. 內(nèi)層函數(shù)操作了外層函數(shù)的局部變量
3. 外層函數(shù)將內(nèi)層函數(shù)返回到外部
被全局變量保存住
判斷閉包執(zhí)行結(jié)果：
*1. 外層函數(shù)被調(diào)用幾次，就有幾個(gè)受保護(hù)的局部變量副本
2. 反復(fù)調(diào)用來自一個(gè)閉包的函數(shù)，受保護(hù)的局部變量就變化幾次
正課：
1. 面向?qū)ο?br> 1. 創(chuàng)建自定義對象
2. ****繼承
1. 面向?qū)ο螅涸诔绦蛑卸际怯靡粋€(gè)對象來描述現(xiàn)實(shí)中一個(gè)具體的東西；
現(xiàn)實(shí)中的一個(gè)東西都包含屬性和功能：
屬性：描述一個(gè)東西特點(diǎn)的變量
功能：東西可以執(zhí)行操作
什么是對象：封裝多個(gè)數(shù)據(jù)的存儲(chǔ)空間
什么是自定義對象：封裝現(xiàn)實(shí)中一個(gè)東西的屬性和功能的存儲(chǔ)空
間?，F(xiàn)實(shí)中東西的屬性會(huì)成為對象中的屬性變量?，F(xiàn)實(shí)中的東西的功能，會(huì)成為對象中
的方法（函數(shù)）
2. 創(chuàng)建自定義對象：3種方式：
1. var obj = {'屬性名1':值1,
'屬性名2':值2,
...
'功能名1':function()
{...}};
js中一切都是對象！所有對象的底層都是hash數(shù)組
屬性：如何訪問屬性：2種：obj.屬性名 obj["屬性名"]
訪問對象中不存在的屬性
（訪問數(shù)組中不存在的下標(biāo)）：不會(huì)出錯(cuò)，返回undefined
強(qiáng)行給不存在屬性賦值，不報(bào)錯(cuò)！js會(huì)自動(dòng)創(chuàng)建同名屬性
如何判斷某個(gè)對象是否包含指定成員：3種
1. obj.hasOwnProperty("成員名");
2. "屬性名" in 對象
如果找到，返回true，否則返回false
3. 直接使用 obj.屬性名 作為條件：
arr.indexOf !== undefined
如果不包含，返回undefined ————> false
如果包含，返回值或function ————> true
何時(shí)省略：判斷方法是否存在時(shí)，可省略 !==
如果確定屬性值一定
不是null, 0, "", NaN 也可省略
方法：如何在方法中，訪問當(dāng)前對象自己：
****this關(guān)鍵字：運(yùn)行時(shí)，指代正在*調(diào)用*方法的對象
（.前的對象）
this本質(zhì)是window下唯一的一個(gè)指針，指向當(dāng)前正在
調(diào)用方法的對象
如何在方法內(nèi)，訪問當(dāng)前對象自己的屬性：this.屬性名
**在方法內(nèi)訪問當(dāng)前對象自己的屬性，必須用this.屬性
名
省略this，默認(rèn)訪問活動(dòng)對象和window中的變量（閉
包除外）
***this和定義在哪無關(guān)！僅和調(diào)用時(shí)使用的當(dāng)前對象有
關(guān)
***如果無主的調(diào)用或復(fù)制，默認(rèn)this都是window！
PM：
正課：
1. ***面向?qū)ο螅豪^承
面向?qū)ο笕筇攸c(diǎn)：封裝 繼承 多態(tài)
封裝：將描述同一個(gè)東西的屬性和方法，定義在一個(gè)對象中
繼承：父對象中的屬性和方法，子對象可直接使用
多態(tài)：同一個(gè)對象，在不同情況下，呈現(xiàn)不同的狀態(tài)
重載：同一方法名，傳入?yún)?shù)不同，執(zhí)行不同的操作
重寫：子對象覺得父對象的成員不好用，可自己定義一
個(gè)，覆蓋父對象的成員
創(chuàng)建對象：3種：
1. 對象直接量
var obj = {"屬性名":值, ..., "方法名":function(){...}};
2. var obj = new Object();//創(chuàng)建一個(gè)空對象
obj.屬性名 = 值;
obj.方法名 = function(){... this.屬性名 ...};
3. 利用構(gòu)造函數(shù)*反復(fù)*創(chuàng)建*相同結(jié)構(gòu)*的對象
構(gòu)造函數(shù)：描述一類對象結(jié)構(gòu)的特殊函數(shù)
2步：
1. 定義構(gòu)造函數(shù)
function 構(gòu)造函數(shù)名|類型名(屬性參數(shù)1, ...){
this.屬性名 = 屬性參數(shù)1;
//在當(dāng)前正在創(chuàng)建的對象中創(chuàng)建一個(gè)屬性名
//賦值為屬性參數(shù)1的值
...
this.方法名 = function(){
...this.屬性名...
}
}
2. 利用構(gòu)造函數(shù)創(chuàng)建對象
var obj = new 構(gòu)造函數(shù)名|類型名(屬性值1, ...);
new：1. 創(chuàng)建一個(gè)空對象：new obj = {};
2. 利用空對象，調(diào)用構(gòu)造函數(shù)
構(gòu)造函數(shù)在空對象中添加屬性和
方法
3. 設(shè)置新對象的 __proto__ 指向構(gòu)造函數(shù)的
prototype對象
4. 返回新對象的地址
繼承：js中一切繼承都是用原型對象實(shí)現(xiàn)的！
原型對象：每個(gè)函數(shù)對象都有一個(gè)原型對象
構(gòu)造函數(shù)的原型對象負(fù)責(zé)保存所有子對象共享的成員！
建議：所有子對象共享的方法，都應(yīng)定義在構(gòu)造函數(shù)的原型對象中。———
—避免重復(fù)定義方法對象，浪費(fèi)內(nèi)存。
說明：其實(shí)所有內(nèi)置類型的API都是定義在類型.prototype
擴(kuò)展對象屬性：2種擴(kuò)展：
1. 擴(kuò)展共有屬性：通過構(gòu)造函數(shù).prototype添加的屬性
2. 擴(kuò)展自有屬性：通過某一具體子對象添加屬性
判斷自有屬性或擴(kuò)展屬性：
1. 判斷自有屬性：obj.hasOwnProperty("屬性名");
2. 判斷共有屬性："屬性名" in obj && !obj.hasOwnProperty("屬性名")
在原型對象關(guān)系中包含 且 子對
象自己*沒有*
刪除屬性：delete 對象.屬性名
*僅能刪除當(dāng)前對象自己的屬性，無法刪除共有屬性
全局變量：3種
var n = 1; window.n = 1; window["n"] = 1;
不能delete 不能delete 能delete
原型鏈：由各級對象的 __proto__ 逐級繼承形成的關(guān)系
獲得任意對象的父級原型對象：Object.getPrototypeOf(子對象) =》子對象.__proto__
檢查對象的父對象：父對象.isPrototypeOf(子對象);
day11
面向?qū)ο螅悍庋b 繼承 多態(tài)
1. 創(chuàng)建對象：3種：4種：
1. 直接量：var obj = {"屬性名":值, ..., "方法名":function(){}};
__proto__ ————> Object.prototype
2. new關(guān)鍵字：var obj = new Object();
obj.屬性名 = 值;
...
obj.方法名 = function(){}
3. 使用構(gòu)造函數(shù)反復(fù)創(chuàng)建相同結(jié)構(gòu)的對象：2步
1. 定義構(gòu)造函數(shù)：
function 構(gòu)造函數(shù)名(屬性參數(shù), ...){
this.屬性名 = 屬性參數(shù);
if(!構(gòu)造函數(shù)名.prototype.方法名){
構(gòu)造函數(shù)名.prototype.方法名 =
function(){}
}
}
2. 使用new創(chuàng)建對象同時(shí)，調(diào)用構(gòu)造函數(shù)：
var obj = new 構(gòu)造函數(shù)名(屬性值, ...);
4. Object.create(父對象， {擴(kuò)展屬性的列表對象});
2. this：指代當(dāng)前正在調(diào)用方法的對象
this和定義在哪無關(guān)！僅和調(diào)用時(shí)使用的對象有關(guān)！
所有無主（不用var賦值的變量，匿名函數(shù)）都是window的
3. 原型，原型鏈，繼承：
原型：保存所有子對象共有屬性和方法的對象！
所有函數(shù)都有prototype，指向自己的原型對象
所有對象都有 __proto__ ，指向自己父級原型對象
所有原型對象都有constructor，指回原型對應(yīng)的構(gòu)造函數(shù)
原型鏈：所有父子級對象間由 __proto__ 形成的多級引用關(guān)系
————>*多級*繼承
原型相關(guān)API：
1. 判斷自有屬性和共有屬性：
1. 判斷自有：obj.hasOwnProperty("屬性名");
2. 判斷原型鏈上的屬性：2種
判斷不包含：if(!("屬性名" in obj/原型))
if(obj.屬性名 === undefined)
if(!obj.屬性名)
3. 僅判斷共有：必須滿足兩個(gè)條件
!obj.hasOwnProperty("屬性名") && obj.屬性名
2. 獲得任意對象的原型：
obj.__proto__ X
Object.getPrototypeOf(obj)
3. 判斷父對象是否在子對象的原型鏈上
父對象.isPrototypeOf(子對象)
***檢測一個(gè)對象是不是數(shù)組類型：4種：
1. Array.prototype.isPrototypeOf(obj);
2. obj instanceof Array
對象 是不是 構(gòu)造函數(shù) 的實(shí)例
3. obj.constructor == Array 僅判斷直接父級
4. 利用當(dāng)前對象，強(qiáng)行調(diào)用原始的toString方法
Object.prototype.toString.call(obj) == "[object Array]"
apply(obj)
繼承：
為什么要繼承：代碼重用！節(jié)省空間！
1. 直接繼承對象：想方設(shè)法修改對象的 __proto__ 屬性
3種：
1. 僅修改一個(gè)對象的 __proto__
Object.setPrototypeOf(子對象， 父對象);
2. 通過修改構(gòu)造函數(shù)的原型對象，實(shí)現(xiàn)批量修改后續(xù)子對象的繼承關(guān)系。
構(gòu)造函數(shù).prototype = 父對象
強(qiáng)調(diào)：僅影響之后創(chuàng)建的對象的繼承關(guān)系
之前創(chuàng)建的對象依然繼承舊構(gòu)造函
數(shù).prototype
3. var obj = Object.create(父對象[, {屬性列表}])
創(chuàng)建一個(gè)空對象，
繼承父對象中的屬性，
繼承同時(shí)可再擴(kuò)展屬性和方法
2. 僅繼承結(jié)構(gòu)：模擬java中的繼承
function 父類型構(gòu)造函數(shù)(屬性參數(shù)1, 屬性參數(shù)2){
this.屬性1 = 屬性參數(shù)1；
this.屬性2 = 屬性參數(shù)2;
}
function 子類型構(gòu)造函數(shù)(屬性參數(shù)1, 屬性參數(shù)2, 屬性參數(shù)3){
父類型構(gòu)造函數(shù).call(this, 屬性參數(shù)1, 屬性參數(shù)2);
this.屬性3 =屬性參數(shù)3;
}
var obj = new 子類型構(gòu)造函數(shù)(值1, 值2, 值3);
轉(zhuǎn)自 https://www.cnblogs.com/skorzeny/p/5668527.html
|
