Pertanyaan angular.service vs angular.factory


Saya telah melihat keduanya angular.factory () dan angular.service () digunakan untuk menyatakan layanan; Namun, saya tidak dapat menemukan  angular.service di mana saja dalam dokumentasi resmi.

Apa perbedaan antara kedua metode ini? Yang harus digunakan untuk apa (dengan asumsi mereka melakukan hal yang berbeda)?


1036
2018-01-14 18:36


asal


Jawaban:


  angular.service('myService', myServiceFunction);
  angular.factory('myFactory', myFactoryFunction);

Saya mengalami kesulitan membungkus kepala saya di sekitar konsep ini sampai saya menempatkannya pada diri saya seperti ini:

Layanan: the fungsi Anda akan menulis baru-ed:

  myInjectedService  <----  new myServiceFunction()

Pabrik: the fungsi (konstruktor) yang akan Anda tulis dipanggil:

  myInjectedFactory  <---  myFactoryFunction()

Apa yang Anda lakukan dengan itu terserah Anda, tetapi ada beberapa pola yang berguna ...

Seperti menulis a layanan berfungsi untuk mengekspos API publik:

function myServiceFunction() {
  this.awesomeApi = function(optional) {
    // calculate some stuff
    return awesomeListOfValues;
  }
}
---------------------------------------------------------------------------------
// Injected in your controller
$scope.awesome = myInjectedService.awesomeApi();

Atau menggunakan pabrik berfungsi untuk mengekspos API publik:

function myFactoryFunction() {
  var aPrivateVariable = "yay";

  function hello() {
    return "hello mars " + aPrivateVariable;
  }

  // expose a public API
  return {
    hello: hello
  };
}
---------------------------------------------------------------------------------
// Injected in your controller
$scope.hello = myInjectedFactory.hello();

Atau menggunakan pabrik berfungsi untuk mengembalikan konstruktor:

function myFactoryFunction() {
    return function() {
        var a = 2;
        this.a2 = function() {
            return a*2;
        };
    };
}
---------------------------------------------------------------------------------
// Injected in your controller
var myShinyNewObject = new myInjectedFactory();
$scope.four = myShinyNewObject.a2();

Yang mana yang digunakan? ...

Anda dapat mencapai hal yang sama dengan keduanya. Namun, dalam beberapa kasus itu pabrik memberi Anda sedikit lebih banyak fleksibilitas untuk membuat suntikan dengan sintaks yang lebih sederhana. Itu karena saat myInjectedService harus selalu menjadi objek, myInjectedFactory bisa menjadi objek, referensi fungsi, atau nilai apa pun. Misalnya, jika Anda menulis layanan untuk membuat konstruktor (seperti pada contoh terakhir di atas), itu harus dipakai seperti:

var myShinyNewObject = new myInjectedService.myFunction()

yang bisa dibilang kurang diminati daripada ini:

var myShinyNewObject = new myInjectedFactory();

(Tapi Anda harus waspada tentang penggunaan jenis pola ini di tempat pertama karena baruobjek -ing di pengontrol Anda menciptakan dependensi sulit-untuk-melacak yang sulit untuk mengejek untuk pengujian. Lebih baik memiliki layanan mengelola kumpulan objek untuk Anda daripada digunakan new() susah payah.)


Satu lagi, mereka semua Singletons ...

Juga perlu diingat bahwa dalam kedua kasus, sudut membantu Anda mengelola tunggal. Terlepas dari di mana atau berapa kali Anda menyuntikkan layanan atau fungsi Anda, Anda akan mendapatkan referensi yang sama ke objek atau fungsi yang sama. (Dengan pengecualian ketika pabrik hanya mengembalikan nilai seperti angka atau string. Dalam hal ini, Anda akan selalu mendapatkan nilai yang sama, tetapi bukan referensi.)


1248
2018-02-20 06:46



Sederhananya ..

// Service
service = (a, b) => {
  a.lastName = b;
  return a;
};

// Factory
factory = (a, b) => Object.assign({}, a, { lastName: b });

const fullName = { firstName: 'john' };

// Service
const lastNameService = (a, b) => {
  a.lastName = b;
  return a;
};
console.log(lastNameService(fullName, 'doe'));

// Factory
const lastNameFactory = (a, b) => 
  Object.assign({}, a, { lastName: b })
console.log(lastNameFactory(fullName, 'doe'));


316
2018-01-08 02:05



Berikut perbedaan utamanya:

Jasa

Sintaksis: module.service( 'serviceName', function );

