Obtenha o valor anterior de um observável em subscrever o mesmo observável

É possível obter no knockout o valor atual de um observável dentro de uma assinatura desse observável, antes de receber o novo valor?

Exemplo:

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

Existe uma maneira de fazer uma assinatura do valor before desta forma:

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

Use o acima assim:

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

});

Uma pequena mudança na resposta do Beagle90. Sempre retorne a própria assinatura para poder acessar o dispose (), por exemplo.

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

A solicitação pull para adicionar esse recurso tem algum código diferente que acaba sendo melhor do que depender do uso do beforeChangeevento.

Todo o crédito pela solução para 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 Michael:

Originalmente, sugeri usar beforeChangepara resolver esse problema, mas desde então percebi que nem sempre é confiável (por exemplo, se você chamar valueHasMutated()o observável).

Descobri que posso chamar peek () de um observável computado gravável para obter o valor anterior.

Algo assim (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);
    }
});