如何提升代码质量,重构并非“万能药”

随着编程技术的不断进步,编程语言变得越来越高级,功能封装也越来越完善。各种技术都在帮助程序员提高编写代码的效率。通过层层封装,程序员似乎不需要了解技术细节,只需逐行翻译需求内容即可。
许多程序员不了解如何组织代码、提升运行效率以及底层基于的原理是什么,但是他们编写的代码通过了编译、测试,并且在上线运行了一个月而没有出现问题,似乎并没有对他们的实际工作产生明显的负面影响。
尽管有“菜鸟”表达了对代码质量潜在问题的担忧,但这些担忧通常会被用“目前项目进展紧迫,等几个月后项目进度宽松后再进行代码重构”这样的说辞来安抚。
虽然我们不能否认,在某些(极其有限的)场景下,重构是解决问题的一种方法。但是,写了大量代码后,我们会发现,重构往往是程序开发过程中最复杂的任务之一。如果我们花了一个月的时间写了一堆糟糕的代码,那么要重构它可能需要更长的时间,也可能面临更高的风险。
过去我们经历了几次无法忍受的大规模重构。每一次重构之前,我们都会集合组内的专家,进行多次分析会议,暂停组内的需求,然后才开始重构。然而,在重构过程中,我们经常会遇到各种困难,几乎每天都会出现许多意想不到的问题。而且,上线时也几乎一定会出现一些问题。
在进行复杂代码重构时,从技术角度来看,需要执行三项任务:理解原有代码、将原有代码分解、构建新代码。然而,待重构的原有代码通常难以理解;模块之间过度耦合,一举一动可能影响整个系统,难以控制影响范围;原有代码不容易进行测试,无法确保新代码的正确性。
重构后会使效率提升多少?风险会降低多少?这个问题很难回答,因为低质量的代码本身并不能简单地标准化。

与写出质量差的代码不同的是,想写出好代码有很多前提:

✔ 理解要开发的功能需求。

✔ 了解程序的运行原理。

✔ 做出合理的抽象。

✔ 组织复杂的逻辑。

✔ 对自己开发效率的正确估算。

✔ 持续不断的练习。

因此随着技术的进步,终究能否实现快速交付和保证代码质量二者的世纪大和解?

以SoFlu软件机器人近日推出的专注AI生成Java函数的FuncGPT(慧函数)为代表的AI代码生成工具的出现,或许带来了新的希望。

作为飞算SoFlu软件机器人的一个重要组成部分,FuncGPT(慧函数)支持所有类型函数创建。通过自然语言描述Java函数需求,实时生成高质量、高可读性的Java函数代码。生成代码可直接复制到IDEA,或一键导入Java全自动开发工具函数库。同时FuncGPT(慧函数)采用代码编写最佳实践及大规模机器联合训练的方式,致力于通过AIGF(AI-Generated Function)赋能软件开发,为中国软件开发者提供全栈式全流程软件开发的最佳体验,让程序员告别996!

FuncGPT(慧函数)具备以下五大能力:

● 自然语言:通过自然语言即可生成函数,降低软件开发门槛。

● 秒级函数开发:全自动秒级开发函数,秒级完成,效率千倍提升。

● 一站式函数开发应用:函数生成即可直接应用,效率、安全有保障。

● 质量可靠:生成的函数代码符合业界规范、具备良好的可读性,符合最优解。

● 灵活生成:可以根据开发人员的具体需求生成并支持调整和修改。

FuncGPT(慧函数)的代码质量如何?我们以一个Java函数实现BigDecimal的表达式运算需求为例,让FuncGPT与代码屎山一决高下。

代码屎山示例

