ईएस 6 / नोड 4 में इंटरफेस बनाने का एक तरीका है?


110

ES6 पूरी तरह से नोड 4 में उपलब्ध है। मैं सोच रहा था कि क्या इसमें विधि अनुबंधों को परिभाषित करने के लिए इंटरफ़ेस की अवधारणा शामिल है MyClass implements MyInterface

मैं अपने Googling के साथ बहुत कुछ नहीं पा सकता, लेकिन शायद एक अच्छी चाल या वर्कअराउंड उपलब्ध है।


2
पूरी तरह से? दूर तक नहीं।
बर्गी १

1
JS अभी भी बतख टाइपिंग का उपयोग करता है । कोई सांख्यिकीय रूप से लागू "विधि अनुबंध" नहीं हैं। यदि आप उन्हें गतिशील रूप से परीक्षण करना चाहते हैं, तो आप आसानी से अपना स्वयं का इंटरफ़ेस परीक्षक लिख सकते हैं।
बरगी

26
पार्टी के लिए देर से, लेकिन सवाल असहमत है। यदि अपेक्षित सुविधा मौजूद है तो ओपी पुष्टि चाहता है। वर्गों के लिए नया, सरलीकृत, वाक्यविन्यास लंबे समय से अपेक्षित है और व्यापक रूप से इसका उपयोग किया जाएगा। लेकिन अन्य भाषाओं में बहुत अच्छे कारण के लिए इंटरफेस आम हैं। मैं भी आश्चर्यचकित था, और निराश था, इंटरफेस सीखने के लिए ES2015 का हिस्सा नहीं है। यह देखते हुए कि यह एक आम खोज है, IMHO यह पूछना अनुचित नहीं है कि क्या कोई सुझाया गया वर्कअराउंड है।

9
पृथ्वी पर यह कैसा विषय है? इंटरफेस प्रोग्रामिंग तकनीक है उत्पाद नहीं। प्रश्न मान्य है और ईसीएमए स्क्रिप्ट 6 की रिलीज के साथ एक अच्छा है जो जावा में कक्षा की परिभाषाओं की तरह लाता है। मुझे लगता है कि इस विषय का समापन समझ की कमी को दर्शाता है और कैसे स्टैक ओवरफ्लो पर अंक प्रणाली की क्षमता के साथ संबंध नहीं है।
एंड्रयू एस

4
शाब्दिक रूप से इस प्रश्न पर ओपी (पूछना) हमें किसी पुस्तक, उपकरण, सॉफ्टवेयर लाइब्रेरी, ट्यूटोरियल या अन्य ऑफ-साइट संसाधन की सिफारिश या खोजने के लिए नहीं करता है ।
लियाम

जवाबों:


90

इंटरफेस ईएस 6 का हिस्सा नहीं हैं, लेकिन कक्षाएं हैं।

यदि आपको वास्तव में उनकी आवश्यकता है, तो आपको टाइपस्क्रिप्ट को देखना चाहिए जो उनका समर्थन करते हैं


1
"उन्हें" इंटरफेस किया जा रहा है। एफडब्ल्यूआईडब्ल्यू आपको ऊपर दिए गए ट्रांसपिलर के लिंक पर ध्यान से विचार करने की आवश्यकता हो सकती है। बिल्कुल वैसा नहीं जैसा मुझे उम्मीद थी, लेकिन करीब है।

एक नोट: जहाँ तक मुझे पता है कि टाइपस्क्रिप्ट ट्रांसपाइल्स में शुद्ध इंटरफ़ेस कुछ भी नहीं है। केवल यदि आप उनका उपयोग करते हैं तो ट्रांसप्लड कोड में एक निश्चित तर्क होता है।
डैनियल डेनिलेकी

9

टिप्पणियों में देबीजज ने नीचे लिखा लेख डिजाइन पैटर्न (इंटरफेस, कक्षाओं के आधार पर) के बारे में अधिक बताता है:

http://loredanacirstea.github.io/es6-design-patterns/

जावास्क्रिप्ट में डिजाइन पैटर्न बुक आपके लिए भी उपयोगी हो सकती है:

http://addyosmani.com/resources/essentialjsdesignpatterns/book/

डिजाइन पैटर्न = कक्षाएं + इंटरफ़ेस या कई विरासत

ES6 JS में कारखाना पैटर्न का एक उदाहरण (चलाने के लिए: नोड example.js):

"use strict";

// Types.js - Constructors used behind the scenes

