内容

ECMAScript中心语法构造：

1.语法

2.对象

3.函数

4.继承

5.数组

6.正则表达式

7.要领

8.附录A-毒瘤

9.附录B-糟粕

一、语法

1.范例、值和变量

1) 范例：分辨数据范例

在JS中运用var关键词声明变量，变量的范例会依据其所赋值来决议（动态范例）。
JS中数据范例分为原始数据范例（5种）和援用数据范例（Object范例）。

• 原始数据范例(5)：Number、String、Boolean、Undefined、Null。须要注重的是JS中字符串属于原始数据范例。
• typeof返回值(6)：number、string、boolean、undefined、object、function 。null返回object
• instanceof:处置惩罚援用范例推断题目 详解

3) 变量

• 变量:局部变量和全局变量
• 变量提拔:
  函数及变量的声明都将被提拔到函数的最顶部。
  变量能够在运用后声明，也就是变量能够先运用再声明。

2.语句

1) 前提语句

• if：
• switch:

2)轮回语句

• while
• for
• do

3)强迫跳转语句

• continue:跳出单次轮回
• break：跳出单层轮回
• return：函数返回语句，然则返回的同时也将函数住手
• throw：建立或抛出异常

4)运用
1.label运用-跳出多层轮回

二、对象

1.对象字面量

var obj={
    "last-name":"yue",//'-'是不合法的，必需运用引号
    firstName:"su"
} 

2.检索

1）检索对象里包括的值：

obj["last-name"] //yue
obj.firstName //su

2）用||添补默许值

var name=obj.name||'susu';

3）用&&防止毛病

obj.likeInfo.model// throw "TypeError"
obj.likeInfo && obj.likeInfo.model //undefined

3.更新

经由过程赋值语句更新，假如有值则替代，没有值则新增

obj.firstName='susu'

4.援用

对象经由过程援用来通报。它们永久不会被复制

var x=obj;
x.nick='aaa';
console.log(obj.nick);//aaa
// x,obj指向同一个对象的援用

var a={},b={},c={}//a,b,c每一个都援用一个差别的空对象
var a=b=c={};//a,b,c援用同一个空对象

5.原型

每一个对象都衔接到一个原型对象，并从中继承属性
经由过程字面量建立的对象都衔接到Object.prototype
object的create要领能够挑选某个对象作为它的原型

if(typeof Object.beget!=='function'){
    Object.create=function(proto){
        function F(){};
        F.prototype=proto;
        return new F();
    }
}
var a=Object.create(obj);

// 当对a对象做出转变时，不会影响该对象的原型

6.反射

搜检对象并肯定对象的属性
删除不须要的属性：
1) 搜检并扬弃值是函数的属性

typeof obj.toString // 'function'

2) hasOwnProperty 搜检对象本身的属性，不会搜检原型链

obj.hasOwnProperty('toString') //false

7.罗列

for in:遍历对象中的一切属性名，包括原型中本身增添的属性
注重：属性名涌现的递次是不肯定的，（能够建立包括属性名的数组，再用for轮回来处置惩罚）

8.删除

delete :删除对象的属性,不会触及原型链中的任何对象
假如存在该属性，则被移除，并返回true;
假如不存在该属性，返回undefined;

// 不会影响原型
Object.prototype.name='1111111';
delete name;//true
obj.name;//1111111

9.削减全局变量污染

最小化运用全局变量的要领之一：只建立一个唯一的全局变量

var local={
    data:{},
    methods:{
        test(){
            console.log(123)
        }
    }
}
local.methods.test();//123

三、函数

1.函数对象

函数对象衔接到Function.prototype(该原型对象本身衔接到Object.prototype)
每一个函数在建立时会附加两个隐蔽属性：函数的上下文和完成函数行动的代码。
每一个函数对象在建立时也随配有一个prototype属性。它的值是一个具有controctor属性且值即为该函数的对象。
这和隐蔽衔接到Function.prototype完整差别。

2.函数字面量

函数对象经由过程函数字面量来建立：

