`
openxtiger
  • 浏览: 151742 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

[原创]类似Java语法的Javascript框架js5(v2)

阅读更多

第二版本:

1.添加了 jimport 类似实现java的import关键字

2.jclass的改进:

  • 单个参数为返回查找的类,
  • 第一个参数为""时,产生匿名函数。
  • 从第三个参数到倒数第二个参数为mixin,且所有的mixin将按照顺序传入类定义的闭包函数的第二个参数到最后一个参数。

 

 

附上代码:

 

var Js5 = {version:"5.0.0"};
var __cpackage__;
var __classes__ = {};
var __iclasses__ = {};
var __imports__ = [];

Js5.apply = function(o, c) {
    if (o && c && typeof c == 'object') {
        for (var p in c) {
            o[p] = c[p];
        }
    }
    return o;
};

(function() {

    Js5.apply(Js5, {
        applyIf : function(o, c) {
            if (o) {
                for (var p in c) {
                    if (!Js5.isDefined(o[p])) {
                        o[p] = c[p];
                    }
                }
            }
            return o;
        },
        extend : function() {
            var oc = Object.prototype.constructor;
            return function(sb, sp, overrides) {

                var coverrides = overrides;
                if (!overrides) {
                    coverrides = sp;
                    sp = sb;
                }
                var F = function() {
                },sbp,spp = sp.prototype;
                F.prototype = spp;

                coverrides = coverrides(spp) || {};
                if (!overrides) {
                    sb = coverrides.constructor != oc ? coverrides.constructor : function() {
                        sp.apply(this, arguments);
                    };
                }
                sbp = sb.prototype = new F();
                sbp.constructor = sb;
                sb.superclass = spp;
                if (spp.constructor == oc) {
                    spp.constructor = sp;
                }

                sbp.superclass = (function() {
                    return spp;
                });

                Js5.override(sb, coverrides);  // extend coverrides

                return sb;
            }
        }(),
        mixin:function() {
            var oc = Object.prototype.constructor;
            return function(mixins, sb, sp, overrides) {
                if (!Js5.isArray(mixins)) {
                    mixins = [mixins];
                }
                var coverrides = overrides;
                if (!overrides) {
                    coverrides = sp;
                    sp = sb;
                }
                var F = function() {
                },sbp,spp = sp.prototype;
                F.prototype = spp;
                mixins.unshift(spp);

                coverrides = coverrides.apply(this, mixins) || {};
                if (!overrides) {
                    sb = coverrides.constructor != oc ? coverrides.constructor : function() {
                        sp.apply(this, arguments);
                    };
                }
                sbp = sb.prototype = new F();
                sbp.constructor = sb;
                sb.superclass = spp;
                if (spp.constructor == oc) {
                    spp.constructor = sp;
                }

                sbp.superclass = (function() {
                    return spp;
                });

                Js5.override(sb, coverrides);  // extend coverrides
                mixins.shift();
                Js5.each(mixins, function(mixin) {
                    Js5.applyIf(sbp, mixin);
                });

                return sb;
            }
        }(),
        override: function(origclass, overrides) {
            if (overrides) {
                var p = origclass.prototype;
                Js5.apply(p, overrides);
            }
        },
        /*override : function(origclass, overrides) {
         if (overrides) {
         var p = origclass.prototype;
         overrides = overrides(p.superclass);

         Js5.apply(p, overrides);

         if (Js5.isIE && overrides.hasOwnProperty('toString')) {
         p.toString = overrides.toString;
         }
         }

         },*/
        isString : function(v) {
            return typeof v === 'string';
        },
        isBoolean : function(v) {
            return typeof v === 'boolean';
        },
        isElement : function(v) {
            return !!v && v.tagName;
        },
        isDefined : function(v) {
            return typeof v !== 'undefined';
        },
        isObject : function(v) {
            return !!v && Object.prototype.toString.call(v) === '[object Object]';
        },
        isDate : function(v) {
            return toString.apply(v) === '[object Date]';
        },
        isPrimitive : function(v) {
            return Js5.isString(v) || Js5.isNumber(v) || Js5.isBoolean(v);
        },
        isNumber : function(v) {
            return typeof v === 'number' && isFinite(v);
        },
        isEmpty : function(v, allowBlank) {
            return v === null || v === undefined || ((Js5.isArray(v) && !v.length)) || (!allowBlank ? v === '' : false);
        },
        isArray : function(v) {
            return toString.apply(v) === '[object Array]';
        },
        isIterable : function(v) {
            //check for array or arguments
            if (Js5.isArray(v) || v.callee) {
                return true;
            }
            //check for node list type
            if (/NodeList|HTMLCollection/.test(toString.call(v))) {
                return true;
            }
            //NodeList has an item and length property
            //IXMLDOMNodeList has nextNode method, needs to be checked first.
            return ((typeof v.nextNode != 'undefined' || v.item) && Js5.isNumber(v.length));
        },
        each : function(array, fn, scope) {
            if (Js5.isEmpty(array, true)) {
                return [];
            }
            if (!Js5.isIterable(array) || Js5.isPrimitive(array)) {
                array = [array];
            }
            for (var i = 0, len = array.length; i < len; i++) {
                if (fn.call(scope || array[i], array[i], i, array) === false) {
                    return i;
                }
            }
            return [];
        },
        namespace : function() {
            var o, d;
            Js5.each(arguments, function(v) {
                d = v.split(".");
                o = window[d[0]] = window[d[0]] || {};
                Js5.each(d.slice(1), function(v2) {
                    o = o[v2] = o[v2] || {};
                });
            });
            return o;
        },
        nameclass:function(c) {
            if (__classes__[c]) return __classes__[c];
            var d = c.split(".");
            var o = window[d[0]] = window[d[0]] || {};
            Js5.each(d.slice(1, d.length - 1), function(v2) {
                o = o[v2] = o[v2] || {};
            });
            return __classes__[c] = o[d[d.length - 1]];
        },
        importclass:function(c) {
            if (__classes__[c]) return __classes__[c];
            if (__iclasses__[c]) return __iclasses__[c];

            var d = c.split(".");
            var o = window[d[0]] = window[d[0]] || {};
            var name = d[d.length - 1];
            Js5.each(d.slice(1, d.length - 1), function(v2) {
                o = o[v2] = o[v2] || {};
            });
            if (o[name]) {
                o = __classes__[c] = o[name];
            } else {
                Js5.each(__imports__, function(i) {
                    if ((o = i[name])) {
                        return false;
                    }
                });

                __iclasses__[c] = o;
            }

            return o;
        }
    });

    Js5.ns = Js5.namespace;
})();


/**
 * p1:String ==>package name
 * p2..p-1,Object ==>imports
 * p-1,function ==> package body
 */
function jpackage() {
    var l = arguments.length,i = 0;
    if (l == 0) return;
    var pkf = arguments[l - 1];
    if (Js5.isString(arguments[0])) {
        __cpackage__ = Js5.namespace(arguments[0]);
        i = 1;
    } else {
        __cpackage__ = window;
        i = 0;
    }
    var args = [],vs,ip;
    Js5.each(Array.prototype.slice.call(arguments, i, l - 1), function(v) {
        if (Js5.isString(v)) {
            vs = v.split(";");
            Js5.each(vs, function(v2) {
                if (v2.substr(-2) == ".*") {
                    ip = Js5.namespace(v2.substring(0, v2.length - 2));
                    __imports__.push(ip);
                    args.push(ip);
                } else {
                    args.push(Js5.importclass(v2));
                }
            });
        } else if (Js5.isArray(v)) {
            args = args.concat(v);
        } else {
            args.push(v);
        }
    });
    pkf.apply(__cpackage__, args);

    __cpackage__ = null;
    __imports__ = [];
    __iclasses__ = {};

}

function jimport() {
    var args = [],vs,ip;
    __imports__ = [];
    __iclasses__ = {};
    Js5.each(arguments, function(v) {
        if (Js5.isString(v)) {
            vs = v.split(";");
            Js5.each(vs, function(v2) {
                if (v2.substr(-2) == ".*") {
                    ip = Js5.namespace(v2.substring(0, v2.length - 2));
                    __imports__.push(ip);
                    args.push(ip);
                } else {
                    args.push(Js5.importclass(v2));
                }
            });
        } else if (Js5.isArray(v)) {
            args = args.concat(v);
        } else {
            args.push(v);
        }
    });
    return args;
}
/**
 * p1:String ==>class name
 * p2,String ==>same package;Object
 * p3,function ==>
 */
function jclass() {
    var l = arguments.length,i = 0;
    if (l == 0) {
        throw new Error("[jclass] invalid arguments");
    }

    if (l == 1) {
        return Js5.importclass(arguments[0]);
    }

    var clf = arguments[l - 1];

    var c;
    if (Js5.isString(arguments[0])) {
        c = __cpackage__;
    } else {
        c = window;
    }

    var p;
    if (l >= 3) {
        var name = arguments[1];
        if (Js5.isString(name)) {
            p = __cpackage__[name];
            if (!p) {
                p = Js5.importclass(name);
            }
        } else {
            p = arguments[1];
        }
    } else {
        p = Object;
    }
    if (!p) {
        throw new Error("[jclass] unrecognized parent class");
    }
    var mixins = [];

    if (l >= 4) {
        var vs;
        var mc;
        Js5.each(Array.prototype.slice.call(arguments, 2, l - 1), function(v) {
            if (Js5.isString(v)) {
                vs = v.split(",");
                Js5.each(vs, function(v2) {
                    mc = Js5.importclass(v2);
                    if (mc) {
                        mixins.push(mc.prototype);
                    }

                });

            } else {
                mixins.push(v.prototype);
            }
        });
    }

    var cls = Js5.mixin(mixins, p, clf);

    if (arguments[0]) {
        c[arguments[0]] = cls;
    }


    return cls;
}

function jnew() {
    var l = arguments.length,i = 0;
    if (l == 0) return {};

    var args = Array.prototype.slice.call(arguments, 1);

    var name = arguments[0];

    var cls;
    if (Js5.isString(name)) {
        if (__cpackage__ && __cpackage__[name]) {
            cls = __cpackage__[name];
        }

        if (!cls) {
            cls = Js5.importclass(name);
        }
        if (!cls) {
            throw new Error("[jnew] unrecognized  class");
        }
    } else {
        cls = name;
    }


    /*var temp = function() {
     };

     var constructor = cls.prototype.constructor;
     var instanceCls = function() {
     return constructor.apply(this, args);
     };

     temp.prototype = cls.prototype;
     instanceCls.prototype = new temp();
     instanceCls.prototype.constructor = instanceCls;

     return new instanceCls();*/

    var obj = {};
    Js5.override(obj, cls);
    obj.__proto__ = cls.prototype;
    cls.apply(obj, args);
    return obj;


}

 

例子:

  var jui = {};

  jpackage("jui", function() {

    jclass("Component", function() {
      return {
        constructor:function(x) {
          console.log("Component:" + x);
        },
        show:function() {
          console.log("Component");
        }
      }
    });

    jclass("Container", "Component", function(_supr) {
      return {
        constructor:function(x) {
          console.log("Container:" + x);
          _supr.constructor.call(this, x);
        }
      };
    });

  });

  jpackage("jui", function() {

    jclass("Window", "Container", function(_supr) {
      return {
        show:function() {
          console.log("Window");
        }
      }
    });

  });

  jpackage("jui.form", function() {

    jimport("jui.*");

    jclass("TextField", "Component", function(_supr) {
      return {
        show:function() {
          console.log("TextField");
        }
      }
    });


  });

  jpackage("js5.util", function() {

    jclass("Observable", function(_supr) {
      return {
        constructor:function() {
          console.log("Observable.constructor");
        },
        on:function() {
          console.log("Observable.on");
        },
        show:function() {
          console.log("Observable.show");
        }
      }
    });

  });

  jpackage("jui.ex", jimport("jui.Window;jui.*;jui.form.*"), function(_W, j) {

    jclass("Window", "jui.Window", "js5.util.Observable", function(_supr, _ob) {
      return {
        constructor:function(x) {
          console.log("jui.ex.Window.constructor");
          _supr.constructor.call(this, x);
          _ob.constructor.call(this);
        },
        show:function() {
          console.log("Window Ex");
          _supr.show();
        }
      }
    });

    var MyWindow = jclass("", "jui.Window", function() {

      return {
        show:function() {
          console.log("anonymous myWindow");
        }
      }
    });

    var x = jnew("Window", "package jui.ex.Window");
    x.show();
    x.on();

    x = new MyWindow();
    x.show();

    jclass("jui.Window").superclass.constructor.call(this, "111111111111")


    x = jnew(jui.Window, "jui.Window : new in package, use complete class path");
    x.show();

    x = new jui.Window("jui.Window : new in package, use complete class path");
    x.show();

    x = jnew("jui.Window", "jui.Window: new in package, use complete class path");
    x.show();

    x = new j["Window"]("jui.Window: new in package, use import jui.*");
    x.show();

    x = new _W("jui.Window:  new in package, use import jui.Window");
    x.show();

    for (var i = 1; i <= 5; i++) {
      x = jnew("TextField", "jui.form.TextField  new in package,use import jui.form.*");
      x.show();
    }


  });

  var x = jnew("jui.ex.Window", "global jui.ex.Window");
  x.show();
 
分享到:
评论

相关推荐

    采用Flutter开发的一个v2ex移动App

    例如,如果你有一个现有的JavaScript库,可能需要通过Flutter的WebView插件来运行JavaScript代码,或者使用`dart:js`库在Dart中调用JavaScript函数。 在“v2ex移动App”这个项目中,开发者可能涉及以下具体功能的...

    V2EX的一个ReactNativeAndroid客户端

    React Native 是一个由Facebook开发的开源框架,它允许开发者使用JavaScript和React库来构建原生的iOS和Android应用。在本项目"V2EX的一个ReactNativeAndroid客户端"中,我们看到的是一个基于React Native实现的V2EX...

    java/j2ee学习资料大全第二部分(共5部分)

    - Java语法基础:包括变量、数据类型、运算符、流程控制语句等。 - 面向对象编程:类、对象、封装、继承、多态等概念。 - 异常处理:了解try-catch-finally结构以及自定义异常。 - 集合框架:List、Set、Map接口...

    GWT开发者手册_v2

    - **正则表达式**:Java 正则表达式的语法与 JavaScript 相似但也有区别,某些方法如 `replaceAll` 和 `split` 在转换后的 JavaScript 中可能表现不同。 - **序列化**:由于动态类装载和反射在编译后的 JavaScript ...

    jingshanccc-course-main_java_

    前端部分则选择了Vue.js作为主要的JavaScript框架,结合ElementUI组件库,提供了用户友好的界面设计。 【描述】中提到的“基于 Go 1.14、Go-Micro v2、Gorm 1.20.7、Vue、ElementUI的微服务化的前后端分离的在线...

    Vue.js v2.x 官方教程_103021.pdf

    Vue.js是一个流行的JavaScript框架,用于构建用户界面和单页应用程序。v2.x版本的Vue.js官方教程详细介绍了Vue的核心概念和高级特性,适合开发人员深入学习和掌握Vue.js的应用开发。教程内容涵盖了Vue.js的基本使用...

    spring boot v2+vue,根绝ruoyi改版

    【Vue.js】是一个轻量级的前端JavaScript框架,以数据驱动和组件化为核心,用于构建用户界面。Vue的特点包括: 1. **声明式渲染**:Vue通过模板语法使得数据绑定和DOM操作变得简单直观。 2. **组件化**:Vue允许将...

    恋爱话术小程序源码,微猫恋撩术V2 4.1.0 小程序-多开.zip

    恋爱话术小程序源码是针对恋爱交流技巧的小程序开发资源,微猫恋撩术V2 4.1.0 版本提供了一个平台,让用户能够通过互动的方式学习和提升自己的情感沟通能力。这个源码主要面向熟悉前端开发的人员,用于学习、研究或...

    基于微信小程序的V2EX社区小程序.zip

    2. **微信小程序框架**:微信小程序采用自有的WXML(WeiXin Markup Language)和WXSS(WeiXin Style Sheets)来定义视图层,使用JavaScript处理数据逻辑和用户交互。WXML负责结构,类似于HTML,但有其特定的语法;...

    宏软JSP上传系统 v2.0完美版-upload-v2.zip

    1. **JSP基础**:理解JSP的基本语法,包括声明、脚本元素、指令等,以及如何在JSP页面中嵌入Java代码来处理业务逻辑。 2. **Servlet**:JSP与Servlet紧密相关,Servlet是Java Web应用中的核心组件,用于处理HTTP...

    pdd_blog_v2:白头先生java技术交流博客后台原始仓库

    1. **Java编程语言**:作为项目的开发语言,Java的基本语法、面向对象设计原则、异常处理、集合框架、多线程等都会有所体现。 2. **Spring Boot框架**:Java后端开发常用的微服务框架,用于快速构建可生产的Spring...

    react-native-marketplace-v2-源码.rar

    React Native是Facebook推出的一款开源框架,它允许开发者使用JavaScript和React来构建原生的iOS和Android应用程序。React Native的核心理念是“Learn Once, Write Everywhere”,即学习一次,到处编写。通过将React...

    Qarto_V2

    8. **前端技术**:考虑到现代Web应用的需求,Qarto_V2的前端可能使用了React、Angular或Vue.js等JavaScript框架,与后端通过JSON进行数据交换。 9. **容器化部署**:Docker可能是Qarto_V2部署的首选方式,它可以将...

    API_XIAXINWEN

    5. **JavaScript源码大全.chm**:这个文档可能包含了大量的JavaScript代码示例和实用脚本,帮助开发者理解和学习JavaScript的实际应用,包括事件处理、AJAX(异步JavaScript和XML)、动画效果、表单验证等方面。...

    ssh所需要的jar.1

    7. **dwr.jar**:Direct Web Remoting (DWR) 是一个Java库,允许在浏览器和服务器之间进行异步的JavaScript到Java的调用,简化了Ajax开发,使得Web应用可以更加动态和交互。 8. **...

    AleControlTask​​sV2

    1. **JavaScript基本语法**:JavaScript语法类似于C++和Java,包含变量、数据类型(如字符串、数字、布尔值、对象等)、控制流程(if语句、switch、for循环、while循环)、函数、数组、对象等。熟悉这些基本概念对于...

    HackBulgariaCoreJavaV2

    课程中的问题可能是对学生理解Java语法、类与对象、异常处理、数据结构、多线程等概念的检验。 【标签】"JavaScript"可能意味着尽管课程主要关注Java,但也可能会涉及到JavaScript,这可能是因为JavaScript在Web...

    mdeditor markdown编辑器 v2.0.zip

    - **后端接口**(如果存在):可能涉及Node.js、Python或Java等服务器端技术,处理如数据存储、导出等功能。 - **配置文件**:包括设置编辑器的默认样式、快捷键绑定等信息。 - **资源文件**:如字体、图片和其他...

    方立勋JavaWeb视频前十一天笔记word

    1. **Java基础知识**:复习Java的基本语法,类,对象,包,异常处理,输入/输出流等,这是理解JavaWeb的前提。 2. **Servlet技术**:介绍Servlet的概念,生命周期,如何创建和配置Servlet,以及Servlet与HTTP请求...

Global site tag (gtag.js) - Google Analytics