Which would be more advantageous: using a single setter method or multiple setter methods for objects that have a set number of fields?

Question

Which would be more advantageous: using a single setter method or multiple setter methods for objects that have a set number of fields?

As I ponder over designing a class with a member variable of type object containing a fixed number of fields, the question arises: should I opt for a single setter function or multiple setters to modify these fields?

To illustrate this dilemma clearly, I have created a simple organizational management structure class in two different ways:

Multiple Setter Functions

class Management {
    constructor() {
        this.numberOfManagers = 100;
        this.salaryDetails = {
            regionalManagerSalary: 80000,
            stateManagerSalary: 110000,
            executiveManagerSalary: 200000
        };
    }

    setRegionalManagerSalary(salary) {
        this.salaryDetails.regionalManagerSalary = salary;
    }

    setStateManagerSalary(salary) {
        this.salaryDetails.stateManagerSalary = salary;
    }  

    setExecutiveManagerSalary(salary) {
        this.salaryDetails.executiveManagerSalary = salary;
    }
}

const management = new Management();
management.setRegionalManagerSalary(100000);
management.setStateManagerSalary(120000);
management.setExecutiveManagerSalary(210000);

One Setter Function

class Management {
    constructor() {
        this.numberOfManagers = 100;
        this.salaryDetails = {
            regionalManagerSalary: 80000,
            stateManagerSalary: 110000,
            executiveManagerSalary: 200000
        };
    }

    setManagerSalary(typeOfManagerSalary, salary) {
        this.salaryDetails[typeOfManagerSalary] = salary;
    }
}

const management = new Management();
management.setManagerSalary('regionalManagerSalary', 100000);
management.setManagerSalary('stateManagerSalary', 120000);
management.setManagerSalary('executiveManagerSalary', 210000);

So, which implementation do you think would be more effective: the first one with multiple setters or the second one with a single setter function?

javascript architecture readability maintainability

Answer 1

Answer №1

When it comes to choosing between readability and writability, I always lean towards the option that offers higher readability without sacrificing too much writability. The second approach may be more generic, but the clarity of the first approach is undeniable.

In my opinion, the first approach is preferable because it explicitly states that there are only 3 fields in salaryDetails. With the second approach, there is uncertainty about the number of fields in salaryDetails as additional fields could be added through external calls like

management.setManagerSalary('someNewSalary', 100000);

.

Unless you have multiple Management objects with unique fields under salaryDetails, I believe the first approach is the way to go.

Answer 2

When it comes to choosing between readability and writability, I always lean towards the option that offers higher readability without sacrificing too much writability. The second approach may be more generic, but the clarity of the first approach is undeniable.

In my opinion, the first approach is preferable because it explicitly states that there are only 3 fields in salaryDetails. With the second approach, there is uncertainty about the number of fields in salaryDetails as additional fields could be added through external calls like

management.setManagerSalary('someNewSalary', 100000);

.

Unless you have multiple Management objects with unique fields under salaryDetails, I believe the first approach is the way to go.

Answer 3

Answer №2

If I were to offer a suggestion, I would propose implementing a method called setSalaryDetails. This method would accept a salary object as a parameter, allowing you to set it directly. Here's an example:

setSalaryDetails(salaryDetails) { this.salaryDetails = salaryDetails; }

When you call this method, you can easily create the salary object with the desired fields already set before passing it as an argument.

Answer 4

If I were to offer a suggestion, I would propose implementing a method called setSalaryDetails. This method would accept a salary object as a parameter, allowing you to set it directly. Here's an example:

setSalaryDetails(salaryDetails) { this.salaryDetails = salaryDetails; }

When you call this method, you can easily create the salary object with the desired fields already set before passing it as an argument.

Answer 5

Answer №3

It is recommended to avoid using setters altogether. Instead, initialize all necessary properties in the constructor by passing arguments.

The code provided appears to be procedural rather than object-oriented. To make it truly OOP, the data should be kept within the class.

To start improving the code, consider structuring it like this:

class Management {
    constructor(numManagers, regionalSalary, stateSalary, executiveSalary) {
        this.numberOfManagers = numManagers;
        this.salaryDetails = {
            regionalManagerSalary: regionalSalary,
            stateManagerSalary: stateSalary,
            executiveManagerSalary: executiveSalary
        };
    }
}

const management = new Management(100, 100000, 120000, 210000);

