Is there a bug in Javascript?

is there a bug in js, the script is tilted and others will not stop the script execution

Except for syntax syntax errors, no.

There are exceptions in JavaScript. The exception comes out of the code in which it is thrown, and the code that caused it, and so on, until it catches. If it is not caught, all current functions are terminated and the error is logged to the web console.

So an exception (either one of them that you throw explicitly, or something that happens as a byproduct of what you do) will either stop executing all running functions (if not caught), or only terminate some code (if it caught).

For example:

function foo() {
    try {
        bar(0);
    }
    catch (e) {
        console.log("Caught exception");
    }
}
function bar(a) {
    if (a <= 0) {
        throw new Error("'a' cannot be <= 0");
    }
    console.log("bar: a = " + a);
}

foo();

      

        
        
        
      

    

There the code in bar

except does not run (we do not see "bar: a = 0"

) because an exception was thrown, completion bar

. But the foo

code continues, in block catch

, because it foo

caught the exception.

JavaScript is unusual in that you can throw anything, including a string, a number, etc. But if you want useful information, you usually throw Error

:

throw new Error("Optional message here");

      

        
        
        
      

    

Since what you throw can be anything, you might think that there is a way to only catch certain things, but this is not the case. catch

catches any exception that was thrown. So:

try {
    throw "foo";
}
catch (e) {
}

try {
    throw new Error();
}
catch (e)
}

try {
    throw 42;
}
catch (e)
}

      

        
        
        
      

    

Note that those sentences are catch

identical; they catch anything that has been thrown away. You can of course check what you have and re-cast:

try {
    // ...some code here that may throw any of several things...
}
catch (e)
    if (typeof e === "string") {
        // Handle it here
    }
    else {
        throw e;
    }
}

      

        
        
        
      

    

Here we handle exceptions that are strings, not those that are numbers, Error

objects, etc.

You can create your own derived versions Error

if you like, although this is a bit of a pain than it should be:

function MySpecificError(msg) {
  this.message = msg;
  try {
    throw new Error();
  }
  catch (e) {
    this.stack = e.stack;
  }
}
MySpecificError.prototype = Object.create(Error.prototype);
MySpecificError.prototype.constructor = MySpecificError;

      

        
        
        
      

    

Then:

throw new MySpecificError("Something went wrong.");

      

        
        
        
      

    

Note that we needed to populate the code in in MySpecificError

order to create the stack trace. (Also note that not all engines provide a stack trace, but if so, it allows you to use it.)

Some engines provide several types of errors out of the box:

• Error
  
  
• RangeError
  
  (something was out of range)
• ReferenceError
  
  (but usually this is what you let the engine quit)
• TypeError
  
  (again)
• SyntaxError
  
  (again)

Finally, it's worth noting that a few things that can throw exceptions in environments other than JavaScript, mostly around math. For example:

var result = 10 / 0;

      

        
        
        
      

    

In many non-JavaScript environments, this results in a runtime error (division by zero). This is not the case in JavaScript; result

gets the value Infinity

.

Similarly:

var x = Number("I am not a number");

      

        
        
        
      

    

or

var x = parseInt("I am not a number", 10);

      

        
        
        
      

    

... does not raise a parse error, sets x

to NaN

("not a number").