Soru AngularJS: Hizmet vs sağlayıcı vs fabrika


Arasındaki farklar nelerdir Service, Provider ve Factory AngularJS içinde?


3167
2018-03-27 17:59


Menşei


Tüm Açısal terimlerin yeni başlayanlar için korkutucu olduğunu buldum. Programcılarımızın Angular'ı öğrenirken anlaması biraz daha kolay olan bu hilelerle başladık. demisx.github.io/angularjs/2014/09/14/.... Umarım bu da ekibinize yardımcı olur. - demisx
Benim düşünceme göre, farkı anlamanın en iyi yolu Angular'ın kendi belgelerini kullanmaktır: docs.angularjs.org/guide/providers Son derece iyi açıklanmış ve bunu anlamanıza yardımcı olacak kendine özgü bir örnek kullanmaktadır. - Rafael Merlin
@Blaise Teşekkürler! Gönderiye yaptığım yorum uyarınca, kasıtlı olarak dışarıda bıraktım, çünkü kullanımımın% 99'unun benim tecrübemden başarıyla geçmesi sağlanabilir. service.factory. Bu konuyu daha da karmaşıklaştırmak istemedim. - demisx
Bu tartışmayı da çok yararlı buluyorum stackoverflow.com/questions/18939709/... - Anand Gupta
İşte bazı iyi cevaplar nasıl olacağı hakkında services, factories ve providers Eserleri. - Mistalis


Cevaplar:


AngularJS posta listemden aldım inanılmaz bir konu Hizmet vs fabrika vs sağlayıcı ve bunların enjeksiyon kullanımını açıklar. Cevapları derlemek:

Hizmetler

Sözdizimi: module.service( 'serviceName', function ); 
Sonuç: serviceName enjekte edilebilir bir argüman olarak ilan edildiğinde Bu işlevin bir örneği ile sağlanacaktır. Diğer bir deyişle  new FunctionYouPassedToService().

Fabrikalar

Sözdizimi: module.factory( 'factoryName', function ); 
Sonuç: factoryName enjekte edilebilir bir argüman olarak ilan edildiğinde size işlev referansı çağrılarak döndürülen değer modülü..

Sağlayıcıları

Sözdizimi: module.provider( 'providerName', function ); 
Sonuç: providerName enjekte edilebilir bir argüman olarak ilan edildiğinde ile sağlanacak  (new ProviderFunction()).$get(). $ Get yöntemi çağrılmadan önce kurucu işlevi başlatılır - ProviderFunction module.provider'a iletilen işlev referansıdır.

Sağlayıcılar, modül yapılandırma aşamasında yapılandırılabilmeleri avantajına sahiptir.

Görmek İşte sağlanan kod için.

İşte Misko'nun daha büyük bir açıklaması:

provide.value('a', 123);

function Controller(a) {
  expect(a).toEqual(123);
}

Bu durumda enjektör, değeri olduğu gibi döndürür. Ama eğer değeri hesaplamak istiyorsan? Sonra bir fabrika kullanın

provide.factory('b', function(a) {
  return a*2;
});

function Controller(b) {
  expect(b).toEqual(246);
}

Yani factory değeri yaratmaktan sorumlu olan bir işlevdir. Fabrika işlevinin diğer bağımlılıkları isteyebileceğine dikkat edin.

Ama daha fazla OO olmak ve Greeter adında bir derse sahip olmak istiyorsan ne olur?

function Greeter(a) {
  this.greet = function() {
    return 'Hello ' + a;
  }
}

O zaman örnek vermek zorundasın.

provide.factory('greeter', function(a) {
  return new Greeter(a);
});

Sonra denetleyicide böyle bir şekilde 'karşılama' isteyebiliriz.

function Controller(greeter) {
  expect(greeter instanceof Greeter).toBe(true);
  expect(greeter.greet()).toEqual('Hello 123');
}

Ama bu çok endişeli. Bunu yazmanın daha kısa bir yolu olurdu provider.service('greeter', Greeter);

Ama eğer yapılandırmak istediysek Greeter enjeksiyondan önce sınıf? Sonra yazabilirdik

provide.provider('greeter2', function() {
  var salutation = 'Hello';
  this.setSalutation = function(s) {
    salutation = s;
  }

  function Greeter(a) {
    this.greet = function() {
      return salutation + ' ' + a;
    }
  }

  this.$get = function(a) {
    return new Greeter(a);
  };
});

Sonra bunu yapabiliriz:

angular.module('abc', []).config(function(greeter2Provider) {
  greeter2Provider.setSalutation('Halo');
});

function Controller(greeter2) {
  expect(greeter2.greet()).toEqual('Halo 123');
}

Yan not olarak, service, factory, ve value hepsi sağlayıcıdan türetilmiştir.

provider.service = function(name, Class) {
  provider.provide(name, function() {
    this.$get = function($injector) {
      return $injector.instantiate(Class);
    };
  });
}

provider.factory = function(name, factory) {
  provider.provide(name, function() {
    this.$get = function($injector) {
      return $injector.invoke(factory);
    };
  });
}

provider.value = function(name, value) {
  provider.factory(name, function() {
    return value;
  });
};

2803
2017-07-30 10:20



Ayrıca bakınız stackoverflow.com/a/13763886/215945 Hizmet ve fabrika arasındaki farkları tartışır. - Mark Rajcok
611 düzenlemesinde açısal sabitlerin ve değerlerin kullanımını ekledim. Diğerleri zaten gösterilen farklılıkları göstermek için. jsbin.com/ohamub/611/edit - Nick
Bir işlev, işlevin bir örneğini oluşturarak çağrılsa da. Aslında, enjektör başına sadece bir kez yaratılır, bu da onu singleton gibi yapar.docs.angularjs.org/guide/dev_guide.services.creating_services - angelokh
Açık bir pratik örnek kullansa, bu örnek inanılmaz olabilir. Ne gibi şeylerin olduğunu anlamaya çalışırken kayboluyorum. toEqual ve greeter.Greetolduğunu. Neden biraz daha gerçek ve bağlanabilir bir şey kullanmıyorsunuz? - Kyle Pennell
Function expect () işlevi bir şeyi açıklamak için zayıf bir seçimdir. Bir dahaki sefere gerçek dünya kodunu kullan. - Craig


