Try–catch block in Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of a try–catch block in JavaScript?

A try–catch block is used to handle errors gracefully. The code inside the try block runs normally, but if an error happens, the catch block runs to handle that error without stopping the whole program.

beginner

What happens if no error occurs inside the try block?

If no error occurs, the code inside the catch block is skipped, and the program continues running after the try–catch block.

beginner

How do you access the error object inside the catch block?

You give a name to the error in parentheses after catch, like catch (error). Then you can use this name to get details about the error, for example, error.message.

intermediate

Can you use a try–catch block without a catch block in JavaScript?

No, in JavaScript, a try block must be followed by either a catch block, a finally block, or both. You cannot have a try block alone.

intermediate

What is the role of the finally block in a try–catch statement?

The finally block runs after the try and catch blocks, no matter what. It is used to run code that should always happen, like cleaning up resources.

What part of a try–catch block runs only if an error occurs?

A try block

B catch block

C finally block

D none

The catch block runs only when an error happens inside the try block.

Which keyword is used to define the block where you put code that might cause an error?

A catch

B finally

C try

D throw

The try keyword defines the block where you put code that might throw an error.

What will happen if an error occurs in the try block but there is no catch block?

A The error is automatically fixed

B The error is ignored

C The finally block runs

D The program crashes

Without a catch block, the error is not handled and will cause the program to crash.

Which block runs regardless of whether an error occurs or not?

A finally

B catch

C try

D throw

The finally block always runs after try and catch, no matter what.

How do you get the error message inside the catch block?

A Using error.message

B Using try.message

C Using catch.message

D Using finally.message

Inside catch, the error object is usually named (e.g., error), and you access the message with error.message.

Explain how a try–catch block helps in handling errors in JavaScript.

Think about what happens when code causes a problem.

Describe the difference between the catch and finally blocks in a try–catch statement.

One runs only on error, the other runs no matter what.

Practice

1.

What is the main purpose of a try block in JavaScript?

easy

A. To run code that might cause an error

B. To declare variables

C. To create loops

D. To define functions

Solution

1. Step 1: Understand the role of try

   The try block is used to run code that might throw an error during execution.

2. Step 2: Differentiate from other code blocks

   Other options like declaring variables, loops, or functions are unrelated to error handling.

3. Final Answer:

   To run code that might cause an error -> Option A

4. Quick Check:

   try runs risky code [OK]

Hint: Try block runs risky code safely [OK]

Common Mistakes:

• Thinking try declares variables
• Confusing try with loops
• Assuming try defines functions

2.

Which of the following is the correct syntax to start a try-catch block in JavaScript?

?

easy

A. try: { /* code */ } catch: { /* handle error */ }

B. try { /* code */ } catch (error) { /* handle error */ }

C. try (/* code */) catch (error) { /* handle error */ }

D. try { /* code */ } catch error { /* handle error */ }

Solution

1. Step 1: Recall correct try-catch syntax

   The correct syntax uses curly braces and parentheses for catch: try { ... } catch (error) { ... }.

2. Step 2: Identify syntax errors in other options

   Options B, C, and D misuse colons, parentheses, or omit parentheses around the error parameter.

3. Final Answer:

   try { /* code */ } catch (error) { /* handle error */ } -> Option B

4. Quick Check:

   Curly braces and catch(error) needed [OK]

Hint: Catch needs parentheses around error [OK]

Common Mistakes:

• Using colons instead of braces
• Omitting parentheses in catch
• Using parentheses after try

3.

What will be the output of the following code?

try {
  console.log('Start');
  throw new Error('Oops');
  console.log('End');
} catch (e) {
  console.log('Caught:', e.message);
}

medium

A. Start\nEnd

B. Start

C. Caught: Oops

D. Start\nCaught: Oops

Solution

1. Step 1: Trace code inside try block

   The first console logs 'Start'. Then an error is thrown, so the next console.log('End') is skipped.

2. Step 2: Catch block runs after error

   The catch block catches the error and logs 'Caught: Oops'.

3. Final Answer:

   Start\nCaught: Oops -> Option D

4. Quick Check:

   Error stops try, catch logs message [OK]

Hint: Error stops try; catch runs next [OK]

Common Mistakes:

• Thinking code after throw runs
• Ignoring catch block output
• Confusing error message with error object

4.

Find the error in this code snippet:

try {
  console.log('Hello');
} catch e {
  console.log('Error:', e);
}

medium

A. Missing parentheses around e in catch

B. Missing semicolon after console.log

C. Try block cannot have console.log

D. Catch block must come before try

Solution

1. Step 1: Check catch syntax

   The catch block must have parentheses around the error variable: catch (e).

2. Step 2: Verify other parts

   Semicolons are optional in JavaScript; console.log is allowed in try; catch must come after try.

3. Final Answer:

   Missing parentheses around e in catch -> Option A

4. Quick Check:

   Catch needs (error) [OK]

Hint: Catch always needs parentheses around error [OK]

Common Mistakes:

• Omitting parentheses in catch
• Thinking semicolons are mandatory here
• Reversing try and catch order

5.

You want to safely parse a JSON string that might be invalid. Which code correctly uses try-catch to handle errors and return null if parsing fails?

?

hard

A. try {
JSON.parse(str);
} catch {
return null;
}

B. try {
return JSON.parse(str);
} catch e {
return null;
}

C. try {
return JSON.parse(str);
} catch (e) {
return null;
}

D. try {
return JSON.parse(str);
} catch (e) {
throw null;
}

Solution

1. Step 1: Understand JSON parsing risks

   Parsing invalid JSON throws an error, so we use try-catch to handle it safely.

2. Step 2: Check correct catch syntax and behavior

   try { return JSON.parse(str); } catch (e) { return null; } uses correct catch syntax with (e) and returns null on error, which is the goal.

3. Step 3: Identify errors in other options

   try { JSON.parse(str); } catch { return null; } misses return before JSON.parse(str), so returns undefined on success. try { return JSON.parse(str); } catch e { return null; } has syntax error (catch e needs catch (e)). try { return JSON.parse(str); } catch (e) { throw null; } throws null instead of returning it.

4. Final Answer:

   try { return JSON.parse(str); } catch (e) { return null; } -> Option C

5. Quick Check:

   Catch error with (e), return null on failure [OK]

Hint: Catch error with (e), return null on failure [OK]

Common Mistakes:

• Omitting parentheses in catch
• Throwing instead of returning null
• Assuming catch without parameter always works