Saya ingin membuang beberapa hal dalam kode JS saya dan saya ingin mereka menjadi contoh Kesalahan, tetapi saya juga ingin mereka menjadi sesuatu yang lain.

Dalam Python, biasanya, seseorang akan subkelas Pengecualian.

Apa hal yang tepat untuk dilakukan di JS?

Satu-satunya objek Galat bidang standar miliki adalah messageproperti. (Lihat MDN , atau Spesifikasi Bahasa EcmaScript, bagian 15.11) Yang lainnya adalah platform spesifik.

Sebagian besar lingkungan mengatur stackproperti, tetapi fileNamedan lineNumberpraktis tidak berguna untuk digunakan dalam warisan.

Jadi, pendekatan minimalis adalah:

function MyError(message) {
    this.name = 'MyError';
    this.message = message;
    this.stack = (new Error()).stack;
}
MyError.prototype = new Error;  // <-- remove this if you do not 
                                //     want MyError to be instanceof Error

Anda dapat mengendus tumpukan, melepaskan elemen yang tidak diinginkan darinya dan mengekstrak informasi seperti fileName dan lineNumber, tetapi untuk melakukannya diperlukan informasi tentang platform yang saat ini dijalankan JavaScript. Sebagian besar kasus yang tidak perlu - dan Anda dapat melakukannya di rumah sakit jika Anda benar-benar menginginkannya.

Safari adalah pengecualian penting. Tidak ada stackproperti, tetapi throwset kata kunci sourceURLdan lineproperti objek yang dilemparkan. Hal-hal itu dijamin benar.

Kasus pengujian yang saya gunakan dapat ditemukan di sini: JavaScript membuat perbandingan objek Kesalahan .

Dalam ES6:

class MyError extends Error {
  constructor(message) {
    super(message);
    this.name = 'MyError';
  }
}

sumber

Pendeknya:

• Jika Anda menggunakan ES6 tanpa transpiler :

  class CustomError extends Error { /* ... */}

• Jika Anda menggunakan Babel transpiler :

Opsi 1: gunakan babel-plugin-transform-builtin-extended

