blocks|key|1332028|text|我没有意识到更深层次的概念。我相信它通常是在可维护性指数的背景下被考虑的。一个特定方法中的分支越多，维护该方法操作的心理模型(通常)就越困难。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1332029|具有更高圈复杂度的方法在单元测试中也更难获得完整的代码复盖率。(谢谢Mark+W!)|offset|length|1332030|当然，这也带来了可维护性的所有其他方面。错误/回归/等等的可能性。不过，其核心概念非常简单明了。|1332031|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/102529/marc-w^0|0|Y|6|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

I'm not aware of a deeper concept. I believe it's generally considered in the context of a maintainability index. The more branches there are within a particular method, the more difficult it is to maintain a mental model of that method's operation (generally). 

Methods with higher cyclomatic complexity are also more difficult to obtain full code coverage on in unit tests. (Thanks <a href="https://stackoverflow.com/users/102529/marc-w">Mark W</a>!)

That brings all the other aspects of maintainability in, of course. Likelihood of errors/regressions/so forth. The core concept is pretty straight-forward, though.

blocks|key|1332067|text|是的，就是这样。代码可以采用的执行路径越多，必须测试的东西就越多，出错的概率也就越高。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1332068|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yep, that's really it. The more execution paths your code can take, the more things that must be tested, and the higher probability of error.

blocks|key|1547445|text|就是这样，想法是CC低的方法有更少的fork，循环等，这些都会使方法变得更加复杂。想象一下，使用分析器检查500,000行代码，并看到两个具有更高CC量级的方法。这让您可以专注于重构这些方法，以便更好地理解(高CC也有高bug率的情况也很常见)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547446|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

That's it, the idea is that a method which has a low CC has less forks, looping etc which all make a method more complex. Imagine reviewing 500,000 lines of code, with an analyzer and seeing a couple methods which have oder of magnitude higher CC. This lets you then focus on refactoring those methods for better understanding (It's also common that a high CC has a high bug rate)

blocks|key|1547486|text|圈复杂度衡量的是您必须执行具有不同参数的代码块的次数，以便执行通过该块的每条路径。更高的计数是不好的，因为它增加了逻辑错误逃离测试策略的机会。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547487|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Cyclomatic complexity measures the number of times you must execute a block of code with varying parameters in order to execute every path through that block. A higher count is bad because it increases the chances for logical errors escaping your testing strategy.

blocks|key|1547537|text|例程中的每个决策点(循环、切换、if等)本质上归结为一个等价的if语句。对于每个if，您有两个可以采用的代码路径。因此，第一个分支有2个代码路径，第二个有4个可能的路径，第三个有8个，依此类推。至少有2**N个代码路径，其中N是分支的数量。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1547538|这使得理解代码的行为并在N增长超过某个小数字时对其进行测试变得困难。|1547539|entityMap^0|14|2|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Each decision point in a routine (loop, switch, if, etc...) essentially boils down to an if statement equivalent. For each <code>if</code> you have 2 codepaths that can be taken. So with the 1st branch there's 2 code paths, with the second there are 4 possible paths, with the 3rd there are 8 and so on. There are at least 2**N code paths where N is the number of branches.

This makes it difficult to understand the behavior of code and to test it when N grows beyond some small number.

blocks|key|1547689|text|考虑函数的control+flow+graph，从出口到入口有一个额外的边缘。圈复杂度是我们在不将图分成两部分的情况下所能进行的最大切割次数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1547690|例如：|1547691|function+F:
++++if+condition1:
+++++++...
++++else:
+++++++...
++++if+condition2:
+++++++...
++++else:
+++++++...|code-block|syntax|javascript|1547692|​|1547693|📷|atomic|1547694|1547695|Control+Flow+Graph|1547696|您可能可以直观地看出为什么链接图的圈复杂度为3。|1547697|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Control_flow_graph|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/28bb17782b35baa66e112f4cbbdd6eca.png|imageAlt|2|http://en.wikipedia.org/wiki/File:Control_flow_graph_of_function_with_two_if_else_statements.svg^0|5|I|0|0|0|0|0|0|1|1|0|0|0|I|2|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1F|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|C|$]]|$1|M|3|N|5|O|7|1H|8|@]|9|@$A|1I|B|1J|1|1K]]|C|$]]|$1|P|3|L|5|6|7|1L|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|S|3|T|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|13|Y|14|C|$15|16|17|-4]]|18|$5|X|Y|Z|C|$10|19]]]]

