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

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

  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 : fungsi yang Anda tulis akan baru :

  myInjectedService  <----  new myServiceFunction()

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

  myInjectedFactory  <---  myFactoryFunction()

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

Seperti menulis fungsi layanan 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 fungsi pabrik 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 fungsi pabrik 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 akan digunakan? ...

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

var myShinyNewObject = new myInjectedService.myFunction()

yang bisa dibilang kurang diinginkan dari ini:

var myShinyNewObject = new myInjectedFactory();

(Tapi Anda harus waspada tentang penggunaan pola jenis ini di tempat pertama karena objek yang baru di controller Anda menciptakan dependensi sulit dilacak yang sulit untuk dipermainkan untuk pengujian. Lebih baik memiliki layanan mengelola koleksi objek untuk Anda daripada menggunakan dengan new()cerdik.)

Satu hal lagi, mereka semua lajang ...

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.)

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

Inilah perbedaan utamanya:

Jasa

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

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

Penggunaan: Dapat bermanfaat untuk berbagi fungsi utilitas yang berguna untuk dipanggil hanya dengan menambahkan ( )referensi fungsi yang disuntikkan. Bisa juga dijalankan denganinjectedArg.call( this ) atau serupa.

Pabrik

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

Hasil: Saat mendeklarasikan factoryName sebagai argumen injeksi, Anda akan diberikan nilai yang dikembalikan dengan menggunakan referensi fungsi yang diteruskan kemodule.factory .

Penggunaan: Dapat bermanfaat untuk mengembalikan 'kelas' yang kemudian dapat digunakan untuk membuat instance.

Berikut ini adalah contoh menggunakan layanan dan pabrik . Baca lebih lanjut tentang Layanan AngularJS vs Pabrik .

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

TL; DR

1) Saat Anda menggunakan Pabrik, Anda membuat objek, menambahkan properti ke sana, lalu mengembalikan objek yang sama. Ketika Anda melewati pabrik ini ke controller Anda, properti-properti pada objek sekarang akan tersedia di controller 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 membuat instance di belakang layar dengan kata kunci 'baru'. Karena itu, Anda akan menambahkan properti ke 'ini' dan layanan akan mengembalikan 'ini'. Ketika Anda melewati layanan ke controller Anda, properti-properti di 'ini' sekarang akan tersedia pada controller itu 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. Benar-benar tidak lebih dari apa yang dikatakan TL; DR. Anda cukup membuat objek, menambahkan properti ke sana, lalu mengembalikan objek yang sama. Kemudian ketika Anda melewati pabrik ke controller Anda, properti-properti pada objek sekarang akan tersedia di controller melalui pabrik Anda. Contoh yang lebih luas ada di bawah ini.

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

Sekarang properti apa pun yang kita lampirkan ke 'layanan' akan tersedia untuk kita ketika kita melewati 'myFactory' ke controller kita.

Sekarang mari kita tambahkan beberapa variabel 'pribadi' ke fungsi panggilan balik kita. Ini tidak akan dapat diakses langsung dari controller, tetapi kami akhirnya akan menyiapkan beberapa metode pengambil / penyetel pada 'layanan' untuk dapat mengubah variabel 'pribadi' ini ketika 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 kami tidak melampirkan variabel / fungsi itu ke 'layanan'. Kami hanya membuatnya untuk menggunakan atau memodifikasinya nanti.

• baseUrl adalah URL dasar yang dibutuhkan oleh iTunes API
• _artist adalah artis yang ingin kita cari
• _finalUrl adalah URL final dan sepenuhnya dibangun yang akan kami panggil ke iTunes makeUrl adalah fungsi yang akan membuat dan mengembalikan URL ramah iTunes kami.

Sekarang, ketika variabel pembantu dan fungsi dan fungsi kami sudah ada, mari kita tambahkan beberapa properti ke objek 'layanan'. Apa pun yang kita pakai pada 'layanan' kita akan dapat langsung menggunakan pengontrol mana pun yang kita lewati 'myFactory'.

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

Di bawah setArtist menerima artis dan memungkinkan Anda untuk mengatur artis. getArtist mengembalikan artist callItunes panggilan pertama makeUrl () untuk membangun URL yang akan kami gunakan dengan permintaan $ http kami. Kemudian ia membuat objek janji, membuat permintaan $ http dengan url akhir kami, lalu 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 dalam pengontrol apa pun dan kami kemudian 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);
      })
  }
});

