Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

function-overloader

Package Overview
Dependencies
Maintainers
1
Versions
42
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

function-overloader

improve overloading functions and methods in js

  • 1.5.0
  • Source
  • npm
  • Socket score

Version published
Maintainers
1
Created
Source

FUNCTION OVERLOADER

Build Status Downloads Downloads NPM version

Introduce the mechanism for easy overloading functions and method.

install

npm install function-overloader

Introduction

This library/helper is solution for lack of function overloading in javascript. It will not introduce overloading for functions. But it will help handling multiple different arguments.

It will return response from correct do block.

teaser

import Overload from "function-overloader";
class Monster {

    constructor() {
        Overload.set(...arguments)
            .when("string", "number")
            .do((monsterName, level) => {
                this.name = monsterName;
                this.level = level;
            })
            .when("object")
            .do(monsterData => {
                this.name = monsterData.name;
                this.level = monsterData.level;
            })
            .done();
        console.log(`Monster ${this.name} level ${this.level} created`);
    }
    
    addAttribute() {
        return Overload.set(...arguments)
            .when(Attribute)
            .do(this.addExisitingAttribute)
            .when("string", "function")
            .do(this.addNewAttribute)
            .done();
    }
    
    addExisitingAttribute (attribute) {
        this.attributes.push(attribute);
        return attribute;
    }
    
    addNewAttribute (attributeName, attributeLogic) {
        const attribute = new Attribute(attributeName, attributeLogic);
        this.attributes.push(attribute);
        return attribute;
    }
}

Now it is possible:

    const monster1 = new Monster ("hakuna", 3);
    monster1.addAttribute("happy", () => {});
    const attribute = new Attribute("sad", () => {});
    monster1.addAttribute(attribute);
    
    const monster2 = new Monster ({
        name: "froggy",
        level: 2
    });

motivation

Decrease code complexity of overloaded functions and methods.

Old fashion:

function someMethod () {
    if(arguments.length === 2 && typeof arguments[0] === "string" && typeof arguments[1] === "number") {
        //do some stuff when get string and number
    } else if (arguments.length === 1 && typeof arguments[0] === "object" && arguments[0] instanceof SomeCustomConstructor) {
        //do something else if one argument which is instance of SomeCustomConstructor
    } else {
        //do something else
    }
}

usage

import/require this library

import Overload from "function-overloader";

then:

function someOverloadedFunction() {
    return Overload.set(...arguments)
        .when("sometypeA1", "sometypeA2")
        .do(someFunctionHandlingFirstCase)
        .when("sometypeB1", "sometypeB2")
        .do(someFunctionHandlingSecondCase)  
        .done();
}

API

init

Overload.set(...arguments)

accept function arguments. It is possible by passing them one by one, but preffered why is to just pass spread ...arguments. It will return Condition Response

Another possibility is to :

new Overload(...arguments);

And it will also return Condition Response

.when()

.when()

It is for describe when to run related do method. Return object with do method

Accept multiple values that will descibe function. Possible values:

  • "boolean"

  • "number"

  • "string"

  • "symbol"

  • "function"

  • "undefined"

  • Constructor function / class to define that argument should be an instance of provided class / constructor.

if there is no arguments it means that it will resolve only when overloaded function doesn't get any arguments.

In addition you can import overloader with build in types

import Overload, * as TYPES from "./Overload";

Then to define types you can:

  • TYPES.STRING
  • TYPES.NUMBER
  • TYPES.OBJECT
  • TYPES.FUNCTION
  • TYPES.BOOLEAN
  • TYPES.SYMBOL
  • TYPES.UNDEFINED

.else()

.else()

Accept callback function. Will invoke it when other criteria are not met.

Return object with done method.

.done()

.done()

should be called at the end to mark that now we should get chosen function response

No arguments. Will return funtion response

.do()

Is accessible only from object returned from .when method

.do()

Accept callback function which should be called if previous .when match arguments. Will respond with Condition Response

Debugger

For easy debug this library run your script with

DEBUG=Overloader <command to run>

License

MIT

FAQs

Package last updated on 02 Oct 2017

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc