JavaScript对象：这个repl测试在寻找什么？

我正在用JavaScript开发自定义函数中的一些对象

我写了一段代码如下：

function updateObject(obj) {
    var obj = {
        foo: 'foo',
        bar: 'bar',
        bizz: 'bizz',
        bang: 'bang'
    };

    return obj;
}

console.log(updateObject());

我知道这没有错，因为它在控制台中输出了一个带有key:value对的对象，但它没有通过Repl:

/* test suite */
(function testUpdateObject() {
  var oldObj = {
    cats: 'cats',
    dogs: 'dogs',
  };
  var newObj = updateObject(oldObj);
  if (typeof newObj !== 'object') {
    console.error('ERROR: `createMyObject` must return an object');
    return false
  }
  ['foo', 'bar', 'bizz', 'bang'].forEach(function(key) {
    if (!(key in newObj)) {
      console.error('ERROR: `' + key + '` not in object returned by `updateObject`');
      return false;
    }
  });
  ['foo', 'bar', 'bizz', 'bang'].forEach(function(key) {
    if (newObj[key] !== key) {
      console.error('ERROR: `' + key + '` should be "' + key + '" but was ' + newObj[key]);
      return false;
    }
  });
  if (!(newObj.cats === 'cats' && newObj.dogs === 'dogs')) {
    console.error('ERROR: your function doesn\'t preserve existing key/value pairs');
    return false;
  }
  console.log('SUCCESS: `updateObject` works correctly!');

})();

具体来说，该函数无法保留现有的键/值对。这就是我试图解决的问题

我还尝试了点符号和方括号符号，如下所示：

function updateObject(obj) {
    var obj = {};
    {
      obj.foo ='foo',
        obj.bar ='bar',
        obj.bizz ='bizz',
        obj.bang ='bang'
    }
    return obj;
}

及

这两种情况都是

console.log（updateObject（））

我不知道如何用对象编写这个自定义函数，这个对象将通过测试，它保留键/值对，我正在寻找一些关于如何解决这个问题的指导

我找不到一篇直接针对这种情况的堆栈溢出文章，也找不到任何在线文档说明如何编写保留现有键/值对的函数。
只是不要覆盖您的参数

function updateObject(obj) {
      obj['foo'] ='foo';
        obj['bar'] ='bar';
        obj['bizz']  ='bizz';
        obj['bang']  ='bang';
    return obj;
}

您永远不会更新对象，因为您将新对象指定给给定的变量/参数。您需要保留数组并逐步分配值，或者使用ES6


函数更新对象（obj）{
obj=obj |{}；
obj.foo='foo'；
obj.bar=‘bar’；
obj.bizz='bizz'；
obj.bang=‘bang’；
返回obj；
}
log（updateObject（））；
（函数testUpdateObject（）{
var oldObj={
猫：“猫”，
狗：“狗”，
};
var newObj=更新对象（oldObj）；
if（newObj的类型！=='object'）{
error（'error:`createMyObject`必须返回一个对象'）；
返回错误
}
['foo'，'bar'，'bizz'，'bang'].forEach（函数（键）{
如果（！（输入新对象））{
console.error（'error:'+key+'不在`updateObject`'返回的对象中）；
返回false；
}
});
['foo'，'bar'，'bizz'，'bang'].forEach（函数（键）{
if（newObj[键]！==键）{
错误（'error:'+key+'应该是'+key+'，但是是'+newObj[key]）；
返回false；
}
});
如果（！（newObj.cats=='cats'&&newObj.dogs=='dogs'））{
error（'错误：您的函数不保留现有的键/值对'）；
返回false；
}
log（'SUCCESS:`updateObject`工作正常！'）；
})();当你说“var obj”时，你正在重新定义obj。删除下面的变量更新代码

function updateObject(obj) {
    var newObj = {
        foo: 'foo',
        bar: 'bar',
        bizz: 'bizz',
        bang: 'bang'
    };

    // Apply all props of newObj to oldObj, while preserving oldObj
    return Object.assign(obj, newObj);
}

请注意，如果要更新原始对象，更改它就足够了。从技术上讲，您不必返回更新后的对象（当您将其传递到函数中时，引用将保留），但无论如何，这可能是一种很好的做法

if (!(newObj.cats === 'cats' && newObj.dogs === 'dogs')) {
    console.error('ERROR: your function doesn\'t preserve existing key/value pairs');
    return false;
  }

所以问题是您不保留现有的键/值对

因为您使用var重新定义了obj，而不是向其添加新属性，所以您将覆盖所有旧的对

因此，正确的方法是编辑输入的对象，而不是重新定义它。您可以手动添加它们：

function updateObject(obj) {
    obj.foo = 'foo';
    obj.bar = 'bar';
    obj.bizz = 'bizz';
    obj.bang = 'bang';
    return obj;
}

或者，如果浏览器支持，可以使用相对较新的
Object.assign（）
方法将两个对象合并到一起：

function updateObject(obj) {
    var extension = {
        foo: 'foo',
        bar: 'bar',
        bizz: 'bizz',
        bang: 'bang'
    };
    return Object.assign( obj, extension );
}

function updateObject(obj) {
    var extension = {
        foo: 'foo',
        bar: 'bar',
        bizz: 'bizz',
        bang: 'bang'
    };
    return Object.assign( obj, extension );
}