Pada controller di atas kami menyuntikkan layanan 'myFactory'. Kami kemudian mengatur properti pada objek $ scope 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 janji, kita dapat menggunakan metode .then () dan hanya menetapkan $ scope.data.artistData setelah janji kita dipenuhi dengan data iTunes. Anda akan melihat pengontrol kami sangat 'tipis'. Semua logika dan data persisten kami terletak di layanan kami, bukan di controller kami.

2) Layanan
Mungkin hal terbesar yang perlu diketahui ketika berhadapan dengan menciptakan Layanan adalah bahwa itu dipakai dengan kata kunci 'baru'. Bagi Anda guru JavaScript ini harus memberi Anda petunjuk besar tentang sifat kode. Bagi Anda yang memiliki latar belakang terbatas dalam JavaScript atau bagi mereka yang tidak terlalu mengenal apa kata kunci 'baru' sebenarnya, mari kita tinjau beberapa dasar-dasar JavaScript yang pada akhirnya akan membantu kita dalam memahami sifat dari suatu Layanan.

Untuk benar-benar melihat perubahan yang terjadi ketika Anda menjalankan fungsi dengan kata kunci 'baru', mari kita membuat fungsi dan memohonnya dengan kata kunci 'baru', lalu mari kita tunjukkan apa yang dilakukan penerjemah ketika melihat kata kunci 'baru'. Hasil akhirnya akan sama.

Pertama mari kita buat konstruktor kita.

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

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

Sekarang mari kita tambahkan metode ke prototipe Person kita sehingga akan tersedia pada setiap instance 'kelas' Person kita.

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

Sekarang, karena kita meletakkan fungsi sayName pada prototipe, setiap instance dari Person akan dapat memanggil fungsi sayName untuk mengingatkan nama instance itu.

Sekarang kita memiliki fungsi konstruktor Person kita dan fungsi sayName kita pada prototipe, mari kita benar-benar membuat instance 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 itu, membuat contoh Person, dan kemudian memanggil fungsi pada prototipe terlihat 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' dalam 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-tama, kita tahu bahwa konstruktor Person kita mengembalikan objek, apakah kita dapat melihatnya dalam kode atau tidak. Kedua, kita tahu bahwa karena fungsi sayName kita terletak pada prototipe dan tidak langsung pada contoh Person, objek yang dikembalikan fungsi Person harus didelegasikan ke prototipe pada pencarian gagal. Dalam istilah yang lebih sederhana, ketika kita memanggil tyler.sayName () interpreter mengatakan “OK, aku akan melihat objek 'tyler' yang baru saja kita buat, cari fungsi sayName, lalu panggil saja. Tunggu sebentar, saya tidak melihatnya di sini - yang saya lihat hanyalah nama dan umur, izinkan saya memeriksa prototipe. Yup, sepertinya ada di prototipe, biar saya sebut saja. ”.

Di bawah ini adalah kode untuk cara Anda berpikir tentang apa yang sebenarnya dilakukan kata kunci 'baru' dalam JavaScript. Ini pada dasarnya adalah contoh kode paragraf di atas. Saya telah menempatkan 'tampilan penerjemah' 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 sebenarnya dilakukan kata kunci 'baru' dalam JavaScript, membuat Layanan di Angular harus lebih mudah dipahami.

Hal terbesar untuk dipahami saat membuat Layanan adalah mengetahui bahwa Layanan dipakai dengan kata kunci 'baru'. Menggabungkan pengetahuan itu dengan contoh-contoh kami di atas, Anda sekarang harus mengakui 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 kami lakukan dengan contoh Pabrik, kita tidak perlu membuat objek lalu mengembalikan objek itu karena, seperti yang disebutkan berkali-kali sebelumnya, kita menggunakan kata kunci 'baru' sehingga penerjemah akan membuat objek itu, minta didelegasikan kepada itu prototipe, lalu kembalikan untuk kita tanpa kita harus melakukan pekerjaan.

Hal pertama yang pertama, mari kita buat fungsi 'pribadi' dan penolong kami. Ini seharusnya terlihat sangat akrab karena kami melakukan hal yang persis sama dengan pabrik kami. Saya tidak akan menjelaskan apa yang dilakukan setiap baris di sini karena saya melakukannya di contoh pabrik, 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 controller 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 sama seperti di pabrik kami, setArtist, getArtist, dan callItunes akan tersedia di mana pun controller kita lewati myService. Inilah pengendali 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, begitu Anda benar-benar memahami apa yang 'baru' lakukan, Layanan hampir identik dengan pabrik di Angular.