JS Fiddle Demo

"Merhaba dünya" örneği ile factory / service / provider:

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

//service style, probably the simplest one
myApp.service('helloWorldFromService', function() {
    this.sayHello = function() {
        return "Hello, World!";
    };
});

//factory style, more involved but more sophisticated
myApp.factory('helloWorldFromFactory', function() {
    return {
        sayHello: function() {
            return "Hello, World!";
        }
    };
});
    
//provider style, full blown, configurable version     
myApp.provider('helloWorld', function() {

    this.name = 'Default';

    this.$get = function() {
        var name = this.name;
        return {
            sayHello: function() {
                return "Hello, " + name + "!";
            }
        }
    };

    this.setName = function(name) {
        this.name = name;
    };
});

//hey, we can configure a provider!            
myApp.config(function(helloWorldProvider){
    helloWorldProvider.setName('World');
});
        

function MyCtrl($scope, helloWorld, helloWorldFromFactory, helloWorldFromService) {
    
    $scope.hellos = [
        helloWorld.sayHello(),
        helloWorldFromFactory.sayHello(),
        helloWorldFromService.sayHello()];
}
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.23/angular.min.js"></script>
<body ng-app="myApp">
<div ng-controller="MyCtrl">
    {{hellos}}
</div>
</body>


797
2018-05-15 15:53



yok mu this bağlamı değiştir $get işlev? - Artık bu işlevdeki örnek sağlayıcıya başvurmuyorsunuz. - Nate-Wilkins
@Nate: this aslında bağlamı değiştirmez, çünkü çağrılan şey new Provider(). $ get (), nerede Provider iletilen işleve app.provider. Bu demek ki $get() Yapılmış bir yöntem olarak çağrılıyor Provider, yani this başvurmak Provider örnek olarak göstermektedir. - Brandon
@Brandon Ohh tamam o zaman düzgün temiz. İlk bakışta kafa karıştırıcı - açıklık için teşekkürler! - Nate-Wilkins
Neden alıyorum Unknown provider: helloWorldProvider <- helloWorld Bu yerel olarak çalışırken? Bunu yorumlamak, diğer 2 örnek için aynı hata. Gizli sağlayıcı yapılandırması var mı? (Açısal 1.0.8) - Bulunan: stackoverflow.com/questions/12339272/... - Antoine
@Antoine neden "Unknown sağlar: helloWorldProvider" hatası alır çünkü .config kodunuzda, 'helloWorldProvider' kullanırsınız, ancak myApp.provider'da sağlayıcıyı tanımladığınızda ('helloWorld', function ()), 'Selam Dünya'? Başka bir deyişle, yapılandırma kodunuzda, açısal merhaba helloWorld sağlayıcısına başvurduğunuzu nasıl anlar? Teşekkürler - jmtoung


TL; DR 

1) Bir Fabrika Bir nesne yaratır, ona özellik ekler, sonra aynı nesneyi döndürürsünüz. Bu fabrikayı denetleyiciye aktardığınızda, nesnenin üzerindeki bu özellikler şimdi o denetleyicide fabrikada kullanılabilir olacaktır.

app.controller(‘myFactoryCtrl’, function($scope, myFactory){
  $scope.artist = myFactory.getArtist();
});

app.factory(‘myFactory’, function(){
  var _artist = ‘Shakira’;
  var service = {};

  service.getArtist = function(){
    return _artist;
  }

  return service;
});


2) Kullanırken HizmetAngularJS, ‘yeni’ anahtar kelimeyle sahnelerini arka planında gösterir. Bu nedenle, "bu" için mülkler eklersiniz ve bu hizmet "bu" değerini döndürür. Hizmeti denetleyicinize aktardığınızda, "bu" üzerindeki özellikler artık bu denetleyicide hizmetinizdeyken kullanılabilir.

app.controller(‘myServiceCtrl’, function($scope, myService){
  $scope.artist = myService.getArtist();
});

app.service(‘myService’, function(){
  var _artist = ‘Nelly’;
  this.getArtist = function(){
    return _artist;
  }
});



3)  Sağlayıcıları .config () işlevinize geçirebileceğiniz tek hizmettir. Hizmet nesnesini kullanmadan önce modülünüzün geniş yapılandırmasını sağlamak istediğinizde bir sağlayıcı kullanın.

app.controller(‘myProvider’, function($scope, myProvider){
  $scope.artist = myProvider.getArtist();
  $scope.data.thingFromConfig = myProvider.thingOnConfig;
});

app.provider(‘myProvider’, function(){
 //Only the next two lines are available in the app.config()
 this._artist = ‘’;
 this.thingFromConfig = ‘’;
  this.$get = function(){
    var that = this;
    return {
      getArtist: function(){
        return that._artist;
      },
      thingOnConfig: that.thingFromConfig
    }
  }
});

app.config(function(myProviderProvider){
  myProviderProvider.thingFromConfig = ‘This was set in config’;
});



TL olmayan; DR

1) Fabrika 
Fabrikalar, bir hizmet oluşturmanın ve yapılandırmanın en popüler yoludur. DR'nin söylediklerinden çok daha fazlası yok. Sadece bir nesne oluşturun, ona özellik ekleyin, sonra aynı nesneyi döndürün. Ardından, fabrikayı denetleyiciye aktardığınızda, nesnenin üzerindeki bu özellikler fabrikada bu denetleyicide kullanılabilir olacaktır. Daha kapsamlı bir örnek aşağıdadır.

app.factory(‘myFactory’, function(){
  var service = {};
  return service;
});

Şimdi "fabrikamıza" eklediğimiz mülkler, "myFactory" i denetçimize aktarırken bize sunulacak.

Şimdi geri arama işlevimize bazı "özel" değişkenler ekleyelim. Bunlar doğrudan kontrolörden erişilemez. Ancak, gerektiğinde bu "özel" değişkenleri değiştirebilmek için "hizmet" konusunda bazı alıcı / ayarlayıcı yöntemler oluşturacağız.

app.factory(‘myFactory’, function($http, $q){
  var service = {};
  var baseUrl = ‘https://itunes.apple.com/search?term=’;
  var _artist = ‘’;
  var _finalUrl = ‘’;

  var makeUrl = function(){
   _artist = _artist.split(‘ ‘).join(‘+’);
    _finalUrl = baseUrl + _artist + ‘&callback=JSON_CALLBACK’;
    return _finalUrl
  }

  return service;
});

