模拟jquery的javascript自定义可扩展插件

最新推荐文章于 2024-09-21 11:29:05 发布

xiao88xin

最新推荐文章于 2024-09-21 11:29:05 发布

阅读量515

点赞数

分类专栏： javascript 文章标签： javascript

本文链接：https://blog.csdn.net/xiao88xin/article/details/46558803

版权

javascript 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

<html>
<head>
    <title></title>
</head>
<body>
<script>




  (function(gg, undefined ){
      var Test = function(selector){
          return new Test.fn.init(selector);
      },toString = Object.prototype.toString,hasOwnProperty = Object.prototype.hasOwnProperty;

      Test.fn = Test.prototype = {
          
          init: function(selector){
            this.name2 = "test2";
            return this || [];
          },
          name1 : "test",
          name2 : "test",
          getName : function(){
              return this.name1+" "+this.name2;
          }
      };

      Test.fn.init.prototype = Test.fn;

      //扩展静态方法
      Test.extend = Test.fn.extend = function(){
          // copy reference to target object
          var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;

          // Handle a deep copy situation
          if ( typeof target === "boolean" ) {
              deep = target;
              target = arguments[1] || {};
              // skip the boolean and the target
              i = 2;
          }

          // Handle case when target is a string or something (possible in deep copy)
          if ( typeof target !== "object" && !Test.isFunction(target) ) {
              target = {};
          }

          // extend jQuery itself if only one argument is passed
          if ( length === i ) {
              target = this;
              --i;
          }
          for ( ; i < length; i++ ) {
              // Only deal with non-null/undefined values
              if ( (options = arguments[ i ]) != null ) {
                  // Extend the base object
                  for ( name in options ) {
                      src = target[ name ];
                      copy = options[ name ];
                      // Prevent never-ending loop
                      if ( target === copy ) {
                          continue;
                      }
                      // Recurse if we're merging object literal values or arrays
                      if ( deep && copy && ( Test.isPlainObject(copy) || Test.isArray(copy) ) ) {
                          var clone = src && ( Test.isPlainObject(src) || Test.isArray(src) ) ? src
                                  : Test.isArray(copy) ? [] : {};
                          // Never move original objects, clone them
                          target[ name ] = Test.extend( deep, clone, copy );
                          // Don't bring in undefined values
                      } else if ( copy !== undefined ) {
                          target[ name ] = copy;
                      }
                  }
              }
          }
          // Return the modified object
          return target;
      };
      Test.extend({
         // getName : function(){
          //    return "test---";
          //},
          isFunction: function( obj ) {
            return toString.call(obj) === "[object Function]";
          },
          isArray: function( obj ) {
              console.log(this == window);
              return toString.call(obj) === "[object Array]";
          },

          isPlainObject: function( obj ) {
              // Must be an Object.
              // Because of IE, we also have to check the presence of the constructor property.
              // Make sure that DOM nodes and window objects don't pass through, as well
              if ( !obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval ) {
                  return false;
              }

              // Not own constructor property must be Object
              if ( obj.constructor
                      && !hasOwnProperty.call(obj, "constructor")
                      && !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf") ) {
                  return false;
              }

              // Own properties are enumerated firstly, so to speed up,
              // if last one is own, then all properties are own.

              var key;
              for ( key in obj ) {}

              return key === undefined || hasOwnProperty.call( obj, key );
          }
      });
      
      gg.aTest = Test;
  })(window);

  aTest.extend({
    selfDefine : function(){
      return '343';
    }
  });
  console.log(aTest('#test1').getName());
  console.log(aTest.isArray([]));
  console.log(aTest.selfDefine());


</body>
</html>

//aTest完全模拟jQuery插件，aTest.exntend是直接从jquery中copy出来的代码实现静态方法和对象实例方法扩展，自己标记下。