Best practices for modularizing and reusing functions in large code bases

In large code bases, function modularization and reuse are crucial, following the principles of single responsibility, high cohesion, low coupling, and loose coupling. Modularization strategies include function extraction, parameterized functions, and higher-order functions. The reuse strategy includes the universal function calcArea(), which calculates the area according to the shape type, and implements polymorphism through the Shape interface and Circle/Rectangle class to reduce code duplication.

Best practices for function modularization and reuse: How to maintain large code bases

Modularization and reuse of functions in large code bases Crucial. Modular functions facilitate maintenance, enhance code readability and reusability, thereby improving development efficiency and code quality.

The principle of modularity

• Single responsibility principle: Each function is only responsible for a single, clear functional area.
• High cohesion, low coupling: The internal code of the function has strong dependence and weak dependence on the external code.
• Loose coupling: Functions interact through clearly defined interfaces to avoid direct dependencies.

Reuse strategy

• Function extraction: Extract duplicate code blocks into separate functions to achieve code reuse.
• Parameterized functions: Parameterization enables functions to handle different types or ranges of data.
• Higher-order functions: Use higher-order functions to pass functions as parameters or return values ​​to increase the flexibility of the code.

Practical case

Original code:

// 计算圆的面积
public double calcCircleArea(double radius) {
    return Math.PI * radius * radius;
}

// 计算矩形的面积
public double calcRectangleArea(double width, double height) {
    return width * height;
}

Modularized code:

// 定义一个计算面积的通用函数
public double calcArea(Shape shape) {
    return switch (shape.getType()) {
        case CIRCLE -> Math.PI * shape.getRadius() * shape.getRadius();
        case RECTANGLE -> shape.getWidth() * shape.getHeight();
        default -> throw new IllegalArgumentException("Unknown shape type");
    };
}

// Shape 接口定义了形状类型的常量
public interface Shape {
    enum Type {
        CIRCLE,
        RECTANGLE
    }

    Type getType();

    double getRadius();

    double getWidth();

    double getHeight();
}

// Circle 和 Rectangle 类实现 Shape 接口
public class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public Type getType() {
        return Type.CIRCLE;
    }

    @Override
    public double getRadius() {
        return radius;
    }
}

public class Rectangle implements Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public Type getType() {
        return Type.RECTANGLE;
    }

    @Override
    public double getWidth() {
        return width;
    }

    @Override
    public double getHeight() {
        return height;
    }
}

Through modularization, code responsibilities are clear and reusable. General function calcArea() Calculates the area based on the passed shape type without repeating similar calculation logic.

The above is the detailed content of Best practices for modularizing and reusing functions in large code bases. For more information, please follow other related articles on the PHP Chinese website!