@MethodDesc(desc="BigDecimal按公式运算,结果四舍五入取N位小数",params= {
            @ParamDesc(name="scaleLen",desc="结果小数位"),
            @ParamDesc(name="middleScaleLen",desc="中间运算除法小数位(传0默认为6位)"),
            @ParamDesc(name="formualText",desc="计算公式(如:A+B/C),如果出现负数请用下划线代替(例:A+B*-1写成A+B*_1"),
            @ParamDesc(name="varArr",desc="变量名和变量值列表(如:A:90,B:89)"),
    })
    public static BigDecimal bigDecimalFormualCalc(int scaleLen, int middleScaleLen, String formualText, Map varArr) {
        int iMiddleScaleLen=6;
        if(middleScaleLen>0){
            iMiddleScaleLen=middleScaleLen;
        }
        Set keySet = varArr.keySet();
        for (String key : keySet) {
            varArr.put(key, varArr.get(key).toString().replace("-", "_"));
        }

        BigDecimal result=null;
        String formualTextStr=formualText;
        String sFormual="";
        String valueTemp="";
        int iLeftBracketIndex=formualTextStr.lastIndexOf(LEFT);
        int iRightBracketIndex=0;
        if(iLeftBracketIndex>=0){
            while (iLeftBracketIndex>=0){
                iRightBracketIndex=formualTextStr.indexOf(RIGHT,iLeftBracketIndex);
                sFormual=formualTextStr.substring(iLeftBracketIndex,iRightBracketIndex+1);
                sFormual=sFormual.replace(LEFT, REPLACEMENT);
                sFormual=sFormual.replace(RIGHT,REPLACEMENT);
                result= FloatUtils.oneBigDecimalFormualCalc(middleScaleLen,iMiddleScaleLen,sFormual,varArr);
                valueTemp=result.toString().replace("-","_");
                formualTextStr=formualTextStr.replace(LEFT.concat(sFormual).concat(RIGHT),valueTemp);
                iLeftBracketIndex=formualTextStr.lastIndexOf(LEFT);
            }
        }

        result=FloatUtils.oneBigDecimalFormualCalc(scaleLen,iMiddleScaleLen,formualTextStr,varArr);
        return  result;
    }
	
	
	public class FloatUtils {
    private FloatUtils(){}
    public static BigDecimal oneBigDecimalFormualCalc(int scaleLen, int middleScaleLen,
                                                      String oneFormualText, Map varArr) {

        BigDecimal result=null;
        String formualTextStr=oneFormualText;
        String linkStr="";

        Set keySet = varArr.keySet();
        for (String key : keySet) {
            formualTextStr = formualTextStr.replace(key, varArr.get(key).toString());
        }
        char c ;
        List chars = new ArrayList<>();
        List valueList = new ArrayList<>();
        String oneValue="";
        chars.add('+');
        chars.add('-');
        chars.add('*');
        chars.add('/');
        boolean isFindedLink=false;
        while (formualTextStr.length()>0) {
            isFindedLink=false;
            for (int i = 0; i < formualTextStr.length(); i++) {
                c = formualTextStr.charAt(i);
                if (chars.contains(c)) {
                    linkStr = linkStr.concat(String.valueOf(c));
                    oneValue = formualTextStr.substring(0, i);
                    oneValue=oneValue.replace("_","-");
                    formualTextStr = formualTextStr.substring(i+1, formualTextStr.length());
                    valueList.add(oneValue);
                    isFindedLink=true;
                    break;
                }
            }
            if(!isFindedLink){
                formualTextStr=formualTextStr.replace("_","-");
                valueList.add(formualTextStr);
                formualTextStr="";
            }
        }
        BigDecimal[] valueArr=new BigDecimal[valueList.size()];
        for(int i=0;i0){
            iMiddleScaleLen=middleScaleLen;
        }
        ArrayList valueList=new ArrayList();
        ArrayList linkList=new ArrayList();
        for (int i=0;i0){
            multiplyDivideIndex=-1;
            for (int i=0;i

FuncGPT(慧函数)

// 类名:BigDecimalCalculator
// 函数名:calculateExpression
// 函数功能:使用BigDecimal计算表达式的结果
// POM依赖包:
// 
//     org.apache.commons
//     commons-lang3
//     3.12.0
// 

import org.apache.commons.lang3.StringUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Stack;

public class BigDecimalCalculator {
    /**
     * 使用BigDecimal计算表达式的结果
     * @param expression 要计算的表达式
     * @return 计算结果
     */
    public static BigDecimal calculateExpression(String expression) {
        if (StringUtils.isBlank(expression)) {
            throw new IllegalArgumentException("Expression cannot be blank");
        }

        Stack numberStack = new Stack<>();
        Stack operatorStack = new Stack<>();

        for (int i = 0; i < expression.length(); i++) {
            char ch = expression.charAt(i);
            if (Character.isDigit(ch)) {
                StringBuilder sb = new StringBuilder();
                while (i < expression.length() && (Character.isDigit(expression.charAt(i)) || expression.charAt(i) == '.')) {
                    sb.append(expression.charAt(i));
                    i++;
                }
                i--;

                BigDecimal number = new BigDecimal(sb.toString());
                numberStack.push(number);
            } else if (ch == '(') {
                operatorStack.push(ch);
            } else if (ch == ')') {
                while (!operatorStack.isEmpty() && operatorStack.peek() != '(') {
                    BigDecimal result = performOperation(numberStack, operatorStack);
                    numberStack.push(result);
                }
                if (!operatorStack.isEmpty() && operatorStack.peek() == '(') {
                    operatorStack.pop();
                }
            } else if (isOperator(ch)) {
                while (!operatorStack.isEmpty() && hasHigherPrecedence(ch, operatorStack.peek())) {
                    BigDecimal result = performOperation(numberStack, operatorStack);
                    numberStack.push(result);
                }
                operatorStack.push(ch);
            }
        }

        while (!operatorStack.isEmpty()) {
            BigDecimal result = performOperation(numberStack, operatorStack);
            numberStack.push(result);
        }

        return numberStack.pop();
    }

    private static boolean isOperator(char ch) {
        return ch == '+' || ch == '-' || ch == '*' || ch == '/';
    }

    private static boolean hasHigherPrecedence(char op1, char op2) {
        if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-')) {
            return true;
        }
        return false;
    }

    private static BigDecimal performOperation(Stack numberStack, Stack operatorStack) {
        BigDecimal num2 = numberStack.pop();
        BigDecimal num1 = numberStack.pop();
        char operator = operatorStack.pop();

        BigDecimal result;
        switch (operator) {
            case '+':
                result = num1.add(num2);
                break;
            case '-':
                result = num1.subtract(num2);
                break;
            case '*':
                result = num1.multiply(num2);
                break;
            case '/':
                result = num1.divide(num2, 2, RoundingMode.HALF_UP);
                break;
            default:
                throw new IllegalArgumentException("Invalid operator");
        }

        return result;
    }
}

// 函数示例
// 使用BigDecimal计算表达式的结果示例
// 入参:expression,要计算的表达式
// 出参:result,计算结果
// 调用示例:
// String expression = "2.5 + 3 * (4 - 1)";
// BigDecimal result = BigDecimalCalculator.calculateExpression(expression);
// System.out.println(result);
// 输出结果:例如,计算表达式"2.5 + 3 * (4 - 1)"的结果为:11.5
// 则输出结果为:11.5

经过对比分析,不难发现:

可读性上:

人工代码命名存在截断和不规范,注释不够简洁清晰,代码可读性差;

FuncGPT使用了合理的命名和注释,函数和变量的命名清晰明了,注释对函数的功能和参数进行了说明,提高了代码的可读性。

可维护性上:

人工代码代码层层嵌套,方法繁琐,不利于后期维护修改;

FuncGPT使用了合适的数据结构和算法。它使用两个栈来处理运算符和操作数,通过遍历表达式字符并根据优先级进行计算,避免了复杂的嵌套逻辑和多重判断。

安全性上:

人工代码没有判断空值,存在漏洞,健壮性差;

FuncGPT引入了Apache Commons Lang库,利用StringUtils类的isBlank方法判断表达式是否为空,提高了代码的健壮性和可靠性。

综上,FuncGPT(慧函数)生成的代码具有更好的可读性、可维护性和异常处理,并且使用了逆波兰表达式计算和第三方库来提供更强大的功能。

FuncGPT(慧函数)免费使用,秒级生成函数

你可能感兴趣的:(重构,java,程序员创富)