使用Object键值替换switch
在许多编程语言中，switch语句存在 - 但是它应该更长吗？如果你是一个JavaScript程序员，你经常跳进和跳出对象，创建，实例化和操作它们。对象非常灵活，它们是JavaScript中几乎所有内容的核心，使用它们代替switch语句是我最近一直在做的事情。
什么是switch语句？
如果您以前没有使用switch过或者有点不确定它是做什么的，那么让我们来看看吧。什么switch是输入并提供输出，例如正在运行的代码。
让我们来看一个通常的switch陈述：
var type = 'coke';
var drink;
switch(type) {
case 'coke':
drink = 'Coke';
break;
case 'pepsi':
drink = 'Pepsi';
break;
default:
drink = 'Unknown drink!';
}
console.log(drink); // 'Coke'
它类似于if和else语句，但它应该评估单个值 - 在switch我们使用a case来评估每个值。
当你开始看到很多else if陈述时，某些东西可能是错误的，通常你会使用类似于switch它更适合目的和意图的东西。这是一些else if滥用：
function getDrink (type) {
if (type === 'coke') {
type = 'Coke';
} else if (type === 'pepsi') {
type = 'Pepsi';
} else if (type === 'mountain dew') {
type = 'Mountain Dew';
} else if (type === 'lemonade') {
type = 'Lemonade';
} else if (type === 'fanta') {
type = 'Fanta';
} else {
// acts as our "default"
type = 'Unknown drink!';
}
return 'You\'ve picked a ' + type;
}
这个实现太松散了，有错误的余地，加上它是一个非常冗长的语法，可以不断重复自己。还有一个黑客攻击的空间，因为你可以评估每个内部的多个表达式else if，例如else if (type === 'coke' && somethingElse ！== 'apples')。这switch是该工作的最佳工具，尽管您需要不断添加break;语句以防止案件失败，这是其众多问题之一。
开关问题
switch从程序控制流程到其处理代码块的非标准方式存在多个问题，其余的JavaScript使用花括号而交换机则不然。从语法上讲，它不是JavaScript的最佳选择，也不是它的设计。我们被迫break;在每个语句中手动添加语句case，这可能导致难以调试和嵌套错误，如果我们忘记了！道格拉斯·克罗克福德（Douglas Crockford）曾多次撰写和谈论过这个问题，他的建议是谨慎对待。
我们经常在JavaScript中使用Object查找，通常用于我们永远不会考虑使用的东西switch- 那么为什么不使用Object键值替换switch？对象更灵活，具有更好的可读性和可维护性，我们不需要手动break;每个“案例”。他们对新的JavaScript开发人员也很友好，因为他们是标准对象。
随着“案例”数量的增加，对象（哈希表）的性能优于交换机的平均成本（案例的顺序很重要）。对象方法是哈希表查找，并且交换机必须评估每个案例，直到它遇到匹配和中断。
对象文本查找
我们一直使用对象，无论是构造函数还是文字。通常，我们将它们用于对象查找目的，以从Object属性中获取值。
让我们设置一个String仅返回值的简单Object键值。
function getDrink (type) {
var drinks = {
'coke': 'Coke',
'pepsi': 'Pepsi',
'lemonade': 'Lemonade',
'default': 'Default item'
};
return 'The drink I chose was ' + (drinks[type] || drinks['default']);
}
var drink = getDrink('coke');
// The drink I chose was Coke
console.log(drink);
我们从交换机中保存了几行代码，对我而言，数据在演示中更加清晰。我们甚至可以进一步简化它，没有默认情况：
function getDrink (type) {
return 'The drink I chose was ' + {
'coke': 'Coke',
'pepsi': 'Pepsi',
'lemonade': 'Lemonade'
}[type];
}
但是，我们可能需要比a更复杂的代码String，这可能会挂在函数内部。为了简洁和易于理解的示例，我将从新创建的函数返回上述字符串：
var type = 'coke';
var drinks = {
'coke': function () {
return 'Coke';
},
'pepsi': function () {
return 'Pepsi';
},
'lemonade': function () {
return 'Lemonade';
}
};
区别在于我们需要调用Object文字的函数：
drinks[type]();
更具可维护性和可读性。我们也不必担心break;陈述和案例会失败-这只是一个普通的对象。
通常，我们会switch在函数内部放入一个return值，因此在这里做同样的事情，然后将对象文字查找转换为可用的函数：
function getDrink (type) {
var drinks = {
'coke': function () {
return 'Coke';
},
'pepsi': function () {
return 'Pepsi';
},
'lemonade': function () {
return 'Lemonade';
}
};
return drinks[type]();
}
// let's call it
var drink = getDrink('coke');
console.log(drink); // 'Coke'
不错，很容易，但这并不能满足“ default”的要求case，因此我们可以轻松创建它：
function getDrink (type) {
var fn;
var drinks = {
'coke': function () {
return 'Coke';
},
'pepsi': function () {
return 'Pepsi';
},
'lemonade': function () {
return 'Lemonade';
},
'default': function () {
return 'Default item';
}
};
// if the drinks Object contains the type
// passed in, let's use it
if (drinks[type]) {
fn = drinks[type];
} else {
// otherwise we'll assign the default
// also the same as drinks.default
// it's just a little more consistent using square
// bracket notation everywhere
fn = drinks['default'];
}
return fn();
}
// called with "dr pepper"
var drink = getDrink('dr pepper');
console.log(drink); // 'Default item'
我们可以简化上面的内容，if并在表达式中else使用or ||运算符：
function getDrink (type) {
var drinks = {
'coke': function () {
return 'Coke';
},
'pepsi': function () {
return 'Pepsi';
},
'lemonade': function () {
return 'Lemonade';
},
'default': function () {
return 'Default item';
}
};
return (drinks[type] || drinks['default'])();
}
这会将两个对象查找包装在括号内( )，将它们视为表达式。然后调用表达式的结果。如果drinks[type]在查找中未找到，则默认为drinks['default']，简单！
我们不具备总是return里面的函数或者，我们可以改变引用任何变量然后返回它：
function getDrink (type) {
var drink;
var drinks = {
'coke': function () {
drink = 'Coke';
},
'pepsi': function () {
drink = 'Pepsi';
},
'lemonade': function () {
drink = 'Lemonade';
},
'default': function () {
drink = 'Default item';
}
};
// invoke it
(drinks[type] || drinks['default'])();
// return a String with chosen drink
return 'The drink I chose was ' + drink;
}
var drink = getDrink('coke');
// The drink I chose was Coke
console.log(drink);
这些是非常基本的解决方案，而Object字面量包含一个function返回a的值String，在您只需要a的情况下String，可以将a String用作键的值-在某些情况下，该函数将包含逻辑，该逻辑将从该函数返回。如果您要混合使用函数和字符串，则始终可以使用函数来保存查找type和调用（如果是函数）会更容易-我们不想尝试调用String。
对象字面量“告吹”
对于switch案例，我们可以让它们失败（这意味着一个以上的案例可以应用于特定的代码段）：
var type = 'coke';
var snack;
switch(type) {
case 'coke':
case 'pepsi':
snack = 'Drink';
break;
case 'cookies':
case 'crisps':
snack = 'Food';
break;
default:
drink = 'Unknown type!';
}
console.log(snack); // 'Drink'
让我们coke和pepsi“贯穿”以不添加break语句。为Object Literals执行此操作非常简单且更具说明性 - 并且不易出错。我们的代码突然变得更加结构化，可读性和可重用性：
function getSnack (type) {
var snack;
function isDrink () {
return snack = 'Drink';
}
function isFood () {
return snack = 'Food';
}
var snacks = {
'coke': isDrink,
'pepsi': isDrink,
'cookies': isFood,
'crisps': isFood,
};
return snacks[type]();
}
var snack = getSnack('coke');
console.log(snack); // 'Drink'
总结
Object键值是JavaScript中流动的一种更自然的控制，switch有点陈旧和笨重，并且容易出现调试错误。对象更具可扩展性，可维护性，我们可以更好地测试它们。它们也是设计模式的一部分，在日常的其他编程任务中非常常用。对象键值可以包含函数以及任何其他对象类型，这使它们非常灵活！键值中的每个函数也都有函数作用域，因此我们可以从我们调用的父函数getDrink返回闭包（在这种情况下返回闭包）。
