AngularJS-Direktive mit der Methode von außerhalb aufgerufen

Ich fand mein Problem.

Vom der angularJS Dokumentation über Richtlinien, ich war auf der Suche in die transclude option da, die besagt:

Was hat das transclude option tun, genau? transclude macht den Inhalt einer Richtlinie, die mit dieser option haben Sie Zugriff auf den Bereich außerhalb der in der Richtlinie eher als im inneren.

Kombinierte ich transclude=false mit der controller Funktion, da durch die Methode, wieder von docs:

Versierte Leser werden sich vielleicht Fragen, was der Unterschied ist zwischen link und controller. Der grundlegende Unterschied ist, dass der controller kann verfügbar machen, ein API und link-Funktionen interagieren können mit Controllern benötigen.

Jedoch , was ich komplett verpasst, war, dass ich isoliert Umfang innerhalb meines Richtlinie. Von docs:

Was wir sein wollen in der Lage zu tun ist, trennen Sie die Rahmen innerhalb einer Richtlinie vom Anwendungsbereich außen, und ordnen Sie dann den äußeren Umfang, um eine Richtlinie der innere Umfang. Wir können dies tun, indem Sie das, was wir nennen ein Isolat Umfang. Um dies zu tun, können wir eine Richtlinie Anwendungsbereich option:

So, selbst wenn Sie transclude=false und die controller Funktion werden Sie immer noch nicht, setzen Methoden, wenn Sie isoliert Umfang! Lektion gelernt!

Während herauszufinden, was schief ging, habe ich auch eine Geige zum besseren Verständnis: http://jsfiddle.net/qyBEr/1/

html

<div ng-app="directiveScopeExample">

    <div ng-controller="Ctrl1">

        <p>see if we can trigger a method form the controller that exists in the directive.</p>

        <ul>
            <li><a href="#" ng-click="methodInController()">Method in Controller</a></li>
            <li><a href="#" ng-click="methodInDirective()">Method in Directive</a></li>
        </ul>

    <simple-directive/>
    </div>
</div>

javascript

angular.module('directiveScopeExample', [])

  .controller('Ctrl1', function Ctrl1($scope) {

      $scope.methodInController = function(){
          alert('Method in controller triggered');
    };

  })
  .directive('simpleDirective', function(){

      return {
      restrict: 'E',
      transclude: false,

      controller: function($scope){
          $scope.methodInDirective = function(){
              //call a method that is defined on scope but only within the directive, this is exposed beause defined within the link function on the $scope
              $scope.showMessage('Method in directive triggered');
          }
      }
      //this is the issue, creating a new scope prevents the controller to call the methods from the directive
      //, scope: {
      // title: '@'
      //}
      , link: function(scope, element, attrs, tabsCtrl) {
         //view related code here
          scope.showMessage = function(message){
              alert(message);
          }
      },
      //templateUrl: 'some-template-here.html'
     };
  })  

Standardmäßig wird der Anwendungsbereich der Richtlinie ist false Bedeutung der Richtlinie wird die Verwendung des übergeordneten Rahmen statt einen neuen zu erstellen. Und daher kann jede Funktion oder Modell definiert in der Richtlinie zugänglich sein wird, in den übergeordneten Bereich. Check-out diese.

Ich denke dein problem kann gelöst werden, wie folgt:

angular.module('directiveScopeExample', [])

  .controller('Ctrl1', function Ctrl1($scope) {

      $scope.methodInController = function(){
          alert('Method in controller triggered');
    };

  })
  .directive('simpleDirective', function(){

      return {
      restrict: 'E',
      scope: false,
      link: function(scope, element, attrs, tabsCtrl) {
         //view related code here
          scope.showMessage = function(message){
              alert(message);
          }
      },
      //templateUrl: 'some-template-here.html'
     };

Dieser Ansatz könnte sein, ein Problem, in Fall, dass Sie möchten, erstellen Sie wiederverwendbare Richtlinien und Sie sind dabei auch noch Staat/Modelle in Ihrem Anwendungsbereich der Richtlinie. Da bist du aber einfach erstellen Funktionen ohne Nebenwirkungen, und Sie sollten in Ordnung sein.