Refactoring 020 - Transform Static Functions

Kill Static, Revive Objects

TL;DR: Replace static functions with object interactions.

Problems Addressed

• High coupling due to global access

• Poor testability

• Overloaded protocols in classes

• Decreased cohesion

Related Code Smells

Code Smell 18 — Static Functions

Maxi Contieri ・ Nov 6 '20

#codenewbie #tutorial #development #coding

Code Smell 17 - Global Functions

Maxi Contieri ・ Nov 5 '20

#codenewbie #development #tutorial

Code Smell 22 - Helpers

Maxi Contieri ・ Nov 12 '20

#oop #helpers #codenewbie #beginners

Steps

1. Identify static methods used in your code.

2. Replace static methods with instance methods.

3. Pass dependencies explicitly through constructors or method parameters.

4. Refactor clients to interact with objects instead of static functions.

Sample Code

Before

class CharacterUtils {
    static createOrpheus() {
        return { name: "Orpheus", role: "Musician" };
    }

    static createEurydice() {
        return { name: "Eurydice", role: "Wanderer" };
    }

    static lookBack(character) {
      if (character.name === "Orpheus") {
        return "Orpheus looks back and loses Eurydice.";
    } else if (character.name === "Eurydice") {
        return "Eurydice follows Orpheus in silence.";
    }
       return "Unknown character.";
  }
}

const orpheus = CharacterUtils.createOrpheus();
const eurydice = CharacterUtils.createEurydice();

After

// 1. Identify static methods used in your code.
// 2. Replace static methods with instance methods.
// 3. Pass dependencies explicitly through
// constructors or method parameters.

class Character {
    constructor(name, role, lookBackBehavior) {
        this.name = name;
        this.role = role;
        this.lookBackBehavior = lookBackBehavior;
    }

    lookBack() {
        return this.lookBackBehavior(this);
    }
}

// 4. Refactor clients to interact with objects 
// instead of static functions.
const orpheusLookBack = (character) =>
    "Orpheus looks back and loses Eurydice.";
const eurydiceLookBack = (character) =>
    "Eurydice follows Orpheus in silence.";

const orpheus = new Character("Orpheus", "Musician", orpheusLookBack);
const eurydice = new Character("Eurydice", "Wanderer", eurydiceLookBack);

Type

[X] Semi-Automatic

You can make step-by-step replacements.

Safety

This refactoring is generally safe, but you should test your changes thoroughly.

Ensure no other parts of your code depend on the static methods you replace.

Why is the Code Better?

Your code is easier to test because you can replace dependencies during testing.

Objects encapsulate behavior, improving cohesion and reducing protocol overloading.

You remove hidden global dependencies, making the code clearer and easier to understand.

Refactor with AI

Without Proper Instructions	With Specific Instructions
ChatGPT	ChatGPT
Claude	Claude
Perplexity	Perplexity
Copilot	Copilot
Gemini	Gemini

Tags

• Cohesion

Related Refactorings

• [https://dev.to/mcsee/refactoring-018-replace-singleton-18gn]

• [https://dev.to/mcsee/refactoring-007-extract-class-18ei]

• Replace Global Variable with Dependency Injection

See also

Coupling: The one and only software design problem

Maxi Contieri ・ Feb 6 '21

#webdev #programming #oop #tutorial

Credits

Image by Menno van der Krift from Pixabay

---

This article is part of the Refactoring Series.

How to Improve your Code With easy Refactorings

Maxi Contieri ・ Oct 24 '22

#webdev #beginners #programming #tutorial