此筆記是我在拉勾學(xué)習(xí)課程過程中的總結(jié)沐兰，文字原創(chuàng)哆档，筆記里很多技巧和知識是老師總結(jié)的，如果有侵權(quán)瓜浸，請聯(lián)系本人插佛！

一雇寇、數(shù)組

1谢床、定義

一組有序的數(shù)據(jù)集合出革，可以存放多個數(shù)據(jù)骂束，不限制數(shù)據(jù)類型展箱，并且數(shù)組長度可以動態(tài)調(diào)整攀隔。
創(chuàng)建數(shù)組最簡單的方式就是數(shù)組字面量方式
數(shù)組的字面量：[]
一般將數(shù)組字面量賦值給一個變量，方便后期對數(shù)組操作如果存放多個數(shù)據(jù)明刷，每個數(shù)據(jù)用逗號隔開辈末。

2挤聘、獲取數(shù)據(jù)元素

數(shù)組可以通過index獲取對應(yīng)的數(shù)據(jù)组去，進(jìn)行下一步操作
Index：從0開始，按照整數(shù)排序往后順序排列
可以通過index獲取某一項之后广料，使用或者更改數(shù)組項的值
調(diào)用數(shù)組：利用數(shù)組變量名后面直接加[index]方式
注意：
如果索引值超過最大項艾杏，相當(dāng)于這一項沒有賦值购桑，返回undefined
更改數(shù)據(jù)：arr[index]調(diào)用這項數(shù)據(jù)勃蜘，后面等號賦值更改數(shù)據(jù)

3缭贡、獲取數(shù)組長度

數(shù)組有個length屬性，記錄數(shù)組總長度
變量名.length
數(shù)組長度與數(shù)組最后一項的下標(biāo)存在關(guān)系眶俩，最后一項的下標(biāo)等于數(shù)組length-1

數(shù)組長度可以發(fā)生改變纲岭，不是固定的。
增加數(shù)組長度：直接給length附一個值柒莉，大于原來長度
或者兢孝，給一個大于最大下標(biāo)的項直接賦值，可以強(qiáng)制拉長
縮短：強(qiáng)制給一個length賦值橘沥，后面數(shù)據(jù)會被直接刪除痢艺，刪除不可逆堤舒。

 <script>
        // 創(chuàng)建包含多個數(shù)據(jù)的數(shù)組舌缤，數(shù)據(jù)類型不限制
        var arr2 = [1,true,false,undefined,null,[7,7],"haha"];
        // console.log(arr2);

        // 獲取元素的方法
        console.log(arr2[0]);
        console.log(arr2[1]);
        console.log(arr2[2]);
        //更改元素方法
        arr2[2] = 5;
        console.log(arr2);
       // 獲取最后一項數(shù)據(jù)
        console.log(arr2[arr2.length-1]);


    </script>

4国撵、數(shù)組遍歷

根據(jù)下標(biāo)在0到arr.length-1之間，進(jìn)行for循環(huán)遍歷

// 定義一個數(shù)組
        var arr = [1,2,3,4,5,6,77,885,33,22,55,55];
        // 遍歷數(shù)組
        for (var i = 0; i <= arr.length-1 ; i++) {
            console.log(arr[i]);
        }

        // 為每個數(shù)據(jù)加5
        for (var i = 0; i < arr.length ; i++) {
            arr[i] += 5;
        }
        console.log(arr);

二耻瑟、函數(shù)基礎(chǔ)

1、函數(shù)概念

也叫作功能裸扶、方法呵晨，函數(shù)可以將一段代碼一起封裝起來摸屠，被封裝起來的函數(shù)具備某一項特殊的功能季二。
特點(diǎn)就是內(nèi)部封裝的一段代碼作為一個完整的結(jié)構(gòu)體刻蚯，要執(zhí)行就都執(zhí)行炊汹，要不執(zhí)行就都不執(zhí)行讨便。

2霸褒、函數(shù)聲明

函數(shù)必須先定義后使用傲霸，函數(shù)聲明的時候，函數(shù)體不執(zhí)行梳凛，只有當(dāng)函數(shù)調(diào)用的時候才執(zhí)行韧拒。
特點(diǎn)： 函數(shù)聲明的時候叛溢，函數(shù)體并不會執(zhí)行楷掉，只有當(dāng)函數(shù)被調(diào)用的時候才會執(zhí)行烹植。

命名規(guī)則：

函數(shù)名的命名規(guī)則：
  1巷屿、可以使用字母嘱巾、數(shù)字浓冒、下劃線稳懒、$ 场梆，數(shù)字不能作為開頭
  2或油、區(qū)分大小寫顶岸，不能使用關(guān)鍵字和保留字
