Ottieni il valore precedente di un osservabile nella sottoscrizione dello stesso osservabile

È possibile in knockout ottenere il valore corrente di un osservabile all'interno di una sottoscrizione a quell'osservabile, prima che riceva il nuovo valore?

Esempio:

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
});

C'è un modo per fare un abbonamento al valore prima in questo modo:

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);
    });
};

Usa quanto sopra in questo modo:

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

});

Piccola modifica alla risposta Beagle90. Restituisci sempre l'abbonamento stesso per poter accedere a dispose (), ad esempio.

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 richiesta pull per aggiungere questa funzionalità ha un codice diverso che finisce per essere migliore rispetto all'utilizzo beforeChangedell'evento.

Tutto il merito per la soluzione 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);
    });
};

Per citare Michael:

Inizialmente ho suggerito di utilizzare beforeChangeper risolvere questo problema, ma da allora ho capito che non è sempre affidabile (ad esempio, se chiami valueHasMutated()l'osservabile).

Ho scoperto che posso chiamare peek () da un osservabile calcolato scrivibile per ottenere il valore precedente.

Qualcosa di simile (vedi 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);
    }
});