JS基礎(chǔ)講解

1. JavaScript組成
   • ECMAScript：解釋器赔蒲、翻譯
   • DOM：Document Object Model
   • BOM：Browser Object Model 各組成部分的兼容性，兼容性問題由來
2. 兼容性
   • ECMAScript幾乎沒有兼容性問題 (ES6)
   • DOM 有一些兼容性問題
   • BOM 幾乎不兼容

變量詳解

1 .變量如果不進(jìn)行聲明,而直接使用一個(gè)'局部'變量,那么這個(gè)變量會(huì)變成全局的

2. 變量類型

   • 弱語言也有類型

   • typeof查看變量的類型

     typeof null === "object" //true
     typeof NaN //number
     typeof eval //function
     new Object() instanceof Array === false
     

   • 類型檢測(cè):

     • typeof適合基本類型和function檢測(cè),遇到null失效

     • Class 通過{}.toString()拿到,適合內(nèi)置對(duì)象和基本類型,遇到null和undefined失效(IE678等返回object)

     • instanceof適合自定義對(duì)象,也可以用來檢測(cè)原聲對(duì)象,在不同iframe和window間檢測(cè)失效

3. 常見類型:

   • number, string, boolean, object, null, undefined, function
   • 基本數(shù)據(jù)類型: number,string,boolean,undefined,null
   • 復(fù)合類型:對(duì)象(js里面一切皆是對(duì)象)
   • undefined:
     • 沒有定義變量
     • 定義了但是沒有存東西進(jìn)去
   • 一個(gè)變量應(yīng)該只存放一種類型的數(shù)據(jù)

4. 比較

   • 類型相同 a===b

   • 類型不同,嘗試類型轉(zhuǎn)換后比較

     null==undefined      //true
     number==string 轉(zhuǎn)化為number 1=="1.0" //true
     boolean == number 轉(zhuǎn)化為number 1==true//true
     object == string | number 嘗試對(duì)象轉(zhuǎn)為基本類型
     

5. 類型轉(zhuǎn)換

   var num = parseInt(str);  //會(huì)提取其中的數(shù)字
   //str="abc"           //NaN(not a number)
   //str = "abc 12 bc"   //NaN
   //str = "123px"       //123 從最左邊提取
   

   • 注意:

     • NaN與其他任意數(shù)值之間的比較總是不相等的
       • 比如: parseInt('abc') == NaN 返回的是false
       • 只能調(diào)用isNaN(parseInt('abc'))來進(jìn)行比較

   • parseFloat

   • Number

     var num = Number("123");
     var num = Number("123abc"); //NaN, 比Number嚴(yán)格轉(zhuǎn)換
     

   • 隱式轉(zhuǎn)換

     var a = 12, b = "12";
     alert(a==b) //返回true  但是===不會(huì)進(jìn)行轉(zhuǎn)換
     
     // 先把兩邊的東西轉(zhuǎn)成一樣的東西之后 再進(jìn)行轉(zhuǎn)換
     alert('12'-'5');  //返回值為7 string轉(zhuǎn)化為number
     alert(typeof a); //string  a的類型不變
     

