JxUnderscore(function (J, _, root) {
var isWindow,
deepObject,
Namespace,
Class,
LOG;
/**
* 一个对象是否为window对象
* @param obj
* @returns {boolean}
*/
isWindow = function (obj) {
return !!obj && obj.window === window;
};
/**
* 用于打印日志的方法
*/
LOG = (function () {
if (isWindow(root)) {
if (!!window.console) {
return {
error: function (s) {
window.console.log("[error]" + s);
},
debug: function () {
window.console.log("[debug]" + s);
}
};
} else {
return {
error: function (s) {
window.alert(s)
},
debug: function () {
}
}
}
} else {
return {
error: function () {
},
debug: function () {
}
};
}
})();
/**
* 创建/获取一个命名空间/包
* @param namespacePath
* @param context
* @returns {*}
*/
deepObject = function (namespacePath, context) {
if ("string" !== typeof namespacePath) {
return undefined;
}
var ns = context || root;
var pathArr = namespacePath.split('.');
for (var i = 0; i < pathArr.length; i++) {
var path = pathArr[i];
ns[path] = ns[path] || {};
ns = ns[path];
}
return ns;
};
/**
* 创建Class类的类
* Class
* @class
* @memberOf Jx
* @param {Object} option = {extend: superClass} 在option对象的extend属性中指定要继承的对象,可以不写
* @param {Object} object 扩展的对象
* @return {Object} Class类
*
* @example
*
* var Person = new J.Class({
* init : function(name){
* this.name = name;
* alert("init");
* },
* showName : function(){
* alert(this.name);
*
* }
*
*
*
* // 继承Person
* var Person2 = new J.Class({extend : Person}, {
* init : function(name){
* this.name = name;
* alert("init");
* },
* showName : function(){
* alert(this.name);
*
* }
*
* });
*
* };
*
*/
Class = function () {
var length = arguments.length;
var option = arguments[length - 1];
option.init = option.init || function () {
};
// 如果参数中有要继承的父类
if (length === 2) {
/**
* @ignore
*/
var superClass = arguments[0].extend;
/**
* @ignore
*/
var tempClass = function () {
};
tempClass.prototype = superClass.prototype;
/**
* @ignore
*/
var subClass = function () {
this.init.apply(this, arguments);
};
// 加一个对父类原型引用的静态属性
subClass.superClass = superClass.prototype;
//subClass.superClass = superClass;
/**
* @ignore
*/
subClass.callSuper = function (context, func) {
var slice = Array.prototype.slice;
var a = slice.call(arguments, 2);
var func = subClass.superClass[func];
//var func = subClass.superClass.prototype[func];
if (func) {
func.apply(context, a.concat(slice.call(arguments)));
}
};
// 指定原型
subClass.prototype = new tempClass();
// 重新指定构造函数
subClass.prototype.constructor = subClass;
_.extend(subClass.prototype, option);
/**
* @ignore
*/
subClass.prototype.init = function () {
// 调用父类的构造函数
// subClass.superClass.init.apply(this, arguments);
// 调用此类自身的构造函数
option.init.apply(this, arguments);
};
return subClass;
// 如果参数中没有父类,则单纯构建一个类
} else if (length === 1) {
/**
* @ignore
*/
var newClass = function () {
// 加了return,否则init返回的对象不生效
return this.init.apply(this, arguments);
};
newClass.prototype = option;
return newClass;
}
};
/**
* 创建/获取一个命名空间/包
* @param {String} namespacePath
* @param {function} workspace
* @constructor
* @example
* J.Namespace("jx.ui.pm",function(pm){
* return {
* a:"a",
* b:"b"
* }
* });
* J.Package("jx.ui.pm",function(pm){
* var a=pm.a;
* return {
* c:"c"+a,
* d:"d"
* };
* });
*/
Namespace = function (namespacePath, workspace) {
namespacePath = namespacePath || "";
workspace = workspace || function () {
};
var namespaceObj = deepObject(namespacePath);
if (namespaceObj) {
var result = workspace(namespaceObj);
if (_.isObject(result)) {
_.extend(namespaceObj, result);
} else {
LOG.error("the return value is not an object,namespace :" + namespacePath);
}
}
};
J.Namespace = Namespace;
J.Package = Namespace;
J.Class = Class;
J.isWindow = isWindow;
J.createDeepObject = deepObject;
J.LOG = LOG;
return {
Namespace: Namespace,
Package: Namespace,
Class: Class,
isWindow: isWindow,
createDeepObject: deepObject,
LOG: LOG
};
});