Question

假设我有以下对象：

let obj={
    childone: (value) => {
        return value+1;
    },
    childtwo: (value) => {
        return value+3;
    },
    childsingle: (value) => {
        return value+1;
    }
};

在同一声明中，是否有任何方法可以将obj.childsingle设置为等于obj.childone？

我正在尝试在对象声明中实现childsingle=childone。

我还尝试根据重复的建议答案使用get。

但是，使用此功能后：

let obj = {
    childone: (value) => {
        return value+1;
    },
    childtwo: (value) => {
        return value+3;
    },
    get childsingle() {
        return this.childone;
    }
};

我得到handleError TypeError: childsingle is not a function。

Answer 1

您可以使用getter方法进行childsingle声明。示例如下所示。

在其中，即使您更新childone，childsingle仍将始终指向最新的childone。当您致电childone时，它将始终返回childone。 >

有关更多信息，请参见Defining getters and setters Section

let obj = {
    childone: (value) => {
        return value+1;
    },
    childtwo: (value) => {
        return value+3;
    },
    get childsingle() {
        return this.childone;
    }
};

console.log(obj.childsingle(10));

Answer 2

避免的原因是什么

let obj = {
    childone: (value) => {
        return value + 1;
    },
    childtwo: (value) => {
        return value + 3;
    },
    childsingle: (value) => {
        return obj.childone(value);
    }
};

它提供：

console.log(obj.childone(1)); // 2
console.log(obj.childsingle(2)); // 3

在更高级的场景中，词法作用域也保持诚实：

function getObj() {
    const obj = {
        childone: (value) => {
            return value + 1;
        },
        childtwo: (value) => {
            return value + 3;
        },
        childsingle: (value) => {
            return obj.childone(value);
        }
    };

    return obj;
}

const example = getObj();

console.log(example.childone(1));
console.log(example.childsingle(2));

Answer 3

您可能会想到这样的东西：

let obj={
    childone: (value) => {
        return value+1;
    },
    childtwo: (value) => {
        return value+3;
    },
    childsingle: obj.childone
    }
};

但这不起作用。您必须分两个步骤进行操作。

赋值运算符（=）的工作方式如下。它使用运算符的右侧，计算其值，然后将该值（在您的情况下是对对象的引用）分配给左侧的变量。

因此，在分配赋值运算符的右侧时，obj变量不存在。所以你会得到一个错误。

这也不起作用

let obj={
    childone: (value) => {
        return value+1;
    },
    childtwo: (value) => {
        return value+3;
    },
    childsingle: this.childone
    }
};

因为this不会引用当前对象。

这将不起作用，因为未定义childone

let obj={
    childone: (value) => {
        return value+1;
    },
    childtwo: (value) => {
        return value+3;
    },
    childsingle: childone
    }
};

这是要走的路：

let obj={
    childone: (value) => {
        return value+1;
    },
    childtwo: (value) => {
        return value+3;
    },
};
obj.childsingle = obj.childone;

但是请注意，如果您打算更改childone函数并且认为childsingle函数也将发生变化，那是不正确的。

在更改childone之前，我们有两个对象的键（childone和childsingle），它们分别引用相同的功能。但是childone和childsingle并没有其他关系。如果您更改chilone，则将引用新功能，而childsingle将保留相同的旧功能

如何设置一个对象函数等于另一个

3 个答案: