《JavaScript语言精粹》笔记

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(‘&lt;&quot;&gt;‘.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页

时间: 10-23

《JavaScript语言精粹》笔记的相关文章

javascript语言精粹----笔记【转载】

javascript语言精粹----笔记 1.6种值会为假(==false),分别是false,null,undefined,' ',0,NaN 2.typeof有6种值,分别是'number','string','boolean','undefined','function','object';其中typeof(null),结果是'object' 3.number类型总是64位浮点数,两个整数相除也可能出现非整数结果 4.如果第一个运算数的值为假,那么运算符&&产生它的第一个运算数的值.

JavaScript语言精粹笔记

JavaScript语言精粹笔记 掌握语言的每个特性可以让你出风头,但是并不推荐,因为一部分的特性带来的麻烦可能远超本身的价值.正如书中所言,坏的材料并不能雕刻出好的作品,要成为一名更好的程序员,要取其精华去其糟粕.当你知道要做什么的时候,它还能表现的更好,编程时一件相对困难的事情,绝不应该在懵懂的状态下开始编程之旅. JS中的注意为//或者/*content*/,注释一定要精确地描述代码,不然没有用的注释比没有注释更糟糕. JS中的代码块不会创建新的作用域,因此变量应该被定义在函数的头部,而不

javascript 语言精粹 笔记推荐。。

http://www.cnblogs.com/Cohlint/archive/2012/11/26/2788790.html 这篇javascript 语言精粹 学习笔记不错..不过看上去就是读书笔记,没有深入研究某个点..比如闭包..我还是不懂噢.. 比如17条:“add_the_handles 函数目的是给每个时间处理器一个唯一值(i).它未能达到目的是因为事件处理器函数绑定了变量i,而不是函数在构造时的变量i的值.” 这是原书的翻译过来的理解,但是感觉还是很艰涩,不太理解. 闭包这个变量作

JavaScript语言精粹 笔记01

内容比较简单,只是从头梳理一下JS的知识 语法空白标识符数字字符串语句 对象对象字面量检索更新引用原型反射枚举删除减少全局变量污染  语法 1 空白 空白可能表现为格式化字符或注释的形式.空白通常没有意义,但是偶尔必须用它来分割字符序列,否则它们就会被合并成一个单一的符号.例如: var that = this; var 和that之间的空格是不能去掉的,其他的空格都可以被移除. JS提供两种注释: /* */ // 建议使用//,因为/* */中要注释的内容可能包括字符 */ 而报错,例如:

JavaScript语言精粹 笔记03

继承伪类对象说明符原型函数化部件 继承 JS不是基于类的,而是基于原型的,这意味着对象直接从其他对象继承. 1 伪类 JS提供了一套丰富的代码重用模式,它可以模拟那些基于类的模式,因为JS实际上没有类,所以把模拟的类称为伪类.我们可以定义一个构造器并扩充它的原型: var Mammal = function (name) { this.name = name; }; Mammal.prototype.get_name = function ( ) { return this.name; }; M

JavaScript语言精粹 笔记02

函数函数对象函数字面量调用参数返回异常给类型增加方法递归作用域闭包回调模块级联套用记忆   函数 1 函数对象 在JS中函数就是对象.对象是“名/值”对的集合并拥有一个连接到原型对象的隐藏连接.对象字面量产生的对象连接到Object.prototype.函数对象连接到Function.prototype(该原型本身连接到Object.prototype).每个函数在创建时附有两个附加的隐藏属性:函数上下文和实现函数行为的代码. 因为函数是对象,所以它可以像任何其他的值一样被使用.函数可以存放在变

JavaScript语言精粹 笔记06 方法

JS包含了少量可用在标准类型上的标准方法. ArrayFunctionNumberObjectRegExpString Array array.concat(item...) concat方法返回一个新数组,它包含array的浅复制并将1个或多个参数item附加在其后.如果参数item是一个数组,那么他的每个元素会被本别添加. var a = ['a', 'b', 'c']; var b = ['x', 'y', 'z']; var c = a.concat(b, true); // c 是 [

JavaScript语言精粹 笔记05 正则表达式

正则表达式 正则表达式以方法的形式被用于对字符串中的信息进行查找.替换画图提取操作.可处理正则表达式的方法有:regexp.exec, regexp.test,string.match, string.replace, string.search, 和string.split. 结构 有两个方法来创建一个RegExp对象.优先方法是使用正则表达式字面量.正则表达式被包围在一对斜杠中.有3个标志能在RegExp中设置,分别为g.i.m. // 构造一个匹配JavaScript字符串的正则表达式对象

JavaScript语言精粹 笔记04 数组

数组1 数组字面量2 长度3 删除4 列举5 混淆的地方6 方法7 维度 数组1 数组字面量 var empty = []; var numbers = [ 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine' ]; empty[1] // undefined numbers[1] // 'one' empty.length // 0 numbers.length // 10 数组字面量可以出

JavaScript语言精粹读书笔记- JavaScript对象

JavaScript 对象 除了数字.字符串.布尔值.null.undefined(都不可变)这5种简单类型,其他都是对象. JavaScript中的对象是可变的键控集合(keyed collections). 对象是属性的容器,其中每个属性都拥有名字和值. JavaScript中的对象是无类别的(class-free)的.它对新属性的名字和值没有约束. JavaScript包括一个原型链特性,允许对象继承另一对象的属性. 对象的检索: stooge[“first-name”]或者stooge.