164

我正在寻找如何在 AngularJS 中绑定到服务属性的最佳实践。

我已经通过多个示例来了解如何绑定到使用 AngularJS 创建的服务中的属性。

下面我有两个示例说明如何绑定到服务中的属性;他们都工作。第一个示例使用基本绑定,第二个示例使用 $scope.$watch 绑定到服务属性

在绑定到服务中的属性时是否首选这些示例中的任何一个,或者是否有另一个我不知道的选项会被推荐?

这些示例的前提是服务应每 5 秒更新其属性“lastUpdated”和“calls”。更新服务属性后,视图应反映这些更改。这两个例子都成功地工作了;我想知道是否有更好的方法来做到这一点。

基本绑定

可以在此处查看和运行以下代码:http: //plnkr.co/edit/d3c16z

<html>
<body ng-app="ServiceNotification" >

    <div ng-controller="TimerCtrl1" style="border-style:dotted"> 
        TimerCtrl1 <br/>
        Last Updated: {{timerData.lastUpdated}}<br/>
        Last Updated: {{timerData.calls}}<br/>
    </div>

    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.5/angular.js"></script>
    <script type="text/javascript">
        var app = angular.module("ServiceNotification", []);

        function TimerCtrl1($scope, Timer) {
            $scope.timerData = Timer.data;
        };

        app.factory("Timer", function ($timeout) {
            var data = { lastUpdated: new Date(), calls: 0 };

            var updateTimer = function () {
                data.lastUpdated = new Date();
                data.calls += 1;
                console.log("updateTimer: " + data.lastUpdated);

                $timeout(updateTimer, 5000);
            };
            updateTimer();

            return {
                data: data
            };
        });
    </script>
</body>
</html>

我解决绑定到服务属性的另一种方法是在控制器中使用 $scope.$watch。

$scope.$watch

可以在此处查看和运行以下代码:http: //plnkr.co/edit/dSBlC9

<html>
<body ng-app="ServiceNotification">
    <div style="border-style:dotted" ng-controller="TimerCtrl1">
        TimerCtrl1<br/>
        Last Updated: {{lastUpdated}}<br/>
        Last Updated: {{calls}}<br/>
    </div>

    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.5/angular.js"></script>
    <script type="text/javascript">
        var app = angular.module("ServiceNotification", []);

        function TimerCtrl1($scope, Timer) {
            $scope.$watch(function () { return Timer.data.lastUpdated; },
                function (value) {
                    console.log("In $watch - lastUpdated:" + value);
                    $scope.lastUpdated = value;
                }
            );

            $scope.$watch(function () { return Timer.data.calls; },
                function (value) {
                    console.log("In $watch - calls:" + value);
                    $scope.calls = value;
                }
            );
        };

        app.factory("Timer", function ($timeout) {
            var data = { lastUpdated: new Date(), calls: 0 };

            var updateTimer = function () {
                data.lastUpdated = new Date();
                data.calls += 1;
                console.log("updateTimer: " + data.lastUpdated);

                $timeout(updateTimer, 5000);
            };
            updateTimer();

            return {
                data: data
            };
        });
    </script>
</body>
</html>

我知道我可以在服务中使用 $rootscope.$broadcast 并在控制器中使用 $root.$on ,但是在我创建的其他示例中,在第一次广播中使用 $broadcast/$ 不会被控制器,但在控制器中触发了广播的其他调用。如果您知道解决 $rootscope.$broadcast 问题的方法,请提供答案。

但是为了重申我之前提到的内容,我想知道如何绑定到服务属性的最佳实践。


更新

这个问题最初是在 2013 年 4 月提出并回答的。2014 年 5 月,Gil Birman 提供了一个新答案,我将其更改为正确答案。由于 Gil Birman 的回答几乎没有赞成票,我担心阅读这个问题的人会无视他的回答,转而支持更多投票的其他答案。在您决定最佳答案之前,我强烈推荐 Gil Birman 的答案。

4

10 回答 10

100

考虑第二种方法的一些优点和缺点

  • 0 {{lastUpdated}}而不是{{timerData.lastUpdated}},这可能很容易{{timer.lastUpdated}},我可能会认为它更具可读性(但我们不要争论......我给这一点一个中性评级,所以你自己决定)

  • +1控制器充当标记的一种API可能很方便,这样如果数据模型的结构发生某种变化,您可以(理论上)更新控制器的API映射而不接触html部分。

  • -1但是,理论并不总是实践,无论如何,我通常发现自己必须在需要更改时修改标记控制器逻辑。因此,编写 API 的额外努力抵消了它的优势。

  • -1此外,这种方法不是很干燥。

  • -1如果您想将数据绑定到ng-model您的代码变得更不干燥,因为您必须在控制器中重新打包$scope.scalar_values以进行新的 REST 调用。

  • -0.1创建额外的观察者对性能的影响很小。此外,如果将数据属性附加到不需要在特定控制器中观察的模型,它们将为深度观察者创建额外的开销。

  • -1如果多个控制器需要相同的数据模型怎么办?这意味着您有多个 API 可以随着每次模型更改而更新。

