是专门针对于数组，类数组，字符串，数字，对象提供了N多便捷方法。正如dom实例是把元素节点包裹到里面进行链式操作一样，dom.lang实例是把上述数据类型包裹起来进行链式操作。但链式操作有一个缺点，就是失去了原来的返回值，因此实例提供了两组方法，一组是用于进行链式操作，此类方法名以“X”结束，除非原始返回值的类型不在数组，数字，字符串，对象这四个范围之内，它总是返回dom.lang实例。另一组则总是返回原始返回值。比如forEach与forEachX是一组。使用方法:dom.lang("aaa").underscored()，dom.lang("bbb").toUpperCase()，dom.lang([1,2,3]).forEach(fn)。此外，它还提供了几个依附于dom命名空间的静态方法。
//=========================================
// 语言扩展模块 by 司徒正美
//=========================================
(function(global,DOC){
var dom = global[DOC.URL.replace(/(#.+|\W)/g,'')];
var deps = Array.isArray && Object.create ? "" : "ecma";
dom.define("lang", deps, function(){
dom.log("已加载lang模块");
var
rascii = /[^\x00-\xff]/g,
rformat = /\\?\#{([^{}]+)\}/gm,
rnoclose = /^(area|base|basefont|bgsound|br|col|frame|hr|img|input|isindex|link|meta|param|embed|wbr)$/i,
// JSON RegExp
rvalidchars = /^[\],:{}\s]*$/,
rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
P = "prototype",
H = dom.hasOwnProperty,
N = (global.open + '').replace(/open/g, '');
dom.mix(dom,{
//判定是否一个朴素的对象,只能允许是对象对面量及由new Object生成的对象
isPlainObject : function (obj){
return !!obj && dom.type(obj,"Object") && H.call(obj.constructor[P],"isPrototypeOf") ;
},
isFunction : function(obj){
return dom.type(obj,"Function")
},
isString : function(obj){
return dom.type(obj,"String");
},
isArray: function(obj){
return dom.type(obj,"Array");
},
/**
* 是否为原生方法
* @param {Object} obj
* @param {Function} method
* @return {Boolean}
*/
isNative : function(obj, method) {
var m = obj ? obj[method] : false, r = new RegExp(method, 'g');
return !!(m && typeof m != 'string' && N === (m + '').replace(r, ''));
},
globalEval: function( code ) {
//IE中，window.eval()和eval()一样只在当前作用域生效。
//Firefox，Safari，Opera中，直接调用eval()为当前作用域，window.eval()调用为全局作用域。
if ( code && /\S/.test(code) ) {
var method = global.execScript ? "execScript" : "eval"
try{
global[method](code);
}catch(e){}
}
},
parseJSON: function( data ) {
if ( typeof data !== "string" || !data ) {
return null;
}
data = data.trim();
if ( global.JSON && global.JSON.parse ) {
//使用原生的JSON.parse转换字符串为对象
dom.log("使用原生的JSON.parse转换字符串为对象")
return global.JSON.parse( data );
}
if ( rvalidchars.test( data.replace( rvalidescape, "@" )
.replace( rvalidtokens, "]" )
.replace( rvalidbraces, "")) ) {
//使用new Function生成一个JSON对象
dom.log("使用new Function生成一个JSON对象")
return (new Function( "return " + data ))();
}
dom.log( "Invalid JSON: " + data );
},
// Cross-browser xml parsing
parseXML: function( data,xml,tmp ) {
try {
if ( global.DOMParser ) { // Standard
tmp = new DOMParser();
xml = tmp.parseFromString( data , "text/xml" );
} else { // IE
xml = new ActiveXObject( "Microsoft.XMLDOM" );
xml.async = "false";
xml.loadXML( data );
}
} catch( e ) {
xml = undefined;
}
if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
dom.log( "Invalid XML: " + data );
}
return xml;
},
/**
* 是否为空对象
* @param {Object} obj
* @return {Boolean}
*/
isEmptyObject: function(obj ) {
for ( var name in obj ){
if ( name !== "toJSON" ) {
return false;
}
}
return true;
},
//包括Array,Arguments,NodeList,HTMLCollection,IXMLDOMNodeList与自定义类数组对象
//select.options集合（它们两个都有item与length属性）
isArrayLike : function (obj) {
if(!obj || obj.document || obj.nodeType || dom.type(obj,"Function")) return false;
return isFinite(obj.length) ;
},
//将字符串中的占位符替换为对应的键值
//http://www.cnblogs.com/rubylouvre/archive/2011/05/02/1972176.html
format : function(str, object){
var array = dom.slice(arguments,1);
return str.replace(rformat, function(match, name){
if (match.charAt(0) == '\\')
return match.slice(1);
var index = Number(name)
if(index >=0 )
return array[index];
if(object && object[name])
return object[name];
return '' ;
});
},
/**
* 用于拼接多行字符串,免去写<与>与结束标签之苦
* @param {String} tag 可带属性的开始标签
* @param {String} innerHTML 可选
* @param {Boolean} xml 可选 默认false,使用HTML模式,需要处理空标签
* @example var html = T("P title=aaa",T("span","111111")("strong","22222"))("div",T("div",T("span","两层")))("H1",T("span","33333"))('',"这是纯文本");
* console.log(html+"");
* @return {Function}
*/
tag:function (start,content,xml){
xml = !!xml
var chain = function(start,content,xml){
var html = arguments.callee.html;
start && html.push("<",start,">");
content = ''+(content||'');
content && html.push(content);
var end = start.split(' ')[0];//取得结束标签
if(end && (xml || !rnoclose.test(end))){
html.push("</",end,">");
}
return chain;
}
chain.html = [];
chain.toString = function(){
return this.html.join("");
}
return chain(start,content,xml);
},
// Generate an integer Array containing an arithmetic progression. A port of
// the native Python `range()` function. See
// [the Python documentation](http://docs.python.org/library/functions.html#range).
range : function(start, stop, step) {
if (arguments.length <= 1) {
stop = start || 0;
start = 0;
}
step = arguments[2] || 1;
var len = Math.max(Math.ceil((stop - start) / step), 0);
var idx = 0;
var range = new Array(len);
while(idx < len) {
range[idx++] = start;
start += step;
}
return range;
},
quote : String.quote || (function(){
var meta = {
'\t':'t',
'\n':'n',
'\v':'v',
'f':'f',
'\r':'\r',
'\'':'\'',
'\"':'\"',
'\\':'\\'
},
reg = /[\x00-\x1F\'\"\\\u007F-\uFFFF]/g,
regFn = function(c){
if (c in meta) return '\\' + meta[c];
var ord = c.charCodeAt(0);
return ord < 0x20 ? '\\x0' + ord.toString(16)
: ord < 0x7F ? '\\' + c
: ord < 0x100 ? '\\x' + ord.toString(16)
: ord < 0x1000 ? '\\u0' + ord.toString(16)
: '\\u' + ord.toString(16)
};
return function (str) {
return '"' + str.replace(reg, regFn)+ '"';
}
})()
}, false);
if(Array.isArray){
dom.isArray = Array.isArray;
}
var String2 = dom.String2 = {
//判断一个字符串是否包含另一个字符
contains: function(string, separator){
return (separator) ? (separator + this + separator).indexOf(separator + string + separator) > -1 : this.indexOf(string) > -1;
},
//以XXX开头
startsWith: function(string, ignorecase) {
var start_str = this.substr(0, string.length);
return ignorecase ? start_str.toLowerCase() === string.toLowerCase() :
start_str === string;
},
endsWith: function(string, ignorecase) {
var end_str = this.substring(this.length - string.length);
return ignorecase ? end_str.toLowerCase() === string.toLowerCase() :
end_str === string;
},
toArray:function(crash){
return !!crash ? this.split('') : this.split(/\s+/g);
},
//得到字节长度
byteLen:function(){
return this.replace(rascii,"--").length;
},
empty: function () {
return this.valueOf() === '';
},
//判定字符串是否只有空白
blank: function () {
return /^\s*$/.test(this);
},
//length，新字符串长度，truncation，新字符串的结尾的字段,返回新字符串
truncate :function(length, truncation) {
length = length || 30;
truncation = truncation === void(0) ? '...' : truncation;
return this.length > length ?
this.slice(0, length - truncation.length) + truncation :String(this);
},
camelize:function(){
return this.replace(/-([a-z])/g, function($1,$2){
return $2.toUpperCase();
});
},
//首字母大写
capitalize: function(){
return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
},
underscored: function() {
return this.replace(/([a-z\d])([A-Z]+)/g, '$1_$2').replace(/\-/g, '_').toLowerCase();
},
toInt: function(radix) {
return parseInt(this, radix || 10);
},
toFloat: function() {
return parseFloat(this);
},
//http://stevenlevithan.com/regex/xregexp/
escapeRegExp: function(){
return this.replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1');
},
//http://www.cnblogs.com/rubylouvre/archive/2010/02/09/1666165.html
//在左边补上一些字符,默认为0
padLeft: function(digits, radix, filling){
var num = this.toString(radix || 10);
filling = filling || "0";
while(num.length < digits){
num= filling + num;
}
return num;
},
//在右边补上一些字符,默认为0
padRight: function(digits, radix, filling){
var num = this.toString(radix || 10);
filling = filling || "0";
while(num.length < digits){
num += filling;
}
return num;
},
// http://www.cnblogs.com/rubylouvre/archive/2009/11/08/1598383.html
times :function(n){
var str = this,res = "";
while (n > 0) {
if (n & 1)
res += str;
str += str;
n >>= 1;
}
return res;
}
};
var Array2 = dom.Array2 = {
//深拷贝当前数组
clone: function(){
var i = this.length, result = [];
while (i--) result[i] = cloneOf(this[i]);
return result;
},
first: function(fn,scope){
if(dom.type(fn,"Function")){
for(var i=0, n = this.length;i < n;i++){
if(fn.call(scope,this[i],i,this)){
return this[i];
}
}
return null;
}else{
return this[0];
}
},
last: function(fn, scope) {
if(dom.type(fn,"Function")){
for (var i=this.length-1; i > -1; i--) {
if (fn.call(scope, this[i], i, this)) {
return this[i];
}
}
return null;
}else{
return this[this.length-1];
}
},
//判断数组是否包含此元素
contains: function (el) {
return this.indexOf(el) !== -1;
},
//去掉与传入参数相同的元素
without:function(){
var args = dom.slice(arguments);
return this.filter(function (el) {
return args.indexOf(el) < 0;
});
},
//http://msdn.microsoft.com/zh-cn/library/bb383786.aspx
//移除 Array 对象中某个元素的第一个匹配项。
remove: function (item) {
var index = this.indexOf(item);
if (index !== -1) return Array2.removeAt.call(this,index);
return null;
},
//移除 Array 对象中指定位置的元素。
removeAt: function (index) {
return this.splice(index, 1);
},
//对数组进行洗牌,但不影响原对象
// Jonas Raoni Soares Silva http://jsfromhell.com/array/shuffle [v1.0]
shuffle: function () {
var shuff = (this || []).concat(), j, x, i = shuff.length;
for (; i > 0; j = parseInt(Math.random() * i), x = shuff[--i], shuff[i] = shuff[j], shuff[j] = x) {};
return shuff;
},
//从数组中随机抽选一个元素出来
random: function () {
return Array2.shuffle.call(this)[0];
},
//取得数字数组中值最小的元素
min: function() {
return Math.min.apply(0, this);
},
//取得数字数组中值最大的元素
max: function() {
return Math.max.apply(0, this);
},
//只有原数组不存在才添加它
ensure: function() {
var args = dom.slice(arguments);
args.forEach(function(el){
if (this.indexOf(el) < 0) this.push(el);
},this);
return this;
},
//取得对象数组的每个元素的特定属性
pluck:function(name){
var result = [],prop;
this.forEach(function(el){
prop = el[name];
if(prop != null)
result.push(prop);
});
return result;
},
//根据对象的某个属性进行排序
sortBy: function(fn, scope) {
var array = this.map(function(el, index) {
return {
el: el,
re: fn.call(scope, el, index)
};
}).sort(function(left, right) {
var a = left.re, b = right.re;
return a < b ? -1 : a > b ? 1 : 0;
});
return Array2.pluck.call(array,'el');
},
// 以数组形式返回原数组中不为null与undefined的元素
compact: function () {
return this.filter(function (el) {
return el != null;
});
},
// 返回没有重复值的新数组
unique: function () {
var result = [];
for(var i=0,l=this.length; i < l; i++) {
if(result.indexOf(this[i]) < 0){
result.push(this[i]);
}
}
return result;
},
//对数组进行平坦化处理，返回一个一维数组
flatten: function() {
var result = [],self = Array2.flatten;
this.forEach(function(value) {
if (dom.isArray(value)) {
result = result.concat(self.call(value));
} else {
result.push(value);
}
});
return result;
},
//returns a new Array with the elements that are in a but not in b
diff : function(array) {
var result = this.slice();
for ( var i = 0; i < result.length; i++ ) {
for ( var j = 0; j < array.length; j++ ) {
if ( result[i] === array[j] ) {
result.splice(i, 1);
i--;
break;
}
}
}
return result;
}
}
var Number2 = dom.Number2 ={
times: function(fn, bind) {
for (var i=0; i < this; i++)
fn.call(bind, i);
return this;
},
padLeft:function(digits, radix, filling){
return String2.padLeft.apply(this,[digits, radix, filling]);
},
padRight:function(digits, radix, filling){
return String2.padRight.apply(this,[digits, radix, filling]);
},
//确保数值在[n1,n2]闭区间之内,如果超出限界,则置换为离它最近的最大值或最小值
constrain:function(n1,n2){
var a = [n1,n2].sort(),num = Number(this);
if(num < a[0]) num = a[0];
if(num > a[1]) num = a[1];
return num;
},
//求出距离原数最近的那个数
nearer:function(n1,n2){
var num = Number(this),
diff1 = Math.abs(num - n1),
diff2 = Math.abs(num - n2);
return diff1 < diff2 ? n1 : n2
},
upto: function(number, fn, scope) {
for (var i=this+0; i <= number; i++)
fn.call(scope, i);
return this;
},
downto: function(number, fn, scope) {
for (var i=this+0; i >= number; i--)
fn.call(scope, i);
return this;
},
round: function(base) {
if (base) {
base = Math.pow(10, base);
return Math.round(this * base) / base;
} else {
return Math.round(this);
}
}
}
var mathFns = ["abs", "acos", "asin", "atan", "atan2", "ceil",
"cos", "exp", "floor", "log", "pow","sin", "sqrt", "tan"];
mathFns.forEach(function(name){
Number2[name] = function(){
return Math[name](this);
}
});
function cloneOf(item){
switch(dom.type(item)){
case "Array":
return Array2.clone.call(item);
case "Object":
return Object2.clone.call(item);
default:
return item;
}
}
//使用深拷贝方法将多个对象或数组合并成一个
function mergeOne(source, key, current){
if(source[key] && typeof source[key] == "object"){
Object2.merge.call(source[key], current);
}else{
source[key] = cloneOf(current)
}
return source;
};
var Object2 = dom.Object2 = {
//根据传入数组取当前对象相关的键值对组成一个新对象返回
subset: function(keys){
var results = {};
for (var i = 0, l = keys.length; i < l; i++){
var k = keys[i];
results[k] = this[k];
}
return results;
},
//遍历对象的键值对
forEach: function(fn,scope){
for(var name in this){
fn.call(scope,this[name],name,this);
}
if(dom.DONT_ENUM){
for(var i = 0; name = dom.DONT_ENUM[i++]; ){
H.call(this,name) && fn.call(scope,this[name],name,this);
}
}
},
//进行深拷贝，返回一个新对象，如果是拷贝请使用dom.mix
clone: function(){
var clone = {};
for (var key in this) clone[key] = cloneOf(this[key]);
return clone;
},
merge: function(k, v){
var target = this,obj,key;
//为目标对象添加一个键值对
if (typeof k === "string")
return mergeOne(target, k, v);
//合并多个对象
for (var i = 0, l = arguments.length; i < l; i++){
obj = arguments[i];
for ( key in obj){
mergeOne(target, key, obj[key]);
}
}
return target;
},
//去掉与传入参数相同的元素
without: function() {
var args = dom.slice(arguments),result = {}, key;
for (key in this) {
if (args.indexOf(key) < 0) {
result[key] = this[key];
}
}
return result;
}
}
var inner = {
String : ["charAt", "charCodeAt", "concat", "indexOf", "lastIndexOf", "localeCompare",
"match", "replace","search", "slice", "split", "substring", "toLowerCase",
"toLocaleLowerCase", "toUpperCase", "toLocaleUpperCase", "trim", "toJSON"],
Array : [ "toLocaleString","concat", "join", "pop", "push", "shift", "slice", "sort", "reverse","splice", "unshift",
"indexOf", "lastIndexOf", "every", "some", "forEach", "map","filter", "reduce", "reduceRight"],
Number : ["toLocaleString", "toFixed", "toExponential", "toPrecision", "toJSON"],
Object : ["toLocaleString", "hasOwnerProperty", "isPrototypeOf", "propertyIsEnumerable" ]
}
var adjustOne = dom.oneObject(["String","Array","Number","Object"]);
var Lang = dom.lang = function(obj){
var type = dom.type(obj), that = this;
if(type == "NodeList" || type === "Arguments" || type === "Object" && isFinite(obj.length)){
obj = dom.slice(obj);
type = "Array";
}
if(adjustOne[type]){
if(!(that instanceof Lang)){
that = new Lang;
}
that.target = obj;
that.type = type;
return that;
}else{// undefined boolean null
return obj
}
}
var proto = Lang[P] = {
constructor:Lang,
valueOf:function(){
return this.target;
},
toString:function(){
return this.target + "";
}
};
function force(type){
var methods = inner[type].concat(Object.keys(dom[type+2]));
methods.forEach(function(name){
proto[name] = function(){
var obj = this.target;
var method = obj[name] ? obj[name] : dom[this.type+2][name];
var result = method.apply(obj,arguments);
return result;
}
proto[name+"X"] = function(){
var obj = this.target;
var method = obj[name] ? obj[name] : dom[this.type+2][name];
var result = method.apply(obj,arguments);
return Lang.call(this,result) ;
}
});
return force;
};
force("Array")("String")("Number")("Object");
});
})(this,this.document);
//2011.7.12
//将toArray转移到lang模块下
//2011.7.26
//去掉toArray方法,添加globalEval parseJSON parseXML方法
//2011.8.6
//增加tag方法
//2011.8.14
//更新隐藏的命名空间,更新range方法