var add=function(a,b){
    return a+b;
}

函数字面量包括四个部份：
1) 保留字function
2) 函数名:能够省略(匿名函数)，能够用来递归挪用本身，
3）参数:
4) 函数主体

3.挪用

挪用时每一个函数吸收两个附加参数：this,arguments。
挪用情势：这些情势在怎样初始化this上存在差别
1) 要领挪用情势
当一个函数被保留为对象的一个属性时，我们称它为一个要领。
当要领挪用时，this被绑定到该对象

var myObj={
    value:0,
    increment:function(inc){
        this.value+=typeof inc==='number'?inc:1;
    }

}

myObj.increment(2);
console.log(myObj.value);//3

2) 函数挪用情势
当一个函数并不是一个对象的属性时，那末它就是被看成函数来挪用的。
挪用函数时，this被绑定到全局对象。

var sum=add(3,4); //7

处置惩罚this指向：在外部函数中定义that=this,那末内部函数能够经由过程that接见外部的对象。

3) 组织器挪用情势
假如在一个函数前面带上new来挪用，那末背地里将会建立一个衔接到该函数的prototype成员的新对象，
同时this会被绑定到新对象上。会转变return语句的行动。

var Obj=function(str){
    this.status=str;
}
Obj.prototype.get_status=function(){
    return this.status;
}
var myobj=new Obj('aaa');
myobj.get_status();//aaa

4) apply挪用情势
aplly(绑定给this的值，参数数组)：构建一个参数数组通报给挪用函数

var statusObj={
    status:123
}
Obj.prototype.get_status.apply(statusObj);//123

4.参数

当函数挪用时，会接收一个附加参数arguments数组(类数组：有length属性，但没有数组的任何要领)。
能够编写一个不必指定参数个数的函数。

var sum=function(){
    var sum=0;
    for(var i=0;i<arguments.length;i++){
        sum+=arguments[i];
    }
    return sum;
}
sum(1,2,3)//6

5.返回

return语句可用来使函数提早返回。
假如运用组织器挪用(有new前缀)，且返回不是一个对象，则返回this(该新对象)。

6.异常

异常是滋扰顺序的平常流程的不寻常
throw语句中缀函数的实行，并抛出exception对象，该对象会被通报到try语句的catch从句。

var add=function(a,b){
    if(typeof a!=='number'||typeof b !=='number'){
        throw{
            name:'TypeError',
            message:'必需是数字'
        }
    }
    return a+b;
}
try{
    add(1,'aaa')
}catch(e){
    console.log(e.name,e.message);//TypeError 必需是数字
}

7.扩大范例的功用

经由过程给基础范例增添要领，新的要领马上被给予到一切对象的实例上，进步言语的表现力。

Function.prototype.method=function(name,func){
    if(!this.prototype[name]){
        this.prototype[name]=func;
    }
    return this;
}

Number.method('interge',function(){
    return Math[this<0?'ceil':'floor'](this);
});
2.3.interge();//2

8.递归

递归函数就是会直接或间接的挪用本身的一种函数。
递归函数操纵树形构造，如浏览器端的文档对象模子(DOM)

// 汉诺塔游戏
var hanoi=function(n,from,ass,to){
  if(n>0){
    hanoi(n-1,from,to,ass);
    console.log("挪动第"+n+"个从"+from+"到"+to);
    hanoi(n-1,ass,from,to);
  }
}

hanoi(2,"A","B","C");
// 挪动次数
function moveTimes(n){
    if(n==1){
        return 1;
    }
    return 2*moveTimes(n-1)+1;
}

9.作用域

作用域掌握着变量与参数的可见性及生命周期，它削减了称号争执，并供应了自动内存治理。
长处：内部函数能够接见定义它们的外部函数的参数和变量(除了this和arguments)。

10.闭包

当内部函数被保留到外部时，将会天生闭包。闭包会致使原有作用域链不开释，形成内存走漏。
闭包能够接见它被建立时所处的上下文环境。