Burada, bu değişkenleri / işlevi "hizmete" bağlanmadığımızı göreceksiniz. Daha sonra bunları kullanmak veya değiştirmek için onları basit bir şekilde oluşturuyoruz.

  • baseUrl, iTunes API'nin gerektirdiği temel URL'dir
  • _artist, aramak istediğimiz sanatçıdır
  • _finalUrl, aramayı iTunes'a yapacağımız nihai ve tam olarak oluşturulmuş bir URL'dir.
  • makeUrl, iTunes dostu URL'mizi oluşturacak ve döndürecek bir işlevdir.

Artık yardımcımızın / özel değişkenlerimizin ve işlevimizin yerine getirildiğinden, "hizmet" nesnesine bazı özellikler ekleyelim. “Hizmet” e ne koyduk her ne olursa olsun, “myFactory” cihazını hangi kontrolörden geçirdiğimiz içinde doğrudan kullanılabilir.

Sanatçıya geri dönen veya ayarlayan setArtist ve getArtist yöntemlerini oluşturacağız. Ayrıca, oluşturulmuş URL'imiz ile iTunes API'yi arayacak bir yöntem oluşturacağız. Bu yöntem, veriler iTunes API’ndan geri geldiğinde yerine getirecek bir söz verecekti. AngularJS'de vaatler kullanma konusunda fazla deneyime sahip değilseniz, onlara derin bir dalış yapmanızı şiddetle tavsiye ederim.

Altında setArtist bir sanatçıyı kabul eder ve sanatçıyı ayarlamanızı sağlar. getArtist sanatçıyı döndürür. callItunes ilk olarak $ http isteğimizle kullanacağımız URL'yi oluşturmak için makeUrl () öğesini çağırır. Sonra bir söz nesnesi kurar, son url ile bir $ http isteği yapar, o zaman $ http bir söz verir, isteğimizden sonra .success veya .error'u arayabiliriz. Ardından verdiğimiz sözleri iTunes verisi ile çözüyoruz ya da "Hata var" yazan bir mesajla reddediyoruz.

app.factory('myFactory', function($http, $q){
  var service = {};
  var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  var makeUrl = function(){
    _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK'
    return _finalUrl;
  }

  service.setArtist = function(artist){
    _artist = artist;
  }

  service.getArtist = function(){
    return _artist;
  }

  service.callItunes = function(){
    makeUrl();
    var deferred = $q.defer();
    $http({
      method: 'JSONP',
      url: _finalUrl
    }).success(function(data){
      deferred.resolve(data);
    }).error(function(){
      deferred.reject('There was an error')
    })
    return deferred.promise;
  }

  return service;
});

Şimdi fabrikamız tamamlandı. Artık "myFactory" i herhangi bir denetleyiciye enjekte edebiliyoruz ve daha sonra hizmet nesnesine eklediğimiz yöntemlerimizi (setArtist, getArtist ve callItunes) arayabileceğiz.

app.controller('myFactoryCtrl', function($scope, myFactory){
  $scope.data = {};
  $scope.updateArtist = function(){
    myFactory.setArtist($scope.data.artist);
  };

  $scope.submitArtist = function(){
    myFactory.callItunes()
      .then(function(data){
        $scope.data.artistData = data;
      }, function(data){
        alert(data);
      })
  }
});

Yukarıdaki denetleyicide "fabrikamın" hizmetini enjekte ediyoruz. Daha sonra, $ kapsam nesnesindeki özellikleri "myFactory" adresindeki verilerle belirleriz. Yukarıdaki tek zorlu kod, daha önce hiç söz vermediyseniz. CallItunes bir söz verdiğinden, .then () yöntemini kullanabiliriz ve yalnızca verdiğimiz verilere iTunes verisi ile ulaşıldığında $ scope.data.artistData ayarlayabiliriz. Kontrol cihazımızın çok ince olduğunu fark edeceksiniz (Bu iyi bir kodlama uygulamasıdır). Tüm mantığımız ve kalıcı verilerimiz, bizim kontrol birimimizde değil, hizmetimizde bulunmaktadır.

2) Hizmet 
Bir Hizmet oluştururken bilmeniz gereken en büyük şey, belki de ‘yeni’ anahtar kelimeyle özdeşleşmesidir. Sizin için JavaScript uzmanları size bu kodun niteliğine büyük bir ipucu vermelidir. JavaScript'te sınırlı bir arka plana sahip olanlar veya "yeni" anahtar kelimenin gerçekte ne işe yaradığını bilmeyenler için, bir Hizmetin yapısını anlamada bize yardımcı olacak bazı JavaScript temellerini inceleyelim.

Function Yeni ’anahtar kelimeyle bir işlevi çağırdığınızda meydana gelen değişiklikleri gerçekten görmek için, bir işlev oluşturalım ve‘ yeni ’anahtar kelimeyle çağırırız, ardından yorumcunun‘ yeni ’anahtar kelimesini gördüğünde ne yaptığını gösterelim. Sonuçların her ikisi de aynı olacaktır.

Öncelikle Oluşturucumuzu oluşturalım.

var Person = function(name, age){
  this.name = name;
  this.age = age;
}

Bu, tipik bir JavaScript yapıcı işlevidir. Şimdi function yeni ’anahtar sözcüğünü kullanarak Kişi işlevini çağırdığımızda,‘ bu ’yeni oluşturulan nesneye bağlı olacaktır.

Şimdi, Kişinin prototipine bir yöntem ekleyelim. Böylece, "Kişiler sınıfı" nın her bir örneğinde kullanılabilir olacak.

Person.prototype.sayName = function(){
  alert(‘My name is ‘ + this.name);
}

Şimdi, prototip üzerinde sayName işlevini koyduğumuz için, her bir Kişi örneğinde, söz konusu kişinin ismini uyarmak için sayName işlevini çağırabilecektir.

Şimdi bizim şahsi yapıcı fonksiyonumuza ve bizim isimim fonksiyonumuzun prototipine sahip olduğumuza göre, aslında bir Kişi örneğini oluşturalım ve sonra sayName fonksiyonunu çağırın.

