Functions and Method Design

# CHAPTER 4

Functions and Method Design #

1. Introduction #

2. Learning Objectives #

• Understand the critical importance of keeping functions extremely small.

• Apply the Single Responsibility Principle (SRP) to function design.

• Identify and eliminate hidden "Side Effects" in methods.

• Manage function arguments effectively (minimizing parameters).

• Master the "Extract Method" refactoring technique.

3. Rule #1: Small! #

• Why? A small function is easy to read, easy to test, and easy to reuse. If your function is 100 lines long, it is doing too many things.

4. Rule #2: Do One Thing (Single Responsibility) #

• The "And" Test: If you describe what your function does and you use the word "AND," it is doing too much. (e.g., "This function validates the user *and* saves them to the database"). That must be split into two separate functions: validateUser() and saveUser().

5. Managing Function Arguments #

• The Problem: createUser("John", "Doe", "john@test.com", "password123", true, 1) -> What do all these strings and booleans mean? It's impossible to read.

• The Solution (Data Objects): If a function needs more than 2 or 3 arguments, those arguments should be wrapped into an Object.

• *Clean:* createUser($userRegistrationDTO) (Pass a single Data Transfer Object instead of 6 raw variables).

6. Avoiding Side Effects #

• Example: You have a function called checkPassword(). A developer expects this to just return True/False. However, inside the function, the previous author added code that initializes a session and logs the user in.

• The Danger: A developer calls checkPassword() just to validate a string, and accidentally logs a user in. This is a catastrophic side effect. Functions must do *exactly* what their name says, and nothing else.

7. Diagrams/Visual Suggestions #

[ BEFORE (The God Function) ]
function processCheckout() {
    // 20 lines of validation
    // 30 lines of credit card processing
    // 15 lines of database saving
    // 20 lines of email sending
}

[ AFTER (Clean, Single Responsibility Functions) ]
function processCheckout($order) {
    validateOrder($order);
    chargeCreditCard($order);
    saveOrderToDatabase($order);
    sendConfirmationEmail($order);
}
// Each sub-function is exactly 5-10 lines long.

8. Best Practices #

• Command Query Separation (CQS): Functions should either do something (Command: modify state/database) OR answer something (Query: return data), but not both.

• *Bad:* A function that saves a user to the DB *and* returns the HTML string for the profile page.

• *Clean:* saveUser() (Command) and getUserProfileHtml() (Query).

9. Common Mistakes #

• Flag Arguments (Booleans): Passing a boolean into a function (e.g., renderPage(true)) is a terrible practice. It loudly proclaims that the function does more than one thing: it does one thing if the flag is true, and another if the flag is false. Split it into two functions! (renderAdminPage() and renderUserPage()).

10. Mini Project: Extract Method #

function registerUser($username, $password, $email) {
    if (strlen($password) < 8) { throw new Exception("Password too short"); }
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) { throw new Exception("Bad email"); }
    
    $hashed = password_hash($password, PASSWORD_BCRYPT);
    $db->query("INSERT INTO users...");
}

*After:*

function registerUser(UserRegistrationRequest $request) {
    validateRequest($request);
    $hashedPassword = hashPassword($request->password);
    saveUserToDatabase($request->username, $hashedPassword, $request->email);
}

function validateRequest(UserRegistrationRequest $request) {
    // 5 lines of validation logic here
}
function hashPassword($password) {
    // 2 lines of hashing logic here
}
// ...

11. Practice Exercises #

1. 1. Explain the "Command Query Separation" principle. Why should a function not modify a database and return a complex UI view at the same time?

1. 2. What is the maximum recommended number of arguments for a clean function? How do you resolve a function that currently requires 7 arguments?

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the Single Responsibility Principle (SRP) as it applies to functions. If a function is named calculateTaxAndPrintInvoice(), what is wrong with it, and how do you fix it?

• Q: What is the "Extract Method" refactoring technique? Walk me through how you would use it to clean up a 100-line procedural function.

• Q: During a code review, you see a function with 8 parameters. The author argues they need all 8 variables to create a User. How do you instruct them to refactor it to reduce the parameter count to 1?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #