JavaScript是否具有接口类型(例如Java的“接口”)?

2020/10/02 11:01 · javascript ·  · 0评论

我正在学习如何使用JavaScript进行OOP它具有接口概念(例如Java的接口interface)吗?

这样我就可以创建一个侦听器...

没有“此类必须具有这些功能”的概念(也就是说,本身没有接口),因为:

  1. JavaScript继承基于对象,而不是类。除非您意识到:这不是什么大不了的事情
  2. JavaScript是一种非常动态的类型化语言-您可以使用适当的方法创建对象,这将使其符合接口,然后取消定义使其符合要求的所有内容颠覆类型系统非常容易-甚至偶然!-首先尝试创建类型系统是不值得的。

相反,JavaScript使用所谓的鸭子类型(就JS而言,如果它像鸭子一样行走,而像鸭子一样嘎嘎叫,那就是鸭子。)如果您的对象具有quack(),walk()和fly()方法,则代码可以在期望的地方使用一个可以走路,嘎嘎和飞起来的对象,而无需实现某些“ Duckable”接口。接口恰好是代码使用的一组函数(以及这些函数的返回值),使用鸭子输入即可免费获得。

现在,这并不是说,如果您尝试调用,您的代码不会中途失败some_dog.quack()您将收到TypeError。坦白说,如果您要让狗嘎嘎叫,那您的问题就会大一些。可以说,当您将所有鸭子连续放置时,鸭子打字最有效,除非您将它们视为普通动物,否则不要让它们混在一起。换句话说,即使界面是流畅的,它仍然存在。将狗传递给期望它一开始就发出嘎嘎叫声的代码通常是错误的。

但是,如果您确定自己做的正确,则可以在尝试使用特定方法之前通过测试特定方法的存在来解决“嘎嘎狗”问题。就像是

if (typeof(someObject.quack) == "function")
{
    // This thing can quack
}

因此,您可以在使用前检查所有可以使用的方法。但是,语法有点丑陋。有一种更漂亮的方法:

Object.prototype.can = function(methodName)
{
     return ((typeof this[methodName]) == "function");
};

if (someObject.can("quack"))
{
    someObject.quack();
}

这是标准的JavaScript,因此可以在任何值得使用的JS解释器中使用。它具有像英语一样阅读的额外好处。

对于现代浏览器(即IE 6-8以外的几乎所有浏览器),甚至都可以通过以下方式阻止该属性显示for...in

