Generator.prototype.return()

value Optional

Der zurückzugebende Wert.

Ein Object mit zwei Eigenschaften:

done

Ein boolescher Wert:

• true, wenn der Kontrollfluss der Generatorfunktion das Ende erreicht hat.
• false, wenn der Kontrollfluss der Generatorfunktion das Ende noch nicht erreicht hat und noch weitere Werte erzeugen kann. Dies kann nur passieren, wenn das return in einem try...finally eingefangen wird und es mehr yield-Ausdrücke im finally-Block gibt.

value

Der als Argument angegebene Wert oder, wenn der yield-Ausdruck in einem try...finally eingeschlossen ist, der Wert, der im finally-Block ausgegeben/zurückgegeben wird.

TypeError

Wird ausgelöst, wenn der Generator bereits läuft.

Die return()-Methode kann beim Aufruf gesehen werden, als ob eine return value;-Anweisung im Körper des Generators an der aktuellen angehaltenen Position eingefügt wird, wobei value der an die return()-Methode übergebene Wert ist. Daher wird im typischen Ablauf durch Aufrufen von return(value) { done: true, value: value } zurückgegeben. Ist jedoch der yield-Ausdruck in einem try...finally-Block eingeschlossen, verlässt der Kontrollfluss nicht den Funktionskörper, sondern fährt im finally-Block fort. In diesem Fall kann der zurückgegebene Wert unterschiedlich sein und done kann sogar false sein, wenn es mehr yield-Ausdrücke im finally-Block gibt.

Das folgende Beispiel zeigt einen Generator und die return-Methode.

function* gen() {
  yield 1;
  yield 2;
  yield 3;
}

const g = gen();

g.next(); // { value: 1, done: false }
g.return("foo"); // { value: "foo", done: true }
g.next(); // { value: undefined, done: true }

Wenn return(value) auf einen Generator aufgerufen wird, der sich bereits im "abgeschlossenen" Zustand befindet, bleibt der Generator im "abgeschlossenen" Zustand.

Wenn kein Argument bereitgestellt wird, ist die value-Eigenschaft des zurückgegebenen Objekts undefined. Wird ein Argument bereitgestellt, wird es zum Wert der value-Eigenschaft des zurückgegebenen Objekts, es sei denn, der yield-Ausdruck ist in einem try...finally eingeschlossen.

function* gen() {
  yield 1;
  yield 2;
  yield 3;
}

const g = gen();
g.next(); // { value: 1, done: false }
g.next(); // { value: 2, done: false }
g.next(); // { value: 3, done: false }
g.next(); // { value: undefined, done: true }
g.return(); // { value: undefined, done: true }
g.return(1); // { value: 1, done: true }

Die Tatsache, dass die return-Methode aufgerufen wurde, kann dem Generator nur bekannt gemacht werden, wenn der yield-Ausdruck in einem try...finally-Block eingeschlossen ist.

Wenn die return-Methode auf einen Generator aufgerufen wird, der innerhalb eines try-Blocks angehalten ist, wird die Ausführung im Generator zum finally-Block fortgesetzt — da der finally-Block der try...finally-Anweisungen immer ausgeführt wird.

function* gen() {
  yield 1;
  try {
    yield 2;
    yield 3;
  } finally {
    yield "cleanup";
  }
}

const g1 = gen();
g1.next(); // { value: 1, done: false }

// Execution is suspended before the try...finally.
g1.return("early return"); // { value: 'early return', done: true }

const g2 = gen();
g2.next(); // { value: 1, done: false }
g2.next(); // { value: 2, done: false }

// Execution is suspended within the try...finally.
g2.return("early return"); // { value: 'cleanup', done: false }

// The completion value is preserved
g2.next(); // { value: 'early return', done: true }

// Generator is in the completed state
g2.return("not so early return"); // { value: 'not so early return', done: true }

Der Rückgabewert des finally-Blocks kann auch zum value des Ergebnisses werden, das von dem return-Aufruf zurückgegeben wird.

function* gen() {
  try {
    yield 1;
  } finally {
    return "cleanup";
  }
}

const generator = gen();
generator.next(); // { value: 1, done: false }
generator.return("early return"); // { value: 'cleanup', done: true }

• function*