var tyler = new Person(‘Tyler’, 23);
tyler.sayName(); //alerts ‘My name is Tyler’

Böylece, bir Kişi kurucusu oluşturma, prototipine bir işlev ekleyerek, bir Kişi örneği oluşturup daha sonra prototipinde işlevi çağırmak için kullanılan kod buna benziyor.

var Person = function(name, age){
  this.name = name;
  this.age = age;
}
Person.prototype.sayName = function(){
  alert(‘My name is ‘ + this.name);
}
var tyler = new Person(‘Tyler’, 23);
tyler.sayName(); //alerts ‘My name is Tyler’

Şimdi JavaScript’te ‘yeni’ anahtar kelimesini kullandığınızda gerçekte neler olduğuna bakalım. Dikkat etmeniz gereken ilk şey, örneğimizde "yeni" ifadesini kullandıktan sonra, tıpkı bir nesne gibi, "tyler" üzerinde bir yöntem (adıAdı) çağırabileceğimizdir. Öncelikle, Kurucumuzun bir nesneyi döndürdüğünü biliyoruz, ister kodda olsun ya da olmasın. İkincisi, bizim adıAdı işlevimizin doğrudan örnek örneğinde değil, prototip üzerinde yer almasından dolayı, Kişi işlevinin geri döndüğü nesnenin, hatalı aramalarda prototipine delege edilmesi gerektiğini biliyoruz. Daha basit terimlerle, tyler.sayName () dediğimizde yorumlayıcı “Tamam, yeni oluşturduğumuz 'tyler' nesnesine bakacağım, sayName işlevini bulup sonra arayacağım. Bekle bir dakika, burada görmüyorum - tek gördüğüm isim ve yaş, prototipi kontrol edeyim. Evet, prototipte olduğu gibi, aramama izin ver. ”

Aşağıda, ‘yeni’ anahtar kelimenin aslında JavaScript’te ne yaptığını düşünebileceğiniz bir kod bulunmaktadır. Temel olarak yukarıdaki paragrafın bir kod örneği. “Tercüman bakışını” veya tercümanın kodu kod içinde görmesini sağladım.

var Person = function(name, age){
  //The below line creates an object(obj) that will delegate to the person’s prototype on failed lookups.
  //var obj = Object.create(Person.prototype);

  //The line directly below this sets ‘this’ to the newly created object
  //this = obj;

  this.name = name;
  this.age = age;

  //return this;
}

Şimdi ‘yeni’ anahtar kelimesinin JavaScript’te gerçekten ne yaptığıyla ilgili bu bilgiye sahip olmak, AngularJS’de bir Hizmet oluşturmak daha kolay anlaşılmalıdır.

Hizmet oluştururken anlaşılması gereken en büyük şey, Hizmetlerin ‘yeni’ anahtar kelimeyle özdeşleştiğini bilmektir. Bu bilgileri yukarıdaki örneklerle birleştirerek, şimdi mülklerinizi ve yöntemlerinizi doğrudan "bu" ya ekleyeceğinizi ve bunun da Hizmet’in kendisinden iade edileceğini kabul etmelisiniz. Buna bir bakalım.

Başlangıçta Fabrika örneğiyle yaptığımızdan farklı olarak, bir nesne oluşturmaya gerek yok, o zaman bu nesneyi döndürmemize gerek yok, çünkü daha önce bahsettiğimiz gibi, 'yeni' anahtar kelimesini kullandık, böylece yorumlayıcı bu nesneyi oluşturacak, prototip, sonra işi yapmak zorunda kalmadan bizim için geri ver.

Öncelikle ilk önce, "özel" ve yardımcı işlevlerimizi oluşturalım. Fabrikamızla aynı şeyi yaptığımızdan bu çok tanıdık gelmeli. Her bir hattın burada ne yaptığını açıklamamıştım çünkü bunu fabrika örneğinde yaptım, kafanız karıştıysa, fabrika örneğini tekrar okuyun.

app.service('myService', function($http, $q){
  var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  var makeUrl = function(){
    _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK'
    return _finalUrl;
  }
});

Şimdi, denetleyicimizde kullanıma sunulacak tüm yöntemlerimizi "bunu" olarak ekleyeceğiz.

app.service('myService', function($http, $q){
  var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  var makeUrl = function(){
    _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK'
    return _finalUrl;
  }

  this.setArtist = function(artist){
    _artist = artist;
  }

  this.getArtist = function(){
    return _artist;
  }

  this.callItunes = function(){
    makeUrl();
    var deferred = $q.defer();
    $http({
      method: 'JSONP',
      url: _finalUrl
    }).success(function(data){
      deferred.resolve(data);
    }).error(function(){
      deferred.reject('There was an error')
    })
    return deferred.promise;
  }

});

Şimdi bizim fabrikamızda olduğu gibi setArtist, getArtist ve callItunes, kontrolörümüzü hangi hizmet biriminden geçtiğimizde mevcut olacak. İşte benimService denetleyici (neredeyse bizim fabrika denetleyicimizle aynıdır).

app.controller('myServiceCtrl', function($scope, myService){
  $scope.data = {};
  $scope.updateArtist = function(){
    myService.setArtist($scope.data.artist);
  };

  $scope.submitArtist = function(){
    myService.callItunes()
      .then(function(data){
        $scope.data.artistData = data;
      }, function(data){
        alert(data);
      })
  }
});

Daha önce de bahsettiğim gibi, “yeni” nin ne olduğunu gerçekten anladığınızda, Hizmetler AngularJS'deki fabrikalarla neredeyse aynıdır.

3) Sağlayıcı

Sağlayıcılar hakkında hatırlamanız gereken en önemli şey, uygulamanızın app.config bölümüne aktarabileceğiniz tek hizmet olmalarıdır. Bu, hizmet nesnesinin bir kısmını uygulamanızın her yerinde kullanıma sunulmadan önce değiştirmeniz gerektiğinde çok önemlidir. Hizmetler / Fabrikalara çok benzese de, tartışacağımız birkaç farklılık var.

İlk olarak, Tedarikçimizi Servis ve Fabrika ile yaptığımız gibi kurduk. Aşağıdaki değişkenler bizim 'özel' ve yardımcı işlevimizdir.

