Bir AngularJS denetleyicisi diğerini arayabilir mi?


581

Bir kontrolörün diğerini kullanmasını sağlamak mümkün müdür?

Örneğin:

Bu HTML belgesi MessageCtrl, messageCtrl.jsdosyadaki denetleyici tarafından iletilen bir iletiyi yazdırır .

<html xmlns:ng="http://angularjs.org/">
<head>
    <meta charset="utf-8" />
    <title>Inter Controller Communication</title>
</head>
<body>
    <div ng:controller="MessageCtrl">
        <p>{{message}}</p>
    </div>

    <!-- Angular Scripts -->
    <script src="http://code.angularjs.org/angular-0.9.19.js" ng:autobind></script>
    <script src="js/messageCtrl.js" type="text/javascript"></script>
</body>
</html>

Denetleyici dosyası aşağıdaki kodu içerir:

function MessageCtrl()
{
    this.message = function() { 
        return "The current date is: " + new Date().toString(); 
    };
}

Hangi sadece geçerli tarihi yazdırır;

DateCtrlTarihi belirli bir biçimde geri veren başka bir denetleyici ekleseydim, MessageCtrlbunu nasıl yapabilirdim? DI çerçevesi, XmlHttpRequestshizmetlerle ilgileniyor ve hizmetlere erişiyor gibi görünüyor .


4
Bu google grubu iş parçacığı olan groups.google.com/d/topic/angular/m_mn-8gnNt4/discussion , denetleyicilerin birbirleriyle konuşabileceği 5 yolu anlatıyor .
Mark Rajcok

Burada zaten iyi cevaplar var, bu yüzden bahsettiğim belirli kullanım durumu için belki de bir AngularJS filtresinin daha iyi bir çözüm olacağını belirtmek isterim?
Bahsettiğimi

Yanıtlar:


705

Kontrolörler arasında iletişim kurmanın birçok yolu vardır.

En iyisi muhtemelen bir hizmeti paylaşmaktır:

function FirstController(someDataService) 
{
  // use the data service, bind to template...
  // or call methods on someDataService to send a request to server
}

function SecondController(someDataService) 
{
  // has a reference to the same instance of the service
  // so if the service updates state for example, this controller knows about it
}

Başka bir yol, kapsamda bir etkinlik yayınlamaktır:

function FirstController($scope) 
{
  $scope.$on('someEvent', function(event, args) {});
  // another controller or even directive
}

function SecondController($scope) 
{
  $scope.$emit('someEvent', args);
}

Her iki durumda da, herhangi bir direktifle de iletişim kurabilirsiniz.


4
Hia, İlk örnek, web sayfasının yığındaki tüm hizmetlerden haberdar olmasını gerektirir. Hangi kötü bir koku gibi geliyor (?). İkincisinde olduğu gibi, web sayfasının $ scope argümanını sağlaması gerekmez mi?
BanksySan

54
Ne? Neden? Tüm kontrolörlere Angular's DI tarafından enjekte edilir.
Vojta

7
@JoshNoe in 1 / iki denetleyiciniz (veya daha fazlasınız) var ve ikisi de aynı / paylaşılan hizmeti alıyor. Sonra, bazılarından bahsettiğiniz, iletişim kurmanın birden fazla yolu var. Özel kullanım durumunuza göre karar veririm. Paylaşılan mantığı / durumu hizmete koyabilirsiniz ve her iki denetleyici de yalnızca bu hizmete temsilci seçebilir veya hizmeti şablona verebilirsiniz. Tabii ki, hizmet de olayları ateşleyebilir ...
Vojta

137
Bu kadar geç geliyor: Google'dan AngularJS üzerinde çalışan THE Vojta ile tartıştığınızı biliyorsunuz, değil mi? :)
Suman

16
HTML'imde olay yayan denetleyicinin çalışması için dinleme denetleyicisinin alt düğümü olması gerektiği açık değildi.
djangonaut

122

Bu kemanı görün: http://jsfiddle.net/simpulton/XqDxG/

