¿Cómo ignoro la carga inicial cuando veo cambios de modelo en AngularJS?

Tengo una página web que sirve como editor para una sola entidad, que se ubica como un gráfico profundo en la propiedad $ scope.fieldcontainer. Después de recibir una respuesta de mi API REST (a través de $ resource), agrego un reloj a 'fieldcontainer'. Estoy usando este reloj para detectar si la página / entidad está "sucia". En este momento estoy haciendo que el botón Guardar rebote, pero realmente quiero hacer que el botón Guardar sea invisible hasta que el usuario ensucie el modelo.

Lo que estoy obteniendo es un solo disparador del reloj, lo que creo que está sucediendo porque la asignación .fieldcontainer = ... se lleva a cabo inmediatamente después de crear mi reloj. Estaba pensando en usar una propiedad "dirtyCount" para absorber la falsa alarma inicial, pero eso se siente muy hacky ... y pensé que tenía que haber una manera "idiomática angular" para lidiar con esto: no soy el único usando un reloj para detectar un modelo sucio.

Aquí está el código donde configuré mi reloj:

 $scope.fieldcontainer = Message.get({id: $scope.entityId },
            function(message,headers) {
                $scope.$watch('fieldcontainer',
                    function() {
                        console.log("model is dirty.");
                        if ($scope.visibility.saveButton) {
                            $('#saveMessageButtonRow').effect("bounce", { times:5, direction: 'right' }, 300);
                        }
                    }, true);
            });

Solo sigo pensando que debe haber una forma más limpia de hacerlo que proteger mi código de "ensuciamiento de la interfaz de usuario" con un "if (dirtyCount> 0)" ...

establecer una bandera justo antes de la carga inicial,

var initializing = true

y luego, cuando se dispara el primer $ watch,

$scope.$watch('fieldcontainer', function() {
  if (initializing) {
    $timeout(function() { initializing = false; });
  } else {
    // do whatever you were going to do
  }
});

La bandera se derribará justo al final del ciclo de resumen actual, por lo que el próximo cambio no se bloqueará.

La primera vez que se llama al oyente, el valor antiguo y el nuevo valor serán idénticos. Entonces solo haz esto:

$scope.$watch('fieldcontainer', function(newValue, oldValue) {
  if (newValue !== oldValue) {
    // do whatever you were going to do
  }
});

Esta es realmente la forma en que los documentos de Angular recomiendan manejarlo :

Después de registrar un observador con el ámbito, se llama al oyente fn de forma asíncrona (a través de $ evalAsync) para inicializar el observador. En casos raros, esto no es deseable porque se llama al oyente cuando el resultado de watchExpression no cambió. Para detectar este escenario dentro del oyente fn, puede comparar newVal y oldVal. Si estos dos valores son idénticos (===), se llamó al oyente debido a la inicialización

Me doy cuenta de que esta pregunta ha sido respondida, sin embargo, tengo una sugerencia:

$scope.$watch('fieldcontainer', function (new_fieldcontainer, old_fieldcontainer) {
    if (typeof old_fieldcontainer === 'undefined') return;

    // Other code for handling changed object here.
});

El uso de banderas funciona pero tiene un poco de olor a código , ¿no le parece?

Durante la carga inicial de los valores actuales, el campo de valor antiguo no está definido. Entonces, el siguiente ejemplo lo ayuda a excluir las cargas iniciales.

$scope.$watch('fieldcontainer', 
  function(newValue, oldValue) {
    if (newValue && oldValue && newValue != oldValue) {
      // here what to do
    }
  }), true;

Solo valido el estado del nuevo val:

$scope.$watch('fieldcontainer',function(newVal) {
      if(angular.isDefined(newVal)){
          //Do something
      }
});