// A constructor for defining new cars
class Car {
  constructor(options){
    console.log("Creating Car...\n");
    // some defaults
    this.doors = options.doors || 4;
    this.state = options.state || "brand new";
    this.color = options.color || "silver";
  }
}

// A constructor for defining new trucks
class Truck {
  constructor(options){
    console.log("Creating Truck...\n");
    this.state = options.state || "used";
    this.wheelSize = options.wheelSize || "large";
    this.color = options.color || "blue";
  }
}


// FactoryExample.js

// Define a skeleton vehicle factory
class VehicleFactory {}

// Define the prototypes and utilities for this factory

// Our default vehicleClass is Car
VehicleFactory.prototype.vehicleClass = Car;

// Our Factory method for creating new Vehicle instances
VehicleFactory.prototype.createVehicle = function ( options ) {

  switch(options.vehicleType){
    case "car":
      this.vehicleClass = Car;
      break;
    case "truck":
      this.vehicleClass = Truck;
      break;
    //defaults to VehicleFactory.prototype.vehicleClass (Car)
  }

  return new this.vehicleClass( options );

};

// Create an instance of our factory that makes cars
var carFactory = new VehicleFactory();
var car = carFactory.createVehicle( {
            vehicleType: "car",
            color: "yellow",
            doors: 6 } );

// Test to confirm our car was created using the vehicleClass/prototype Car

// Outputs: true
console.log( car instanceof Car );

// Outputs: Car object of color "yellow", doors: 6 in a "brand new" state
console.log( car );

var movingTruck = carFactory.createVehicle( {
                      vehicleType: "truck",
                      state: "like new",
                      color: "red",
                      wheelSize: "small" } );

// Test to confirm our truck was created with the vehicleClass/prototype Truck

// Outputs: true
console.log( movingTruck instanceof Truck );

// Outputs: Truck object of color "red", a "like new" state
// and a "small" wheelSize
console.log( movingTruck );

34
तो यहाँ एक इंटरफ़ेस कहाँ है जो मैं दूसरों के साथ बना सकता हूँ?
दिमित्री ज़ैतसेव

इस साइट पर कुछ गहरी व्याख्याएँ हैं: sitepoint.com/object-oriented-javascript-deep-dive-es6-classes
42n4

2
इस साइट पर ES6 के लिए
ES5

8

यह देखते हुए कि ECMA एक 'क्लास-फ़्री' भाषा है, शास्त्रीय रचना को लागू नहीं करती - मेरी नज़र में - बहुत मायने रखती है। खतरा यह है कि, ऐसा करने में, आप प्रभावी रूप से भाषा को फिर से इंजीनियर करने का प्रयास कर रहे हैं (और, यदि कोई व्यक्ति इसके बारे में दृढ़ता से महसूस करता है, तो उपरोक्त प्रकार के टाइपस्क्रिप्ट जैसे उत्कृष्ट समग्र समाधान हैं जो पहिया को फिर से स्थापित करने को कम करते हैं)

अब यह कहना नहीं है कि रचना प्लेन ओल्ड जेएस में प्रश्न से बाहर है। मैंने कुछ समय पहले इस पर शोध किया था। सबसे मजबूत उम्मीदवार जिसे मैंने वस्तु प्रोटोटाइप प्रतिमान के भीतर रचना से निपटने के लिए देखा है , वह स्टैम्पिट है , जिसका उपयोग मैं अब कई परियोजनाओं में करता हूं। और, महत्वपूर्ण रूप से, यह एक अच्छी तरह से व्यक्त विनिर्देश का पालन करता है।

टिकटों के बारे में अधिक जानकारी यहाँ


1
मैं -1 के साथ भी अपनी पोस्ट के साथ खड़ा हूं। अफसोस की बात है कि कभी-कभी एसओ का लोकतंत्र है। मुझे आशा है कि किसी को लिंक उपयोगी लगता है। स्टैम्पिट आपके समय के लायक है।
जे एडवर्ड्स

-1 कोई अंतिम फैसला नहीं है। आपकी पोस्ट + 100 / -1 तक समाप्त हो सकती है। हालाँकि मुझे अभी भी लगता है कि यह अस्पष्ट है। जेएस अब "क्लास-फ्री" नहीं है। मुझे संदेह है कि "शास्त्रीय रचना" का मतलब यह भी नहीं समझा जाएगा कि आपका क्या मतलब है: विरासत। (संपूर्ण विरासत बनाम रचना पवित्र युद्ध पर विचार करें।) यह भी स्पष्ट नहीं है कि "प्लेन ओल्ड जेएस" क्या है। ES5? अधिक क्रिया सिंटैक्स के साथ यद्यपि, यह उन तकनीकों का समर्थन करता है जो अब अधिक व्यापक हैं, जैसे "सच" मिक्स-इन्स । टिकट दिलचस्प लगते हैं, मिक्स-इन पर उनके फायदे क्या हैं?
4: 44