6. 變量的作用域和閉包

   • 作用域: 局部變量和全局變量

   • 什么是閉包

     • 子函數(shù)可以使用父函數(shù)中的局部變量
     • 之前一直在使用閉包(閉包-封裝)
     • 網(wǎng)上對(duì)于閉包的定義(常見錯(cuò)誤-循環(huán)閉包)

   • 優(yōu)勢(shì): 靈活方便 封裝

   • 弊端: 空間浪費(fèi) 內(nèi)存泄露 性能消耗

     function outer()
     {
         var localVal = 30;
         return function()
         {
             return localVal;
         };
     }
     var func = outer();
     func(); //30  任然有能力訪問到局部變量
     
     var a = eval('({name:"fff", age:18})'); //外面一定要帶一層括號(hào)
     alert(a.name); //fff
     

   • 抽象概念:

     • 執(zhí)行上下文
     • 變量對(duì)象:是一個(gè)抽象概念中的對(duì)象,用于存儲(chǔ)執(zhí)行上下文中的
       • 1,變量 2,函數(shù)聲明 3,函數(shù)參數(shù)
     • VO按照如下順序填充(變量初始化階段):

       1. 函數(shù)參數(shù)(若為傳入,初始值該參數(shù)為undefined)

       2. 函數(shù)聲明(若發(fā)生命名沖突,會(huì)覆蓋掉)

       3. 變量聲明(初始化變量為undefined,若發(fā)生命名沖突會(huì)忽略)

          function test(a,b){
            var c = 10;
            function d(){};
            var e = function _e(){};
            (function x(){});  //此處被忽略掉
            b = 20;
          }
          test(100);
          

     1. 初始化階段 (可稱為編譯階段 時(shí)間非成翁椋快)

        AO(test) = {
            a:100,
            b:undefined,
            c:undefined,
            d:<ref to func "d">,
            e:undefined,
        }
        

     2. 代碼執(zhí)行階段

        VO['c'] = 10;
        VO['e'] = function _e(){};
        VO['b'] = 20;
        

7. 變量的使用習(xí)慣

   • 只存儲(chǔ)一種類型的值
   • 命名規(guī)范以及必要性:可讀性 規(guī)范性
   • 匈牙利命名法
     • 首字母大寫 oDivUserInfo
     • 類型前綴
       o-->object s-->string
       a-->array i-->integer
       f-->float b-->boolean
       fn-->function re-->RegExp
       v--> Variant(變體變量 不限定一個(gè)類型的變量)

8. 函數(shù)返回值

   1. 一個(gè)函數(shù)應(yīng)該只返回一種類型的參數(shù)(函數(shù)可以沒有return)

   2. 函數(shù)有return 但是沒有返回值, 實(shí)際返回一個(gè)undefined

   3. 可變參數(shù)和不定參數(shù)auguments
      auguments是一個(gè)數(shù)組--存的是所有的數(shù)組

   4. 復(fù)合樣式: background
      單一樣式(基本樣式) width, height..

   5. 函數(shù)參數(shù)和arguments是可以共存的

   6. 函數(shù)聲明與函數(shù)表達(dá)式

      function add(a,b){} //函數(shù)聲明  會(huì)前置 可以沒有聲明的時(shí)候提前調(diào)用
      
      var add = function(a,b){} //函數(shù)表達(dá)式  不能再此之前使用
      
      //命名函數(shù)表達(dá)式
      var func = function nef(){} //IE6-8不相等 IE9+ FF會(huì)報(bào)錯(cuò)
          
      //函數(shù)構(gòu)造器
      var func = new Function('a','b','console.log(a+b)');
      var func = Function('a','b','console.log(a+b)');
      func(1,2) //3
          
      //Function構(gòu)造器
      Function("var localVal ='local'; console.log(localVal);")();
      console.log(typeof localVal); //undefined 因?yàn)槭蔷植孔兞?

9. this

   • 全局的this

     this.document === document //true
     this === window //true
     
     function f1()
     {
         return this;
     }
     f1() === window //true
     
     function f2()
     {
         'use strict'
         return this;
     }
     f2() === undefined //true global object
     

   • 作為對(duì)象方法的函數(shù)this

     var o = {prop:37};
     
     function independent() {
         return this.prop;
     }
     o.f = independent;
     console.log(o.f()); //37
     

   • 構(gòu)造器中的this

     function c()
     {
         this.a = 37;
         return {a:38};
     }
     
     o= new c();
     console.log(o.a); //38 o為返回的對(duì)象 如果返回的是基本類型 那么就返回this
     

+ call/apply與this

    ```js
    function add(c,d)
    {
        return this.a+ this.b + c + d;
    }
    var o = {a:1,b:3};
    add.call(o,5,7);      //1+3+5+7;
    add.apply(o,[10,20]); //1+3+10+20

    function fooBar()
    {
        console.log(Object.prototype.toString.call(this));
    }
    bar.call(3); //[object Number]
    ```