// 防止在轮回中建立函数，能够在轮回以外建立一个辅佐函数，
// 让这个辅佐函数再返回一个绑定了当前i值的函数

var add_handlers=function(nodes){
    var helper=function(i){
        return function(){
            console.log(i);
        }
    }
    for(var i=0;i<nodes.length;i++){
        nodes[i].onclick=helper(i)
    }
}

add_handlers(document.getElementsByTagName('li'))

11.回调

提议异步请求时，供应一个当服务器的相应抵达时随即触发的回调函数，异步函数马上返回，如许客户端就不会被壅塞。

12.模块

运用函数和闭包来组织模块。
模块情势应用了函数作用域和闭包来建立被绑定对象与私有成员的关联。
平常情势：一个定义了私有变量和函数的函数；应用闭包建立能够接见私有变量和函数的特权函数；末了返回这个特权函数，或许保留到一个可接见到的处所。

String.method('deentityify',function(){
    // 字符实体表,若放在函数内部每次实行函数时该字面量都邑被求值一次，会带来运转时的消耗，
    var entity={
        quot:'"',
        lt:'<',
        gt:'>',

    }
    return function(){
        return this.replace(/&([^&;]+);/g,function(a,b){
            var r=entity[b];
            return typeof r==='string'?r:a;
        })
    }
}())

'&gt;&quot;&lt;'.deentityify(); // >"<

13.级联

假如要领返回this,就会启用级联。
在一个级联中，能够在零丁一条语句中顺次挪用同一个对象的许多要领。

14.柯里化

柯里化许可我们把函数与通报给它的参数相结合，发作一个新的函数。

Function.method('curry',function(){
    var slice=Array.prototype.slice,
        args=slice.apply(arguments);
        that=this;
    return function(){
        return that.apply(null,args.concat(slice.apply(arguments)));
    }
});

function add(a,b){
    return a+b;
}
var add1=add.curry(1);
var res=add1(6);//7

15.影象

影象：函数能够将先前操纵的结果记录在某个对象里，从而防止无谓的反复运算。

// memo:初始数组； formula:函数 公式
var memoizer=function(memo,formula){
    var recur=function(n){
         result=memo[n];
        if(typeof result !=='number'){
            result=formula(recur,n);
            memo[n]=result;
        }
        return result;
    }
    return recur;

}

var fibonacci=memoizer([0,1],function(recur,n){
    return recur(n-1)+recur(n-2);
});
var res=fibonacci(10);

四、继承

1.伪类

瑕玷：没有私有环境，一切的属性都是公然的。

// 当采纳组织器挪用情势，函数实行的体式格局会被修改。
// 假如new运算符是一个要领，它能够会像如许实行

Function.method('new',function(){
    // 建立一个新对象，它继承自组织器的原型对象
    var that=Object.create(this.prototype);
    // 挪用组织器函数，绑定this到新对象上
    var other=this.apply(that,arguments);
    // 假如它的返回值不是一个对象，就返回改新对象
    return (typeof other=='object'&& other)||that;
})

能够组织一个伪类来继承父类，这是经由过程定义它的constructor函数并替代它的prototype为一个父类的实例来完成

Function.method('inherits',function(Parent){
    this.prototype=new Parent();
    return this;
})

2.对象说明符

在编写组织器时让它接收一个简朴的对象说明符。
多个参数能够按任何递次排列，假如组织器运用默许值，一些参数能够疏忽，代码易浏览。

var obj=testFn({
        first:f,
        middle:m,
        last:l
    });

3.原型

一个新对象能够继承一个旧对象的属性
用Object.create(parent)组织出更多的实例
差别化继承：经由过程定制一个新对象，我们指明它与所基于的基础对象的区分

// 作用域继承，内部作用域继承外部作用域碰到一个左花括号时block函数被挪用，
var block=function(){
    // 记着当前作用域，组织一个包括了当前作用域中一切对象的新作用域
    var oldScope=scope;
    scope=Object.create(oldScope);
    // 通报左花括号作为参数挪用advance
    advance('{');
    // 运用新的作用域举行剖析
    parse(scope);
    // 通报左花括号作为参数挪用advance并扬弃新作用域，恢复本来老的作用域。
    advance('}');
    scope=oldScope;
}

