精华内容
下载资源
问答
  • 什么是代码圈复杂度圈复杂度(Cyclomatic Complexity)是一种代码复杂度的衡量标准,由 Thomas McCabe 于 1976年定义。它可以用来衡量一个模块判定结构的复杂程度,数量上表现为独立现行路径条数,也可理解为覆盖...

    什么是代码圈复杂度?

    圈复杂度(Cyclomatic Complexity)是一种代码复杂度的衡量标准,由 Thomas McCabe 于 1976年定义。它可以用来衡量一个模块判定结构的复杂程度,数量上表现为独立现行路径条数,也可理解为覆盖所有的可能情况最少使用的测试用例数。圈复杂度大说明程序代码的判断逻辑复杂,可能质量低且难于测试和维护。程序的可能错误和高的圈复杂度有着很大关系。

    圈复杂度主要与分支语句(if、else、,switch 等)的个数成正相关。可以在图1中看到常用到的几种语句的控制流图(表示程序执行流程的有向图)。当一段代码中含有较多的分支语句,其逻辑复杂程度就会增加。在计算圈复杂度时,可以通过程序控制流图方便的计算出来。

    代码圈复杂度的计算方法

    通常使用的计算公式是V(G) = e – n + 2 , e 代表在控制流图中的边的数量(对应代码中顺序结构的部分),n 代表在控制流图中的节点数量,包括起点和终点(1、所有终点只计算一次,即便有多个return或者throw;2、节点对应代码中的分支语句)。

    增加圈复杂度的语句:在代码中的表现形式:在一段代码中含有很多的 if / else 语句或者其他的判定语句(if / else , switch / case , for , while , | | , ? , …)。

     

    代码示例-控制流图

    根据公式 V(G) = e – n + 2 = 12 – 8 + 2 = 6 ,上图的圈复杂段为6。

    说明一下为什么n = 8,虽然图上的真正节点有12个,但是其中有5个节点为throw、return,这样的节点为end节点,只能记做一个。

     

    采用圈复杂度去衡量代码的好处

    1.指出极复杂模块或方法,这样的模块或方法也许可以进一步细化。
    2.限制程序逻辑过长。
    
    McCabe&Associates 公司建议尽可能使 V(G) <= 10。NIST(国家标准技术研究所)认为在一些特定情形下,模块圈复杂度上限放宽到 15 会比较合适。
    
    因此圈复杂度 V(G)与代码质量的关系如下: 
    V(G) ∈ [ 0 , 10 ]:代码质量不错; 
    V(G) ∈ [ 11 , 15 ]:可能存在需要拆分的代码,应当尽可能想措施重构; 
    V(G) ∈ [ 16 , ∞ ):必须进行重构;
    3.方便做测试计划,确定测试重点。
    
    许多研究指出一模块及方法的圈复杂度和其中的缺陷个数有相关性,许多这类研究发现圈复杂度和模块或者方法的缺陷个数有正相关的关系:圈复杂度最高的模块及方法,其中的缺陷个数也最多,做测试时做重点测试。


    可以降低圈复杂度的重构技术

    1.Extract Method(提炼函数)

    代码段可被组织在一起并独立出来
    
    void printOwing(double previousAmount)
    {
      Enumeration e = _orders.elements();
      double outstanding = previousAmount * 1.2;
    
      // print banner
      System.out.println ("* * * * * * * * * * * * * * * * * * * * * * *");
      System.out.println ("Customer Owes ");
      System.out.println (" * * * * * * * * * * * * * * * * * * * * * * *");
    
      // calculate outstanding
      while (e.hasMoreElements())
      {
        Order each = (Order) e.nextElement();
        outstanding += each.getAmount();
      }
    
      //print details
      System.out.println ("name:" +_name);
      System.out.println ("amount" + outstanding)
    }

     

    展开全文
  • 圈复杂度metrics

    2018-02-25 18:55:02
    圈复杂度metrics,
  • 圈复杂度PPT

    2015-02-03 00:39:44
    详细介绍了代码的圈复杂度,常见的圈复杂度侧脸方法,及9中常规降低圈复杂度的方法。
  • 圈复杂度

    2017-10-24 14:05:00
     圈复杂度大说明代码的判断逻辑复杂,可能质量低;  需要的更多的测试用例,难于测试和维护;  程序的可能错误和高的圈复杂度有着很大关系。  c. 圈复杂度的表现:  代码中分支循环语句多(if/else, switch/...

    Cyclomatic Complexity

    1. 概念

      a. 圈复杂度是一种衡量代码复杂程度的标准。

      b. 圈复杂度高的害处:

        圈复杂度大说明代码的判断逻辑复杂,可能质量低;

        需要的更多的测试用例,难于测试和维护;

        程序的可能错误和高的圈复杂度有着很大关系。

      c. 圈复杂度的表现:

        代码中分支循环语句多(if/else, switch/case, for, while),圈复杂度与分支循环语句个数正相关;

        表达式复杂(含有三元运算符 )。

    1. 圈复杂度的计算方法

    (1)圈复杂度可以通过程序控制流图计算,公式为:V(G) = e + 2 - n

      e : 控制流图中边的数量

      n : 控制流图中节点的数量(包括起点和终点;所有终点只计算一次,多个return和throw算作一个节点)

    (2)圈复杂度对应程序控制流图中从起点到所有终点的路径的条数,所以页可以通过数路径的方式获得圈复杂度。

    1. 圈复杂度计算实例

    复制代码
    private int CalculateScore(int culture, String nation, boolean extend) {
    int result = 0;
    if (culture < 0) {
    throw new RuntimeException("分数不能小于0");
    } else if (culture < 200) {
    return culture;
    } else {
    switch (nation){
    case "汉":
    result = 0;
    break;
    case "蒙":
    case "回":
    case "维":
    case "藏":
    result = 10;
    break;
    default:
    result = 20;
    }
    }

        if (extend) {
            result += 10; 
        }
        return result + culture;
        
    }

    复制代码
    程序控制流图:

    (1) V(G) = 21 + 2 - 13 = 8;

    (2) 数路径:8条

    1. 减小圈复杂度的方法

    a. 提取函数 - 将独立业务或模块代码独立出来,封装为函数,通过函数名诠释代码作用,做到见名知意。

    b. 替换算法 - 复杂算法会导致bug可能性的增加及可理解性/可维护性的降低,如果函数对性能要求不高,提倡使用简单明了的算法。

    c. 分解条件式 - 复杂的条件表达式,使用函数进行封装

    d. 合并条件式 - 将一系列得到相同结果的条件表达式合并,可以的话封装为函数

    e. 合并重复的条件片段 - 不同条件的分支,有相同的处理,可以提炼出分支以外,或者封装为函数

    f. 移除控制标记 - 使用控制标签作为条件的,使用break 和 return取代

    g. 将查询函数和修改函数分离 - 单一职责原则,强调函数的复用性而不是多用性

    h. 函数携带参数 - 使用带参函数,强调函数的复用性

    i. 以明确函数取代参数 - 强调函数的功能的明确性

    转自http://www.cnblogs.com/techroad4ca/archive/2015/12/02/5012406.html

    转载于:https://www.cnblogs.com/szqmvp/p/7723215.html

    展开全文
  • Java圈复杂度

    2021-02-03 18:03:50
    Java圈复杂度一、圈复杂度概念1、圈复杂度计算规则2、idea圈复杂度插件 MetricsReload圈复杂度优化1、优化表达式2、提炼函数3、简化代码[合并条件式、使用更简洁的表达]4、减少认知复杂度5、工具类替换逻辑判断 ...

    一、圈复杂度概念

    圈复杂度(Cyclomatic complexity)是一种代码复杂度的衡量标准,是一种固定的数据模型计算方式。
    圈复杂度用来衡量一个模块判定结构的复杂程度,数量上表现为线性无关路径条数,即覆盖所有的可能情况
    最少使用的测试用例数。圈复杂度大说明程序代码的判断逻辑复杂,可能质量低且难以测试和维护。
    

    1、圈复杂度计算规则

    在计算圈复杂度时,可以通过程序控制流图方便的计算出来。 通常使用的计算公式是V(G) = e – n + 2 ,
     e 代表在控制流图中的边的数量(对应代码中顺序结构的部分),n 代表在控制流图中的节点数量,包括起点
     和终点(1、所有终点只计算一次,即便有多个return或者throw;2、节点对应代码中的分支语句)。
    
    • && 、|| 条件判断符号 +1
    • if、elseif、else、switch 分支语句 +1
    • for、while、do while 循环语句 +1
    • catch捕获异常语句 +1
    • break、continue 终端语句 +1
    • 如果if、for、while、do while、catch 存在嵌套时,里层的语句相对外层 +1

    2、idea圈复杂度插件 MetricsReload

    在这里插入图片描述

    圈复杂度优化

    1、优化表达式

    针对if、else判断的处理,如果之后没有处理,则在if中直接返回,else无需使用
    

    代码示例:
    源程序:

    public String testCase(String number){
        String str = null;
        if(StringUtils.isEmpty){
            return null;
        }else{
            str = Integer.valueOf(number);
        }
        return str;
    }
    

    重构后:

    public String testCase(String number){
        String str = null;
        if(!StringUtils.isEmpty){
            str = Integer.valueOf(number);
        }
        return str;
    }
    

    2、提炼函数

    将可以组织独立起来的代码放进一个独立函数中,并使用可以解释函数用法的函数名。
    如果开发工具是idea,可以使用 Ctrl+ALT+M快捷键直接抽取方法。
    

    代码示例:
    源程序:

    void printItem(Long itemId){   
          // 打印大标题
        System.out.println ("**************************");
        System.out.println ("********** item **********");
        System.out.println ("**************************");
    
        Item item = null;
        // 查询商品信息
        if (null == itemId){
            return;
        }
        item = itemService.searchItemById(itemId);
        //打印详情
        System.out.println ("code:" + item.code);
        System.out.println ("name:" + item.name);
        System.out.println ("price" + item.price);
    }
    

    重构后:

    void printItem(Long itemId){   
        // 打印大标题
    	printTitle();
    
        Item item = null;
        // 查询商品信息
        if (null == itemId){
            return;
        }
        item = itemService.searchItemById(itemId);
        //打印详情
    	printItemDetail(item);
    }
    
    void printTitle(){
        System.out.println ("**************************");
        System.out.println ("********** item **********");
        System.out.println ("**************************");  
    }
    
    void printItemDetail(Item item){
        System.out.println ("code:" + item.code);
        System.out.println ("name:" + item.name);
        System.out.println ("price" + item.price);
    }
    

    3、简化代码[合并条件式、使用更简洁的表达]

    将当前算法重构成更简洁清晰的算法
    

    代码示例:
    源程序:

     public String foundNumber(String[] numbers){
         for (int i = 0; i < numbers.length; i++) {
             if ("One".equals(numbers[i])){
                 return "One";
             }else if("Two".equals(numbers[i])){
                 return "Two";
             }else if("Three".equals(numbers[i])){
                 return "Three";
             }
         }
         return null;
    }
    

    重构后:

    public String newFundNumber(String[] numbers){
        List<String> numberList = Arrays.asList("One", "Two", "Three");
        for (String number : numbers) {
            if (numberList.contains(number)) {
                return number;
            }
        }
        return null;
    }
    

    4、减少认知复杂度

    如果大量使用if-else语句可以考虑用switch代替;考虑使用return和break替换标记变量,提高可读性。
    

    5、工具类替换逻辑判断

    使用已有的工具类判断。判空等操作可以使用工具类,减少&&和||的判断使用
    
    展开全文
  • 根据sonar分析结果,获取圈复杂度和方法来计算最大平均圈复杂度
  • 软件复杂度和圈复杂度

    千次阅读 2018-12-24 15:30:19
    软件复杂度和圈复杂度 软件复杂度 1,起源与应用 成立于1976的McCabe &amp;amp; Associates公司开发出了McCabe Cyclomatic Complexity Metric(McCabe圈复杂度)技术对软件进行结构测试。 McCabe复杂度是...

    作者:翁松秀


    软件复杂度和圈复杂度

    软件复杂度

    1,起源与应用

    • 成立于1976的McCabe & Associates公司开发出了McCabe Cyclomatic Complexity Metric(McCabe圈复杂度)技术对软件进行结构测试
    • McCabe复杂度是对软件结构进行严格的算术分析得来的,实质上是对程序拓扑结构复杂性的度量,明确指出了任务复杂部分。
    • McCabe复杂度能帮助工程师识别难以测试和维护的模块,已经成为评估软件质量的一个重要标准。
    • McCabe复杂度可以为软件开发过程中平衡成本、进度和性能提供指导

    2,McCabe复杂度分类
    在这里插入图片描述

    (1)圈复杂度(Cyclomatic Complexity (v(G)) )
    概念: 圈复杂度用来衡量一个模块的复杂程度
    计算方法: 一个模块控制流图有e条边,n个节点,它的圈复杂度v(G) = e - n + 2。
    在这里插入图片描述

    (2)基本复杂度(Essential Complexity (ev(G)) )
    概念: 基本复杂度用来衡量程序非结构化程度
    计算方法: 将模块控制流图中的结构化部分简化成节点,计算简化后控制流图的圈复杂度就是基本复杂度。

    (3)模块设计复杂度(Module Design Complexity (iv(G)) )
    概念: 模块设计复杂度用来衡量模块之间的调用关系,复杂度越高,模块之间耦合性越高,越难隔离,维护和复用。
    计算方法: 从模块控制流图中移去那些不包含调用子模块的判定循环结构后得到的圈复杂度。模块设计复杂度通常远小于圈复杂度。

    (4)设计复杂度(Design Complexity (S0) )
    概念: 用来衡量程序模块之间的相互作用关系。
    计算方法: 程序中所有模块设计复杂度之和。
    在这里插入图片描述

    (5)集成复杂度(Integration Complexity (S1) )
    概念: 集成测试的数量表示,也是程序中独立线性子树的数目。
    计算方法: S1=S0-N+1, N是程序中模块的数目。

    (6)行数(Number of Lines (nl) )
    概念: 模块中总的代码行数,包括注释。

    (7)规范化复杂度(Normalized Complexity (nv) )
    概念: 规范化复杂度是圈复杂度和行数的比。
    计算方法: nv=v(G)/nl

    (8)全局数据复杂度

    (9)局部数据复杂度

    (10)病态数据复杂度

    圈复杂度

    概念: 衡量一个模块的复杂程度,数量上表现为独立路径的条数,也就是合理预防错误所需测试的最少路径条数。圈复杂度以软件的控制流图为基础。经验表明,程序的可能错误和高的圈复杂度有很大的关系,McCabe & Associates建议圈复杂度到10。过于复杂的模块容易出错,难于理解、测试、更正,所以应当在软件开发的各个阶段有意识地限制复杂度。
    计算方法一: 一个模块控制流图有e条边,n个节点,它的圈复杂度v(G) = e - n + 2。
    在这里插入图片描述
    计算方法二: v(G)=判定节点数+1。对于多分支的CASE结构IF-ELSEIF-ELSE结构,要求必须统计全部实际的判定节点数,也即每个ELSEIF语句,以及每个CASE语句,都应该算为一个判定节点。
    在这里插入图片描述
    计算方法三: v(G)=R。其中,R代表平面被控制流图划分成的区域数。
    在这里插入图片描述

    方法总结:

    • 针对程序的控制流图计算圈复杂度V(G)时,最好还是采用公式v(G)=e-n+2;
    • 针对模块的控制流图时,可以直接统计判定节点数,这样更为简单;
    • 针对复杂的控制流图时,使用区域计算公式v(G)=R更为简单。
    展开全文
  • 圈复杂度 圈复杂度(Cyclomatic Complexity)是一种代码复杂度的衡量标准。它可以用来衡量一个模块判定结构的复杂程度,数量上表现为独立现行路径条数,也可理解为覆盖所有的可能情况最少使用的测试用例数。圈复杂度大...
  • 圈复杂度计算

    千次阅读 2019-11-06 17:15:12
    计算公式1:V(G)=e-n+2p。其中, e表示控制流图中边的数量, n表示控制流图中节点的数量, p图的连接组件数目(图的组件数是相连节点的...所以圈复杂度实际上就是等于判定节点的数量再加上1,也即控制流图的区域数...
  • 程序复杂度之圈复杂度

    千次阅读 2015-12-30 14:55:42
    圈复杂度(Cyclomatic complexity)也称为条件复杂度或循环复杂度,是一种软件度量,是由Thomas J. McCabe, Sr. 在 1976 年提出,用来表示程序的复杂度,其符号为 VG 或是 M。圈复杂度是对源代码中线性独立路径数的...
  • 圈复杂度的计算

    2021-07-23 09:34:54
    什么是圈复杂度? 代表程序的复杂程度,if else嵌套判断多少,逻辑要走的路径多少 圈复杂度的计算 圈复杂度=判定条件+1 注意 不增加圈复杂度的关键字 else try finally 圈复杂度的解决 采用提取方法方式...
  • 代码圈复杂度

    千次阅读 2020-02-24 19:24:22
    圈复杂度 (Cyclomatic complexity) 是一种代码复杂度的衡量标准,也称为条件复杂度或循环复杂度,它可以用来衡量一个模块判定结构的复杂程度,数量上表现为独立现行路径条数,也可理解为覆盖所有的可能情况最少使用...
  • 【书名】:软件架构——Python语言实现【主题】:圈复杂度【摘要】:圈复杂度(Cyclomatic Complexity)是衡量计算机程序复杂程度的一种措施。它根据程序从开始到结束的线性独立路径的数量计算得来的。在 Python 中...
  • 圈复杂度讨论

    2021-07-01 20:04:12
    定义 一个方法从头走到结束会经过多少种路径。 如下图,该程序的圈复杂度为6。 由定义可以看出,圈复杂度与程序中if-else语句、switch语句的case数量、while语句的循环次数有直接关系。
  • 圈复杂度及其运用

    2020-12-01 17:01:02
    1.圈复杂度的定义 圈复杂度是由Thomas J. McCabe, Sr. 在1976年提出的概念,用于判断代码复杂度。圈复杂度(Cyclomatic complexity)又称为条件复杂度或循环复杂度,用于衡量要给模块判定结构的复杂程度;数量上...
  • I'm working on a class which sends a RequestDTO to a Web Service. I need to validate the request before it is sent.The request can be sent from 3 different places and there are different validation ru...
  • while working with java i was stuck in a weird situation, lets start with code first.public static String constructMessage(final String reason, final String xId,final String yId, final IonStruct metad...
  • 简单圈复杂度计算

    2019-12-23 00:07:54
     圈复杂度大说明代码的判断逻辑复杂,可能质量低;  需要的更多的测试用例,难于测试和维护;  程序的可能错误和高的圈复杂度有着很大关系。  c. 圈复杂度的表现:  代码中分支循环语句多(if/else, switch...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,754
精华内容 17,101
关键字:

圈复杂度12