Question

我想做这样的事情：

function createParam(value, key = 'params') {
    return [key]: {value: JSON.stringify(value) ,name: ''}
}

这样我就可以做这样的事情：

const param1 = createParam(someVaue);
const param2 = createParam(someOtherValue, someKey);
const parameter = {param1, param2}

我该如何做这样的事情？，目前我在function createParam上遇到问题，因为似乎不存在上述语法。
更新01：
某些答案提出了有效的解决方案，但仅是对其他阅读该问题的人进行了澄清，参数的预期输出为：

{key1: {value:'xx', name: ''},key2: {value:'xx', name: ''},key3: {value:'xx', name: ''},...}

Answer 1

您的预期行为是不可能的。但是您可以尝试以下

function createParam(value, key = 'params') {
    return {[key]: {value: JSON.stringify(value) ,name: ''}}
}

您可以使用ES6语法执行以下操作

const param1 = createParam(someVaue);
const param2 = createParam(someOtherValue, someKey);
const parameter = {...param1, ...param2}

或

const param1 = createParam(someVaue);
const param2 = createParam(someOtherValue, someKey);
const parameter = Object.assign({}, param1, param2);

function createParam(value, key = 'params') {
    return {[key]: {value: JSON.stringify(value) ,name: ''}}
}
let someValue = "someValue";
let someOtherValue = "someOtherValue";
let someKey = "key1";

const param1 = createParam(someValue);
const param2 = createParam(someOtherValue, someKey);
const parameter = {...param1, ...param2}
console.log(parameter);

const param3 = createParam(someValue);
const param4 = createParam(someOtherValue, someKey);
const parameter2 = Object.assign({}, param3, param4);
console.log(parameter2);

Answer 2

将每个参数作为一个适当的对象，然后将它们全部散布到一个新的对象中会更简单。

const param1 = { params: 'someValue' };
const param2 = { [key]: 'someOtherValue' };
const parameter = {...param1, ...param2 }

// paramter = { params: 'someValue', [key]: 'someOtherValue' }

Answer 3

您将需要仅使用参数创建临时对象，每个参数1个，然后将所有这些对象合并在一起。一种方法是使用spread operator

function createParam(value, key = 'params') {
    // added {} around the returns to return an object
    return {[key]: {value: JSON.stringify(value) ,name: ''}}
}

// create the params
const param1 = createParam(42);
console.log(param1)
const param2 = createParam(123, "key");
console.log(param2)

// merge the resultings objects using spread operator
const parameter = {...param1, ...param2}
console.log(parameter)

如果您在创建参数时有更多参数将它们添加到参数中，则可以防止在末尾添加一条大合并行

function createParam(value, key = 'params') {
    // added {} around the returns to return an object
    return {[key]: {value: JSON.stringify(value) ,name: ''}}
}

// create the parameter object
let parameter = {}

// merge each time you create a new param
parameter = {...parameter, ...createParam(42)}
parameter = {...parameter, ...createParam(123, "key")}
console.log(parameter)

Answer 4

您可以将基础对象传递给函数以映射自定义属性。像这样：

function mapProp( baseObject, customPropKey, value){
    return (baseObject[customPropKey] = value)
}

并致电：

var myObject = {a1:'a1value'};
console.log(myObject); //{a1:'a1value'}
var newObject = mapProp(myObject, 'a2', 'a2value');
console.log(newObject); //{a1:'a1value', a2:'a2Value'}

Answer 5

我相信您最好的选择是将属性直接设置到对象中。您可以：

将对象作为参数传递。

function createParam(obj, value, key = 'params') {
    obj[key] = {value: JSON.stringify(value) ,name: ''};
    return obj;
}
const parameter = {};
createParam(parameter, someValue);
createParam(parameter, someOtherValue, someKey);

从对象中调用该函数。

const parameter = {};
parameter.createParam = function(value, key = 'params') {
    this[key] = {value: JSON.stringify(value) ,name: ''};
    return this;
}
parameter.createParam(someValue);
parameter.createParam(someOtherValue, someKey);

创建一个类。

function Parameters() {
    this.createParam = function(value, key = 'params') {
        this[key] = {value: JSON.stringify(value) ,name: ''};
        return this;
    }
}
parameter = new Parameters();
parameter.createParam(someValue);
parameter.createParam(someOtherValue, someKey);

Answer 6

您可以像这样更新 createParam ：

function createParam(value, key = 'params') {
    return {[key]: {value: JSON.stringify(value) ,name: ''}}
}

现在，无论何时调用createParam函数。它将返回一个像这样的对象：

const param1 = createParam(someVaue); //{ someVaue: { value: someVaue, name: '' } }

如何返回JSON对象属性

6 个答案: