js基礎篇

安全防範機制

未聲明變量undeclared、聲明未初始化變量undefined

var a 
b 
typeof a //"undefined"
typeof b //"undefined"

使用typeof來作安全防範機制能夠預防報錯

if(typeof r !== 'undefined'){
    //do
}
else{
    //do
}

數組

數組能夠容納任何類型的值。

用delete刪除數組的某一項值後，數組長度不會改變

var a = [1,2,3]
delete a[1]
console.log(a.length)
//3

建立「稀鬆」數組(含有空白或空缺的數組)後，其中空白單元值爲undefined，與將其顯示賦值爲undefined有區別

數組經過數字進行索引，但它也是對象，能夠包含字符串鍵值和屬性，可是這些並不計算在數組長度內

var c = []
c[0] = 1
c ["dd"] = 2
console.log(c.length) // 1

注意：若是字符串值可以被強制轉換爲十進制數字的話，它就能夠被看成數字索引來處理

var d = []
b[0] = 1
b["13"] = 12
console.log(b) // [1, 13: 12]0: 1 13: 12length: 14

類數組

將類數組轉化成真數組，使用數組工具函數indexOf() concat() forEach() slice().經過arguments對象將函數的參數看成列表來訪問在ES6中已廢棄

Array.form(arguemnts)實現返回參數列表的數組複本

字符串

js中字符串是不可變的，而（字符）數組是可變的。
字符串不變指的是字符串成員函數不會改變其原始值，而建立並返回一個新的字符串。而數組成員都是在其原始值上進行操做。

var m = "foo"
var n = ['f','o','o']
m[1] = 1
n[1] = 1
console.log(m,n)          // foo ["f", 1, "o"]

c = m.toUpperCase()
m === c                          //false
m                                  //"foo"
c                                 //"FOO"

許多數組函數用來處理字符串很方便，雖然字符串沒有這些函數，但能夠經過「借用」數組的非變動方法來處理字符串

一般方法：

Array.prototype.join.call()

字符串反轉：
不能經過Aarry.prototype.reverse.call()來「借用」可變動成員函數reverse()

簡單字符串反轉經常使用方法：

var c = "foo"
c
//將字符串轉成字符數組
.split("")
.reverse()
//將字符數組轉成字符串
.join("")                          //"o,o,f"

數字

js沒有真正意義上的「整數」，js中數據類型基於IEEE754標準實現的，該標準一般也被稱爲」浮點數「。

較小的數值

怎樣來判斷0.1 ＋ 0.2 ＝＝ 0.3是否相等呢？

設置一個偏差範圍值，
ES6中定義Number.EPSILON

爲ES6寫的polyfill

if(!Number.EPSILON){
     Number.EPSILON = Math.pow(2,-52)
 }

可使用Number.EPSILON來比較兩個數字是否相等（即在指定偏差內）

檢查一個數是否爲整數

ES6:Number.isInterger

polyfill

if(!Number.isInteger){
    Number.ismteger = function(num){
        return typeof num == 'number' && num % 1 == 0
    }
}

檢查是否爲一個安全的整數

polyfill

if(!Number.isSafeInteger){
    Number.isSafeInteger = function)(num){
        return Number.isInteger(num) && Math.abs(num) <= Num.MAX_SAFE_INTEGER
    }
}

32位有符號整數

整數最大可以達到53位，有些數字操做適用32位數字。
a | 0能夠將變量轉換成32位有符號的整數，由於整數運算符｜只適用32位整數。所以與0進行操做便可截取a中的32位數位。

特殊數值

undefined null:既是類型也是值

null 空值，特殊關鍵字，指曾賦過值，可是目前沒有值

undefined 標誌符，沒有值，未賦值

NaN

不是數字的數字（沒法解析爲常規十進制／十六進制）

var a = 2/"foo"          //NaN
typeof a                   //"number"

自反的值 NaN !== NaN

isNaN():檢查參數是否不是NaN，也不是數字

var a = 2/"foo"
var b = "foo"
window.isNaN(b)        //true
window.isNaN(a)        //true

ES6:Number.isNaN

polyfill:

if(!Number.isNaN){
    Number.isNaN = function(num){
        return num !== num
    }
}

無窮數

var a = -1 / 0       //-Infinity
var b = 1 / 0          //Infinity

var c = 1 / Infinity      //0
var d = -1 / Infinity     //-0
var e = Infinity / Infinity  // NaN

零值

0和-0

var a = 0 / -3             //-0
var b = 0 * -3            //-0

加法和減法運算得不到－0

要區分0和－0

function isNegZero (n) {
    n = Number(n)
    return (n===0) && (1/n === -Infinity)
}

特殊等式

ES6: Object.is(..)

polyfill

if(!Object.is){
     Object.is = function (v1,v2) {
         if(v1 === 0 && v2 === 0 ){
             return 1 / v1 === 1 / v2
         }
         if(v1 !== v1){
             return v2 !== v2
         }
         return v1 === v2
     }
 }

PS:數值考慮NaN 與 0 －0

值和引用

js對值和引用的賦值在語法上沒有區別，徹底根據值的類型

值複製：標量基本類型的值是不可更改的

null / undefined

字符串

數字 new Number()

boolean

symbol

引用複製：同時指向一個值，更改的也是同一個值

對象（數組和封裝對象）

函數

若是經過值複製來傳遞複合值，就須要爲其建立一個複本，這樣傳遞的就不是原始值foo(a.slice())

相反，若是將標量基本類型值傳遞到函數並進行更改，就須要將該值封裝到一個複合值中，而後經過引用複製進行傳遞

function foo(wrapper){
    wrapper.a = 42
}

var obj = {
    a : 2
}

foo(obj)
obj.a                             //42