Object.defineProperty(Object.prototype, 'can', {
    enumerable: false,
    value: function(method) {
        return (typeof this[method] === 'function');
    }
}

问题在于IE7对象根本没有.defineProperty,而在IE8中,据称它仅适用于宿主对象(即DOM元素等)。如果兼容性是一个问题,则不能使用.defineProperty(我什至不会提到IE6,因为在中国以外它不再相关了。)

另一个问题是,某些编码风格喜欢假设每个人都编写了不好的代码,并禁止修改Object.prototype以防有人盲目使用for...in如果您对此有所关注,或者正在使用这样做的代码(IMO损坏),请尝试稍有不同的版本:

function can(obj, methodName)
{
     return ((typeof obj[methodName]) == "function");
}

if (can(someObject, "quack"))
{
    someObject.quack();
}

拿起Dustin Diaz的“ JavaScript设计模式的副本有几章专门介绍如何通过Duck Typing实现JavaScript接口。读起来也不错。但是,没有,没有语言的本地实现,您必须使用Duck Type

// example duck typing method
var hasMethods = function(obj /*, method list as strings */){
    var i = 1, methodName;
    while((methodName = arguments[i++])){
        if(typeof obj[methodName] != 'function') {
            return false;
        }
    }
    return true;
}

// in your code
if(hasMethods(obj, 'quak', 'flapWings','waggle')) {
    //  IT'S A DUCK, do your duck thang
}

JavaScript(ECMAScript版本3)具有implements保留字,以备将来使用我认为这正是为此目的而设计的,但是,由于急于将其发布出去,他们没有时间来定义如何处理该规范,因此,目前,浏览器除了执行任何操作让它坐在那里,如果您尝试将其用于某些东西,有时会抱怨。

Object.implement(Interface)只要在给定对象中未实现一组特定的属性/功能时,就可以创建带有逻辑的自定义方法,并且这种方法确实很容易

我写了一篇有关面向对象 的文章,其中使用了我自己的符号,如下所示

// Create a 'Dog' class that inherits from 'Animal'
// and implements the 'Mammal' interface
var Dog = Object.extend(Animal, {
    constructor: function(name) {
        Dog.superClass.call(this, name);
    },
    bark: function() {
        alert('woof');
    }
}).implement(Mammal);

有很多方法可以使这只猫变皮,但这是我用于自己的Interface实现的逻辑。我发现我更喜欢这种方法,并且易于阅读和使用(如您在上面看到的)。这确实意味着增加了Function.prototype一些人可能会遇到问题的“实现”方法,但我发现它的工作原理很不错。

Function.prototype.implement = function() {
    // Loop through each interface passed in and then check 
    // that its members are implemented in the context object (this).
    for(var i = 0; i < arguments.length; i++) {
       // .. Check member's logic ..
    }
    // Remember to return the class being tested
    return this;
}

JavaScript接口:

虽然JavaScript并没有interface型,它往往是需要时间。由于与JavaScript的动态性质和原型继承的使用相关的原因,很难确保类之间的接口一致-但是,可以这样做;并经常被模仿。

现在,有几种特殊的方法可以在JavaScript中模拟接口。方法上的差异通常可以满足某些需求,而其他需求则无法解决。通常,最健壮的方法过于繁琐,妨碍了实现者(开发人员)。

这是一种接口/抽象类的方法,该方法不是很麻烦,具有解释性,将抽象内部的实现保持在最低限度,并为动态或自定义方法留有足够的空间:

function resolvePrecept(interfaceName) {
    var interfaceName = interfaceName;
    return function curry(value) {
        /*      throw new Error(interfaceName + ' requires an implementation for ...');     */
        console.warn('%s requires an implementation for ...', interfaceName);
        return value;
    };
}

var iAbstractClass = function AbstractClass() {
    var defaultTo = resolvePrecept('iAbstractClass');

    this.datum1 = this.datum1 || defaultTo(new Number());
    this.datum2 = this.datum2 || defaultTo(new String());

    this.method1 = this.method1 || defaultTo(new Function('return new Boolean();'));
    this.method2 = this.method2 || defaultTo(new Function('return new Object();'));

};

var ConcreteImplementation = function ConcreteImplementation() {

    this.datum1 = 1;
    this.datum2 = 'str';

    this.method1 = function method1() {
        return true;
    };
    this.method2 = function method2() {
        return {};
    };

    //Applies Interface (Implement iAbstractClass Interface)
    iAbstractClass.apply(this);  // .call / .apply after precept definitions
};

参加者

戒律解析器

resolvePrecept函数是在Abstract类内部使用的实用程序和帮助函数其工作是允许对封装的规范(数据和行为)进行定制的实现处理它可能会引发错误或发出警告-并且-将默认值分配给Implementor类。

iAbstractClass

iAbstractClass定义要使用的接口。它的方法需要与其实现者类达成默契。此接口将每个规范分配给相同的确切规范名称空间-或-分配给Precept Resolver函数返回的任何内容。但是,默认协议解决了一个环境-实施者的规定。

实施者

实现者简单地(“一致”与接口iAbstractClass在这种情况下)和通过使用其应用于构造劫持iAbstractClass.apply(this)通过定义上面的数据和行为,然后劫持接口的构造函数(将Implementor的上下文传递给Interface构造函数),我们可以确保将添加Implementor的替代项,并且Interface将显示警告和默认值。

这是一种非常轻松的方法,在一段时间内以及在不同的项目中为我的团队和我都提供了很好的服务。但是,它确实有一些警告和缺点。

缺点

尽管这在很大程度上有助于实现整个软件的一致性,但它并没有实现真正的接口,而是模拟了它们。尽管定义,默认值和警告或错误已被阐明,但使用的表现是由开发人员强制执行和断言的(与许多JavaScript开发一样)。

这似乎是“ JavaScript接口”的最佳方法,但是,我希望看到以下解决方法:

  • 断言类型的断言
  • 签名断言
  • delete动作冻结对象
  • 断言JavaScript社区的特殊性中普遍存在或需要的其他任何事物

就是说,希望对我和我的团队有帮助。

希望任何仍在寻找答案的人都能找到帮助。

您可以尝试使用代理服务器(这是ECMAScript 2015以来的标准设置):https : //developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

latLngLiteral = new Proxy({},{
    set: function(obj, prop, val) {
        //only these two properties can be set
        if(['lng','lat'].indexOf(prop) == -1) {
            throw new ReferenceError('Key must be "lat" or "lng"!');
        }

        //the dec format only accepts numbers
        if(typeof val !== 'number') {
            throw new TypeError('Value must be numeric');
        }

        //latitude is in range between 0 and 90
        if(prop == 'lat'  && !(0 < val && val < 90)) {
            throw new RangeError('Position is out of range!');
        }
        //longitude is in range between 0 and 180
        else if(prop == 'lng' && !(0 < val && val < 180)) {
            throw new RangeError('Position is out of range!');
        }

        obj[prop] = val;

        return true;
    }
});

然后您可以轻松地说:

myMap = {}
myMap.position = latLngLiteral;

您需要Java中的接口,因为它是静态类型的,并且在编译期间应该知道类之间的协定。在JavaScript中则有所不同。JavaScript是动态类型的;这意味着当您获得对象时,您只需检查它是否具有特定的方法并调用它即可。

当您想使用转编译器时,可以尝试TypeScript。它支持ECMA草案功能(在提案中,接口称为“协议”),类似于coffeescript或babel之类的语言。

在TypeScript中,您的界面如下所示:

interface IMyInterface {
    id: number; // TypeScript types are lowercase
    name: string;
    callback: (key: string; value: any; array: string[]) => void;
    type: "test" | "notATest"; // so called "union type"
}

您不能做什么:

JavaScript中没有本机接口,有几种模拟接口的方法。我写了一个包

你可以在这里看到植入

Javascript没有接口。但是它可以是鸭子型的,可以在这里找到一个例子:

http://reinsbrain.blogspot.com/2008/10/interface-in-javascript.html

像这样的抽象接口

const MyInterface = {
  serialize: () => {throw "must implement serialize for MyInterface types"},
  print: () => console.log(this.serialize())
}

创建一个实例:

function MyType() {
  this.serialize = () => "serialized "
}
MyType.prototype = MyInterface

并使用它

let x = new MyType()
x.print()

我知道这是一个旧的,但是最近我发现自己越来越需要一个方便的API来根据接口检查对象。所以我写了这个:https : //github.com/tomhicks/methodical

也可以通过NPM获得: npm install methodical

它基本上完成了上面建议的所有操作,并提供了一些更严格的选项,并且所有这些都无需进行if (typeof x.method === 'function')样板工作。

希望有人发现它有用。

这是一个古老的问题,不过,这个话题永远不会困扰我。

由于此处和整个网络上的许多答案都集中在“强制”界面上,我想提出一个替代的观点:

当我使用行为相似的多个类(即实现一个interface时,我感到最缺乏接口

例如,我有一个电子邮件生成器,期望接收“电子邮件部分工厂”,“知道”如何生成部分的内容和HTML。因此,他们都需要有某种getContent(id)getHtml(content)方法。

我能想到的最接近接口的模式(尽管仍然是一种解决方法)使用的类将获得2个参数,它将定义2个接口方法。

这种模式的主要挑战在于,方法必须是static或必须作为实例本身的参数来访问其属性。但是,在某些情况下,我发现这种权衡值得麻烦。

class Filterable {
  constructor(data, { filter, toString }) {
    this.data = data;
    this.filter = filter;
    this.toString = toString;
    // You can also enforce here an Iterable interface, for example,
    // which feels much more natural than having an external check
  }
}

const evenNumbersList = new Filterable(
  [1, 2, 3, 4, 5, 6], {
    filter: (lst) => {
      const evenElements = lst.data.filter(x => x % 2 === 0);
      lst.data = evenElements;
    },
    toString: lst => `< ${lst.data.toString()} >`,
  }
);

console.log('The whole list:    ', evenNumbersList.toString(evenNumbersList));
evenNumbersList.filter(evenNumbersList);
console.log('The filtered list: ', evenNumbersList.toString(evenNumbersList));

这也困扰着我,以至于无法找到一种模拟接口的解决方案,以尽可能降低影响。

一种解决方案可能是制作工具:

/**
@parameter {Array|object} required : method name list or members types by their name
@constructor
*/
let Interface=function(required){
    this.obj=0;
    if(required instanceof Array){
        this.obj={};
        required.forEach(r=>this.obj[r]='function');
    }else if(typeof(required)==='object'){
        this.obj=required;
    }else {
        throw('Interface invalid parameter required = '+required);
    }
};
/** check constructor instance
@parameter {object} scope : instance to check.
@parameter {boolean} [strict] : if true -> throw an error if errors ar found.
@constructor
*/
Interface.prototype.check=function(scope,strict){
    let err=[],type,res={};
    for(let k in this.obj){
        type=typeof(scope[k]);
        if(type!==this.obj[k]){
            err.push({
                key:k,
                type:this.obj[k],
                inputType:type,
                msg:type==='undefined'?'missing element':'bad element type "'+type+'"'
            });
        }
    }
    res.success=!err.length;
    if(err.length){
        res.msg='Class bad structure :';
        res.errors=err;
        if(strict){
            let stk = new Error().stack.split('\n');
            stk.shift();
            throw(['',res.msg,
                res.errors.map(e=>'- {'+e.type+'} '+e.key+' : '+e.msg).join('\n'),
                '','at :\n\t'+stk.join('\n\t')
            ].join('\n'));

        }
    }
    return res;
};

使用示例:

// create interface tool
let dataInterface=new Interface(['toData','fromData']);
// abstract constructor
let AbstractData=function(){
    dataInterface.check(this,1);// check extended element
};
// extended constructor
let DataXY=function(){
    AbstractData.apply(this,[]);
    this.xy=[0,0];
};
DataXY.prototype.toData=function(){
    return [this.xy[0],this.xy[1]];
};

// should throw an error because 'fromData' is missing
let dx=new DataXY();

带班

class AbstractData{
    constructor(){
        dataInterface.check(this,1);
    }
}
class DataXY extends AbstractData{
    constructor(){
        super();
        this.xy=[0,0];
    }
    toData(){
        return [this.xy[0],this.xy[1]];
    }
}

它仍然需要一些性能,并且需要对Interface进行依赖,但是可以用于调试或打开api。

本文地址:http://javascript.askforanswer.com/javascriptshifoujuyoujiekouleixinglirujavadejiekou.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!