一. Javascript基本介紹

Javascript 簡(jiǎn)稱JS武翎，是一門獨(dú)立的編程語(yǔ)言烈炭，是可以運(yùn)行在瀏覽器上的腳本；名稱上有Java宝恶，但是它與Java沒有任何關(guān)系的符隙。
在HTML中引入JS的方法：
方案一, 直接在<script>標(biāo)簽中引入編寫js代碼
方案二, 將js代碼寫在js文件中, 然后通過script標(biāo)簽的src屬性進(jìn)行引入
兩種方式運(yùn)行出的效果是一致的. 但是需要各位注意一點(diǎn), HTML程序在執(zhí)行的時(shí)候是從上到下進(jìn)行渲染的. （代碼也是從上到下執(zhí)行的）

在js中使用// 來表示單行注釋. 使用/* */表示多行注釋.

二. Javascript基本數(shù)據(jù)類型

常見的兩行JS代碼

console.log('開始學(xué)習(xí)了');    // 在控制臺(tái)打印，相當(dāng)于python中的print
let a = '1002';
console.log(typeof a);    //打印變量a的數(shù)據(jù)類型

1垫毙、主要是以下幾種數(shù)據(jù)類型

number  數(shù)字, 不論是整數(shù)還是小數(shù), 數(shù)據(jù)類型都是number
string  字符串, 這個(gè)沒啥可聊的. 就是很單純的字符串
boolean  布爾值, 只有兩個(gè), true和false. 注意不是大寫T和F. 
object 對(duì)象, 這個(gè)比較特殊. 你可以理解為所有被new出來的東西都是對(duì)象  
undefined, 這個(gè)表示未定義. 所有沒有被定義過的東西默認(rèn)都是該類型 類似像空一樣的東西

2霹疫、定義變量

JS中，要使用一個(gè)變量要先定義變量综芥，關(guān)鍵詞是 var 或者 let丽蝎，可以定義變量名稱，不賦值膀藐。要注意一行代碼同時(shí)創(chuàng)建多個(gè)變量的情況屠阻。

var 變量名; // 創(chuàng)建變量, 此時(shí)該變量除了被賦值啥也干不了. 
let 變量名; // 創(chuàng)建變量, 此時(shí)該變量除了被賦值啥也干不了. 
var 變量名 = 值; // 創(chuàng)建一個(gè)變量, 并且有值. 
var 變量名 = 值1, 變量名2 = 值2, 變量名3 = 值3.....; // 一次創(chuàng)建多個(gè)變量.并都有值
var 變量名1, 變量名2, 變量名3 = 值3;  // 創(chuàng)建多個(gè)變量. 并且只有變量3有值

3红省、JS中的運(yùn)算符

JS中的運(yùn)算符和Python幾乎一致. 但有些特殊的.

and, or, not 到了js中注意,換成了&&, ||, !, 其含義和概念是一致的.

var a = 10, b = 20, c = 30 ;
console.log(a > b && b > c);  // false
console.log(!(a > b)) // 注意括號(hào)

4、JS 中的 == 和 ===,

== 只是判斷值是否一致,  
=== 會(huì)判斷數(shù)據(jù)類型和數(shù)據(jù)是否都一致. 

var a = "123";
var b = 123;
console,log(a == b);  // true
console.log(a === b); // false

5国觉、數(shù)據(jù)類型及進(jìn)制轉(zhuǎn)換

字符串轉(zhuǎn)換成數(shù)字吧恃，使用parseInt(字符串)，parse英文翻譯是“解析”的意思

let a = '1002';
console.log(typeof a);
let b = parseInt(a);
console.log(typeof b); //輸出 number

數(shù)字轉(zhuǎn)換成字符串
方法1：數(shù)字.toString()麻诀，參數(shù)不填是默認(rèn)是十進(jìn)制
方法2： 數(shù)字 + ""

var a = 10;
var b = a.toString(16);  //輸出是16進(jìn)制數(shù)字對(duì)應(yīng)的字符串蚜枢，10對(duì)應(yīng)16進(jìn)制是a，
console.log(b);
console.log(typeof b);
//方法2
b = a+"";    //b就是字符串了

