javascript 超级字符串对象

* 博客文章部分截图及内容来自于学习的书本及相应培训课程以及网络其他博客，仅做学习讨论之用，不做商业用途。
* 如有侵权，马上联系我，我立马删除对应链接。
* @author Alan
* @Email no008@foxmail.com

javascript 超级字符串对象

正文

javascript 超级字符串对象

基于不对原生对象进行扩展的原则，搞了这个方便的处理字符串的对象。

下面是第一类工厂，相当于mootools的Native方法。

var dom = {},//命名空间
slice = Array.prototype.slice;
dom.mixin = function (obj, bag) {
  if (arguments.length === 1) {
    bag = obj;
    obj = this;
  };
  if (obj && bag && typeof bag === 'object') {
    for (var p in bag) {
      if(bag.hasOwnProperty(p))
        obj[p] = bag[p];
    }
  };
  if (!+"\v1") {//IE不能在for...in循环中遍历toString与valueOf属性，需要单独处理
    var t = bag.toString,v = bag.valueOf,op = Object.prototype;
    if (bag.hasOwnProperty("toString") && typeof t === "function" && t !== op.toString)
      obj.toString = t;
    if (bag.hasOwnProperty("valueOf") && typeof v === "function" && v !== op.valueOf)
      obj.valueOf = v;
  }
  return obj;
};
dom.factory = function(obj){//第一类工厂
  var init = obj.init,
  klass = function() {
    //如果传入参数与当前类是同一类型，则直接返回
    if(arguments.length === 1 && arguments[0] instanceof klass)
      return arguments[0];
    return new klass.fn.init(arguments);
  }
  klass.fn = klass.prototype = {
    init :init,
    constructor: klass
  };
  klass.fn.init.prototype = klass.fn;
  delete obj.klass;delete obj.init;
  dom.mixin(klass.fn, obj);
  //用于扩展原型方法
  klass.mixin = function(bag){
    dom.mixin(this.fn,bag);
    return this;
  };
  klass.alias = function(oldName, newName){
    var bag = {};
    if (dom.isString(oldName) && dom.isString(newName)){
      var method = this.fn[oldName]
      if (!!method){
        bag[newName] = method;
        return this.mixin(bag);
      };
    };
    //如果是一个属性包，如Hash.alias({keyOf: 'indexOf', hasValue: 'contains'});
    bag = oldName;
    for (var name in bag)
      if(bag.hasOwnProperty(name))
        this.alias(name,bag[name]);
    return this;
  };
  klass.staticizeWithout = function(arr){
    var conditions = {},keys = arr || [],me = this;
    for(var i=0,n = keys.length;i<n;i++){
      conditions[keys[i]] = 1;
    }
    dom.each(me.fn,function(method, name){
      if(!conditions[name] && dom.isFunction(me.fn[name]) && dom.isUndefined(me[name])&&
        name !== 'init' && name !== 'toString' && name !== 'valueOf' ){
        me[name] = function () {
          var args = dom.toArray(arguments),
          caller = args.shift();
          method.name = name; //为其泛化方法添加一个name属性
          return method.apply(me(caller), args);
        }
      }
    });
    return me;
  }
  return klass;
};
dom.mixin(new function(){
  var _toString = Object.prototype.toString,
  _slice = Array.prototype.slice,
  _push = Array.prototype.push,
  is = function(obj,type) {
    return _toString.call(obj).match(/^\[object\s(.*)\]$/)[1] === type;
  }
  return {
    isArray: function (obj) {
      return is(obj,"Array");
    },
    isFunction: function (obj) {
      return is(obj,"Function") ;
    },
    isNumber: function (obj) {
      return is(obj,"Number") ;
    },
    isString: function (obj) {
      return is(obj,"String") ;
    },
    isUndefined: function (obj) {
      return  obj === void(0);
    },
    each: function (obj, fn, bind) {
      for (var key in obj) //只遍历本地属性
        if (obj.hasOwnProperty(key))
          fn.call(bind, obj[key], key, obj);
    },
    isArrayLike : function (obj) {//包括Array
      if(dom.isArray(obj) || obj.callee) return true;
      if(is(obj,'NodeList')) return true;
      if(is(obj,'HTMLCollection')) return true;
      //不能为字符串,不能为window,具有length属性
      if(dom.isNumber(obj.length) && !dom.isString(obj) && !obj.eval){
        if(obj.nextNode || obj.item)
          return true;
        var n = obj.length - 1 < 0 ? 0 : obj.length - 1 ;
        //如果是具有数字键或length属性的对象,如jQuery对象
        if(obj.hasOwnProperty(n) && obj.hasOwnProperty(0))
          return true
        return false;
      }
      return false;
    },
    toArray : function (arr) { //把普通对象变成原生数组对象
      if(arguments.length === 0 || arr === null){
        return [];
      }else if(arr.callee){//如果是Arguments对象
        return _slice.call(arr);
      }else if(dom.isArray(arr)){//如果Array对象返回一个克隆
        return arr.concat();
      }else if(dom.isArrayLike(arr)){
        try{//jQuery对象，dom对象，el.getElementsByTagName得到的HTMLCollection
          //与el.childNodes得到的NodeList
          return _slice.call(arr);
        }catch(e){//IE用slice处理元素或节点集合会出错，只能慢慢拷贝
          var ret = [], i = arr.length;
          while (i) ret[--i] = arr[i]; //Clone数组
          return ret;
        }
      }else {//普通函数，单个元素节点，字符串，数字，window对象
        return [arr];
      }
    },
    setArray: function (els) { //把普通对象变成类数组对象
      this.length = 0;
      _push.apply(this, els);
      return this;
    }
  }
});
dom.win = window;

