登录查看更多内容

How can you identify and fix common code smells in refactoring?

由人工智能和领英社区提供技术支持

Refactoring is the process of improving the design, structure, and readability of your code without changing its functionality or behavior. It can help you make your code more maintainable, testable, and reusable. However, refactoring can also introduce new problems or reveal existing ones, such as code smells. Code smells are indicators of poor coding practices, such as duplication, complexity, inconsistency, or ambiguity, that can affect the quality and performance of your code. In this article, you will learn how to identify and fix some of the most common code smells in refactoring, using examples in Python.

此文章中的业界达人

由社区从 9 条内容中精选。了解更多

Lex Kuncevic

Strategic Software Engineering ? Discovery | Advisory | Systems & Hands-on Tech Leadership | Fractional CTO | MIT | GDE…
Vahe Aslanyan

Software Engineer | Founder of LunarTech | As Seen in Forbes
Ashish Tad

Software Engineer at Juniper Networks

1 Long Methods

One of the most frequent code smells is having long methods that do too many things or have too many parameters. Long methods are hard to read, understand, test, and debug. They also increase the risk of errors and bugs, as well as the coupling and dependency between different parts of your code. A good rule of thumb is to keep your methods short and focused, ideally less than 10 lines of code. You can use several techniques to break down long methods into smaller and more cohesive ones, such as extracting subtasks into separate methods, replacing conditional logic with polymorphism, or applying the single responsibility principle.

添加您的观点

Vahe Aslanyan

Software Engineer | Founder of LunarTech | As Seen in Forbes
举报内容
To tackle long methods, it's crucial to think beyond mere line counts. Embrace refactoring with a strategic mindset. Techniques like extracting methods are a start, but consider leveraging design patterns that promote cleaner, more modular code. For instance, the Command pattern can encapsulate requests as objects, reducing method complexity. Also, integrate code review tools that automate the detection of long methods, pushing developers to continually refine their code. The key is not just shorter methods but smarter, more maintainable code. This approach transforms coding from a task to an art, ensuring each line of code serves a clear, concise purpose.

已翻译

赞
Ashish Tad

Software Engineer at Juniper Networks
举报内容
In order to deal with long methods, the metric should not only be the LOC. It's about the allignment of the function name and the task it is executing. Alongwith the lines of code, the task getting done should be ensured. Ideally each function should be responsible to perform only a single responsibility. Even while performing a single responsibility if at all the LOC is going beyond 15 or 20, then the responsibility needs to be revisited and can be broken to further sub tasks.

已翻译

赞
Lex Kuncevic

Strategic Software Engineering ? Discovery | Advisory | Systems & Hands-on Tech Leadership | Fractional CTO | MIT | GDE | Speaker | Educator ?? Open to Networking & Collaboration
举报内容
Refactoring code smells requires meticulous review to spot duplicate logic, lengthy methods, or complex code. Automated tools aid in detecting problem areas. Prioritize addressing smells by extracting repeating segments, splitting large functions, or applying design patterns. Refactor gradually with extensive testing to maintain functionality while eliminating issues. Continuous monitoring and iterations refine the architecture over time. Meticulous inspection, prioritization, incremental changes, and ongoing refinement help eliminate code smells through refactoring. The result is cleaner, more maintainable software.

已翻译

赞
Akash Sheokand

Tech lead
举报内容
When writing code one must always consider keeping the functions concise and as simple as possible. The function should do what it names suggests and if it becomes long then it should be broken down into smaller functions to keep the complexity low. Couple similar code together and break them into to smaller functions. Smaller functions are easy to test compared to bigger functions.

已翻译

赞

2 Duplicate Code

Another common code smell is having duplicate code, which means repeating the same or similar code in multiple places. Duplicate code is a sign of poor abstraction and modularity, and it can lead to inconsistency, redundancy, and waste of resources. It can also make your code harder to maintain and modify, as you have to update the same code in multiple places whenever you make a change. To avoid duplicate code, you should use abstraction and encapsulation to create reusable and modular components, such as classes, functions, or modules. You should also use inheritance and composition to leverage existing code and avoid repetition.

添加您的观点

Lex Kuncevic

Strategic Software Engineering ? Discovery | Advisory | Systems & Hands-on Tech Leadership | Fractional CTO | MIT | GDE | Speaker | Educator ?? Open to Networking & Collaboration
举报内容
Duplicate code is a common code smell that bloats codebases and increases maintenance costs. Spotting copied-and-pasted segments through careful inspection, extract the duplicates into new functions that can be called from the original locations. This eliminates repetition, reduces bugs from parallel edits, shrinks code volume, and improves readability and organization. Refactoring in small steps with tests ensures improvements without introducing new issues.

已翻译

赞
Vahe Aslanyan