Hasil: Saat mendeklarasikan serviceName sebagai argumen yang dapat disuntikkan, Anda akan diberikan dengan contoh fungsi diteruskan ke module.service.

Penggunaan: Bisa berguna untuk berbagi fungsi utilitas yang berguna untuk diaktifkan hanya dengan menambahkan ( ) ke referensi fungsi yang disuntikkan. Bisa juga dijalankan injectedArg.call( this ) atau serupa.

Pabrik

Sintaksis: module.factory( 'factoryName', function );

Hasil: Saat mendeklarasikan factoryName sebagai argumen yang dapat disuntikkan, Anda akan diberikan dengan nilai yang dikembalikan dengan menjalankan referensi fungsi diteruskan ke module.factory.

Penggunaan: Bisa berguna untuk mengembalikan a 'kelas' fungsi yang kemudian dapat dibuat baru untuk membuat instance.

Disini adalah contoh menggunakan layanan dan pabrik. Baca lebih lanjut tentang Layanan AngularJS vs. Factory.

Anda juga dapat memeriksa Dokumentasi AngularJS dan pertanyaan serupa tentang stackoverflow bingung tentang layanan vs pabrik.


243
2018-04-09 23:18



TL; DR 

1) Saat Anda menggunakan Pabrik Anda membuat objek, menambahkan properti ke dalamnya, lalu mengembalikan objek yang sama. Ketika Anda mengirimkan pabrik ini ke pengontrol Anda, properti-properti tersebut pada objek sekarang akan tersedia di pengontrol itu melalui pabrik Anda.

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) Saat Anda menggunakan Layanan, Angular instantiates di belakang layar dengan kata kunci 'baru'. Karena itu, Anda akan menambahkan properti ke ‘ini’ dan layanan akan mengembalikan ‘ini’. Saat Anda meneruskan layanan ke pengontrol Anda, properti tersebut pada 'ini' sekarang akan tersedia di pengontrol tersebut melalui layanan Anda.

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

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



Non TL; DR

1) Pabrik 
Pabrik adalah cara paling populer untuk membuat dan mengonfigurasi layanan. Ada benar-benar tidak lebih dari apa yang TL; DR kata. Anda cukup membuat objek, tambahkan properti ke dalamnya, lalu kembalikan objek yang sama. Kemudian ketika Anda memasukkan pabrik ke pengontrol Anda, properti tersebut pada objek sekarang akan tersedia di pengontrol itu melalui pabrik Anda. Contoh yang lebih luas ada di bawah.

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

Sekarang, properti apa pun yang kami lampirkan ke 'layanan' akan tersedia bagi kami ketika kami meneruskan 'myFactory' ke pengontrol kami.

Sekarang mari tambahkan beberapa variabel 'pribadi' ke fungsi panggil balik kami. Ini tidak akan dapat diakses langsung dari pengontrol, tetapi pada akhirnya kami akan menyiapkan beberapa metode pengambil / penyetel pada 'layanan' untuk dapat mengubah variabel 'pribadi' ini saat diperlukan.

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;
});

Di sini Anda akan melihat bahwa kami tidak melampirkan variabel / fungsi tersebut ke ‘layanan’. Kami hanya membuat mereka untuk menggunakan atau memodifikasinya nanti.

  • baseUrl adalah URL dasar yang diperlukan oleh API iTunes
  • _artist adalah artis yang ingin kita cari
  • _finalUrl adalah URL final dan lengkap yang akan kita buat panggilan ke iTunes makeUrl adalah fungsi yang akan membuat dan mengembalikan URL ramah iTunes.

Sekarang setelah variabel dan fungsi pembantu / pribadi kami ada, mari tambahkan beberapa properti ke objek ‘layanan’. Apa pun yang kami berikan pada 'layanan', kami akan dapat langsung digunakan di pengontrol mana pun yang kami lewati ‘myFactory’.

Kami akan membuat metode setArtist dan getArtist yang hanya mengembalikan atau mengatur artis. Kami juga akan membuat metode yang akan memanggil API iTunes dengan URL yang kami buat. Metode ini akan mengembalikan janji yang akan dipenuhi setelah data kembali dari API iTunes. Jika Anda belum memiliki banyak pengalaman menggunakan janji dalam Angular, saya sangat menyarankan untuk melakukan penyelaman mendalam pada mereka.