+ bind與this (ES5)
    
    ```js
    function f()
    {
        return this.a;
    }
    var g = f.bind({a:"test"});
    console.log(g()); //test
    var o = {a:37,f:f,g:g}
    console.log(o.f(),o.g()); //37 test
    ```

9. arguments

   • 注意區(qū)分嚴(yán)格模式和非嚴(yán)格模式下 arguments的跟蹤問題

   function foo(x,y,z)
   {
       arguments.length; //2
       arguments[0]  //1
       arguments[0] = 10 ;//x changes to 10
       x// 10
   
       arguments[2]=100;    //沒有傳參數(shù)過去
       z; //still undefined 失去綁定關(guān)系
   
       arguments.callee === foo ;//true  //嚴(yán)格模式下不能使用
       typeof arguments // object 類數(shù)組 obj { 0: 'args1', 1:'args2', length:2}
   }
   

對(duì)象描述

屬性是無序的且是字符串,(key不是字符串的話先將key toString()一下)

1. 對(duì)象結(jié)構(gòu)

   • writable, enumberable, configurable, value, get/set
   • 對(duì)象有的屬性
     proto, class, extensible, 自定義屬性
   • 讀寫對(duì)象的屬性

     • 屬性異常

       • 訪問不存在屬性y, 會(huì)訪問原型鏈,再?zèng)]有找到會(huì)返回undefined

     • 刪除屬性

       delete Object.prototype //不允許刪除 返回false
       var descriptor = Object.getOwnPropertyDescriptor(Object,'prototype');
       descriptor.configurable //false  是否可配置
       
       
       var globalVal - 1; delete globalVal; //false,
       

       • 局部變量和函數(shù)也是不可以delete掉
       • 但是如果是隱式的創(chuàng)建的話 是可以被刪除掉的, 比如ohNo = 1; window.ohNo返回1, delete ohNo //true

     • 檢測(cè)屬性

       property in obj
       var cat = new Object(); cat.legs = 4; cat.name="Kitty";
       'legs' in cat//true    "toString" in cat//true, 從原型上繼承
       cat.hasOwnProperty('legs')// true
       cat.hasOwnProperty('toString') //false
       

     • 枚舉屬性

       • cat.propertyIsEnumberable('legs')//true 是否可枚舉

       • cat.propertyIsEnumberable('toString')//false

       • 自定義對(duì)象的屬性

         Object defineProperty(cat,'price',{enumerable:false ,value:1000});
         //通過defineProperty創(chuàng)建對(duì)象, 所有的屬性默認(rèn)false
         cat.propertyIsEnumerbla('price'); //false
         cat.hasOwnProperty('price')// true
         

       • 區(qū)分:

         var o = {x:1,y:2,z:3};
         var obj = Object.create(o);//以o為原型創(chuàng)建對(duì)象
         obj.a = 4;
         var key;
         for (key in obj)
         {
             console.log(key); //a,x,y,z
             if (obj.hasOwnProperty(key))
             {
                 console.log(key); //只有a打印出來, xyz是原型鏈上的屬性
             }
         }
         

2. getter/setter:

   var man = {
       name: 'Bosn',
       get age(){
           return new Date().getFullYear() - 1988;
       },
       set age(val){
           console.log("Age can\'t be set to");
       }
   }
   
   function foo() {}
   Object.defineProperty(foo.prototype,'z',{get:function(){return 1;}})
   var obj = new foo();
   obj.z;//1;
   obj.z = 10;
   obj.z; //still 1;
   //原型是現(xiàn)在自己上找屬性發(fā)現(xiàn)沒有, 就去原型上找有但是沒有set方法,不會(huì)更改
   
   修改上面的定義代碼
   Object.defineProperty(foo.prototype,'z',{value:100,configuration:true})
   obj.z; //100
   delete obj.z;
   obj.z// 1
   
   Object.defineProperty(o,'x',{value:1});//表示其不可writable和configurable
   