This approach is more concise, cleaner, and less prone to errors.

Based on the constructor signature, it seems like there may be an issue with mixing too many responsibilities in a single class.

A more organized design involves utilizing separate classes for different manager types:

/* abstract */ class Manager {
    constructor(salary) {
        this.salary = salary;
    }
}

class RegionalManager extends Manager { }
class StateManager extends Manager { }
class ExecutiveManager extends Manager { }

class Management {
    constructor(numManagers, regionalMgr, stateMgr, executiveMgr) {
        this.numberOfManagers = numManagers;
        this.managers = {
            regionalManager: regionalMgr,
            stateManager: stateMgr,
            executiveManager: executiveMgr
        };
    }
}

const management = new Management(
    100,
    new RegionalManager(100000),
    new StateManager(120000),
    new ExecutiveManager(210000)
);

By organizing the code in this manner, common logic for all manager types can be implemented in the Manager class, while specific behaviors for each type can be encapsulated in their respective classes. The Management class can then handle these managers based on quantity, without getting bogged down with their individual characteristics. This results in code that is easier to comprehend, maintain, and extend.

Answer 6

It is recommended to avoid using setters altogether. Instead, initialize all necessary properties in the constructor by passing arguments.

The code provided appears to be procedural rather than object-oriented. To make it truly OOP, the data should be kept within the class.

To start improving the code, consider structuring it like this:

class Management {
    constructor(numManagers, regionalSalary, stateSalary, executiveSalary) {
        this.numberOfManagers = numManagers;
        this.salaryDetails = {
            regionalManagerSalary: regionalSalary,
            stateManagerSalary: stateSalary,
            executiveManagerSalary: executiveSalary
        };
    }
}

const management = new Management(100, 100000, 120000, 210000);

This approach is more concise, cleaner, and less prone to errors.

Based on the constructor signature, it seems like there may be an issue with mixing too many responsibilities in a single class.

A more organized design involves utilizing separate classes for different manager types:

/* abstract */ class Manager {
    constructor(salary) {
        this.salary = salary;
    }
}

class RegionalManager extends Manager { }
class StateManager extends Manager { }
class ExecutiveManager extends Manager { }

class Management {
    constructor(numManagers, regionalMgr, stateMgr, executiveMgr) {
        this.numberOfManagers = numManagers;
        this.managers = {
            regionalManager: regionalMgr,
            stateManager: stateMgr,
            executiveManager: executiveMgr
        };
    }
}

const management = new Management(
    100,
    new RegionalManager(100000),
    new StateManager(120000),
    new ExecutiveManager(210000)
);

By organizing the code in this manner, common logic for all manager types can be implemented in the Manager class, while specific behaviors for each type can be encapsulated in their respective classes. The Management class can then handle these managers based on quantity, without getting bogged down with their individual characteristics. This results in code that is easier to comprehend, maintain, and extend.

Which would be more advantageous: using a single setter method or multiple setter methods for objects that have a set number of fields?

Answer №1

Answer №2

Answer №3

Similar questions

The function is not explicitly declared within the instance, yet it is being cited during the rendering process in a .vue

Tips for creating an automatic interval timer reset feature

Difficulty retrieving information using AngularJS service post selection of item

What is the best way to rotate a mesh by 90 degrees in ThreeJS?

Issue: Module 'curl' is not located at Function.Module._resolveFilename (module.js:489:15)

The usage of arrow functions in ReactJS programming

Is the IE7 Modal Dialog Misaligned?

Issue with jQuery UI: Accordion not functioning properly

Creating a multi-step form in Rails without using the Wizard gem allows for more

I am not sure how to properly execute this asynchronously

Start from scratch when establishing the baseline for "defaults."

Automating the selection of a drop down based on a condition in Angular 2: A step-by-step guide

Skrollr's transformation effect makes the text tremble

Working with floating point numbers in Node.js with a zero decimal place

Using JavaScript to load the contents of a JSON file

The CSS is not displaying correctly on Safari and Chrome browsers in Mac OS

NativeScript encountered an error while trying to locate the module 'ui/sidedrawer' for the specified element 'Sidedrawer'

What sets a module apart from a script?

What is the process for eliminating transparency from the overlay feature while utilizing Dojox/Standby?

Upon the initial data retrieval, everything seems to be working fine. However, when the user transitions to chatting with another user, the state value does not reset and instead shows a combination