export - / import-single-Klasse Methode unter Verwendung von ES6-Modulen?

Sagen wir, ich habe eine einfache Klasse, wie dies in fileA.js:

class foo {
    constructor(x) {
        this.name = x
    }

    fooMethod(x) {
        return x + 'hello';
    }
}

Und ich will den import und die Nutzung fooMethod im fileB.js wie diese:

import { fooMethod } from './fileA';

class bar() {
    ...
    barMethod(x) {
        return fooMethod(x);
    }
}

Wie würde ich schreiben, die export im fileA um dies zu erreichen?

export { foo.prototype.fooMethod as fooMethod } arbeiten könnte.
Wie wollen Sie es aufrufen?
Nein, dies würde den export der Klasse, nicht der bloßen Methode.
Aber als Lux hingewiesen hat, ist es wahrscheinlich besser zu finden, eine alternative Art der Strukturierung von (Prototyp-Methoden aufgerufen werden sollen auf etwas, das nicht auf Ihre eigenen).
Ich aktualisiert die Frage.

InformationsquelleAutor Rotareti | 2016-07-11

7

Würden Sie haben, um es zu exportieren, die auf dem Prototyp. Aber denken Sie daran, dass, wenn Sie das tun, werden Sie nicht rufen Sie die Funktion in der Klasse/Objekt-Kontext:
```
export foo.prototype. fooMethod
```
Aber ich würde Ihnen empfehlen, es nicht zu tun.

Okay, aufgrund Ihres Kommentars, den Sie wollen, ein guter Weg, um eine gemeinsame Funktionalität für zwei Klassen, die nicht verlängern, der gleichen Basis-Klasse. Eine einfache Möglichkeit ist das importieren der utility-Funktion, die aus zwei Klassen:

foo.js
```
export function foo() {
  return this.name;
}
```
ein.js
```
import {foo} from 'foo';
export class A extends BaseA {
  foo() {
    foo.apply(this, arguments);
  }
}
```
b.js
```
import {foo} from 'foo';
export class B extends BaseB {
  foo() {
    foo.apply(this, arguments);
  }
}
```
Dies ist ein gutes Muster und eignet sich gut für eine einzelne Funktion, hat aber Ihre Grenzen, wenn Sie sich bewerben möchten komplexere Funktionalität. Ein guter Weg dies zu erreichen ist eine Misch Muster:

foo.js
```
export default superClass => class extends superClass {
  foo() {
    return this.name;
  }
};
```
ein.js
```
import foo from 'foo';
export class A extends foo(BaseA) {
  ..
}
```
b.js
```
import foo from 'foo';
export class B extends foo(BaseB) {
  ..
}
```
Dadurch wird Ihr mischen, erstellen Sie eine neue anonyme Klasse, die zwischen Ihre Klasse 'A'/'B' und 'BaseA'/'BaseB', die die gemeinsame Funktion foo.

Also ist der einzige Weg, um fooMethod im fileB mit dem Zusammenhang von Klasse foo ist das importieren der gesamten foo Klasse, und rufen Sie fooMethod aus?
Nun, würden Sie brauchen, ein Objekt zu haben, ein Zusammenhang, nicht eine Klasse. So müssten Sie zum initialisieren eines Objekts. Vielleicht erstellen Sie ein singleton?
Das mischen Muster sieht sehr interessant aus! Könnte ich eine Klasse erweitern, mit mehreren foo-wie Klassen, die auf diese Weise: class A extends fooOne(fooTwo(Base))?
ja sicher!

InformationsquelleAutor Lux
6

Haben Sie, exportieren Sie es als eine separate variable/Konstante, wie diese:
```
class Foo {
  fooMethod() {};
}

export const fooMethod = Foo.prototype.fooMethod;
```
Sehen Babel/repl

Bearbeiten

Es stellt sich heraus in den Anmerkungen, die Sie nicht wirklich brauchen, eine Instanz-Methode (die Sie nicht verwenden this). Ich würde nur die Definition und Verwendung einer regulären Funktion:
```
export function fooMethod(x) {
    return x + 1;
}
```
InformationsquelleAutor Tamas Hegedus

-2

Ist es besser, Sie nicht export-Methoden.
Folgen Sie dieser.

fileA

export class foo {
    constructor(x) {
        this.name = x
    }

    fooMethod(x) {
        return x + 'hello';
    }
}

app.Komponente.ts

import { Component } from '@angular/core';
import { foo } from './fileA';

@Component({
  moduleId: module.id,
  selector: 'app-root',
  templateUrl: 'app.component.html',
  styleUrls: ['app.component.css']
})
export class AppComponent {
  title = 'app works!';
  constructor(private fooClass: foo){
      this.fooClass.fooMethod('');
  }
}

Es gibt keinen Hinweis in der Frage, daß die OP ist mit TS oder Eckig, so dass Ihr Beispiel hat eine Menge Lärm. On top of, die du nicht erklären, warum dies besser ist, und verpasst haben die Tatsache fooMethod können statisch sein.

InformationsquelleAutor Paulo Roberto Dalmas Junior

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.