Function.prototype.method=function(name,func){
this.prototype[name]=func;
return this;
}
//1.注释最好使用双斜杠而不是带*斜杠
/*2.数字，js不区分整数类型，1和1.0是相等的
* NaN是一个数值，它表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它自己，可用isNaN(number)检查
* 值Infinity表示所有大于1.79769313486231570e+308的值
*/
/*3.js没有字符类型，可用一个字母的字符串表示字符，字符串有length属性，字符串不可变
两个包含相同着完全相同的字符且字符顺序也相同的字符串被认为相同的字符串*/
/*4.js中以下值为假:false,null,undefined,空字符串,数字0,数字NaN*/
/*第三章：对象
存取属性:stooge["first-name"]与stooge.first-name一样,不存在的属性返回undefined
||用于填充默认值:var name=stooge.first-name||"unknown";
每个对象都连接到一个原型对象，并且它可以从中继承属性，原型只在检索时有用，如为一个对象添加一个不存在的属性时，
该对象会临时将属性添加到对象中，但如果检索一个不存在的属性，便会到原型对象中查找该属性，即委托
hasOwnProperty()可以限制只在自己中查找对象
delete stooge.first-name删除某个属性，但不触及原型中的对象
尽量避免全局变量
*/
/*第四章：函数对象
* 函数会产生一个原型Function.property,而Function包含一个原型Object.property
* 函数也是对象，唯一特殊在于可以调用执行
* 函数调用时会默认配置一个this和argments,其中argments是一个类似数字的对象，但不具备数组的一切方法
* 函数执行完成总会return一个东西(undefined或者对象)，如果是对象调用函数，则返回this(调用函数的对象)
* 函数抛出的异常对象包括一个name和message
* */
//递归48页
var hanoi=function(disc,src,aux,dst){//desc-碟子个数,
if(desc>0){
hanoi(disc-1,src,dst,aux);
hanio(disc-1,aux,src,dst);
}
}
var walk_the_DOM=function walk(node,func){
func(node);
node=node.firstChild;
while(node){
walk(node,func);
node=node.nextSibiling
}
}
var getELementByAttrbute=function(attr,value){//实现根据属性值查找节点
var results=[];
walk_the_DOM(document.body,function(node){
var actual=node.nodeType ===1 && node.getAttrbute(attr);
if(typeof actual===‘string‘ &&
(actual===value || typeof value !==‘string‘))
results.push(node);
});
return results;
}
/*如果一个函数返回自身递归调用的结果，那么调用的过程会被替换为一个循环，它可以显著提高速度，即尾递归优化，js并不支持*/
var factorial=function factorial(i,a){
a=a||1;
if(i<2){
return a;
}
return factorial(i-1,a*i);
}
/* 函数作用域，js只支持函数内的变量外部不可见，代码块级的变量在函数中处处可见，这与其他语言(c)不一样
* 因此，最好把函数用到的变量全部放在函数顶部，而不是像其他语言一样延迟定义
* 闭包:作用域的好处是内部函数可以访问定义它们的外部函数的变量和参数(除了this和argments),有时候一个内部函数
*拥有比它的外部函数更长的生命周期*/
var myObject=function(){
var value=0;
return {
increament:function(inc){
value += typeof inc ===‘number‘?inc:1;
},
getValue:function(){
return value;
}
}
}();//注意这里的()
var quo=function(status){
return {
get_status:function(){
return status;
}
};
};
var myQuo=quo("amazed");//新建一个对象后，quo调用已经结束返回，但是get_status依然可以访问quo中的sttaus,闭包
document.writeln(myQuo.get_status());
var fade=function(node){//渐变实现，闭包的演示
var level=1;
var step=function(){
var hex=level.toString(16);
node.style.backgroundColor=‘#FFFF‘+hex+hex;
if(level<15){
level+=1;
setTimeout(step,100);
}
};
setTimeout(step,100);
};
var add_the_handlers=function(nodes){//这是一个错误的方法(54页)
var i;
for(i=0;i<nodes.length;i++){
nodes[i].onclick=function(e){
alert(i);
}
}
}
var add_the_handlers=function(nodes){//上面方法的正确写法(54页)
var i;
for(i=0;i<nodes.length;i++){
nodes[i].onclick=function(i){
return function(e){alert(i);}
}(i);
}
}
//模块，可以通过函数和闭包实现模块
String.method("deentityify",function(){//TODO 模块，重要
//字符实体表，它映射字符实体的名字到对应的字符
var entity={quot:‘"‘,lt:‘<‘,gt:‘>‘};
//返回deentityify方法。方法逻辑在此处
return function(){
//这才是deentityify的方法。它调用字符串的replace方法。
return this.replace(/&([^&;]+);/g,function(a,b){
var r=entity[b];
return typeof r=== ‘string‘?r:a;
});
};
}());//此处()执行立刻调用刚刚构造的函数，这个调用之后返回的才是deentityify方法
document.writeln(‘<">‘.deentityify());
/*模块的一般形式是:1.一个定义了私有变量和函数的函数；
2.利用闭包创建可以访问私有变量和函数的特权函数
3.最后返回这个特权函数，或者把它们保存到一个可以访问到的地方*/
var serial_maker=function(){//练习
var prefix=‘‘;
var seq=0;
return {
set_prefix:function(p){prefix=String(p);},
set_seq:function(s){seq=s;},
gensym:function(){
var result=prefix+seq;
seq++;
return result;
}};
}
var seqer=serial_maker();
document.writeln(seqer.gensym());
seqer.set_prefix(‘Q‘);
seqer.set_seq(1000);
document.writeln(seqer.gensym());
//套用57页
//记忆：以下是
var fibonacci=function(n){
return n<2?n:fibonacci(n-1)+fibonacci(n-2);
};
for(var i=0;i<10;i++){fibonacci(i);}//会执行453次
var fibonacci=function(){
var memo=[0,1];//记忆数组
var fib=function(n){
var result=memo[n];
if(typeof result !==‘number‘){
result= fib(n-1)+fib(n-2);
memo[n]=result;
}
return result;
};
return fib;
}();//使用该方法会记住之前算出的结果，执行次数会减少到11次
//第五章：继承，60页
//基于原型的继承
var myMammal={
name:‘Herb the Mammal‘,
get_name:function(){
return this.name;
},
says:function(){
return this.saying || ‘‘;
}
};
var myCat=Object.beget(myMammal);//对象继承
myCat.name=‘Henrietta‘;//重设属性
myCat.saying=‘meow‘;
myCat.purr=function(n){//扩展新方法
var i,s=‘‘;
for(i=0;i<n;i++){
if(s)
s+=‘_‘;
s+=‘r‘;
}
return s;
};
myCat.get_name=function(){//覆盖父类方法
return this.says+‘‘+this.name+‘‘+this.says;
};
//5.4函数化 66页未理解
//第六章:数组，72页
//js中数组以对象方式实现，typeof返回Object ，第一个元素为[0]...,数组没有固定大小，具备动态扩展
//push()增加最新的元素，splice(index,amount)删除元素
//第七章:正则表达式，79页
//js中正则表达式必须写在一行,js的语言处理程序之间的兼容性非常高，除了正则表达式的移植性不好
//处理的方法有:regexp.exec、regexp.test、string.match、string.replace、string.search、string.split
var parse_url=/^(?:([A-Za-z]+):)?(\/{0,3})([0-9.\-A-Za-z]+)(?::(\d+))?(?:\/([^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/;
var url="http://www.ora.com:80/goodparts?q#fragment";
var result=parse_url.exec(url);
//第八章:方法，92页
//1.Array:array.contact()、array.join()、array.pop()、array.push()、array.reverse()、array.shift()
//array.slice()[浅复制]、array.sort()[小心]、array.splice()[删除]
//第九章:代码风格，108页
//第十章:优美的特性，112页，js的一些特性是很不稳定的，必须谨慎
//附录A,116页
//A.1全局变量：尽量避免全部变量污染，例如var
//A.2块级作用域:大多数类c的语言都支持变量的块级作用域，因此建议变量在第一次使用时声明，
// 但js不支持这一特性，因此建议在函数开头声明变量
//A.3自动插入分号:js解析时可以在忘记分号的地方自动插入分号，但有些分号不一定就是开发者相要的！
//A.4保留字、A.5 Unicode、A.6 typeof、A.7 parseInt()、A.8 +、A.9浮点数
//A10 NaN用isNaN()检测而不是===NaN
//B.1 ===和!== ==和!=,建议使用===
//B.4 Continue，不用continue性能会好点
//附录E:JSON,150页