進(jìn)制轉(zhuǎn)換
parseInt 的結(jié)果是十進(jìn)制针饥，參數(shù)中要說明要轉(zhuǎn)換的參數(shù)是多少進(jìn)制的
toString() 要說明轉(zhuǎn)換成多少進(jìn)制的

var a = 10;
// 16進(jìn)制的數(shù)字是多少
var x = a.toString(16);  // a厂抽，字符串類型
console.log(x, typeof x)    //a string


// AB的十進(jìn)制是多少
var d = parseInt("AB", 16); // parseInt的結(jié)果是十進(jìn)制，參數(shù)中要說明要轉(zhuǎn)換的參數(shù)是多少進(jìn)制的 171
console.log(d, typeof d)    //171 number

6丁眼、JS中的++與--

a++; 就是a = a + 1
++a; 就是a = a + 1
a--; 就是a = a - 1
--a; 就是a = a - 1
重點(diǎn)概括：

1. 不論是a++還是++a. 目的都是讓a自增1.

a++這個(gè)表達(dá)式整體運(yùn)算出來的結(jié)果等于 a
++a這個(gè)表達(dá)式整體運(yùn)算出來的結(jié)果等于 a + 1
表達(dá)式執(zhí)行完成后筷凤，a自增1

a = 10
b = a++    //a++表達(dá)式運(yùn)算結(jié)果為a，就是10苞七，所以b=10藐守；運(yùn)算完成后，a自增1蹂风，那么a=11
console.log(b)  // 10
console.log(a)  // 11

a = 10
b = ++a  //++a表達(dá)式運(yùn)算結(jié)果為a+1卢厂，就是10+1，所以b=11惠啄；運(yùn)算完成后慎恒，a自增1，那么a=11
console.log(b)  // 11
console.log(a)  // 11

以下邏輯比較奇怪撵渡，一般不會(huì)這么使用

a = 10;
a = a++;    //a=a融柬，也就是a=10，運(yùn)算完成后a自增1趋距，所以a又變成了11粒氧，但是最終賦值的時(shí)候，還是按照之前計(jì)算的a=a++节腐，而由于是先計(jì)算a++外盯，所以a++的值是a=10，a=11只是短暫的瞬間
console.log(a);  // 10

a = 10;
a = ++a;    //a=a+翼雀，也就是a=11饱苟，運(yùn)算完成后a自增1，所以a短暫瞬間變成了12锅纺，a=12掷空，但是賦值是最后運(yùn)算的，而++a是最初運(yùn)算的囤锉，值是11
console.log(a)  // 11

剖析：

a = 10;
a = a++;  
console.log(a);  // 10

第一步：a = 10
第二步：1）先計(jì)算a++坦弟，表達(dá)式的值是a，也就是10官地；
2）a自增1酿傍，而原來a=10，所以驱入，此時(shí)a==11赤炒；
3）最終賦值，a = a++亏较，記住莺褒，這一步只是賦值，而不再進(jìn)行對(duì)a進(jìn)行任何計(jì)算雪情，a++之前已經(jīng)計(jì)算好了遵岩，表達(dá)式的值就是10，所以巡通，賦值這步的結(jié)果就是把之前計(jì)算好的a++的值賦值給a尘执，所以，a==10宴凉。（在上一步a通過自增已經(jīng)從10變成11了誊锭，但是最后這步又對(duì)a重新進(jìn)行賦值了）
第三步：打印a的值，所以打印的結(jié)果是a=10

第二部分代碼：

a = 10;
a = ++a;  
console.log(a);  // 11

第一步：a = 10
第二步：1）先計(jì)算++a弥锄，表達(dá)式的值是a+1的值丧靡，也就是++a == 11；
2）a自增1籽暇，而原來a=10窘行，所以，此時(shí)a==11图仓；
3）最終賦值罐盔，a = ++a，記住救崔，這一步只是賦值惶看，而不再進(jìn)行對(duì)a進(jìn)行任何計(jì)算，++a之前已經(jīng)計(jì)算好了六孵，表達(dá)式的值就是11纬黎，所以，賦值這步的結(jié)果就是把之前計(jì)算好的a++的值賦值給a劫窒，所以本今，a=11；
第三步：打印a的值，所以打印的結(jié)果是a=11