3. 屬性標(biāo)簽

   Object.getOwnPropertyDescriptor({pro:true},'pro');//獲取對(duì)于對(duì)象的描述
   //第一個(gè)參數(shù)表示一個(gè)對(duì)象, 第二個(gè)參數(shù)表示獲取對(duì)象某一屬性
   //Object{value:true,writable:true,enumberable:true,configurable:true}
       
   Object.getOwnPropertyDescriptor({pro:true},'a'); //undefined
   
   var person = {};
   Object.defineProperty(person,'name',{//給Person添加name屬性
       value:"Confidence",writable:false,enumberable:true,configurable:false
   });//configurable為false表明不可刪除. enumerable表示該屬性不可被遍歷到
   
   Object.keys(person);//訪問對(duì)象的屬性
   Object.defineProperties(person,{
       title:{value:'t',enumerable:false},
       head:{value:'h',enumerable:true},
     }
   );
   

4. 對(duì)象標(biāo)簽和對(duì)象序列化

   • 原型標(biāo)簽 proto

   • 類標(biāo)簽 class沒有直接的方式查看, 通過toString查看

     function getType(o)
     {
         return toString().call(o).slice(8,-1);
     }
     
     ({}).toString.call(window).slice(8, -1)  //"[object Window]" - > window
     
     toString.call(null); // Object[null]
     
     getType(null); //null
     
     getType(1); //number
     
     getType(new Number(1)); //number
     
     typeof new Number(1); //object
     

   • extensible標(biāo)簽

     obj = {x:1, y:2};
     
     Object.isExtensible(obj); //true;
     Object.preventExtensions(obj);//阻止之后即不能夠擴(kuò)展了
     
     Object.seal(obj);  //設(shè)置configurable為false
     Object.isSealed(obj); //true
     
     Object.freeze(obj); //凍結(jié), 所有屬性都是false
     Object.isFrozen(); //true
     

5. 對(duì)象的序列化

   var obj = {x:1,y:true,z:[1,2,3],"nullVal":null};
   JSON.stringify(obj);
   
   obj = {val:undefined,a:NaN,b:Infinity,c:new Date()};
   JSON.stringify(obj); //"{"a":null,"b":null,"c":"2015-01-20T14.."}";
   
   obj = JSON.parse("{'x':1}")
   

   • 序列化的自定義

     var  obj = {
         x:1,
         y:2,
         o:{
             o1:1,
             o2:2,
             toJSON:function()
             {
                 return this.o1+this.o2;
             },
         },
     };
     
     JSON.stringify(obj); //"{"x":1","y":2","o":3}"
     
     var obj = {x:1,y:2};
     obj.toString(); //[Object object]
     obj.toString = function() {
         return this.x + this.y;
     }
     "result: " + obj;  //result: 3
     +obj;// 3
     
     //嘗試把類變成基本類型的時(shí)候
     obj.valueOf = function(){
         return this.x+this.y + 100;
     }
     +obj;   //103, from valueOf
     "reuslt: "+ obj;  //result: 103
     //嘗試把對(duì)象變成基本類型, 先找valueOf再找toString
     

7. 創(chuàng)建對(duì)象

   當(dāng)我們給對(duì)象賦值的時(shí)候,先看對(duì)象上有沒有當(dāng)前屬性,如果有的話修改當(dāng)前值,
   如果沒有的話僅在當(dāng)前對(duì)象上添加屬性, 而不會(huì)修改原型鏈上的屬性值

   • obj.hasOwnProperty("z"): 判斷自身對(duì)象是是否有該屬性
     如果需要訪問原型上的z,

   • delete obj.z; obj.z; 才會(huì)獲取原型上的z

   • 通過var obj = Object.createa({x:1});
     var obj = Object.create(null); alert(obj.toString) 為undefined