// 函數(shù)聲明
        function fun() {
            console.log(1);
            console.log(2);
            console.log(3);
            console.log(4);
        }

3、函數(shù)調(diào)用

調(diào)用方法：函數(shù)名()卷谈；
函數(shù)調(diào)用時會將函數(shù)內(nèi)部封裝的所有代碼立即執(zhí)行
函數(shù)內(nèi)部語句執(zhí)行的位置世蔗，與函數(shù)定義位置無關(guān)污淋，與函數(shù)調(diào)用位置有關(guān)寸爆。
函數(shù)可以一次調(diào)用，多次執(zhí)行歌憨。

// 函數(shù)調(diào)用
        function fun() {
            console.log(1);
            console.log(2);
            console.log(3);
            console.log(4);
        }
fun();

4务嫡、函數(shù)的參數(shù)

一個函數(shù)可以設(shè)置0個或者多個參數(shù)，參數(shù)之間逗號分隔挫剑。
函數(shù)的參數(shù)根據(jù)書寫位置不同愉棱，名稱也不同：
? 形式參數(shù)：本質(zhì)是變量奔滑，可以接收實際參數(shù)傳遞過來的數(shù)據(jù)朋其。
? 實際參數(shù)：本質(zhì)就是傳遞的各種類型的數(shù)據(jù)梅猿，傳遞給每個形參。

   // 定義一個而求和函數(shù)簇爆，傳入兩個數(shù)據(jù)
        function sum(a,b) {
            console.log(a + b);
        }
        // 調(diào)用函數(shù)中响蓉，給小括號內(nèi)部添加數(shù)據(jù)
        sum(3,4);
        sum(4,5);

5枫甲、函數(shù)的返回值

函數(shù)能夠通過參數(shù)接收數(shù)據(jù)粱栖，也能夠?qū)⒑瘮?shù)執(zhí)行結(jié)果返回一個值闹究。
利用函數(shù)內(nèi)部的一個 return 的關(guān)鍵字設(shè)置函數(shù)的返回值渣淤。
作用1：函數(shù)內(nèi)部結(jié)構(gòu)體執(zhí)行到return价认，會立即停止后面代碼的執(zhí)行。
作用2：可以在return后加空格椒功，后面任意定義一個數(shù)據(jù)字面量或表達(dá)式丁屎，函數(shù)執(zhí)行完自身功能之后晨川，整體被return矮化成為表達(dá)式共虑，表達(dá)式必須求出一個值繼續(xù)可以參與程序妈拌，表達(dá)式的值就是return后的數(shù)據(jù)。
作用3：如果有返回值培愁，執(zhí)行結(jié)果可以當(dāng)成普通數(shù)據(jù)參與程序
作用4：如果有返回值定续，可以作為普通數(shù)據(jù)賦值給一個變量私股，或賦值給其他函數(shù)的實際參數(shù)倡鲸。
注意：如果函數(shù)沒設(shè)置return語句，默認(rèn)返回undefined宁炫，如果有return語句氮凝，但是return沒有值罩阵，返回值也是undefined稿壁。

6匪燕、函數(shù)表達(dá)式

將函數(shù)的定義喧笔、匿名函數(shù)值給一個變量
函數(shù)定義賦值給一個變量尼变，相當(dāng)于函數(shù)整體矮化成了一個表達(dá)式嫌术。
調(diào)用函數(shù)表達(dá)式蛉威，方法是給變量名加()執(zhí)行蚯嫌，不能使用函數(shù)名加()執(zhí)行择示。

       // 定義一個函數(shù)表達(dá)式
        var foo = function name() {
            console.log(1);
        };
        var foo2 = function () {
            console.log(2);
        };
        // 調(diào)用函數(shù)時汪诉，只能用變量名調(diào)用扒寄，如果函數(shù)名不成功
        foo();
        foo2();

7该编、函數(shù)數(shù)據(jù)類型

函數(shù)是一種單獨(dú)的數(shù)據(jù)類型: function
由于函數(shù)是一種數(shù)據(jù)類型课竣∮谡粒可以參與其他程序。
例如奢米，可以把函數(shù)作為另一個函數(shù)的參數(shù)鬓长，被另一個函數(shù)調(diào)用涉波。
或者可以把函數(shù)作為返回值從函數(shù)內(nèi)部返回啤覆。

// 函數(shù)作為一種數(shù)據(jù)類型窗声，可以當(dāng)做其他函數(shù)的參數(shù)
        setInterval(function () {
            console.log(1);
        },1000);
        // 把函數(shù)當(dāng)成另一個函數(shù)的返回值
        function fun (b) {
            var a = 10;
            return function () {
                alert(a + b);
            };
        }

