What is the difference between `throw new Error` and `throw someObject`?

In JavaScript, using the throw keyword can throw exceptions, which is a mechanism for controlling program flow to handle errors or exceptional situations. throw can throw any type of value, including error objects (Error) or any other type of object (e.g., an arbitrary object). However, these two approaches have distinct differences and different use cases:

1. throw new Error

• Type: Typically throws an Error object or its subclasses (e.g., SyntaxError, TypeError, RangeError, etc.).
• Purpose: Used to indicate an error or exceptional situation, typically when unexpected issues occur in the program, such as type mismatches in parameters or values outside the expected range.
• Advantages: The Error object includes a stack trace and error message, which significantly aids in debugging and pinpointing issues.
• Example:

javascript
function divide(x, y) {
    if (y === 0) {
        throw new Error("Division by zero is not allowed");
    }
    return x / y;
}

try {
    console.log(divide(10, 0));
} catch (e) {
    console.error(e.message);  // Output: Division by zero is not allowed
}

2. throw an arbitrary object

• Type: Can be any type of object, such as { message: "error message" }, or even primitive data types like strings and numbers.
• Purpose: When you need to define errors more flexibly or carry additional error handling information, you can choose to throw a plain object.
• Disadvantages: Typically lacks automatic stack trace information, which may complicate debugging.
• Example:

javascript
function checkAge(age) {
    if (age < 18) {
        throw { message: "Age is insufficient", code: 1001 };
    }
    return "Verification successful";
}

try {
    console.log(checkAge(17));
} catch (e) {
    console.error(e.message);  // Output: Age is insufficient
    console.error(e.code);     // Output: 1001
}

Summary

Both approaches have valid use cases. Generally, it is recommended to use throw new Error or its subclasses, as it provides comprehensive error information including stack traces, which greatly facilitates debugging. On the other hand, throw an arbitrary object can be used when custom error messages or additional data need to be included within the error object. In practical development, selecting the appropriate approach based on specific requirements is essential.