I haven't seen any mention of it in other answers, but as of Angular 1.5, one-way bindings for objects are supported ( see the section scope

in the $ compile docs for Angular 1.5.9 ):

<

or <attr

- establish a one-way (one-way) binding between the local scope property and the expression passed through the attribute attr

. The expression is evaluated in the context of the parent scope. If no name is specified attr

, the attribute name is considered to be the same as the local name. You can also make the binding optional by adding ?

: <?

or <?attr

.

For example, with <my-component my-attr="parentModel">

and a definition directive scope: { localModel:'<myAttr' }

, the isolated real estate sphere localModel

will reflect the value parentModel

on the parent area. Any changes in parentModel

will be reflected in localModel

, but changes in localModel

will not be reflected in parentModel

. There are, however, two caveats:

• one-way binding does not copy the value from the parent to the isolation area, it just sets the same value. This means that if your bound value is an object, changes to its properties in the isolated scope will be reflected in the parent scope (since both refer to the same object).
• one way bindings look at the id of the parent value. This means that $watch
  
  the parent value is triggered only when the reference to the value changes. In most cases this should not be a concern, but it can be important to know if you are anchored to a one-way binding to an object, and then replace that object in the isolated area. If you now change a property on an object in your parent scope, the change will not propagate to the isolated scope because the object ID in the parent scope has not changed. Instead, you must assign a new object.

One-way binding is useful if you don't plan to propagate changes to your isolated scope bindings back to the parent. However, this does not make it completely impossible.

The example below uses one-way binding to propagate changes to an object within the scope of a controller in a directive.

Update

As @Suamere pointed out, you can indeed change the properties of a one way bound object; however, if the entire object is changed from the local model, then the link to the parent model will be broken, since the parent and local scope will refer to different objects. This is for two-way binding. The code snippet has been updated to highlight the differences.

angular.module('App', [])

.directive('counter', function() {
  return {
    templateUrl: 'counter.html',
    restrict: 'E',
    scope: {
      obj1: '<objOneWayBinding',
      obj2: '=objTwoWayBinding'
    },
    link: function(scope) {
      scope.increment1 = function() {
        scope.obj1.counter++;
      };
      scope.increment2 = function() {
        scope.obj2.counter++;
      };

      scope.reset1 = function() {
        scope.obj1 = {
          counter: 0,
          id: Math.floor(Math.random()*10000),
          descr: "One-way binding",
          creator: "Directive"
        };
      };

      scope.reset2 = function() {
        scope.obj2 = {
          counter: 0,
          id: Math.floor(Math.random()*10000),
          descr: "Two-way binding",
          creator: "Directive"
        };
      };
    }
  };
})

.controller('MyCtrl', ['$scope', function($scope) {
  $scope.increment = function() {
    $scope.obj1FromController.counter++;
    $scope.obj2FromController.counter++;
  };

  $scope.reset = function() {
    $scope.obj1FromController = {
      counter: 0,
      id: Math.floor(Math.random()*10000),
      descr: "One-way binding",
      creator: "Parent"
    };

    $scope.obj2FromController = {
      counter: 0,
      id: Math.floor(Math.random()*10000),
      descr: "Two-way binding",
      creator: "Parent"
    };
  };

  $scope.reset();
}])

;
      

        
        
        
      

    

<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.5.6/angular.js"></script>

<div ng-app="App">

  <script type="text/ng-template" id="counter.html">
    <h3>In Directive</h3>
    <pre>{{obj1 | json:0}}</pre>

    <button ng-click="increment1()">
      Increment obj1 from directive
    </button>

    <button ng-click="reset1()">
      Replace obj1 from directive (breaks binding)
    </button>

    <pre>{{obj2 | json:0}}</pre>

    <button ng-click="increment2()">
      Increment obj2 from directive
    </button>

    <button ng-click="reset2()">
      Replace obj2 from directive (maintains binding)
    </button>

  </script>

  <div ng-controller="MyCtrl">
    
    <counter obj-one-way-binding="obj1FromController"
             obj-two-way-binding="obj2FromController">
    </counter>
    
    <h3>In Parent</h3>

    <pre>{{obj1FromController | json:0}}</pre>
    <pre>{{obj2FromController | json:0}}</pre>

    <button ng-click="increment()">
      Increment from parent
    </button>
    
    <button ng-click="reset()">
      Replace from parent (maintains binding)
    </button>

  </div>
</div>