Ruby's Louvre

每天学习一点点算法

导航

统计

我的MVVM框架 v2发布

此版本仍然有许多knouckoutjs的影子,其中最下方那个normalizeJSON直接抄自knouckoutjs,我深感内疚。

knouckoutjs的声明式绑定的值部分是非常复杂,它允许用户直接在里面使用函数,表达式什么,然后再往它两边花括号一包就是一个JSON的字面量。但直接转换为JSON是不行的,IE对键名为关键字的对象肯定报错,必须要用双引号括起。于是才有了normalizeJSON这东西。另一方面,knouckoutjs为VM的每个字段建立关联的方式非常复杂冗长,大量使用闭包。这个我的MVVM框架avalon做了改进。我非常讨厌knouckoutjs的事件绑定方式,那还不如直接用onclick=xxx绑好了,或结合jQuery, mass Framework能得到更大的回报。不过在v2中,我还没有想到更好的方法,既不跟风照搬,也没有搞出相应方案,因此事件绑定部分是一片空白。

说说avalon v2的优点吧。只有730行,非常精简,虽然建立在功能残缺的基础上,没有knouckoutjs的虚拟结点,没有事件绑定,没有options绑定。

双向绑定链的许多概念已经成形。我们做一件事,要做好,就要知道怎么去做,什么分步做。这些步骤,其中细节,全部都要抽象成特定的术语才能指导我们行动。knouckoutjs之所以能在前端MVC拥有一席之地,是因为它确定了许多以后被大家抄袭的东西。knouckout的三大理论基石:

  • 位于VM中的监控属性, 监控数组, 依赖监控属性。
  • 位于视图中的声明式绑定,以data-bind的形式写在标签中。
  • 位于视图中的动态模板,就是那些被声明式绑定圈起来的区域。

avalon也建立对应的概念来指导自己的发展:

  • 位于VM中的原子监控者,依赖监控者,监控数组与绑定监控者。原子监控者对应ko的监控属性,它是由M中字段抽象而成,是一个函数。依赖监控者对应ko的依赖监控属性。在VM中,有些字段是建立在M的两个或多个字段的基础上。比如fullName 对应为 firstName+" "+lastName,但在M中是找不到它的跟影,但它在视图中却又是一个独立的个体,有专门的文本域给它。绑定监控者是我独创的,它是根据视图中的数据绑定转化而为,在ko中这些依然称之为依赖监控属性。但这一类监控函数分明是真正用于连结DOM树与VM的。它通过框架提供的默认绑定器将自己中数据渲染到DOM中。它的结构比一般的依赖监控属性复杂多了。依赖监控属性,knouckoutjs称之为Dependent Observables,在另一个著名的emberjs框架中,它叫做computed。在绑定监控者这类东西显然不需要返回值,它一般将比它低一级的原子监控者,依赖监控者当作事件回调来监控用户行为就行了。当用户改变了文本域的值,就相当于对这个原子监控者进行写入,从而引发整条依赖的更新。绑定监控者是与DOM树某个节点或某一些节点交道,当底层涌上来的变动要求它也刷新时,它就调用框架自带的绑定器进行干活。因此你看到绑定器都有一个叫update的函数,就是干这事。
  • 位于视图中的声明式绑定,我使用bind,但也可以配置你喜欢的属性名。我个人喜欢称之为数据绑定,其实它还兼容流程控制,事件绑定的活儿。
  • 位于视图中的动态模板,就是那些被声明式绑定圈起来的区域。动态模板与流程绑定最密切,它的实现好坏,牵及到最小化刷新的实现与内存的占有率。这个v2有实现比knouckout要高明多了。

avalon在数据绑定上做了许多友好的改进,虽然与knouckoutjs一样支持表达式,是没有花括号的JSON。但它要求用户不用写双引号,这辛苦活由框架去实现了。

avalon的自带绑定器有text绑定,html绑定,value绑定,class绑定,style绑定,attr绑定,display绑定,checked绑定,with绑定,if绑定,unless绑定,foreach绑定

有关它们的使用,可以查看这里

