Utilize extenders:

ko.extenders.trackChange = function (target, track) {
    if (track) {
        target.isModified = ko.observable(false);
        target.originalValue = target();
        target.setOriginalValue = function(startingValue) {
            target.originalValue = startingValue; 
        };
        target.subscribe(function (newValue) {
            // Use != instead of !== to compare numbers naturally
            target.isModified(newValue != target.originalValue);
        });
    }
    return target;
};

Next:

self.MyProperty= ko.observable("Property Value").extend({ trackChange: true });

Now you can check like this:

self.MyProperty.isModified()

You can also create a generic viewModel traversal to detect any changes:

self.hasModifications = ko.computed(function () {
    for (key in self) {
        if (self.hasOwnProperty(key) && ko.isObservable(self[key]) && typeof self[key].isModified === 'function' && self[key].isModified()) {
            return true;
        }
    }
});

... and then simply verify at the level of the viewModel

self.hasModifications()

If you want to track specific properties, you can subscribe to them for monitoring:

myViewModel.personName.subscribe(function(newValue) {
    alert("The person's new name is " + newValue); 
});

This will trigger an alert whenever the personName property changes.

Now, if you're looking to monitor any change in your model...

var viewModel = … // define your viewModel

var changeLog = new Array();  

function catchChanges(property, value){
    changeLog.push({property: property, value: value});
    viewModel.isDirty = true;
}

function initialiseViewModel()
{
    // iterate through all properties in the model
    for (var property in viewModel) {

        if (viewModel.hasOwnProperty(property)) { 

            // check if they are observable
            if(viewModel[property].subscribe){

                // subscribe to changes
                viewModel[property].subscribe(function(value) {
                    catchChanges(property, value);
                });
            }
        }
    }
    viewModel.isDirty = false;
}

function resetViewModel() {
    changeLog = new Array();  
    viewModel.isDirty = false;
}

(This code snippet has not been tested yet, but should give you a good grasp of the concept)

Have you considered using the Knockout-Validation plugin for your project?

This plugin offers features such as:

Check if a user has modified a property with yourProperty.isModified()

Compare the current value to the original value with yourProperty.originalValue

It also includes other helpful validation tools that can be quite useful!

Cheers!

If you're looking to track changes within a viewModel, consider using the plugin provided below:

https://github.com/ZiadJ/knockoutjs-reactor

The following code example demonstrates how you can monitor all changes in any given viewModel:

ko.watch(someViewModel, { depth: -1 }, function(parents, child) { 
    alert('New value is: ' + child());
});

Please note that at present, this functionality does not support subscribables nested within an array. However, an updated version with this capability is currently in development.

Update: The code snippet has been enhanced to be compatible with v1.2b, which now includes support for array elements and properties containing subscribable values.

Encountering a similar issue, I found myself in need of monitoring any changes to the viewModel to send data back to the server. For those still interested, after some research, I have put together what I believe to be the most effective solution:

function GlobalObserver(viewModel, callback) {  
    var self = this;
    viewModel.allChangesObserver = ko.computed(function() {
        self.viewModelRaw = ko.mapping.toJS(viewModel);
    });
    viewModel.allChangesObserver.subscribe(function() {
        callback(self.viewModelRaw);
    });
    self.dispose = function() {
        if (viewModel.allChangesObserver)
            viewModel.allChangesObserver.dispose();
        delete viewModel.allChangesObserver;
    };
};

To utilize this 'global observer':

function updateEntireViewModel() {
    var rawViewModel = Ajax_GetItemEntity(); //retrieve the JSON object..    
    //insert validation code here to ensure entity correctness.
    if (koGlobalObserver)
        koGlobalObserver.dispose(); //If already observing the older ViewModel, stop doing so!
    var viewModel = ko.mapping.fromJS(rawViewModel);        
    koGlobalObserver = new GlobalObserver(viewModel, Ajax_Submit);
    ko.applyBindings(viewModel [ ,optional DOM element]);   
}

Keep in mind that the provided callback (in this case 'Ajax_Submit') will trigger on ANY changes made to the view model; therefore, implementing a delay mechanism before sending the entity is highly recommended to ensure user edits completion:

var _entitiesUpdateTimers = {};

function Ajax_Submit(entity) { 
    var key = entity.ID; //or any other unique identifier relevant to the current view model..
    if (typeof _entitiesUpdateTimers[key] !== 'undefined')
        clearTimeout(_entitiesUpdateTimers[key]);    
    _entitiesUpdateTimers[key] = 
        setTimeout(function() { SendEntityFunction(entity); }, 500);           
}

I am relatively new to JavaScript and the knockout framework – having just started working with it recently. Thus, please forgive any mistakes on my part. (-:

I hope this information proves useful!

After studying @Brett Green's code, I decided to enhance and customize it for our needs. By introducing AcceptChanges functionality and improving the way models are tracked, we were able to make the model cleaner and more efficient. Take a look at the modified code below:

var customModel = {
    title: ko.observable(),
    description: ko.observable()
};

ko.track(customModel);

http://jsfiddle.net/example_user/2XJZ8/

My approach involved capturing the initial state of the view model upon page load and then later comparing it to the current state without considering which specific properties had changed.

Here's how I captured the initial state:

var originalViewModel = JSON.stringify(ko.toJS(viewModel));

And here's how I compared it later:

if(originalViewModel != JSON.stringify(ko.toJS(viewModel))){
    // A change has occurred, but the exact details are unknown
}

Let's discuss a view model structure below

function myViewModel(){
    var ref = this;
    ref.Name = ko.observable();
    ref.OldState = ko.observable();
    ref.NewState = ko.observable();

    ref.changeCalculations - ko.computed(function(){
    // Action triggers upon observable state change.
});
}

Once your data is bound, you can save the state using function ko.toJS(myViewModel).

myViewModel.Name("test");
myViewModel.OldState(ko.toJS(myViewModel));

You may introduce a computed observable variable within the view model like so

ref.changeCalculations = ko.computed(function () {});

This computation will activate upon any changes to other observables inside the view model.

You are able to compare both states of the view model as shown below:

ref.changeCalculations = ko.computed(function () {
  ref.NewState(ref);

  // Compare old state with new state
  if(ref.OldState().Name == ref.NewState().Name()){
       // View model states match.
  }
  else{
      // View model states differ.
  }

});

**Please note: This computed observable piece also runs when initializing the view model for the first time. **

We trust this information will be beneficial! Best regards!

Great solution proposed by Brett Green! It was noted that the isDirty comparison doesn't function correctly with Date objects. My approach to solving this issue involved extending the subscribe method in the following way:

    observable.subscribe(function (newValue) {
            observable.isDirty(newValue != observable.originalValue);

            if (newValue instanceof Date) {
                observable.isDirty(newValue.getTime() != observable.originalValue.getTime());
            }
        });