Clean code is a concept that refers to writing code in such a way that it is easy to understand, easy to maintain, and easy to modify. The principles and best practices for writing clean code can be summarized as follows:
1. Meaningful Names:
- Use descriptive, unambiguous names for variables, functions, classes, and modules.
- Avoid disinformation (e.g., using a variable name l that looks like 1 or I).
- Make meaningful distinctions (e.g., getUserInfo vs getUserData).
- Use pronounceable names.
2. Functions:
- Functions should be small and do only one thing.
- They should have a small number of parameters, ideally no more than three.
- Function names should describe what they do.
- Functions should not have side effects that are not obvious from the name.
3. Comments:
- Comments should explain why something is done, not what is done.
- Avoid redundant comments that just repeat the code.
- Update comments when code changes.
- Use comments to mark incomplete code or areas that need improvement.
4. Formatting:
- Code should be consistently indented and formatted.
- Use blank lines to separate sections of code that are logically related.
- Follow the coding standards of your team or organization.
5. Error Handling:
- Use exceptions rather than return codes for error handling.
- Don't ignore exceptions.
- Provide context with exceptions to make them more helpful.
6. Unit Tests:
- Write tests for your code.
- Tests should be clean, too – easy to read, easy to understand, and easy to modify.
- Tests should cover various cases and edge conditions.
7. DRY (Don't Repeat Yourself):
- Avoid duplication of code.
- Use abstraction, functions, or classes to avoid code duplication.
8. Simplicity:
- Write simple code that gets the job done.
- Avoid over-engineering and premature optimization.
- Remove unnecessary code.
9. Code Review:
- Regularly review your code with colleagues to catch mistakes and get suggestions for improvement.
10. Refactoring:
- Continuously refactor your code to make it cleaner.
- Make one change at a time and test it before moving on.
11. Code Cohesion:
- Keep related code together.
- Ensure that classes and modules have a clear responsibility.
12. Use Design Patterns Wisely:
Use design patterns where they are needed, but don't force them into your code.
15. Code Documentation:
Write documentation that explains how to use your code, especially for libraries and APIs.
Top comments (0)