7冠息、字符串操作

s.split() 字符串切割

let s = "劉德華_張學(xué)友_黎明_郭富城";

let res=s.split('_');
console.log(res);    // [ '劉德華', '張學(xué)友', '黎明', '郭富城' ]
console.log(typeof res);    // object

s.substr(start, len) 字符串切割, 從start開始切, 切l(wèi)en個(gè)字符

let s = "劉德華_張學(xué)友_黎明_郭富城"
let res = s.substr(4, 3);  // 從索引為4的位置開始切挪凑，切取長(zhǎng)度為3
console.log(res);  // 張學(xué)友

s.substring(start, end) 字符串切割, 從索引start切割到索引end，取左不取右

let s = "劉德華_張學(xué)友_黎明_郭富城"
let res1=s.substring(0,3)
console.log(res1)  //劉德華

（重點(diǎn)）s.length 字符串長(zhǎng)度

let s = "劉德華_張學(xué)友_黎明_郭富城"
console.log(s.length)

s.charAt(i) 第i索引位置的字符

let s = "劉德華_張學(xué)友_黎明_郭富城"
console.log(s.charAt(0))  //劉

（重點(diǎn)）st.charCodeAt(索引)逛艰，對(duì)應(yīng)索引的字符在ASCII碼中的字符編碼

let st='nameAge天空'
let res=st.toUpperCase()
console.log(st.charCodeAt(3)); //索引3對(duì)應(yīng)的字符是e躏碳，在ASCII編碼中對(duì)應(yīng)是101

把ASCII字符編碼轉(zhuǎn)換成字符

let as = String.fromCharCode(101)
console.log(as);  //輸出字符是e

s.indexOf('xxx')返回xxx的第一個(gè)索引位置, 如果沒有xxx. 則返回-1

let s = "劉德華_張學(xué)友_黎明_郭富城華"
let res=s.indexOf('華')
console.log(res);  //結(jié)果是2，返回的是散怖，第一個(gè)“華”的索引
console.log(s.indexOf('哈'))  //沒有'哈'這個(gè)字符菇绵，所以返回-1

s.lastIndexOf("xxx") 返回xxx的最后一次出現(xiàn)的索引位置，如果沒有xxx. 則返回-1

let s = "劉德華_張學(xué)友_黎明_郭富城華"
let res=s.lastIndexOf('華')
console.log(res);  //結(jié)果是14镇眷，返回的是咬最，最后一個(gè)“華”的索引

s.includes("xxx") 判斷xxx是否出現(xiàn)在s中. 在就返回 true，不在就返回 false欠动；相當(dāng)于是python中的in

let s = "劉德華_張學(xué)友_黎明_郭富城華"
console.log(s.includes('劉德華'));//返回true

s.toUpperCase() 把字符串中所有小寫字母轉(zhuǎn)換成大寫字母

let st='nameAge天空'
let res=st.toUpperCase()
console.log(res); // NAMEAGE天空

s.startsWith("xxx") 判斷是否以xxx開頭

let st='nameAge天空'
let res=st.toUpperCase()
console.log(res)
console.log(st.startsWith('n'))    ;// true
console.log(st.startsWith('an'))    ;// false

關(guān)于null和undefined. null可以理解為變量創(chuàng)建了永乌，但是值為空. undefined就是沒有定義變量。

練習(xí)：提取json字符串

s = "callback_jsonp({'name': '劉德華', 'age': 18, zhiye:  {'one': '歌手'}})";

let start = s.indexOf('{')
let end = s.lastIndexOf('}')
let ret = s.substring(start, end+1)
console.log(ret)

二. JS條件語(yǔ)句

注：如果代碼塊1中的內(nèi)容只有一行. 則可以省略外面的大括號(hào)(一些逆向工程里會(huì)有)

// 語(yǔ)法
if(條件1){
    代碼塊1    
}

