UNIT 2 CLIENT SIDE PROGRAMMING

-

 2.3 JavaScript - Exception Handling

Introduction:

Exception handling in JavaScript refers to managing errors that occur during the execution of a program. It allows developers to gracefully handle unexpected situations, ensuring the program doesn't crash and provides meaningful feedback to the user.

1. What is Exception Handling in JavaScript?

Exception handling is the process of capturing and managing errors during program execution.

Key elements of exception handling in JavaScript:

  • try: Contains code that may throw an error.
  • catch: Handles the error if one occurs.
  • finally: Executes code after the try-catch block, regardless of the outcome.
  • throw: Used to create custom errors.

Example:

try {
  // Code that may throw an error
  let num = 10 / 0;
  console.log(num);
} catch (error) {
  // Handles the error
  console.log("An error occurred:", error.message);
} finally {
  // Executes regardless of an error
  console.log("Execution complete.");
}

2. How Exception Handling Works (Simple Explanation):

Step 1: Place code that might cause an error inside a try block.

Step 2: Use a catch block to handle the error if it occurs.

Step 3: Optionally, use a finally block to execute code regardless of the error.

Example:

try {
  console.log(nonExistentVariable);
} catch (error) {
  console.log("Error caught:", error.message);
} finally {
  console.log("This will always execute.");
}

3. Common Exception Handling Keywords:

• try: Executes code that may throw an error.

Example:

try {
  let x = 5 / 0;
}

• catch (error): Handles errors thrown in the try block.

Example:

catch (error) {
  console.log("Error:", error.message);
}

• finally: Executes code after the try and catch blocks, regardless of success or failure.

Example:

finally {
  console.log("Always runs.");
}

• throw: Manually creates custom exceptions.

Example:

throw new Error("This is a custom error!");

4. Advantages of Exception Handling:

  • Prevents program crashes by handling errors gracefully.
  • Makes debugging easier by identifying specific error locations.
  • Improves user experience by providing meaningful error messages.

5. Disadvantages of Exception Handling:

  • Overhead: Adding try-catch blocks can slightly impact performance.
  • Misuse: Improper handling may obscure bugs or lead to unhandled exceptions.

6. Real-World Use of Exception Handling:

Examples:

  • Form Validation: Catching and handling invalid inputs during form submission.
    • try {
  let age = parseInt("abc");
  if (isNaN(age)) throw new Error("Invalid age");
  console.log("Age is valid.");
} catch (error) {
  console.log("Error:", error.message);
}
  • API Requests: Handling errors when fetching data from a server.
    • fetch("https://api.example.com/data")
  .then(response => {
    if (!response.ok) throw new Error("Network response was not ok");
    return response.json();
  })
  .catch(error => console.log("Fetch error:", error.message));

Comments

Post a Comment

Popular posts from this blog

CS3492 Database Management Systems Syllabus

-
UNIT I RELATIONAL DATABASES  Purpose of Database System – Views of data – Data Models – Database System Architecture – Introduction to relational databases – Relational Model – Keys – Relational Algebra – SQL fundamentals – Advanced SQL features – Embedded SQL– Dynamic SQL UNIT II DATABASE DESIGN Entity-Relationship model – E-R Diagrams – Enhanced-ER Model – ER-to-Relational Mapping – Functional Dependencies – Non-loss Decomposition – First, Second, Third Normal Forms, Dependency Preservation – Boyce/Codd Normal Form – Multi-valued Dependencies and Fourth Normal Form – Join Dependencies and Fifth Normal Form UNIT III TRANSACTIONS Transaction Concepts – ACID Properties – Schedules – Serializability – Transaction support in SQL – Need for Concurrency – Concurrency control – Two Phase Locking - Timestamp – Multiversion – Validation and Snapshot isolation – Multiple Granularity locking – Deadlock Handling – Recovery Concepts – Recovery based on deferred and immed...
Read more

UNIT I RELATIONAL DATABASES

-
Image
 1.7 Keys In the context of a relational database, keys are one of the basic requirements of a relational database model. Keys are fundamental components that ensure data integrity, uniqueness and efficient access. It is widely used to identify the tuples(rows) uniquely in the table. We also use keys to set up relations amongst various columns and tables of a relational database. Keys in DBMS Why do we require Keys in a DBMS? Keys are important in a Database Management System (DBMS) for several reasons: Uniqueness: Keys ensure that each record in a table is unique and can be identified distinctly. Data Integrity: Keys prevent data duplication and maintain the consistency of the data. Efficient Data Retrieval: By defining relationships between tables, keys enable faster querying and better data organization. Without keys, it would be extremely difficult to manage large datasets and queries would become inefficient and prone to errors. Types of Database Keys 1. Super Key The set of o...
Read more

UNIT I RELATIONAL DATABASES

-
Image
1.3 Data Models Data Model   is a logical structure of Database. It describes the design of database to reflect entities, attributes, relationship among data, constrains etc. Types of Data Models There are several types of data models in DBMS.  Object based logical Models  – Describe data at the conceptual and view levels. E-R Model Object oriented Model Record based logical Models  – Like Object based model, they also describe data at the conceptual and view levels. These models specify logical structure of database with records, fields and attributes. Relational Model Hierarchical Model Network Model – Network Model is same as hierarchical model except that it has graph-like structure rather than a tree-based structure. Unlike hierarchical model, this model allows each record to have more than one parent record. Physical Data Models  – These models describe data at the lowest level of abstraction. 1.4 Database System Architechture      The archi...
Read more