8拦耐、arguments 對象

JavaScript中见剩，arguments 對象是比較特別的一個對象固翰，實際上是當(dāng)前函數(shù)的一個內(nèi)置屬性骂际。
也就是說所有函數(shù)都內(nèi)置了一個 arguments 對象方援，arguments 對象中存儲了傳遞的所有的實參送火。
arguments 是一個偽數(shù)組弃衍，因此及可以進(jìn)行遍歷镜盯。
函數(shù)的實參個數(shù)和形參個數(shù)可以不一致速缆，所有的實參都會存儲在函數(shù)內(nèi)部的 arguments 類數(shù)組對象中。

案例
定義一個求和函數(shù)破停，如果傳入 1 個參數(shù)真慢，返回它自己黑界，如果傳入兩個參數(shù)宠蚂，返回他們的和求厕，如果傳入三個參數(shù)呀癣，先比較前兩個的大小项栏，大的與第三個參數(shù)求和返回沼沈，如果傳入 4 個及以上，輸出錯誤提示页衙。

function sum(a,b,c ) {
            // 條件分支語句，根據(jù)實參個數(shù)不同走不通分支
            switch (arguments.length) {
                case 1:
                      return a;
                      break;
                case 2:
                      return a + b;
                case 3:
                      return a > b ? a + c : b + c;
                default:
                // 模擬控制臺眨八，拋出異常
                throw new Error("參數(shù)個數(shù)不能超過3個");

            }
        }
        // 調(diào)用函數(shù)
        console.log(sum(1));
        console.log(sum(2,3));
        console.log(sum(2,3,2));

9、函數(shù)遞歸

函數(shù)內(nèi)部可以通過函數(shù)名調(diào)用函數(shù)自身
遞歸次數(shù)太多容易出現(xiàn)錯誤伏穆，超出計算機(jī)的最大計算能力。
1000項以上吧烟瞧，我覺得還是不要再用遞歸了
案例
例如菲波那切數(shù)列中的一項诗鸭。

        // 函數(shù)如果傳入的參數(shù)是1，返回1参滴，如果傳入的是1以上的數(shù)字强岸，讓他返回參數(shù) + 函數(shù)調(diào)用上一項
        function fun(a) {
            if (a == 1) {
                return 1;
            }else {
                return a + fun(a - 1);
    
            }
        }
        // 調(diào)用函數(shù)、
        console.log(fun(1));
        console.log(fun(2));
        console.log(fun(3));

10砾赔、作用域

變量可以起作用的范圍
如果變量定義在函數(shù)內(nèi)部蝌箍，只能在函數(shù)內(nèi)部被訪問到，函數(shù)外部不能使用這個變量暴心，函數(shù)就是變量定義的作用域。
任意{}中的結(jié)構(gòu)屬于一個塊，在這之中定義的所有變量在代碼塊外都是不可見的，我們稱之為 塊級作用域
在es5之前沒有 塊級作用域的概念促脉，只有函數(shù)作用域旁仿，現(xiàn)階段可以認(rèn)為JavaScript沒有 塊級作用域尘奏。

 // 定義函數(shù)
        function name() {
            var i = 1;
            console.log(i);
        }
        name();
        function name2 () {
            console.log(i);
        }
        name2();//報錯

全局變量和局部變量

局部變量：定義在函數(shù)內(nèi)部的變量酒甸，只能在函數(shù)作用域內(nèi)部被訪問到饮六，在外面沒有定義的窟扑。
全局變量：從廣義上來說殖属，也是一種局部變量挠唆，定義在全局的變量，作用域范圍是全局患膛，在整個 js 程序任意位置都能夠被訪問到亡哄。
變量退出作用域之后會銷毀截型，全局變量關(guān)閉網(wǎng)頁或瀏覽器才會銷毀

函數(shù)參數(shù)也是局部變量
函數(shù)參數(shù)本質(zhì)是一個變量，也有自己的作用域，函數(shù)的參數(shù)也屬于函數(shù)自己內(nèi)部的局部變量，也只能在內(nèi)部使用余黎，外部沒有定義垮衷。

        // // 函數(shù)的參數(shù)也是局部變量
        //     function fun(a) {
        //         a = 2;
        //         console.log(a);
        //     }
        //     fun(1);
        //     console.log(a);

函數(shù)定義在另一個函數(shù)內(nèi)部甸昏，如果外部函數(shù)沒執(zhí)行修械，相當(dāng)于內(nèi)部沒寫东羹。

 // 函數(shù)也有自己的作用域
            function outer() {
                var a = 1;
                function inner () {
                    console.log(2);
                }
                // 函數(shù)內(nèi)部調(diào)用子函數(shù)才能成功
                inner();
            }
            // 調(diào)用函數(shù)
            outer();