Di bawah setArtist menerima artis dan memungkinkan Anda untuk mengatur artis. getArtist mengembalikan panggilan artisItunes panggilan pertama makeUrl () untuk membangun URL yang akan kita gunakan dengan permintaan $ http kami. Kemudian ia membuat objek janji, membuat permintaan $ http dengan url final kami, kemudian karena $ http mengembalikan janji, kami dapat memanggil .success atau .error setelah permintaan kami. Kami kemudian menyelesaikan janji kami dengan data iTunes, atau kami menolaknya dengan pesan yang mengatakan 'Ada kesalahan'.

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;
});

Sekarang pabrik kami selesai. Kami sekarang dapat menyuntikkan ‘myFactory’ ke pengontrol apa pun dan kemudian kami akan dapat memanggil metode kami yang kami lampirkan ke objek layanan kami (setArtist, getArtist, dan callItunes).

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);
      })
  }
});

Di pengontrol di atas, kami sedang menyuntikkan di layanan ‘myFactory’. Kami kemudian mengatur properti pada objek lingkup $ kami yang berasal dari data dari ‘myFactory’. Satu-satunya kode rumit di atas adalah jika Anda belum pernah berurusan dengan janji sebelumnya. Karena callItunes mengembalikan sebuah janji, kita dapat menggunakan metode .then () dan hanya mengatur $ scope.data.artistData setelah janji kita dipenuhi dengan data iTunes. Anda akan melihat pengontrol kami sangat 'tipis'. Semua data logika dan persisten kami terletak di layanan kami, bukan di controller kami.

2) Layanan 
Mungkin hal terbesar yang perlu diketahui ketika berhadapan dengan membuat Layanan adalah bahwa itu dibuat dengan kata kunci 'baru'. Bagi Anda guru JavaScript ini seharusnya memberi Anda petunjuk besar tentang sifat kode. Bagi Anda dengan latar belakang terbatas dalam JavaScript atau bagi mereka yang tidak terlalu akrab dengan apa yang kata kunci ‘baru’ sebenarnya, mari kita tinjau beberapa dasar-dasar JavaScript yang pada akhirnya akan membantu kami memahami sifat Layanan.

Untuk benar-benar melihat perubahan yang terjadi ketika Anda menjalankan fungsi dengan kata kunci ‘baru’, mari buat fungsi dan aktifkan dengan kata kunci ‘baru’, lalu mari kita tunjukkan apa yang dilakukan juru bahasa ketika melihat kata kunci ‘baru’. Hasil akhir keduanya akan sama.

Pertama mari buat Pembuatnya.

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

Ini adalah fungsi konstruktor JavaScript yang umum. Sekarang setiap kali kita memanggil fungsi Person menggunakan kata kunci 'baru', 'ini' akan terikat ke objek yang baru dibuat.

Sekarang mari tambahkan metode ke prototipe Person kami sehingga akan tersedia di setiap instance 'kelas' Person kami.

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

Sekarang, karena kami menempatkan fungsi sayName pada prototipe, setiap instance Orang akan dapat memanggil fungsi sayName dalam rangka memperingatkan nama instance itu.

Sekarang setelah kita memiliki fungsi konstruktor Person dan fungsi sayName pada prototipenya, mari kita membuat sebuah instance dari Person kemudian memanggil fungsi sayName.

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

Jadi bersama-sama kode untuk membuat konstruktor Person, menambahkan fungsi ke prototipe, membuat instance Person, dan kemudian memanggil fungsi pada prototipe tampilannya seperti ini.

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'

Sekarang mari kita lihat apa yang sebenarnya terjadi ketika Anda menggunakan kata kunci ‘baru’ di JavaScript. Hal pertama yang harus Anda perhatikan adalah bahwa setelah menggunakan ‘baru’ dalam contoh kami, kami dapat memanggil metode (sayName) di ‘tyler’ seolah-olah itu adalah objek - itu karena itu. Jadi pertama, kita tahu bahwa konstruktor Person kita mengembalikan objek, apakah kita dapat melihat itu dalam kode atau tidak. Kedua, kita tahu bahwa karena fungsi sayName kami terletak pada prototipe dan tidak langsung pada instance Person, objek yang dikembalikan fungsi Person harus mendelegasikan ke prototipe pada pencarian gagal. Dalam istilah yang lebih sederhana, ketika kita memanggil tyler.sayName () penerjemah mengatakan, “Oke, saya akan melihat objek‘ tyler ’yang baru saja kita buat, mencari fungsi sayName, lalu memanggilnya. Tunggu sebentar, saya tidak melihatnya di sini - yang saya lihat hanyalah nama dan usia, biarkan saya memeriksa prototipe. Yup, sepertinya itu ada di prototipe, biarkan saya menyebutnya. ”.

Di bawah ini adalah kode untuk bagaimana Anda dapat berpikir tentang apa yang sebenarnya dilakukan oleh kata kunci 'baru' di JavaScript. Pada dasarnya ini adalah contoh kode dari paragraf di atas. Saya telah menempatkan ‘tampilan juru bahasa’ atau cara penerjemah melihat kode di dalam catatan.

var Person = function(name, age){
  //The line below this creates an obj object 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;
}

Sekarang memiliki pengetahuan tentang apa yang kata kunci 'baru' benar-benar dilakukan di JavaScript, membuat Layanan dalam Sudut harus lebih mudah dipahami.

Hal terbesar yang harus dipahami saat membuat Layanan adalah mengetahui bahwa Layanan dibuat dengan kata kunci 'baru'. Dengan menggabungkan pengetahuan tersebut dengan contoh-contoh kami di atas, Anda sekarang harus menyadari bahwa Anda akan melampirkan properti dan metode Anda langsung ke 'ini' yang kemudian akan dikembalikan dari Layanan itu sendiri. Mari kita lihat ini dalam aksi.

Tidak seperti apa yang awalnya kita lakukan dengan contoh Pabrik, kita tidak perlu membuat objek kemudian mengembalikan objek itu karena, seperti disebutkan berkali-kali sebelumnya, kami menggunakan kata kunci 'baru' sehingga penerjemah akan membuat objek itu, mendelegasikannya ke itu prototipe, lalu kembalikan untuk kita tanpa kita harus melakukan pekerjaan.

Pertama-tama, mari kita ciptakan fungsi 'pribadi' dan pembantu kami. Ini akan terlihat sangat akrab karena kami melakukan hal yang sama persis dengan pabrik kami. Saya tidak akan menjelaskan apa yang dilakukan setiap baris di sini karena saya melakukan itu di pabrik contoh, jika Anda bingung, baca kembali contoh pabrik.

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;
  }
});

Sekarang, kami akan melampirkan semua metode kami yang akan tersedia di pengontrol kami untuk ‘ini’.

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;
  }

});

Sekarang seperti di pabrik kami, setArtist, getArtist, dan callItunes akan tersedia di controller mana pun yang kami lewati myService. Berikut pengontrol myService (yang hampir persis sama dengan pengontrol pabrik kami).

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);
      })
  }
});

Seperti yang saya sebutkan sebelumnya, setelah Anda benar-benar memahami apa yang 'baru', Layanan hampir identik dengan pabrik di Angular.


134
2018-05-14 16:14



Petunjuknya ada di nama

Layanan dan pabrik mirip satu sama lain. Keduanya akan menghasilkan objek tunggal yang dapat disuntikkan ke objek lain, dan sering digunakan secara bergantian.

Mereka dimaksudkan untuk digunakan secara semantis untuk menerapkan pola desain yang berbeda.

Layanan adalah untuk menerapkan pola layanan

Pola layanan adalah pola di mana aplikasi Anda dipecah menjadi unit fungsi yang konsisten secara logis. Contohnya mungkin adalah pengakses API, atau serangkaian logika bisnis.

Ini sangat penting dalam Angular karena model Sudut biasanya hanya objek JSON yang ditarik dari server, jadi kita perlu tempat untuk menempatkan logika bisnis kita.

Berikut ini adalah layanan Github misalnya. Ia tahu bagaimana berbicara dengan Github. Ia tahu tentang url dan metode. Kita bisa menyuntikkannya ke pengontrol, dan itu akan menghasilkan dan mengembalikan janji.

