We Keep Coding

How to get the line number of error inside of catch on ajax call in javascript

When I use try, catch I can get line number of error by stack message.
But When I use this for ajax call as below,
try {
await axios.get('http://example.com')
} catch (error) {
console.log(error)
}
I can't get the stack error. It just gives me error of ajax call.
Isn't there any method for catching the line number in this case?
Thank you for reading it.

Usually, error will contain enough information to identify the problem. error is an object, when you do console.log(error), it actually calls its toString implementation.
To get the stack only, you can use.
try {
throw new Error('Test');
} catch (error) {
console.log(error.stack);
}
The above will only point to the JavaScript file/piece of code that fires the request to example.com, nothing more. :)
If you want to see what happened with your call (more details of why it failed), and what was the response, try console.log(JSON.stringify(error)) and use Network DevTools - https://developers.google.com/web/tools/chrome-devtools/network

Why does the finally stanza of a try..catch..finally block get run before catch?

try {
throw new Error('yikes!');
} catch (e) {
throw e;
} finally {
console.log('caught error!')
}
Prints out:
caught error!
Error: yikes!
So is the finally block running before the throw statement?
It only looks like the finally block ran first, but we can see this isn't actually the case:
let failed;
try {
throw new Error('yikes!');
failed = false;
} catch (e) {
failed = true;
throw e;
} finally {
console.log(`caught error! failed: ${failed}`)
}
prints
caught error! failed: true
Error: yikes!
So why is the printing of the error out of band? is there some asynchronous behaviour here that I'm not seeing?

Try runs - Your try runs and throws the error
Catch runs - Your catch catches the error and simply re-throws it.
Finally runs - You print out your string
The rethrown error is now uncaught - And your browser logs details about the error

The finally clause runs before the overall try block finishes. The error that's logged happens when the runtime intercepts the exception, which is after the try block finishes. (Note that your catch code does not console.log() anything. It throws a new exception, but the finally clause will still run before the rest of the world sees that.)
All languages with try catch finally that I know of behave in exactly the same way. The point of finally blocks is to provide a place to put code that is guaranteed to run whether the try succeeds or fails.

The throw statement doesn't print anything. The error is printed later when the browser catches the thrown error.

Catch invalid variable name with SyntaxError

First off the catch clause isn't being executed. But I am getting "SyntaxError: missing exponent" error in the browser. I'm wondering if it's because of load time? Or my setup is not right.
I want to make a custom error for incorrect variable name.
try {
var 1ele = 1;
} catch (error) {
if (error instanceOf SyntaxError) {
throw new SyntaxError("There is a syntax error!");
}
}
Thanks for the help.

You have introduced a Syntax error in your code var 1ele = 1; and intend to catch the error to display a custom error message. However this won't work in the way you have written now since the Syntax error will cause the JavaScript parser to stop soon after encountering the Syntax error. The catch part of your code will never be reached.
However, you can implement the same using an eval statement. Try the code below.
try {
eval("var 1ele = 1");
} catch (error) {
if (error instanceof SyntaxError) {
throw new SyntaxError("There is a syntax error!");
}
}
Here, I have wrapped the Syntax error causing variable declaration inside an eval function. This will cause the syntax error only in the environment where the eval statement is executed and not your main code. You will be able to catch the error and display your custom message.
NOTE 1: You are getting the "SyntaxError: missing exponent" error message because your variable name starts with 1e which makes the JavaScript parser think that it is a number in exponential format.
NOTE 2: You have used instanceOf in your code. It is actually instanceof (with a lower case o). Ref

javascript pass

Is there something along the lines of python 'pass' in javascript?
I want to do the javascript equivalent of:
try:
# Something that throws exception
catch:
pass

pass is a no-op in Python. You need it for empty blocks because
try:
# Something that throws exception
catch:
# continue other stuff
is a syntax error. In JavaScript you can just use an empty catch block.
try {
// Something that throws exception
}
catch (e) {}

There is, and here it is:
That's right, nothing at all:
try {
somethingThatThrowsAnException();
} catch (e) {
}

I want to do the javascript equivalent of:
try:
# Something that throws exception
catch:
pass
Python doesn't have try/catch. It has try/except. So replacing catch with except, we would have this:
try {
// throw any exception
} catch(err) {}
The empty code block after the catch is equivalent to Python's pass.
Best Practices
However, one might interpret this question a little differently. Suppose you want to adopt the same semantics as a Python try/except block. Python's exception handling is a little more nuanced, and lets you specify what errors to catch.
In fact, it is considered a best practice to only catch specific error types.
So a best practice version for Python would be, since you want to only catch exceptions you are prepared to handle, and avoid hiding bugs:
try:
raise TypeError
except TypeError as err:
pass
You should probably subclass the appropriate error type, standard Javascript doesn't have a very rich exception hierarchy. I chose TypeError because it has the same spelling and similar semantics to Python's TypeError.
To follow the same semantics for this in Javascript, we first have to catch all errors, and so we need control flow that adjusts for that. So we need to determine if the error is not the type of error we want to pass with an if condition. The lack of else control flow is what silences the TypeError. And with this code, in theory, all other types of errors should bubble up to the surface and be fixed, or at least be identified for additional error handling:
try { // try:
throw TypeError() // raise ValueError
} catch(err) { // # this code block same behavior as
if (!(err instanceof TypeError)) { // except ValueError as err:
throw err // pass
}
}
Comments welcome!

JavaScript: Catch not hit on "Uncaught SyntaxError" [Chrome]

Can someone explain to me why an "Uncaught SyntaxError" isn't handled by a try/catch? Is it possible to gracefully handle this type of error so the rest of the JS runs?
For example:
try { response.write(;); }
catch(e) { console.log(e); }
This code throws a "Uncaught SyntaxError: Unexpected token ;" [Chrome] browser error instead of jumping to the catch and logging the error object. You get similar results in Firefox as well; a thrown error instead of handling it with the catch.

A syntax error is not a run-time exception. In order for your program to be able to throw and catch exceptions, it needs to be able to run. In order to run, it needs to be javascript. The above example is not valid javascript. The interpreter gives up and prints an error when it sees the first invalid line and it never even gets to the "catch" line.

Well, since this is a syntax exception, it means that javascript parser failed to parse you code. Since browser failed to parse your code, it can not execute it. It does not even know about your try/catch block. try/catch block can only catch exception thrown as a result of code executing in context of the block.

You could use a workaround for this.
try {
Function('response.write(;);')
} catch(e) {
console.log(e);
}
Could be used for determining es6 template string support this way:
var isEs6Template;
try {
Function('``');
isEs6Template = true;
} catch(e) {
isEs6Template = false;
}
console.log('es6 template is', isEs6Template ? 'supported' : 'unsupported');