Opsi 2: lakukan sendiri (terinspirasi dari perpustakaan yang sama)

    function CustomError(...args) {
      const instance = Reflect.construct(Error, args);
      Reflect.setPrototypeOf(instance, Reflect.getPrototypeOf(this));
      return instance;
    }
    CustomError.prototype = Object.create(Error.prototype, {
      constructor: {
        value: Error,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    Reflect.setPrototypeOf(CustomError, Error);

• Jika Anda menggunakan ES5 murni :

  function CustomError(message, fileName, lineNumber) {
    var instance = new Error(message, fileName, lineNumber);
    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
    return instance;
  }
  CustomError.prototype = Object.create(Error.prototype, {
    constructor: {
      value: Error,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (Object.setPrototypeOf){
      Object.setPrototypeOf(CustomError, Error);
  } else {
      CustomError.__proto__ = Error;
  }

• Alternatif: gunakan kerangka kerja Classtrophobic

Penjelasan:

Mengapa memperluas kelas Kesalahan menggunakan ES6 dan Babel merupakan masalah?

Karena turunan CustomError tidak lagi dikenali.

class CustomError extends Error {}
console.log(new CustomError('test') instanceof Error);// true
console.log(new CustomError('test') instanceof CustomError);// false

Bahkan, dari dokumentasi resmi Babel, Anda tidak dapat memperpanjang built-in kelas JavaScript seperti Date, Array, DOMatau Error.

Masalahnya dijelaskan di sini:

• Native extends breaks HTMLELement, Array, dan lainnya
• objek kelas yang diperluas oleh tipe dasar seperti Array, Number, Object, String atau Error bukan turunan dari kelas ini

Bagaimana dengan jawaban SO lainnya?

Semua jawaban yang diberikan memperbaiki instanceofmasalah tetapi Anda kehilangan kesalahan reguler console.log:

console.log(new CustomError('test'));
// output:
// CustomError {name: "MyError", message: "test", stack: "Error↵    at CustomError (<anonymous>:4:19)↵    at <anonymous>:1:5"}

Sedangkan menggunakan metode yang disebutkan di atas, tidak hanya Anda memperbaiki instanceofmasalah tetapi Anda juga menyimpan kesalahan rutin console.log:

console.log(new CustomError('test'));
// output:
// Error: test
//     at CustomError (<anonymous>:2:32)
//     at <anonymous>:1:5

Sunting: Silakan baca komentar. Ternyata ini hanya berfungsi dengan baik di V8 (Chrome / Node.JS) Maksud saya adalah untuk memberikan solusi lintas-browser, yang akan bekerja di semua browser, dan menyediakan jejak tumpukan di mana ada dukungan.

Sunting: Saya membuat Wiki Komunitas ini untuk memungkinkan pengeditan lebih lanjut.

Solusi untuk V8 (Chrome / Node.JS), berfungsi di Firefox, dan dapat dimodifikasi agar berfungsi sebagian besar dengan benar di IE. (lihat akhir posting)

function UserError(message) {
  this.constructor.prototype.__proto__ = Error.prototype // Make this an instanceof Error.
  Error.call(this) // Does not seem necessary. Perhaps remove this line?
  Error.captureStackTrace(this, this.constructor) // Creates the this.stack getter
  this.name = this.constructor.name; // Used to cause messages like "UserError: message" instead of the default "Error: message"
  this.message = message; // Used to set the message
}

Posting asli pada "Tunjukkan kodenya!"

Versi pendek:

function UserError(message) {
  this.constructor.prototype.__proto__ = Error.prototype
  Error.captureStackTrace(this, this.constructor)
  this.name = this.constructor.name
  this.message = message
}

Saya tetap this.constructor.prototype.__proto__ = Error.prototypedi dalam fungsi untuk menyimpan semua kode. Tetapi Anda juga dapat mengganti this.constructordengan UserErrordan itu memungkinkan Anda untuk memindahkan kode ke luar fungsi, sehingga hanya dipanggil sekali.

Jika Anda pergi ke rute itu, pastikan Anda menelepon saluran itu sebelum pertama kali Anda melempar UserError.

Peringatan itu tidak menerapkan fungsi, karena fungsi dibuat terlebih dahulu, apa pun urutannya. Dengan demikian, Anda dapat memindahkan fungsi ke akhir file, tanpa masalah.

Kompatibilitas Browser

Bekerja di Firefox dan Chrome (dan Node.JS) serta memenuhi semua janji.

Internet Explorer gagal sebagai berikut

• Kesalahan tidak harus err.stackdimulai dengan, jadi "itu bukan salahku".

• Error.captureStackTrace(this, this.constructor) tidak ada sehingga Anda perlu melakukan hal lain seperti

  if(Error.captureStackTrace) // AKA if not IE
      Error.captureStackTrace(this, this.constructor)

• toStringtidak ada lagi saat Anda subkelas Error. Jadi, Anda juga perlu menambahkan.

  else
      this.toString = function () { return this.name + ': ' + this.message }

• IE tidak akan mempertimbangkan UserErrormenjadi instanceof Errorkecuali Anda menjalankan beberapa waktu sebelum Andathrow UserError

  UserError.prototype = Error.prototype

Untuk menghindari pelat ketel untuk setiap jenis kesalahan yang berbeda, saya menggabungkan kebijaksanaan beberapa solusi ke dalam  createErrorTypefungsi:

function createErrorType(name, init) {
  function E(message) {
    if (!Error.captureStackTrace)
      this.stack = (new Error()).stack;
    else
      Error.captureStackTrace(this, this.constructor);
    this.message = message;
    init && init.apply(this, arguments);
  }
  E.prototype = new Error();
  E.prototype.name = name;
  E.prototype.constructor = E;
  return E;
}

Kemudian Anda dapat mendefinisikan tipe kesalahan baru dengan mudah sebagai berikut:

var NameError = createErrorType('NameError', function (name, invalidChar) {
  this.message = 'The name ' + name + ' may not contain ' + invalidChar;
});

var UnboundError = createErrorType('UnboundError', function (variableName) {
  this.message = 'Variable ' + variableName + ' is not bound';
});

Pada 2018 , saya pikir ini adalah cara terbaik; yang mendukung IE9 + dan browser modern.

UPDATE : Lihat tes ini dan repo untuk perbandingan tentang implementasi yang berbeda.

function CustomError(message) {
    Object.defineProperty(this, 'name', {
        enumerable: false,
        writable: false,
        value: 'CustomError'
    });

    Object.defineProperty(this, 'message', {
        enumerable: false,
        writable: true,
        value: message
    });

    if (Error.hasOwnProperty('captureStackTrace')) { // V8
        Error.captureStackTrace(this, CustomError);
    } else {
        Object.defineProperty(this, 'stack', {
            enumerable: false,
            writable: false,
            value: (new Error(message)).stack
        });
    }
}

if (typeof Object.setPrototypeOf === 'function') {
    Object.setPrototypeOf(CustomError.prototype, Error.prototype);
} else {
    CustomError.prototype = Object.create(Error.prototype, {
        constructor: { value: CustomError }
    });
}

Waspadalah juga bahwa __proto__properti tidak digunakan lagi yang banyak digunakan dalam jawaban lain.

Demi kelengkapan - hanya karena tidak ada jawaban sebelumnya yang menyebutkan metode ini - jika Anda bekerja dengan Node.js dan tidak perlu peduli dengan kompatibilitas browser, efek yang diinginkan cukup mudah dicapai dengan built in inheritsdari utilmodul ( docs resmi di sini ).

Misalnya, anggap Anda ingin membuat kelas kesalahan khusus yang menggunakan kode kesalahan sebagai argumen pertama dan pesan kesalahan sebagai argumen kedua:

mengajukan custom-error.js :

'use strict';

var util = require('util');

function CustomError(code, message) {
  Error.captureStackTrace(this, CustomError);
  this.name = CustomError.name;
  this.code = code;
  this.message = message;
}

util.inherits(CustomError, Error);

module.exports = CustomError;

Sekarang Anda dapat instantiate dan lulus / lemparkan CustomError:

var CustomError = require('./path/to/custom-error');

// pass as the first argument to your callback
callback(new CustomError(404, 'Not found!'));

// or, if you are working with try/catch, throw it
throw new CustomError(500, 'Server Error!');

Perhatikan bahwa, dengan cuplikan ini, jejak tumpukan akan memiliki nama dan baris file yang benar, dan instance kesalahan akan memiliki nama yang benar!

Ini terjadi karena penggunaan captureStackTracemetode, yang membuat stackproperti pada objek target (dalam hal ini, yang CustomErrorsedang dipakai). Untuk detail lebih lanjut tentang cara kerjanya, lihat dokumentasi di sini .

Jawaban Crescent Fresh jawaban sangat menyesatkan. Meskipun peringatannya tidak valid, ada batasan lain yang tidak dia tangani.

Pertama, alasan dalam paragraf "Peringatan:" Crescent tidak masuk akal. Penjelasan menyiratkan bahwa pengkodean "sekelompok if (instance error MyError) lain ..." entah bagaimana memberatkan atau bertele-tele dibandingkan dengan beberapa pernyataan tangkapan. Banyak contoh pernyataan dalam satu blok tangkap sama ringkasnya dengan banyak pernyataan tangkap - kode bersih dan ringkas tanpa trik. Ini adalah cara yang bagus untuk meniru penanganan error subtipe-spesifik Java yang bisa dibuang.

WRT "muncul properti pesan dari subkelas tidak diatur", itu tidak terjadi jika Anda menggunakan subkelas Kesalahan dibangun dengan benar. Untuk membuat subclass ErrorX Anda sendiri, cukup salin blok kode yang diawali dengan "var MyError =", mengubah satu kata "MyError" menjadi "ErrorX". (Jika Anda ingin menambahkan metode khusus ke subkelas Anda, ikuti teks sampel).

Batasan nyata dan signifikan dari subclass kesalahan JavaScript adalah bahwa untuk implementasi atau debugers JavaScript yang melacak dan melaporkan jejak stack dan lokasi-instantiasi, seperti FireFox, lokasi dalam implementasi subclass Error Anda sendiri akan dicatat sebagai titik instantiasi dari kelas, sedangkan jika Anda menggunakan Kesalahan langsung, itu akan menjadi lokasi di mana Anda menjalankan "Kesalahan baru (...)"). Pengguna IE mungkin tidak akan pernah memperhatikan, tetapi pengguna Fire Bug pada FF akan melihat nilai nama file dan nomor baris yang tidak berguna yang dilaporkan di samping Kesalahan ini, dan harus menelusuri jejak tumpukan ke elemen # 1 untuk menemukan lokasi instantiasi nyata.

Bagaimana dengan solusi ini?

Alih-alih melempar Kesalahan khusus Anda menggunakan:

throw new MyError("Oops!");

Anda akan membungkus objek Kesalahan (seperti dekorator):

throw new MyError(Error("Oops!"));

Ini memastikan semua atribut benar, seperti tumpukan, fileName lineNumber, dan lain-lain.

Yang harus Anda lakukan adalah menyalin atribut, atau menentukan getter untuknya. Berikut ini adalah contoh menggunakan getter (IE9):

function MyError(wrapped)
{
        this.wrapped = wrapped;
        this.wrapped.name = 'MyError';
}

function wrap(attr)
{
        Object.defineProperty(MyError.prototype, attr, {
                get: function()
                {
                        return this.wrapped[attr];
                }
        });
}

MyError.prototype = Object.create(Error.prototype);
MyError.prototype.constructor = MyError;

wrap('name');
wrap('message');
wrap('stack');
wrap('fileName');
wrap('lineNumber');
wrap('columnNumber');

MyError.prototype.toString = function()
{
        return this.wrapped.toString();
};

Seperti yang dikatakan beberapa orang, cukup mudah dengan ES6:

class CustomError extends Error { }

Jadi saya mencobanya di dalam aplikasi saya, (Angular, Typescript) dan ternyata tidak berhasil. Setelah beberapa waktu saya telah menemukan bahwa masalahnya berasal dari Script: O

Lihat https://github.com/Microsoft/TypeScript/issues/13965

Ini sangat mengganggu karena jika Anda melakukannya:

class CustomError extends Error {}
​

try {
  throw new CustomError()
} catch(e) {
  if (e instanceof CustomError) {
    console.log('Custom error');
  } else {
    console.log('Basic error');
  }
}

Di node atau langsung ke browser Anda, ia akan menampilkan: Custom error

Cobalah untuk menjalankannya dengan Typescript di proyek Anda di pada taman bermain Typecript, itu akan menampilkan Basic error...

Solusinya adalah dengan melakukan hal berikut:

class CustomError extends Error {
  // we have to do the following because of: https://github.com/Microsoft/TypeScript/issues/13965
  // otherwise we cannot use instanceof later to catch a given type
  public __proto__: Error;

  constructor(message?: string) {
    const trueProto = new.target.prototype;
    super(message);

    this.__proto__ = trueProto;
  }
}

Solusi saya lebih sederhana daripada jawaban lain yang diberikan dan tidak memiliki kelemahan.

Ini mempertahankan rantai prototipe Kesalahan dan semua properti pada Kesalahan tanpa perlu pengetahuan khusus tentang mereka. Sudah diuji di Chrome, Firefox, Node, dan IE11.

Satu-satunya batasan adalah entri tambahan di bagian atas tumpukan panggilan. Tapi itu mudah diabaikan.

Berikut ini contoh dengan dua parameter khusus:

function CustomError(message, param1, param2) {
    var err = new Error(message);
    Object.setPrototypeOf(err, CustomError.prototype);

    err.param1 = param1;
    err.param2 = param2;

    return err;
}

CustomError.prototype = Object.create(
    Error.prototype,
    {name: {value: 'CustomError', enumerable: false}}
);

Contoh penggunaan:

try {
    throw new CustomError('Something Unexpected Happened!', 1234, 'neat');
} catch (ex) {
    console.log(ex.name); //CustomError
    console.log(ex.message); //Something Unexpected Happened!
    console.log(ex.param1); //1234
    console.log(ex.param2); //neat
    console.log(ex.stack); //stacktrace
    console.log(ex instanceof Error); //true
    console.log(ex instanceof CustomError); //true
}

Untuk lingkungan yang memerlukan polyfil dari setPrototypeOf:

Object.setPrototypeOf = Object.setPrototypeOf || function (obj, proto) {
    obj.__proto__ = proto;
    return obj;
};

Dalam contoh di atas Error.apply(juga Error.call) tidak melakukan apa pun untuk saya (Firefox 3.6 / Chrome 5). Solusi yang saya gunakan adalah:

function MyError(message, fileName, lineNumber) {
    var err = new Error();

    if (err.stack) {
        // remove one stack level:
        if (typeof(Components) != 'undefined') {
            // Mozilla:
            this.stack = err.stack.substring(err.stack.indexOf('\n')+1);
        }
        else if (typeof(chrome) != 'undefined' || typeof(process) != 'undefined') {
            // Google Chrome/Node.js:
            this.stack = err.stack.replace(/\n[^\n]*/,'');
        }
        else {
            this.stack = err.stack;
        }
    }
    this.message    = message    === undefined ? err.message    : message;
    this.fileName   = fileName   === undefined ? err.fileName   : fileName;
    this.lineNumber = lineNumber === undefined ? err.lineNumber : lineNumber;
}

MyError.prototype = new Error();
MyError.prototype.constructor = MyError;
MyError.prototype.name = 'MyError';

Di Node seperti yang orang lain katakan, itu sederhana:

class DumbError extends Error {
    constructor(foo = 'bar', ...params) {
        super(...params);

        if (Error.captureStackTrace) {
            Error.captureStackTrace(this, DumbError);
        }

        this.name = 'DumbError';

        this.foo = foo;
        this.date = new Date();
    }
}

try {
    let x = 3;
    if (x < 10) {
        throw new DumbError();
    }
} catch (error) {
    console.log(error);
}

Saya hanya ingin menambahkan apa yang sudah dikatakan orang lain:

Untuk memastikan bahwa kelas kesalahan khusus muncul dengan benar di jejak tumpukan, Anda perlu mengatur properti nama prototipe kelas kesalahan ke properti nama kelas kesalahan kustom. Inilah yang saya maksud:

CustomError.prototype = Error.prototype;
CustomError.prototype.name = 'CustomError';

Jadi contoh lengkapnya adalah:

    var CustomError = function(message) {
        var err = new Error(message);
        err.name = 'CustomError';
        this.name = err.name;
        this.message = err.message;
        //check if there is a stack property supported in browser
        if (err.stack) {
            this.stack = err.stack;
        }
        //we should define how our toString function works as this will be used internally
        //by the browser's stack trace generation function
        this.toString = function() {
           return this.name + ': ' + this.message;
        };
    };
    CustomError.prototype = new Error();
    CustomError.prototype.name = 'CustomError';

Ketika semua dikatakan dan dilakukan, Anda melempar pengecualian baru Anda dan sepertinya ini (saya malas mencoba ini di alat dev chrome):

CustomError: Stuff Happened. GASP!
    at Error.CustomError (<anonymous>:3:19)
    at <anonymous>:2:7
    at Object.InjectedScript._evaluateOn (<anonymous>:603:39)
    at Object.InjectedScript._evaluateAndWrap (<anonymous>:562:52)
    at Object.InjectedScript.evaluate (<anonymous>:481:21)

2 sen saya:

Mengapa ada jawaban lain?

a) Karena mengakses Error.stackproperti (seperti dalam beberapa jawaban) memiliki penalti kinerja yang besar.

b) Karena hanya satu baris.

c) Karena solusi di https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error tampaknya tidak mempertahankan informasi tumpukan.

//MyError class constructor
function MyError(msg){
    this.__proto__.__proto__ = Error.apply(null, arguments);
};

contoh penggunaan

http://jsfiddle.net/luciotato/xXyeB/

Apa fungsinya?

this.__proto__.__proto__adalah MyError.prototype.__proto__, jadi itu mengatur __proto__UNTUK SEMUA INSTAN MyError ke Kesalahan khusus yang baru dibuat. Itu membuat properti dan metode kelas MyError dan juga menempatkan properti Kesalahan baru (termasuk .stack) di __proto__rantai.

Masalah yang jelas:

Anda tidak dapat memiliki lebih dari satu instance MyError dengan info tumpukan berguna.

Jangan gunakan solusi ini jika Anda tidak sepenuhnya mengerti apa yang this.__proto__.__proto__=terjadi.

Karena Pengecualian JavaScript sulit untuk sub-kelas, saya tidak sub-kelas. Saya baru saja membuat kelas Pengecualian baru dan menggunakan Kesalahan di dalamnya. Saya mengubah properti Error.name sehingga sepertinya pengecualian khusus pada konsol:

var InvalidInputError = function(message) {
    var error = new Error(message);
    error.name = 'InvalidInputError';
    return error;
};

Pengecualian baru di atas dapat dilemparkan seperti Kesalahan biasa dan akan berfungsi seperti yang diharapkan, misalnya:

throw new InvalidInputError("Input must be a string");
// Output: Uncaught InvalidInputError: Input must be a string 

Peringatan: jejak tumpukan tidak sempurna, karena akan membawa Anda ke tempat Kesalahan baru dibuat dan bukan ke tempat Anda membuang. Ini bukan masalah besar di Chrome karena memberi Anda jejak tumpukan penuh langsung di konsol. Tapi itu lebih bermasalah di Firefox, misalnya.

Seperti yang ditunjukkan dalam jawaban Mohsen, dalam ES6 dimungkinkan untuk memperluas kesalahan menggunakan kelas. Ini jauh lebih mudah dan perilaku mereka lebih konsisten dengan kesalahan asli ... tapi sayangnya itu bukan masalah sederhana untuk menggunakan ini di browser jika Anda perlu mendukung browser pra-ES6. Lihat di bawah untuk beberapa catatan tentang bagaimana hal itu dapat diterapkan, tetapi sementara itu saya menyarankan pendekatan yang relatif sederhana yang menggabungkan beberapa saran terbaik dari jawaban lain:

function CustomError(message) {
    //This is for future compatibility with the ES6 version, which
    //would display a similar message if invoked without the
    //`new` operator.
    if (!(this instanceof CustomError)) {
        throw new TypeError("Constructor 'CustomError' cannot be invoked without 'new'");
    }
    this.message = message;

    //Stack trace in V8
    if (Error.captureStackTrace) {
       Error.captureStackTrace(this, CustomError);
    }
    else this.stack = (new Error).stack;
}
CustomError.prototype = Object.create(Error.prototype);
CustomError.prototype.name = 'CustomError';

Dalam ES6 sesederhana:

class CustomError extends Error {}

... dan Anda dapat mendeteksi dukungan untuk kelas ES6 try {eval('class X{}'), tetapi Anda akan mendapatkan kesalahan sintaksis jika Anda mencoba untuk memasukkan versi ES6 dalam skrip yang dimuat oleh browser yang lebih lama. Jadi satu-satunya cara untuk mendukung semua browser adalah dengan memuat skrip terpisah secara dinamis (misalnya melalui AJAX atau eval()) untuk browser yang mendukung ES6. Komplikasi lebih lanjut adalah yang eval()tidak didukung di semua lingkungan (karena Kebijakan Keamanan Konten), yang mungkin atau mungkin tidak menjadi pertimbangan untuk proyek Anda.

Jadi untuk saat ini, baik pendekatan pertama di atas atau hanya menggunakan Errorsecara langsung tanpa mencoba memperluas tampaknya menjadi yang terbaik yang secara praktis dapat dilakukan untuk kode yang perlu mendukung browser non-ES6.

Ada satu pendekatan lain yang beberapa orang mungkin ingin mempertimbangkan, yaitu menggunakan di Object.setPrototypeOf()mana tersedia untuk membuat objek kesalahan yang merupakan contoh dari jenis kesalahan kustom Anda tetapi yang terlihat dan berperilaku lebih seperti kesalahan asli di konsol (berkat jawaban Ben untuk rekomendasi). Inilah pendapat saya tentang pendekatan itu: https://gist.github.com/mbrowne/fe45db61cea7858d11be933a998926a8 . Tetapi mengingat bahwa suatu hari kita akan dapat hanya menggunakan ES6, secara pribadi saya tidak yakin kompleksitas pendekatan itu sepadan.

Cara untuk melakukan ini dengan benar adalah dengan mengembalikan hasil berlaku dari konstruktor, serta menetapkan prototipe dengan cara javascripty rumit yang biasa:

function MyError() {
    var tmp = Error.apply(this, arguments);
    tmp.name = this.name = 'MyError'

    this.stack = tmp.stack
    this.message = tmp.message

    return this
}
    var IntermediateInheritor = function() {}
        IntermediateInheritor.prototype = Error.prototype;
    MyError.prototype = new IntermediateInheritor()

var myError = new MyError("message");
console.log("The message is: '"+myError.message+"'") // The message is: 'message'
console.log(myError instanceof Error)                // true
console.log(myError instanceof MyError)              // true
console.log(myError.toString())                      // MyError: message
console.log(myError.stack)                           // MyError: message \n 
                                                     // <stack trace ...>

Satu-satunya masalah dengan cara melakukannya pada saat ini (saya sudah mengulanginya sedikit) adalah itu

• properti selain stackdan messagetidak termasuk dalam MyErrordan
• stacktrace memiliki baris tambahan yang sebenarnya tidak perlu.

Masalah pertama dapat diperbaiki dengan mengulangi semua properti kesalahan yang tidak dapat dihitung menggunakan trik dalam jawaban ini: Apakah mungkin untuk mendapatkan nama properti yang diwarisi dari objek yang tidak dapat dihitung? , tetapi ini tidak didukung oleh yaitu <9. Masalah kedua dapat diselesaikan dengan merobek garis itu di jejak tumpukan, tapi saya tidak yakin bagaimana melakukannya dengan aman (mungkin hanya menghapus baris kedua dari e.stack.toString () ??).

Cuplikan menunjukkan semuanya.

function add(x, y) {
      if (x && y) {
        return x + y;
      } else {
        /**
         * 
         * the error thrown will be instanceof Error class and InvalidArgsError also
         */
        throw new InvalidArgsError();
        // throw new Invalid_Args_Error(); 
      }
    }

    // Declare custom error using using Class
    class Invalid_Args_Error extends Error {
      constructor() {
        super("Invalid arguments");
        Error.captureStackTrace(this);
      }
    }

    // Declare custom error using Function
    function InvalidArgsError(message) {
      this.message = `Invalid arguments`;
      Error.captureStackTrace(this);
    }
    // does the same magic as extends keyword
    Object.setPrototypeOf(InvalidArgsError.prototype, Error.prototype);

    try{
      add(2)
    }catch(e){
      // true
      if(e instanceof Error){
        console.log(e)
      }
      // true
      if(e instanceof InvalidArgsError){
        console.log(e)
      }
    }

Saya akan mengambil langkah mundur dan mempertimbangkan mengapa Anda ingin melakukan itu? Saya pikir intinya adalah menangani kesalahan yang berbeda secara berbeda.

Misalnya, dalam Python, Anda dapat membatasi pernyataan tangkapan hanya tangkapan MyValidationError, dan mungkin Anda ingin dapat melakukan hal serupa di javascript.

catch (MyValidationError e) {
    ....
}

Anda tidak dapat melakukan ini dalam javascript. Hanya akan ada satu blok penangkap. Anda seharusnya menggunakan pernyataan if pada kesalahan untuk menentukan jenisnya.

catch(e) { if(isMyValidationError(e)) { ... } else { // maybe rethrow? throw e; } }

Saya pikir saya akan membuang objek mentah dengan tipe, pesan, dan properti lain yang Anda inginkan.

throw { type: "validation", message: "Invalid timestamp" }

Dan ketika Anda menangkap kesalahan:

catch(e) {
    if(e.type === "validation") {
         // handle error
    }
    // re-throw, or whatever else
}

Penghias Kesalahan Kustom

Ini didasarkan pada jawaban George Bailey , tetapi memperluas dan menyederhanakan ide aslinya. Ini ditulis dalam CoffeeScript, tetapi mudah dikonversi ke JavaScript. Idenya adalah memperpanjang kesalahan kustom Bailey dengan dekorator yang membungkusnya, memungkinkan Anda untuk membuat kesalahan khusus baru dengan mudah.

Catatan: Ini hanya akan berfungsi di V8. Tidak ada dukungan untuk Error.captureStackTracedi lingkungan lain.

Menetapkan

Dekorator mengambil nama untuk jenis kesalahan, dan mengembalikan fungsi yang mengambil pesan kesalahan, dan menyertakan nama kesalahan.

CoreError = (@message) ->

    @constructor.prototype.__proto__ = Error.prototype
    Error.captureStackTrace @, @constructor
    @name = @constructor.name

BaseError = (type) ->

    (message) -> new CoreError "#{ type }Error: #{ message }"

Menggunakan

Sekarang mudah untuk membuat jenis kesalahan baru.

StorageError   = BaseError "Storage"
SignatureError = BaseError "Signature"

Untuk bersenang-senang, Anda sekarang dapat mendefinisikan fungsi yang melempar a SignatureErrorjika dipanggil dengan terlalu banyak argumen.

f = -> throw SignatureError "too many args" if arguments.length

Ini telah diuji dengan cukup baik dan tampaknya berfungsi dengan baik pada V8, mempertahankan traceback, posisi, dll.

Catatan: Menggunakan newadalah opsional saat membuat kesalahan khusus.

jika Anda tidak peduli dengan kesalahan karena ini adalah yang terkecil yang dapat Anda lakukan

Object.setPrototypeOf(MyError.prototype, Error.prototype)
function MyError(message) {
    const error = new Error(message)
    Object.setPrototypeOf(error, MyError.prototype);
    return error
}

Anda dapat menggunakannya tanpa hanya MyError (pesan) baru

Dengan mengubah prototipe setelah Kesalahan konstruktor dipanggil, kita tidak perlu mengatur callstack dan pesan

Mohsen memiliki jawaban hebat di atas dalam ES6 yang menetapkan nama, tetapi jika Anda menggunakan TypeScript atau jika Anda hidup di masa depan di mana semoga proposal untuk bidang kelas publik dan swasta ini telah bergerak melewati tahap 3 sebagai proposal dan membuatnya ke tahap 4 sebagai bagian dari ECMAScript / JavaScript maka Anda mungkin ingin tahu ini kemudian hanya sedikit lebih pendek. Tahap 3 adalah tempat browser mulai mengimplementasikan fitur, jadi jika browser Anda mendukungnya, kode di bawah ini mungkin berfungsi. (Diuji di browser Edge baru v81 tampaknya berfungsi dengan baik). Berhati-hatilah meskipun ini adalah fitur yang tidak stabil saat ini dan harus digunakan dengan hati-hati dan Anda harus selalu memeriksa dukungan browser pada fitur yang tidak stabil. Posting ini terutama untuk para penghuni masa depan ketika browser mungkin mendukung ini. Untuk memeriksa dukungan, periksa MDNdan Dapatkah saya menggunakan . Saat ini mendapat dukungan 66% di seluruh pasar browser yang ada di sana tetapi tidak terlalu bagus jadi jika Anda benar-benar ingin menggunakannya sekarang dan tidak ingin menunggu menggunakan transpiler seperti Babel atau sesuatu seperti TypeScript .

class EOFError extends Error { 
  name="EOFError"
}
throw new EOFError("Oops errored");

Bandingkan ini dengan kesalahan tanpa nama yang ketika dilempar tidak akan mencatat namanya.

class NamelessEOFError extends Error {}
throw new NamelessEOFError("Oops errored");