Catch exception not raised - javascript

Hey guys i wrote a code to raise exception ..The code is
<html>
<body>
<script>
var d =1;
try {
if(d == 2) {
console.log('fd');
}
} catch(e) {
console.log('catch');
}
</script>
</body>
</html>
When i give the value 2 for d the code inside try works but when the value is given 1 the code inside catch didnt works..
Can you tel me why its not working ??..Any help would be great ...Thanx

try...catch is for catching errors, not for handling conditional statements. if (d == 2) is perfectly valid and doesn't throw any errors, nor does the code within your conditional statement.
A catch clause contain statements that specify what to do if an exception is thrown in the try block. That is, you want the try block to succeed, and if it does not succeed, you want control to pass to the catch block. If any statement within the try block (or in a function called from within the try block) throws an exception, control immediately shifts to the catch clause. If no exception is thrown in the try block, the catch clause is skipped.
— MDN's Notes on try...catch
If you want to do something if d isn't equal to 2, you can use else:
if (d == 2) {
...
}
else {
...
}
If you really want to use a try...catch statement here then you're going to have to throw an error. You can do this with JavaScript's throw statement:
try {
if (d != 2) {
throw "d is not equal to 2!";
}
}
catch (e) {
...
}
The catch block here will catch the error, and the e argument will be equal to our error string: "d is not equal to 2!".

try/catch is for handling errors. You're not generating an error, since your comparison is a valid comparison. An error is not the same as an if statement that returns false.

That's not the way a catch is intended to be used. The catch block will be visited once an exception is thrown. As an example, try to add the following else block to your if:
else { throw new Error; }
That said, it is not a good idea to control your flow by means of exceptions and I strongly discourage the use of such a solution in a production environment.

You need to throws the exception. Use throw "Exception" inside code like this:
try {
if(d == 2) {
console.log('fd');
}else{
throw "Exception";
}
} catch(e) {
console.log('catch');
}

Related

What is the main use of Try & Catch in Javascript?

I would like to know the main goal to use Try & Catch in Javascript, below is the example i am achieving
Should I need to let the program stop in case of error?
Why In programming I need to my application to continue running
however there is an error?
try {
if (typeof a != "number") {
throw new ReferenceError("The First argument is not a number");
} else if (typeof b != "number") {
throw new ReferenceError("The Second argument is not a number");
} else {
console.log(a + b);
}
} catch (error) {
console.log("Error:", error.message);
}
}
addTwoNums("10", 100);
console.log("It still works");
The code in the try block is executed first, and if it throws an exception, the code in the catch block will be executed. The code in the finally block will always be executed before control flow exits the entire construct
There are some things in java that require try and catch statements to function, for instance if you wanted to read a file java will prevent you from doing so unless error catching is used.
In your example whilst there is no harm in using try, it is simply unnecessary as there is no variability in the success of your function. Also, since there is no need to stop the program if the arguments are invalid, instead of throwing errors it might be preferable to instead halt the operation and return a warning.

Using OR for two possible errors inside try catch in JS

I have to possible error inside a try catch block like below:
try {
let result = A || B;
// use result
} catch(e) {
console.log("ERROR")
}
Each of A or B can throw error. Waht I need is I want to refer to catch only in situation both A and B throw error. is it possible?
**Note: I know that I can use separate try-catch for each of them. I was wondering if I can write it inside just single try-catch block

Is there type of error in Javascript?

