当我查看其他答案中的解决方案时，我看到了一些我知道对性能不利的事情。我打算将它们放在评论中，但我认为最好对其进行基准测试并分享结果。你可以自己测试一下。以下是我在每个浏览器中以最快速度运行后标准化的结果 (ymmv)。

这是 2021-MAY-05 的结果

2021 年的测试在 64 位 Windows 10 上执行，使用以下版本：Chrome 90.0.4430.212、Firefox 89.0b13、Opera 76.0.4017.123、Edge 90.0.818.62、Brave 1.24.SL8016下运行和Node.816 s.1

Apple 没有为 Windows更新Safari，所以它仍然是 5.1.7。我在这次测试中将其更改为 Brave。

以下是 2012 年 9 月 4 日的结果，用于历史比较：

2012 年的测试在 32 位 Windows 7 上执行，使用以下版本：Chrome 21.0.1180.89m、Firefox 15.0、Opera 12.02、MSIE 9.0.8112、Safari 5.1.7。Node在 Linux 64 位机器上运行，因为 Node for Windows 上的计时器分辨率是 10 毫秒而不是 1 毫秒。

如果立即

这是所有测试环境中最快的方法，除了...鼓声MSIE！（惊喜，惊喜）。

这是实现它的推荐方法。

if (val < 1000) { /*do something */ } else
if (val < 2000) { /*do something */ } else
...
if (val < 30000) { /*do something */ } else

如果-间接

这是switch-indirect-arraybut with if-statements的变体，在所有测试引擎中速度更快。

2021 年，它比最快的测试慢 20-120%（2012 年：0-280%）。Chrome 2021 (2.20) 比 2012 (1.2) 需要更长的时间

values=[
   1000,  2000, ... 30000
];
if (val < values[0]) { /* do something */ } else
if (val < values[1]) { /* do something */ } else
...
if (val < values[29]) { /* do something */ } else

立即切换

当您可以进行计算以获取索引时，这会起作用。

在 2021 年，它比 慢 40-120%（2012 年：0-180%）if-immediate，除了在 MSIE 中它实际上是最快的。

switch (Math.floor(val/1000)) {
  case 0: /* do something */ break;
  case 1: /* do something */ break;
  ...
  case 29: /* do something */ break;
}

开关量程

它很慢，因为引擎必须为每种情况比较两次值。

2021 年，它比最快的测试慢 1-2.6（2012 年：1.6-38）倍。Chrome 从 38 到 3.6 的改进最大，但仍然是最慢的测试引擎。

switch (true) {
  case (0 <= val &&  val < 1000): /* do something */ break;
  case (1000 <= val &&  val < 2000): /* do something */ break;
  ...
  case (29000 <= val &&  val < 30000): /* do something */ break;
}

开关范围2

这是 的变体，switch-range但每个案例只有一个比较，因此速度更快。case 语句的顺序很重要，因为引擎将按照源代码顺序测试每个 case ECMAScript 2020 13.12.9

在 2021 年，它比最快的测试慢 36-107%，但在 2012 年，它慢了 1-31 倍。本次测试中表现最差的依然是Chrome，但从32倍提升到了2倍。

switch (true) {
  case (val < 1000): /* do something */ break;
  case (val < 2000): /* do something */ break;
  ...
  case (val < 30000): /* do something */ break;
}

开关间接阵列

在这个变体中，范围存储在一个数组中。

2021 年，它比最快的测试慢 57-193%（2012 年：3-35 倍）。所有测试引擎的性能都有所提高，虽然 Chrome 仍然是最慢的，但它已从 35 提高到 2.93。

values=[1000,  2000 ... 29000, 30000];

switch(true) {
  case (val < values[0]): /* do something */ break;
  case (val < values[1]): /* do something */ break;
  ...
  case (val < values[29]): /* do something */ break;
}

数组线性搜索

在这个变体中，范围存储在一个数组中。

2021 年，它比最快的测试慢 57-193%（2012 年：3-35 倍）。所有测试引擎的性能都有所提高，虽然 Chrome 仍然是最慢的，但它已从 35 提高到 2.93。

values=[1000,  2000 ... 29000, 30000];

for (sidx=0, slen=values.length; sidx < slen; ++sidx) {
  if (val < values[sidx]) break;
}

switch (sidx) {
  case 0: /* do something */ break;
  case 1: /* do something */ break;
  ...
  case 29: /* do something */ break;
}

阵列二进制开关

这是一种变体，array-linear-switch但带有二分搜索。不幸的是，它比线性搜索慢。不知道是我的实现还是线性搜索更优化了。也可能是键空间太小。

在 2021 年，这慢了 4-5（2012 年：4-16）倍。不要使用.

values=[0, 1000,  2000 ... 29000, 30000];

while(range) {
  range = Math.floor( (smax - smin) / 2 );
  sidx = smin + range;
  if ( val < values[sidx] ) { smax = sidx; } else { smin = sidx; }
}

switch (sidx) {
  case 0: /* do something */ break;
  ...
  case 29: /* do something */ break;
}

结论

如果性能很重要，请使用带有直接值的if-statements 或switch。

替代：

var scrollleft = 1000;
switch (true)
{
    case (scrollleft > 1000):
      alert('gt');
      break;
    case (scrollleft <= 1000):
      alert('lt');
      break; 
}

演示：http : //jsfiddle.net/UWYzr/

switch (Math.floor(scrollLeft/1000)) {
  case 0: // (<1000)
   //do stuff
   break;
  case 1: // (>=1000 && <2000)
   //do stuff;
   break;
}

只有在你有规律的步骤时才有效......

编辑：由于此解决方案不断获得赞成票，因此我必须建议mofolo 的解决方案更好

您可以使用条件和与条件对应的功能创建自定义对象

var rules = [{ lowerLimit: 0,    upperLimit: 1000, action: function1 }, 
             { lowerLimit: 1000, upperLimit: 2000, action: function2 }, 
             { lowerLimit: 2000, upperLimit: 3000, action: function3 }];

在这些情况下为您想要执行的操作定义函数（定义函数 1、函数 2 等）

并“评估”规则

function applyRules(scrollLeft)
{
   for(var i=0; i>rules.length; i++)
   {
       var oneRule = rules[i];
       if(scrollLeft > oneRule.lowerLimit && scrollLeft < oneRule.upperLimit)
       {
          oneRule.action();
       }
   }
}

笔记

我讨厌使用 30 个 if 语句

很多时候 if 语句更容易阅读和维护。只有当您有很多条件并且将来有很多增长的可能性时，我才会推荐上述内容。

更新
正如@Brad 在评论中指出的那样，如果条件是互斥的（一次只能其中一个为真），检查上限就足够了：

if(scrollLeft < oneRule.upperLimit)

如果条件是按升序定义的（例如0 to 1000，首先是最低的，然后1000 to 2000是）

你到底在做什么//do stuff？

您可以执行以下操作：

(scrollLeft < 1000) ? //do stuff
: (scrollLeft > 1000 && scrollLeft < 2000) ? //do stuff
: (scrollLeft > 2000) ? //do stuff
: //etc.