作用域鏈

查找變量的時候堪滨，都是從內(nèi)往外查找
案例

作用域鏈.png

案例2

image.png

var a = 1; // 0級
function outer(){
  var a = 2; // 1級
  function inner(){
    var a = 3; // 2級
    // 先查找自身作用域有沒有a,沒有就查找外層是否有啊a,沒有就查找全局變量中是否有a,沒有就報錯 --- 作用域鏈
    console.log(a); 
  }
}

在定義變量的必須寫var關(guān)鍵字，否則會定義在全局韭赘，造成全局變量污染問題

        // var a = 1;
        function name() {
            var a = 2;
            console.log(a);
        }
        name();
        console.log(a);

11鞭达、預(yù)解析和聲明提升

過程：
1幔荒、 把變量的聲明提升到當(dāng)前作用域最前面积糯，只會提升聲明唠椭，不會提升賦值亮靴。
2、 把函數(shù)的聲明提升到當(dāng)前作用域最前面雏婶，只會提升聲明，不會提升調(diào)用
3侨嘀、 先提升var抛计，在提升function蛾默。
JavaScript的執(zhí)行過程：在預(yù)解析之后，根據(jù)新的代碼順序耘婚，從上往下按照既定規(guī)律執(zhí)行js代碼挠进。

        // // 預(yù)解析局蚀，吧變量聲明部分提升到作用域最頂部
        // var a;//a中存了一個underfined
        // console.log(a);
        // // 后定義變量
        // // var a = 1;
        // a = 1;
        console.log(foo);
        foo();//underfined
        // 函數(shù)表達(dá)式提升，進(jìn)行的是變量聲明提升
        var foo = function () {
            console.log(3);
        }

變量聲明提升
所有定義的變量，都會將聲明的過程提升到所在作用域的最上面驰徊，在將來的代碼執(zhí)行過程中，按先后順序先執(zhí)行被提升的聲明變量。
提升時滩愁，只提升聲明過程，而不進(jìn)行賦值屑宠，相當(dāng)于變量定義未賦值，變量內(nèi)存儲underfined值假瞬。
因此说榆，在前面調(diào)用后定義的變量，不會報錯桃漾，會underfined值

        // 預(yù)解析坏匪，吧變量聲明部分提升到作用域最頂部
        console.log(a);
        // 后定義變量
        var a = 1;
//預(yù)解析過程
var a;//a中存了一個underfined
        console.log(a);
        // 后定義變量
        // var a = 1;
        a = 1;

函數(shù)聲明提升

函數(shù)定義過程已經(jīng)在最開始就會執(zhí)行，一旦函數(shù)定義成功撬统，后續(xù)就可以直接調(diào)用剥槐。

預(yù)解析過程中，先提升 var 變量聲明宪摧，再提升 function 函數(shù)聲明粒竖。

如果變量名與函數(shù)同名颅崩，后提升的函數(shù)名標(biāo)識符會覆蓋先提升的變量名，因此蕊苗，后續(xù)代碼調(diào)用標(biāo)識符時沿后，內(nèi)部是函數(shù)定義過程，而不是underfined朽砰。
建議：不要書寫相同的標(biāo)識符給變量名或函數(shù)名尖滚，避免出現(xiàn)覆蓋。

函數(shù)表達(dá)式
進(jìn)行的是變量聲明提升瞧柔。提升后變量內(nèi)部存一個underfined漆弄，在前面進(jìn)行函數(shù)方法調(diào)用，會報錯造锅。
建議：定義函數(shù)時撼唾，最好使用function關(guān)鍵字方式，這樣函數(shù)聲明提升可以永遠(yuǎn)生效哥蔚。

12倒谷、IIFE自調(diào)用函數(shù)

函數(shù)矮化成了一個表達(dá)式，后面加()運(yùn)算符就可以立即執(zhí)行
調(diào)用方式：函數(shù)名或者函數(shù)表達(dá)式的變量名后加（）運(yùn)算符

 // 關(guān)鍵字定義的方式糙箍，不能立即執(zhí)行
        // function name() {
        //     console.log(2);
        // }();

        // 函數(shù)表達(dá)式方式
        var foo = function () {
            console.log(2);
        }();

函數(shù)矮化成表達(dá)式渤愁，就可以實現(xiàn)自調(diào)用

數(shù)學(xué)運(yùn)算符： + -（）
邏輯運(yùn)算符： ！非運(yùn)算
IIFE結(jié)構(gòu)可以關(guān)住函數(shù)的作用域深夯，結(jié)構(gòu)外面不能調(diào)用函數(shù)信殊。
IIFE最常用的就是（）運(yùn)算符辆飘，而且函數(shù)可以不寫函數(shù)名牢屋，使用匿名函數(shù)烫葬。