Consider the <a href="http://en.wikipedia.org/wiki/Control_flow_graph" rel="nofollow noreferrer">control flow graph</a> of your function, with an additional edge running from the exit to the entrance. The cyclomatic complexity is the maximum number of cuts we can make without separating the graph into two pieces.

For example:

<pre><code>function F:
 if condition1:
 ...
 else:
 ...
 if condition2:
 ...
 else:
 ...
</code></pre>

<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/7/7f/Control_flow_graph_of_function_with_two_if_else_statements.svg/384px-Control_flow_graph_of_function_with_two_if_else_statements.svg.png" alt="Control Flow Graph">

<a href="http://en.wikipedia.org/wiki/File:Control_flow_graph_of_function_with_two_if_else_statements.svg" rel="nofollow noreferrer">Control Flow Graph</a>

You can probably intuitively see why the linked graph has a cyclomatic complexity of 3.

blocks|key|1332347|text|循环复杂度基本上是一个度量标准，用来找出需要更多关注可维护性的代码区域。它基本上是重构的一个输入。在避免深度嵌套循环、条件等方面，它明确指出了代码改进的地方。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1332348|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Cyclomatric complexity is basically a metric to figure out areas of code that needs more attension for the maintainability. It would be basically an input to the refactoring.
It definitely gives an indication of code improvement area in terms of avoiding deep nested loop, conditions etc.

blocks|key|1332398|text|圈复杂度真的只是一个可怕的流行语。事实上，它是用于软件开发的代码复杂性的度量，用于指出代码中更复杂的部分(更有可能是错误的，因此必须非常仔细和彻底地测试)。你可以使用E-N%2B2P公式来计算它，但我建议你通过插件自动计算它。我听说过一条经验法则，即你应该努力将CC保持在5以下，以保持代码的良好可读性和可维护性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1332399|我最近刚刚在我的Java项目中试用了Eclipse+Metrics+Plugin，它有一个非常好和简洁的帮助文件，它当然会与您的常规Eclipse帮助集成在一起，您可以阅读有关各种复杂性度量的更多定义以及改进代码的提示和技巧。|offset|length|1332400|entityMap|0|LINK|mutability|MUTABLE|url|http://eclipse-metrics.sourceforge.net/^0|0|I|M|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Cyclomatic Complexity really is just a scary buzzword. In fact it's a measure of code complexity used in software development to point out more complex parts of code (more likely to be buggy, and therefore has to be very carefully and thoroughly tested). You can calculate it using the E-N+2P formula, but I would suggest you have this calculated automatically by a plugin. I have heard of a rule of thumb that you should strive to keep the CC below 5 to maintain good readability and maintainability of your code.

I have just recently experimented with the <a href="http://eclipse-metrics.sourceforge.net/" rel="nofollow noreferrer">Eclipse Metrics Plugin</a> on my Java projects, and it has a really nice and concise Help file which will of course integrate with your regular Eclipse help and you can read some more definitions of various complexity measures and tips and tricks on improving your code.

blocks|key|1547831|text|我听到的另一个有趣的观点是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547832|代码中缩进最多的地方应该有最高的CC。这些通常是确保测试覆盖率的最重要的区域，因为预计它们将更难阅读/维护。正如其他答案所指出的那样，这些也是确保覆盖率的更困难的代码区域。|1547833|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|$]]

Another interesting point I've heard:

The places in your code with the biggest indents should have the highest CC. These are generally the most important areas to ensure testing coverage because it's expected that they'll be harder to read/maintain. As other answers note, these are also the more difficult regions of code to ensure coverage.

