Maxi Contieri

Posted on Jul 11

Refactoring 030 - Inline Attributes

#webdev #programming #javascript #beginners

Avoid accidental redundancy

TL;DR: Don’t pass attributes your object already owns

Problems Addressed 😔

Redundant Parameters
Unclear responsibility
Duplicated logic
Parameter pollution
Low cohesion
Parameter redundancy
Code duplication
Incomplete extracted method object

Related Code Smells 💨

Code Smell 188 - Redundant Parameter Names

Maxi Contieri ・ Dec 24 '22

#gratitude #community

Code Smell 174 - Class Name in Attributes

Maxi Contieri ・ Oct 29 '22

#javascript #webdev #beginners #programming

Code Smell 10 - Too Many Arguments

Maxi Contieri ・ Oct 29 '20

#codenewbie #beginners #100daysofcode #oop

Code Smell 46 - Repeated Code

Maxi Contieri ・ Dec 8 '20

#oop #codenewbie #tutorial #webdev

Code Smell 143 - Data Clumps

Maxi Contieri ・ Jun 22 '22

#webdev #javascript #beginners #programming

Steps 👣

Identify methods that receive owned attributes
Remove those parameters from the method signature
Replace usage with direct access to the attribute
Rename the method if needed to match the new intention

Sample Code 💻

Before 🚨

class Auto {
  constructor(motor) {
    this.motor = motor
  }

  startEngine(motor) {
    motor.ignite()
  }
}

// Usage
const motor = new Motor()
const auto = new Auto(motor)

auto.startEngine(motor)
// Redundant and maybe inconsistent

After 👉

class Auto {
  constructor(motor) {
    this.motor = motor
  }

  // 1. Identify methods that receive owned attributes    
  startEngine() {
    // 2. Remove those parameters from the method signature  
    // 4. Rename the method if needed to match the new intention
    this.motor.ignite()
  }
}

// Adjust usage to call without passing motor
const motor = new Motor()
const auto = new Auto(motor)

// 3. Replace usage with direct access to the attribute  
auto.startEngine() // No parameter needed

Type 📝

[X] Automatic

Safety 🛡️

This refactoring is straightforward and safe if you have good test coverage.

Why is the Code Better? ✨

You remove accidental complexity.

You stop pretending your method needs information from the outside.

You reduce the cognitive load and improve encapsulation.

You clarify which attributes are essential.

You avoid passing the same data through different paths.

You reduce parameter redundancy and simplify method signatures.

You eliminate the possibility of passing inconsistent values since methods now directly access the object's state.

This makes the code more maintainable and reduces the cognitive load when reading method calls.

The methods become more cohesive by relying on their own object's data rather than external parameters.

How Does it Improve the Bijection? 🗺️

This refactoring enhances the Bijection by aligning object behavior more closely with real-world entities.

You match the real-world concept: an object uses what it owns.

You improve the anthropomorphism and avoid unrealistic indirection.

You also reduce internal and external coupling.

Limitations ⚠️

This works only if the method always uses the internal attribute.

If you need to inject different versions for testing or variations, consider using dependency injection or a strategy pattern.

Refactor with AI 🤖

Suggested Prompt: 1. Identify methods that receive owned attributes 2. Remove those parameters from the method signature 3. Replace usage with direct access to the attribute 4. Rename the method if needed to match the new intention

Without Proper Instructions	With Specific Instructions
ChatGPT	ChatGPT
Claude	Claude
Perplexity	Perplexity
Copilot	Copilot
You	You
Gemini	Gemini
DeepSeek	DeepSeek
Meta AI	Meta AI
Grok	Grok
Qwen	Qwen

Tags 🏷️

Encapsulation

Level 🔋

[X] Beginner

Related Refactorings 🔄

Refactoring 010 - Extract Method Object

Maxi Contieri ・ Nov 7 '22