Achieving inheritance in a streamlined and effective manner

Question

Achieving inheritance in a streamlined and effective manner

What is the most effective approach to eliminate repetitive code?

let BaseErrorResponse = function(mes, rti, rsi, st) {
    return {
        "message": msg,
        "response_type_id": rti,
        "response_status_id": rsi,
        "status": st
    }
};


let InvalidParamResponse = function(mes, rti, rsi, st, ip) {
    return {
        "message": msg,
        "response_type_id": rti,
        "response_status_id": rsi,
        "status": st,
        "invalid_params": ip
    }
};


let SuccessResponse = function(msg, rti, rsi, st, data) {
    return {
        "message": null,
        "response_type_id": null,
        "response_status_id": null,
        "status": null,
        "data": {}
    }
};

javascript

Answer 1

Answer №1

If you want to combine objects, you can simply use the Object.assign() method:

let BaseError = function(message, typeId, statusId, statusCode) {
    return {
        "message": message,
        "type_id": typeId,
        "status_id": statusId,
        "status_code": statusCode
    }
};


let InvalidParameterError = function(message, typeId, statusId, statusCode, params) {
    return Object.assign(BaseError(message, typeId, statusId, statusCode), {
        "invalid_params": params
    });
};


let SuccessMessage = function(message, typeId, statusId, statusCode, resultData) {
    return Object.assign(BaseError(message, typeId, statusId, statusCode), {
        "data": {}
    });
};

Alternatively, you could consider converting these functions into actual constructors with inheritance relationships between them.

function BaseError(message, typeId, statusId, statusCode) {
    this.message = message;
    this.type_id = typeId;
    this.status_id = statusId;
    this.status_code = statusCode;
}

function InvalidParameterError(message, typeId, statusId, statusCode, params) {
    BaseError.call(this, message, typeId, statusId, statusCode);
    this.invalid_params = params;
}

InvalidParameterError.prototype = Object.create(BaseError.prototype);
InvalidParameterError.prototype.constructor = InvalidParameterError;

function SuccessMessage(message, typeId, statusId, statusCode, resultData) {
    BaseError.call(this, message, typeId, statusId, statusCode);
    this.data = resultData;
}

SuccessMessage.prototype = Object.create(BaseError.prototype);
SuccessMessage.prototype.constructor = SuccessMessage;

Answer 2

If you want to combine objects, you can simply use the Object.assign() method:

let BaseError = function(message, typeId, statusId, statusCode) {
    return {
        "message": message,
        "type_id": typeId,
        "status_id": statusId,
        "status_code": statusCode
    }
};


let InvalidParameterError = function(message, typeId, statusId, statusCode, params) {
    return Object.assign(BaseError(message, typeId, statusId, statusCode), {
        "invalid_params": params
    });
};


let SuccessMessage = function(message, typeId, statusId, statusCode, resultData) {
    return Object.assign(BaseError(message, typeId, statusId, statusCode), {
        "data": {}
    });
};

Alternatively, you could consider converting these functions into actual constructors with inheritance relationships between them.

function BaseError(message, typeId, statusId, statusCode) {
    this.message = message;
    this.type_id = typeId;
    this.status_id = statusId;
    this.status_code = statusCode;
}

function InvalidParameterError(message, typeId, statusId, statusCode, params) {
    BaseError.call(this, message, typeId, statusId, statusCode);
    this.invalid_params = params;
}

InvalidParameterError.prototype = Object.create(BaseError.prototype);
InvalidParameterError.prototype.constructor = InvalidParameterError;

function SuccessMessage(message, typeId, statusId, statusCode, resultData) {
    BaseError.call(this, message, typeId, statusId, statusCode);
    this.data = resultData;
}

SuccessMessage.prototype = Object.create(BaseError.prototype);
SuccessMessage.prototype.constructor = SuccessMessage;

Answer 3

Answer №2

It appears that using ES2015 (also known as ES6) makes the class feature a suitable choice for your needs:

class BaseErrorResponse {
    constructor(mes, rti, rsi, st) {
        this.message = mes;
        this.response_type_id = rti;
        this.response_status_id = rsi;
        this.status = st;
    }
}

class InvalidParamResponse extends BaseErrorResponse {
    constructor(mes, rti, rsi, st, ip) {
        super(mes, rti, rsi, st);
        this.invalid_params = ip;
    }
}

class SuccessResponse extends BaseErrorResponse {
    constructor(msg, rti, rsi, st, data) {
        super(null, null, null, null); // Omitting values here seems unnecessary
        this.data = {};                // Shouldn't this be assigned to = data instead?
    }
}

Considering your response to my comment on the question, the corrected version of the last one would be:

class SuccessResponse extends BaseErrorResponse {
    constructor(msg, rti, rsi, st, data) {
        super(msg, rti, rsi, st);
        this.data = data;
    }
}

Answer 4

It appears that using ES2015 (also known as ES6) makes the class feature a suitable choice for your needs:

class BaseErrorResponse {
    constructor(mes, rti, rsi, st) {
        this.message = mes;
        this.response_type_id = rti;
        this.response_status_id = rsi;
        this.status = st;
    }
}

