Verwendung von instanceof in einer switch-Anweisung

Question 1

Ich verwende benutzerdefinierte Fehler (es6-Fehler), sodass ich Fehler basierend auf ihrer Klasse wie folgt behandeln kann:

import { DatabaseEntryNotFoundError, NotAllowedError } from 'customError';

function fooRoute(req, res) {
  doSomethingAsync()
    .then(() => {
      // on resolve / success
      return res.send(200);
    })
    .catch((error) => {
      // on reject / failure
      if (error instanceof DatabaseEntryNotFoundError) {
        return res.send(404);
      } else if (error instanceof NotAllowedError) {
        return res.send(400);
      }
      log('Failed to do something async with an unspecified error: ', error);
      return res.send(500);
    };
}

Jetzt würde ich lieber einen Schalter für diese Art von Fluss verwenden, was zu etwas führt wie:

import { DatabaseEntryNotFoundError, NotAllowedError } from 'customError';

function fooRoute(req, res) {
  doSomethingAsync()
    .then(() => {
      // on resolve / success
      return res.send(200);
    })
    .catch((error) => {
      // on reject / failure
      switch (error instanceof) {
        case NotAllowedError:
          return res.send(400);
        case DatabaseEntryNotFoundError:
          return res.send(404);
        default:
          log('Failed to do something async with an unspecified error: ', error);
          return res.send(500);
      }
    });
}

Instanzvon geht so aber nicht. Letzteres fällt also aus.

Gibt es eine Möglichkeit, eine Instanz in einer switch-Anweisung auf ihre Klasse zu überprüfen?

Question 2

Eine gute Option ist die Verwendung von constructor Eigentum des Objektes:

// on reject / failure
switch (error.constructor) {
    case NotAllowedError:
        return res.send(400);
    case DatabaseEntryNotFoundError:
        return res.send(404);
    default:
        log('Failed to do something async with an unspecified error: ', error);
        return res.send(500);
}

Beachten Sie, dass die constructor muss genau mit dem übereinstimmen, mit dem das Objekt erstellt wurde (angenommen error ist eine Instanz von NotAllowedError und NotAllowedError ist eine Unterklasse von Error):

error.constructor === NotAllowedError ist true
error.constructor === Error ist false

Dies unterscheidet sich von instanceofdie auch mit der Superklasse mithalten kann:

error instanceof NotAllowedError ist true
error instanceof Error ist true

Prüfen dieser interessante Beitrag um constructor Eigentum.

Question 3

Problemumgehung, um if-else zu vermeiden. Gefunden hier

switch (true) {
    case error instanceof NotAllowedError: 
        return res.send(400);

    case error instanceof DatabaseEntryNotFoundError: 
        return res.send(404);

    default:
        log('Failed to do something async with an unspecified error: ', error);
        return res.send(500);
}

Question 4

Eine Alternative zu diesem Schalterfall besteht darin, nur ein Statusfeld im Konstruktor des Fehlers zu haben.

Bauen Sie Ihren Fehler beispielsweise so auf:

class NotAllowedError extends Error {
    constructor(message, status) {
        super(message);
        this.message = message;
        this.status = 403; // Forbidden error code
    }
}

Behandeln Sie Ihren Fehler wie folgt:

.catch((error) => {
  res.send(error.status);
});

Question 5

Ich kann keine Kommentare schreiben, also musste ich eine Antwort schreiben.

Wenn Sie das Konstruktorobjekt verwenden, um den Instanztyp eines Objekts zu bestimmen, sollten Sie den folgenden Absatz beachten Webdokumentation für Mozilla-Entwickler:

Es gibt nichts, was die Konstruktor-Eigenschaft davor schützt, neu zugewiesen oder gespiegelt zu werden, daher sollte ihre Verwendung zur Erkennung des Typs einer Variablen normalerweise zugunsten weniger fragiler Methoden wie instanceof und Symbol.toStringTag für Objekte oder typeof für Primitive vermieden werden.

Ein weiteres Problem bei der Verwendung von Konstruktorobjekten ist, wenn Sie später einige neue Unterklassen bereits vorhandener Klassen erstellen. Denn wenn der Typ auf diese Weise überprüft wird, werden Objekte von Unterklassen nicht als Instanzen der übergeordneten Klasse erkannt.

Allerdings bietet diese Option eine gute Möglichkeit, den Objekttyp innerhalb der switch-Anweisung zu bestimmen, solange Sie sich dabei der Risiken bewusst sind.