Using the switch(true) pattern in JavaScript (opens in new tab)

Which would look like this:

    const user = {
        firstName: "Seán",
        lastName: "Barry",
        email: "my.address@email.com",
        number: "00447123456789",
    };

    if (!user) {
        throw new Error("User must be defined.");
    }

    if (!user.firstName) {
        throw new Error("User's first name must be defined");
    }

    if (typeof user.firstName !== "string") {
        throw new Error("User's first name must be a string");
    }

    return user;

E.g.

  if (!user) {
    throw new Error("User must be defined.");
  } 

  if (!user.firstName) {
    throw new Error("User's first name must be defined");
  }

  return user;

The example I would pick is the following: Consider you need to switch depending on a version (of a specification in my case), but this version isn't represented as an enum in the codebase, but as a number instead. So our team had something like this in the codebase (early return):

  function foobar(version: number): string {
    if (version === 3.1 || version === 3) {
      return 'result_3';
    }

    if (version < 2 && version >= 1) {
      return 'result_1';
    }
  
    if (version >= 2) {
      return 'result_2';
    }
  
    throw new Error(`Cannot interpret version '${version}'`);
  }

  enum Version {
    _1_1 = 1.1,
    _2   = 2,
    _3   = 3,
    _3_1 = 3.1,
  };

  function foobar(version: Version): string {
    switch (version) {
      case Version._3_1:
      case Version._3:
        return 'result_3';
      case Version._2:
        return 'result_2';
      case Version._1_1:
        return 'result_1';
      default:
        (function (val: never): never {
          throw new Error(`Exhaustiveness reached: ${val}`);
        })(version);
    }
  }

  function foobar(version: number): string {
    switch (true) {
      case version >= 3:
        return 'result_3';
      case version >= 2:
        return 'result_2';
      case version >= 1:
        return 'result_1';
      default:
        throw new Error(`Cannot interpret version '${version}'`);
    }
  }

   ...
   case !isValidPhoneNumber(user.email):
   ...

[1]: https://github.com/kdeldycke/awesome-falsehood#emails

[2]: https://github.com/kdeldycke/awesome-falsehood#phone-numbers

It has an additional benefit of extracting code into data structures or making them parametric

  function getArrow(direction) {
    switch (direction) {
      case "left":
        return "<--"
      case "righ":
        return "-->"
      default:
        return "¯\\_(ツ)_/¯"
    }
  }

  function getArrow(direction) {
    const arrows = {
      left: "<--",
      right: "-->",
      default: "¯\\_(ツ)_/¯",
    }
    let arrow = arrows[direction]

    if (arrow) {
      return arrow
    } else {
      return arrow.default
    }
  }

I’ve recently added it back into my toolkit and am reminded how much I love it. Don’t over use it but there are some really gnarly if/else blocks that can be expressed beautifully with a switch and fall-thru.

  bool success = false;

  do {
    if (!someCondition) break;
    if (!otherCondition) break; 
    ...
    success = true;
  } while(false);
  
  if (!success) {
   ...
  }

Validations that happened at an application level must still be written but those tend to be specific to the application logic or system state. An example of logic related validation is contingently valid argument values where the compatibility of one value being used with another must be tested. An example of state related validation is a constraint that a given value must exist in a dynamic table.

Go did good by making case blocks break automatically and requiring the "fallthrough" keyword in one of those very rare cases you need it do.

It should be states as "The fundamental principle of the switch pattern in JavaScript is that you can match against expressions as well as values."

From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...:

A switch statement first evaluates its expression. It then looks for the first case clause whose expression evaluates to the same value as the result of the input expression

The switch(true) format was the closest I got to it, which I personally don't like compared to a clean if/else or early return.

There's probably some performance differences between if/else and switch (I haven't checked) but it probably end up being what's your preference / what standard code style you want to enforce on your team.

Also, because it throws you can just use if, without a block. Or use if at the end of the line if your language supports that.

Way cleaner (less indentation), and less error prone. Switch statements only exist because of the underlying assembly/opcode.

It just as bad as goto, because it IS goto. The cases are goto-labels. It behaves like goto, and will simply generate the same JE/JNE jumps

All in all: I probably won't be using it

This is wrong, Since there is no return or break default will also be executed.

— Programming in JavaScript is a bad pattern itself.