app.provider('myProvider', function(){
   var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  //Going to set this property on the config function below.
  this.thingFromConfig = ‘’;

  var makeUrl = function(){
    _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK'
    return _finalUrl;
  }
}

* Yine yukarıdaki kodun herhangi bir kısmı kafa karıştırıcı ise, tüm detayların ne olduğunu açıkladığım Fabrika bölümüne bakın.

Sağlayıcıları üç bölüm halinde düşünebilirsiniz. İlk bölüm, daha sonra değiştirilecek / ayarlanacak (yukarıda gösterilen) "özel" değişkenler / işlevlerdir. İkinci bölüm, app.config fonksiyonunuzda kullanılabilecek değişkenler / fonksiyonlardır ve bu nedenle başka herhangi bir yerde (yukarıda da gösterilmiştir) sunulmadan önce değiştirilebilir. Bu değişkenlerin "bu" anahtar kelimesine eklenmesi gerektiğini unutmayın. Örneğimizde, app.config dosyasında değişiklik yapmak için yalnızca ‘thingFromConfig’ mevcut olacaktır. Üçüncü bölüm (aşağıda gösterilmiştir), "myProvider" hizmetini bu belirli denetleyiciye ilettiğinizde, denetleyicinizde kullanılabilen tüm değişkenler / işlevlerdir.

Sağlayıcı ile bir hizmet oluştururken, denetleyicinizde bulunabilecek tek özellikler / yöntemler $ get () işlevinden döndürülen özellikler / yöntemlerdir. Aşağıdaki kod, "bu" (bu işlevin sonunda geri getirileceğini bildiğimiz) 'a atıyor. Şimdi, bu $ get fonksiyonu, denetleyicide bulunmasını istediğimiz tüm yöntemleri / özellikleri döndürür. İşte bir kod örneği.

this.$get = function($http, $q){
    return {
      callItunes: function(){
        makeUrl();
        var deferred = $q.defer();
        $http({
          method: 'JSONP',
          url: _finalUrl
        }).success(function(data){
          deferred.resolve(data);
        }).error(function(){
          deferred.reject('There was an error')
        })
        return deferred.promise;
      },
      setArtist: function(artist){
        _artist = artist;
      },
      getArtist: function(){
        return _artist;
      },
      thingOnConfig: this.thingFromConfig
    }
  }

Şimdi tam Sağlayıcı kodu böyle görünüyor

app.provider('myProvider', function(){
  var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  //Going to set this property on the config function below
  this.thingFromConfig = '';

  var makeUrl = function(){
    _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK'
    return _finalUrl;
  }

  this.$get = function($http, $q){
    return {
      callItunes: function(){
        makeUrl();
        var deferred = $q.defer();
        $http({
          method: 'JSONP',
          url: _finalUrl
        }).success(function(data){
          deferred.resolve(data);
        }).error(function(){
          deferred.reject('There was an error')
        })
        return deferred.promise;
      },
      setArtist: function(artist){
        _artist = artist;
      },
      getArtist: function(){
        return _artist;
      },
      thingOnConfig: this.thingFromConfig
    }
  }
});

Artık fabrikamızda ve Servisimizde olduğu gibi setArtist, getArtist ve callItunes, myProvider'ı hangi kontrolöre geçirdiğimizde mevcut olacak. İşte myProvider denetleyici (neredeyse bizim fabrika / Servis denetleyicimizle aynıdır).

app.controller('myProviderCtrl', function($scope, myProvider){
  $scope.data = {};
  $scope.updateArtist = function(){
    myProvider.setArtist($scope.data.artist);
  };

  $scope.submitArtist = function(){
    myProvider.callItunes()
      .then(function(data){
        $scope.data.artistData = data;
      }, function(data){
        alert(data);
      })
  }

  $scope.data.thingFromConfig = myProvider.thingOnConfig;
});

Daha önce de belirtildiği gibi, Sağlayıcı ile bir hizmet oluşturma noktasının tamamı, son nesne uygulamanın geri kalanına geçmeden önce app.config işlevi aracılığıyla bazı değişkenleri değiştirebilmektir. Bunun bir örneğini görelim.

app.config(function(myProviderProvider){
  //Providers are the only service you can pass into app.config
  myProviderProvider.thingFromConfig = 'This sentence was set in app.config. Providers are the only service that can be passed into config. Check out the code to see how it works';
});

Artık ‘thingFromConfig’ öğesinin sağlayıcımızda boş bir dize olduğunu görebiliriz, ancak DOM’da bu durum ortaya çıktığında it Bu cümle kuruldu… ’olacaktır.


619
2017-12-24 13:15



Bu mükemmel yazmada eksik olan tek parça, servisin bir fabrikada kullanılmasının göreceli avantajlarıdır; Lior tarafından kabul edilen cevapta açıkça açıklanmıştır - infinity
FWIW (belki çok fazla), burada Angular ile ilgili bir blogger ve sağlayıcıProvider sevmez codeofrob.com/entries/you-have-ruined-javascript.html - barlop
'Javascript gurus' punchline sinsi oldu. : D Bence bu cevap şeyleri çok temizliyor. Süper yazılı. - amarmishra
TLDR'niz bir TLDR'ye ihtiyaç duyar. - JensB
@JensB tl; dr - Reaksiyonu Öğrenin. - Tyler McGinnis


Tüm hizmetler singletonların; Uygulama başına bir kez örneklenir. Onlar yapabilir her türlüİster ilkel, ister nesnel, işlev, isterse de özel bir türün örneği olsun.

value, factory, service, constant, ve provider yöntemler tüm sağlayıcılar. Enjektöre Hizmetleri nasıl sunacağını öğretir.

En ayrıntılı, ama aynı zamanda en kapsamlı olanı bir sağlayıcıdır   yemek tarifi. kalan dört Tarif çeşitleri - Değer, Fabrika, Servis ve   Sabit - Sağlayıcı tarifi üzerine sadece sözdizimsel şeker.

  • Değer Tarifesi Hizmeti kendiniz oluşturduğunuz ve sağladığınız en basit durumdur somutlaşmış değer enjektöre.
  • Fabrika tarifi Enjektöre, hizmetin başlatılması gerektiğinde çağırdığı fabrika işlevini verir. Çağrıldığında, fabrika işlevi Hizmet örneğini oluşturur ve döndürür. Hizmetin bağımlılıkları, işlevlerin argümanları olarak enjekte edilir. Bu tarifi kullanarak aşağıdaki yetenekleri ekler:
    • Diğer hizmetleri kullanma yeteneği (bağımlılıkları var)
    • Servis başlatması
    • Gecikmeli / tembel başlatma
  • Servis tarifi Fabrika tarifi ile neredeyse aynı, ancak burada Enjektör bir inşaatçı Fabrika fonksiyonu yerine yeni operatörle.
  • Sağlayıcı tarifi genellikle overkill. Fabrikanın oluşturulmasını yapılandırmanıza izin vererek bir daha fazla dolaylı katman katıyor.

Sağlayıcı tarifini yalnızca bir API'yi göstermek istediğinizde kullanmalısınız   önce uygulama yapılması gereken uygulama çapında yapılandırma için   uygulama başlar. Bu genellikle sadece yeniden kullanılabilir için ilginç   davranışları arasında biraz değişiklik gösterebilen hizmetler   uygulamalar.


506
2018-02-01 12:58



Yani servis ve fabrika aslında aynı? Diğerinden birini kullanmak, alternatif sözdiziminden başka bir şey sağlamaz mı? - Matt
@Matt, evet, servis, hizmet olarak ifşa etmek istediğiniz kendi fonksiyonunuza sahip olduğunuz zaman kısa bir yoldur. Dokümanlardan: myApp.factory ('unicornLauncher', ["apiToken", işlev (apiToken) {return yeni UnicornLauncher (apiToken);}]); vs: myApp.service ('unicornLauncher', ["apiToken", UnicornLauncher]); - janek
@joshperry Bir acemi olarak, bir süredir servis ve fabrika arasındaki farkı araştırdım. Şimdiye kadar ki en iyi cevap bu katılıyorum! Hizmeti, bazı özel özelliklere sahip olabilecek bir hizmet sınıfı (örneğin kodlayıcı / kod çözücü sınıfı) olarak anlayabilirim. Ve fabrika bir grup vatansız yardımcısı metodu sağlıyor. - stanleyxu2005
Yukarıdaki diğer cevaplarda yer alan örneklere göre, bu tariflerin ne zaman uygulamaya konulduğu gibi enjekte edilen çekirdek farklılıkları ve hizmet sağlayıcıları çok net bir şekilde açıklayamamaktadır. - Ashish Singh


AngularJS Fabrikası, Servis ve Tedarikçisini Anlamak

Tüm bunlar yeniden kullanılabilir tekil nesneleri paylaşmak için kullanılır. Uygulamanıza / çeşitli bileşenlere / modüllere yeniden kullanılabilir kodun paylaşılmasına yardımcı olur.

Dokümanlar'dan Servis / Fabrika:

  • Tembel olarak ortaya çıktı - Açısal, yalnızca bir uygulama bileşenine bağlı olduğunda bir servisi / fabrikayı başlatır.
  • singletons - Her bileşen   bir hizmete bağlı olarak, tek örnek için bir başvuru alır   Servis fabrikası tarafından üretilmiştir.

Fabrika

Bir fabrika, bir nesne oluşturmadan önce mantığı işleyebileceğiniz / ekleyebileceğiniz bir işlevdir, sonra yeni oluşturulan nesne döndürülür.

app.factory('MyFactory', function() {
    var serviceObj = {};
    //creating an object with methods/functions or variables
    serviceObj.myFunction = function() {
        //TO DO:
    };
    //return that object
    return serviceObj;
});

kullanım

Bir sınıf gibi sadece fonksiyonların bir koleksiyonu olabilir. Bu nedenle, kontrol ünitenizin / fabrika / yönerge fonksiyonlarınızın içine enjekte edildiğinde farklı kontrol cihazlarında başlatılabilir. Uygulama başına yalnızca bir kez başlatılır.

Hizmet

Sadece servislere bakarken dizi prototipini düşünün. Bir hizmet, 'yeni' anahtar sözcüğünü kullanarak yeni bir nesneyi gösteren bir işlevdir. Bir hizmet nesnesini kullanarak özellikleri ve işlevleri ekleyebilirsiniz. thisAnahtar kelime. Bir fabrikanın aksine, hiçbir şey döndürmez (yöntem / özellik içeren bir nesne döndürür).

app.service('MyService', function() {
    //directly binding events to this context
    this.myServiceFunction = function() {
        //TO DO:
    };
});

kullanım

Uygulama boyunca tek bir nesneyi paylaşmanız gerektiğinde kullanın. Örneğin, kimliği doğrulanmış kullanıcı ayrıntıları, paylaşılabilir yöntemler / veriler, Yardımcı işlevler vb.

sağlayan

Yapılandırılabilir bir hizmet nesnesi oluşturmak için bir sağlayıcı kullanılır. Servis ayarını yapılandırma fonksiyonundan yapılandırabilirsiniz. Kullanarak bir değer döndürür $get() işlevi. $get Fonksiyon, çalışma fazında açısal olarak yürütülür.

app.provider('configurableService', function() {
    var name = '';
    //this method can be be available at configuration time inside app.config.
    this.setName = function(newName) {
        name = newName;
    };
    this.$get = function() {
        var getName = function() {
             return name;
        };
        return {
            getName: getName //exposed object to where it gets injected.
        };
    };
});

kullanım

Hizmet nesnesini, kullanıma sunmadan önce, modül tabanlı bir yapılandırma sağlamanız gerektiğinde, örn. API URL'nizi Ortamınıza göre ayarlamak istediğinizi varsayalım. dev, stage veya prod

NOT 

Açısal konfigürasyon aşamasında sadece sağlayıcı mevcut olacaktır.   Servis ve fabrika değildir.

Umarım bu senin anlayışını temizledi. Fabrika, Servis ve Sağlayıcı.


221
2017-11-14 06:25



Belirli bir arabirim ile bir hizmet almak istedim, ancak iki farklı uygulama var ve her biri bir denetleyiciye enjekte edip ui yönlendiriciyi kullanarak farklı durumlara bağlanırsam ne yapmalıyım? Örneğin. uzaktan aramaları tek bir durumda yapın, ancak başka bir yerde yerel depoya yazın. Sağlayıcı dokümanları kullanmak only when you want to expose an API for application-wide configuration that must be made before the application starts. This is usually interesting only for reusable services whose behavior might need to vary slightly between applicationsYani, mümkün değil, değil mi? - qix


Benim için, vahiy, hepsinin de aynı şekilde çalıştığını fark ettiğimde ortaya çıktı: bir şey çalıştırarak bir Zamanlar, aldıkları değeri saklamak ve sonra öksürük aynı depolanmış değer aracılığıyla başvuruda bulunulduğunda bağımlılık enjeksiyonu.

Var ki:

app.factory('a', fn);
app.service('b', fn);
app.provider('c', fn);

Üçü arasındaki fark şu:

  1. akayıtlı değer çalışıyor fn.
  2. bKayıtlı değeri newing fn.
  3. cSaklanan değer ilk önce bir örnek almaktan kaynaklanır newing fnve ardından bir $get örneğinin yöntemi.

AngularJS içinde bir önbellek nesnesi gibi bir şey olduğu anlamına gelir, bu da her bir enjeksiyonun değeri ilk kez enjekte edildiğinde ve bir kez verildiğinde:

cache.a = fn()
cache.b = new fn()
cache.c = (new fn()).$get()

Bu yüzden kullanıyoruz this hizmetlerde ve tanımla this.$get sağlayıcılarda.


190
2017-07-22 11:39



Bu cevabı en çok beğendim. Hepsinin anlamı, DI aracılığıyla ihtiyaç duyulduğunda bir nesneye erişim sağlamaktır. Normalde iyi yapıyorsun factorys. Tek neden servicevar, CoffeeScript, TypeScript, ES6 vb. dillerdir, böylece sınıf sözdizimlerini kullanabilirsiniz. İhtiyacın var providerSadece modülünüz farklı ayarlarla çeşitli uygulamalarda kullanılıyorsa app.config(). Hizmetiniz saf bir tek kişilikse veya bir şeylerin örneklerini oluşturabiliyorsa, yalnızca uygulamanıza bağlıdır. - Andreas Linnert


Hizmet vs sağlayıcı vs fabrika:

Basit tutmaya çalışıyorum. Her şey temel JavaScript konseptiyle ilgili.

Öncelikle, konuşalım Hizmetler AngularJS içinde!

Servis nedir: AngularJS'de Hizmet bazı yararlı yöntemleri veya özellikleri depolayabilen tek bir javascript nesnesinden başka bir şey değildir. Bu tekil nesne ngApp (Açısal uygulama) bazında oluşturulur ve mevcut uygulama içindeki tüm kontrolörler arasında paylaşılır. Angularjs bir hizmet nesnesini başlattığında, bu hizmet nesnesini benzersiz bir hizmet adıyla kaydettirir. Bu nedenle, hizmet örneğine ihtiyaç duyduğumuz her an, Angular bu hizmet adının kayıt defterini arar ve başvuru nesnesine başvuruyu döndürür. Hizmet nesnesinde yöntem, erişim özellikleri vb. Denetleyicilerin kapsam nesnesine özellik ve yöntemleri de koyabileceğinizi sorgulayabilirsiniz! Peki neden servis nesnesine ihtiyacınız var? Cevaplar: Servisler çoklu kontrolör kapsamı arasında paylaşılır. Bir denetleyicinin kapsam nesnesine bazı özellikler / yöntemler koyarsanız, yalnızca geçerli kapsam için kullanılabilir olacaktır. Ancak, hizmet nesnesindeki yöntemleri, özellikleri tanımladığınızda, genel olarak kullanılabilir olacak ve bu hizmetin enjekte edilmesi yoluyla herhangi bir denetleyicinin kapsamına erişilebilecektir.

Yani üç denetleyici kapsamı varsa, bunun controllerA, controllerB ve controllerC olmasına izin verin, hepsi aynı hizmet örneğini paylaşır.

<div ng-controller='controllerA'>
    <!-- controllerA scope -->
</div>
<div ng-controller='controllerB'>
    <!-- controllerB scope -->
</div>
<div ng-controller='controllerC'>
    <!-- controllerC scope -->
</div>

Servis nasıl oluşturulur?

AngularJS, bir servisi kaydetmek için farklı yöntemler sunar. Burada üç yöntem fabrikasına (..), hizmete (..), sağlayıcınıza (..);

Kod referansı için bu bağlantıyı kullan

Fabrika fonksiyonu:

Aşağıdaki gibi bir fabrika işlevi tanımlayabiliriz.

factory('serviceName',function fnFactory(){ return serviceInstance;})

AngularJS sağlar 'fabrika (' serviceName ', fnFactory)' İki parametre, serviceName ve bir JavaScript işlevi alan yöntem. Köşeli, işlevi çağırmak suretiyle servis örneği oluşturur fnFactory () aşağıda olduğu gibi.

var serviceInstace = fnFactory();

Geçirilen işlev bir nesneyi tanımlayabilir ve bu nesneyi döndürebilir. AngularJS bu nesne başvurusunu basitçe ilk argüman olarak iletilen bir değişkene kaydeder. FnFactory'den iade edilen herhangi bir şey, serviceInstance'a bağlı olacaktır. Nesneyi döndürmek yerine, işlevi, değerleri vb. Döndürebiliriz, geri dönüp dönmeyeceğimiz, hizmet örneğinde kullanılabilir.

Örnek:

var app= angular.module('myApp', []);
//creating service using factory method
app.factory('factoryPattern',function(){
  var data={
    'firstName':'Tom',
    'lastName':' Cruise',
    greet: function(){
      console.log('hello!' + this.firstName + this.lastName);
    }
  };

  //Now all the properties and methods of data object will be available in our service object
  return data;
});

Servis Fonksiyonu:

service('serviceName',function fnServiceConstructor(){})

Başka bir yol, bir servis kaydı yapabiliriz. Tek fark, AngularJS'nin hizmet nesnesini başlatmaya çalıştığı yoldur. Bu sefer açısal 'yeni' anahtar kelimesini kullanır ve aşağıdaki gibi bir yapıcı işlevini çağırır.

var serviceInstance = new fnServiceConstructor();

Kurucu işlevinde, hizmet nesnesine özellikler / yöntemler eklemek için 'this' anahtar sözcüğünü kullanabiliriz. örnek:

//Creating a service using the service method
var app= angular.module('myApp', []);
app.service('servicePattern',function(){
  this.firstName ='James';
  this.lastName =' Bond';
  this.greet = function(){
    console.log('My Name is '+ this.firstName + this.lastName);
  };
});

Sağlayıcı fonksiyonu:

Sağlayıcı () işlevi, hizmet oluşturmanın başka bir yoludur. Kullanıcıya sadece tebrik mesajı gösteren bir hizmet oluşturmayı düşünelim. Ancak, kullanıcının kendi tebrik mesajını ayarlayabileceği bir işlevsellik sağlamak istiyoruz. Teknik açıdan yapılandırılabilir hizmetler oluşturmak istiyoruz. Bunu nasıl yapabiliriz? Uygulamanın, özel tebrik mesajlarını iletebilmesi için bir yol olmalı ve Angularjs, hizmetlerimizi oluşturan fabrika / yapıcı işlevini kullanılabilir hale getirecektir. Böyle bir durumda provider () işlevi işi yapar. provider () işlevini kullanarak yapılandırılabilir hizmetler oluşturabiliriz.

Aşağıda verilen sağlayıcı sözdizimini kullanarak yapılandırılabilir hizmetler oluşturabiliriz.

/*step1:define a service */
app.provider('service',function serviceProviderConstructor(){});

/*step2:configure the service */
app.config(function configureService(serviceProvider){});

Sağlayıcı sözdizimi dahili olarak nasıl çalışır?

1.Provider nesnesi, sağlayıcı işlevimizde tanımladığımız yapıcı işlevi kullanılarak oluşturulur.

var serviceProvider = new serviceProviderConstructor();

2. app.config () 'da geçirdiğimiz işlev, yürütülür. Buna yapılandırma aşaması denir ve burada hizmetimizi özelleştirmek için bir şansımız var.

configureService(serviceProvider);

3.Final servis örneği, serviceProvider'ın $ get yöntemini arayarak yaratılır.

serviceInstance = serviceProvider.$get()

Sözdizimi kullanarak hizmet oluşturmak için örnek kod:

var app= angular.module('myApp', []);
app.provider('providerPattern',function providerConstructor(){
  //this function works as constructor function for provider
  this.firstName = 'Arnold ';
  this.lastName = ' Schwarzenegger' ;
  this.greetMessage = ' Welcome, This is default Greeting Message' ;
  //adding some method which we can call in app.config() function
  this.setGreetMsg = function(msg){
    if(msg){
      this.greetMessage =  msg ;
    }
  };

  //We can also add a method which can change firstName and lastName
  this.$get = function(){
    var firstName = this.firstName;
    var lastName = this.lastName ;
    var greetMessage = this.greetMessage;
    var data={
       greet: function(){
         console.log('hello, ' + firstName + lastName+'! '+ greetMessage);
       }
    };
    return data ;
  };
});

app.config(
  function(providerPatternProvider){
    providerPatternProvider.setGreetMsg(' How do you do ?');
  }
);

Çalışma demo

Özet:


Fabrika Servis örneğini döndüren bir fabrika işlevi kullanın. serviceInstance = fnFactory ();

Hizmet Bir kurucu işlevi kullanın ve Açısal, hizmet örneğini oluşturmak için 'yeni' anahtar sözcüğünü kullanarak bu yapıcı işlevini çağırır. serviceInstance = new fnServiceConstructor ();

sağlayan bir providerConstructor işlevini tanımlar, bu providerConstructor işlevi bir fabrika işlevi tanımlar $ olsun . Açısal servis nesnesini oluşturmak için $ get () öğesini çağırır. Sağlayıcı sözdizimi, hizmet nesnesinin örneklenmeden önce yapılandırılmasının ek bir avantajına sahiptir. serviceInstance = $ get ();


133
2017-11-19 13:36





Burada birkaç kişi tarafından işaret edildiği gibi bir fabrika, sağlayıcı, servis ve hatta değer ve sabit aynı şeyin versiyonlarıdır. Daha genel incelemek olabilir provider hepsine. Öyle:

enter image description here

Bu resmin konusu şöyledir:

http://www.simplygoodcode.com/2015/11/the-difference-between-service-provider-and-factory-in-angularjs/


79
2017-08-02 05:37





Fabrika

AngularJS'ye bir fonksiyon verirseniz, fabrika talep edildiğinde AngularJS önbellek ve geri dönüş değerini enjekte edecektir.

Örnek:

app.factory('factory', function() {
    var name = '';
    // Return value **is** the object that will be injected
    return {
        name: name;
    }
})

Kullanımı:

app.controller('ctrl', function($scope, factory) {
     $scope.name = factory.name;
});

Hizmet

AngularJS'e bir işlev verirsin, AngularJS arayacak yeni onu örneklendirmek için. Hizmet istendiğinde, önbelleğe alınacak ve enjekte edilecek AngularJS'nin yarattığı örnek budur. Dan beri yeni hizmeti başlatmak için kullanıldı, anahtar kelime bu geçerli ve örneği ifade eder.

Örnek:

app.service('service', function() {
     var name = '';
     this.setName = function(newName) {
         name = newName;
     }
     this.getName = function() {
         return name;
     }
});

Kullanımı:

app.controller('ctrl', function($scope, service) {
   $scope.name = service.getName();
});

sağlayan

AngularJS bir işlev verirsiniz ve AngularJS $get işlevi. Dan dönüş değeri $get Hizmet talep edildiğinde önbelleğe alınacak ve enjekte edilecek işlev.

Sağlayıcılar sağlayıcıyı yapılandırmanıza izin verir önce AngularJS çağırır $get enjekte etmek için yöntem.

Örnek:

app.provider('provider', function() {
     var name = '';
     this.setName = function(newName) {
          name = newName;
     }
     this.$get = function() {
         return {
            name: name
         }
     }
})

Kullanım (bir kontrolörde enjekte edilebilir)

app.controller('ctrl', function($scope, provider) {
    $scope.name = provider.name;
});

Kullanım (önce sağlayıcıyı yapılandırma $get enjekte edilebilir oluşturmak için denir

app.config(function(providerProvider) {
    providerProvider.setName('John');
});

62
2018-05-19 19:53