// 通過函數(shù)前面添加操作符，可以將函數(shù)矮化成表達(dá)式

        + function name() {
            console.log(2);
        }();
        - function name() {
            console.log(2);
        }();
        (function name() {
            console.log(2);
        })();
        // * function name() {
        //     console.log(2);
        // }();不成功
        // iife關(guān)住了函數(shù)的作用域捡需，無法在外面調(diào)用

三办桨、對象

1、對象可以自定義名稱存儲一系列的問題

JavaScript的對象是無序?qū)傩缘募稀?br> 其屬性可以包含基本值站辉、對象或函數(shù)呢撞。對象就是一組沒有順序的值。我們可以吧JavaScript中的對象想象成鍵值對饰剥，其中值可以使數(shù)據(jù)和函數(shù)

對象行為特征：
特征：用屬性表示
行為：用方法表示

2殊霞、對象字面量

創(chuàng)建一個對象最簡單的方式就是使用對象字面量賦值給變量，類似數(shù)組

語法：{}
每條數(shù)據(jù)都有屬性名和屬性值構(gòu)成汰蓉，鍵值對：k:v
K是屬性名
V是屬性值绷蹲，可以存放任意類型數(shù)據(jù)，比如簡單類型數(shù)據(jù)、函數(shù)祝钢、對象比规。

3、創(chuàng)建對象

new Object()創(chuàng)建對象
Object()構(gòu)造函數(shù)是一種特殊函數(shù)拦英，主要用來創(chuàng)建對象時初始化對象蜒什，即為對象成員變量賦初始值。
1疤估、 構(gòu)造函數(shù)用于創(chuàng)建一類對象灾常，首字母大寫
2、 構(gòu)造函數(shù)和new一起使用才有意義铃拇。

// new Object()方法創(chuàng)建
            var person1 = new Object();
            // 添加屬性和方法
                person1.name = "zs";
            person1.age = "19";
            person1.sex = true;
            person1.sayhi = function () {
                console.log("hello");
            };
            console.log(person1);

New的執(zhí)行做的四件事情

1钞瀑、 new會在內(nèi)存先創(chuàng)建一個空對象
2、 new會讓this指向這個新的對象
3慷荔、 執(zhí)行構(gòu)造函數(shù) 目的是給這個對象增加屬性和方法
4雕什、 New會返回這個新的對象（執(zhí)行完構(gòu)造函數(shù)，返回這個對象賦值給變量）
工廠函數(shù)方法創(chuàng)建對象
如果創(chuàng)建多個類似對象拧廊，可以將new object()過程封裝到函數(shù)里监徘，將來調(diào)用函數(shù)就可以創(chuàng)建對象晋修，相當(dāng)于一個生產(chǎn)對象的函數(shù)工廠吧碾，簡化代碼。

// 工廠方法就是相當(dāng)于對new object方法的一個封裝
        function createPerson (name , age , sex) {
            // 創(chuàng)建一個空對象
            var person = new Object();
            // 給對象內(nèi)部添加屬性和方法
            person.name = name;
            person.age = age;
            person.sex = sex;
            person.sayhi = function () {
                console.log("hello");
            }
            // 返回這個對象
            return person;
        }
        // 調(diào)用工廠函數(shù)創(chuàng)建對象
        var p1 = createPerson("zhangs" , 18 , true);
        var p2 = createPerson("lisi" , 356 , false);
        // 輸出
        console.log(p1);
        console.log(p2);

自定義構(gòu)造函數(shù)創(chuàng)建對象
自定義一個創(chuàng)建具體對象的構(gòu)造函數(shù)墓卦，函數(shù)不需要new一個構(gòu)造函數(shù)的過程倦春，直接使用this代替對象進(jìn)行屬性和方法的書寫，也不需要return一個返回值落剪。
使用時睁本，利用new關(guān)鍵字調(diào)用自定義的構(gòu)造函數(shù)即可。
注意：構(gòu)造函數(shù)的函數(shù)名首字母需要大寫忠怖，區(qū)別于其他普通函數(shù)名呢堰。

 //自定義一個構(gòu)造函數(shù)
        function Person (name,age,sex) {
            // 不需要new一個新對象
            // 用this替代將來創(chuàng)建的新對象
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.sayhi = function () {
                console.log("hei");
            };
        // 不需要return
        }
        // 用new關(guān)鍵字調(diào)用構(gòu)造函數(shù)
        var p1 = new Person ('ls',18,true);
        console.log(p1);