Ayrıca aşağıdaki videoyu izleyin: Denetleyiciler Arasında İletişim Kurma

Html:

<div ng-controller="ControllerZero">
  <input ng-model="message" >
  <button ng-click="handleClick(message);">LOG</button>
</div>

<div ng-controller="ControllerOne">
  <input ng-model="message" >
</div>

<div ng-controller="ControllerTwo">
  <input ng-model="message" >
</div>

javascript:

var myModule = angular.module('myModule', []);
myModule.factory('mySharedService', function($rootScope) {
  var sharedService = {};

  sharedService.message = '';

  sharedService.prepForBroadcast = function(msg) {
    this.message = msg;
    this.broadcastItem();
  };

  sharedService.broadcastItem = function() {
    $rootScope.$broadcast('handleBroadcast');
  };

  return sharedService;
});

function ControllerZero($scope, sharedService) {
  $scope.handleClick = function(msg) {
    sharedService.prepForBroadcast(msg);
  };

  $scope.$on('handleBroadcast', function() {
    $scope.message = sharedService.message;
  });        
}

function ControllerOne($scope, sharedService) {
  $scope.$on('handleBroadcast', function() {
    $scope.message = 'ONE: ' + sharedService.message;
  });        
}

function ControllerTwo($scope, sharedService) {
  $scope.$on('handleBroadcast', function() {
    $scope.message = 'TWO: ' + sharedService.message;
  });
}

ControllerZero.$inject = ['$scope', 'mySharedService'];        

ControllerOne.$inject = ['$scope', 'mySharedService'];

ControllerTwo.$inject = ['$scope', 'mySharedService'];

12
Yukarıdaki keman ve video bir hizmeti paylaşıyor. İşte $ scope kullanan bir keman. $ Emit
Mark Rajcok

1
@adardesign: Direktifler için aynı özlü ve anlamlı örneği okumak isterdim (bu cevap için de teşekkürler!)
sscarduzio

Harika Cevap, myModule.factory yerine myModule.service ('mySharedService', işlev ($ rootScope) {}) kullanıyorum, ancak daha az çalışmıyor!
TacoEater

Mükemmel. Yine de bir sorum var: ControllerZero'ya neden bir işleyici eklediniz? $ scope. $ on ('handleBroadcast', function () {$ scope.message = sharedService.message;});
ZooZ

Sağlanan video gerçekten harika! Başka bir denetleyiciden başka bir denetleyicinin durumunu sormak için ihtiyacım olan şey bu. Ancak, bu "invoke" işlevi kullanılarak çalışmaz. "Tetikleyici" eylemini kullanarak çalışır. Böylece, bir denetleyici bir eylem gerçekleştirirse ve yeni bir duruma sahipse, durumu yayınlamak zorunda kalacaktır ve bu yayını dinlemek ve buna göre yanıt vermek diğer denetleyicilere bağlıdır. Ya da daha iyisi, paylaşılan hizmette eylemi gerçekleştirin, ardından durumu yayınlayın. Lütfen anlayışımın doğru olup olmadığını söyle.
tarekahf

53

Bir denetleyiciyi diğerine çağırmak istiyorsanız dört yöntem vardır

  1. $ rootScope. $ emit () ve $ rootScope. $ broadcast ()
  2. İkinci denetleyici çocuksa, Ana çocuk iletişimini kullanabilirsiniz.
  3. Kullanım Hizmetleri
  4. Hack türü - angular.element () yardımıyla

1. $ rootScope. $ Emit () ve $ rootScope. $ Broadcast ()

Denetleyici ve kapsamı yok edilebilir, ancak $ rootScope uygulama genelinde kalır, bu yüzden $ rootScope alıyoruz, çünkü $ rootScope tüm kapsamların üstüdür.

Ebeveynten çocuğa iletişim kuruyorsanız ve hatta çocuk kardeşleriyle iletişim kurmak istiyorsa, $ broadcast kullanabilirsiniz

