blocks|key|276198|text|这个解决方案更好，但我不建议在生产中使用它，因为它有点令人困惑：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|276199|4+-+[median+%2B+stdev,+median,+median+-+stdev].filter(function(e,+i,+a)+{
++++return+value(d)+>+e;
}).length+|code-block|syntax|javascript|276200|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This solution is nicer, but I would not recommend using it in production as it is kind of confusing:

<pre><code>4 - [median + stdev, median, median - stdev].filter(function(e, i, a) {
 return value(d) &gt; e;
}).length 
</code></pre>

blocks|key|276271|text|我没有看到太多的改进空间，可以保证与起始案例相同的可读性。如果你真的要返回整数，而且它们不是为了这个例子而存在的，我建议你返回一些更有意义的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|276272|您只需计算一次value(d)即可|offset|length|style|CODE|276273|var+level+=+function+(d)+{
++var+dValue+=+value(d);
++if+(dValue+>+median+%2B+stdev)+{
++++return+1;
++}+else+if+(dValue+>+median)+{
++++return+2;
++}+else+if+(dValue+>+median+-+stdev)+{
++++return+3;
++}+else+{
+++return+4;
++}
};|code-block|syntax|javascript|276274|此外，你可能想要避免多次返回，或者你不想，对我来说它们是一样的，每一个都有优点/缺点：|276275|var+level+=+function+(d)+{
++var+dValue+=+value(d),
++++++code+=+4;
++if+(dValue+>+median+%2B+stdev)+{
++++code+=+1;
++}+else+if+(dValue+>+median)+{
++++code+=+2;
++}+else+if+(dValue+>+median+-+stdev)+{
++++code+=+3;
++}+
++return+code;
};|276276|如果您为code指定了一个有意义的名称，那么您为正在阅读您的代码的人提供了更多的信息。|276277|entityMap^0|0|7|8|0|0|0|0|4|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

I don't see much room for improvements which could guarantee the same readability of the starting case. If you are really returning integers, and they aren't there just for the sake of this example, I would suggest you to return something more meaningful.

You could for sure compute <code>value(d)</code> just once

<pre><code>var level = function (d) {
 var dValue = value(d);
 if (dValue &gt; median + stdev) {
 return 1;
 } else if (dValue &gt; median) {
 return 2;
 } else if (dValue &gt; median - stdev) {
 return 3;
 } else {
 return 4;
 }
};
</code></pre>

Also, you might want to avoid multiple returns, or maybe you don't, for me they're the same, each has advanges/disadvantages:

<pre><code>var level = function (d) {
 var dValue = value(d),
 code = 4;
 if (dValue &gt; median + stdev) {
 code = 1;
 } else if (dValue &gt; median) {
 code = 2;
 } else if (dValue &gt; median - stdev) {
 code = 3;
 } 
 return code;
};
</code></pre>

If you assign a meaningful name to <code>code</code> you are giving even more information to the guy who is reading your code.

blocks|key|59880|text|这不会删除if/else结构，但会使代码更简洁：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|59881|var+level+=+function+(d)+{
++++var+delta+=+value(d)+-+median;
++++if+(delta+>+stdev)+{
++++++++return+1;
++++}+else+if+(delta+>+0)+{
++++++++return+2;
++++}+else+if+(delta+>+-stdev)+{
++++++++return+3;
++++}+else+{
++++++++return+4;
++++}
+};|code-block|syntax|javascript|59882|它还有一个额外的好处，那就是只调用value(d)一次。|offset|length|style|CODE|59883|entityMap^0|0|0|H|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This doesn't remove the if/else structure but makes the code a bit cleaner: 

<pre><code>var level = function (d) {
 var delta = value(d) - median;
 if (delta &gt; stdev) {
 return 1;
 } else if (delta &gt; 0) {
 return 2;
 } else if (delta &gt; -stdev) {
 return 3;
 } else {
 return 4;
 }
 };
</code></pre>

It has the added benefit of calling <code>value(d)</code> only once.

blocks|key|276406|text|我建议避免多次调用value|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|276407|function+level(d)+{
++++var+diff+=+value(d)+-+median;
++++if+(diff+>+0)+{
++++++++if+(diff+>+stdev)
++++++++++++return+1;
++++++++else
++++++++++++return+2;
++++else
++++++++if+(diff+>+-stdev)
++++++++++++return+3;
++++++++else
++++++++++++return+4;
}|code-block|syntax|javascript|276408|此外，我还将if-else-语句嵌套在(希望)更有意义的结构中-这取决于您的用例。如果你返回像-2、-1、1和2之类的值，可能会更有帮助。三元运算符可以为您节省一些编写工作，但这不一定会变得更加清晰。|276409|或者，一些数学可以帮助你：|276410|function+level(d)+{
++++var+diff+=+value(d)+-+median;
++++return+2+%2B+(diff+>+0+?+-.5+:+.5)+*+(Math.abs(diff)+>+stdev+?+3+:+1);
}|276411|尽管它指向3，而不是case+value(d)+===+median-stdev中的4。有关如何避免这种情况，请参阅@6502的答案。|276412|entityMap^0|9|5|0|0|1B|2|1E|2|1H|1|1J|1|0|0|0|5|1|F|P|16|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|17|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|T|$]]