// 解讀: 當(dāng)`條件1`成立時(shí), 執(zhí)行代`碼塊1`中的內(nèi)容, 如果`條件1`不成立. 則不執(zhí)行該`代碼塊1`中的內(nèi)容

例子

let a = 10;
if(a>1){
    console.log('條件成立');
};

if (a>1) console.log('如果大括號(hào)中的內(nèi)容只有一行. 則可以省略外面的大括號(hào)');

雙條件分支

// 語(yǔ)法
if(條件1){
    代碼塊1
} else {
    代碼塊2
}
// 解讀: 當(dāng)`條件1`成立時(shí), 執(zhí)行`代碼塊1`中的內(nèi)容, 如果`條件1`不成立. 則執(zhí)行`代碼塊2`中的內(nèi)容

例子

let b=10;
if (b>20){
    console.log('條件為真是執(zhí)行');

}else {
    console.log('條件為假是執(zhí)行');
}

多條件分支

// 語(yǔ)法
if(條件1){
    代碼塊1
} else if(條件2) {
    代碼塊2
} else if(條件3) {
    代碼塊3
} ... {
    代碼塊n
} else {
    代碼塊else
}
// 解讀: 當(dāng)`條件1`成立時(shí), 執(zhí)行`代碼塊1`中的內(nèi)容, 如果`條件2`不成立. 則執(zhí)行`代碼塊2`中的內(nèi)容...如果都不成立, 最終執(zhí)行`代碼塊else`中的內(nèi)容. 

例子

let c = 85;
if (c>=85){
    console.log('優(yōu)秀')}
else if(c>=75){
    console.log('良好')}
else if(c>=60){
    console.log('及格')}
else {
    console.log('不及格')}

switch語(yǔ)句. 也是一種多分支翁垂，在JS中常用于混淆铆遭，打亂case的執(zhí)行順序。

switch(變量){
    case 值1:
        代碼塊1
        break  // 可選
    case 值2:
        代碼塊2
        break  // 可選
    case 值3:
        代碼塊3
        break  // 可選
        
    default:   // 可選
        default代碼塊
}

/*
    解讀: 
        執(zhí)行時(shí), 
        switch會(huì)判斷變量的值是否是`值1`, 
        如果是, 則執(zhí)行代碼塊1以及代碼塊1中的break, 
        如果不是, 則繼續(xù)判斷`值2`...
        如果前面的`值`都沒有和`變量`相等的.則執(zhí)行`default代碼塊`. 
        
    注意, 
        每一個(gè)`case`中都可以選擇`break`, 也可以不選擇`break`, 需要注意的是, 如果不寫`break`. 
        那么就會(huì)形成`case穿透`現(xiàn)象. 
        
    例, `變量`的值如果和`值1` 相等. 并且case1中沒有寫`break`, 
    則在執(zhí)行的時(shí)候. 會(huì)執(zhí)行完`case1`中的代碼. 
    然后會(huì)自動(dòng)穿透到`case2`中去執(zhí)行里面的代碼, 而不經(jīng)過case2中的數(shù)據(jù)的驗(yàn)證. 

*/

例子

let t=10;
switch (t){
    case 1:
        console.log('我是1');
        console.log('我就是1');
        break;
    case 2:
        console.log('我是2');
        console.log('我就是2');
        break;
    case 3:
    console.log('我是3');
    console.log('我就是3');
    break;
    default:
        console.log('我是默認(rèn)');
}

case穿透現(xiàn)象的利用

let month=5
switch (month){
    case 1:
    case 2:
    case 3:
        console.log('第一季度');
        break;
    case 4:
    case 5:
    case 6:
        console.log('第二季度');
                break;

    case 7:
    case 8:
    case 9:
        console.log('第三季度');
                break;

    case 10:
    case 11:
    case 12:
        console.log('第四季度');
        break;
    default:
        console.log('輸入的月份要在1-12之間')
}

三. JS中的循環(huán)語(yǔ)句

在js中有三種循環(huán)語(yǔ)句. 首先是while循環(huán). 它的邏輯和python中的while幾乎一模一樣, 就是符號(hào)上有些許的區(qū)別.