Çocuktan ebeveyne iletişim kuruyorsanız, hiçbir kardeş çağrılmazsa $ rootScope kullanabilirsiniz. $ Emit

HTML

<body ng-app="myApp">
    <div ng-controller="ParentCtrl" class="ng-scope">
      // ParentCtrl
      <div ng-controller="Sibling1" class="ng-scope">
        // Sibling first controller
      </div>
      <div ng-controller="Sibling2" class="ng-scope">
        // Sibling Second controller
        <div ng-controller="Child" class="ng-scope">
          // Child controller
        </div>
      </div>
    </div>
</body>

Angularjs Kodu

 var app =  angular.module('myApp',[]);//We will use it throughout the example 
    app.controller('Child', function($rootScope) {
      $rootScope.$emit('childEmit', 'Child calling parent');
      $rootScope.$broadcast('siblingAndParent');
    });

app.controller('Sibling1', function($rootScope) {
  $rootScope.$on('childEmit', function(event, data) {
    console.log(data + ' Inside Sibling one');
  });
  $rootScope.$on('siblingAndParent', function(event, data) {
    console.log('broadcast from child in parent');
  });
});

app.controller('Sibling2', function($rootScope) {
  $rootScope.$on('childEmit', function(event, data) {
    console.log(data + ' Inside Sibling two');
  });
  $rootScope.$on('siblingAndParent', function(event, data) {
    console.log('broadcast from child in parent');
  });
});

app.controller('ParentCtrl', function($rootScope) {
  $rootScope.$on('childEmit', function(event, data) {
    console.log(data + ' Inside parent controller');
  });
  $rootScope.$on('siblingAndParent', function(event, data) {
    console.log('broadcast from child in parent');
  });
});

Yukarıdaki $ emit 'childEmit' kod konsolunda çocuk kardeşleri arayamaz ve $ broadcast'in kardeşlerin ve ebeveynlerin içinde çağrıldığı sadece ebeveyni arayacaktır.Bu, performansın eyleme geçtiği yerdir. bazı kirli denetimleri atladığı için çocuk-ebeveyn iletişimi kullanıyorsanız tercih edilebilir.

2. İkinci denetleyici çocuksa, Çocuk Ebeveyn iletişimini kullanabilirsiniz

En iyi yöntemlerden biri, eğer çocuğun hemen ebeveyn ile iletişim kurmak istediği çocuk ebeveyn iletişimi yapmak istiyorsanız, o zaman herhangi bir tür $ yayın veya $ emit gerekmez, ancak ebeveyn ile çocuk arasında iletişim kurmak istiyorsanız, hizmet veya $ yayın kullan

Örneğin HTML: -

<div ng-controller="ParentCtrl">
 <div ng-controller="ChildCtrl">
 </div>
</div>

angularjs

 app.controller('ParentCtrl', function($scope) {
   $scope.value='Its parent';
      });
  app.controller('ChildCtrl', function($scope) {
   console.log($scope.value);
  });

Çocuk-ebeveyn iletişimini her kullandığınızda, Angularjs çocuğun içinde bir değişken arayacaktır, İçinde mevcut değilse, ebeveyn denetleyicisinin içindeki değerleri görmeyi seçecektir.

3. Hizmetleri Kullanın

AngularJS, hizmet mimarisini kullanarak "Endişelerin Ayrılması" kavramlarını destekler . Hizmetler javascript işlevleridir ve yalnızca belirli görevleri yapmaktan sorumludur.Bu, onları sürdürülebilir ve test edilebilir olan bireysel bir varlık haline getirir.

Angularjs kodu:

app.service('communicate',function(){
  this.communicateValue='Hello';
});

app.controller('ParentCtrl',function(communicate){//Dependency Injection
  console.log(communicate.communicateValue+" Parent World");
});

app.controller('ChildCtrl',function(communicate){//Dependency Injection
  console.log(communicate.communicateValue+" Child World");
});

Hello Child World ve Hello Parent World çıktılarını verecektir. Hizmetlerin açısal belgelerine göre Teklitonlar - Bir hizmete bağımlı her bileşen, hizmet fabrikası tarafından oluşturulan tek örneğe başvuru alır .