क्लास कीवर्ड वाक्य-रचना चीनी है। जेएस - ईएस ^ 6 या अन्यथा - एक वर्ग भाषा नहीं है। यह केवल ES5 में पारंपरिक फ़ंक्शन कंस्ट्रक्टर दृष्टिकोण को सजाता है। "सादे पुराने जेएस" खुशी से ईएस के जेएस कार्यान्वयन के किसी भी परिभाषित करता है, इसलिए। सच कहूँ तो, मैं चाहता हूँ कि निर्णय भाषा में वर्ग के विचार को आगे बढ़ाने के लिए नहीं किया गया था quora.com/Are-ES6-classes-bad-for-JavaScript। टिकटें जेएस की ताकत को बेहतर तरीके से दर्शाती हैं। Stampit.js.org कक्षाओं से मतभेदों का एक अच्छा हिस्सा देता है। अंततः, यह एक अधिक व्यावहारिक पद्धति है।
जे एडवर्ड्स

1
लेकिन फिर, "वर्ग भाषा" क्या है? सी ++? classके लिए सिर्फ एक पर्याय है struct। स्मालटाक जैसी सही मायने में क्लासिक भाषा? यह प्रोटोटाइप और यहां तक ​​कि उदाहरणों के गतिशील विस्तार की अनुमति देता है
ᆼ '

यह एक उचित बिंदु है। मैं एक वर्ग की भाषा को एक भाषा के रूप में परिभाषित करूंगा जो आंतरिक रूप से OOP है। MDN से: "जावास्क्रिप्ट एक प्रोटोटाइप-आधारित, बहु-प्रतिमान, गतिशील भाषा है, जो वस्तु-उन्मुख, आवश्यक और सहायक (जैसे कार्यात्मक प्रोग्रामिंग) शैलियों का समर्थन करता है।" google.com/url?sa=t&source=web&rct=j&url=https://…
Jay Edwards

6

समस्या के लिए यह मेरा समाधान है। आप एक इंटरफेस को दूसरे के साथ ओवरराइड करके कई इंटरफेस को 'कार्यान्वित' कर सकते हैं।

class MyInterface {
    // Declare your JS doc in the Interface to make it acceable while writing the Class and for later inheritance
    /**
     * Gives the sum of the given Numbers
     * @param {Number} a The first Number
     * @param {Number} b The second Number
     * @return {Number} The sum of the Numbers
     */
    sum(a, b) { this._WARNING('sum(a, b)'); }


    // delcare a warning generator to notice if a method of the interface is not overridden
    // Needs the function name of the Interface method or any String that gives you a hint ;)
    _WARNING(fName='unknown method') {
        console.warn('WARNING! Function "'+fName+'" is not overridden in '+this.constructor.name);
    }
}

class MultipleInterfaces extends MyInterface {
    // this is used for "implement" multiple Interfaces at once
    /**
     * Gives the square of the given Number
     * @param {Number} a The Number
     * @return {Number} The square of the Numbers
     */
    square(a) { this._WARNING('square(a)'); }
}

class MyCorrectUsedClass extends MyInterface {
    // You can easy use the JS doc declared in the interface
    /** @inheritdoc */
    sum(a, b) {
        return a+b;
    }
}
class MyIncorrectUsedClass extends MyInterface {
    // not overriding the method sum(a, b)
}

class MyMultipleInterfacesClass extends MultipleInterfaces {
    // nothing overriden to show, that it still works
}


let working = new MyCorrectUsedClass();

let notWorking = new MyIncorrectUsedClass();

let multipleInterfacesInstance = new MyMultipleInterfacesClass();

// TEST IT

console.log('working.sum(1, 2) =', working.sum(1, 2));
// output: 'working.sum(1, 2) = 3'

console.log('notWorking.sum(1, 2) =', notWorking.sum(1, 2));
// output: 'notWorking.sum(1, 2) = undefined'
// but also sends a warn to the console with 'WARNING! Function "sum(a, b)" is not overridden in MyIncorrectUsedClass'