I would ask about java script error, is there type of error like php
or others,
example: In php we have notice, and Parse Error ..etc notice will not
be stop php execute, but parse will be stop execute php code
directly..
now is there js error like this, or what is the js classification
error .. I know we can handle error by try, catch ..,but is there
error in js was stooped script and others will not stop execute script
thank you
is there error in js was stooped script and others will not stop execute script
Not except for parsing/syntax errors, no.
JavaScript has exceptions. An exception exits the code in which it is thrown, and the code that called that, and so on until it's caught. If it isn't caught, then all currently-running functions are terminated and the error is logged to the web console.
So an exception (either one you throw explicitly or one that happens as a by-product of something you do) will either terminate all running functions (if not caught) or only terminate some code (if 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 following the exception is not run (we don't see "bar: a = 0") because an exception was throw, terminating bar. But foo's code continues, in the catch block, because 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 be thinking there's a way to catch only certain things, but that's 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 catch clauses are identical; they catch anything that was thrown. Of course, you can then inspect what you got and re-throw:
try {
// ...some code here that may throw any of several things...
}
catch (e)
if (typeof e === "string") {
// Handle it here
}
else {
throw e;
}
}
There we only handle exceptions that are strings, and not ones that are numbers, Error objects, etc.
You can create your own derived versions of Error if you like, although it's a bit more of a pain than it ought to 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 had to fill in the code in MySpecificError to create the stack trace. (Also note that not all engines provide a stack trace, but if they do, this lets you use it.)
Some engines provide a few error types out of the box:
Error
RangeError (something was out of range)
ReferenceError (but usually that's something you'd let the engine throw)
TypeError (again)
SyntaxError (again)
Finally, it's worth noting that several things that would cause exceptions in other environments don't in JavaScript, mostly around math. For instance:
var result = 10 / 0;
In many non-JavaScript environments, that results in a runtime error (division by zero). In JavaScript, it doesn't; result gets the value Infinity.
Similarly:
var x = Number("I am not a number");
or
var x = parseInt("I am not a number", 10);
...doesn't throw a parsing error, it sets x to NaN ("not a number").
Yes. Javascript errors can have types, and there is a standard error type hierarchy. You can also write your code to "throw" things that are not error objects.
(In fact, since the catch clause in Javascript / ECMAScript does not discriminate based on the type of the exception, exception handling tends to be rather crude; i.e. "catch all errors" and then attempt to recover. Hence, to a first order, it doesn't matter what you throw.)
The ECMAScript 5.1 spec says that syntax errors are "early errors" and that they must be reported before the program is executed. An exception to this is syntax errors detected in code being run using eval. However, the spec doesn't say how early errors are to reported, or what happens afterwards. (At least, I don't think it does ...)
I believe that a common strategy for a Javascript parser/compiler/interpreter to skip to the enclosing block, and replace the affected code with code that throws an exception (e.g. SyntaxError) if it is run.
References:
http://www-archive.mozilla.org/js/language/js20-1999-02-18/error-recovery.html
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError
EcmaScript 5.1 - Errors

What if I use "throw" in "catch"?

function f(){
try{
if (/*some codes*/) throw false;
return true;
}
catch(x){
if (x===false) return false;
throw x;
}
}
Here,what does "throw x" mean? It seems codes in "catch" won't run twice.
If you had something like:
try {
try {
//something
} catch(x) {
throw x;
}
} catch(x) {
//handle it
}
The throw in the inner catch would cause the outer catch to execute
It means it throws the exception to the calling function, which will execute its catch block in case there is one defined.
For example, in the below code, you log the exception in the callthis() function, but you would like the calling function (init()) to decide how to handle it. Hence you re-throw the exception, which gets bubbled up.
window.onload = init();
function init(){
try {
callthis();
} catch(e) {
alert('init - calling function');
}
}
function callthis(){
try {
var x = null.split(','); //inducing an error
} catch(e){
alert('callthis - called function');
throw e;
}
}
Fiddle
When you have a try/catch block in Javascript, the catch block will take any error that can happen in try block. The keyword throw is used to throw a error to the superior scope (who call the function for sample) passing the error on it (exception) that will be taken by the catch block. In the catch you can take as a first argument the exception. In your code, you get a error the throw using throw x where x is the exception. The caller will get the x as a argument on the catch block.
function K()
{
try
{
f();
}
catch(ex)
{
// handle any exception thrown by f();
}
}
If you or the runtime throw an error on catch block, it will be passed to superior scope, in this case, the scope who called K function.
This is the way you would both catch an exception and bubble it up the stack for users to handle.
I wouldn't like seeing this code. You've already caught the exception and set the return value to false. Why throw the exception? Let the users check the return value and decide what to do next. Your catch block does nothing useful.
If you catch an exception, you should consider it handled and shouldn't rethrow it. The only exception would be wrap a checked exception as unchecked.
If you can't handle it, and logging is NOT considered handling, I'd prefer to add the throws clause to the method signature and let it bubble out of the method.

How javascript try...catch statement works

I am trying to test in browsermob if certain input field work or not. I am attempting to use a try...catch statement which I have never used before. I know that the form is:
try {
//some code
} catch (){
//some error code
};
What exactly is supposed to be put in the parenthesis after the catch statement?
When I try to use the statement it runs everything through the catch statement no matter if it is not an error. What am I doing wrong?
See the “try...catch statement” guide on MDN.
In short, try/catch is used to handle exceptions (which are "thrown" using the throw statement). The syntax for try/catch is:
try {
// Code
} catch (varName) { // Optional
// If exception thrown in try block,
// execute this block
} finally { // Optional
// Execute this block after
// try or after catch clause
// (i.e. this is *always* called)
}
varName is available to the scope of the catch block only. It refers to the exception object which was thrown (which could be any type of object, e.g. a String, but is usually an Error object).
The try catch statement is used to detected for exceptions/errors that are raised inside the try-block. In the catch block you can then react on this exceptional behavior and try to resolve it or get to a safe state.
You got the statement almost right:
try {
// code that may fail with error/exception
} catch (e) { // e represents the exception/error object
// react
}
Consider the following examples:
try {
var x = parseInt("xxx");
if(isNaN(x)){
throw new Error("Not a number");
}
} catch (e) { // e represents the exception/error object
alert(e);
}
try {
// some code
if(!condition){
throw new Error("Something went wrong!");
}
} catch (e) { // e represents the exception/error object
alert(e);
}
the stuff inside try {...} is what you want to execute. The stuff in catch() { ... } is what you want to execute if you get any javascript errors from anything executed in the try {...}
catch {...} only executes if there is a javascript error in the try {...} block. You can find out what the error is by doing for example this:
try {
// do something
} catch (err) {
alert(err);
}
According to ECMAScript specifications,
try {
// Code
} catch (varName) { // optional if 'finally' block is present.
if (condition) { // eg. (varName instanceof URIError)
// Condition (Type) specific error handling
}
else {
// Generic error handling
}
} finally { // Optional if 'catch' block is present.
// Execute this block after
// try or after catch clause
// (i.e. this is *always* called)
}
the code that is likely to throw an exception goes into try { }, The code to be run when an exception is thrown, comes into catch() { }. In catch() you can specify which exceptions you want to catch, and in which automatic variables to put it.
finally { } is always run, regardless whether exception was thrown or not.

Categories

Resources