I'd recommend to avoid multiple calls to <code>value</code>:

<pre><code>function level(d) {
 var diff = value(d) - median;
 if (diff &gt; 0) {
 if (diff &gt; stdev)
 return 1;
 else
 return 2;
 else
 if (diff &gt; -stdev)
 return 3;
 else
 return 4;
}
</code></pre>

Also I've nested the if-else-statements in a (hopefully) more meaningful structure - that depends on your usecase though. Might be more helpful if you returned values like <code>-2</code>, <code>-1</code>, <code>1</code> and <code>2</code> instead or something. A ternary operator could save you some writing, but it's not necessarily getting clearer.

Alternatively, some maths could help you:

<pre><code>function level(d) {
 var diff = value(d) - median;
 return 2 + (diff &gt; 0 ? -.5 : .5) * (Math.abs(diff) &gt; stdev ? 3 : 1);
}
</code></pre>

Though it leads to <code>3</code> instead of <code>4</code> in case <code>value(d) === median-stdev</code>. See @6502's answer on how to avoid that.

blocks|key|276432|text|您可以计算值和中位数之间的差异，这使得比较变得更简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|276433|function+level(d)+{
++var+n+=+value(d)+-+median;
++if+(n+>+stdev)+{
++++return+1;
++}+else+if+(n+>+0)+{
++++return+2;
++}+else+if+(n+>+-stdev)+{
++++return+3;
++}+else+{
++++return+4;
++}
};|code-block|syntax|javascript|276434|也可以使用条件运算符而不是if语句来编写它：|offset|length|style|CODE|276435|function+level(d)+{
++var+n+=+value(d)+-+median;
++return+n+>+stdev+?+1+:
++++n+>+0+?+2+:
++++n+>+-stdev+?+3+:
++++4;
++}
};|276436|这是不是更好，这是一个品味问题，但它更短。|276437|entityMap^0|0|0|D|2|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You can calculate the difference between the value and the median, which makes the comparisons simpler:

<pre><code>function level(d) {
 var n = value(d) - median;
 if (n &gt; stdev) {
 return 1;
 } else if (n &gt; 0) {
 return 2;
 } else if (n &gt; -stdev) {
 return 3;
 } else {
 return 4;
 }
};
</code></pre>

You can also write it using the conditional operator instead of <code>if</code> statements:

<pre><code>function level(d) {
 var n = value(d) - median;
 return n &gt; stdev ? 1 :
 n &gt; 0 ? 2 :
 n &gt; -stdev ? 3 :
 4;
 }
};
</code></pre>

Whether this is nicer or not is a matter of taste, but it's shorter.

blocks|key|60006|text|当然，多次调用value(d)是可以避免的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|60007|您还可以使用symmetry将其缩短一点|60008|++var+level+=+function+(d)+{
++++//
++++//+++++++++++++++-std++++median++%2Bstd
++++//+----------------%7C-------%7C-------%7C------------------
++++//+4444444444444444+3333333+2222222+111111111111111111
++++//
++++var+i+=+Math.floor((median+-+value(d))+/+stddev)+%2B+3;
++++return+Math.max(1,+Math.min(4,+i));
++};|code-block|syntax|javascript|60009|然而，对于一个真正的项目来说可能不是一个好主意。我没有测试，但如果我发现这个代码比你问题中的原始代码慢，我也不会感到惊讶，而且我肯定会发现它更难维护。|60010|请注意，排除一次性一次性脚本通常代码是一次编写和多次读取(为了维护，如改进或调试)，因此“更容易阅读”通常比“更容易编写”更重要。|60011|当shorter意味着“更容易阅读”是一件好事，当它开始意味着“更难阅读”时就不是了。|60012|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Symmetry^0|7|8|0|6|8|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@$9|14|A|15|1|16]]|E|$]]|$1|H|3|I|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|18|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|19|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1A|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

Of course calling <code>value(d)</code> multiple times is something you can avoid.

Also you can shorten a little using the <a href="http://en.wikipedia.org/wiki/Symmetry" rel="nofollow">symmetry</a>:

<pre><code> var level = function (d) {
 //
 // -std median +std
 // ----------------|-------|-------|------------------
 // 4444444444444444 3333333 2222222 111111111111111111
 //
 var i = Math.floor((median - value(d)) / stddev) + 3;
 return Math.max(1, Math.min(4, i));
 };
</code></pre>

Probably not a good idea for a real project however... I didn't test but I wouldn't be surprised to find this code slower than the original in your question and for sure I find it harder to maintain.

Note that excluding one-shot throwaway scripts normally code is written once and read many times (for maintenance like improvements or debugging), thus "easier to read" is normally much more important than "easier to write".

When shorter means "easier to read" is a good thing, when it starts meaning "harder to read" it's not.

blocks|key|60027|text|为了完成这个集合，这里是@austin引用的switch方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|60028|var+level+=+function+(d)+{
++var+d+=+value(d)+-+median;
++switch+(true)+{
++case+d+>+stdev+:+return+1;
++case+d+>+0:++++++return+2;
++case+d+>+-stdev:+return+3;
++default:+++++++++return+4;
++}
};|code-block|syntax|javascript|60029|entityMap^0|M|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