(function() {
  var base = "https://api.github.com";

  angular.module('github', [])
    .service('githubService', function( $http ) {
      this.getEvents: function() {
        var url = [
          base,
          '/events',
          '?callback=JSON_CALLBACK'
        ].join('');
        return $http.jsonp(url);
      }
    });
  )();

Pabrik menerapkan pola pabrik

Pabrik, di sisi lain dimaksudkan untuk menerapkan pola pabrik. Pola pabrik di mana kita menggunakan fungsi pabrik untuk menghasilkan objek. Biasanya kami mungkin menggunakan ini untuk membangun model. Berikut ini adalah pabrik yang mengembalikan konstruktor Penulis:

angular.module('user', [])
  .factory('User', function($resource) {
    var url = 'http://simple-api.herokuapp.com/api/v1/authors/:id'
    return $resource(url);
  })

Kami akan menggunakan ini seperti:

angular.module('app', ['user'])
  .controller('authorController', function($scope, User) {
    $scope.user = new User();
  })

Perhatikan bahwa pabrik juga mengembalikan lajang.

Pabrik dapat mengembalikan konstruktor

Karena pabrik hanya mengembalikan objek, ia dapat mengembalikan jenis objek apa pun yang Anda sukai, termasuk fungsi konstruktor, seperti yang kita lihat di atas.

Pabrik mengembalikan suatu objek; layanan baru

Perbedaan teknis lainnya adalah cara layanan dan pabrik disusun. Fungsi layanan akan baru untuk menghasilkan objek. Fungsi pabrik akan dipanggil dan akan mengembalikan objek.

  • Layanan adalah konstruktor baru.
  • Pabrik hanya disebut dan mengembalikan suatu objek.

Ini berarti bahwa dalam suatu layanan, kami menambahkan "ini" yang, dalam konteks konstruktor, akan menunjuk ke objek yang sedang dibangun.

Untuk mengilustrasikan ini, di sini adalah objek sederhana yang sama yang dibuat menggunakan layanan dan pabrik:

angular.module('app', [])
  .service('helloService', function() {
    this.sayHello = function() {
      return "Hello!";
    }
  })
  .factory('helloFactory', function() {
    return {
      sayHello: function() {
        return "Hello!";
      }
    }
  });

33
2017-12-18 11:48



app.factory ('fn', fn) vs. app.service ('fn', fn)

Konstruksi

Dengan pabrik, Angular akan memanggil fungsi untuk mendapatkan hasilnya. Ini adalah hasil yang di-cache dan disuntikkan.

 //factory
 var obj = fn();
 return obj;

Dengan layanan, Angular akan memanggil fungsi konstruktor dengan memanggil baru. Fungsi yang dibangun di-cache dan disuntikkan.

  //service
  var obj = new fn();
  return obj;

Pelaksanaan

Pabrik biasanya mengembalikan literal objek karena nilai kembalian aku s apa yang disuntikkan ke pengendali, menjalankan blok, arahan, dll

  app.factory('fn', function(){
         var foo = 0;
         var bar = 0;
         function setFoo(val) {
               foo = val;
         }
         function setBar (val){
               bar = val;
         }
         return {
                setFoo: setFoo,
                serBar: setBar
         }
  });

Fungsi layanan biasanya tidak mengembalikan apa pun. Sebaliknya, mereka melakukan inisialisasi dan mengekspos fungsi. Fungsi juga bisa merujuk 'ini' karena dibangun menggunakan 'baru'.

app.service('fn', function () {
         var foo = 0;
         var bar = 0;
         this.setFoo = function (val) {
               foo = val;
         }
         this.setBar = function (val){
               bar = val;
         }
});

Kesimpulan

Ketika datang untuk menggunakan pabrik atau layanan, keduanya sangat mirip. Mereka disuntikkan ke controller, arahan, run block, dll, dan digunakan dalam kode klien dengan cara yang hampir sama. Mereka juga merupakan lajang - yang berarti contoh yang sama dibagikan di antara semua tempat di mana layanan / pabrik disuntikkan.

Jadi mana yang sebaiknya Anda pilih? Entah satu - mereka sangat mirip sehingga perbedaannya sepele. Jika Anda memilih salah satu dari yang lain, cukup sadar bagaimana mereka dibangun, sehingga Anda dapat menerapkannya dengan benar.


23
2018-06-27 00:17



Semua jawaban di sini tampaknya seputar layanan dan pabrik, dan itu berlaku karena itulah yang ditanyakan. Tetapi penting juga untuk diingat bahwa ada beberapa orang lain termasuk provider(), value(), dan constant().

Kunci untuk diingat adalah bahwa masing-masing adalah kasus khusus dari yang lain. Setiap kasus khusus di rantai memungkinkan Anda melakukan hal yang sama dengan kode yang lebih sedikit. Masing-masing juga memiliki beberapa batasan tambahan.

Untuk memutuskan kapan untuk menggunakan yang baru saja Anda lihat yang mana yang memungkinkan Anda melakukan apa yang Anda inginkan dalam kode yang lebih sedikit. Berikut ini gambar yang menggambarkan betapa miripnya mereka:

enter image description here

Untuk perincian langkah demi langkah lengkap dan referensi cepat tentang kapan menggunakan setiap Anda dapat mengunjungi posting blog di mana saya mendapat gambar ini dari:

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


23
2017-12-10 12:55



Saya telah menghabiskan beberapa waktu untuk mencari tahu perbedaannya.

Dan saya pikir fungsi pabrik menggunakan pola modul dan fungsi layanan menggunakan pola konstruktor java script standar.


5
2018-03-10 15:04