Switch-case block behavior with OR operator

The behavior is as expected, it happens that for each block caseyou should use a statement breakthat indicates the exit or interruption of the switch, if you don't, the evaluation of the next block will be executed.

For example:

const bad = (value) => {
    // switch sin usar break
    switch (value) {
        case 1:
            console.log(`Foo: ${value}`);
        case -1:
            console.log(`Bar: ${value}`);
        default:
            console.log(`Baz: ${value}`);
            break;
    }
};

const values = [0, 1, -1];
values.forEach(v => bad(v));

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

As can be seen, by not incorporating or including the statement break, the following block of code is executed regardless of whether it does not match the given case. The statement switchlooks for the case and starts executing from the first one it finds within the case, if it doesn't get any, it executes the statement default.

If we put the sentence breakthe code is executed correctly:

const good = (value) => {
    // switch usando break
    switch (value) {
        case 1:
            console.log(`Foo: ${value}`);
            break;
        case -1:
            console.log(`Bar: ${value}`);
            break;
        default:
            console.log(`Baz: ${value}`);
            break;
    }
};

const values = [0, 1, -1];
values.forEach(v => good(v));

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

However, we see that for both case 1 and -1, the block to be executed is identical, so we can write:

const better = (value) => {
    // switch sin usar break
    switch (value) {
        case 1:
        case -1:
            console.log(`Bar: ${value}`);
            break;
        default:
            console.log(`Baz: ${value}`);
            break;
    }
};

const values = [0, 1, -1];
values.forEach(v => better(v));

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

And if you want to make it a bit more obvious, then you write it as you show in your question:

const evenBetter = (value) => {
    // switch sin usar break
    switch (value) {
        case 1: case -1:
            console.log(`Bar: ${value}`);
            break;
        default:
            console.log(`Baz: ${value}`);
            break;
    }
};

const values = [0, 1, -1];
values.forEach(v => evenBetter(v));

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

Why case 1 || -1doesn't it work?

First of all, it must be understood that the statement switch ... casecompares the value of the variable passed as an argument to switchthe value declared in case:

switch(value) {
    case 1: // si value === 1
       ...
       break;
    case -1: // si value === -1
       ...
       break;
    default: // si no es ninguno de los anteriores
       ...
}

So using one caseof this type: case 1 || -1will always evaluate the case when values ​​is 1, because the operator ||is short-circuiting, and returns the leftmost element if itself evaluates to true, that is, if itself is truthy.

That means that it case 1 || -1:will always be equal to case 1:and will never be equal tocase -1:

We can see it:

const tooBad = (value) => {
    // switch sin usar break
    switch (value) {
        case 1 || -1:
            console.log(`Bar: ${value}`);
            break;
        default:
            console.log(`Baz: ${value}`);
            break;
    }
};

const values = [0, 1, -1];
values.forEach(v => tooBad(v));
console.log(`1 || -1 => ${1 || -1}`);

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

Hope this clears your doubt. Agur!!!

The case statement syntax expects a single value, as its documentation says .

In your question you intend to compare the switch parameter with different case values, which is not interpreted as you intend, because what the case does is resolve that OR to convert it to a single value before being executed in the switch statement.

If you do this in javascript:

console.log(1 || -1)

you will see that it returns 1, that's why it only works in that case.

To use conditionals within case statements, it is still possible, but they must be resolved before being compared to the case statement parameter.

In your case, this could be a solution:

input = "1";
switch(true){
  case (input == "1" || input == "-1"):
    console.log("1 o -1");
    break;
   default:
    console.log("Default")
    break;
}

where we establish a boolean value true as a parameter , and within the case we compare both possible inputs with the OR, which will return true or false, allowing us to enter the corresponding case or jump to the default.

The block switchcompares the value of each casewith input. You can't use logical operators in a case. In the example you gave it works with input = 1a particularity of the operator ||.

1 || -1is an expression that evaluates to 1(because 1 == true, so the operator ||returns the first value). Then the label remains as case 1:, that's why when you put input = 1enters that case but not withinput = -1