JavaScript设计模式之一Interface接口

最新推荐文章于 2024-04-14 05:48:15 发布

JAVA之迷_

最新推荐文章于 2024-04-14 05:48:15 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏： ======所有内容====== 设计模式 html_js_jquery_ajax WEB开发由浅入深

本文链接：https://blog.youkuaiyun.com/loganwong/article/details/24512325

======所有内容====== 同时被 3 个专栏收录

589 篇文章

订阅专栏

html_js_jquery_ajax

63 篇文章

订阅专栏

设计模式

20 篇文章

订阅专栏

本文探讨了JavaScript中如何实现类似Interface的概念，通过实例解释其在类型检查和确保对象符合特定规范方面的作用。虽然JavaScript本身不直接支持Interface，但通过一些技巧可以达到相似的效果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

如何用面向对象的思想来写JavaScript，对于初学者应该是比较难的，我们经常用的JQuery其实也是用面向对象的思想去封装的，今天我们来看看如何在Javascript中用Interface，在C#还是JAVA中都应该面向接口设计我们的程序，在C#和Java中都Interface这样的关键字，但是JavaScript中没有相应的机制，但是Javascript很灵活，我们可以用它的特性去模仿Interface，但是我们需要加入一些methods来做check的动作。

我们来看下一个Interface的作用：继承了这个Interface就必须要实现这个Interface中定义的方法（方法签名）//JavaScript 现在还做不到方法的签名的约束

           
            var
             Interface 
            =
             
            function
             (name, methods) {
        
            if
             (arguments.length 
            !=
             
            2
            ) {
            
            throw
             
            new
             Error(
            "
            the interface length is bigger than 2
            "
            );
        }
        
            this
            .Name 
            =
             name;
        
            this
            .Method 
            =
             [];
        
            for
             (
            var
             i 
            =
             
            0
            ; i 
            <
             methods.length; i
            ++
            ) {
        
            if
            (
            typeof
             methods[i]
            !==
             
            '
            string
            '
            ) {
        
            throw
             
            new
             Error(
            "
            the method name is not string
            "
            );
        }
        
            this
            .Method.push(methods[i]);
        }
    }
    
            /*
            static method in interface
            */
            
    Interface.ensureImplement 
            =
             
            function
             (object) {
        
            if
             (arguments.length 
            <
             
            2
            ) {
            
            throw
             
            new
             Error(
            "
            there is not Interface or the instance
            "
            );
        }

        
            for
             (
            var
             i 
            =
             
            1
            ; i 
            <
             arguments.length; i
            ++
            ) {
            
            var
             interface1 
            =
             arguments[i];
            
            if
             (interface1.constructor 
            !==
             Interface) {
                
            throw
             
            new
             Error(
            "
            the argument is not interface
            "
            );
            }
            
            for
             (
            var
             j 
            =
             
            0
            ; j 
            <
             interface1.Method.length; j
            ++
            ) {
                
            var
             method 
            =
             interface1.Method[j];
                
            if
             (
            !
            object[method] 
            ||
             
            typeof
             object[method] 
            !==
             
            '
            function
            '
            ) {
                    
            throw
             
            new
             Error(
            "
            you instance doesn't implement the interface
            "
            );
                   
                }
            }
        }
    }

我们来分析一下code，我们现在的做法是用来比较一个Instance中的方法名在接口中是否定义了。

我先定义一个接口（2个参数），第二个参数是接口中的方法名。Check方法用简单的2层for循环来做比较动作。

我们来看下如何去用这个接口：

           
             
            var
             Person 
            =
             
            new
             Interface(
            "
            Person
            "
            , [
            "
            GetName
            "
            , 
            "
            GetAge
            "
            ]);
  
    
            var
             Man 
            =
             
            function
             (name, age) {
        
            this
            .Name 
            =
             name;
        
            this
            .Age 
            =
             age;
    }
    Man.prototype 
            =
             { GetName: 
            function
             () { 
            return
             
            this
            .Name; },
      
            //
              GetAge: function () { return this.Age; }
            

                }
    
            var
             test 
            =
             
            function
             (instance) {   
            Interface.ensureImplement(instance, Person);   
        
            var
             name 
            =
             instance.GetName();
        alert(name);

    }
    test(
            new
             Man(
            "
            Alan
            "
            ,
            20
            ));