安全防范机制

未声明变量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