4、遍歷對象

For in循環(huán)也是循環(huán)的一種凡泣，專門用來遍歷對象.
簡單的循環(huán)遍歷：輸出每一項屬性名和屬性值枉疼。
循環(huán)遍歷每一項

for(var k in obj){
    console.log(k+"項的屬性值是"+obj[k]);
}

5、簡單類型和復(fù)雜類型

值類型：簡單數(shù)據(jù)類型鞋拟，基本數(shù)據(jù)類型骂维，在存儲時，變量中存儲的是只本身贺纲，因此叫做值類型航闺。
引用類型：復(fù)雜數(shù)據(jù)類型，在存儲時，變量中存儲的僅僅是地址（引用）潦刃，因此叫做以引用數(shù)據(jù)類型侮措。

1. 棧（操作系統(tǒng)）：由操作系統(tǒng)自動分配釋放 ，存放函數(shù)的參數(shù)值乖杠，局部變量的值等萝毛。
2. 堆（操作系統(tǒng)）： 存儲復(fù)雜類型(對象)，一般由程序員分配釋放滑黔， 若程序員不釋放笆包，由垃圾回收機(jī)制回收。

5略荡、內(nèi)置對象

JavaScript 包含：ECMAscript DOM BOM
? ECMAscript 包含：變量庵佣、數(shù)據(jù)、運(yùn)算符汛兜、條件分支語句巴粪、循環(huán)語句、函數(shù)粥谬、數(shù)組肛根、對象……
JavaScript 的對象包含三種：自定義對象 內(nèi)置對象 瀏覽器對象
? ECMAscript 的對象：自定義對象 內(nèi)置對象
? 使用一個內(nèi)置對象，只需要知道對象中有哪些成員漏策，有什么功能派哲，直接使用
Math對象

// 獲取隨機(jī)數(shù) 0-1
// 參數(shù)：不需要傳遞參數(shù)
// 返回值： 0 <=  < 1
Math.random()
function getRandom(min,max){
  return Math.floor(Math.random() * ( max - min ) + min);
}

// 圓周率 3.14159
Math.PI;

//向下取整
Math.floor(123.4); // 123
// 向上取整
Math.ceil(123.2);//124
// 四舍伍入
Math.round(123.4); // 123
Math.round(123.5); // 124
// 絕對值
Math.abs(-5); // 5
// 最大值
Math.max(12,3,24); // 24
var arr = [12,3,24];
Math.max(...arr);
// 最小值
Math.min(12,3,24); // 3
// 次冪
Math.pow(3,4); // 3的4次方  81
// 平分跟
Math.sqrt(9); // 3

創(chuàng)建數(shù)組對象array

new Array（）構(gòu)造函數(shù)方法

// 數(shù)組也是對象，可以通過構(gòu)造函數(shù)生成
        // 空數(shù)組
        var arr1 = new Array();
        // 添加數(shù)據(jù)掺喻，可以傳參數(shù)
        var arr2 = new Array(1,2,3);
        // console.log(arr1);
        // console.log(arr2);
        var a = {};
        // 檢測數(shù)組的數(shù)據(jù)類型
        console.log(typeof(arr1));

        // 檢測某個實例對象是否屬于某個對象類型
        console.log(arr1 instanceof Array);
        console.log(a instanceof Array);

6芭届、數(shù)組方法

//  字面量方法創(chuàng)建數(shù)組
        var arr = [1,2,3,4];
        //toString()方法:轉(zhuǎn)字符串
        console.log(arr.toString());
//  字面量方法創(chuàng)建數(shù)組
        var arr = [1,2,3,4];
        //toString()方法:轉(zhuǎn)字符串
        // console.log(arr.toString());

        // 收尾操作方法
        // 尾推,參數(shù)是隨意的，可以有一個或多個
        // arr.push(5,4,56,4);
        // arr.push([1,3,4,5,5]);
        // console.log(arr.push(5,4,56,4));
        // console.log(arr);

        // 刪除最后一項數(shù)據(jù)
        // 不需要傳參
        // console.log(arr.pop());
        // console.log(arr);

        // 刪除第一項數(shù)據(jù)感耙，不需要傳參
        console.log(arr.shift());
        console.log(arr);

        // 首填褂乍，參數(shù)與push方法類似
        console.log(arr.unshift(1,2));
        console.log(arr);
 //  字面量方法創(chuàng)建數(shù)組
                var arr = [1,2,3,4];
                // 合并方法
                // 參數(shù)：數(shù)組、數(shù)組變量即硼、零散的值
                // 返回值：一個新的拼接后的數(shù)組
                // var arr1 = arr.concat([5,6,7]);
                // var ar = [5,6,7];
                // var  arr1 = arr.concat(ar);
                var arr1 = arr.concat(11,12,13);
                console.log(arr);
                console.log(arr1);
                //拆分
                //  字面量方法創(chuàng)建數(shù)組
                var arr = [1,2,3,4,5,6,7,8,9,10];
                
                // 拆分方法
                // 參數(shù)為證
