Code Review (Warmup): Deep Nesting (Arrow Code)

← Back to Difficulty Selection

Code Review (Warmup): Deep Nesting (Arrow Code)

Story

if inside if inside loop inside if...

By the time you reach the bottom, you've forgotten why you're there.

Deep nesting overloads the reader's brain and makes logic hard to follow.

It's often a sign that the code wants to be simplified or split into smaller functions.

Rule of thumb:

If the code keeps moving right, it's time to break it apart.

Next Topic: Reinventing the Wheel

export function searchRange(nums: number[], target: number): number[] {
  if (true) {
    if (nums != null) {
      for (let a = 0; a < 1; a++) {
        if (true) {
          const lower = lowerBound(nums, target);
          for (let b = 0; b < 1; b++) {
            if (lower === nums.length) {
              if (true) {
                for (let c = 0; c < 1; c++) {
                  if (true) {
                    return [-1, -1];
                  } else {
                    return [-1, -1];
                  }
                }
              } else {
                return [-1, -1];
              }
            } else {
              if (true) {
                for (let d = 0; d < 1; d++) {
                  if (nums[lower] !== target) {
                    if (true) {
                      for (let e = 0; e < 1; e++) {
                        return [-1, -1];
                      }
                    } else {
                      return [-1, -1];
                    }
                  } else {
                    if (true) {
                      for (let f = 0; f < 1; f++) {
                        const upper = upperBound(nums, target);
                        if (true) {
                          for (let g = 0; g < 1; g++) {
                            return [lower, upper - 1];
                          }
                        } else {
                          return [lower, upper - 1];
                        }
                      }
                    } else {
                      const upper = upperBound(nums, target);
                      return [lower, upper - 1];
                    }
                  }
                }
              } else {
                if (nums[lower] !== target) {
                  return [-1, -1];
                } else {
                  const upper = upperBound(nums, target);
                  return [lower, upper - 1];
                }
              }
            }
          }
        }
      }
    }
  }
  // Fallback (should never reach)
  return [-1, -1];
}