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;

<!doctype html>
<html dir="ltr" lang="zh-CN" >
  <head id="head">
    <meta charset="utf-8"/>
    <title>超级字符串对象 by司徒正美</title>

}
    </script>
  </head>
  <body>

</body>
</html>

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

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

Ruby's Louvre

导航

公告

javascript 超级字符串对象