// 語(yǔ)法
while(條件){
    循環(huán)體 ->  里面可以有break和continue等關(guān)鍵字
}


/*
    判斷`條件`是否為真, 如果`真`, 則執(zhí)行`循環(huán)體`.執(zhí)行完`循環(huán)體`, 會(huì)再次判斷`條件`....
    并且在循環(huán)中也可以使用`break`和`continue`等關(guān)鍵字來控制循環(huán)的走向. 
*/

// 語(yǔ)法
do{
    循環(huán)體
} while(條件);

/*
    解讀:
        先執(zhí)行`循環(huán)體`, 然后判斷`條件`是否成立, 如果成立.在來一次. 
    注意, 由于do..while是先執(zhí)行的`循環(huán)體`. 所以, 不論條件如何, 至少執(zhí)行一次`循環(huán)體`
*/

例子

let a=10;
do{
    console.log(a);
    a++;
} while (a<=10)

// 語(yǔ)法: for的第一種語(yǔ)法
for(表達(dá)式1; 表達(dá)式2; 表達(dá)式3){
    循環(huán)體
}
表達(dá)式1
while 表達(dá)式2:
    循環(huán)體
    表達(dá)式3

/*
    解讀: 
        for循環(huán)和我們python中的循環(huán)是完全不一樣的. 解讀起來會(huì)有點(diǎn)兒麻煩. 
        首先, 在執(zhí)行的時(shí)候, 先執(zhí)行`表達(dá)式1`, 
        然后, 判斷`表達(dá)式2`得到的結(jié)果是否真, 如果`真`, 則執(zhí)行循環(huán)體, 
        再然后, 執(zhí)行`表達(dá)式3`, 
        再然后, 判斷`表達(dá)式2`執(zhí)行的結(jié)果是否為`真`, 如果`真`, 則執(zhí)行`循環(huán)體`
        再然后, 執(zhí)行`表達(dá)式3`
        .....
        直到, `表達(dá)式2`得到的結(jié)果是`假`, 則跳出循環(huán)
*/
// 看起來很繞. 我們用for循環(huán)來跑一個(gè)1~99
for(var i = 1; i < 100; i++){
    console.log(i);
}
/*
    首先, i = 1, 
    然后, 判斷 i < 100 成立
        打印i
    在然后, i++, i變成2
    再然后, 判斷 i < 100 還是成立
        打印i
    再然后, i++, i變成3
    再然后, 判斷 i< 100 還是成立
        打印3....
    ....
    當(dāng)i = 100了. i < 100不成立. 程序結(jié)束 
*/

// for循環(huán)的固定邏輯也就這樣了
for(變量聲明; 條件判斷; 改變變量){
    循環(huán)體
}

// for的第二種用法
var a = [11,22,33,44,55,66]
for(let i in a){
    console.log(i + "_" + a[i])
}
// 這種寫法非常類似python中的for循環(huán). 但是要注意. 這里的`i`拿到的僅僅是 `數(shù)組a`的索引信息. 
// 如果需要數(shù)據(jù) a[i]

四.JS中的數(shù)組和對(duì)象(重點(diǎn))

在JS中創(chuàng)建數(shù)組. 直接[ ]即可. 也可以用new Array(). 效果都是一樣的.
在JS中 new 出來的東西沿猜，數(shù)據(jù)類型都是object枚荣；在JS中 創(chuàng)建空對(duì)象的時(shí)候，可以不寫()

// 定義數(shù)字的兩個(gè)方法

let a1=['劉德華', '張學(xué)友', '黎明', '郭富城'];

console.log(a1, typeof a1);     // [ '劉德華', '張學(xué)友', '黎明', '郭富城' ] object

// 在JS中 new 出來的東西啼肩，數(shù)據(jù)類型都是object
let a2=new Array('劉德華', '張學(xué)友', '黎明', '郭富城');
console.log(a2, typeof a2);     // [ '劉德華', '張學(xué)友', '黎明', '郭富城' ] object

// 在JS中 創(chuàng)建空對(duì)象的時(shí)候橄妆，可以不寫()
let a3=new Array;
console.log(a3, typeof a3);     //[] object

