Voglio scrivere un gestore di errori comune che rileverà errori personalizzati lanciati di proposito in qualsiasi istanza del codice.

Quando mi è throw new Error('sample')piaciuto nel seguente codice

try {
    throw new Error({'hehe':'haha'});
    // throw new Error('hehe');
} catch(e) {
    alert(e);
    console.log(e);
}

Il registro mostra in Firefox come Error: [object Object]e non ho potuto analizzare l'oggetto.

Per il secondo throwil registro mostra come:Error: hehe

Mentre quando l'ho fatto

try {
    throw ({'hehe':'haha'});
} catch(e) {
    alert(e);
    console.log(e);
}

la console ha mostrato come: Object { hehe="haha"}in cui sono stato in grado di accedere alle proprietà dell'errore.

Qual è la differenza?

La differenza si vede nel codice? Come stringa verrà appena passata come stringa e oggetto come oggetti ma la sintassi sarà diversa?

Non ho esplorato il lancio di un oggetto di errore ... Avevo fatto solo il lancio di stringhe.

Esiste un modo diverso dai due metodi sopra menzionati?

Ecco una buona spiegazione sull'oggetto Error e sul lancio dei propri errori

L'oggetto errore

Proprio quello che possiamo estrarre da esso in caso di errore? L'oggetto Error in tutti i browser supporta le seguenti due proprietà:

• name: il nome dell'errore, o più specificamente, il nome della funzione di costruzione a cui appartiene l'errore.

• messaggio: una descrizione dell'errore, con questa descrizione che varia a seconda del browser.

Sei valori possibili possono essere restituiti dalla proprietà name, che come detto corrisponde ai nomi dei costruttori dell'errore. Loro sono:

Error Name          Description

EvalError           An error in the eval() function has occurred.

RangeError          Out of range number value has occurred.

ReferenceError      An illegal reference has occurred.

SyntaxError         A syntax error within code inside the eval() function has occurred.
                    All other syntax errors are not caught by try/catch/finally, and will
                    trigger the default browser error message associated with the error. 
                    To catch actual syntax errors, you may use the onerror event.

TypeError           An error in the expected variable type has occurred.

URIError            An error when encoding or decoding the URI has occurred 
                   (ie: when calling encodeURI()).

Lanciare i propri errori (eccezioni)

Invece di attendere che si verifichi uno dei 6 tipi di errori prima che il controllo venga trasferito automaticamente dal blocco try al blocco catch, è anche possibile generare esplicitamente le proprie eccezioni per forzare che ciò avvenga su richiesta. Questo è ottimo per creare le tue definizioni di cosa sia un errore e quando il controllo dovrebbe essere trasferito per catturare.

getta "I'm Evil"

throwsi terminerà l'ulteriore esecuzione & esporre stringa di messaggio sulla cattura l'errore.

try {
  throw "I'm Evil"
  console.log("You'll never reach to me", 123465)
} catch (e) {
  console.log(e); //I'm Evil
}

La console dopo il lancio non sarà mai raggiunta a causa della risoluzione.

genera un nuovo errore ("Sono così dolce")

throw new Errorespone un evento di errore con due parametri nome e messaggio . Termina anche ulteriori esecuzioni

try {
  throw new Error("I'm Evil")
  console.log("You'll never reach to me", 123465)
} catch (e) {
  console.log(e.name, e.message); //Error, I'm Evil
}

Il seguente articolo forse fornisce alcuni dettagli in più su quale sia una scelta migliore; throw 'An error'oppure throw new Error('An error'):

http://www.nczonline.net/blog/2009/03/10/the-art-of-throwing-javascript-errors-part-2/

Suggerisce che quest'ultimo ( new Error()) sia più affidabile, poiché browser come Internet Explorer e Safari (non sicuri delle versioni) non segnalano correttamente il messaggio quando si utilizza il primo.

In questo modo verrà generato un errore, ma non tutti i browser risponderanno come ti aspetteresti. Firefox, Opera e Chrome visualizzano ciascuno un messaggio di "eccezione non rilevata" e quindi includono la stringa di messaggio. Safari e Internet Explorer generano semplicemente un errore di "eccezione non rilevata" e non forniscono affatto la stringa di messaggio. Chiaramente, questo non è ottimale dal punto di vista del debug.

Prima menzioni questo codice:

throw new Error('sample')

e poi nel tuo primo esempio scrivi:

throw new Error({'hehe':'haha'}) 

Il primo oggetto Error funzionerebbe effettivamente, perché si aspetta un valore di stringa, in questo caso 'campione'. Il secondo no perché stai provando a passare un oggetto e si aspetta una stringa.

L'oggetto errore avrebbe la proprietà "message", che sarebbe "campione".

TLDR: sono equivalenti.

// this:
const x = Error('I was created using a function call!');
​​​​// has the same functionality as this:
const y = new Error('I was constructed via the "new" keyword!');

fonte: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error

puoi throwcome oggetto

throw ({message: 'This Failed'})

quindi ad esempio nel tuo try/catch

try {
//
} catch(e) {
    console.log(e); //{message: 'This Failed'}
    console.log(e.message); //This Failed
}

o semplicemente lanciare un errore di stringa

throw ('Your error')

try {
//
} catch(e) {
    console.log(e); //Your error
}

throw new Error //only accept a string

Il Errorcostruttore viene utilizzato per creare un oggetto errore. Gli oggetti errore vengono generati quando si verificano errori di runtime. L'oggetto Error può anche essere usato come oggetto base per eccezioni definite dall'utente.

Gli errori definiti dall'utente vengono generati tramite l' throwistruzione. il controllo del programma verrà passato al primo catchblocco nello stack di chiamate.

La differenza tra generare un errore con e senza oggetto Error:

throw {'hehe':'haha'};

In chrome devtools si presenta così:

Chrome ci dice che abbiamo un errore non rilevato che è solo un oggetto JS. L'oggetto stesso potrebbe contenere informazioni sull'errore ma non sappiamo ancora da dove provenga. Non molto utile quando stiamo lavorando sul nostro codice e il debug.

throw new Error({'hehe':'haha'}); 

In chrome devtools si presenta così:

Un errore generato con l'oggetto Error ci fornisce una traccia dello stack quando lo espandiamo. Questo ci fornisce informazioni preziose da cui proviene esattamente l'errore, che spesso sono informazioni preziose durante il debug del codice. Si noti inoltre che l'errore dice [object Object], questo perché il Errorcostruttore si aspetta una stringa di messaggio come primo argomento. Quando riceve un oggetto, lo forzerà in una stringa.

Reagire al comportamento

A parte il resto delle risposte, vorrei mostrare una differenza in React.

Se lancio new Error()ae sono in modalità sviluppo, visualizzerò una schermata di errore e un registro della console. Se lancio letteralmente una stringa, la vedrò solo nella console e probabilmente la mancherò, se non guardo il registro della console.

Esempio

Lancio di un errore accede alla console e mostra una schermata di errore in modalità di sviluppo (la schermata non sarà visibile in produzione).

throw new Error("The application could not authenticate.");

Considerando che il seguente codice accede solo alla console:

throw "The application could not authenticate.";