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