javascript中基于对象的切换替代方案

Question

I tend to use expression like this these days:

{ typeA: 'some code' }[type] ||
{ typeB: 'some other code' }[type] ||
defaultType

How do I fairly simple put multiple cases (something like:

switch (value)
{
   case typeA:
   case typeC:
      //do some stuff
      break;
   case typeB:
      //do some other stuff
   default:
       //default stuff
      break;
}

) in the code above? So it could work this way ( invalid piece of code):

{ typeA || typeC: 'some code' }[type] ||
{ typeB: 'some other code' }[type] ||
defaultType

Backstory: I am utilising the code in React, so the 'some code' samples are actually React components.

Answer 1

You're halfway there already. Just combine your objects into a big one:

    return ({
        typeA: "Foo",
        typeB: "Bar",
        get typeC() {//why not getters?
            return "computed value"
        }, 
    }[value]) || defaultValue;

I strongly recommend saving the case-object as a const or it'll re-allocate on every call.

---

This structure is suitable for values, but not conditional logic. If you need to execute different code on each case , you should either stick with switch , or make your object return functions:

const Values = {
    caseA: () => { /*...*/ },
    caseB: () => { /*...*/ },
   // ...etc
}


//get value from Values and execute function
Values['caseA']();

With this structure you don't get fall-through. If you want fall-through, stick with switch .

Answer 2

Define your switch-like object:

const types = {
  typeA: 'some code',
  ...
}

Then call it:

types[type] || defaultType

You can also include the default value in the switch-lick object:

const types= {
  typeA: 'some code',
  ...,
  default: 'some code for default type',
}

Later:

types[type] || types.default

If you are using functions as values:

(types[type] && types[type](args)) || types.default()

Answer 3

You could combine the objects into a single one, the first one at last, to keep the values from the first and take type as accessor.

For using an alias, you need to specify a new property for it.

result = { ...objectB, ...objectA, typeC: objectA.typeA }[type] || defaultValue;