class InvalidParamResponse extends BaseErrorResponse {
    constructor(mes, rti, rsi, st, ip) {
        super(mes, rti, rsi, st);
        this.invalid_params = ip;
    }
}

class SuccessResponse extends BaseErrorResponse {
    constructor(msg, rti, rsi, st, data) {
        super(null, null, null, null); // Omitting values here seems unnecessary
        this.data = {};                // Shouldn't this be assigned to = data instead?
    }
}

Considering your response to my comment on the question, the corrected version of the last one would be:

class SuccessResponse extends BaseErrorResponse {
    constructor(msg, rti, rsi, st, data) {
        super(msg, rti, rsi, st);
        this.data = data;
    }
}

Answer 5

Answer №3

My preferred solution is a simpler approach:

const BaseErrorResponse = (message, requestId, responseId, status) => {
  return { message, requestId, responseId, status };
};

const InvalidParamResponse = (message, requestId, responseId, status, invalidParams) => {
  let response = BaseErrorResponse(message, requestId, responseId, status);
  response.invalidParams = invalidParams;
  return response;
};

const SuccessResponse = () => {
  let response = BaseErrorResponse(null, null, null, null);
  response.data = {};
  return response;
};

Answer 6

My preferred solution is a simpler approach:

const BaseErrorResponse = (message, requestId, responseId, status) => {
  return { message, requestId, responseId, status };
};

const InvalidParamResponse = (message, requestId, responseId, status, invalidParams) => {
  let response = BaseErrorResponse(message, requestId, responseId, status);
  response.invalidParams = invalidParams;
  return response;
};

const SuccessResponse = () => {
  let response = BaseErrorResponse(null, null, null, null);
  response.data = {};
  return response;
};

Answer 7

Answer №4

The code snippet provided by T.J. Crowder has been implemented successfully with great results.

'use strict';
class BaseErrorResponse {
    constructor(msg, rti, rsi, st) {
        this.message = msg;
        this.response_type_id = rti;
        this.response_status_id = rsi;
        this.status = st;
    }
}

class InvalidParamResponse extends BaseErrorResponse {
    constructor(mes, rti, rsi, st, ip) {
        super(mes, rti, rsi, st);
        this.invalid_params = ip;
    }
}

class SuccessResponse extends BaseErrorResponse {
    constructor(msg, rti, rsi, st, data) {
        super(msg, rti, rsi, st); // No need for null values here
        this.data = data;         // Correction: '=' instead of 'd'
    }
}


(()=> {
    let sr = new SuccessResponse('Message', 1, 2, 3, {name: 'vivek'});
    console.log(sr);
})();

OUTPUT:

test )

node js-class-test.js 
SuccessResponse {
  message: 'Message',
  response_type_id: 1,
  response_status_id: 2,
  status: 3,
  data: { name: 'vivek' } }

Answer 8

The code snippet provided by T.J. Crowder has been implemented successfully with great results.

'use strict';
class BaseErrorResponse {
    constructor(msg, rti, rsi, st) {
        this.message = msg;
        this.response_type_id = rti;
        this.response_status_id = rsi;
        this.status = st;
    }
}

class InvalidParamResponse extends BaseErrorResponse {
    constructor(mes, rti, rsi, st, ip) {
        super(mes, rti, rsi, st);
        this.invalid_params = ip;
    }
}

class SuccessResponse extends BaseErrorResponse {
    constructor(msg, rti, rsi, st, data) {
        super(msg, rti, rsi, st); // No need for null values here
        this.data = data;         // Correction: '=' instead of 'd'
    }
}


(()=> {
    let sr = new SuccessResponse('Message', 1, 2, 3, {name: 'vivek'});
    console.log(sr);
})();

OUTPUT:

test )

node js-class-test.js 
SuccessResponse {
  message: 'Message',
  response_type_id: 1,
  response_status_id: 2,
  status: 3,
  data: { name: 'vivek' } }

Achieving inheritance in a streamlined and effective manner

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

refusing to display the pop-up in a separate window

problem of keeping behat/selenium browser open after execution

Adding several <div> elements with the correct indices

Store the text area content as a JSON object

PHP code to display "ed elements that do not adjust height"

Is it possible to pass an external function to the RxJs subscribe function?

Using Javascript and Node.js to send a JSON request

Implement a query string feature using a drop-down list

What exactly are Node.js core files?

Preserve the existing value and then check it against the updated value of a variable within JavaScript

Ways to efficiently manage session control without repeating it in each route

Ways to address the issue of "$ is not a function"

Is there a way to retrieve the form name within my directive?

What is the best way to prevent a directory from being included in the Webpack bundle?

Retrieve PDF from Controller using jQuery AJAX request

The communication hub in a Vue.js application

Is EmailJS Secure Enough for Your Data?

Implementing dynamic page loading with ajax on your Wordpress website

Invoke a Java script function for Regular Expression validation failure in ASP.NET

Learn the steps to merging all yarn files using gulp