To complete the set, here is the <code>switch</code> way referenced by @austin :

<pre><code>var level = function (d) {
 var d = value(d) - median;
 switch (true) {
 case d &gt; stdev : return 1;
 case d &gt; 0: return 2;
 case d &gt; -stdev: return 3;
 default: return 4;
 }
};
</code></pre>

blocks|key|60087|text|另一种选择-在这种情况下忽略数学的有用性-是完全取消if语句。我通常更喜欢这种方法，而不是使用三元运算符。我倾向于认为这比拥有多个if/else结构(对于简单的情况)更具可读性，但这只是因为我精通JavaScript的逻辑运算符。我完全理解对于那些正在学习的人，或者那些用1+&&+3+===+TRUE而不是3用奇怪的外语编写代码的人来说，这是多么奇怪。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|60088|var+level+=+function+(d)+{
++d+=+value(d);
++return+((d+>+median+%2B+stdev)+&&+1)+
++++++%7C%7C+((d+>+median)+++++++++&&+2)+
++++++%7C%7C+((d+>+median+-+stdev)+&&+3)
++++++%7C%7C+4
++;
}|code-block|syntax|javascript|60089|另一个可能的优化-这个问题独一无二的-将从比较中删除median，然而，这很可能会影响可读性：|60090|var+level+=+function+(d)+{
++d+=+value(d)+-+median;
++return+((d+>+%2B+stdev)+&&+1)+
++++++%7C%7C+((d+>+0)+++++++&&+2)+
++++++%7C%7C+((d+>+-+stdev)+&&+3)
++++++%7C%7C+4
++;
}|60091|entityMap^0|3S|F|4A|1|0|0|Q|6|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

Another option &mdash; ignoring the usefulness of maths in this instance &mdash; is to do away with the if statements altogether. I generally prefer this approach to that of using ternary operators. I tend to think this is more readable than having multiple if/else constructs (for simple situations), but that is only because I am versed in the ways of JavaScript's logical operators. I can fully understand how odd it might look to those learning, or people who code in strange and foreign languages where <code>1 &amp;&amp; 3 === TRUE</code> and not <code>3</code>

<pre><code>var level = function (d) {
 d = value(d);
 return ((d &gt; median + stdev) &amp;&amp; 1) 
 || ((d &gt; median) &amp;&amp; 2) 
 || ((d &gt; median - stdev) &amp;&amp; 3)
 || 4
 ;
}
</code></pre>

A further possible optimisation &mdash; unique to this question &mdash; would be to remove <code>median</code> from the comparisons, however, this would most likely affect the readability:

<pre><code>var level = function (d) {
 d = value(d) - median;
 return ((d &gt; + stdev) &amp;&amp; 1) 
 || ((d &gt; 0) &amp;&amp; 2) 
 || ((d &gt; - stdev) &amp;&amp; 3)
 || 4
 ;
}
</code></pre>

blocks|key|60096|text|如果我们想要简短的，有创意的解决方案...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|60097|var+level+=+function(d){
++++d+=+value(d);
++++return+%2B(d<=median%2Bstdev)%2B+%2B(d<=median)%2B+%2B(d<=median-stdev)+%2B+1
}|code-block|syntax|javascript|60098|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Well if we're going for short, creative solutions...

<pre><code>var level = function(d){
 d = value(d);
 return +(d&lt;=median+stdev)+ +(d&lt;=median)+ +(d&lt;=median-stdev) + 1
}
</code></pre>

blocks|key|60115|text|var+level+=+function(d){
++++var+n+=+value(d)+-+median,+values+=+[];
++++values[stdev]++=+1;
++++values[0]++++++=+2;
++++values[-stdev]+=+3;
++++return+values[n]+?+values[n]+:+4;
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|60116|如果需要，可以将values从函数范围中拉出。|unstyled|offset|length|style|CODE|60117|entityMap^0|0|8|6|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>var level = function(d){
 var n = value(d) - median, values = [];
 values[stdev] = 1;
 values[0] = 2;
 values[-stdev] = 3;
 return values[n] ? values[n] : 4;
};
</code></pre>

<code>values</code> could be pulled out of the function scope if desired.

blocks|key|276606|text|我不会碰密码的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|276607|这里有许多张贴的代码，但你的代码仍然是可读性最强的。|276608|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I wouldn't touch the code.

There are many posted codes here, but still yours is the most readable.

The code I have is:

<pre><code> var level = function (d) {
 if (value(d) &gt; median + stdev) {
 return 1;
 } else if (value(d) &gt; median) {
 return 2;
 } else if (value(d) &gt; median - stdev) {
 return 3;
 } else {
 return 4;
 }
 };
</code></pre>

Is there a nicer way of doing this?

Shortening a Javascript if-else structure

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我的代码是： var level = function (d) {    if (value(d) > median + stdev) {        return 1;    } else if (value(d) > median) {        return 2;    } else if (value(d...

问缩短Javascript if-else结构
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问缩短Javascript if-else结构EN