Javascript 对“大”进行小改动；选项“；数据结构

我将一个大的“options”对象传递给另一组用JavaScript实例化的对象。问题是，这些“选项”中的极少数必须在不同的对象之间改变。做一个完全独立的选项变量，改变了许多选项中的一个，感觉很傻。我也不认为我可以仅仅更改同一个“options”对象上的选项，因为所有对象都将引用相同的“options”

以下是相关代码

    for (var i = 0; i < invoices.length; i++) {

        var ura_original_column = { "column" : "ura_ppa_original",
                                    "on_update" : [format_ura],
                                    "display" : "URA" };

        if (invoices[i]["type"] == "P") {
            ura_original_column = { "column" : "ura_original",
                                    "on_update" : [format_ura],
                                    "display" : "URA" };
        }

        var options = { template_table  : "template_table",
                        template_total  : "template_total",
                        template_row    : "template_row",
                        template_text   : "template_text",
                        template_select : "template_select",
                        packet_id       : <?val=packet["packet_id"]?>,
                        products        : <?val=json.dumps(products)?>,
                        allow_new_rows  : <?val=json.dumps(packet["status"] not in api.NON_MODIFIABLE_STATUS)?>, 
                        on_table_focus  : on_table_focus,
                        on_row_update   : on_row_update,
                        on_new_row      : on_new_row,
                        columns : [{"column" : "product_code", 
                                    "display" : "Product"},
                                   {"column" : "transaction_type",
                                    "display" : "FFSU/MCOU",
                                    "editor" : "selectedit",
                                    "options" : ["FFSU", "MCOU"]},
                                    ura_original_column,
                                   {"column" : "ura_current",
                                    "display" : "Calculated URA"},
                                   {"column" : "units_current",
                                    "display" : "Current Units",
                                    "on_update" : [format_units],
                                    "show_total" : true},
                                   {"column" : "amount_claimed", 
                                    "display" : "Amt Claimed",
                                    "on_update" : [format_currency],
                                    "show_total" : true},
                                   {"column" : "scripts_current",
                                    "display" : "Scripts",
                                    "on_update" : [format_scripts],
                                    "show_total" : true},
                                   {"column" : "amount_medi_reimbursed", 
                                    "display" : "MEDI Amt", 
                                    "on_update" : [format_currency],
                                    "show_total" : true},
                                   {"column" : "amount_non_medi_reimbursed", 
                                    "display" : "Non-MEDI Amt", 
                                    "on_update" : [format_currency],
                                    "show_total" : true},
                                   {"column" : "amount_total_reimbursed", 
                                    "display" : "Total Amt", 
                                    "on_update" : [format_currency],
                                    "show_total" : true}]}

        var invoice_id = invoices[i]['invoice_id'];
        var transactions = transactions_by_invoice[invoice_id];
        var table = new Table.Table("invoice_" + invoice_id, options, transactions);

        tables.push(table);
    }
});

for（变量i=0；i

因此，在这个庞大的期权结构中，只有“ura_original_column”发生了变化。这可能是最好的方法，但感觉有点像黑客

有人有更优雅的建议吗

感谢您花时间查看。

您可以使用“新建”创建一个新对象，该对象仅具有不同的选项，但由一个包含所有其他选项的原型支持。（这是一项ES5功能，但您可以创建一个提供主要功能的版本，或在“ES5 shim”项目上使用，包括您需要的位；不可能完全创建

对象。在ES5之前的环境中创建
，但您不需要全部。）

看起来是这样的：

var mainOptions = { /* ...bit list of main options... */ };

for (index = 0; index < limit; ++index) {
    theseOptions = Object.create(mainOptions);
    theseOptions.column = "new column name";
    doTheThing(theseOptions);
}

var mainpoptions={/*…主选项的位列表…*/}；
对于（索引=0；索引<限制；++索引）{
theseOptions=Object.create（主选项）；
theseOptions.column=“新列名”；
doTheThing（这些选项）；
}

最终得到的是一个对象，该对象只具有您更改的属性，但如果请求提供任何其他属性，它将从主选项原型返回值

这里有一个这样做的独立示例：|

（函数（）{
//获取一个“create”函数，其行为有点像
//`Object.create`即使`Object.create`不是
//那里
var objectCreate=（函数（）{
if（Object.create）{
返回Object.create；
}
函数ctor（）{}
返回函数（proto）{
var-rv，键；
ctor.prototype=proto；
rv=新的ctor（）；
ctor.prototype=未定义；
返回rv；
};
})();
var main选项={
选项1：“主选项1”，
选项2：“主选项2”，
选项3：“主选项3”
};
var指数；
var期权；
对于（索引=0；索引<4；++索引）{
这些选项=对象创建（主选项）；
theseOptions.option2=“索引的特殊选项2”+索引；
显示选项（索引、选项）；
}
显示（“传递给函数的选项”）；
功能显示选项
(function() {

  // Get a `create` function that acts a bit like
  // `Object.create` even if `Object.create` isn't
  // there
  var objectCreate = (function() {
    if (Object.create) {
      return Object.create;
    }

    function ctor() { }

    return function(proto) {
      var rv, key;

      ctor.prototype = proto;
      rv = new ctor();
      ctor.prototype = undefined;

      return rv;
    };
  })();


  var mainOptions = {
    option1: "Main option 1",
    option2: "Main option 2",
    option3: "Main option 3"
  };

  var index;
  var theseOptions;

  for (index = 0; index < 4; ++index) {
    theseOptions = objectCreate(mainOptions);
    theseOptions.option2 = "Special option 2 for index " + index;

    displayOptions(index, theseOptions);
  }
  display("Options passed to function");

  function displayOptions(index, options) {
    // Do it *later* so we know we weren't just
    // doing it before the object got updated
    setTimeout(function() {
      display("Options for index " + index + ":");
      display(options.option1);
      display(options.option2);
      display(options.option3);
    }, 0);
  }

  function display(msg) {
    var p = document.createElement('p');
    p.innerHTML = String(msg);
    document.body.appendChild(p);
  }
})();