不过大家也急着看它们是怎么用的,因为写这文章时,我已经完成非常先进的v3了。这世界就是这样,当日本把小灵通卖给中国时,人家已经普及下下一代的方案。另一更让人心痛的比喻时,当中国在炫耀那垃圾的J10时,美国早在几十年前把飞碟,水上飞机,鸭嘴机玩一遍了。这就是差距。比差距更可怕的是知识的断层。面试时有人问我既然Sizzle这么快了,为什么还要自己写个?这说得那啥的,人家兜里有一百万跟我屁事啊!反正,我是搞出选择器,加载器,动画引擎,异步列队,操作流等东西出来。知识体系,至少是在前端的应用层是完整的。MVVM是前端究极解决方案。从 v1到v2,起码我算是逐渐吃透相关概念,形成自己的解决方案。这个对于后来想进入这领域的国人来说,也留下一点带路石。

define("avalon",["$attr","$event"], function(){
    $.log("已加载avalon v2", 7);
    var BINDING = $.config.bindname || "bind", bridge = {}, uuid = 0, expando = new Date - 0;
    //将一个普通的对象转换为ViewModel,ViewModel里面每个对象都是监控者(监控函数或监控数组)
    $.ViewModel = function(data, model){
        model = model || {};
        if(Array.isArray(data)){
            return listWatch(data);
        }
        for(var p in data) {
            if(data.hasOwnProperty(p)) {
                addWatchs(p, data[p], model);
            }
        }
        return model;
    }
    //监控数组,listWatch,它实质上就是一个数组,不过它的许多方法都被覆写了,
    //以便与DOM实现同步在您添加、删除、移动、刷新或替换数组中的项目时触发对应元素的局部刷新
    //我们可以在页面通过foreach绑定此对象
    function listWatch(array, models){
        models = models || [];
        for(var index = 0; index < array.length; index++){
            var f =  addWatchs(index, array[index], models);
            f.$value = f.$value || f;
        }
        String("push,pop,shift,unshift,splice,sort,reverse").replace($.rword, function(method){
            var nativeMethod = models[ method ];
            models[ method ] = function(){
                nativeMethod.apply( models, arguments)
                var Watchs = models["$"+expando];
                for(var i = 0, Watch; Watch = Watchs[i++];){
                    Watch(method, arguments);
                }
            }
        });
        models.removeAt = function(index){//移除指定索引上的元素
            models.splice(index, 1);
        }
        models.remove = function(item){//移除第一个等于给定值的元素
            var array = models.map(function(el){
                return el();
            })
            var index = array.indexOf(item);
            models.removeAt(index);
        }
        //模拟监控函数的行为,监控函数在foreach都会生成一个$value函数
        models.$value = function(){
            return models
        }
        models.$value.$uuid = ++uuid;
        return models;
    }
    //将ViewMode绑定到元素节点上,没有指定默认是绑在body上
    $.View = function(model, node){
        node = node || document.body;
        //开始在其自身与孩子中绑定
        return setBindingsToElementAndChildren.call( node, model );
    }
    //我们根据用户提供的最初普通对象的键值,选用不同的方式转换成各种监控函数或监控数组
    var err = new Error("只能是字符串,数值,布尔,Null,Undefined,函数以及纯净的对象")
    function addWatchs( key, val, model ){
        switch( $.type( val )){
            case "Null":
            case "Undefined":
            case "String":
            case "Number":
            case "Boolean":
                return atomWatch( key, val, model );
            case "Function":
                return depsWatch( key, val, model, "get");
            case "Array":
                var models = model[key] || (model[key] = []);
                return listWatch( val, models );
            case "Object":
                if($.isPlainObject( val )){
                    if( $.isFunction( val.setter ) && $.isFunction( val.getter )){
                        return  depsWatch( key, val, model, "setget");
                    }else{
                        var object = model[key] || (model[key] = {});
                        $.ViewModel( val,object );
                        object.$value = function(){
                            return object
                        }
                        return object
                    }
                }else{
                    throw err
                }
                break;
            default:
                throw err
        }
    }

    //atomWatch,原子监控者,它是最简单的监控函数,是指在ViewModel定义时,键值为基础类型的个体
    //它们是位于双向依赖链的最底层。不需要依赖于其他Watch!
    function atomWatch( key, val, host ){
        function Watch( neo ){
            if( bridge[ expando ] ){ //收集依赖于它的depsWatch,以便它的值改变时,通它们更新自身
                $.Array.ensure( Watch.$deps, bridge[ expando ] );
            }
            if( arguments.length ){//在传参不等于已有值时,才更新自已,并通知其的依赖
                if( Watch.$val !== neo ){
                    Watch.$val = neo;
                    updateDeps( Watch );
                }
            }
            return Watch.$val;
        }
        Watch.$val = val;
        Watch.$uuid = ++uuid
        return addWatch( key, Watch, host );
    }

    //depsWatch,依赖监控者,是指在ViewModel定义时,值为类型为函数,或为一个拥有setter、getter函数的对象。
    //它们是位于双向绑定链的中间层,需要依赖于其他atomWatch或depsWatch的返回值计算自己的value。
    //当顶层的VM改变了,通知底层的改变
    //当底层的VM改变了,通知顶层的改变
    //当中间层的VM改变,通知两端的改变
    function depsWatch( key, val,host, type){
        var getter, setter//构建一个至少拥有getter,scope属性的对象
        if(type == "get"){//getter必然存在
            getter = val;
        }else if(type == "setget"){
            getter = val.getter;
            setter = val.setter;
            host = val.scope || host;
        }
        function Watch( neo ){
            if( bridge[ expando ] ){
                //收集依赖于它的depsWatch与bindWatch,以便它的值改变时,通知它们更新自身
                $.Array.ensure( Watch.$deps, bridge[ expando ] );
            }
            var change = false;
            if( arguments.length ){//写入新值
                if( setter ){
                    setter.apply( host, arguments );
                }
            }else{
                if( !("$val" in Watch) ){
                    if( !Watch.$uuid ){
                        bridge[ expando ] = Watch;
                        Watch.$uuid = ++uuid;
                    }
                    neo = getter.call( host );
                    change = true;
                    delete bridge[ expando ];
                }
            }
            //放到这里是为了当是最底层的域的值发出改变后,当前域跟着改变,然后再触发更高层的域
            if( change && (Watch.$val !== neo) ){
                Watch.$val = neo;
                //通知此域的所有直接依赖者更新自身
                updateDeps( Watch );
            }
            return Watch.$val;
        }
        return addWatch( key, Watch, host );
    }
    //bindWatch,绑定监控者,用于DOM树或节点打交道的Watch,它们仅在用户调用了$.View(viewmodel, node ),
    //把写在元素节点上的bind属性的分解出来之时生成的。
    //names values 包含上一级的键名与值
    function bindWatch (node, names, values, key, str, binding, model ){
        function Watch( neo ){
            if( !Watch.$uuid ){ //只有在第一次执行它时才进入此分支
                if( key == "foreach" ){
                    var arr = model[str]
                    var p = arr["$"+expando] || ( arr[ "$"+ expando] =  [] );
                    $.Array.ensure( p ,Watch);
                    arguments = ["start"];
                }
                bridge[ expando ] = Watch;
            }
            var callback, val;
            try{
                val = Function(names, "return "+ str).apply(null, values );
            }catch(e){
                return  $.log(e, 3)
            }
            if(typeof val == "function" ){ //&& isFinite( val.$uuid ) 如果返回值也是个域
                callback = val; //这里的域为它所依赖的域
                val = callback();//如果是监控体
            }
            if( !Watch.$uuid ){
                delete bridge[ expando ];
                Watch.$uuid = ++uuid;
                //第四个参数供流程绑定使用
                binding.init && binding.init(node, val, callback, Watch);
            }
            var method = arguments[0], args = arguments[1]
            if( typeof binding[method] == "function" ){
                //处理foreach.start, sort, reserve, unshift, shift, pop, push....
                var ret = binding[method]( Watch, val, Watch.fragments, method, args );
                if(ret){
                    val = ret;
                }
            }
            //只有执行到这里才知道要不要中断往下渲染
            binding.update(node, val, Watch, model, names, values);
            return Watch.$val = val;
        }
        return addWatch( "interacted" ,Watch, node);
    }
    //执行绑定在元素标签内的各种指令
    //MVVM不代表什么很炫的视觉效果之类的,它只是组织你代码的一种方式。有方便后期维护,松耦合等等优点而已
    var inputOne = $.oneObject("text,password,textarea,tel,url,search,number,month,email,datetime,week,datetime-local")
    $.ViewBindings = {
        text: {
            update:  function( node, val ){
                val = val == null ? "" : val+""
                if(node.childNodes.length === 1 && node.firstChild.nodeType == 3){
                    node.firstChild.data = val;
                }else{
                    $( node ).text( val );
                }
            }
        },
        value:{
            init: function(node, val, Watch){
                if(/input|textarea/i.test(node.nodeName) && inputOne[node.type]){
                    $(node).on("input",function(){
                        Watch(node.value)
                    });
                }
            },
            update:  function( node, val ){
                node.value = val;
            }
        },
        html: {
            update:  function( node, val ){
                $( node ).html( val );
            },
            stopBindings: true
        },
        //通过display样式控制显隐
        display: {
            update:  function( node, val ){
                node.style.display = val ? "" : "none";
            }
        },
        enable: {
            update:  function( node, val ){
                if (val && node.disabled)
                    node.removeAttribute("disabled");
                else if ((!val) && (!node.disabled))
                    node.disabled = true;
            }
        },
        style: {
            update:  function( node, val ){
                var style = node.style, styleName;
                for (var name in val) {
                    styleName = $.cssName(name, style) || name;
                    style[styleName] = val[ name ] || "";
                }
            }
        },
        "class": {
            update:  function( node, val ){
                if (typeof val == "object") {
                    for (var className in val) {
                        var shouldHaveClass = val[className];
                        toggleClass(node, className, shouldHaveClass);
                    }
                } else {
                    val = String(val || '');
                    toggleClass(node, val, true);
                }
            }
        } ,
        attr: {
            update:  function( node, val ){
                for (var name in val) {
                    $.attr(node, name, val[ name ] );
                }
            }
        },
        checked: {
            init:  function( node, val, Watch ){
                if(typeof Watch !== "function"){
                    throw new Error("check的值必须是一个Feild")
                }
                $(node).bind("change",function(){
                    Watch(node.checked);
                });
            },
            update:function( node, val ){
                if ( node.type == "checkbox" ) {
                    if (Array.isArray( val )) {
                        node.checked = val.indexOf(node.value) >= 0;
                    } else {
                        node.checked = val;
                    }
                } else if (node.type == "radio") {
                    node.checked = ( node.value == val );
                }
            }
        },
        template: {
            //它暂时只供内部使用
            update: function( node, val, callback, model, names, values){
                var transfer = callback(), code = transfer[0], Watch = transfer[1];
                var fragment = Watch.fragments[0];         //取得原始模板
                if( code > 0 ){                            //处理with if 绑定
                    fragment.recover();                    //将Watch所引用着的节点移出DOM树
                    var elems = getChildren( fragment );   //取得它们当中的元素节点
                    node.appendChild( fragment );          //将Watch所引用着的节点放回DOM树
                    if( elems.length ){
                        if( code == 2 ){                    //处理with 绑定
                            model = transfer[2]
                        }
                        return setBindingsToChildren.call( elems, model, true, names, values )
                    }
                }else if( code === 0 ){                    //处理unless 绑定
                    fragment.recover();
                }
                if( code < 0  && val ){                    //处理foreach 绑定
                    var fragments = Watch.fragments, models = val;
                    if(!models.length){
                         fragments[0].recover();
                         return
                    }
                    for( var i = 0, el ; el = fragments[i]; i++){
                        el.recover();                      //先回收,以防在unshift时,新添加的节点就插入在后面
                        elems = getChildren( el );
                        node.appendChild( el );            //继续往元素的子节点绑定数据
                        setBindingsToChildren.call( elems, models[i], true, names, values );
                    }
                }
            },
            stopBindings: true
        }
    }
    $.ViewBindings.disable = {
        update: function( node, val ){
            $.ViewBindings.enable.update(node, !val);
        }
    }
    //if unless with foreach四种bindings都是基于template bindings
    "if,unless,with,foreach,case".replace($.rword, function( type ){
        $.ViewBindings[ type ] = {
            init: function(node, _, _, Watch){
                node.normalize();                  //合并文本节点数
                var fragment = node.ownerDocument.createDocumentFragment(), el
                while((el = node.firstChild)){
                    fragment.appendChild(el);     //将node中的所有节点移出DOM树
                }
                Watch.fragments = [];             //添加一个数组属性,用于储存经过改造的文档碎片
                Watch.fragment = fragment;         //最初的文档碎片,用于克隆
                Watch.cloneFragment = function( dom, unshift ){ //改造文档碎片并放入数组
                    dom = dom || Watch.fragment.cloneNode(true);
                    var add = unshift == true ? "unshift" : "push"
                    Watch.fragments[add]( patchFragment(dom) );
                    return dom;
                }
                var clone = Watch.cloneFragment();  //先改造一翻,方便在update时调用recover方法
                node.appendChild( clone );          //将文档碎片中的节点放回DOM树
            },
            update : function(node, val, Watch, model, names, values){
                $.ViewBindings['template']['update'](node, val, function(){
                    switch(type){//返回结果可能为 -1 0 1 2
                        case "if":
                            return [ !!val - 0, Watch];//1 if
                        case "unless":
                            return [!val - 0, Watch]; //0  unless
                        case "with":
                            return [2, Watch, val];   //2  with
                        default:
                            return [-1, Watch];       //-1 foreach
                    }
                }, model, names, values);
            },
            stopBindings: true
        }
    });
    //foreach绑定拥有大量的子方法,用于同步数据的增删改查与排序
    var foreach = $.ViewBindings.foreach;
    foreach.start = function( Watch, models, fragments, method, args ){
        if(!Array.isArray(models)){
            var array = []
            for(var key in models){
                //通过这里模拟数组行为
                if(models.hasOwnProperty(key) && (key !== "$value") && (key != "$"+expando)){
                    var value = models[key];
                    value.$value = value;
                    array.push( value );
                }
            }
            models = array
        }
        for(var i = 1; i < models.length; i++ ){
            Watch.cloneFragment();
        }
        return models
    };
    //push ok
    foreach.push = function( Watch, models, fragments, method, args ){
        var l = fragments.length
        for(var index = 0; index < args.length; index++ ){
            var n = index + l;
            var f =  addWatchs(n, models[n], models);
            f.$value = f;
            Watch.cloneFragment()
        }
    }
    //unshift ok
    foreach.unshift = function( Watch, models, fragments, method, args ){
        for(var index = 0; index < args.length; index++ ){
            var f =  addWatchs(index, models[index], models);
            f.$value = f;
            Watch.cloneFragment(0, true)
        }
        for( index = 0; index < models.length; index++ ){
            models[index].$key = index
        }
    }
    // shift pop ok
    foreach.shift = function( Watch, models, fragments, method, args ){
        var fragment = fragments[method]()
        fragment.recover();
        for(var index = 0; index < models.length; index++ ){
            models[index].$key = index
        }
    }
    foreach.pop = foreach.shift;
    foreach.splice = function( Watch, models, fragments, method, args ){
        var start = args[0], n = args.length - 2;
        var removes = fragments.splice(start, args[1]);
        //移除对应的文档碎片
        for(var i = 0; i < removes.length; i++){
            removes[i].recover();
        }
        for(i = 0; i < n; i++ ){
            //将新数据封装成域
            var index = start + i
            var f =  addWatchs(index, models[ index ], models);
            f.$value = f;
            //为这些新数据创建对应的文档碎片
            var dom = Watch.fragment.cloneNode(true);
            Watch.fragments.splice(index, 0, patchFragment(dom) );
        }
        for( index = start+n; index < models.length; index++ ){
            models[index].$key = index
        }
    }
    //对文档碎片进行改造,通过nodes属性取得所有子节点的引用,以方便把它们一并移出DOM树或插入DOM树
    function patchFragment( fragment ){
        fragment.nodes = $.slice( fragment.childNodes );
        fragment.recover = function(){
            this.nodes.forEach(function( el ){
                this.appendChild(el)
            },this);
        }
        return fragment;
    }
    //$.ViewBindings.class的辅助方法
    var toggleClass = function (node, className, shouldHaveClass) {
        var classes = (node.className || "").split(/\s+/);
        var hasClass = classes.indexOf( className) >= 0;//原className是否有这东西
        if (shouldHaveClass && !hasClass) {
            node.className += (classes[0] ? " " : "") + className;
        } else if (hasClass && !shouldHaveClass) {
            var newClassName = "";
            for (var i = 0; i < classes.length; i++)
                if (classes[i] != className)
                    newClassName += classes[i] + " ";
            node.className = newClassName.trim();
        }
    }


    //为当前元素把数据隐藏与视图模块绑定在一块
    //参数分别为model, pnames, pvalues
    $.fn.model = function(){
        return $._data(this[0], "$model")
    }
    $.fn.$value = function(){
        var watch = $(this).model()
        if(typeof watch == "function"){
            return watch();
        }
    }
    //取得标签内的属性绑定,然后构建成bindWatch,并与ViewModel关联在一块
    function setBindingsToElement( model, pnames, pvalues ){
        var node = this;
        pnames = pnames || [];
        pvalues = pvalues || [];
        var attr = node.getAttribute( BINDING ), names = [], values = [], continueBindings = true,
        key, val, binding;
        $._data(node,"$model",model);
        for(var name in model){
            if(model.hasOwnProperty(name)){
                names.push( name );
                values.push( model[ name ] );
            }
        }
        if(pnames.length){
            pnames.forEach(function(name, i){
                if(names.indexOf(name) === -1){
                    names.push(name);
                    values.push(pvalues[i])
                }
            })
        }
        var array = normalizeJSON("{"+ attr+"}",true);
        for(var i = 0; i < array.length; i += 2){
            key = array[i]
            val = array[i+1];
            binding = $.ViewBindings[ key ];
            if( binding ){
                if( binding.stopBindings ){
                    continueBindings = false;
                }
                if(key == "foreach" && Array.isArray(model[key]) && !model[key].length ){
                    continueBindings = false;
                  //  continue
                }
                bindWatch(node, names, values, key, val, binding, model);
            }
        }
        return continueBindings;
    }
    //在元素及其后代中将数据隐藏与viewModel关联在一起
    //参数分别为model, pnames, pvalues
    function setBindingsToElementAndChildren(){
        if ( this.nodeType === 1  ){
            var continueBindings = true;
            if( hasBindings( this ) ){
                continueBindings = setBindingsToElement.apply(this, arguments);
            }
            if( continueBindings ){
                var elems = getChildren( this );
                elems.length && setBindingsToChildren.apply(elems, arguments);
            }
        }
    }
    //参数分别为model, pnames, pvalues
    function setBindingsToChildren( ){
        for(var i = 0, n = this.length; i < n ; i++){
            setBindingsToElementAndChildren.apply( this[i], arguments );
        }
    }
    //通知此监控函数或数组的所有直接依赖者更新自身
    function updateDeps(Watch){
        var list = Watch.$deps || [] ;
        if( list.length ){
            var safelist = list.concat();
            for(var i = 0, el; el = safelist[i++];){
                delete el.$val;
                el()
            }
        }
    }
    //判定是否设置数据绑定的标记
    function hasBindings( node ){
        var str = node.getAttribute( BINDING );
        return typeof str === "string" && str.indexOf(":") > 1
    }
    //取得元素的所有子元素节点
    function getChildren( node ){
        var elems = [] ,ri = 0;
        for (node = node.firstChild; node; node = node.nextSibling){
            if (node.nodeType === 1){
                elems[ri++] = node;
            }
        }
        return elems;
    }
    //为监控函数添加更多必须的方法或属性
    function addWatch( key, Watch, host ){
        //收集依赖于它的depsWatch与bindWatch,以便它的值改变时,通知它们更新自身
        Watch.toString = Watch.valueOf = function(){
            if( bridge[ expando ] ){
                $.Array.ensure( Watch.$deps, bridge[ expando ] );
            }
            return Watch.$val
        }
        if(!host.nodeType){
            Watch.$key = key;
            host[ key ] = Watch;
        }
        Watch.$deps = [];
        Watch();
        return Watch;
    }
    //============================================================
    // 将bindings变成一个对象或一个数组 by 司徒正美
    //============================================================
    function normalizeJSON(json, array){
        var keyValueArray = parseObjectLiteral(json),resultStrings = [],keyValueEntry;
        for (var i = 0; keyValueEntry = keyValueArray[i]; i++) {
            if (resultStrings.length > 0 && !array)
                resultStrings.push(",");
            if (keyValueEntry['key']) {
                var key = keyValueEntry['key'].trim();
                var quotedKey = ensureQuoted(key, array), val = keyValueEntry['value'].trim();
                resultStrings.push(quotedKey);
                if(!array)
                    resultStrings.push(":");
                if(val.charAt(0) == "{" && val.charAt(val.length - 1) == "}"){
                    val = normalizeJSON( val );//逐层加引号
                }
                resultStrings.push(val);
            } else if (keyValueEntry['unknown']) {
                resultStrings.push(keyValueEntry['unknown']);//基于跑到这里就是出错了
            }
        }
        if(array){
            return resultStrings
        }
        resultStrings = resultStrings.join("");
        return "{" +resultStrings +"}";
    };
    //============================================================
    // normalizeJSON的辅助函数 by 司徒正美
    //============================================================
    var restoreCapturedTokensRegex = /\@mass_token_(\d+)\@/g;
    function restoreTokens(string, tokens) {
        var prevValue = null;
        while (string != prevValue) { //把原字符串放回占位符的位置之上
            prevValue = string;
            string = string.replace(restoreCapturedTokensRegex, function (match, tokenIndex) {
                return tokens[tokenIndex];
            });
        }
        return string;
    }
    function parseObjectLiteral(objectLiteralString) {
        var str = objectLiteralString.trim();
        if (str.length < 3)
            return [];
        if (str.charAt(0) === "{")// 去掉最开始{与最后的}
            str = str.substring(1, str.length - 1);
        // 首先用占位符把字段中的字符串与正则处理掉
        var tokens = [];
        var tokenStart = null, tokenEndChar;
        for (var position = 0; position < str.length; position++) {
            var c = str.charAt(position);//IE6字符串不支持[],开始一个个字符分析
            if (tokenStart === null) {
                switch (c) {
                    case '"':
                    case "'":
                    case "/":
                        tokenStart = position;//索引
                        tokenEndChar = c;//值
                        break;
                }//如果再次找到一个与tokenEndChar相同的字符,并且此字符前面不是转义符
            } else if ((c == tokenEndChar) && (str.charAt(position - 1) !== "\\")) {
                var token = str.substring(tokenStart, position + 1);
                tokens.push(token);
                var replacement = "@mass_token_" + (tokens.length - 1) + "@";//对应的占位符
                str = str.substring(0, tokenStart) + replacement + str.substring(position + 1);
                position -= (token.length - replacement.length);
                tokenStart = null;
            }
        }
        // 将{},[],()等括起来的部分全部用占位符代替
        tokenEndChar = tokenStart = null;
        var tokenDepth = 0, tokenStartChar = null;
        for (position = 0; position < str.length; position++) {
            var c = str.charAt(position);
            if (tokenStart === null) {
                switch (c) {
                    case "{":
                        tokenStart = position;
                        tokenStartChar = c;
                        tokenEndChar = "}";
                        break;
                    case "(":
                        tokenStart = position;
                        tokenStartChar = c;
                        tokenEndChar = ")";
                        break;
                    case "[":
                        tokenStart = position;
                        tokenStartChar = c;
                        tokenEndChar = "]";
                        break;
                }
            }
            if (c === tokenStartChar)
                tokenDepth++;
            else if (c === tokenEndChar) {
                tokenDepth--;
                if (tokenDepth === 0) {
                    var token = str.substring(tokenStart, position + 1);
                    tokens.push(token);
                    replacement = "@mass_token_" + (tokens.length - 1) + "@";
                    str = str.substring(0, tokenStart) + replacement + str.substring(position + 1);
                    position -= (token.length - replacement.length);
                    tokenStart = null;
                }
            }
        }
        //拆解字段,还原占位符的部分
        var result = [];
        var keyValuePairs = str.split(",");
        for (var i = 0, j = keyValuePairs.length; i < j; i++) {
            var pair = keyValuePairs[i];
            var colonPos = pair.indexOf(":");
            if ((colonPos > 0) && (colonPos < pair.length - 1)) {
                var key = pair.substring(0, colonPos);
                var value = pair.substring(colonPos + 1);
                result.push({
                    'key': restoreTokens(key, tokens),
                    'value': restoreTokens(value, tokens)
                });
            } else {//到这里应该抛错吧
                result.push({
                    'unknown': restoreTokens(pair, tokens)
                });
            }
        }
        return result;
    }
    function ensureQuoted(key, array) {
        var trimmedKey = key.trim()
        if(array){
            return trimmedKey;
        }
        switch (trimmedKey.length && trimmedKey.charAt(0)) {
            case "'":
            case '"':
                return key;
            default:
                return "'" + trimmedKey + "'";
        }
    }
})

相关链接:avalon v1

posted on 2012-12-11 21:51  司徒正美  阅读(...)  评论(...编辑  收藏