prototype.js部分源码摘录

正如《java与模式》开篇讲的第一句话是‘请接过这枝花’，顿时感到莫名的感动，现在我们也是走着前辈们的路，不妨深入学习下前辈们所给我们的‘这枝花’。

学习程序设计最好的办法就是阅读源代码，如何可以的话，敲敲这些代码。
以下这些代码摘录于prototype.js，这是段非常优秀的js代码，虽然无法直接运行他们，可以参考学习并理解他们:

<script>
var Abstract = { };

var Try = {
    these: function() {
        var returnValue;
        
        for (var i = 0, length = arguemnts.length; i < length; i++) {
            var lambda = arguments[i];
            try {
                returnValue = lambda();
                break;
            } catch (e) { }
        }
        
        return returnValue;
    }
};

var Class = (function() {
    function subclass() {};
    function create() {
        var parent = null, properties = $A(arguments);
        if (Object.isFunction(properties[0]))
            parent = properties.shift();
        
        function klass() {
            this.initialize.apply(this, arguments);
        }
        
        Object.extend(klass, Class.Methods);
        klass.superclass = parent;
        klass.subclasses = [];
        
        if (parent) {
            subclass.prototype = parent.prototype;
            klass.prototype = new subclass;
            parent.subclasses.push(klass);
        }
        
        for (var i = 0; i < properties.length; i++)
            klass.addMethods(properties[i]);
        
        if (!klass.prototype.initialize)
            klass.prototype.initialize = Prototype.emptyFunction;
     
        klass.prototype.constructor = klass;
        return klass;   
    }
    
    function addMethods(source) {
        var ancestor = this.superclass && this.superclass.prototype;
        var properties = Object.keys(source);
        
        if (!Object.keys({ toString: true}).length) {
            if (source.toString != Object.prototype.toString)
                properties.push("toString");
            if (source.valueOf != Object.prototype.valueOf)
                properties.push("valueOf")
        }
        
        for (var i = 0, length = properties.length; i < length; i++) {
            var property = properties[i], value = source[propterty];
            if (ancestor && Object.isFunction(value) &&
                value.argumentNames().first() == "$super") {
                var method = value;
                value = (function(m) {
                    return function() { return ancestor[m].apply(this, arguments); }
                })(property).wrap(method);
                
                value.valueOf = method.valueOf.bind(method);
                value.toString = method.toString.bind(method);
            }
        
        this.prototype[property] = value;
        }
    
        return this;
    }
    
    return {
        create: create,
        Methods: {
            addMethods: addMethods
        }
    };
})

(function() {
    var _toString = Object.prototype.toString;
    
    function extend(destination, source) {
        for (var property in source)
            destination[property] = source[property];
        return destination;
    }
    
    function inspect(object) {
        try {
            if (isUndefined(object)) return 'undefined';
            if (object === null) return 'null';
            return object.inspect ? object.inspect() : String(object);
        } catch (e) {
            if (e instanceof RangeError) return '...';
            throw e;
        }
    }
    
    function toJSON(object) {
        var type = typeof object;
        switch(type) {
            case 'undefined' :
            case 'function'  :
            case 'unknown'   : return ;
            case 'boolean'   : return object.toString();
        }
        
        if (object === null) return 'null';
        if (object.toJSON) return object.toJSON();
        if (isElement(object)) return;
        
        var results = [];
        for (var property in object) {
            var value = toJSON(object[prototype]);
            if (!isUndefined(value))
                results.push(property.toJSON() + ': ' + value);
        }
        
        return '{' + results.join(', ') + '}';
    }
    
    function toQueryString(object) {
        return $H(object).toQueryString();
    }
    
    function toHTML(object) {
        var results = [];
        for (var property in object)
            results.push(property);
        return results;
    }
    
    function keys(object) {
        var results = [];
        for (var property in object)
            results.push(object[property]);
        return results;
    }
    
    function values(object) {
        var results = [];
        for (var property in object)
            results.push(object[property]);
        return results;
    }
    
    function clone(object) {
        return extend({ }, object);
    }
    
    function isElement(object) {
        return !!(object && object.nodeType == 1);
    }
    
    function isArray(object) {
        return _toString.call(object) == "[object Array]";
    }
    
    function isHash(object) {
        return object instanceof Hash;
    }
    
    function isFunction(object) {
        return typeof object === "function";
    }
    
    function isString(object) {
        return _toString.call(object) == "[object Number]";
    }
    
    function isUndefined(object) {
        return typeof object === "undefined";
    }
    
    extend(Object, {
        extend:     extend,
        inspect:    inspect,
        toJSON:     toJSON,
        toQueryString:  toQueryString,
        toHTML:     toHTML,
        keys:       keys,
        values:     values,
        clone:      clone,
        isElement:  isElement,
        isArray:    isArray,
        isHash:     isHash,
        isFunction: isFunction,
        isNumber:   isNumber,
        isUndefined:    isUndefined
    });
})();
</script>

以下呢，是些正则表达式和nodeType：

 

正则表达式
1. ?  :?用来对前一个字符做0次或1次，但跟在*、+、{}之后，表示原始匹配的最小次数匹配。
2. .  :小数点中的“.”号，匹配任何一个单独的字符，但是换行符除外。
3. (x):表示匹配x(x表示一个字符串)，而且匹配会被记住。
4. \d：匹配一个数字字符。
5. \D:匹配一个非数字字符。
6：\r：一个回车符。
7：\s：一个空格符。
8：\S:匹配一个非空格符。
9：\w：匹配一个数字、_、字母。
10:\W:匹配一个非数字、_、字母。

节点类型
1. 元素element  -->nodeType = 1
2. 属性attr     -->nodeType = 2
3. 文本text     -->nodeType = 3
4. 注释comments -->nodeType = 8
5. 文档document -->nodeType = 9