Is this intended behaviour of custom errors?-CodePudding

I'm currently in the process of remaking the maze package from five years ago in ES2015. I am making a custom error, named LengthError, which will be thrown if an argument of type Function does not have a specified length. I just want to know if this is the intended behaviour because I am running this locally, or if this will carry over to production for when others might use this function?

Error:

LengthError: Argument 'adjacent' must be of length 2
/home/runner/maze/index.ts:6
      throw new LengthError('Argument \'adjacent\' must be of length 2')
            ^

LengthError: Argument 'adjacent' must be of length 2
    at null.generate (/home/runner/maze/index.ts:6:13)
    at Object.<anonymous> (/home/runner/maze/index.ts:37:1)
    at Module._compile (node:internal/modules/cjs/loader:1101:14)
    at Object.Module._extensions..js (node:internal/modules/cjs/loader:1153:10)
    at Module.load (node:internal/modules/cjs/loader:981:32)
    at Function.Module._load (node:internal/modules/cjs/loader:822:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
    at node:internal/main/run_main_module:17:47

index.ts:

import { LengthError } from './errors';

export default function generate(nodes: number[], adjacent: Function, choose: Function) {
  if (adjacent.length !== 2) {
    try {
      throw new LengthError('Argument \'adjacent\' must be of length 2')
    } catch(e: any) {
      console.error(e.name   ': '   e.message   '\n'   e.stack)
    }
  }
  let node: number = choose(nodes);
  let stack = [node];
  let maze = new Map();
  for (node of nodes) {
    maze.set(node, []);
  }
  
  while (node) {
    let neighbors = nodes.filter(other => !maze.get(other).length && adjacent(node, other));
    
    if (neighbors.length) {
      const neighbor = choose(neighbors);
      maze.get(node).push(neighbor);
      maze.get(neighbor).push(node);
      stack.unshift(neighbor);
      node = neighbor;
    } else {
      stack.shift();
      node = stack[0];
    }
  }

  
  return maze;
}

generate([], function a() {}, function b() {});

errors.ts:

class LengthError extends Error {
  constructor(message: string) {
    super(message);
    this.message = message;
    this.name = "LengthError";
  }
}

export { LengthError };

Again, is this code going to display a similar error in production (where the custom error shows twice) and will it point to the same line in my file?

CodePudding user response：

I just want to know if this is the intended behaviour because I am running this locally, or if this will carry over to production for when others might use this function?

Yes, this is how it works, both locally and in production. This is what nodejs does when there's an uncaught exception using try/catch.

When you throw errors, you're supposed to have code somewhere else that catches them and turns them into the desired behavior.

In the error message, the first line is the statement of the error. The second set of lines are the "stack trace" that show where in the code this originated from, including the current call stack at the time of the error.

Note, in your code that catches exceptions, you may want to log the exception and perhaps even log the track trace and then "handle" the error in some way that makes sense for your application (such as return a user-friendly error message or in an API, return some documented API error or in an http request, return a 4xx or 5xx error status).