Orologio $ angolare | restituzione del prodotto da funzioni

Question

Sono interessato a scoprire il motivo per cui ho sempre fare questo

$scope.$watch(function() { 
    return $scope.someData; 
}, function(value) { 
    console.log(value); 
}); 

per angolare per guardare effettivamente i dati, perché devo fare questo, questo è una delle cose mi fa davvero schifo perché sembra inutile.

Se faccio qualcosa di simile

$scope.$watch($scope.someData, function(value) { 
    console.log(value); 
}); 

Il che è più bello, non funziona mai?

Io uso anche questo un sacco con le fabbriche

dire che $data è una fabbrica che devo fare

$scope.$watch(function() { 
    return $data.someData; 
}, function(value) { 
    console.log(value); 
}); 

Answer 1

Questo funziona:

$scope.$watch("someData", function(value) { 
    console.log(value); 
}); 

Answer 2

Con una fabbrica, è necessario guardare una funzione perché se si passa una stringa, Angular la valuterà come un'espressione contro $ scope. Poiché $ data.someData non è definito su $ scope, non funzionerà.

di approfondire @ commento di Codezilla, è possibile assegnare i dati di fabbrica di alcune proprietà $ portata, e poi guardare che:

$scope.data = $data.someData; 
$scope.$watch('data', function(newValue) { ... }); 

Answer 3

Credo che sia la pena ricordare che il passaggio di una funzione per $watch è utile quando si vuole monitorare una condizione:

$scope.$watch(function() { 
    return $scope.data.length > 0; 
}, function() { 
    // Do something every time $scope.data.length > 0 changes 
}); 

o

$scope.$watch(function() { 
    return $scope.prop1 && $scope.prop2; 
}, function() { 
    // Do something every time $scope.prop1 && $scope.prop2 changes 
}); 

Answer 4

Dato che la risposta pratica è già stata data, cercherò di spiegarti cosa succede realmente e perché non ha funzionato nel modo in cui hai provato la prima volta.

Prima di tutto questo codice funziona sicuro,

$scope.$watch(function() { 
    return $scope.someData; 
}, function(value) { 
    console.log(value); 
}); 

Ma questo è NON il modo perfetto. Per essere più precisi $watch inietta il scope nella funzione, in questo modo,

$scope.$watch(function(injectedScope) { 
    return injectedScope.someData; 
}, function(value) { 
    console.log(value); 
}); 

precedenza Funziona perché $scope e injectScope sono uno e la stessa cosa.

Ora, come questo article spiega,

Dal $scope è passato attraverso la funzione di orologio, significa che siamo in grado di guardare qualsiasi funzione che si aspetta che il campo di applicazione come argomento e restituisce un valore in risposta. Un ottimo esempio di ciò è la funzione $interpolate .

Quindi nel tuo caso, possiamo anche fare uso di $interpolate come segue:

$scope.$watch($interpolate("{{someData}}"), function(value) { 
    ... 
}); 

Ora, questo è dove veniamo al metodo di breve mano utilizzando solo un'espressione di controllo. $watch può anche accettare un'espressione, che in realtà è interpolata.

Così fornendo $scope.$watch("someData", ...),

someData saranno:

1. interpolati come {{someData}}
2. usando l'ambito iniettato da $watch funzione

Questo è un piacevole, pulito, leggibile , modo di scrivere a mano bassa l'espressione invece della funzione effettiva. Ma alla fine, dopo tutte queste compilazioni, è in definitiva la funzione che restituisce un valore da guardare.