Obtenga el valor anterior de un observable en la suscripción del mismo observable

¿Es posible en el nocaut obtener el valor actual de un observable dentro de una suscripción a ese observable, antes de que reciba el nuevo valor?

Ejemplo:

this.myObservable = ko.observable();
this.myObservable.subscribe(function(newValue){
    //I'd like to get the previous value of 'myObservable' here before it's set to newValue
});

Hay una forma de suscribirse al valor anterior como este:

this.myObservable = ko.observable();
this.myObservable.subscribe(function(previousValue){
    //I'd like to get the previous value of 'myObservable' here before it's set to newValue
}, this, "beforeChange");

ko.subscribable.fn.subscribeChanged = function (callback) {
    var oldValue;
    this.subscribe(function (_oldValue) {
        oldValue = _oldValue;
    }, this, 'beforeChange');

    this.subscribe(function (newValue) {
        callback(newValue, oldValue);
    });
};

Utilice lo anterior así:

MyViewModel.MyObservableProperty.subscribeChanged(function (newValue, oldValue) {

});

Pequeños cambios en la respuesta de Beagle90. Devuelva siempre la propia suscripción para poder acceder a dispose (), por ejemplo.

ko.subscribable.fn.subscribeChanged = function (callback) {
    var oldValue;
    this.subscribe(function (_oldValue) {
        oldValue = _oldValue;
    }, this, 'beforeChange');

    var subscription = this.subscribe(function (newValue) {
        callback(newValue, oldValue);
    });

    // always return subscription
    return subscription;
};

La solicitud de extracción para agregar esta función tiene un código diferente que termina siendo mejor que confiar en el uso del beforeChangeevento.

Todo el mérito de la solución a Michael Best

ko.subscribable.fn.subscribeChanged = function (callback) {
    var savedValue = this.peek();
    return this.subscribe(function (latestValue) {
        var oldValue = savedValue;
        savedValue = latestValue;
        callback(latestValue, oldValue);
    });
};

Para citar a Michael:

Originalmente sugerí usarlo beforeChangepara resolver este problema, pero desde entonces me he dado cuenta de que no siempre es confiable (por ejemplo, si llama valueHasMutated()al observable).

Descubrí que puedo llamar a peek () desde un observable calculado que se puede escribir para obtener el valor anterior.

Algo como esto (consulte http://jsfiddle.net/4MUWp ):

var enclosedObservable = ko.observable();
this.myObservable = ko.computed({
    read: enclosedObservable,
    write: function (newValue) {
        var oldValue = enclosedObservable.peek();
        alert(oldValue);
        enclosedObservable(newValue);
    }
});