AngularJS utilise $rootScope comme un magasin de données

pour apaiser toutes les parties, pourquoi ne pas simplement utiliser le $cacheFactory. Cela permet aux services de demande de données d'être apatrides et essentiellement juste un getter et setter. Je vais admettre garder les données sur le $rootScope ou comme une propriété dans le service est commode mais se sent juste mal. Utiliser $cacheFactory est assez facile aussi.

créer D'abord un service de cache:

angular.module('CacheService', ['ng'])
    .factory('CacheService', function($cacheFactory) {
    return $cacheFactory('CacheService');
});

incluez le fichier js dans votre application.JS et puis injectez-le en vous déclaration app:

var MyApp = angular.module('MyApp', ['CacheService']);

injectez-le dans le service, utilisez-le comme ceci:

'use strict'

MyApp.factory('HackerNewsService', function(CacheService) {
    return {
        getNews: function(key) {
            var news = CacheService.get(key);

            if(news) {
                return news;
            }

            return null;
        },
        setNews: function(key, value) {
            CacheService.put(key, value);
        },
        clearNews: function(key) {
            CacheService.put(key, '');
        }
    };
});

Maintenant, tout ce que vous avez à faire est d'injecter votre HackerNewsService dans votre contrôleur et de l'utiliser en appelant les méthodes que nous avons créé. Par exemple:

HackerNewsService.setNews('myArticle', {headline: 'My Article', body: 'This is the body'});
$scope.article = HackerNewsService.getNews('myArticle');

mon expérience est que l'utilisation du $ rootScope pour stocker la partie de mon datamodel qui est commun à tous les ngViews dans mon application, est la manière la plus commode.

<div>{{mymodel.property}}</div>

est pour moi plus lisible et plus court que

<div>{{getPropertyModel()}}</div>

avec le javascript

app.factory('MyModel', function(){
    return {
        getModel: function() { ... },
        setModel: function(m) { ... },
    }
});

app.controller('ctrl', ['$scope', 'MyModel', function($scope, MyModel){
    $scope.getPropertModel = function() {
        return MyModel.getModel().property;
    };
}]);

si on utilise un service ou un répertoire, chaque accès au modèle dans le modèle html devient une fonction, qui est moins lisible qu'un accès une propriété du rootScope. Utiliser $rootScope donne moins de code, et par conséquent moins d'erreurs et moins de tests.

bien sûr, seule la partie commune de tous les ngView est stockée dans $rootScope. Le reste du modèle est stocké dans le $scope local.

Montres sur une fonction sont également plus lents que sur les propriétés de l'objet. Donc, du point de vue de la performance, $rootScope est aussi meilleur.

je suppose que je ne suis pas sûr pourquoi vous avez besoin d'utiliser le rootScope? La durée de vie d'une instance de service est l'ensemble de l'application ainsi, quel que soit le schéma de données / sémantique que vous utilisez pourrait également être caché directement dans le service lui-même et il serait partagé entre les contrôleurs. L'une ou l'autre de ces méthodes ne survivent cependant pas au rafraîchissement comme le ferait un stockage local.

le reste ressemble à une approche de chargement paresseux. Où le service est la seule chose "conscient" de si les données ont été chargées à partir de la télécommande et si elle est déjà mise en cache et mise en cache et renvoie si elle ne l'est pas? Si je comprends bien cette partie, c'est un bon schéma.

modifier: Ici, j'adopte une approche similaire au chargement paresseux, remarquez que le cache est juste dans le service lui-même:

angular.module('HN_Reddit_Mashup.Services', [])
    .factory('HackerNews', function($http) {
        var HackerNewsCache = {};
        return {
            get: function(url) {
                return HackerNewsCache[url] ||
                    (HackerNewsCache[url] = $http.jsonp("http://api.thriftdb.com/api.hnsearch.com/items/_search?q=" + url +     "&callback=JSON_CALLBACK"));
            },                
        };
    })

je suis juste face à la même question, et il me semble que le stockage de l'information globalement disponible "emplacement" est la bonne approche, mais que $rootScope n'est pas l'endroit idéal.

je viens de faire des recherches plus, et au lieu de stocker vos données sur $rootScope, vous pourriez envisager d'utiliser un "service" pour gérer vos données / préoccupations séparées, comme décrit ici (en particulier le dernier exemple de code): http://joelhooks.com/blog/2013/04/24/modeling-data-and-state-in-your-angularjs-application /

puis dans le" service "que vous créez en utilisant cette approche, si vous enregistrez les données en mémoire, cacheFactory, localstorage (comme fait allusion à ici ), et/ou à votre DB (par ex. via AJAX), est ce qui convient aux besoins de votre application. Cela signifie également que des modifications à la façon dont vous stockez vos données peuvent être apportées indépendamment, selon les besoins.