字符串詳解

1. str.length; 字符串的長(zhǎng)度 (中文和英文是不區(qū)分的)

   '這個(gè)字符串'.length //5 
   var s1 = "anc";  //string
   var s2 = new String('abc')  //object
   

2. 獲取類

   • charAt——指定字符

     var ch = str.charAt(index);  (str[0]也可以 但I(xiàn)E6兼容性)
     var ascCode = str.charCodeAt(index);  //獲取ASCII碼
     var ch = String.fromCharCode(25105);  //編碼轉(zhuǎn)文字
     

   • charCodeAt——指定字符的編碼

   • fromCharCode——編碼轉(zhuǎn)換成字符

3. 查找類

   • indexOf、lastIndexOf、search——查找

     • indexOf 獲取索引 找不到即為-1
     • lastIndexOf 最后一個(gè)位置的索引
     • search 查找

   • indexOf和search的區(qū)別

     • search匹配正則表達(dá)式

     var str = "abcd?efgh";
     alert(str.search('?'))// 會(huì)報(bào)錯(cuò) 因?yàn)?在正則表示數(shù)量詞
     

   • match脚仔、replace——匹配和替換 擴(kuò)展正則的方法

4. 比較類

   • localeCompare——根據(jù)當(dāng)?shù)亓?xí)慣比較字符串
     按照拼音進(jìn)行排序

   • 排序應(yīng)用

   • 截取類 (從原字符串取出子字符串并返回，不改變?cè)址?

     • substring將負(fù)值寫成0來使用

       'JavaScript'.substring(0, 4) // "Java"
       
       'JavaScript'.substring(4) // "Script"
       
       // 如果第二個(gè)參數(shù)大于第一個(gè)參數(shù)掩浙，substring方法會(huì)自動(dòng)更換兩個(gè)參數(shù)的位置花吟。
       'JavaScript'.substring(10, 4) // "Script"
       // 等同于
       'JavaScript'.substring(4, 10) // "Script"
       
       //如果參數(shù)是負(fù)數(shù)，substring方法會(huì)自動(dòng)將負(fù)數(shù)轉(zhuǎn)為0厨姚。
       'Javascript'.substring(-3) // "JavaScript"
       'JavaScript'.substring(4, -3) // "Java"
       

     • slice 負(fù)值倒數(shù)往后看,變成倒數(shù)第幾個(gè)

       • slice方法用于從原字符串取出子字符串并返回衅澈，不改變?cè)址?/li>
       • 它的第一個(gè)參數(shù)是子字符串的開始位置，第二個(gè)參數(shù)是子字符串的結(jié)束位置（不含該位置）谬墙。

       'JavaScript'.slice(0, 4) // "Java"
       
       //如果省略第二個(gè)參數(shù)今布，則表示子字符串一直到原字符串結(jié)束。
       'JavaScript'.slice(4) // "Script"
       
       // 如果參數(shù)是負(fù)值拭抬，表示從結(jié)尾開始倒數(shù)計(jì)算的位置部默，即該負(fù)值加上字符串長(zhǎng)度。
       'JavaScript'.slice(-6) // "Script"
       'JavaScript'.slice(0, -6) // "Java"
       'JavaScript'.slice(-2, -1) // "p"
       

     • substr和substring的區(qū)別

       • substring: 不包含結(jié)束位置
       • substr: 第二個(gè)參數(shù)表示截取的長(zhǎng)度, 為負(fù)取0

     // substr方法的第一個(gè)參數(shù)是子字符串的開始位置造虎，第二個(gè)參數(shù)是子字符串的長(zhǎng)度傅蹂。
     'JavaScript'.substr(4, 6) // "Script"
     // 如果省略第二個(gè)參數(shù)，則表示子字符串一直到原字符串的結(jié)束算凿。
     'JavaScript'.substr(4) // "Script"
     
     // 如果第一個(gè)參數(shù)是負(fù)數(shù)份蝴，表示倒數(shù)計(jì)算的字符位置。
     // 如果第二個(gè)參數(shù)是負(fù)數(shù)氓轰，將被自動(dòng)轉(zhuǎn)為0婚夫，因此會(huì)返回空字符串。
     'JavaScript'.substr(-6) // "Script"
     'JavaScript'.substr(4, -1) // ""
     

   • 其他

     • split——根據(jù)分隔符署鸡、拆分成數(shù)組
       • var strArr = str.split(ch);
     • toLowerCase案糙、toUpperCase——大小寫轉(zhuǎn)換
       • var str = str1.toLowerCase()
       • var str = str2.toUpperCase()