console.log('multipleInterfacesInstance.sum(1, 2) =', multipleInterfacesInstance.sum(1, 2));
// output: 'multipleInterfacesInstance.sum(1, 2) = undefined'
// console warn: 'WARNING! Function "sum(a, b)" is not overridden in MyMultipleInterfacesClass'

console.log('multipleInterfacesInstance.square(2) =', multipleInterfacesInstance.square(2));
// output: 'multipleInterfacesInstance.square(2) = undefined'
// console warn: 'WARNING! Function "square(a)" is not overridden in MyMultipleInterfacesClass'

संपादित करें:

मैंने कोड में सुधार किया है इसलिए अब आप विस्तार में बस (बेसक्लास, इंटरफ़ेस 1, इंटरफ़ेस 2, ...) का उपयोग कर सकते हैं।

/**
* Implements any number of interfaces to a given class.
* @param cls The class you want to use
* @param interfaces Any amount of interfaces separated by comma
* @return The class cls exteded with all methods of all implemented interfaces
*/
function implement(cls, ...interfaces) {
    let clsPrototype = Object.getPrototypeOf(cls).prototype;
    for (let i = 0; i < interfaces.length; i++) {
        let proto = interfaces[i].prototype;
        for (let methodName of Object.getOwnPropertyNames(proto)) {
            if (methodName!== 'constructor')
                if (typeof proto[methodName] === 'function')
                    if (!clsPrototype[methodName]) {
                        console.warn('WARNING! "'+methodName+'" of Interface "'+interfaces[i].name+'" is not declared in class "'+cls.name+'"');
                        clsPrototype[methodName] = proto[methodName];
                    }
        }
    }
    return cls;
}

// Basic Interface to warn, whenever an not overridden method is used
class MyBaseInterface {
    // declare a warning generator to notice if a method of the interface is not overridden
    // Needs the function name of the Interface method or any String that gives you a hint ;)
    _WARNING(fName='unknown method') {
        console.warn('WARNING! Function "'+fName+'" is not overridden in '+this.constructor.name);
    }
}


// create a custom class
/* This is the simplest example but you could also use
*
*   class MyCustomClass1 extends implement(MyBaseInterface) {
*       foo() {return 66;}
*   }
*
*/
class MyCustomClass1 extends MyBaseInterface {
    foo() {return 66;}
}

// create a custom interface
class MyCustomInterface1 {
     // Declare your JS doc in the Interface to make it acceable while writing the Class and for later inheritance

    /**
     * Gives the sum of the given Numbers
     * @param {Number} a The first Number
     * @param {Number} b The second Number
     * @return {Number} The sum of the Numbers
     */
    sum(a, b) { this._WARNING('sum(a, b)'); }
}

// and another custom interface
class MyCustomInterface2 {
    /**
     * Gives the square of the given Number
     * @param {Number} a The Number
     * @return {Number} The square of the Numbers
     */
    square(a) { this._WARNING('square(a)'); }
}

// Extend your custom class even more and implement the custom interfaces
class AllInterfacesImplemented extends implement(MyCustomClass1, MyCustomInterface1, MyCustomInterface2) {
    /**
    * @inheritdoc
    */
    sum(a, b) { return a+b; }

    /**
    * Multiplies two Numbers
    * @param {Number} a The first Number
    * @param {Number} b The second Number
    * @return {Number}
    */
    multiply(a, b) {return a*b;}
}


// TEST IT

let x = new AllInterfacesImplemented();

console.log("x.foo() =", x.foo());
//output: 'x.foo() = 66'

console.log("x.square(2) =", x.square(2));
// output: 'x.square(2) = undefined
// console warn: 'WARNING! Function "square(a)" is not overridden in AllInterfacesImplemented'

console.log("x.sum(1, 2) =", x.sum(1, 2));
// output: 'x.sum(1, 2) = 3'

console.log("x.multiply(4, 5) =", x.multiply(4, 5));
// output: 'x.multiply(4, 5) = 20'

0

ऐसे पैकेज हैं जो इंटरफेस को अनुकरण कर सकते हैं।

आप es6- इंटरफ़ेस का उपयोग कर सकते हैं


2
आपके उत्तर के साथ समस्या यह है कि उसने ऐसा करने के लिए "टूल" नहीं मांगा। लेकिन यह कैसे किया जाता है केनी एक उत्तर को और अधिक सही कर देता था जो यह बताता था कि यह कैसे किया गया था।
जियानफ्रेंसिको ऑरेचिया
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.