Forem: folacode22

Handling exception in NodeJS Express

folacode22 — Tue, 30 Aug 2022 06:05:19 +0000

Debugging errors is the hardest part of programming. Errors can appear in your code in a variety of ways, whether as syntax errors, errors in logic, or the most dreaded of all, runtime errors. Runtime errors occur whenever something unexpected occurs in your application, and they often lead to catastrophic issues that can crash your program.

Like many languages, Node.js provides a mechanism to anticipate errors before they occur. When an error occurs in your code, it turns into an object called an exception. Properly handling these exceptions allows you to recover gracefully from unforeseen issues, resulting in a much better user experience.

Creating exceptions
Error objects
Handling exceptions
Catching uncaught exceptions
Exceptions with promises
error handling in synchronous
error handling in express

Creating exceptions

An exception is created using the throw keyword:

As soon as JavaScript executes this line, the normal program flow is halted and the control is held back to the nearest exception handler.

Usually in client-side code value can be any JavaScript value including a string, a number or an object.

In Node.js, we don't throw strings, we just throw Error objects.

Error objects

An error object is an object that is either an instance of the Error object, or extends the Error class, provided in the Error core module:

Handling exceptions

An exception handler is a try/catch statement.

Any exception raised in the lines of code included in the try block is handled in the corresponding catch block:

try {
  // lines of code
} catch (e) {}

e in this example is the exception value.

You can add multiple handlers, that can catch different kinds of errors.

Exceptions with promises

Using promises you can chain different operations, and handle errors at the end:


performFunction1()
  .then(performFunction2)
  .then(performFunction3)
  .catch(err => console.error(err));

How do you know where the error occurred? You don't really know, but you can handle errors in each of the functions you call (performfunction(x)), and inside the error handler throw a new error, that's going to call the outside catch handler:

const performFunction1 = () => {
  // ...
  try {
    // ...
  } catch (err) {
    // ... handle it locally
    throw new Error(err.message);
  }
  // ...
};

To be able to handle errors locally without handling them in the function we call, we can break the chain. You can create a function in each then() and process the exception:

performFunction1()
  .then(() => {
    return performFunction2().catch(err => {
      // handle error
      throw err; // break the chain!
    });
  })
  .then(() => {
    return performFunction3().catch(err => {
      // handle error
      throw err; // break the chain!
    });
  })
  .catch(err => console.error(err));

Error Handling in express

Error Handling refers to how Express catches and processes errors that occur both synchronously and asynchronously. Express comes with a default error handler so you don’t need to write your own to get started.

It’s important to ensure that Express catches all errors that occur while running route handlers and middleware.

Errors that occur in synchronous code inside route handlers and middleware require no extra work. If synchronous code throws an error, then Express will catch and process it. For example:

app.get('/', (req, res) => {
  throw new Error('BROKEN') // Express will catch this on its own.
})

For errors returned from asynchronous functions invoked by route handlers and middleware, you must pass them to the next() function, where Express will catch and process them. For example:

app.get('/', (req, res, next) => {
  fs.readFile('/file-does-not-exist', (err, data) => {
    if (err) {
      next(err) // Pass errors to Express.
    } else {
      res.send(data)
    }
  })
})

error in asynchronous code, route handlers and middleware that return a Promise will call next(value) automatically when they reject or throw an error. For example:

app.get('/user/:id', async (req, res, next) => {
try{
  const user = await getUserById(req.params.id)
  res.send(user)}
catch(err){next(err)}
})

How to resolve merge Conflict in git ?

folacode22 — Sun, 07 Aug 2022 21:02:00 +0000

what is git?
why git?
basic git command
type of git merge conflict
how to resolve merge conflict in git?
git commands to resolve conflicts

What is Git?

Git is an open-source, distributed version control system (VCS) designed to handle everything from small to very large projects with speed and efficiency, which has a remote repository on the server-side and a local repository on the client-side. This means that the file or code is not present on a central server but there is a copy of the file stored on the client’s computer.

why git?

Simply put, Git is a version control system that lets you manage and keep track of your source code history. GitHub is a cloud-based hosting service that lets you manage Git repositories. If you have open-source projects that use Git, then GitHub is designed to help you better manage them.

Basic Git Commands


- git config 
- git init
- git add . 
- git diff
- git commit
- git reset
- git status
- git merge
- git push
- git pull

What is a Git Merge Conflict?

A merge conflict is an event that takes place when Git is unable to automatically resolve differences in code between two commits. Git can merge the changes automatically only if the commits are on different lines or branches.

Types of Git Merge Conflicts

There are two points when a merge can enter a conflict state:

Starting the Merge Process If there are changes in the working directory’s stage area for the current project, merging won’t start. In this case, conflicts happen due to pending changes that need to be stabilized using different Git commands.
During the Merge Process The failure during the merge process indicates that there is a conflict between the local branch and the branch being merged. In this case, Git resolves as much as possible, but there are things that have to be resolved manually in the conflicted files. We will now go over resolving merge conflicts in Git.

How to Resolve Merge Conflicts in Git?

There are a few steps that could reduce the steps needed to resolve merge conflicts in Git.

The easiest way to resolve a conflicted file is to open it and make any necessary changes
After editing the file, we can use the git add command to stage the new merged content.
The final step is to create a new commit with the help of the git commit command.
Git will create a new merge. commit to finalize the merge

Git Commands to Resolve Conflicts

The git log --merge command helps to produce the list of commits that are causing the conflict. >

 git log --merge

The git diff command helps to identify the differences between the states repositories or files. >

git diff

The git checkout command is used to undo the changes made to the file, or for changing branches >

 git checkout

The git reset --mixed command is used to undo changes to the working directory and staging area >

 git reset --mixed

The git merge --abort command helps in exiting the merge process and returning back to the state before the merging began. >

git merge --abort

The git reset command is used at the time of merge conflict to reset the conflicted files to their original state >

git reset