數(shù)組詳解

1. 數(shù)組的定義

   var arr=new Array(1,2,3);
   
   var arr=[1,2,3];  //上面的這個(gè)的簡(jiǎn)稱,  上面的性能略高 可以忽略不計(jì)
   
   var arr = [1,2,,,3,4]  //中間的表示undefined length表示6
   
   var arr = [1,2,,,,]  //中間的表示undefined length表示6
   
   var arr = new Array(2^23-1)// undefined*2^23-1
   

   • 區(qū)別: 可以說基本上沒有區(qū)別

   • 其他簡(jiǎn)寫

     function show()
     {
     
     };
     var show = function() {};
     var show = new Function("alert('a')");
     
     var str="abc";
     var str1 = String('abc');
     

     以上兩個(gè)不能稱之為簡(jiǎn)寫, 區(qū)別在于第一個(gè)屬于string,第二個(gè)是object
     下面一個(gè)是屬于包裝類

2. 數(shù)組屬性

   • length

     • 不僅可以只讀還可以寫,但是對(duì)于字符串的length進(jìn)行寫的話沒效果

       var arr = [1,2,3];
       arr.length = 10; 
       alert(arr[6]);//undefined
       
       // delete之后, 長(zhǎng)度并不會(huì)變化
       
       //快速清空數(shù)組:  
       arr.length = 0;
       

   • 數(shù)組使用原則:

     • 數(shù)組中應(yīng)該只存一種類型的變量, 如果要存多種類型的話,
       最好是使用json

   • 遍歷

     arr.forEach(function(item)
     {
         console.log('age'+item.age);
     })
     //IE9 之上
     arr.forEach(function(x,index,a)
     {
         console.log(x+"--"+index+"--"+a===arr);
     });
     

3. 添加限嫌、刪除：(修改當(dāng)前數(shù)組)

   • push 尾部添加 arr.push(value)
   • pop 尾部刪除 arr.pop(); 一次只能刪除掉一個(gè) 返回刪除元素
   • shift 頭部刪除 arr.shift(value); 返回刪除元素
   • unshift 頭部添加 arr.unshift(value);
   • splice：
     • 基本語法：splice(開始, 長(zhǎng)度,[元素…])
       先刪除一段長(zhǎng)度的元素 再添加一段元素
     • 插入
       • arr.splice(2,0,'a','b','c');
     • 刪除
       • arr.splice(2,3);
     • 替換
       • arr.splice(2,3,'a','b','c');

4. 數(shù)組操作 (不修改當(dāng)前數(shù)組)

   • 映射

     arr.map(function(x)
     {
         return x + 10; 
         //讓數(shù)組中每一個(gè)元素都加10, 但是并不會(huì)修改原來的數(shù)組
     });
     

   • 過濾

     arr.filter(function(x,index){
         return index % 3 == 0 || x >= 8;
     });
     //并不會(huì)改變數(shù)組原來的內(nèi)容
     

   • 數(shù)組判斷

     arr.every(function(x)
     {
         return x < 3;//判斷數(shù)組的每一個(gè)是不是都滿足條件 都滿足的話返回true
     });
     arr.some(function(x)
     {
         return x === 3;//數(shù)組之中的任意一個(gè)符合條件就返回true
     });
     

   • 數(shù)組操作

     var arr = [1,2,3];
     var sum = arr.reduce(function(x,y)
     {
         return x + y; //數(shù)組中的值兩兩進(jìn)行操作
         //首先將0傳入,1為y 加起來的和賦值為x,取y=2,再次相加賦值
     },0);//6
     //并不會(huì)改變數(shù)組原來的值
     
     //reduceRight 與reduce差不多, 但是是從右往左開始遍歷
     

   • 判斷

     Array.isArray([]); //true
     
     [] instanceof Array; //true
     
     [].constructor ==== Array //true
     
     ({}).toString.apply([]) === '[object Array]' //true
     
     

   • join：合并數(shù)組，變成字符串

     var str = arr.join('-');  // 與split相反操作
     

   • slice：取子數(shù)組

     var arr = [0, 1,2,3,4,5]
     var b = arr.slice(0, 4) //0 1 2 3
     