4.函数化

运用模块情势处置惩罚私有变量和私有函数

函数化组织器步骤：
1）建立一个新对象
2）有挑选的定义私有实例变量和要领。
3）给这个对象扩大要领，这些要领具有特权去接见参数。
4）返回谁人新对象

// 伪代码模板

var constructor=function(spec,my){
    var that,其他的私有实例变量
        my=my||{};
    把同享的变量和函数增添到my中
    that=一个新对象
    增添给that的特权要领
    return that;
}

// 处置惩罚父类的要领
Object.method('superior',function(name){
    var that=this,
        method=that[name];
    return function(){
        return method.apply(that,arguments);
    }
})

//例子
var mammal=function(spec){
    var that={};
    that.get_name=function(){
        return 'hello'+spec.name;
    }
    return that;
}

var cat=function(spec){
    var that=mammal(spec);
    var super_get_name=that.superior('get_name')
    that.get_name=function(){
        return spec.name+'like'+super_get_name();
    }
    return that;
}
var my=cat({name:'su'});
console.log(my.get_name());//su like hello su

5.部件

从一套部件中把对象组装出来。

五、数组

1.定义:

• 字面量: var arr=[1,2,3];
• 组织要领: new Array(length/content);

2.属性

• constructor: 返回建立此对象的数组函数的援用。
• length:设置或返回数组中元素的长度。
• prototype：向对象增添属性和要领

3.删除

1）delete 会在数组中留下一个朴陋
2）splice 能够删除元素并替代为其他元素

var arr=['a','b','c','d'];
delete arr[1];
console.log(arr);//["a", empty, "c", "d"]

// 关于大型数据，能够效力会不高
var arr1=['a','b','c','d'];
arr1.splice(2,1)
console.log(arr1);//["a", "b", "d"]

4.要领

Array.method('reduce',function(f,value){
    for(var i=0;i<this.length;i++){
        value=f(this[i],value)
    }
    return value;
})

function add(a,b){
    return a+b;
}
var arr=[1,2,3];
// 由于数组是对象，能够给零丁的数组增添一个要领
// 由于字符串total不是整数，所以不会转变数组的长度
arr.total=function(){
    return this.reduce(add,0)
}
console.log(arr.total());//6

Object.create要领用在数组是没有意义的，由于它发作一个对象，而不是一个数组。
发作的对象将继承这个数组的值和要领，然则它没有谁人特别的length属性。

5.指定初始值

// fill 初始化
var arr=new Array(5);
arr.fill(0);//[0, 0, 0, 0, 0]

// 初始化一维数组
Array.dim=function(dimension,initial){
    var a=[];
    for(var i=0;i<dimension;i++){
        a[i]=initial;
    }
    return a;
}
Array.dim(5,0);//[0, 0, 0, 0, 0]


// 初始化多维数组
Array.matrix=function(m,n,initial){
    var a=[],mat=[];
    for(var i=0;i<m;i++){
        for(var j=0;j<n;j++){
            a[j]=initial
        }
        mat[i]=a;
    }
    return mat;
}
Array.matrix(2,2,0);//[[0,0],[0,0]]

6.原型-要领

1).转变原数组：

• push:向数组的末端增添一个或更多元素，并返回新的长度。
• pop:删除并返回数组的末了一个元素
• shift: 删除并返回数组的第一个元素
• unshift:向数组开首增添一个或多个元素，并返回新的长度。
• reverse:逆转递次,并返回新数组
• sort:排序，返回排序后的数组
• splice:(从第几位最先，截取若干的长度，在瘦语处增添新的数据) 删除元素，并向数组增添新元素,返回被截取元素的数组
• fill(value, start, end) 将一个固定值替代数组的元素。

2).不转变原数组