4. kesmek türü - açısal.element () yardımıyla

Bu yöntem, scope () öğesini Id / unique class.angular.element () yöntemiyle öğeden alır ve element ve scope (), bir denetleyicinin $ scope değişkenini kullanarak başka bir değişkenin $ scope değişkenini diğerinin içinde iyi bir uygulama değildir.

HTML: -

<div id='parent' ng-controller='ParentCtrl'>{{varParent}}
 <span ng-click='getValueFromChild()'>Click to get ValueFormChild</span>
 <div id='child' ng-controller='childCtrl'>{{varChild}}
   <span ng-click='getValueFromParent()'>Click to get ValueFormParent </span>
 </div>
</div>

Angularjs: -

app.controller('ParentCtrl',function($scope){
 $scope.varParent="Hello Parent";
  $scope.getValueFromChild=function(){
  var childScope=angular.element('#child').scope();
  console.log(childScope.varChild);
  }
});

app.controller('ChildCtrl',function($scope){
 $scope.varChild="Hello Child";
  $scope.getValueFromParent=function(){
  var parentScope=angular.element('#parent').scope();
  console.log(parentScope.varParent);
  }
}); 

Yukarıdaki kod denetleyicileri Html üzerinde kendi değerlerini gösterir ve metne tıkladığınızda buna göre konsolda değerler alırsınız.Ana denetleyicilerin açıklığına tıklarsanız, tarayıcı çocuk ve viceversa değerini konsolize eder.


52

Hizmet verilerini paylaşan iki denetleyicinin tek sayfalık bir örneği:

<!doctype html>
<html ng-app="project">
<head>
    <title>Angular: Service example</title>
    <script src="http://code.angularjs.org/angular-1.0.1.js"></script>
    <script>
var projectModule = angular.module('project',[]);

projectModule.factory('theService', function() {  
    return {
        thing : {
            x : 100
        }
    };
});

function FirstCtrl($scope, theService) {
    $scope.thing = theService.thing;
    $scope.name = "First Controller";
}

function SecondCtrl($scope, theService) {   
    $scope.someThing = theService.thing; 
    $scope.name = "Second Controller!";
}
    </script>
</head>
<body>  
    <div ng-controller="FirstCtrl">
        <h2>{{name}}</h2>
        <input ng-model="thing.x"/>         
    </div>

    <div ng-controller="SecondCtrl">
        <h2>{{name}}</h2>
        <input ng-model="someThing.x"/>             
    </div>
</body>
</html>

Ayrıca burada: https://gist.github.com/3595424


Ve eğer theServicegüncellemeler varsa thing.x, bu değişiklik otomatik olarak <input> 'ların içine yayılır FirstCtrlve SecondCtrl, değil mi? Ve biri thing.xdoğrudan iki girişten herhangi biri aracılığıyla da değiştirilebilir (değil mi?).
KajMagnus

4
Evet. Tüm Açısal hizmetler uygulama tek tonlarıdır, yani Hizmet'in yalnızca bir örneği vardır. Referans: docs.angularjs.org/guide/dev_guide.services.creating_services
exclsr


1
@exclsr Evet! Üzgünüm bunu daha önce özledim
CodyBugstein

3
Şimdiye kadar web'de gördüğüm en iyi örnek. Teşekkür ederim
Sevenearths

33

Denetleyicileri arasında veri paylaşmak veya işlevleri çağırmak için etkinlikler yayınlamak ve yayınlamak istiyorsanız, lütfen şu bağlantıya bakın : ve yanıtı kontrol edin zbynour(en fazla oyla yanıtlayın). Onun cevabından alıntı yapıyorum !!!

FirstCtrl kapsamı secondCtrl kapsamının üst öğesiyse, kodunuz firstCtrl'de $ emit $ broadcast ile değiştirilerek çalışmalıdır:

function firstCtrl($scope){
    $scope.$broadcast('someEvent', [1,2,3]);
}

