这是我根据司徒正美《JavaScript框架设计》一书然后百度了很多东西之后自己写的一个JS框架，满足了司徒正美文中的种子模块部分，包含了命名空间、对象扩展、数组化、类型判断、选择器、多库并存，在异步加载中使用了CMD规范的seaJs，这个框架一年前就已经写了，之后一直在研究其他东西，没有进行扩展，今天把它发布出来也是为了时刻提醒自己，以后一定要继续扩展它。
下面是代码：
//立即执行的函数表达式
(function(){
//定义全局变量_$存储window.$
var window = this,
_$ = window.$,
_Amy = window._Amy,
DOC = document,
W3C = DOC.dispatchEvent, //判断浏览器
html = DOC.documentElement, //HTML元素
head = DOC.head, //head元素
rword = /[^,]+/g, //匹配除 ","以外的东西
class2type = {
"[object HTMLDocument]":"Document",
"[object HTMLCollection]":"NodeList",
"[object StaticNodeList]":"NodeList",
"[object DOMWindow]":"Window",
"[object global]":"Window",
"null":"Null",
"NaN":"NaN",
"undefined":"Undefined"
},
toString = class2type.toString(); "Boolean,Number,String,Function,Array,Da,RegExp,Window,Document,Arguments,NodeList"
.replace(rword,function(name){
class2type["[object " + name+"]"] = name;
}); Amy = window.Amy = window.$ = function(selector){
return new Amy.fn.init(selector);
}; //选择器初始化querySelector
Amy.fn = Amy.prototype = {
init:function(selector){
var dom = document.querySelector(selector);
return dom;
}
}; Amy.fn.init.prototype = Amy.fn; //对象扩展(原型方法)
Amy.extend = Amy.fn.extend = function(obj,prop){
if(!prop){
prop = obj;
obj = this;
}
for(var attr in prop){
obj[attr] = prop[attr];
}
}; Amy.extend({
html : html,
head :head, /**
* 多库并存问题
*/
noConflict:function(deep){
window.$ = _$;
if(deep)
window.Amy = _Amy; return Amy;
},
bindThis:function(obj){
var me = this;
var arg = [].slice.call(arguments,1);
return function(){
me.apply(obj,arg);
}
},
/**
* 运行所有参数，返回运行成功的函数返回值
*/
these:function(){
var returnVal = null;
for(var i = 0,len = arguments.length;i<len;i++){
var lambda = arguments[i];
try{
returnVal = lambda();
}catch(e){}
}
return returnVal;
},
/**
* 根据浏览器获取ajax对象
*/
ajax:function(){
return this.these(
function() {return new ActiveXObject('Msxml2.XMLHTTP')},
function() {return new ActiveXObject('Microsoft.XMLHTTP')},
function() {return new XMLHttpRequest()}
) || false;
},
/**
*数组化
*/
toArray:function(){
return [].slice.call(arguments);
},
/**
* 数组去重
*/
noRepeat:function(target){
var result = {};
target.forEach(function(item){
result[item] = item;
});
return Object.keys(result).map(function(item){
return item | 0;
});
},
/**
* 获取多个Id
* @returns {*}
*/
list:function(){
var result = [];
for(var i = 0,len =arguments.length;i<len;i++){
var element = arguments[i];
if(typeof element == "string"){
element = $(element);
}
if(len == 1)
return element;
else
result.push(element);
}
return result;
},
repeat:(function(){
var join = Array.prototype.join,
obj = {};
return function(target,n){
obj.length = n + 1;
return join.call(obj,target);
};
})(),
/**
* 事件绑定
*/
bind:W3C?function(el,type,fn,bool){
el.addEventListener(type,fn || $.noop,!!bool);
return fn;
} : function(el,type,fn){
el.attachEvent("on"+type,fn || $.noop);
return fn;
},
/**
* 解绑事件
*/
unbind:W3C?function(el,type,fn,bool){
el.removeEventListener(type,fn,!!bool);
} : function(el,type,fn){
el.detachEvent("on"+type,fn);
},
/**
* 用于取得数据的类型（一个参数的情况下）或判定数据的类型（两个参数的情况下）
* @param {Any} obj 要检测的东西
* @param {String} str ? 要比较的类型
* @return {String|Boolean}
* @api public
*/
type:function(obj,str){
var result = class2type[(obj != obj || obj == null)?obj:Object.prototype.toString.call(obj)] || obj.nodeName || "#"; if(result.charAt(0) === "#"){
if(obj == obj.document && obj.document != obj){
result = "Window";
}else if(obj.nodeType === 9){
result = 'Document';
}else if(obj.callee){
result = "Arguments";
}else if(isFinite(obj.length) && obj.item){
result = "NodeList";
}else{
result = Object.prototype.toString.call(obj).slice(8,-1);
}
}
if(str){
return str === result;
}
return result;
},
noop:function(){ },
//字符串操作 /**
* 字符串所占字节数
*/
btyeLen:function(target){
var byteLength = target.length;
for(var i = 0,len = target.length;i<len;i++){
if(target.charCodeAt(i) > 255) //若为中文则加1
byteLength++;
}
return byteLength;
},
/**
*字符串截取，当超过限定时默认添加三个...
*/
truncate : function(target,length,text){
length = length || 30;
text = text === void 0?"...":text;
return target.length > length?
target.slice(0,length - text.length) + text:String(target);
},
capitalize:function(target){
return target.charAt(0).toUpperCase() + target.slice(1).toLowerCase();
},
/**
* 去除字符串开头和结尾空格
*/
trim : function(str){
return str.replace(/^\s+|\s+$/g,"");
}, //数组操作
/**
* 判断目标中是否包含一个数（数组或字符串）
*/
contains : function(target,index){
return target.indexOf(index) > -1;
},
/**
* 删除目标（数组）指定位置的一个数(返回bool)
*/
removeAt:function(target,index){
return !!target.splice(index,1).length;
},
/**
*删除目标（数组）中第一次出现的数
*/
remove:function(target,item){
var index = target.indexOf(item);
if(index > -1){
return !!target.splice(index,1);
}
return false;
},
/**
* 从目标（数组）随机抽取一个数
*/
random:function(target){
return target[(Math.random()*target.length)|0];
},
/**
* 数组平坦化操作
* 命名函数表达式，fla只在函数内有定义，这里用递归
*/
flatten:function fla(target){
var result = [];
target.forEach(function(item){
if(Array.isArray(item)){
result = result.concat(fla(item));
}else{
result.push(item);
}
});
return result;
},
/**
* 删除数组中null和undefined
* 利用filter过滤操作 //返回true值
*/
compact:function(target){
var result = target.filter(function(item){
return item != null;
});
return result;
},
max:function(target){
return Math.max.apply(0, target);
},
min:function(target){
return Math.min.apply(0,target);
},
//数值扩展
/**
* 确保数值在[n1,n2]之间
*/
limit:function(target,n1,n2){
var arr = [n1,n2].sort();
if(target < arr[0]){
target = arr[0];
}
if(target > arr[1]){
target = arr[1];
}
return target;
},
iterator:function iter(n,type){
if(typeof type == "undefined" || type == "*"){
return n==0 ? 1:n*iter(n-1);
}else if(type == "+"){
return n==0 ? 1:n+iter(n-1);
}
},
/**
* 求距离目标最近的数
*/
near : function(target,n1,n2){
var diff1 = Math.abs(target - n1),
diff2 = Math.abs(target - n2);
return diff1 < diff2?n1:n2;
},
/**
* 复制数组
* 一般不希望别人访问原数组进行修改
*/
clone:function(target){
if(this.type(target) == "Array"){
var arr = new Array(target.length);
for(var i = 0,len = target.length;i<len;i++){
arr[i] = target[i];
}
return arr;
}else{
return 0;
}
} });
})();