$scope.timerData = Timer.data;现在开始听起来很诱人...让我们更深入地研究最后一点...我们在谈论什么样的模型更改?后端(服务器)上的模型?还是仅在前端创建并存在的模型?无论哪种情况,数据映射 API本质上属于前端服务层(角度工厂或服务)。(请注意,您的第一个示例——我的偏好——在服务层中没有这样的 API ,这很好,因为它很简单,不需要它。)

总之,一切都不必解耦。就将标记完全与数据模型分离而言,弊大于利。


控制器,一般不应该乱扔$scope = injectable.data.scalar's. 相反,它们应该撒上$scope = injectable.data's,promise.then(..)'s和$scope.complexClickAction = function() {..}'s

作为实现数据解耦和视图封装的另一种方法,将视图与模型解耦真正有意义的唯一地方是使用指令。但即使在那里,也不要在or函数$watch中标量值。这不会节省时间或使代码更易于维护和阅读。它甚至不会使测试更容易,因为Angular 中的健壮测试通常会测试生成的 DOM。相反,在指令中要求您的数据 API采用对象形式,并倾向于仅使用由.controllerlink$watchng-bind


示例 http://plnkr.co/edit/MVeU1GKRTN4bqA3h9Yio

<body ng-app="ServiceNotification">
    <div style="border-style:dotted" ng-controller="TimerCtrl1">
        TimerCtrl1<br/>
        Bad:<br/>
        Last Updated: {{lastUpdated}}<br/>
        Last Updated: {{calls}}<br/>
        Good:<br/>
        Last Updated: {{data.lastUpdated}}<br/>
        Last Updated: {{data.calls}}<br/>
    </div>

    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.5/angular.js"></script>
    <script type="text/javascript">
        var app = angular.module("ServiceNotification", []);

        function TimerCtrl1($scope, Timer) {
            $scope.data = Timer.data;
            $scope.lastUpdated = Timer.data.lastUpdated;
            $scope.calls = Timer.data.calls;
        };

        app.factory("Timer", function ($timeout) {
            var data = { lastUpdated: new Date(), calls: 0 };

            var updateTimer = function () {
                data.lastUpdated = new Date();
                data.calls += 1;
                console.log("updateTimer: " + data.lastUpdated);

                $timeout(updateTimer, 500);
            };
            updateTimer();

            return {
                data: data
            };
        });
    </script>
</body>

更新:我终于回到这个问题来补充一点,我认为这两种方法都不是“错误的”。最初我写过 Josh David Miller 的回答是不正确的,但回想起来他的观点是完全正确的,尤其是他关于关注点分离的观点。

除了关注点分离(但切线相关)之外,还有另一个我没有考虑到的防御性复制的原因。这个问题主要涉及直接从服务中读取数据。但是,如果您团队中的开发人员决定控制器需要在视图显示之前以某种简单的方式转换数据怎么办?(控制器是否应该转换数据是另一个讨论。)如果她不首先制作对象的副本,她可能会无意中在另一个使用相同数据的视图组件中导致回归。

这个问题真正突出的是典型 Angular 应用程序(实际上是任何 JavaScript 应用程序)的架构缺点:关注点的紧密耦合和对象可变性。我最近迷上了使用 React不可变数据结构构建应用程序。这样做很好地解决了以下两个问题:

  1. 关注点分离:组件通过 props 使用它的所有数据,并且几乎不依赖全局单例(例如 Angular 服务),并且对视图层次结构中它上面发生的事情一无所知。

  2. 可变性:所有道具都是不可变的,这消除了不知情的数据突变的风险。

Angular 2.0 现在有望大量借鉴 React 来实现上述两点。

于 2014-05-21T05:40:29.430 回答
78

从我的角度来看,$watch这将是最佳实践方式。

您实际上可以稍微简化您的示例:

function TimerCtrl1($scope, Timer) {
  $scope.$watch( function () { return Timer.data; }, function (data) {
    $scope.lastUpdated = data.lastUpdated;
    $scope.calls = data.calls;
  }, true);
}

这就是你所需要的。

由于属性是同时更新的,因此您只需要一只手表。此外,由于它们来自一个相当小的对象,我将其更改为仅查看Timer.data属性。传递给它的最后一个参数$watch告诉它检查深度相等,而不仅仅是确保引用相同。


