Como ignoro a carga inicial ao assistir alterações de modelo no AngularJS?

Eu tenho uma página da web que serve como editor de uma única entidade, que fica como um gráfico profundo na propriedade $ scope.fieldcontainer. Depois de receber uma resposta da minha API REST (via $ resource), adiciono um relógio ao 'fieldcontainer'. Estou usando este relógio para detectar se a página / entidade está "suja". No momento, estou fazendo o botão salvar saltar, mas realmente quero tornar o botão invisível até que o usuário direcione o modelo.

O que estou obtendo é um único gatilho do relógio, o que acho que está acontecendo porque a atribuição .fieldcontainer = ... ocorre imediatamente após a criação do relógio. Eu estava pensando em usar apenas uma propriedade "dirtyCount" para absorver o alarme falso inicial, mas isso parece muito hacky ... e achei que deveria haver uma maneira "angular idiomática" de lidar com isso - eu não sou o único usando um relógio para detectar um modelo sujo.

Aqui está o código em que eu ajusto meu relógio:

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

Eu continuo pensando que deve haver uma maneira mais limpa de fazer isso do que guardar meu código "UI dirtying" com um "if (dirtyCount> 0)" ...

defina um sinalizador imediatamente antes do carregamento inicial,

var initializing = true

e quando o primeiro $ watch for disparado, faça

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

A sinalização será removida no final do ciclo de resumo atual, para que a próxima alteração não seja bloqueada.

Na primeira vez que o ouvinte é chamado, o valor antigo e o novo valor serão idênticos. Então, faça o seguinte:

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

Essa é realmente a maneira que os documentos do Angular recomendam :

Depois que um observador é registrado com o escopo, o ouvinte fn é chamado de forma assíncrona (via $ evalAsync) para inicializar o observador. Em casos raros, isso é indesejável porque o ouvinte é chamado quando o resultado da watchExpression não foi alterado. Para detectar esse cenário no ouvinte fn, você pode comparar o newVal e o oldVal. Se esses dois valores forem idênticos (===), o ouvinte foi chamado devido à inicialização

Sei que esta pergunta foi respondida, no entanto, tenho uma sugestão:

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

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

O uso de flags funciona, mas tem um pouco de cheiro de código , você não acha?

Durante o carregamento inicial dos valores atuais, o campo de valor antigo é indefinido. Portanto, o exemplo abaixo ajuda você a excluir carregamentos iniciais.

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

Apenas valide o estado do novo valor:

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