类工厂的能力很强大，生成的类拥有自我扩展的能力。下面是超级字符串的核心方法，分别为入口函数，构造函数，toString，valueOf与一个重要的setArray方法，用于设置charAt的索引值与length属性。

var string = dom.factory({
  init: function (obj) {
    this.setArray(obj[0].split(''));
    return this;
  },
  toString: function () {
    return this.valueOf();
  },
  valueOf: function () {
    return Array.prototype.join.call(this, '');
  },
  setArray: dom.setArray
});

再把字符串的泛化方法加持到其上，让其伪装成字符串对象。

//为超级字符串对象添加原生字符串对象的泛化方法
dom.each("charAt,charCodeAt,concat,indexOf,lastIndexOf,match,\
        replace,search,slice,split,substr,substring,toLowerCase,\
        toUpperCase,fontcolor,big,small,anchor,link,bold,italics,\
        sub,sup,fixed,fontsize,strike".match(/\w+/g),
function (name) {
  string.fn[name] = function () {
    var method = String.prototype[name],
    args = dom.toArray(arguments),
    ret = method.apply(this.valueOf(), args);
    if (dom.isString(ret))
      return string(ret)
    return ret;
  }
});

全局变量window也有许多专门处理字符串的方法，我们也把它们加持到超级字符串对象上。

//为超级字符串对象添加全局对象处理字符串的相关方法
dom.each("parseInt,parseFloat,escape,unescape,eval,decodeURI,\
        encodeURI,decodeURIComponent,encodeURIComponent".match(/\w+/g),
function (name) {
  string.fn[name] = function () {
    var ret = dom.win[name](this.valueOf());
    if (dom.isString(ret)) //确保返回超级字符串对象
      return string(ret);
    return ret;
  }
});

再添加一些有用的自定义方法：

string.mixin({
  trim: function () {
    var str = this.valueOf();
    if (String.trim) {
      return string(String.trim(str))
    } else {
      str = str.replace(/^\s\s*/, '');
      var ws = /\s/,
      i = str.length;
      while (ws.test(str.charAt(--i)));
      return string(str.slice(0, i + 1));
    };
  },
  dasherize: function () {
    return this.replace(/_/g, '-');
  },
  camelize : function (str) {
    return this.replace(/-([a-z])/g, function($1,$2){
      return $2.toUpperCase()
    });
  },
  capitalize: function () {
    return this.replace(/\S+/g, function ($1) {
      return $1.charAt(0).toUpperCase() + $1.slice(1);
    });
  },
  contains: function (segment) {
    return this.indexOf(segment) !== -1;
  },
  startsWith: function (pattern) {
    return this.indexOf(pattern) === 0;
  },
  endsWith: function (pattern) {
    var d = this.length - pattern.length;
    return d >= 0 && this.lastIndexOf(pattern) === d;
  },
  empty: function () {
    return this.valueOf() === '';
  },
  blank: function () {
    return /^\s*$/.test(this.valueOf());
  },
  times: function (n) {
    if (n == 1)
      return this;
    var s = this.times(Math.floor(n / 2));
    s += s;
    if (n % 2) {
      s += this;
    }
    return string(s);
  }
});
//静态化超级字符串对象的大部分原型方法
string.staticizeWithout(["setArray"]);
dom.string = string;

像字符串原有的方法与window处理字符串的相关方法就不废话了，我们看一下自定义方法的用法。

超级字符串对象
trim	去除左右两边的空白
contains	检测string是否包含给定的子串
dasherize	将字符串中的"_"代替成"-"
camelize	将字符串改成驼峰风格
capitalize	首字符大写
startsWith	检测string以给定的子串开头
endsWith	检测string以给定的子串结束
empty	检测string是否一个字符也没有
blank	检测string是否全部由空白字符构成
times	字符串乘法，传入一个数字，作为原字符串的倍数