Software Engineer | Founder of LunarTech | As Seen in Forbes
举报内容
To tackle duplicate code, shift the focus to strategic refactoring. Employ advanced concepts like the DRY (Don't Repeat Yourself) principle. Regularly schedule code reviews specifically targeting redundancy. Introduce tools like SonarQube for automated detection of duplicate blocks. Also, leverage design patterns, such as the Template Method pattern for common operations with slight variations. This goes beyond mere elimination of repetition; it's about fostering a culture of efficiency and innovation. Developers should be encouraged to think critically about the broader architecture, ensuring each component serves a unique purpose.

已翻译

赞
Sachin Patil

Full Stack Senior Software Engineer | C#, Python, Go-Lang, NodeJS, Azure, AWS, .Net | Certified in Azure, Kubernetes, MongoDB & AI | Expert in Microservices & Scalable Enterprise Architecture | Microsoft Tech Stack
举报内容
Duplication of code reflects a lack of understanding of fundamental SOLID principles and object-oriented programming (OOP) concepts. This oversight contributes to increased maintenance costs, heightened development efforts, and may lead to negative reviews.

已翻译

赞

3 Magic Numbers

Magic numbers are literal values that appear in your code without any explanation or context. For example, if you write if x > 42: , what does 42 mean and why is it important? Magic numbers are a code smell because they make your code less readable, less meaningful, and less flexible. They can also introduce errors and bugs, as you may forget or mistype the values, or use different values for the same purpose. To fix magic numbers, you should replace them with meaningful constants or variables that have descriptive names and are easy to change. For example, you can write MAX_VALUE = 42 and then use if x > MAX_VALUE: .

添加您的观点

Gil Lau

I design and implement robust maintainable solutions | Passionate about building teams and making an impact
举报内容
Even worse are magic numbers or magic dates that are stored in the database. Someone may change the value not knowing it will break the application.

已翻译

赞

4 Large Classes

Large classes are classes that have too many attributes, methods, or responsibilities. Large classes are a code smell because they violate the principle of cohesion, which states that a class should have a single and clear purpose. Large classes are hard to understand, test, and reuse, and they increase the complexity and coupling of your code. They also tend to have low quality and high maintenance costs. To deal with large classes, you should apply the principle of separation of concerns, which means dividing your code into smaller and more independent units that have specific and well-defined roles. You can use techniques such as extracting subclasses, extracting interfaces, or extracting methods to split large classes into smaller and more cohesive ones.

添加您的观点

5 Feature Envy

Feature envy is a code smell that occurs when a method or a function accesses or manipulates the data or behavior of another class or object more than its own. For example, if you have a method that calculates the total price of an order by accessing the attributes of the order class, such as quantity, price, and discount, then the method has feature envy. Feature envy is a code smell because it breaks the principle of encapsulation, which states that a class or an object should hide its internal details and expose only its public interface. Feature envy also reduces the cohesion and increases the coupling of your code, making it more fragile and less reusable. To fix feature envy, you should move the method or the function to the class or the object that owns the data or the behavior, or use delegation to delegate the responsibility to the appropriate class or object.

添加您的观点

6 Dead Code

Dead code is code that is never executed or used, such as unused variables, unreachable statements, or obsolete methods. Dead code is a code smell because it adds unnecessary clutter and confusion to your code, making it harder to read and maintain. It can also cause performance issues, as it consumes memory and resources. Dead code can also hide potential errors or bugs, as it may indicate logical flaws or outdated assumptions in your code. To eliminate dead code, you should use code analysis tools, such as linters, code coverage tools, or static analyzers, to identify and remove unused or unreachable code. You should also use version control systems, such as Git, to keep track of your code changes and history, so that you can easily restore or revert your code if needed.

添加您的观点

Gil Lau

I design and implement robust maintainable solutions | Passionate about building teams and making an impact
举报内容
Some other forms of dead code: - blocks of commented out code - blocks of else code with the comment "This should not happen." - code tagged #OBSOLETE but never removed Dead code should be removed quickly as the longer it stays, the likelihood of it being removed decreases as other team members come aboard and are afraid of removing it for fear of breaking something.

已翻译

赞

7 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

添加您的观点

Software Development

+ 关注

给文章评分

我们借助人工智能创建了此文章。您认为这篇文章怎么样？

很棒不太好

举报此文章

查看全部

How can you identify and fix common code smells in refactoring?

1

2

3

4

5

6

7

1 Long Methods

2 Duplicate Code

3 Magic Numbers

4 Large Classes

5 Feature Envy

6 Dead Code

7 Here’s what else to consider

Software Development

给文章评分

感谢您的反馈

更多Software Development相关文章

更多相关阅读内容

How can you identify and fix common code smells in refactoring?

1

2

3

4

5

6

7

1 Long Methods

2 Duplicate Code

3 Magic Numbers

4 Large Classes

5 Feature Envy

6 Dead Code

7 Here’s what else to consider

Software Development

给文章评分

感谢您的反馈

查看其他技能