Optimize cyclomatic complicity in your javascript code.

Cyclomatic complexity is a measure of the complexity of a program, and it is calculated based on the number of independent paths through the code. High cyclomatic complexity can make code difficult to understand and maintain, and it can also be an indication of potential bugs.

To optimize cyclomatic complexity in JavaScript, you can follow these steps:

Identify areas of your code with high cyclomatic complexity. You can use a tool like SonarQube or a code analysis plugin for your editor to identify areas of your code with high cyclomatic complexity.

Refactor your code to reduce the number of independent paths. Here are a few ways you can do this:

Extract complex logic into separate functions or modules to make the code more modular and easier to understand.
Use early return statements to exit functions early when certain conditions are met.
Use conditional statements with fewer branches, such as using a switch statement instead of multiple if-else statements.

Here's an example of how these techniques might be applied to reduce cyclomatic complexity in a function:

Before:

function calculateTotal(items) {
  let total = 0;
  for (const item of items) {
    if (item.price > 10) {
      total += item.price * 0.9;
    } else if (item.price > 5) {
      total += item.price * 0.95;
    } else {
      total += item.price;
    }
  }
  return total;
}

After:

function calculateTotal(items) {
  let total = 0;
  for (const item of items) {
    total += getDiscountedPrice(item);
  }
  return total;
}

function getDiscountedPrice(item) {
  if (item.price > 10) {
    return item.price * 0.9;
  } else if (item.price > 5) {
    return item.price * 0.95;
  } else {
    return item.price;
  }
}