Can i spread an Array of parameter names into a function declaration

I have an object which returns,

[
    {
        name:"getSpeed",
        params:["distance","time"]
    },
    {
        name:"getTime",
        params:["speed","distance"]
    },
    ...
]

This object is subject to change as it is gathered from an embedded device.

im trying to convert this into an object with callable functions i.e.

let myObj = {
    getSpeed: function(distance, time){
        /* do something (this is irrelevant) */
    },
    getTime: function(speed, distance){
        /* do something (again not relevant) */
    }

}

is there any way to map an array of strings to function parameters when mapping over an array?

>Solution :

According to your comments it appears you want to create functions from this definition which send commands with a function-call-like string which is evaled on the other side, and you don’t actually care about the paramater names but rather about the correct number of parameters.

I would therefore recommend something like this:

const myObj = Object.fromEntries(data.map(({ name, params }) => [
  name,
  (...args) => {
    if (args.length !== params.length) {
      throw new TypeError(`${name} expected ${params.length} arguments, got ${args.length}`)
    }
    
    this.UART.write(`${name}(${args.map(arg => JSON.stringify(arg)).join(',')})`)
  }
]))

This will work with all the datatypes that JSON supports, and will as a side effect also pass undefined as argument correctly.

Here is a runnable example with console.log instead of this.UART.write:

const data = [
    {
        name: "getSpeed",
        params: ["distance", "time"]
    },
    {
        name: "getTime",
        params: ["speed", "distance"]
    }
]


const myObj = Object.fromEntries(data.map(({ name, params }) => [
  name,
  (...args) => {
    if (args.length !== params.length) {
      throw new TypeError(`${name} expected ${params.length} arguments, got ${args.length}`)
    }

    console.log(`${name}(${args.map(arg => JSON.stringify(arg)).join(',')})`)
  }
]))

myObj.getSpeed(123, 456) // prints `getSpeed(123,456)`
myObj.getTime(123, 456) // prints `getTime(123,456)`
myObj.getTime("hello", true) // prints `getTime("hello",true)`
myObj.getTime(1) // throws `getTime expected 2 arguments, got 1`

However, as you said yourself, the whole eval business is not ideal anyway. I would recommend – if possible – to reconsider the protocol to use something more secure and robust like gRPC or, one layer below, protocol buffers. Given that you are using JavaScript on both ends, JSON-RPC could also be a nice solution.