數(shù)組的常用操作

arr.push(data); // 在數(shù)組后面添加數(shù)據(jù)

// 在JS中 創(chuàng)建空對(duì)象的時(shí)候，可以不寫()
let a3=new Array;
console.log(a3, typeof a3);     //[] object

a3.push('下雨天')
a3.push('無(wú)名火', '666')
console.log(a3 );    //[ '下雨天', '無(wú)名火', '666' ]

arr.length; // 數(shù)組長(zhǎng)度

let res=a3.length
console.log(res)

arr.pop(); // 刪除數(shù)據(jù), 從后面刪除, 并返回被刪除的內(nèi)容

let a3=[ '下雨天', '無(wú)名火', '666' ]
let del = a3.pop()
console.log(del)    //666
console.log(a3)    // [ '下雨天', '無(wú)名火' ]

arr.shift() // 刪除數(shù)據(jù), 從前面刪除, 并返回被刪除的內(nèi)容

let a=[ '下雨天', '無(wú)名火', '666' ]
let del = a.shift()
console.log(del)    // 下雨天
console.log(a)    // [ '無(wú)名火', '666' ]

arr.unshift(xxx); // 在數(shù)組之前增加數(shù)據(jù)

let b=[ '下雨天', '無(wú)名火', '666' ]
let add = b.unshift('劉德華', '張學(xué)友')     // 返回的是數(shù)組的長(zhǎng)度祈坠；也可以不用變量接收
console.log(add)    // 5害碾，返回的是數(shù)組的長(zhǎng)度
console.log(b)    // [ '劉德華', '張學(xué)友', '下雨天', '無(wú)名火', '666' ]

arr.flat(); // 扁平化處理數(shù)組

let arr=[1, 2, 3, [4, 5, 6]]
arr = arr.flat()
console.log(arr)

arr.slice(開始索引,結(jié)束索引)；切片功能赦拘，取左不取右慌随；和python一樣

let arr=[0, 1, 2, 3, 4, 5, 6]
let res = arr.slice(1,3)
console.log(res)

arr.join("連接符"); // 使用連接符將arr中的每一項(xiàng)拼接起來. 和python中的 "".join()雷同

let name=['劉德華', '張學(xué)友', '黎明', '郭富城'];
let res = name.join('-')
console.log(res);    // 劉德華-張學(xué)友-黎明-郭富城

arr.forEach中的每一項(xiàng)循環(huán)出來. 分別去調(diào)用function函數(shù), 會(huì)自動(dòng)的將數(shù)據(jù)傳遞給函數(shù)的第一個(gè)參數(shù)，第二個(gè)參數(shù)是數(shù)組的索引躺同，第三個(gè)參數(shù)就是數(shù)組本身arr

let arr=[11, 22, 33, 44, 55, 66]
arr.forEach(function fn(a,b,c){
    console.log(a, b, c, a+b);
})

在JS中創(chuàng)建一個(gè)字典（也屬于對(duì)象阁猜，object類）非常容易. 和python中的字典幾乎一樣，JS中的字典的key可以加引號(hào)蹋艺，也可以不加剃袍。

var p = {
    name: "劉德華",
    age: 18,
    wife: "朱麗倩",
    
    sin: function(){
        console.log("唱歌")
    }
};

重點(diǎn)：
把對(duì)象變成json字符串: JSON.stringify()
把字符串變成對(duì)象: JSON.parse()

let p = {
    name: "劉德華",
    age: 18,
    wife: "朱麗倩",

    sin: function(){
        console.log("唱歌")
    }
};

console.log(typeof p, p)
// 把字典對(duì)象轉(zhuǎn)換成json字符串
let json_str=JSON.stringify(p)
console.log(typeof json_str, json_str)  // string {"name":"劉德華","age":18,"wife":"朱麗倩"}

// 把json字符串轉(zhuǎn)換成字典對(duì)象
let dic = JSON.parse(json_str)
console.log(typeof dic)     // object

（重點(diǎn)）使用對(duì)象（數(shù)組、字典）的兩種方法：
方法1：對(duì)象.key
方法2：對(duì)象['key']

console.log(p.name, p['age'])
p.sin()

從上述內(nèi)容中幾乎可以看到. JS對(duì)象的使用幾乎是沒有門檻的. 十分靈活

for(var n in p){
    if(typeof(p[n]) != 'function'){
        console.log(p[n])
    }
}

五. JS中的函數(shù)(重點(diǎn))

// 函數(shù):標(biāo)準(zhǔn)函數(shù)捎谨，有函數(shù)名民效，有參數(shù)
function fn(a,b){
    return a+b;
}

let res1 = fn(3, 4)
console.log(res1)

// 函數(shù)名可以是特殊符號(hào)憔维，如 $、_
function $(){
    console.log('函數(shù)名稱是$')
}
// 調(diào)用函數(shù)
$()

function _(){
    console.log('函數(shù)名稱是_')
}
// 調(diào)用函數(shù)
_()

// 賦值畏邢，內(nèi)存地址復(fù)制业扒，函數(shù)運(yùn)行的時(shí)候不是依賴函數(shù)的名字，而是函數(shù)的地址
sdgjksfldfgkjdsfh = _
sdgjksfldfgkjdsfh()

擴(kuò)展一下
數(shù)組的元素是函數(shù)

let arr=[function (){
    console.log(123)}, function (){console.log(456)}, function (){console.log(789)}]

arr[0]()

// for循環(huán)運(yùn)行函數(shù)
for (let i=0;i<arr.length;i++){
    arr[i]()
}

JS中的函數(shù)可以沒有函數(shù)名棵红，也可以自運(yùn)行.
注意：JS中只要能夠形成 xxx() 并且xxx是一個(gè)函數(shù)的話就可以執(zhí)行凶赁。

自運(yùn)行函數(shù)
(function gn(){
    console.log('我要自己運(yùn)行');
})();

(function (){
    console.log('我是一個(gè)函數(shù)咧栗，我沒有函數(shù)名逆甜，我自己運(yùn)行')})()

帶參數(shù)

// 帶參數(shù)
(function (a, b){
    let sum=a+b;
    console.log('我是一個(gè)函數(shù)，我沒有函數(shù)名致板，我自己運(yùn)行 結(jié)果是：', sum)})(3, 4)

自運(yùn)行函數(shù)帶返回值交煞，需要用變量接收

// 帶返回值的自運(yùn)行函數(shù)
let new_arg = (function (a, b){
    let sum=a+b;
    return sum
    })(3, 4)

console.log(new_arg)

自運(yùn)行函數(shù)使用window中參數(shù)值的兩種方法
window是HTML中的頂級(jí)作用域，作用于全局斟或，是所有作用域的根素征。window中的方法可以直接使用，也就是可以直接省略window萝挤。如

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>        // 方法1：
        (function () {
    window.name = '劉德華';
})();console.log(name);
        // 方法2：
        (function (a) {
    a.age = 18;
})(window)

console.log(window.age)
</script>
</head>
<body>

</body>
</html>

注意：JS文件的時(shí)候御毅，不可以直接使用window，因?yàn)閣indow只是HTML中的頂級(jí)作用域怜珍，直接運(yùn)行下面JS代碼會(huì)報(bào)錯(cuò)端蛆，提示 window 沒有定義。所以酥泛，在逆向扣代碼的時(shí)候今豆，要注意

(function () {
    window.name = '劉德華';
})()
console.log(name)

this的用法
字典對(duì)象可以使用this來調(diào)用對(duì)象本身的參數(shù)

let dic={
    name:'劉德華',
    age: 18,
    song: function (){
        console.log(this.name+'唱了一手歌')},
    today: function (){
        console.log('今天');
        this.song();
    }
}

JS中return多個(gè)值時(shí)，前面的表達(dá)式也會(huì)執(zhí)行柔袁，但只返回最后一個(gè)

function fn(){
    let a=2;
    let b=3;
    return a++, a*b, a+b
}

console.log(fn())

執(zhí)行順序的時(shí)候呆躲，先執(zhí)行a++，再執(zhí)行a*b捶索，最后執(zhí)行并返回a+b的值