function secondCtrl($scope){
    $scope.$on('someEvent', function(event, mass) {console.log(mass)});
}

Kapsamlarınız arasında ebeveyn-çocuk ilişkisi yoksa, denetleyiciye $ rootScope enjekte edebilir ve olayı tüm alt kapsamlara (yani secondCtrl) yayınlayabilirsiniz.

function firstCtrl($rootScope){
    $rootScope.$broadcast('someEvent', [1,2,3]);
}

Son olarak, olayı alt denetleyiciden kapsamlara yükseltmek için göndermeniz gerektiğinde $ scope. $ Emit kullanabilirsiniz. FirstCtrl kapsamı secondCtrl kapsamının üstü ise:

function firstCtrl($scope){
    $scope.$on('someEvent', function(event, data) { console.log(data); });
}

function secondCtrl($scope){
    $scope.$emit('someEvent', [1,2,3]);
}

24

İki keman daha: (Hizmet dışı yaklaşım)

1) $scopeEbeveyn- Çocuk kumandası için - Olayları yayınlamak / yayınlamak için ebeveyn kumandasının kullanılması . http://jsfiddle.net/laan_sachin/jnj6y/

2) $rootScopeİlgili olmayan kontrolörlerde kullanma. http://jsfiddle.net/VxafF/


Olaylardaki tüm bu karmaşıklığın nedeni nedir? Neden böyle bir şey yapmıyorsun? jsfiddle.net/jnj6y/32
Dfr

Ne tür bir Ebeveyn Çocuk ilişkisinin doğru olduğuna bağlıdır. Bu bir DOM heirarchy olabilir, bu olayların bir şeyleri ayrıştırmanıza izin vereceği anlamına gelir.
DarkKnight

17

Gerçekte emit ve broadcast kullanmak verimsizdir çünkü olay, karmaşık bir uygulama için kolayca performans düşüşüne dönüşebilen kapsam hiyerarşisini yukarı ve aşağı kabarcıklar.

Bir hizmet kullanmanızı öneririm. Kısa bir süre önce projelerimden birine nasıl uyguladığım - https://gist.github.com/3384419 .

Temel fikir - pub-sub / event bus'ı hizmet olarak kaydedin. Ardından, etkinlik / konulara abone olmanız veya yayınlamanız gereken yere o olay otobüsünü enjekte edin.


5

Ben de bu yolu biliyorum.

angular.element($('#__userProfile')).scope().close();

Ama çok fazla kullanmıyorum, çünkü açısal kodda jQuery seçicileri kullanmaktan hoşlanmıyorum.


en iyi cevap. Çok basit ve kolay ... =)
zVictor

3
@zVictor, bu gerçekten "son çare" bir yaklaşım. Çalışıyor, ancak içeri girmeye zorlamak için kapsamdan çıkıyor. Bu, programlama yoluyla yapmak yerine bir şeyi yapmaya zorlamak için DOM manipülasyonunu kullanıyor. Basit, işe yarıyor, ancak ölçeklenebilir değil.
Brian Noah

2
@BrianNoah, doğru. Bu kodu prototipler veya bazı deneyler için kullanın, ancak üretim kodu için kullanmayın.
Andrey Korchak

1
Bu yapılabilecek en kötü şey. Hizmetlerde DOM manipülasyonu ve doğrudan kapsam erişimi.
Mattia Franchetto

3

Hizmetlere bağımlı olmayan bir yöntem var, $broadcast veya $emit. Her durumda uygun değildir, ancak direktiflere eklenebilecek 2 ilgili kontrolörünüz varsa require, yönerge tanımındaki seçeneği kullanabilirsiniz . Büyük olasılıkla ngModel ve ngForm bu şekilde iletişim kurar. Bunu, iç içe ya da aynı öğedeki yönerge denetleyicileri arasında iletişim kurmak için kullanabilirsiniz.

Ebeveyn / çocuk durumu için kullanım aşağıdaki gibi olacaktır:

<div parent-directive>
  <div inner-directive></div>