/*Slice（start逃片，end）
從當(dāng)前數(shù)組中截取新的數(shù)組，不影響原來的數(shù)組只酥，返回一個新數(shù)組褥实，包含從start到end的元素。*/

                // var arr1 = arr.slice(3,7);
                // 參數(shù)為負(fù)數(shù)
                var arr1 = arr.slice(-3,-7);
                // 只寫一個參數(shù)
                var arr2 = arr.slice(-7,-1);
                console.log(arr1);
                console.log(arr2);
/*刪除层皱、插入性锭、替換：
Splice（index，howmany叫胖，element1草冈，element2……）
用于插入、刪除或者替換數(shù)組元素
Index：刪除元素的開始位置
Howmany：刪除元素的個數(shù)，可以是0
Elemen1怎棱，element2：要替換新的數(shù)據(jù)哩俭。
注意：使用該函數(shù)之后，原有的長度會變短拳恋，如果是循環(huán)凡资，需要用i--，來防止越過下一項
*/
  //  字面量方法創(chuàng)建數(shù)組
               var arr = [1,2,3,4,5,6,7,8,9,10];
            //    刪除功能
            console.log(arr.splice(2,5));
            console.log(arr);
            // 替換功能谬运，傳三個以上的參數(shù)
            arr.splice(2,5,"hahha","ghekke");
            console.log(arr);
            // 插入功能隙赁，傳三個以上的參數(shù)，但是第二個參數(shù)必須為0
            arr.splice(2,0,'hello');

位置方法
IndexOf() 查找數(shù)據(jù)在數(shù)組中最先出現(xiàn)的下標(biāo)
lastIndexOf() 查找數(shù)據(jù)在數(shù)組中最后一次出現(xiàn)的下標(biāo)
注意：如果沒找到返回-1

 //  字面量方法創(chuàng)建數(shù)組
               var arr = [1,2,3,4,5,6,7,8,9,5,10];
            console.log(arr.indexOf(4));
            console.log(arr.lastIndexOf(5));

倒序和排序
Reverse（）將數(shù)組完全顛倒梆暖，第一項變成最后一項伞访，最后一項變成第一項。

 // 倒序排列
            console.log(arr.reverse());

sort（）
默認(rèn)根據(jù)字符編碼順序轰驳，從小到大排序
如果想根據(jù)數(shù)值大小排序厚掷，必須添加sort的比較函數(shù)參數(shù)。
該函數(shù)比較兩個值级解，然后返回一個用于說明兩個值相對順序的數(shù)字冒黑。
比較函數(shù)應(yīng)該具有兩個參數(shù)a 和 b，根據(jù)a 和 b的關(guān)系作為判斷條件勤哗，返回值根據(jù)條件分為三個分支抡爹，正數(shù)、負(fù)數(shù)俺陋、0豁延；
返回值負(fù)數(shù)-1昙篙，a排在b前面
返回值1腊状，a排在b后面
返回值0；a和b順序保持不變

arr.sort(function (a,b){
                if (a > b) {
                    return 1;

                }else if (a < b) {
                    return -1;
                }else {
                    return 0;
                }
            });

轉(zhuǎn)字符串
轉(zhuǎn)字符串方法：將數(shù)組的所有元素連接到一個字符串中苔可。 join() 通過參數(shù)作為連字符將數(shù)組中的每一項用連字符連成一個完整的字符串

 //  字面量方法創(chuàng)建數(shù)組
                var arr = [1,2,3,4,5,6,7,8,9,5,10];
                // 轉(zhuǎn)字符串
                var str = arr.join("*");
                var str = arr.join("");
                console.log(str);

清空數(shù)組

//方式1 推薦
arr = [];
//方式2
arr.length = 0;
//方式3
arr.splice(0, arr.length);

7缴挖、字符串

字符串是不可變的。由于字符串的不可變焚辅，在大量拼接字符串的時候會有效率問題

// 定義一個字符串
        // 特點(diǎn)：字符串不可變
        // var a = "abc";
        // a = 'cde';
        // 大量拼接字符串時映屋，會有效率問題
        var sum = '';
        for (var i = 1; i <= 1000000 ;i++) {
            sum += i;
        }
        console.log(sum);

字符串方法

// 字符串是不可變的，大量字符串拼接的時候會有效率問題
var str = 'abc,def,ghd,efi,gh';

// 1.長度
str.length; // 所有字符的總數(shù) 無論是空格還不是空格

// 2. charAt() 返回指定位置的字符
// 參數(shù)是 index
str.charAt(2); // c

// 3. indexOf() 返回字符串的值的在字符串中首次出現(xiàn)的位置
// 沒有就返回-1
str.indexOf('def'); // 3

// 4. concat() 鏈接兩個或多個字符串
str.concat('klfgfg');

// 5. split 分給字符串成數(shù)組
str.split(',');

// 6. toLowerCase 轉(zhuǎn)小寫
//  toUpperCase  轉(zhuǎn)大寫
var str1 = str.toUpperCase();

// 7. slice() 截取字符串 返回新的字符串
var str1 = str.slice(3,7); // 包3不包7

// 8. substr()  從開始位置截取指定長度
// 不寫第二個參數(shù) 就是開始到結(jié)尾
var str2 = str.substr(3,7); // 從3位置 截取 長度為7的字符串

//9. substring 截取兩個下標(biāo)之間的字符
// 順序可以反同蜻， 從小的開始大的結(jié)束
// 只有一個參數(shù)截取到最后
var str3 = str.substring(4,8);

字符串所有的方法棚点，都不會改變原有字符串，二是返回一個新的字符串湾蔓。
長度屬性：str.length
字符串長度指的是一個字符串中所有的字符總數(shù)瘫析。
charAt() 方法可返回指定位置的字符。
? char：charator，字符
? at：在哪兒
? 參數(shù)是 index 字符串的下標(biāo)贬循。也是從 0 開始咸包。
? 表示返回指定的下標(biāo)位置的字符。

IndexOf（） 可以返回某個指定字符串再字符串中首次出現(xiàn)的位置杖虾。
找到指定的字符串再原有字符串中第一次的位置的下標(biāo)烂瘫。如果字符串在原字符串中沒有，返回-1.

concat() 方法用于連接兩個或多個字符串奇适。
? 參數(shù)比較靈活坟比，可以是字符串、或者字符串變量嚷往、多個字符串温算。
? 生成的是一個新的字符串，原字符串不發(fā)生變化间影。

split() 方法用于把一個字符串分割成字符串?dāng)?shù)組注竿。
? 參數(shù)部分是分割符，利用分割符將字符串分割成多個部分魂贬，多個部分作為數(shù)組的每一項組成數(shù)組巩割。
? 如果分割符是空字符串，相當(dāng)于將每個字符拆分成數(shù)組中的每一項付燥。

toLowerCase() 把字符串轉(zhuǎn)換為小寫宣谈。
toUpperCase() 把字符串轉(zhuǎn)換為大寫。
? 將所有的英文字符轉(zhuǎn)為大寫或者小寫键科。
? 生成的是新的字符串闻丑，原字符串不發(fā)生變化

slice() 方法可提取字符串的某個部分，并以新的字符串返回被提取的部分勋颖。
? 語法：slice(start嗦嗡，end)
? 從開始位置截取到結(jié)束位置（不包括結(jié)束位置）的字符串。
? 參數(shù)區(qū)分正負(fù)饭玲，正值表示下標(biāo)位置侥祭，負(fù)值表示從后面往前數(shù)第幾個位置，參數(shù)可以只傳遞一個茄厘，表示從開始位置截取到字符串結(jié)尾矮冬。

Substr() 可以在字符串中抽取start下標(biāo)開始的指定數(shù)目的字符
語法：substr（start，howmany）
從開始位置截取到指定長度的字符串次哈。
·start 參數(shù)區(qū)分正負(fù)胎署。正值表示下標(biāo)位置，負(fù)值表示從后往前數(shù)第幾個位置窑滞。
·howmany 參數(shù)必須為正數(shù)琼牧，也可以不寫径筏，不寫表示從 start 截取到最后。
注意：使用該函數(shù)之后障陶，原有的長度會變短滋恬，如果是循環(huán)，需要用i--抱究，來防止越過下一項

substring() 方法用于提取字符串中介于兩個指定下標(biāo)之間的字符恢氯。
? 語法：substring(start,end)
? 參數(shù)只能為正數(shù)。
? 兩個參數(shù)都是指代下標(biāo)鼓寺，兩個數(shù)字大小不限制勋拟，執(zhí)行方法之前會比較一下兩個參數(shù)的大小，
會用小當(dāng)做開始位置妈候，大的當(dāng)做結(jié)束位置敢靡，從開始位置截取到結(jié)束位置但是不包含結(jié)束位
置。
? 如果不寫第二個參數(shù)苦银，從開始截取到字符串結(jié)尾