• concat: 衔接两个或更多的数组，并返回结果。
• slice:(从该位最先截取，截取到该位] 截取，返回被截取元素的数组
• join:经由过程指定的分开符(默许逗号)举行分开,返回字符串
• toString:把数组转换为字符串，并返回结果。

7.原型-轮回要领

1)参数雷同 (回调函数(当前元素，当前元素的索引，原数组),this)

• forEach: 替代一般for轮回,没有返回值
• map:经由过程指定函数处置惩罚数组的每一个元素，并返回处置惩罚后的数组。
• filter:过滤 ,返回相符前提一切元素的数组。
• every:检测数值中的每一个元素是不是都相符前提。返回true或false
• some:检测数组中是不是有元素相符前提。返回true或false

5.运用

1.数组-参考手册
2.数组，类数组
3.forEach，for in ,for of的区分

六、正则表达式

1.构造

1）建立RegExp对象：

• 字面量 var my_reg=/[A-Z]/g;
• 组织器，适用于必需在运转时动态天生正则表达式的状况。var my_reg=new RegExp(‘[A-Z]’,’g’);
  建立字符串时须要注重，由于反斜杠在正则表达式和字符串中寄义差别，一般须要双写反斜杠，以及对引号举行转义

2）正则表达式标识

3）RegExp对象的属性

2.元素

1）正则表达式分支
一个正则表达式包括一个或多个正则表达式序列。
这些序列被|(竖线)字符分开，假如这些字符中的任何一项相符婚配前提，那末这个挑选就被婚配。
它常是按递次顺次婚配这些序列项

// 由于in已被胜利婚配，所以不会婚配int
var a='into'.match(/in|int/);//['in']

2）正则表达式序列
一个正则表达式序列包括一个或多个正则表达式因子。
每一个因子能挑选是不是追随一个量词，这个量词决议着这个因子被许可涌现的次数。
假如没有指定这个量词，那末该因子只会被婚配一次

3）正则表达式因子
一个正则表达式因子能够是一个字符、一个由圆括号围困的组、一个字符类，或是一个转义序列
这些字符须要转义: / { } ? + * | . ^ $

4）正则表达式转义

反斜杠字符在正则表达式因子和在字符串中均示意转义，但在正则表达式因子中有点差别
\d : [0-9],\D:[^d]
\s : [tnrvf ] 空缺字符, \S:[^s]
\w : [0-9A-Za-z_] ,\W:[^w]
\b : 单词边境 \B:[^b]
\1 : 指向分组1所捕捉到的文本的一个援用。 如：\2,\3

5）正则表达式分组