5. 二維數(shù)組

   • var arr = [[0,1],[2,3],[4,5]];
   • 稀疏數(shù)組

     • 并不含有從0開始的連續(xù)索引

       var arr1 = [undefined]; //0 in arr1  //true
       
       var arr2 = new Array(1); //0 in arr2 //false
       
       0 in arr[,,] //false
       

6. 排序：(修改原始數(shù)組)

   • sort：排序數(shù)組

     • 排序字符串?dāng)?shù)組
       arr.sort(); //按照字典序排序 (大寫在前)
     • 排序數(shù)字?jǐn)?shù)組
       • 默認(rèn)的情況下, 把所有東西都當(dāng)做字符串處理
       • 排序可以有參數(shù)

     arr.sort(function(num1, num2){
         return num1>num2?-1:1;
         return num1 - num2;
         //返回-1, 表明第一個(gè)比第二個(gè)靠左
         //返回+1, 表明第一個(gè)比第二個(gè)靠右
         //上述返回值只要是負(fù)數(shù)或者整數(shù)都行
     });
     //中文字符串排序
     arr.sort(function(str1,str2)
     {
         return str1.localeCompare(str1,str2);
     });
     

7. 數(shù)組操作 (修改數(shù)組)

   • reverse：反轉(zhuǎn)數(shù)組

     arr.reverse(); // 修改arr
     

   • concat: 數(shù)組連接 arr.concat(arr1);

     arr = [1,2,3];
     arr.concat([10,[11,12]]);  //arr = [1,2,3,10,11,12];
     

   • toString: 數(shù)組轉(zhuǎn)字符串

     • 為了覆蓋某些庫(kù)的源代碼. 覆蓋其toString方法

     show.toString = function() {
         return "就不讓你看"
     };
     

     • 數(shù)字的toString
       • num.toString(n) n代表的數(shù)字的進(jìn)制, 進(jìn)行數(shù)制轉(zhuǎn)換

   • 數(shù)組的去重 (去掉重復(fù)元素 只保留一個(gè))

     • 對(duì)象去重法
     • ES6 Set集合

   • 數(shù)組的復(fù)制

     arr2 = arr1.concat([]);
     //表明concat復(fù)制了一份新的
     //能用原生的方法就用原生的, 效率高
     
     arr2 = arr1.slice(0)
     
      //ES6 語法中數(shù)組復(fù)制
     

8. 數(shù)組apply

   //代碼查看賞析1
   function func()
   {
       var m_points = [];
   
       m_points = Array.apply(m_points, arguments);
       //構(gòu)造函數(shù) 將arguments的參數(shù)加入到m_points中
   
       m_points.push.apply(m_points, arguments);
       // 將arguments數(shù)組加入到m_points當(dāng)中
   
       console.log(m_points);
       //apply的原理: this指向m_points 執(zhí)行 m_points.push方法
       //執(zhí)行m_points.push()方法中的this指向的是 m_points
   }
   func(1,2,3,4,5,6);
   

流程控制和運(yùn)算符