Petunjuk ada dalam 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 semantik untuk menerapkan pola desain yang berbeda.

Layanan adalah untuk menerapkan pola layanan

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

Hal ini sangat penting dalam Angular karena model Angular biasanya hanya objek JSON yang ditarik dari server, jadi kami membutuhkan tempat untuk meletakkan logika bisnis kami.

Berikut adalah layanan Github misalnya. Ia tahu cara berbicara dengan Github. Ia tahu tentang url dan metode. Kita bisa menyuntikkannya ke controller, 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 kita dapat menggunakan ini untuk membangun model. Berikut 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 ini:

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, itu dapat mengembalikan semua jenis objek yang Anda suka, termasuk fungsi konstruktor, seperti yang kita lihat di atas.

Pabrik mengembalikan objek; layanan baru

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

• Layanan adalah konstruktor yang baru.
• Pabrik hanya dipanggil dan mengembalikan objek.

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

Untuk menggambarkan hal ini, berikut adalah objek sederhana yang sama dibuat menggunakan layanan dan pabrik:

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

Semua jawaban di sini tampaknya ada di sekitar layanan dan pabrik, dan itu sah karena itulah yang ditanyakan. Tapi itu juga penting 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 kasing khusus memungkinkan Anda melakukan hal yang sama dengan kode lebih sedikit. Masing-masing juga memiliki beberapa batasan tambahan.

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

Untuk rincian langkah demi langkah lengkap dan referensi cepat kapan harus menggunakan masing-masing Anda dapat mengunjungi posting blog tempat saya mendapatkan gambar ini dari:

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

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 yang baru . Fungsi yang dibangun di-cache dan disuntikkan.

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

Penerapan

Pabrik biasanya mengembalikan objek literal karena nilai kembali adalah apa yang disuntikkan ke pengontrol, 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. Sebagai gantinya, mereka melakukan inisialisasi dan mengekspos fungsi. Fungsi juga dapat 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

Dalam hal 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. Keduanya juga lajang - yang berarti contoh yang sama dibagi antara semua tempat di mana layanan / pabrik disuntikkan.

Jadi mana yang harus Anda pilih? Salah satunya - mereka sangat mirip sehingga perbedaannya sepele. Jika Anda memilih salah satu dari yang lain, perhatikan saja cara pembuatannya, sehingga Anda dapat menerapkannya dengan benar.

Saya telah menghabiskan beberapa waktu untuk mencari tahu perbedaannya.

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

Pola pabrik lebih fleksibel karena dapat mengembalikan fungsi dan nilai serta objek.

Tidak ada banyak titik dalam pola layanan IMHO, karena semua yang dilakukannya dapat dengan mudah dilakukan dengan pabrik. Pengecualian mungkin:

• Jika Anda peduli tentang jenis layanan instantiated yang diumumkan karena alasan tertentu - jika Anda menggunakan pola layanan, konstruktor Anda akan menjadi jenis layanan baru.
• Jika Anda sudah memiliki fungsi konstruktor yang Anda gunakan di tempat lain yang juga ingin Anda gunakan sebagai layanan (walaupun mungkin tidak banyak digunakan jika Anda ingin menyuntikkan sesuatu ke dalamnya!).

Bisa dibilang, pola layanan adalah cara yang sedikit lebih baik untuk membuat objek baru dari sudut pandang sintaksis, tetapi juga lebih mahal untuk instantiate. Yang lain telah mengindikasikan bahwa sudut menggunakan "baru" untuk membuat layanan, tetapi ini tidak sepenuhnya benar - tidak dapat melakukan itu karena setiap konstruktor layanan memiliki jumlah parameter yang berbeda. Apa yang sebenarnya dilakukan angular adalah menggunakan pola pabrik secara internal untuk membungkus fungsi konstruktor Anda. Kemudian ia melakukan beberapa pokery jiggery yang pandai untuk mensimulasikan operator "baru" javascript, memanggil konstruktor Anda dengan sejumlah variabel argumen yang dapat diinjeksi - tetapi Anda dapat meninggalkan langkah ini jika Anda hanya menggunakan pola pabrik secara langsung, sehingga sangat sedikit meningkatkan efisiensi Anda kode.