精华内容
下载资源
问答
  • 白盒测试--圈复杂度循环测试
    2021-06-07 19:23:41

    基本路径测试法

    步骤: 1.画出程序流程控制图 2.设计程序圈复杂度 3.导出测试用例 4.执行测试用例

    程序环路复杂性
    1.流图中区域数量对应唤醒的复杂性区域数+1
    2.给定流图G的圈复杂度V(G),定义为V(G)=E-N+2,E是流图中边的数量,N的流图中结点的数量

    循环覆盖
    简单循环
    嵌套循环
    串接循环
    不规则循环

    循环用例设计方法
    整个跳过循环
    只有一次通过循环
    两次通过循环
    m次通过循环,其中m<n;
    n-1次通过循环
    n次通过循环

    **简单循环:**其中n是允许通过循环的最大次数
    嵌套循环:
    1.从最内层循环开始,将其他循环设置为最小值
    2.对内层循环使用简单循环,外层循环的迭代参数最小,并为范围外或排除的值增加其他测试
    3.由内向外构造下一个循环的测试,其他循环为最小值
    4.继续直到测试完所有循环

    串接循环
    如果串接循环的循环是彼此独立的,可以使用简单循环测试
    如果第一个循环是第二个循环的初始值,则这两个循环并不是独立的,则推荐使用嵌套循环的方式进行测试

    不规则循环
    不进行测试

    更多相关内容
  • 具有较高圈复杂度的功能需要更多的测试用例才能覆盖所有可能的路径,并且可能更难理解。 通过应用导致较小功能的通用重构技术,可以降低复杂性。 安装 要安装gocyclo命令,请运行 $ go get github.com/fzipp/gocy
  • 圈复杂度及其运用

    2020-12-01 17:01:02
    圈复杂度(Cyclomatic complexity)又称为条件复杂度或循环复杂度,用于衡量要给模块判定结构的复杂程度;数量上表现为独立的现行的路径条数,也可理解为覆盖所有的可能情况的最少使用的测试用例数。 2.圈复杂度的...

    1.圈复杂度的定义

             圈复杂度是由Thomas J. McCabe, Sr. 在1976年提出的概念,用于判断代码复杂度。圈复杂度(Cyclomatic complexity)又称为条件复杂度或循环复杂度,用于衡量要给模块判定结构的复杂程度;数量上表现为独立的现行的路径条数,也可理解为覆盖所有的可能情况的最少使用的测试用例数。

    2.圈复杂度的计算方法        

    圈复杂度的概念计算方法有3种。

            1)控制流程图

            一般来说,软件程序的流程分为三种:顺序、条件和循环。用流程图标识出所有分支,可以表示出所有的圈复杂度。如下如所示:       

             2)节点判定法

             一个比较简单的方法是:圈复杂度就是等于判定节点的数量加上1。在编程语言中国,条件判断if-else, swtich-case、for循环、while循环、三木运算符,都可以作为一个判定节点。(国内一些公司,比如华为等公司,就是这么计算的)

            样例如下:        

    funciton complexityExample(param) {
        if(param > 0) {
            print(0);
        }
        else {
        
            print(1)
        }
    
        return param < -1 :True ? False;
    }
    

           可知,这段程序的圈复杂度为3+1= 4.

          3)点边计算法

         计算方法为C = E - N + 2P,其中, E为控制流图(需要的方法为1)中的边的数量,N为控制流图中的节点数量,P为独立组件的数目。

         可得,E为9, N为6,P为1,可得C为5。

    3.圈复杂度的衡量标准

             一般来说,代码复杂度第,代码不一定好;但代码复杂度高,代码质量一定差。具体衡量标准如下:

    圈复杂度代码状况可测性维护成本
    1 - 10清晰、结构化
    10 - 20复杂
    20 - 30非常复杂
    >30不可读不可测非常高

    4.降低圈复杂度的方法

          降低圈复杂度的方法为重构。但是,重构应该保持原有功能不变,并不断完成。

          降低圈复杂度方法如下;

          1)抽象配置;

          2)单一职责-提炼函数;

          3)合并条件;

          4)提取条件。

          同事,针对圈复杂度过于高的语句部分,可以提出来一个函数。

     

     

     

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

    1.什么是代码圈复杂度?

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

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

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

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

    3.代码圈复杂度的计算方法

    通常使用的计算公式是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节点,只能记做一个。

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

    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)
    }
    

    将这段代码放进一个独立函数中,并让函数名称解释该函数的用途

    void printOwing(double previousAmount)
    {
      printBanner();
      double  outstanding  =  getOutsta nding(previousAmount  *  1.2);
      printDetads(outstanding);
    }
    
    void printBanner0
    {
       // print banner
    .....
    }
    
    double getOutstanding(double initialValue)
    {
      double result = initialValue;
      Enumeration e =  orders.elements();
      while (e.hasMoreElements())
      {
        Order each = (Order) e.nextElement();
         result += each.getAmount();
      }
      return result;
    }
    
    void printDetails (double outstanding)
     {
      //print details
    ...
    }
    

    2.Substitute Algorithm(替换你的算法)

    String foundPerson(String[] people)
    {
      for (int i = 0; i < people.length; i++)
      {
          if (people[i].equals ("Don"))
           return "Don";
          if (people[i].equals ("John"))
           return "John";
          if (people[i].equals ("Kent"))
           return "Kent";
      }
      return "";
    }
    

    将函数本体替换为另一个算法

    String foundPerson(String[] people)
    {
       List candidates = Arrays.asList(new String[]{"Don", "John","Kent"});
       for (int i=0; i<people.length; i++)
          if (candidates.contains(people[i]))
             return people[i];
      return "";
    }
    
    

    3.Decompose Conditional(分解条件式)

    //分解前
    if (date.before (SUMMER_START)  || date.after(SUMMER_END))
      charge = quantity * _winterRate  + winterServiceCharge;
    else
      charge = quantity * _summerRate;
    
    //分解后 你有一个复杂的条件语句,从if、else段落中分别提炼出独立函数
    if (notSummer(date))
      charge = winterCharge(quantity);
    else
      charge = summerCharge (quantity);
    

    4.Consolidate Conditional Expression(合并条件式)

    例子1

    double disabilityAmount()
    {
       if (_seniority < 2) return 0;
       if (_monthsDisabled > 12) return 0;
       if (_isPartTime) return 0;
       // compute the disability amount
    ...
    }
    
    //将这些判断合并为一个条件式,并将这个条件式提炼成为一个独立函数,函数名自注释
    double disabilityAmount()
    {
       if (isNotEligableForDisability()) return 0;
       // compute the disability amount
    ...
    }
    

    5.Consolidate Duplicate Conditional Fragments(合并重复的条件片断)

    //在条件式的每个分支上有着相同的一段代码。
    if (isSpecialDeal()) 
    {
         total = price * 0.95;
         send();
    }
    else
    {
         total = price * 0.98;
         send();
    }
    
    //将这段重复代码搬移到条件式之外,避免用拷贝粘贴的方式写重复代码
    if (isSpecialDeal())
        total = price * 0.95;
    else
        total = price * 0.98;
    send();
    

    6.Remove Control Flag(移除控制标记)

    //当前代码使用标记变量,可读性差,容易出错
    void checkSecurity(String[] people) {
        boolean found = false;
        for (int i = 0; i < people.length; i++) {
            if (! found) {
                if (people[i].equals ("Don")){
                    sendAlert();
                    found = true;
                }
                if (people[i].equals ("John")){
                       sendAlert();
                       found = true;
                }
            }
        }
    }
    
    //以break和return取代标记变量
    void checkSecurity(String[] people) {
        for (int i = 0; i < people.length; i++) {     
            if (people[i].equals ("Don")){
                sendAlert();
                break;
            }
            if (people[i].equals ("John")){
                sendAlert();
                break;
            }
        }
    }
    

    7.Parameterize Method(令函数携带参数)

    //若干函数做了类似的工作,但在函数本体中却包含了不同的值
    Dollars baseCharge()
     {
        double result = Math.min(lastUsage(),100) * 0.03;
        if (lastUsage() > 100) {
            result += (Math.min (lastUsage(),200) - 100) * 0.05;
        };
        if (lastUsage() > 200) {
            result += (lastUsage() - 200) * 0.07;
        };
        return new Dollars (result);
    }
    
    //建立单一函数,以参数表达那些不同的值
    Dollars baseCharge() 
    {
        double result = usageInRange(0, 100) * 0.03;
        result += usageInRange (100,200) * 0.05;
        result += usageInRange (200, Integer.MAX_VALUE) * 0.07;
        return new Dollars (result);
    }
    
    int usageInRange(int start, int end) 
    {
        if (lastUsage() > start) 
            return Math.min(lastUsage(),end) -start;
        else 
            return 0;
    }
    

    8.异常逻辑处理型重构方法

    原则:尽可能地维持正常流程代码在最外层。
    意思是说,可以写if-else语句时一定要尽量保持主干代码是正常流程,避免嵌套过深。
    实现的手段有:减少嵌套、移除临时变量、条件取反判断、合并条件表达式等。

    例子1

    double getPayAmount(){
        double result;
        if(_isDead) {
            result = deadAmount();
        }else{
            if(_isSeparated){
                result = separatedAmount();
            }
            else{
                if(_isRetired){
                    result = retiredAmount();
                else{
                    result = normalPayAmount();
                }
            }
        }
        return result;
    
    //重构后   要求梳理清楚逻辑
    double getPayAmount(){
        if(_isDead) 
            return deadAmount();
     
        if(_isSeparated)
            return separatedAmount();
     
        if(_isRetired)
            return retiredAmount();
     
        return normalPayAmount();
    }
    

    例子2

    public double getAdjustedCapital(){
        double result = 0.0;
        if(_capital > 0.0 ){
            if(_intRate > 0 && _duration >0){
                resutl = (_income / _duration) *ADJ_FACTOR;
            }
        }
        return result;
    }
    
    //第一步处理 减少嵌套和移除临时变量:
    public double getAdjustedCapital(){
        if(_capital <= 0.0 ){
            return 0.0;
        }
        if(_intRate > 0 && _duration >0){
            return (_income / _duration) *ADJ_FACTOR;
        }
        return 0.0;
    }
    
    //根据优化原则(尽可能地维持正常流程代码在最外层),可以再继续重构:
    public double getAdjustedCapital(){
        if(_capital <= 0.0 ){
            return 0.0;
        }
        if(_intRate <= 0 || _duration <= 0){
            return 0.0;
        }
     
        return (_income / _duration) *ADJ_FACTOR;
    }
    
    

    例子3

       /* 查找年龄大于18岁且为男性的学生列表 */
        public ArrayList<Student> getStudents(int uid){
            ArrayList<Student> result = new ArrayList<Student>();
            Student stu = getStudentByUid(uid);
            if (stu != null) {
                Teacher teacher = stu.getTeacher();
                if(teacher != null){
                    ArrayList<Student> students = teacher.getStudents();
                    if(students != null){
                        for(Student student : students){
                            if(student.getAge() > = 18 && student.getGender() == MALE){
                                result.add(student);
                            }
                        }
                    }else {
                        logger.error("获取学生列表失败");
                    }
                }else {
                    logger.error("获取老师信息失败");
                }
            } else {
                logger.error("获取学生信息失败");
            }
            return result;
        }
    

    典型的"箭头型"代码,最大的问题是嵌套过深,解决方法是异常条件先退出,保持主干流程是核心流程:

       /* 查找年龄大于18岁且为男性的学生列表 */
        public ArrayList<Student> getStudents(int uid){
            ArrayList<Student> result = new ArrayList<Student>();
            Student stu = getStudentByUid(uid);
            if (stu == null) {
                logger.error("获取学生信息失败");
                return result;
            }
     
            Teacher teacher = stu.getTeacher();
            if(teacher == null){
                logger.error("获取老师信息失败");
                return result;
            }
     
            ArrayList<Student> students = teacher.getStudents();
            if(students == null){
                logger.error("获取学生列表失败");
                return result;
            }
     
            for(Student student : students){
                if(student.getAge() > 18 && student.getGender() == MALE){
                    result.add(student);
                }
            }
            return result;
        }
    

    9.状态处理型重构方法(1)

    double getPayAmount(){
        Object obj = getObj();
        double money = 0;
        if (obj.getType == 1) {
            ObjectA objA = obj.getObjectA();
            money = objA.getMoney()*obj.getNormalMoneryA();
        }
        else if (obj.getType == 2) {
            ObjectB objB = obj.getObjectB();
            money = objB.getMoney()*obj.getNormalMoneryB()+1000;
        }
    }
    

    重构后

    double getPayAmount(){
        Object obj = getObj();
        if (obj.getType == 1) {
            return getType1Money(obj);
        }
        else if (obj.getType == 2) {
            return getType2Money(obj);
        }
    }
     
    double getType1Money(Object obj){
        ObjectA objA = obj.getObjectA();
        return objA.getMoney()*obj.getNormalMoneryA();
    }
     
    double getType2Money(Object obj){
        ObjectB objB = obj.getObjectB();
        return objB.getMoney()*obj.getNormalMoneryB()+1000;
    }
    

    10.状态处理型重构方法(1)

    针对状态处理的代码,一种优雅的做法是用多态取代条件表达式(《重构》推荐做法)。

    double getSpeed(){
        switch(_type){
            case EUROPEAN:
                return getBaseSpeed();
            case AFRICAN:
                return getBaseSpeed()-getLoadFactor()*_numberOfCoconuts;
            case NORWEGIAN_BLUE:
                return (_isNailed)?0:getBaseSpeed(_voltage);
        }
    }
    

    重构后

    class Bird{
        abstract double getSpeed();
    }
     
    class European extends Bird{
        double getSpeed(){
            return getBaseSpeed();
        }
    }
     
    class African extends Bird{
        double getSpeed(){
            return getBaseSpeed()-getLoadFactor()*_numberOfCoconuts;
        }
    }
     
    class NorwegianBlue extends Bird{
        double getSpeed(){
            return (_isNailed)?0:getBaseSpeed(_voltage);
        }
    }
    

    11.case语句重构方法(1)

    https://www.cnblogs.com/wahaha02/p/7435603.html

    展开全文
  • 简单圈复杂度计算

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

    Cyclomatic Complexity

    1. 概念

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

      b. 圈复杂度高的害处:

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

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

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

      c. 圈复杂度的表现:

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

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

     

    2. 圈复杂度的计算方法

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

      e : 控制流图中边的数量

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

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

     

    3. 圈复杂度计算实例

    复制代码

    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) = 19 + 2 - 13 = 8; 

    (2)   数路径:8条

     

    4. 减小圈复杂度的方法

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

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

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

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

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

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

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

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

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

    https://www.cnblogs.com/techroad4ca/archive/2015/12/02/5012406.html

     

    简单计算方法:

    count = 1

    for +1

    if + 0

    if else +1

    else +1

    switch case + default - 1

    while +1

    展开全文
  • 一个pybuilder插件,使用radon检查项目的圈复杂度。 有关radon的更多信息,请参考。 要将这个插件添加到您的pybuilder项目中,请在build.py顶部添加以下行: use_plugin ( 'pypi:pybuilder_radon' , '~=0.1.0' ) ...
  • 详解圈复杂度

    2021-03-09 08:43:33
    详解圈复杂度圈复杂度概念圈复杂度(Cyclomatic complexity,简写CC)也称为条件复杂度,是一种代码复杂度的衡量标准。由托马斯·J·麦凯布(Thomas J. McCabe, Sr.)于1976年提出,用来表示程序的复杂度,其符号为VG...
  • 软件度量-圈复杂度

    2021-05-21 08:01:49
    概念循环复杂度 Cyclomatic complexity也称为条件复杂度或圈复杂度,是一种软件度量,是由老托马斯·J·麦凯布在1976年提出,用来表示程序的复杂度圈复杂度计算公式M = E − N + 2P其中E 为图中边的个数N 为图中节点...
  • 圈复杂度及降低示例

    2021-08-06 09:01:58
    圈复杂度 (Cyclomatic complexity) 是一种代码复杂度的衡量标准,也称为条件复杂度或循环复杂度,它可以用来衡量一个模块判定结构的复杂程度,数量上表现为独立现行路径条数,也可理解为覆盖所有的可能情况最少使用...
  • Cyclomatic Complexity1. 概念a. 圈复杂度是一种衡量代码复杂程度的标准。... 圈复杂度的表现:代码中分支循环语句多(if/else, switch/case, for, while),圈复杂度与分支循环语句个数正相关;表达式复...
  • Java圈复杂度

    千次阅读 2021-02-03 18:03:50
    Java圈复杂度一、圈复杂度概念1、圈复杂度计算规则2、idea圈复杂度插件 MetricsReload圈复杂度优化1、优化表达式2、提炼函数3、简化代码[合并条件式、使用更简洁的表达]4、减少认知复杂度5、工具类替换逻辑判断 ...
  • 什么是圈复杂度?———————————————————————————————————————圈复杂度(Cyclomatic Complexity)是衡量计算机程序复杂程度的一种措施。它根据程序从开始到结束的线性独立路径的...
  • 软件复杂度和圈复杂度

    千次阅读 2018-12-24 15:30:19
    软件复杂度和圈复杂度 软件复杂度 1,起源与应用 成立于1976的McCabe &amp;amp; Associates公司开发出了McCabe Cyclomatic Complexity Metric(McCabe圈复杂度)技术对软件进行结构测试。 McCabe复杂度是...
  • 每位开发人员对代码质量的含义都有着自己...什么?关于这篇文章和代码质量主题的任何其他文章的问题,请访问由 Andrew Glover 主持的Improve your Java Code Quality讨论论坛。代码味道通常由开发人员直接判定,有...
  • 代码圈复杂度

    千次阅读 2020-02-24 19:24:22
    圈复杂度 (Cyclomatic complexity) 是一种代码复杂度的衡量标准,也称为条件复杂度或循环复杂度,它可以用来衡量一个模块判定结构的复杂程度,数量上表现为独立现行路径条数,也可理解为覆盖所有的可能情况最少使用...
  • 软件度量之圈复杂度

    2021-03-07 00:45:26
    在软件测试的概念里,圈复杂度“用来衡量一个模块判定结构的复杂程度,数量上表现为独立现行路径条数,即合理的预防错误所需测试的最少路径条数,圈复杂度大说明程序代码可能质量低且难于测试和维护,根据经验,程序...
  • 文章目录前言其他类型的规范圈复杂度提炼方法if、else卫语句去else策略模式switch循环嵌套其他建议 前言 做Java开发的,大多数可能都有看过阿里的Java后台开发手册,里面有关于Java后台开发规范的一些内容,基本覆盖...
  • [Java教程]圈复杂度

    2021-02-28 17:09:45
    [Java教程]圈复杂度0 2015-12-02 13:00:42Cyclomatic Complexity1. 概念a. 圈复杂度是一种衡量代码复杂程度的标准。b. 圈复杂度高的害处:圈复杂度大说明... 圈复杂度的表现:代码中分支循环语句多(if/else, switch...
  • 声纳给我下面的复杂度数:22。对于以下程序:private static SomeDto checkSomething(AnotherDto anotherDto, String reference){SomeDto someDto = new SomeDto();// condition 1if (!someDto.getA())return new ...
  • 我想减少开关盒的圈复杂度我的代码是:public String getCalenderName() {switch (type) {case COUNTRY:return country == null ? name : country.getName() + HOLIDAY_CALENDAR;case CCP:return ccp == null ? name...
  • 程序复杂度之圈复杂度

    千次阅读 2015-12-30 14:55:42
    圈复杂度(Cyclomatic complexity)也称为条件复杂度或循环复杂度,是一种软件度量,是由Thomas J. McCabe, Sr. 在 1976 年提出,用来表示程序的复杂度,其符号为 VG 或是 M。圈复杂度是对源代码中线性独立路径数的...
  • ev(G) 基本复杂度是用来衡量程序非结构化程度的,非结构成分降低了程序的质量,增加了代码的维护难度,使程序难于理解。因此,基本复杂度高意味着非结构化程度高,难以模块化和维护。实际上,消除了一个错误有时会...
  • R代码的圈复杂度 循环复杂度是一种软件度量标准(度量),用于指示程序的复杂性。 它是对程序源代码中线性独立路径数量的定量度量。 它是由托马斯·J·麦卡比(Thomas J. 安装 devtools :: install_github( " ...
  • 降低函数的复杂度是提供软件质量的一个重要手段。一般情况下有9种技术可直接降低函数的圈复杂度。他们是提炼函数,替换...在降低函数圈复杂度的所有方法中,我们推荐依靠类函数重载多态机制降低函数圈复杂度的方法。
  • 静态分析是一种检查代码的方法,无需执行程序。...圈复杂度与分支语句、循环语句的个数,以及判定复合条件的逻辑组合符成正相关。 圈复杂度计算公式: 其中:V(G)表示圈复杂度; e表示控制流图中边的数量;
  • McCabe环路复杂度(圈复杂度)

    千次阅读 2020-03-30 14:37:16
    红色为一块区域,橘黄色为一块区域,蓝色为一块区域,绿色为一块区域所以复杂度为4 图中黑色区域因为是自环弧线所以要忽略掉(自己指向自己并且没有之后的流程 ps.自己这么理解,如果有错希望路过的朋友指正) ...
  • 值得注意的是,圈复杂度始于计数周期,但最终是为了实际目的而计算条件. 进一步阅读 维基百科有一篇很好的文章依赖于论文,但我发现它没有遵循BASIC BLOCKS和CONNECTED COMPONENTS: 第8章中的“软件工程集成方法”一...
  • 圈复杂度(Cyclomatic complexity, CC) 简介 圈复杂度(Cyclomatic complexity,简写CC)也称为条件复杂度,是一种代码复杂度的衡量标准。在很多公司内上线代码的话,需要衡量这一项指标,所以在这里简单记录一下。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,893
精华内容 7,557
关键字:

循环的圈复杂度