Verfügt JavaScript über einen Schnittstellentyp (wie z. B. Java's 'interface')?

Question

Ich lerne wie man OOP mit JavaScript macht . Verfügt es über ein Schnittstellenkonzept (wie das von Java interface ) ?

Ich könnte also einen Hörer erstellen...

Answer 1

Dies ist alt, aber ich habe Schnittstellen implementiert, die auf ES6 ohne Transpiller verwendet werden können.

https://github.com/jkutianski/ES6-Interfaces

Answer 2

Auch mich hat es gereizt, eine Lösung zu finden, um Schnittstellen mit möglichst geringen Auswirkungen nachzubilden.

Eine Lösung könnte darin bestehen, ein Werkzeug zu entwickeln:

/**
@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;
};

Beispiel für die Verwendung :

// 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();

Mit Klassen

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]];
    }
}

Es ist immer noch ein wenig Performance-verzehrend und erfordern Abhängigkeit von der Schnittstelle Klasse, kann aber für Debug- oder Open-Api von Nutzen sein.

Answer 3

Nein, aber es hat Mixins. Sie können abstrakte Unterklassen oder Mixins als Alternative verwenden https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#mix-ins