最后，我用几个方法扩充了Backbone.Collection来处理这个问题。
saveChangeMethod创建了一个要传递给Backbone. sync的虚拟模型。所有 Backbone 网的sync方法都需要来自模型的url属性和toJSON方法，因此我们可以轻松地实现这一点。
在内部，模型的toJSON方法只返回其属性的副本（发送到服务器），因此我们可以使用toJSON方法，只返回模型数组。Backbone.sync将其字符串化，只提供属性数据。
成功时，saveChanged会在要处理的集合上触发一次事件。我已经插入了一些代码，让它为在任何批处理模型中更改的每个属性触发一次特定事件。

Backbone.Collection.prototype.saveChanged = function () {
    var me = this,
        changed = me.getChanged(),
        dummy = {
            url: this.url,
            toJSON: function () {
                return changed.models;
            }
        },
        options = {
            success: function (model, resp, xhr) {
                for (var i = 0; i < changed.models.length; i++) {
                    changed.models[i].chnageSilently();
                }
                for (var attr in changed.attributes) {
                    me.trigger("batchchange:" + attr);
                }
                me.trigger("batchsync", changed);
            }
        };
    return Backbone.sync("update", dummy, options);
}

然后，我们只需要对集合使用getChanged（）方法，它返回一个具有2个属性的对象，一个包含已更改模型的数组，以及一个标记哪些属性已更改的对象：

Backbone.Collection.prototype.getChanged = function () {
    var models = [],
        changedAttributes = {};
    for (var i = 0; i < this.models.length; i++) {
        if (this.models[i].hasChanged()) {
            _.extend(changedAttributes, this.models[i].changedAttributes());
            models.push(this.models[i]);
        }
    }
    return models.length ? {models: models, attributes: changedAttributes} : null;
}

虽然这是对 Backbone.js “更改模型”范例的轻微滥用，但批处理的全部意义在于，当模型更改时，我们不希望发生任何事情（即，任何事件触发）。
我们因此不得不通过{沉默：true}添加到模型的set（）方法中，所以使用backbone的hasChanged（）来标记等待保存的模型是有意义的。当然，如果您出于其他目的而静默地更改模型，这将是有问题的- collection.saveChanged（）也会保存这些模型，因此值得考虑设置一个替代标记。
在任何情况下，如果我们这样做，在保存时，我们需要确保 Backbone.js 现在认为模型没有改变（而不触发它们的change事件），所以我们需要手动操作模型，就好像它没有被更改一样。（）方法在我们更改的模型上迭代，并无声地调用此change（）方法，这基本上就是Backbone的模型。change（）方法没有触发器：

Backbone.Model.prototype.changeSilently = function () {
    var options = {},
    changing = this._changing;
    this._changing = true;
    for (var attr in this._silent) this._pending[attr] = true;
    this._silent = {};
    if (changing) return this;

    while (!_.isEmpty(this._pending)) {
        this._pending = {};
        for (var attr in this.changed) {
        if (this._pending[attr] || this._silent[attr]) continue;
        delete this.changed[attr];
        }
        this._previousAttributes = _.clone(this.attributes);
    }
    this._changing = false;
    return this;
}

用法：

model1.set({key: value}, {silent: true});
model2.set({key: value}, {silent: true});
model3.set({key: value}, {silent: true});
collection.saveChanged();

RE. RESTfulness..对集合的端点执行PUT来更改其中的“一些”记录是不太正确的。从技术上讲，PUT应该替换整个集合，尽管在我的应用程序真正需要替换整个集合之前，我很乐意采取实用的方法。

您可以定义一个新的 resource 来完成这种行为，您可以将其称为MyModelBatch。
您需要在服务器端实现一个新的资源，它能够处理Array的模型并执行适当的操作：CREATE、UPDATE和DESTROY中的一个或多个。
此外，您还需要在您的 Backbone 客户端中实现一个Model，该Model具有一个 * 属性 *（即模型数组）和一个特殊的url，该url不使用id。
关于 * 重新渲染 * 的事情，我建议你尝试每个模型都有一个视图，这样当模型发生变化时，就会有同样多的 * 渲染 *，但它们将是没有重复的细节 * 重新渲染 *。

这是我想出来的

Backbone.Collection.extend({
    saveAll: function(models, key, val, options) {

        var attrs, xhr, wait, that = this;

        var transport = {
            url: this.url,
            models: [],
            toJSON: function () {
                return { models: this.models };
            },
            trigger: function(){
                return that.trigger.apply(that, arguments);
            }
        };

        if(models == null){
            models = this.models;
        }

        // Handle both `"key", value` and `{key: value}` -style arguments.
        if (key == null || typeof key === 'object') {
            attrs = key;
            options = val;
        } else {
            (attrs = {})[key] = val;
        }

        options = _.extend({validate: true}, options);
        wait = options.wait;

        // After a successful server-side save, the client is (optionally)
        // updated with the server-side state.
        if (options.parse === void 0) options.parse = true;

        var triggers = [];

        _.each(models, function(model){

            var attributes = model.attributes;

            // If we're not waiting and attributes exist, save acts as
            // `set(attr).save(null, opts)` with validation. Otherwise, check if
            // the model will be valid when the attributes, if any, are set.
            if (attrs && !wait) {
                if (!model.set(attrs, options)) return false;
            } else {
                if (!model._validate(attrs, options)) return false;
            }

            // Set temporary attributes if `{wait: true}`.
            if (attrs && wait) {
                model.attributes = _.extend({}, attributes, attrs);
            }

            transport.models.push(model.toJSON());

            triggers.push(function(resp){
                if(resp.errors){
                    model.trigger('error', model, resp, options);
                } else {
                    // Ensure attributes are restored during synchronous saves.
                    model.attributes = attributes;
                    var serverAttrs = options.parse ? model.parse(resp, options) : resp;
                    if (wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
                    if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
                        return false;
                    }
                    model.trigger('sync', model, resp, options);
                }
            });

            // Restore attributes.
            if (attrs && wait) model.attributes = attributes;
        });

        var success = options.success;
        options.success = function(resp) {
            _.each(triggers, function(trigger, i){
                trigger.call(options.context, resp[i]);
            });
            if (success) success.call(options.context, models, resp, options);
        };
        return this.sync('create', transport, options);
    }
});