Nurturing Palpable Magnificence


    1.0.1 • Public • Published


    The best library to parse a function into its parameter names.

    Created because of dissatisfaction with existing npm libraries:

    Advantages of this library over others:

    • Extremely easy user-side syntax
    • Support for object and Array decomposers passed as function parameters
    • Low package size
    • Intuitive return result
    • Attractive and readable code
    • Runs synchronously and fast
    • Uses the latest ECMAScript 6 specifications

    Maintained by theLAZYmd, please report any issues found.


    Parameter grabbing:

    Let's say all your data is stored in a big data object (let's call that data message). Let's say you have an event listener that routes you to a particular function depending on what the event is. That function now takes specific pieces of information in order to work, let's say:

    function onNewMessage(content, member) {}

    where the content and member properties you need to grab are properties of message.

    Now what you could do is write a deconstructor into each of your functions, like:

    function onNewMessage({content, member}) {}

    but that might get annoying if you're not used to it and you might have to change all your previous work and so on. Plus, some people are stylistically opposed to such things

    So what you can do instead, is tell node to find the parameters you need from the function, grab those, and send them in the function call, without ever specifically hard-coding them. For instance:

    let params = getParamNames(onToxicUsers);
    let args = => data[p]);

    and voilà! You've parsed the arguments to the function without ever knowing what they were. This allows you to create a universal system for all your function calls.

    Example Usages


    Use npm install get-param-names to download the package to your workspace. Then write the following at the top of any file that you wish to use the module:

    const getParamNames = require('get-param-names');

    and simply use the constant as a function wherever needed. Returns an array of parameter names, as specified in the function definition.

    Example 1

    Simple named function
    function f0(self, meme, init) {
        return [self, meme, init];
    console.log(getParamNames(f0)); // ["self", "meme", "init"]

    Example 2

    Simple named function with default parameters
    function f1(str = 'hello', arr = ['what\'s up']) {
        return [str, arr];
    console.log(getParamNames(f1)); // ["str", "arr"]

    Example 3

    Simple arrow function with string parameters
    let f2 = (meme, param) => [meme, param];
    console.log(getParamNames(f2)); // ["meme", "param"]

    Example 4

    Function with deconstructed Object parameter
    async function f3(ids, {
        fetch = false,
        filter = user => user,
        arr = []
    } = {}) {
        return [ids, fetch, filter.toString(), arr];
    console.log(getParamNames(f3)); // [ 'ids', { fetch: false, filter: 'user => user', arr: [] } ]

    Example 5

    Complex function with deconstructed Object parameter, deconstructed Array parameter, and default Object and Array values
    async function f4({
        item2 = {
            prop1: true,
            prop2: false,
            prop3: ['array', 'of', 'strings']
    } = {}, [item3, item4, [item5, item6]]) {
        return [item1, item2, item3, item4, item5, item6];
    console.log(getParamNames(f4)); //[{"item2":{"prop1":true,"prop2":false,"prop3":["array","of","strings"]}},["item3","item4",["item5","item6"]]]


    npm i get-param-names

    DownloadsWeekly Downloads






    Unpacked Size

    46.5 kB

    Total Files


    Last publish


    • lazycst