1. 語句塊: {語句1, 語句2} (開發(fā)中用的比較少) 區(qū)分對(duì)象

   • JavaScript沒有塊級(jí)作用域
   • for (var i =0; i < 5; i ++){}
   • 當(dāng)for循環(huán)結(jié)束之后 在外部還是可以訪問i的, 與放在前面聲明是一樣的

2. 判斷（選擇）語句

   • false: 0,false, ''(空字符串), null, undefined
   • true: true,非零數(shù)字, 非空字符串,非空對(duì)象

3. 循環(huán)語句

4. 其他語句

   • with最好不用(讓js引擎更難,可讀性差,可被變量定義替代,嚴(yán)格模式下禁用)

     with({x:1})
     {
         console.log(x); //輸出1
     }
     

5. 對(duì)象屬性

   var val = (1,2,3); //聲明語句 val = 3;
   
   var a = b = 1; //創(chuàng)建的b是一個(gè)全局變量
   
   delete obj.x //刪除對(duì)象上的屬相
   alert(obj.x) //undefined
   
   Object.defineProperty(obj,'x',{
       configuration:false, /*表明對(duì)象上的屬性不可以刪除*/
       value:1,
   });
   delelte obj.x //返回false 表示無法刪掉
   
   'x' in window //對(duì)象里面是否x這個(gè)屬性
   
   obj.hasOwnProperty('x') //判斷對(duì)象是對(duì)象上的屬性還是原型鏈上的屬性
   obj._proto_.hasOwnProperty('x') //是否屬于對(duì)象原型上
   

6. 邏輯運(yùn)算

7. 數(shù)值運(yùn)算

8. 比較運(yùn)算

9. 位運(yùn)算

10. for in

    1. 對(duì)象屬性受原型鏈的影響
    2. enumerable為false的時(shí)候不會(huì)出現(xiàn)

    for(attr in oDiv.style)
    {
        oTxt.value+=attr+'\n';
    }
    

11. 異常處理語句

    try
    {
        throw "test";
    }catch(ex) //可以忽略掉catch
    {
        console.log(ex);
    }finally
    {
        console.log("finally");
    }
    
    try
    {
        try
        {
            throw new Error("oops");
        }
        finally
        {
            console.log("finally");
        }
    }catch (ex)
    {
        console.log(ex);
    }
    //結(jié)果是 先打印 finally 在打印 oops
    

12. 嚴(yán)格模式

    "use strict"
    function fn()
    {
        "use strict";//可以向上兼容, 也可以在文件的最開頭時(shí)使用
    }
    

    • 不允許使用with 會(huì)報(bào)sytax錯(cuò)誤,

    • 不允許未聲明的變量賦值
      !function()
      {
      x = 1;
      console.log(window.x);
      }

    • arguments變?yōu)閰?shù)的靜態(tài)副本

      !function(a)
      {
          aruguments[0] = 100;
          console.log(a);//打印出100
      }(1);
      

      • 上面的情況, 當(dāng)我們不傳參數(shù)1的時(shí)候, a為undefined, 修改參數(shù)argumrnts[0], 但是a的值還是為undefined
      • 使用'use strict' arguments與傳遞的參數(shù)之間不會(huì)有任何的影響,但是如果
        傳遞的是對(duì)象的話, 依然是會(huì)相互影響的

    • 在嚴(yán)格模式下,delete參數(shù),函數(shù)名會(huì)報(bào)錯(cuò), delete不可配置的屬性會(huì)報(bào)錯(cuò)

    • 對(duì)象字面是重復(fù)屬性會(huì)報(bào)錯(cuò) var obj = {x:1, x:2}//語法錯(cuò)誤

    • 嚴(yán)格模式禁止八進(jìn)制字面量 alert(0123);

    • eval,arguments變?yōu)殛P(guān)鍵字,不能作為變量名,函數(shù)名

    • eval獨(dú)立作用域

      eval("var evalVal = 2"); console.log(typeof evalVal);
      // 普通模式下 number, 嚴(yán)格模式下undefined