• 捕捉型: 一个捕捉型分组是一个被围困在圆括号找谁人的正则表达式分支。每一个捕捉型分组都被指定了一个数组。
  任何婚配这个分组的字符都邑被婚配。
  在正则表达式中第一个捕捉(的是分组1，第二个捕捉(的是分组2。
• 非捕捉型: 非捕捉型分组有一个(?:前缀，仅做简朴的婚配，并不会捕捉所婚配的文本，不会滋扰捕捉型分组的编号。
• 向前正向婚配: 向前正向婚配分组有一个(?=前缀，相似非捕捉型分组，
  但在这个组婚配后，文本会倒回到它最先的处所，实际上并不婚配任何东西。
• 向前负向婚配: 向前负向婚配分组有一个(?!前缀，相似向前正向婚配分组，
  但只要当它婚配失利时它才继承向前举行婚配

6）正则表达式字符集
正则表达式字符集是一种指定一组字符的轻易体式格局。
假如婚配一个元音字母，能够写成(?:a|e|i|o|u),
但能够更轻易的写成一个类[aeiou], 类的求反 [^aeiou]

7）正则表达式量词

正则表达式因子能够用一个正则表达式量词后缀来决议这个因子应当被婚配的次数。
围困在一对花括号中的一个数组示意这个因子被婚配的次数。
n+ : {1,} 1到多个
n* : {0,}
n? : {0,1}
n{X} : X个
n{X,Y} : X-Y个
n{X,} : X到多个
?=n : 婚配厥后紧接n 的字符串
?!n : 婚配厥后没有紧接n 的字符串
假如只要一个量词，示意趋向于举行贪欲性婚配，即婚配尽量多的副本直至到达上限。
假如这个量词附加一个后缀?,示意趋向于举行非贪欲性婚配，即只婚配必要的副本就好。

七、要领

1.Array

数组-参考手册

2.Function

function.apply(thisArg,argArray)
apply要领挪用function,通报一个会被绑定到this上的对象和一个可选的数组作为参数

Function.method('bind',function(that){
    var method=this;
    var slice=Array.prototype.slice;
    var args=slice.apply(arguments,[1])
    return function(){
        return method.apply(that,args.concat(slice.apply(arguments)));
    }
})
var test=function(){
    return this.value+':'+Array.prototype.slice.apply(arguments);
}.bind({value:666},1,2);
console.log(test(3));//666:1,2,3

3.Number

Number-参考手册

4.Object

Object.hasOwnProperty(name)不会搜检原型链中的属性

var a={member:true};
var b=Object.create(a);
var c=a.hasOwnProperty('member');//true
var d=b.hasOwnProperty('member');//false
var e=b.member;//true

5.RegExp

RegExp-参考手册

1.regExp.exec(string)
假如经由过程轮归去查询一个婚配情势在字符串中发作了频频，须要注重：假如提早退出了轮回，再次进入这个轮回前必需把
RegExp.lastIndex重置为0，而且，^仅婚配RegExp.lastIndex为0的状况。
假如带有g全局标识，查找不是从这个字符串的肇端位置最先，而是从regExp.lastIndex位置最先。

var reg1=/ab/g;
var str='ababab';

console.log(reg1.exec(str),reg1.lastIndex)
console.log(reg1.exec(str),reg1.lastIndex)
console.log(reg1.exec(str),reg1.lastIndex)
console.log(reg1.exec(str),reg1.lastIndex)
console.log(reg1.exec(str),reg1.lastIndex)
// 打印结果：
["ab", index: 0, input: "ababab", groups: undefined] 2
["ab", index: 2, input: "ababab", groups: undefined] 4
["ab", index: 4, input: "ababab", groups: undefined] 6
null 0
["ab", index: 0, input: "ababab", groups: undefined] 2

2.regExp.test(string)

// 假如这个要领运用g标识，会转变lastIndex的值
var reg=/[A-Z]/g;
var arr=['Asdsd','BsdsCds','Dasas','E1212'];
for(var i=0;i<arr.length;i++){
    console.log(reg.test(arr[i]),reg.lastIndex);//true 1,true 5,false 0,true 1
}

6.String

字符串-参考手册

附录A-毒瘤

1.全局变量

全局变量使得在同一个顺序中运转自力的子顺序变得更难。
由于全局变量能够被顺序的任何部份在恣意时候修改，使顺序的行动变得极端庞杂，下降顺序的可靠性

// 定义全局变量的要领
var foo=value;
window.foo=value;
foo=value;

2.作用域

没有块级作用域，代码块中声明的变量在包括此代码块的函数的任何位置都是可见的。
更好的体式格局：在每一个函数的开首部份声明一切变量

3.自动插进去分号

有一个自动修复机制，它试图经由过程自动插进去分号来修改有缺损的顺序.
它能够会掩饰更为严重的毛病。

// 在return语句后自动插进去分号致使的结果
function test1(){
    return{
        name:'aaa'
    }
}
function test2(){
    return
    {
        name:'aaa'
    }
}
console.log(test1(),test2());//{name: "aaa"} undefined

4.保留字

保留字不能被用来定名变量或参数。
当保留字被用做对象字面量的键值时，它们必需被引号括起来，不能用在点示意法中，必需运用括号示意法。

var case;//不法,都不支撑
// ie8及以下不支撑 不法的写法
var obj={case:'123'};//不法
var a=obj.case//不法
var object={'case':'1212'};//ok
var b=object['case'];//ok

5.Unicode

Unicode把一对字符视为一个单一的字符，而js以为一对字符是两个差别的字符

6.typeof

typeof null返回object
正则表达式，返回object,在safari(3.x版本)中返回function

// 分辨null与对象
if(value&& typeof value=='object'){
    //value是一个对象或数组
}

7.parseInt

parseInt把字符串转换为整数，

// 碰到非数字时会住手剖析
parseInt('16')==parseInt('16aa123');//ture

// ie8及以下会涌现以下题目：
// 假如字符串第一个字符是0，那末字符串会基于八进制来求值，（）
// 会致使顺序剖析日期和时候时涌现题目，能够用parseInt的第二个参数作为基数处置惩罚

console.log(parseInt('08'),parseInt('09'));//0 0
console.log(parseInt('08',10),parseInt('09',10));//8 9

8.+

+运算符能够用于加法运算或字符串衔接，怎样实行取决于其参数的范例
加法运算：两个运算数都是数字
字符串衔接：个中一个运算数是空字符串，则另一个运算数被转换成字符串举行衔接。

9.浮点数

二进制的浮点数不能准确处置惩罚十进制的小数。

0.1+0.2 //0.30000000000000004
//浮点数中的整数运算是准确的，所以小数表现出来的毛病能够经由过程指定精度来防止
(0.1*10+0.2*10)/10 //0.3

10.NaN

NaN是一个特别的数量值。它示意的不是一个数字，然则 typeof NaN===’number’
该值会在试图把非数字情势的字符串转化为数字时发作，如：Number(’12px’) //NaN
NaN===NaN //fales

// 分辨数字与NaN
isNaN(NaN);//true
isNaN('aaa');//true

推断一个值是不是可用做数字运用isFinite函数，由于它会筛掉NaN和Infinity
然则它会试图把运算数转换为一个数字,isFinite(’10’)//true

var isNumber=function(value){
    return typeof value==='number'&&isFinite(value)
}
isNumber('10');//false

11.伪数组

// 分辨数组
// arguments是一个类数组,返回[object Arguments]
if(Object.prototype.toString.apply(value)==='[object Array]'){
    //value是一个数组
}

12.假值

以下这些值悉数等同于假，但它们是不可交换的

13.hasOwnProperty

hasOwnProperty能够处置惩罚for in的隐患
但它是一个要领，在任何对象中，它能够会被一个差别的函数以至一个非函数的值所替代

var name,obj={};
obj.hasOwnProperty=null;//地雷
for(name in obj){
    if(obj.hasOwnProperty(name)){//触雷
        console.log(name,obj[name])
    }
}

14.对象

js对象永久不会是真的空对象，由于它能够从原型中获得成员属性

// 假如字符串内里包括constructor,会返回{hello: 3, word: 1, constructor: "function Object() { [native code] }1"}
// 能够用hasOwnProperty处置惩罚 返回{hello: 1, word: 1, constructor: 1}
var text='hello word hello,Hello constructor';
var words=text.toLowerCase().split(/[\s,.]+/);
var count={},word;
for(var i=0;i<words.length;i++){
    word=words[i];
    if(Object.hasOwnProperty(count[word])&&count[word]){
        count[word]+=1;
    }else{
        count[word]=1;
    }
}
console.log(count);

附录B-糟粕

1.==

==,!=运算符只要在两个运算范例一致时才会做出准确的推断，假如两个运算数是差别的范例，它们试图去强迫转换值的范例
==,!=运算符缺乏通报性，所以运用===和!==

'' == '0'//false
0 == '0' //true
false == 'false'//false
false == '0' //true

false == undefined //false
false == null //fasle
null == undefined //true
'\t\r\n' == 0 //true

2.with语句

with语句本意是用来快速的接见对象的属性，但偶然不可预感，所以应当防止运用它
严重影响了js处置惩罚器的速率，由于它阻断了变量名的词法作用域绑定

with(obj){
    a=b;
}
// 和下面的代码做的是一样的事变
if(obj.a===undefined){
    a = obj.b === undefined ? b : obj.b;
}else{
    obj.a = obj.b === undefined ? b : obj.b;
}
// 所以，它等同于这些语句中的某一条：
a = b;
a = obj.b;
obj.a = b;
obj.a = obj.b;

3.eval

eval函数通报一个字符串给javaScript编辑器，而且实行结果
1）运用eval情势的代码越发难以浏览，这类情势使得机能明显下降，由于它须要运转编译器，但或许只是为了实行一个赋值语句。
2）它会让JSLint失效，让此东西检测题目的才能大打折扣
3）削弱了运用顺序的安全性，由于它被求值的文本授与了太多的权益，与with语句实行体式格局一样，下降言语的机能
4）Function组织器是eval的另一种情势，应当防止运用(new Function ([arg1[, arg2[, …argN]],] functionBody))
5）setTimeout,setInterval当吸收字符串参数时，也会像eval那样处置惩罚，应防止运用字符串参数

4.continue语句

continue语句跳到轮回的顶部
然则假如一段代码经由过程重构移除continue语句以后，机能都邑获得改良

console.time(111)
var sum=0;
for(var i=0;i<100;i++){
    if(i==50){
        continue;
    }
    sum+=i;
}
console.timeEnd(111);//0.051025390625ms


console.time(222)
var sum=0;
for(var i=0;i<100;i++){
    if(i!=50){
        sum+=i;
    }
}
console.timeEnd(222);// 0.02099609375ms

5.switch穿越

除非你明确地中缀流程，不然每次前提推断后都穿越到下一个case前提。

6.缺乏块的语句

if,while,do,for语句能够接收一个括在花括号找谁人的代码块，也能够接收单行语句
然则单行语句隐约了顺序的构造，使得在随后的操纵代码中能够很轻易插进去毛病

//轻易致使毛病
if(ok)
    t=true;
    advance()

7.++

这两个运算符勉励了一种不够郑重的变成作风，大多数的缓冲区溢出的毛病所形成的安全漏洞，都是由像如许的代码致使的
而且它会使代码变得过于拥堵，庞杂和隐晦

8.位运算符

在java里，位运算符处置惩罚的是整数，然则js没有整数范例，只要双精度的浮点数，因而，位操纵符把它们的数字运算数先转换成整数，在实行运算，然后在转换归去。
在大多数言语中，位运算符接近于硬件处置惩罚，所以异常快。但js的实行环境平常打仗不到硬件，所以异常慢，js很少被用来实行位操纵

9.function语句对照function表达式

function语句在剖析时会发作被提拔的状况，不论function被安排在那里，它会被挪动到被定义时地点作用域的顶层,
这放宽了函数先声明后运用的请求,这会致使杂沓

function foo(){

}
// foo是一个包括一个函数值的变量，函数就是数值
var foo=function(){

}

一个语句不能以一个函数表达式开首，但能够把函数挪用括在一个圆括号当中

(function(){
    var a=1;
    // 这个函数能够对环境有一些影响，但不会引入新的全局变量
})()

10.范例的包装对象

new Boolean,new Number,new String会返回一个对象，该对象有一个valueOf要领会返回被包装的值
防止运用new Array和new Object,可运用[]和{}来替代

11.new

1）new运算符建立一个继承于其组织器函数的原型的新对象，然后挪用该组织器函数，把新建立的对象绑定给this,
这给组织器函数一个机会在返回给请求者前自定义新建立的对象
2）假如遗忘new运算符，就是一个一般的函数挪用，this被绑定到全局对象，而不是建立一个新对象。污染全局变量
3）组织器函数应当以首字母大写的情势定名，而且首字母大写的情势应当只用于来定名组织器函数

12.void

在许多言语中，void是一种范例，示意没有值
但在js中，void是一个运算符，它接收一个运算数并返回undefined,这没有什么用，应防止运用它

//当用户链接时，void(0) 盘算为 0，但 Javascript 上没有任何结果。
<a href="javascript:void(0)">单击此处什么也不会发作</a>