</div>

Ve çalışmasını sağlamak için ana noktalar: Ebeveyn yönergesinde, çağrılacak yöntemlerle, onları tanımlamalısınız this(değil$scope ):

controller: function($scope) {
  this.publicMethodOnParentDirective = function() {
    // Do something
  }
}

Child yönergesi tanımında, requireüst denetleyicinin bağlantı işlevine geçirilmesi için seçeneği kullanabilirsiniz (böylece daha sonra üzerindeki işlevleri işlevlerden çağırabilirsiniz.scope alt yönerge .

require: '^parentDirective',
template: '<span ng-click="onClick()">Click on this to call parent directive</span>',
link: function link(scope, iElement, iAttrs, parentController) {
  scope.onClick = function() {
    parentController.publicMethodOnParentDirective();
  }
}

Yukarıda görülebilir http://plnkr.co/edit/poeq460VmQER8Gl9w8Oz?p=preview adresinde

Kardeş bir yönerge benzer şekilde kullanılır, ancak her iki yönerge aynı öğede bulunur:

<div directive1 directive2>
</div>

Şurada bir yöntem oluşturarak kullanılır directive1:

controller: function($scope) {
  this.publicMethod = function() {
    // Do something
  }
}

Ve direktif2'de bu require, siblingController öğesinin link işlevine geçirilmesine neden olan seçenek kullanılarak çağrılabilir :

require: 'directive1',
template: '<span ng-click="onClick()">Click on this to call sibling directive1</span>',
link: function link(scope, iElement, iAttrs, siblingController) {
  scope.onClick = function() {
    siblingController.publicMethod();
  }
}

Bu, http://plnkr.co/edit/MUD2snf9zvadfnDXq85w?p=preview adresinde görülebilir .

Bunun kullanımları?

  • Ebeveyn: Alt öğelerin kendilerini bir ebeveyne "kaydettirmeleri" gereken her durumda. NgModel ve ngForm arasındaki ilişkiye çok benzer. Bunlar modelleri etkileyebilecek belirli davranışlar ekleyebilir. Bir ana öğenin, örneğin yönetmek veya kaydırmaya tepki vermek için belirli çocukların konumlarını yönetmesi gereken tamamen DOM tabanlı bir şey de olabilir.

  • Kardeş: bir direktifin davranışını değiştirmesine izin vermek. ngModel, girişlerde ngModel kullanımına ayrıştırıcılar / doğrulama eklemek için klasik durumdur.


3

Bunun standartların dışında olup olmadığını bilmiyorum ama tüm denetleyicileriniz aynı dosyada varsa, o zaman böyle bir şey yapabilirsiniz:

app = angular.module('dashboardBuzzAdmin', ['ngResource', 'ui.bootstrap']);

var indicatorsCtrl;
var perdiosCtrl;
var finesCtrl;

app.controller('IndicatorsCtrl', ['$scope', '$http', function ($scope, $http) {
  indicatorsCtrl = this;
  this.updateCharts = function () {
    finesCtrl.updateChart();
    periodsCtrl.updateChart();
  };
}]);

app.controller('periodsCtrl', ['$scope', '$http', function ($scope, $http) {
  periodsCtrl = this;
  this.updateChart = function() {...}
}]);

app.controller('FinesCtrl', ['$scope', '$http', function ($scope, $http) {
  finesCtrl = this;
  this.updateChart = function() {...}
}]);

Göstergeleri görebileceğiniz gibi, updateCharts çağrılırken diğer her iki denetleyicinin updateChart işlevlerini çağırıyor.


2

Ana denetleyicinize (MessageCtrl) '$ controller' hizmetini enjekte edebilir ve sonra aşağıdakileri kullanarak çocuk denetleyicisini (DateCtrl) başlatabilir / enjekte edebilirsiniz:
$scope.childController = $controller('childController', { $scope: $scope.$new() });

Artık çocuk denetleyicinizden verilere, bir hizmet olduğu için yöntemlerini çağırarak erişebilirsiniz.
Herhangi bir sorun olursa bana bildirin.


1

Aşağıda publish-subscribeAngular JS'den bağımsız bir yaklaşım yer almaktadır.

Arama Param Kontrolörü

//Note: Multiple entities publish the same event
regionButtonClicked: function () 
{
        EM.fireEvent('onSearchParamSelectedEvent', 'region');
},

plantButtonClicked: function () 
{
        EM.fireEvent('onSearchParamSelectedEvent', 'plant');
},

Arama Seçimleri Denetleyici

//Note: It subscribes for the 'onSearchParamSelectedEvent' published by the Search Param Controller
localSubscribe: function () {
        EM.on('onSearchParamSelectedEvent', this.loadChoicesView, this);

});