为了提供一点上下文,我更喜欢这种方法而不是将服务值直接放在作用域上的原因是为了确保适当地分离关注点。您的视图不应该需要了解有关您的服务的任何信息即可运行。控制器的工作是将所有东西粘合在一起;它的工作是从您的服务中获取数据并以任何必要的方式处理它们,然后为您的视图提供所需的任何细节。但我不认为它的工作只是将服务传递给视图。否则,控制器甚至在那里做什么?当 AngularJS 开发人员选择不在模板中包含任何“逻辑”(例如if语句)时,他们遵循了相同的推理。

公平地说,这里可能有多种观点,我期待其他答案。

于 2013-04-04T00:22:31.360 回答
21

派对迟到了,但对于未来的 Google 员工 - 不要使用提供的答案。

JavaScript 有一种通过引用传递对象的机制,而它只传递值“数字、字符串等”的浅拷贝。

在上面的例子中,我们为什么不将服务暴露给范围,而不是绑定服务的属性呢?

$scope.hello = HelloService;

这种简单的方法将使 Angular 能够进行双向绑定以及您需要的所有神奇事物。不要用观察者或不需要的标记来破解你的控制器。

如果您担心您的视图会意外覆盖您的服务属性,请使用defineProperty使其可读、可枚举、可配置或定义 getter 和 setter。通过使您的服务更加可靠,您可以获得大量控制权。

最后提示:如果您花时间在控制器上而不是服务上,那么您做错了:(。

在您提供的特定演示代码中,我建议您这样做:

 function TimerCtrl1($scope, Timer) {
   $scope.timer = Timer;
 }
///Inside view
{{ timer.time_updated }}
{{ timer.other_property }}
etc...

编辑:

正如我上面提到的,您可以使用控制服务属性的行为defineProperty

例子:

// Lets expose a property named "propertyWithSetter" on our service
// and hook a setter function that automatically saves new value to db !
Object.defineProperty(self, 'propertyWithSetter', {
  get: function() { return self.data.variable; },
  set: function(newValue) { 
         self.data.variable = newValue; 
         // let's update the database too to reflect changes in data-model !
         self.updateDatabaseWithNewData(data);
       },
  enumerable: true,
  configurable: true
});

现在在我们的控制器中,如果我们这样做

$scope.hello = HelloService;
$scope.hello.propertyWithSetter = 'NEW VALUE';

我们的服务将以propertyWithSetter某种方式更改值并将新值发布到数据库!

或者我们可以采取任何我们想要的方法。

请参阅MDN 文档以获取defineProperty.

于 2016-04-06T03:37:07.153 回答
12

我认为这个问题有一个上下文成分。

如果您只是从服务中提取数据并将该信息辐射到它的视图,我认为直接绑定到服务属性就可以了。我不想编写大量样板代码来简单地将服务属性映射到模型属性以在我的视图中使用。

此外,角度的性能基于两件事。第一个是页面上有多少绑定。第二个是 getter 函数的成本。米斯科在这里谈论这个

如果您需要对服务数据执行特定于实例的逻辑(而不是在服务本身内应用数据按摩),并且其结果会影响暴露给视图的数据模型,那么我会说 $watcher 是合适的,因为只要该功能不是非常昂贵。对于昂贵的函数,我建议将结果缓存在本地(到控制器)变量中,在 $watcher 函数之外执行复杂的操作,然后将范围绑定到结果。

需要注意的是,您不应该将任何属性直接挂在 $scope 上。该$scope变量不是您的模型。它引用了您的模型。

在我看来,简单地将信息从服务辐射到视图的“最佳实践”:

function TimerCtrl1($scope, Timer) {
  $scope.model = {timerData: Timer.data};
};

然后您的视图将包含{{model.timerData.lastupdated}}.

于 2013-05-08T21:52:27.820 回答
6

基于上面的示例,我想我会采用一种透明地将控制器变量绑定到服务变量的方式。

在下面的示例中,对 Controller$scope.count变量的更改将自动反映在 Servicecount变量中。

在生产环境中,我们实际上使用 this 绑定来更新服务上的 id,然后异步获取数据并更新其服务变量。进一步的绑定意味着控制器会在服务自身更新时自动更新。

下面的代码可以在http://jsfiddle.net/xuUHS/163/上看到

看法:

<div ng-controller="ServiceCtrl">
    <p> This is my countService variable : {{count}}</p>
    <input type="number" ng-model="count">
    <p> This is my updated after click variable : {{countS}}</p>

    <button ng-click="clickC()" >Controller ++ </button>
    <button ng-click="chkC()" >Check Controller Count</button>
    </br>

    <button ng-click="clickS()" >Service ++ </button>
    <button ng-click="chkS()" >Check Service Count</button>
</div>

服务/控制器:

var app = angular.module('myApp', []);

app.service('testService', function(){
    var count = 10;

    function incrementCount() {
      count++;
      return count;
    };

    function getCount() { return count; }

    return {
        get count() { return count },
        set count(val) {
            count = val;
        },
        getCount: getCount,
        incrementCount: incrementCount
    }

});

function ServiceCtrl($scope, testService)
{

    Object.defineProperty($scope, 'count', {
        get: function() { return testService.count; },
        set: function(val) { testService.count = val; },
    });

    $scope.clickC = function () {
       $scope.count++;
    };
    $scope.chkC = function () {
        alert($scope.count);
    };

    $scope.clickS = function () {
       ++testService.count;
    };
    $scope.chkS = function () {
        alert(testService.count);
    };

}
于 2015-06-26T09:29:15.490 回答
3

我认为这是绑定服务本身而不是绑定属性的更好方法。

原因如下:

<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.3.7/angular.min.js"></script>
<body ng-app="BindToService">

  <div ng-controller="BindToServiceCtrl as ctrl">
    ArrService.arrOne: <span ng-repeat="v in ArrService.arrOne">{{v}}</span>
    <br />
    ArrService.arrTwo: <span ng-repeat="v in ArrService.arrTwo">{{v}}</span>
    <br />
    <br />
    <!-- This is empty since $scope.arrOne never changes -->
    arrOne: <span ng-repeat="v in arrOne">{{v}}</span>
    <br />
    <!-- This is not empty since $scope.arrTwo === ArrService.arrTwo -->
    <!-- Both of them point the memory space modified by the `push` function below -->
    arrTwo: <span ng-repeat="v in arrTwo">{{v}}</span>
  </div>

  <script type="text/javascript">
    var app = angular.module("BindToService", []);

    app.controller("BindToServiceCtrl", function ($scope, ArrService) {
      $scope.ArrService = ArrService;
      $scope.arrOne = ArrService.arrOne;
      $scope.arrTwo = ArrService.arrTwo;
    });

    app.service("ArrService", function ($interval) {
      var that = this,
          i = 0;
      this.arrOne = [];
      that.arrTwo = [];

      $interval(function () {
        // This will change arrOne (the pointer).
        // However, $scope.arrOne is still same as the original arrOne.
        that.arrOne = that.arrOne.concat([i]);

        // This line changes the memory block pointed by arrTwo.
        // And arrTwo (the pointer) itself never changes.
        that.arrTwo.push(i);
        i += 1;
      }, 1000);

    });
  </script>
</body> 

你可以在这个 plunker上玩它。

于 2014-12-17T07:32:40.167 回答
1

我宁愿让我的观察者尽可能少。我的理由是基于我的经验,人们可能会在理论上争论它。
使用观察者的问题是您可以使用范围内的任何属性来调用您喜欢的任何组件或服务中的任何方法。
在一个真实世界的项目中,很快你就会得到一个不可追踪的(更好的说是难以追踪的)方法链被调用和值被改变,这特别使入职过程变得悲惨。

于 2017-04-12T09:34:23.780 回答
0

绑定任何发送服务的数据不是一个好主意(架构),但如果你需要它,我建议你有两种方法来做到这一点

1)您可以获取不在服务内部的数据。您可以在控制器/指令内部获取数据,并且将其绑定到任何地方都不会有问题