blocks|key|1547902|text|到目前为止，提供的答案没有提到软件质量与圈复杂度的相关性。研究表明，具有较低的圈复杂度度量应该有助于开发更高质量的软件。它有助于提高软件的可读性、可维护性和可移植性等软件质量属性。通常，人们应该尝试获得5-10之间的圈复杂度度量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547903|使用像圈复杂度这样的度量标准的原因之一是，一般来说，一个人只能在你的大脑中同时跟踪大约7条(加或减2条)信息。因此，如果您的软件过于复杂，具有多个决策路径，则您不太可能能够可视化您的软件将如何运行(即，它将具有很高的圈复杂度度量)。这很可能会导致开发出错误或充满bug的软件。有关这方面的更多信息可以在here和Wikipedia上找到。|offset|length|1547904|entityMap|0|LINK|mutability|MUTABLE|url|http://www.mathworks.com/discovery/cyclomatic-complexity.html|1|http://One%2520of%2520the%2520reasons%2520for%2520using%2520metrics%2520like%2520cyclomatic%2520complexity%2520is%2520that%2520in%2520general%2520a%2520human%2520being%2520can%2520only%2520keep%2520track%2520of%2520about%25207%2520%2528plus%2520or%2520minus%25202%2529%2520pieces%2520of%2520information%2520simultaneously%2520in%2520your%2520brain.%2520%2520Therefore,%2520if%2520your%2520software%2520is%2520overly%2520complex%2520with%2520multiple%2520decision%2520paths,%2520it%2520is%2520unlikely%2520that%2520you%2520will%2520be%2520able%2520to%2520visualize%2520how%2520your%2520software%2520will%2520behave%2520%2528i.e.%2520it%2520will%2520have%2520a%2520high%2520cyclomatic%2520complexity%2520metric%2529.%2520This%2520would%2520most%2520likely%2520lead%2520to%2520developing%2520erroneous%2520or%2520bug%2520ridden%2520software.%2520%2520More%2520information%2520about%2520this%2520can%2520be%2520found%2520here%2520and%2520also%2520on%2520Wikipedia.^0|0|47|4|0|4C|9|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]|$D|U|E|V|1|W]]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]|N|$5|I|J|K|A|$L|O]]]]

The answers provided so far do not mention the correlation of software quality to cyclomatic complexity. Research has shown that having a lower cyclomatic complexity metric should help develop software that is of higher quality. It can help with software quality attributes of readability, maintainability, and portability. In general one should attempt to obtain a cyclomatic complexity metric of between 5-10. 

One of the reasons for using metrics like cyclomatic complexity is that in general a human being can only keep track of about 7 (plus or minus 2) pieces of information simultaneously in your brain. Therefore, if your software is overly complex with multiple decision paths, it is unlikely that you will be able to visualize how your software will behave (i.e. it will have a high cyclomatic complexity metric). This would most likely lead to developing erroneous or bug ridden software. More information about this can be found <a href="http://www.mathworks.com/discovery/cyclomatic-complexity.html" rel="nofollow">here</a> and also on <a href="http://One%20of%20the%20reasons%20for%20using%20metrics%20like%20cyclomatic%20complexity%20is%20that%20in%20general%20a%20human%20being%20can%20only%20keep%20track%20of%20about%207%20%28plus%20or%20minus%202%29%20pieces%20of%20information%20simultaneously%20in%20your%20brain.%20%20Therefore,%20if%20your%20software%20is%20overly%20complex%20with%20multiple%20decision%20paths,%20it%20is%20unlikely%20that%20you%20will%20be%20able%20to%20visualize%20how%20your%20software%20will%20behave%20%28i.e.%20it%20will%20have%20a%20high%20cyclomatic%20complexity%20metric%29.%20This%20would%20most%20likely%20lead%20to%20developing%20erroneous%20or%20bug%20ridden%20software.%20%20More%20information%20about%20this%20can%20be%20found%20here%20and%20also%20on%20Wikipedia.">Wikipedia</a>.

blocks|key|1332577|text|使用控制流图计算圈复杂度。通过程序源代码的线性独立路径的定量度量的数量称为圈复杂度(+if/+if+else+/+for+/+while+)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1332578|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Cyclomatic complexity is computed using the control flow graph. The Number of quantitative measure of linearly independent paths through a program's source code is called as Cyclomatic Complexity ( if/ if else / for / while )

A term that I see every now and then is "Cyclomatic Complexity". Here on SO I saw some Questions about "how to calculate the CC of Language X" or "How do I do Y with the minimum amount of CC", but I'm not sure I really understand what it is.

On the <a href="http://www.ndepend.com/Metrics.aspx#CC" rel="noreferrer">NDepend Website</a>, I saw an explanation that basically says "The number of decisions in a method. Each if, for, &amp;&amp; etc. adds +1 to the CC "score"). Is that really it? If yes, why is this bad? I can see that one might want to keep the number of if-statements fairly low to keep the code easy to understand, but is this really everything to it?

Or is there some deeper concept to it?

What is Cyclomatic Complexity?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我经常看到的一个术语是“圈复杂度”。在这里，我看到了一些关于“如何计算语言X的CC”或“我如何用最少的CC来做Y”的问题，但我不确定我真的理解它是什么。在上，我看到了一个解释，基本上是“一个方法中的决策数量。每个if，for，&&等都会将CC分数加+1”。真的是这样吗?如果是，为什么这么糟糕?我可以看到，为了让代码更容...

问什么是圈复杂度？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是圈复杂度？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是圈复杂度？
EN