Create a JavaScript constructor function only if the types of parameters are verified

Question

Create a JavaScript constructor function only if the types of parameters are verified

Imagine this scenario: I have a constructor function like the one below:

function Planet(solarSystem, habitable) {

    this.solarSystem = solarSystem;
    this.habitable = habitable;

}

Now, let's say after having a few too many beers, I try to create an instance of this constructor function with incorrect parameters:

let earth = new Planet(23, 'wooow');

Your task is to figure out how to set up a condition for creating the instance where it only happens if the parameter types are correct. If not, don't assign anything to earth.

Note: The expected parameter types for the Planet constructor function are Planet(String, boolean). Keep that in mind while solving this problem.

javascript

Answer 1

Answer №1

Here are a couple of ways to achieve it:

Simply return an object with no properties

    function Planet(solarSystem,habitable) {
        if (typeof solarSystem != 'string' && typeof habitable != 'boolean') {
           return Object.create(null);
        }
        this.solarSystem = solarSystem;
        this.habitable = habitable;
    }
    
    var planetObj1 = new Planet('TEST', true);
    console.log('planetObj1 ' , planetObj1 , 'is instanceof Planet', planetObj1 instanceof Planet);
    var planetObj2 = new Planet(14, 'TEST');
    console.log('planetObj2 ', planetObj2, 'is instanceof Planet', planetObj2  instanceof Planet);

If you need to return other JavaScript types like undefined or null, you can create a prototype to handle these cases

You have the option to create a prototype to determine whether to create your new object or not

function Planet(solarSystem,habitable) {

        this.solarSystem = solarSystem;
        this.habitable = habitable;

    }

    Planet.CreatePlanet = function(solarSystem, habitable) { 
        if (typeof solarSystem != 'string' && typeof habitable != 'boolean') return null;
        return new Planet(solarSystem, habitable);
    }

    // Instead of using new Planet():
    var obj = Planet.CreatePlanet(14, 'habitable');// This will return null
    console.log(obj);

Answer 2

Here are a couple of ways to achieve it:

Simply return an object with no properties

    function Planet(solarSystem,habitable) {
        if (typeof solarSystem != 'string' && typeof habitable != 'boolean') {
           return Object.create(null);
        }
        this.solarSystem = solarSystem;
        this.habitable = habitable;
    }
    
    var planetObj1 = new Planet('TEST', true);
    console.log('planetObj1 ' , planetObj1 , 'is instanceof Planet', planetObj1 instanceof Planet);
    var planetObj2 = new Planet(14, 'TEST');
    console.log('planetObj2 ', planetObj2, 'is instanceof Planet', planetObj2  instanceof Planet);

If you need to return other JavaScript types like undefined or null, you can create a prototype to handle these cases

You have the option to create a prototype to determine whether to create your new object or not

function Planet(solarSystem,habitable) {

        this.solarSystem = solarSystem;
        this.habitable = habitable;

    }

    Planet.CreatePlanet = function(solarSystem, habitable) { 
        if (typeof solarSystem != 'string' && typeof habitable != 'boolean') return null;
        return new Planet(solarSystem, habitable);
    }

    // Instead of using new Planet():
    var obj = Planet.CreatePlanet(14, 'habitable');// This will return null
    console.log(obj);

Answer 3

Answer №2

To implement custom validation logic on an existing constructor, you can utilize a Proxy object in JavaScript:

function Galaxy(name, size) {
    this.name = name;
    this.size = size;
}

const validator = { // handler for Proxy
  construct: function(target, args) {
    let name, size;
    if (Array.isArray(args) && args.length === 2) {
      name = (typeof args[0] === 'string') ? args[0] : null;
      size = (typeof args[1] === 'number') ? args[1] : null;
      return ( name !== null && size !== null)
      ? { name, size} 
        : {}
    } else {
    return {} // return an empty object if arguments are not as expected
    }
  }
}

// create a new constructor with validation using Proxy
const validGalaxy = new Proxy(Galaxy, validator); 
// usage example: const milkyWay = new validGalaxy(<string>, <number>)

// demonstrate problematic behavior of the original constructor:

const andromeda = new Galaxy('Andromeda', 1000000);
console.log('andromeda (Galaxy): ', andromeda);

const invalid = new Galaxy('Invalid', 'large'); // using initial constructor, allowing wrong value
console.log('invalid (Galaxy): ', invalid);

// now apply validation with proxied constructor

const orion = new validGalaxy('Orion', 500000);
console.log('orion (validGalaxy): ', orion);

const failed = new validGalaxy('Failed', 'huge');
console.log('failed (validGalaxy): ', failed); // returns an empty object

If incorrect inputs are provided, the Proxy.construct method will always return an object instead of 'undefined'. This approach ensures consistent handling of input validation.

Answer 4

To implement custom validation logic on an existing constructor, you can utilize a Proxy object in JavaScript:

function Galaxy(name, size) {
    this.name = name;
    this.size = size;
}

const validator = { // handler for Proxy
  construct: function(target, args) {
    let name, size;
    if (Array.isArray(args) && args.length === 2) {
      name = (typeof args[0] === 'string') ? args[0] : null;
      size = (typeof args[1] === 'number') ? args[1] : null;
      return ( name !== null && size !== null)
      ? { name, size} 
        : {}
    } else {
    return {} // return an empty object if arguments are not as expected
    }
  }
}

// create a new constructor with validation using Proxy
const validGalaxy = new Proxy(Galaxy, validator); 
// usage example: const milkyWay = new validGalaxy(<string>, <number>)

// demonstrate problematic behavior of the original constructor:

const andromeda = new Galaxy('Andromeda', 1000000);
console.log('andromeda (Galaxy): ', andromeda);

const invalid = new Galaxy('Invalid', 'large'); // using initial constructor, allowing wrong value
console.log('invalid (Galaxy): ', invalid);

// now apply validation with proxied constructor

const orion = new validGalaxy('Orion', 500000);
console.log('orion (validGalaxy): ', orion);

const failed = new validGalaxy('Failed', 'huge');
console.log('failed (validGalaxy): ', failed); // returns an empty object

If incorrect inputs are provided, the Proxy.construct method will always return an object instead of 'undefined'. This approach ensures consistent handling of input validation.

Create a JavaScript constructor function only if the types of parameters are verified

Answer №1

Answer №2

Similar questions

Angular sorting data is not functioning as expected

Ensuring uniform sizing of anchor text using jQuery

Why is my Angular router displaying the page twice in the browser window?

What is the best way to send a 2D array from JavaScript to PHP?

Displaying spinner until the entire section has finished loading

Steps for implementing a single proxy in JavaScript AJAX with SOAP, mirroring the functionality of the WCF Test Client

Calling Ajax to Flask for fetching MySQL query results

Utilizing Shopify API to seamlessly add items to cart without any redirection for a smoother shopping experience

iterative string ng-list that is specified in the text $scope variable

Converting user input from a string to an object in JavaScript: a comprehensive guide

The VueJS component from a third-party source is not located in the node_modules directory

What is the reason for the unusual incrementing of the index in JavaScript?

How can I add an item to an array within another array in MongoDB?

Converting a JavaScript array to a PHP array using POST request

What is the best way to create an array within an object in JavaScript?

Can the useNavigation hook be used to navigate to a class component in React?

Creating an Engaging Data Visualization: Blending Candlestick Insights with Line Graphs

Explore the Wikipedia API play area by searching based on the user's input

Trouble encountered while attempting to install ng2-bootstrap within my Angular 2 project

Looking for a way to choose a button with a specific class name and a distinct "name" attribute using jquery?