2)您可以使用angularjs事件。无论何时,您都可以发送信号(来自$rootScope)并在任何您想要的地方捕获它。您甚至可以发送关于该事件名称的数据。

也许这可以帮助你。如果您需要更多示例,这里是链接

http://www.w3docs.com/snippets/angularjs/bind-value-between-service-and-controller-directive.html

于 2015-08-11T16:09:31.653 回答
-1

关于什么

scope = _.extend(scope, ParentScope);

ParentScope 在哪里是注入服务?

于 2015-12-23T17:42:08.677 回答
-2

最优雅的解决方案...

app.service('svc', function(){ this.attr = []; return this; });
app.controller('ctrl', function($scope, svc){
    $scope.attr = svc.attr || [];
    $scope.$watch('attr', function(neo, old){ /* if necessary */ });
});
app.run(function($rootScope, svc){
    $rootScope.svc = svc;
    $rootScope.$watch('svc', function(neo, old){ /* change the world */ });
});

此外,我编写 EDA(事件驱动架构),所以我倾向于做类似以下的事情[过度简化的版本]:

var Service = function Service($rootScope) {
    var $scope = $rootScope.$new(this);
    $scope.that = [];
    $scope.$watch('that', thatObserver, true);
    function thatObserver(what) {
        $scope.$broadcast('that:changed', what);
    }
};

然后,我在所需通道上的控制器中放置了一个侦听器,并以这种方式使我的本地范围保持最新。

总之,只要您保持稳定并采用弱耦合,就没有太多的“最佳实践”——相反,它主要是偏好。我提倡后一种代码的原因是因为 EDA 在本质上具有最低的耦合度。如果你不太关心这个事实,让我们避免一起做同一个项目。

希望这可以帮助...

于 2015-02-10T03:09:53.970 回答