loadChoicesView: function (e) {

        //Get the entity name from eData attribute which was set in the event manager
        var entity = $(e.target).attr('eData');

        console.log(entity);

        currentSelectedEntity = entity;
        if (entity == 'region') {
            $('.getvalue').hide();
            this.loadRegionsView();
            this.collapseEntities();
        }
        else if (entity == 'plant') {
            $('.getvalue').hide();
            this.loadPlantsView();
            this.collapseEntities();
        }


});

Organizasyon müdürü

myBase.EventManager = {

    eventArray:new Array(),


    on: function(event, handler, exchangeId) {
        var idArray;
        if (this.eventArray[event] == null) {
            idArray = new Array();
        } else { 
            idArray = this.eventArray[event];
        }
        idArray.push(exchangeId);
        this.eventArray[event] = idArray;

        //Binding using jQuery
        $(exchangeId).bind(event, handler);
    },

    un: function(event, handler, exchangeId) {

        if (this.eventArray[event] != null) {
            var idArray = this.eventArray[event];
            idArray.pop(exchangeId);
            this.eventArray[event] = idArray;

            $(exchangeId).unbind(event, handler);
        }
    },

    fireEvent: function(event, info) {
        var ids = this.eventArray[event];

        for (idindex = 0; idindex < ids.length; idindex++) {
            if (ids[idindex]) {

                //Add attribute eData
                $(ids[idindex]).attr('eData', info);
                $(ids[idindex]).trigger(event);
            }
        }
    }
};

global

var EM = myBase.EventManager;

1

Açısal 1.5'te bu, aşağıdakileri yaparak gerçekleştirilebilir:

(function() {
  'use strict';

  angular
    .module('app')
    .component('parentComponent',{
      bindings: {},
      templateUrl: '/templates/products/product.html',
      controller: 'ProductCtrl as vm'
    });

  angular
    .module('app')
    .controller('ProductCtrl', ProductCtrl);

  function ProductCtrl() {
    var vm = this;
    vm.openAccordion = false;

    // Capture stuff from each of the product forms
    vm.productForms = [{}];

    vm.addNewForm = function() {
      vm.productForms.push({});
    }
  }

}());

Bu ana bileşendir. Bu benim productFormsdizi - not - başka bir nesneyi iten bir işlev yarattık Bu sadece benim örnek, bu işlev gerçekten her şey olabilir.

Şimdi aşağıdakilerden yararlanacak başka bir bileşen oluşturabiliriz require:

(function() {
  'use strict';

  angular
    .module('app')
    .component('childComponent', {
      bindings: {},
      require: {
        parent: '^parentComponent'
      },
      templateUrl: '/templates/products/product-form.html',
      controller: 'ProductFormCtrl as vm'
    });

  angular
    .module('app')
    .controller('ProductFormCtrl', ProductFormCtrl);

  function ProductFormCtrl() {
    var vm = this;

    // Initialization - make use of the parent controllers function
    vm.$onInit = function() {
      vm.addNewForm = vm.parent.addNewForm;
    };  
  }

}());

Burada child bileşeni, addNewFormdaha sonra HTML'ye bağlanabilen ve diğer herhangi bir işlev gibi çağrılabilen ebeveyn bileşeni işlevine bir başvuru oluşturur .

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.